| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtPositioning module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** 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 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.LGPL3 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-3.0.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 (at your option) the GNU General |
| ** Public license version 3 or 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.GPL2 and 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-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| |
| #include <QtPositioningQuick/private/qdeclarativegeoaddress_p.h> |
| #include <QtPositioningQuick/private/qdeclarativegeolocation_p.h> |
| #include <QtPositioning/private/qwebmercator_p.h> |
| #include <QtPositioningQuick/private/qdeclarativeposition_p.h> |
| #include <QtPositioningQuick/private/qdeclarativepositionsource_p.h> |
| #include <QtPositioningQuick/private/qdeclarativepluginparameter_p.h> |
| |
| #include <QtPositioningQuick/private/qquickgeocoordinateanimation_p.h> |
| #include "locationsingleton.h" |
| |
| #include <QtCore/QVariantAnimation> |
| |
| #include <QtQml/qqmlextensionplugin.h> |
| #include <QtQml/private/qqmlvaluetype_p.h> |
| |
| #include <QtPositioning/QGeoRectangle> |
| #include <QtPositioning/QGeoCircle> |
| #include <QtPositioning/QGeoPath> |
| #include <QtPositioning/QGeoLocation> |
| #include <QtPositioning/QGeoPositionInfo> |
| #include <QtPositioning/private/qgeocoordinateobject_p.h> |
| |
| #include <QtCore/QDebug> |
| |
| QT_BEGIN_NAMESPACE |
| |
| /*! |
| \qmlbasictype coordinate |
| \inqmlmodule QtPositioning |
| \ingroup qml-QtPositioning5-basictypes |
| \since 5.2 |
| |
| \brief The coordinate type represents and stores a geographic position. |
| |
| This type is a QML representation of \l QGeoCoordinate and represents a geographic |
| position in the form of \l {latitude}, \l longitude and \l altitude attributes. |
| The \l latitude attribute specifies the number of |
| decimal degrees above and below the equator. A positive latitude indicates the Northern |
| Hemisphere and a negative latitude indicates the Southern Hemisphere. The \l longitude |
| attribute specifies the number of decimal degrees east and west. A positive longitude |
| indicates the Eastern Hemisphere and a negative longitude indicates the Western Hemisphere. |
| The \l altitude attribute specifies the number of meters above sea level. Together, these |
| attributes specify a 3-dimensional position anywhere on or near the Earth's surface. |
| |
| The \l isValid attribute can be used to test if a coordinate is valid. A coordinate is |
| considered valid if it has a valid latitude and longitude. A valid altitude is not required. |
| The latitude must be between -90 and 90 inclusive and the longitude must be between -180 and |
| 180 inclusive. |
| |
| The \c coordinate type is used by many other types in the Qt Location module, for specifying |
| the position of an object on a Map, the current position of a device and many other tasks. |
| They also feature a number of important utility methods that make otherwise complex |
| calculations simple to use, such as \l {atDistanceAndAzimuth}(). |
| |
| \section1 Accuracy |
| |
| The latitude, longitude and altitude attributes stored in the coordinate type are represented |
| as doubles, giving them approximately 16 decimal digits of precision -- enough to specify |
| micrometers. The calculations performed in coordinate's methods such as \l {azimuthTo}() and |
| \l {distanceTo}() also use doubles for all intermediate values, but the inherent inaccuracies in |
| their spherical Earth model dominate the amount of error in their output. |
| |
| \section1 Example Usage |
| |
| Use properties of type \l variant to store a \c {coordinate}. To create a \c coordinate use |
| one of the methods described below. In all cases, specifying the \l altitude attribute is |
| optional. |
| |
| To create a \c coordinate value, use the \l{QtPositioning::coordinate}{QtPositioning.coordinate()} |
| function: |
| |
| \qml |
| import QtPositioning 5.2 |
| |
| Location { coordinate: QtPositioning.coordinate(-27.5, 153.1) } |
| \endqml |
| |
| or as separate \l latitude, \l longitude and \l altitude components: |
| |
| \qml |
| Location { |
| coordinate { |
| latitude: -27.5 |
| longitude: 153.1 |
| } |
| } |
| \endqml |
| |
| When integrating with C++, note that any QGeoCoordinate value passed into QML from C++ is |
| automatically converted into a \c coordinate value, and vice-versa. |
| |
| \section1 Properties |
| |
| \section2 latitude |
| |
| \code |
| real latitude |
| \endcode |
| |
| This property holds the latitude value of the geographical position |
| (decimal degrees). A positive latitude indicates the Northern Hemisphere, |
| and a negative latitude indicates the Southern Hemisphere. |
| If the property has not been set, its default value is NaN. |
| |
| For more details see the \l {QGeoCoordinate::latitude} property |
| |
| \section2 longitude |
| |
| \code |
| real longitude |
| \endcode |
| |
| This property holds the longitude value of the geographical position |
| (decimal degrees). A positive longitude indicates the Eastern Hemisphere, |
| and a negative longitude indicates the Western Hemisphere |
| If the property has not been set, its default value is NaN. |
| |
| For more details see the \l {QGeoCoordinate::longitude} property |
| |
| \section2 altitude |
| |
| \code |
| real altitude |
| \endcode |
| |
| This property holds the altitude value (meters above sea level). |
| If the property has not been set, its default value is NaN. |
| |
| For more details see the \l {QGeoCoordinate::altitude} property |
| |
| \section2 isValid |
| |
| \code |
| bool isValid |
| \endcode |
| |
| This property holds the current validity of the coordinate. Coordinates |
| are considered valid if they have been set with a valid latitude and |
| longitude (altitude is not required). |
| |
| The latitude must be between -90 to 90 inclusive to be considered valid, |
| and the longitude must be between -180 to 180 inclusive to be considered |
| valid. |
| |
| This is a read-only property. |
| |
| \section1 Methods |
| |
| \section2 distanceTo() |
| |
| \code |
| real distanceTo(coordinate other) |
| \endcode |
| |
| Returns the distance (in meters) from this coordinate to the coordinate specified by \a other. |
| Altitude is not used in the calculation. |
| |
| This calculation returns the great-circle distance between the two coordinates, with an |
| assumption that the Earth is spherical for the purpose of this calculation. |
| |
| \section2 azimuthTo() |
| |
| \code |
| real azimuth(coordinate other) |
| \endcode |
| |
| Returns the azimuth (or bearing) in degrees from this coordinate to the coordinate specified by |
| \a other. Altitude is not used in the calculation. |
| |
| There is an assumption that the Earth is spherical for the purpose of this calculation. |
| |
| \section2 atDistanceAndAzimuth() |
| |
| \code |
| coordinate atDistanceAndAzimuth(real distance, real azimuth) |
| \endcode |
| |
| Returns the coordinate that is reached by traveling \a distance metres from this coordinate at |
| \a azimuth degrees along a great-circle. |
| |
| There is an assumption that the Earth is spherical for the purpose of this calculation. |
| */ |
| |
| /*! |
| \qmlbasictype geoshape |
| \inqmlmodule QtPositioning |
| \ingroup qml-QtPositioning5-basictypes |
| \since 5.2 |
| |
| \brief A geoshape type represents an abstract geographic area. |
| |
| This type is a QML representation of \l QGeoShape which is an abstract geographic area. |
| It includes attributes and methods common to all geographic areas. To create objects |
| that represent a valid geographic area use \l {georectangle} or \l {geocircle}. |
| |
| The \l isValid attribute can be used to test if the geoshape represents a valid geographic |
| area. |
| |
| The \l isEmpty attribute can be used to test if the geoshape represents a region with a |
| geometrical area of 0. |
| |
| The \l {contains}() method can be used to test if a \l {coordinate} is |
| within the geoshape. |
| |
| \section1 Example Usage |
| |
| Use properties of type \l variant to store a \c {geoshape}. To create a \c geoshape use one |
| of the methods described below. |
| |
| To create a \c geoshape value, specify it as a "shape()" string: |
| |
| \qml |
| import QtPositioning |
| |
| Item { |
| property variant region: "shape()" |
| } |
| \endqml |
| |
| or with the \l {QtPositioning::shape}{QtPositioning.shape()} function: |
| |
| \qml |
| import QtPositioning 5.2 |
| |
| Item { |
| property variant region: QtPositioning.shape() |
| } |
| \endqml |
| |
| When integrating with C++, note that any QGeoShape value passed into QML from C++ is |
| automatically converted into a \c geoshape value, and vice-versa. |
| |
| \section1 Properties |
| |
| \section2 isEmpty |
| |
| \code |
| bool isEmpty |
| \endcode |
| |
| Returns whether this geoshape is empty. An empty geoshape is a region which has |
| a geometrical area of 0. |
| |
| \section2 isValid |
| |
| \code |
| bool isValid |
| \endcode |
| |
| Returns whether this geoshape is valid. |
| |
| A geoshape is considered to be invalid if some of the data that is required to |
| unambiguously describe the geoshape has not been set or has been set to an |
| unsuitable value. |
| |
| \section2 type |
| |
| \code |
| ShapeType type |
| \endcode |
| |
| Returns the current type of the shape. |
| |
| \list |
| \li \c GeoShape.UnknownType - The shape's type is not known. |
| \li \c GeoShape.RectangleType - The shape is a \l georectangle. |
| \li \c GeoShape.CircleType - The shape is a \l geocircle. |
| \li \c GeoShape.PathType - The shape is a \l geopath. (Since Qt 5.9) |
| \li \c GeoShape.PolygonType - The shape is a \l geopolygon. (Since Qt 5.10) |
| \endlist |
| |
| This QML property was introduced by Qt 5.5. |
| |
| \section1 Methods |
| |
| \section2 contains() |
| |
| \code |
| bool contains(coordinate coord) |
| \endcode |
| |
| Returns true if the \l {QtPositioning::coordinate}{coordinate} specified by \a coord is within |
| this geoshape; Otherwise returns false. |
| */ |
| |
| /*! |
| \qmlbasictype georectangle |
| \inqmlmodule QtPositioning |
| \ingroup qml-QtPositioning5-basictypes |
| \since 5.2 |
| |
| \brief The georectangle type represents a rectangular geographic area. |
| |
| The \c georectangle type is a \l {geoshape} that represents a |
| rectangular geographic area. The type is direct representation of a \l QGeoRectangle. |
| It is defined by a pair of \l {coordinate}{coordinates} which represent the top-left |
| and bottom-right corners of the \c {georectangle}. The coordinates are accessible |
| from the \l topLeft and \l bottomRight attributes. |
| |
| A \c georectangle is considered invalid if the top-left or bottom-right coordinates are invalid |
| or if the top-left coordinate is south of the bottom-right coordinate. |
| |
| The coordinates of the four corners of the \c georectangle can be accessed with the |
| \l {topLeft}, \l {topRight}, \l {bottomLeft} and \l {bottomRight} attributes. The \l center |
| attribute can be used to get the coordinate of the center of the \c georectangle. The \l width |
| and \l height attributes can be used to get the width and height of the \c georectangle in |
| degrees. Setting one of these attributes will cause the other attributes to be adjusted |
| accordingly. |
| |
| \section1 Limitations |
| |
| A \c georectangle can never cross the poles. |
| |
| If the height or center of a \c georectangle is adjusted such that it would cross one of the |
| poles the height is modified such that the \c georectangle touches but does not cross the pole |
| and that the center coordinate is still in the center of the \c georectangle. |
| |
| \section1 Example Usage |
| |
| Use properties of type \l variant to store a \c {georectangle}. To create a \c georectangle |
| value, use the \l {QtPositioning::rectangle}{QtPositioning.rectangle()} function: |
| |
| \qml |
| import QtPositioning 5.2 |
| |
| Item { |
| property variant region: QtPositioning.rectangle(QtPositioning.coordinate(-27.5, 153.1), QtPositioning.coordinate(-27.6, 153.2)) |
| } |
| \endqml |
| |
| When integrating with C++, note that any QGeoRectangle value passed into QML from C++ is |
| automatically converted into a \c georectangle value, and vice-versa. |
| |
| \section1 Properties |
| |
| \section2 bottomLeft |
| |
| \code |
| coordinate bottomLeft |
| \endcode |
| |
| This property holds the bottom left coordinate of this georectangle. |
| |
| \section2 bottomRight |
| |
| \code |
| coordinate bottomRight |
| \endcode |
| |
| This property holds the bottom right coordinate of this georectangle. |
| |
| \section2 center |
| |
| \code |
| coordinate center |
| \endcode |
| |
| This property holds the center coordinate of this georectangle. For more details |
| see \l {QGeoRectangle::setCenter()}. |
| |
| \section2 height |
| |
| \code |
| double height |
| \endcode |
| |
| This property holds the height of this georectangle (in degrees). For more details |
| see \l {QGeoRectangle::setHeight()}. |
| |
| \note If the georectangle is invalid, it is not possible to set the height. QtPositioning |
| releases prior to Qt 5.5 permitted the setting of the height even on invalid georectangles. |
| |
| \section2 topLeft |
| |
| \code |
| coordinate topLeft |
| \endcode |
| |
| This property holds the top left coordinate of this georectangle. |
| |
| \section2 topRight |
| |
| \code |
| coordinate topRight |
| \endcode |
| |
| This property holds the top right coordinate of this georectangle. |
| |
| \section2 width |
| |
| \code |
| double width |
| \endcode |
| |
| This property holds the width of this georectangle (in degrees). For more details |
| see \l {QGeoRectangle::setWidth()}. |
| |
| \note If the georectangle is invalid, it is not possible to set the width. QtPositioning |
| releases prior to Qt 5.5 permitted the setting of the width even on invalid georectangles. |
| */ |
| |
| /*! |
| \qmlbasictype geocircle |
| \inqmlmodule QtPositioning |
| \ingroup qml-QtPositioning5-basictypes |
| \since 5.2 |
| |
| \brief The geocircle type represents a circular geographic area. |
| |
| The \c geocircle type is a \l {geoshape} that represents a circular |
| geographic area. It is a direct representation of a \l QGeoCircle and is defined |
| in terms of a \l {coordinate} which specifies the \l center of the circle and |
| a qreal which specifies the \l radius of the circle in meters. |
| |
| The circle is considered invalid if the \l center coordinate is invalid or if |
| the \l radius is less than zero. |
| |
| \section1 Example Usage |
| |
| Use properties of type \l variant to store a \c {geocircle}. To create a \c geocircle value, |
| use the \l {QtPositioning::circle}{QtPositioning.circle()} function: |
| |
| \qml |
| import QtPositioning 5.2 |
| |
| Item { |
| property variant region: QtPositioning.circle(QtPositioning.coordinate(-27.5, 153.1), 1000) |
| } |
| \endqml |
| |
| When integrating with C++, note that any QGeoCircle value passed into QML from C++ is |
| automatically converted into a \c geocircle value, and vise-versa. |
| |
| \section1 Properties |
| |
| \section2 center |
| |
| \code |
| coordinate radius |
| \endcode |
| |
| This property holds the coordinate of the center of the geocircle. |
| |
| \section2 radius |
| |
| \code |
| real radius |
| \endcode |
| |
| This property holds the radius of the geocircle in meters. |
| |
| The default value for the radius is -1 indicating an invalid geocircle area. |
| */ |
| |
| /*! |
| \qmlbasictype geopath |
| \inqmlmodule QtPositioning |
| \ingroup qml-QtPositioning5-basictypes |
| \since 5.9 |
| |
| \brief The geopath type represents a geographic path. |
| |
| The \c geopath type is a \l {geoshape} that represents a geographic |
| path. It is a direct representation of a \l QGeoPath and is defined |
| in terms of a \l {path} which holds the list of geo coordinates in the |
| path. |
| |
| The path is considered invalid if it is empty. |
| |
| When integrating with C++, note that any QGeoPath value passed into QML from C++ is |
| automatically converted into a \c geopath value, and vice versa. |
| |
| \section1 Properties |
| |
| \section2 path |
| |
| This property holds the list of coordinates defining the path. |
| |
| \section2 width |
| |
| This property holds the width of the path in meters. This is currently only used |
| when calling the \l {contains}() method. |
| |
| The default value for the width is 0. |
| */ |
| |
| /*! |
| \qmlbasictype geopolygon |
| \inqmlmodule QtPositioning |
| \ingroup qml-QtPositioning5-basictypes |
| \since 5.10 |
| |
| \brief The geopolygon type represents a geographic polygon. |
| |
| The \c geopolygon type is a \l [QML] geoshape that represents a geographic |
| polygon. It is a direct representation of QGeoPolygon and is defined in |
| terms of a \l path which holds a list of geo coordinates in the polygon. |
| |
| The polygon is considered invalid if its path holds less than three |
| coordinates. |
| |
| When integrating with C++, note that any QGeoPolygon value passed into QML |
| is automatically converted into a \c geopolygon, and vice versa. |
| |
| \section1 Properties |
| |
| \section2 path |
| |
| This property holds the list of coordinates defining the polygon. |
| */ |
| |
| static QObject *singleton_type_factory(QQmlEngine *engine, QJSEngine *jsEngine) |
| { |
| Q_UNUSED(engine); |
| Q_UNUSED(jsEngine); |
| |
| return new LocationSingleton; |
| } |
| |
| class QtPositioningDeclarativeModule: public QQmlExtensionPlugin |
| { |
| Q_OBJECT |
| |
| Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid |
| FILE "plugin.json") |
| |
| public: |
| QtPositioningDeclarativeModule(QObject *parent = 0) : QQmlExtensionPlugin(parent) { } |
| virtual void registerTypes(const char *uri) |
| { |
| if (QLatin1String(uri) == QStringLiteral("QtPositioning")) { |
| |
| // @uri QtPositioning 5.0 |
| |
| int major = 5; |
| int minor = 0; |
| |
| qRegisterMetaType<QGeoCoordinate>(); |
| QMetaType::registerEqualsComparator<QGeoCoordinate>(); |
| qRegisterMetaType<QGeoAddress>(); |
| qRegisterMetaType<QGeoRectangle>(); |
| QMetaType::registerEqualsComparator<QGeoRectangle>(); |
| qRegisterMetaType<QGeoCircle>(); |
| QMetaType::registerEqualsComparator<QGeoCircle>(); |
| qRegisterMetaType<QGeoPath>(); |
| QMetaType::registerEqualsComparator<QGeoPath>(); |
| qRegisterMetaType<QGeoPolygon>(); |
| QMetaType::registerEqualsComparator<QGeoPolygon>(); |
| qRegisterMetaType<QGeoLocation>(); |
| qRegisterMetaType<QGeoShape>(); |
| QMetaType::registerEqualsComparator<QGeoShape>(); |
| qRegisterMetaType<QGeoCoordinateObject *>(); |
| qRegisterMetaType<QGeoPositionInfo>(); |
| QMetaType::registerEqualsComparator<QGeoPositionInfo>(); |
| |
| qRegisterAnimationInterpolator<QGeoCoordinate>(q_coordinateInterpolator); |
| |
| // Register the 5.0 types |
| // 5.0 is silent and not advertised |
| qmlRegisterSingletonType<LocationSingleton >(uri, major, minor, "QtPositioning", singleton_type_factory); |
| qmlRegisterValueTypeEnums<QGeoShape >(uri, major, minor, "GeoShape"); |
| qmlRegisterType<QDeclarativePosition >(uri, major, minor, "Position"); |
| qmlRegisterType<QDeclarativePositionSource >(uri, major, minor, "PositionSource"); |
| qmlRegisterType<QDeclarativeGeoAddress >(uri, major, minor, "Address"); |
| qmlRegisterType<QDeclarativeGeoLocation >(uri, major, minor, "Location"); |
| |
| // Register the 5.3 types |
| // Introduction of 5.3 version; existing 5.0 exports become automatically available under 5.3 |
| minor = 3; |
| qmlRegisterType<QQuickGeoCoordinateAnimation >(uri, major, minor, "CoordinateAnimation"); |
| qmlRegisterType<QDeclarativePosition, 1>(uri, major, minor, "Position"); |
| |
| minor = 4; |
| qmlRegisterType<QDeclarativePosition, 2>(uri, major, minor, "Position"); |
| |
| minor = 13; |
| qmlRegisterType<QDeclarativeGeoLocation, 13>(uri, major, minor, "Location"); |
| |
| minor = 14; |
| qmlRegisterType<QDeclarativePluginParameter >(uri, major, minor, "PluginParameter"); |
| |
| // Register the latest Qt version as QML type version |
| qmlRegisterModule(uri, QT_VERSION_MAJOR, QT_VERSION_MINOR); |
| } else { |
| qDebug() << "Unsupported URI given to load positioning QML plugin: " << QLatin1String(uri); |
| } |
| } |
| }; |
| |
| QT_END_NAMESPACE |
| |
| #include "positioning.moc" |