Revision control

// Copyright (C) 2019 Julian Sherollari <jdotsh@gmail.com>
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qdeclarativegeojsondata_p.h"
#include <QtLocation/private/qgeojson_p.h>
QT_BEGIN_NAMESPACE
namespace extractor
{
static bool hasProperties(QQuickItem *item)
{
QVariant props = item->property("props");
return !props.isNull();
}
static QVariant toVariant(QObject *mapItem)
{
if (QDeclarativeGeoMapItemView *miv = qobject_cast<QDeclarativeGeoMapItemView *>(mapItem)) {
return toVariant(miv);
} else if (QDeclarativePolylineMapItem *polyline = qobject_cast<QDeclarativePolylineMapItem *>(mapItem)) {
return toVariant(polyline);
} else if (QDeclarativePolygonMapItem *polygon = qobject_cast<QDeclarativePolygonMapItem *>(mapItem)) {
return toVariant(polygon);
} else if (QDeclarativeCircleMapItem *circle = qobject_cast<QDeclarativeCircleMapItem *>(mapItem)) {
return toVariant(circle); // If GeoJSON Point type is visualized in other ways, handle those types here instead.
} else if (QDeclarativeRectangleMapItem *rectangle = qobject_cast<QDeclarativeRectangleMapItem *>(mapItem)) {
return toVariant(rectangle); // For the self-drawn rectangles. Will be exported as Polygons
}
return QVariant();
}
static QVariantMap toVariant(QDeclarativePolygonMapItem *mapPolygon)
{
QVariantMap ls;
ls[QStringLiteral("type")] = QStringLiteral("Polygon");
ls[QStringLiteral("data")] = QVariant::fromValue(mapPolygon->geoShape());
if (hasProperties(mapPolygon))
ls[QStringLiteral("properties")] = mapPolygon->property("props").toMap();
return ls;
}
static QVariantMap toVariant(QDeclarativePolylineMapItem *mapPolyline)
{
QVariantMap ls;
ls[QStringLiteral("type")] = QStringLiteral("LineString");
ls[QStringLiteral("data")] = QVariant::fromValue(mapPolyline->geoShape());
if (hasProperties(mapPolyline))
ls[QStringLiteral("properties")] = mapPolyline->property("props").toMap();
return ls;
}
static QVariantMap toVariant(QDeclarativeCircleMapItem *mapCircle)
{
QVariantMap pt;
pt[QStringLiteral("type")] = QStringLiteral("Point");
pt[QStringLiteral("data")] = QVariant::fromValue(mapCircle->geoShape());
QVariantMap propMap = mapCircle->property("props").toMap();
propMap[QStringLiteral("radius")] = mapCircle->radius();
pt[QStringLiteral("properties")] = propMap;
return pt;
}
static QVariantMap toVariant(QDeclarativeRectangleMapItem *mapRectangle)
{
QVariantMap pt;
pt[QStringLiteral("type")] = QStringLiteral("Polygon");
QGeoRectangle rectanlge = mapRectangle->geoShape();
QGeoPolygon poly;
poly.addCoordinate(rectanlge.topLeft());
poly.addCoordinate(rectanlge.topRight());
poly.addCoordinate(rectanlge.bottomRight());
poly.addCoordinate(rectanlge.bottomLeft());
pt[QStringLiteral("data")] = QVariant::fromValue(poly);
if (hasProperties(mapRectangle))
pt[QStringLiteral("properties")] = mapRectangle->property("props").toMap();
return pt;
}
};
/*!
\qmltype GeoJsonData
\nativetype QDeclarativeGeoJsonData
\inqmlmodule QtLocation
\ingroup qml-QtLocation5-maps
\since QtLocation 6.7
\brief A model to represent, load and save GeoJSON documents.
- The GeoJsonData element reads and writes GeoJson documents
- (see the \l {https://en.wikipedia.org/wiki/GeoJSON}
- {Wikipedia page}, \l {https://tools.ietf.org/html/rfc7946} {RFC}) from
- the \l {sourceUrl}.
- The respective data can be accessed as \l {QVariant} via the \l {model} property.
- The \l {QVariant} representation can be used with delegates to visualize
- the data or to make small modifications, e.g. adding new items with the
- \l {addItem} function.
-
- New data can be stored with the \l {save} and \l {saveAs} functions.
-
- \sa QGeoJson
+ The GeoJsonData type reads and writes GeoJson formatted documents.
+ GeoJsonData has functions to open and save the model at the URL set
+ to the \l sourceUrl property. The loaded model is internally represented by
+ QVariant and binds to the \l model property. Use
+ \l{Models and Views in Qt Quick#View Delegates}{Delegates} to visualize the items
+ in a view.
+
+ For information about GeoJSON, visit the \l{https://geojson.org/}{GeoJSON} website.
+
+ \section1 GeoJSON Object
+
+ The GeoJSON object is a valid JSON object that represents geometry, a feature, or a
+ collection of geometries or features.
+
+ A GeoJSON object must be one of these types:
+ \list
+ \li \c Point
+ \li \c MultiPoint
+ \li \c LineString
+ \li \c MultiLineString
+ \li \c Polygon
+ \li \c MultiPolygon
+ \li \c GeometryCollection
+ \li \c Feature
+ \li \c FeatureCollection
+ \endlist
+
+ To set the type, bind the \c type member to a GeoJSON type. The \c coordinates member can
+ be a type of QGeoShape or a list, depending on the GeoJSON type. The \c Feature type has an additional
+ \c geometry and \c properties member.
+
+ A list of the geometric types and their equivalent QVariant representations:
+
+ \list
+ \li For a \c Point object, \c coordinates pairs with QGeoCircle.
+ For example:
+ \code
+ {
+ "type": "Point",
+ "coordinates": [11, 60]
+ }
+ \endcode
+ This GeoJSON object has a corresponding QVariantMap representation:
+ \code
+ {
+ type: "Point"
+ coordinates: QGeoCircle({11.000, 60.000}, -1)
+ }
+ \endcode
+
+ \li For a \c LineString object, \c coordinates pairs with QGeoPath.
+ For example:
+ \code
+ {
+ "type" : "LineString",
+ "coordinates" : [
+ [13.5, 43],
+ [10.73, 59.92]
+ ]
+ }
+ \endcode
+ This GeoJSON object has a corresponding QVariantMap representation:
+ \code
+ {
+ type : "LineString"
+ data : QGeoPath([{43.000, 13.500}, {59.920, 10.730}])
+ }
+ \endcode
+
+ \li For a \c{Polygon} object, \c coordinates member pairs with QGeoPolygon (holes are possible). The polygon is a
+ \e{linear ring}, whose final coordinate is the same as the first coordinate, thereby opening and closing
+ the ring. The \c bbox member is an optional member and is for setting the area's range, useful for concave boundaries.
+ For more information about the accepted polygon coordinates, read about the
+ \l{https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.6Polygon}{Polygon} type in the GeoJson specification.
+ For example:
+ \code
+ {
+ "type": "Polygon",
+ "coordinates": [
+ [
+ [17.13, 51.11],
+ [30.54, 50.42],
+ [26.70, 58.36],
+ [17.13, 51.11]
+ ]
+ ],
+ "bbox": [50, -50, 10, -10]
+ }
+ \endcode
+ This GeoJSON object has a corresponding QVariantMap representation:
+ \code
+ {
+ type : "Polygon"
+ coordinates : QGeoPolygon([{51.110, 17.130}, {50.420,30.540}, {58.360, 26.700}, {51.110, 17.130}])
+ }
+ \endcode
+
+ \endlist
+
+ For the \c MultiPoint, \c MultiLineString, and \c MultiPolygon types, \c coordinates pairs with a QVariantList.
+ The list element is a QVariantMap containing geometry.
+
+ \list
+ \li For a \c MultiPoint object, \c coordinates pairs with a list of Point coordinates.
+ For example:
+ \code
+ {
+ "type": "MultiPoint",
+ "coordinates": [
+ [11, 60],
+ [5.5, 60.3],
+ [5.7, 58.90]
+ ]
+ }
+ \endcode
+ This GeoJSON object has a corresponding QVariantMap representation:
+ \code
+ {
+ type : "MultiPoint"
+ coordinates : [
+ {
+ type : "Point"
+ coordinates : QGeoCircle({60.000, 11.000}, -1)
+ },
+ {
+ type : "Point"
+ coordinates : QGeoCircle({60.300, 5.500}, -1)
+ },
+ {
+ type : "Point"
+ coordinates : QGeoCircle({58.900, 5.700}, -1)
+ }
+ ]
+ }
+ \endcode
+
+ \li For a \c MultiLineString object, \c coordinates pairs with a list of LineString coordinates.
+ The following GeoJSON object constructs two non-parallel lines:
+ \code
+ {
+ "type" : "MultiLineString",
+ "coordinates" : [
+ [[13.5, 43], [10.73, 59.92]],
+ [[9.15, 45], [-3.15, 58.90]]
+ ]
+ }
+ \endcode
+ This GeoJSON object has a corresponding QVariantMap representation:
+ \code
+ {
+ type : "MultiLineString"
+ coordinates : [
+ {
+ type : "LineString"
+ coordinates : QGeoPath([{45.000, 9.150}, {58.900, -3.150}])
+ },
+ {
+ type : "LineString"
+ coordinates : QGeoPath([{43.000, 13.500}, {59.920, 10.730}])
+ }
+ ]
+ }
+ \endcode
+
+ \li For a \c MultiPolygon type, \c coordinates pairs with a list of Polygon coordinates.
+ The polygon is a \e{linear ring} and the \c Polygon type has more information about accepted formats.
+ The following GeoJSON object contains a list of two triangles:
+ \code
+ {
+ "type" : "MultiPolygon",
+ "coordinates" : [
+ [
+ [[17.13, 51.11],
+ [30.54, 50.42],
+ [26.74, 58.36],
+ [17.13, 51.11]
+ ]],
+ [
+ [[19.84, 41.33],
+ [30.45, 49.26],
+ [17.07, 50.10],
+ [19.84, 41.33]
+ ]]
+ ]
+ }
+ \endcode
+ This GeoJSON object has a corresponding QVariantMap representation:
+ \code
+ {
+ type : "MultiPolygon"
+ coordinates : [
+ {
+ type : "Polygon"
+ coordinates : QGeoPolygon([{51.110, 17.130}, {50.420,30.540}, {58.360, 26.740}])
+ },
+ {
+ type : "Polygon"
+ coordinates : QGeoPolygon([{41.330, 19.840}, {49.260,30.450}, {50.100, 17.070}])
+ }
+ ]
+ }
+ \endcode
+
+ \endlist
+
+ The \c GeometryCollection type is a composition of other geometry types. The value of the
+ \c geometries member is a QVariantList containing QVariantMaps of various types,
+ including other GeometryCollection types.
+
+ For example, the following \c GeometryCollection type contains several other geometries:
+ \code
+ {
+ "type" : "GeometryCollection",
+ "geometries" : [
+ {
+ "type" : "MultiPoint",
+ "coordinates" : [
+ [11,60], [5.5,60.3], [5.7,58.90]
+ ]
+ },
+ {
+ "type" : "MultiLineString",
+ "coordinates": [
+ [[13.5, 43], [10.73, 59.92]],
+ [[9.15, 45], [-3.15, 58.90]]
+ ]
+ },
+ {
+ "type" : "MultiPolygon",
+ "coordinates" : [
+ [
+ [
+ [17.13, 51.11],
+ [30.54, 50.42],
+ [26.74, 58.36],
+ [17.13, 51.11]
+ ]
+ ],
+ [
+ [
+ [19.84, 41.33],
+ [30.45, 49.26],
+ [17.07, 50.10],
+ [19.84, 41.33]
+ ]
+ ]
+ ]
+ }
+ ]
+ }
+ \endcode
+ This GeoJSON object has a corresponding QVariantMap representation:
+ \code
+ {
+ type : "GeometryCollection"
+ coordinates : [
+ {
+ type : "MultiPolygon"
+ coordinates : [
+ {
+ type : "Polygon"
+ coordinates : QGeoPolygon([{41.330, 19.840}, {49.260, 30.450}, {50.100, 17.070}])
+ },
+ {
+ type : "Polygon"
+ coordinates : QGeoPolygon([{51.110, 17.130}, {50.420, 30.540}, {58.360, 26.740}])
+ }
+ ]
+ }
+ {
+ type : "MultiLineString"
+ coordinates : [
+ {
+ type : "LineString"
+ coordinates : QGeoPath([{45.000, 9.150}, {58.900, -3.150}])
+ },
+ {
+ type : "LineString"
+ coordinates : QGeoPath([{43.000, 13.500}, {59.920, 10.730}])
+ }
+ ]
+ }
+ {
+ type : "MultiPoint"
+ coordinates : [
+ {
+ type : Point
+ coordinates : QGeoCircle({58.900, 5.700}, -1)
+ },
+ {
+ type : Point
+ coordinates : QGeoCircle({60.300, 5.500}, -1)
+ },
+ {
+ type : Point
+ coordinates : QGeoCircle({60.000, 11.000}, -1)
+ }
+ ]
+ }
+ ]
+ }
+ \endcode
+
+ The \c Feature type contains an additional \c geometry and \c properties
+ member. The only way to distinguish a Feature object from other geometrical objects
+ is to check for the existence of a \c properties node in the QVariantMap object.
+
+ For example, the following \c Feature has a geometry and properties members:
+ \code
+ {
+ "type": "Feature",
+ "id": "Poly",
+ "properties": {
+ "name": "Poly",
+ "text": "This is a Feature with a Polygon",
+ "color": "limegreen"
+ },
+ "geometry": {
+ "type": "Polygon",
+ "coordinates": [
+ [
+ [17.13, 51.11],
+ [30.54, 50.42],
+ [26.70, 58.36],
+ [17.13, 51.11]
+ ],
+ [
+ [23.46, 54.36],
+ [20.52, 51.91],
+ [28.25, 51.50],
+ [26.80, 54.36],
+ [23.46, 54.36]
+ ]
+ ]
+ }
+ }
+ \endcode
+ This GeoJSON object has a corresponding QVariantMap representation:
+ \code
+ {
+ type : "Polygon"
+ data : QGeoPolygon([{51.110, 17.130}, {50.420,30.540}, {58.360, 26.700}, {51.110, 17.130}])
+ properties : {text : "This is a Feature with a Polygon"}
+ }
+ \endcode
+
+ The \c FeatureCollection is a composition of Feature objects. THe \c features
+ member binds to a QVariantList object containing other Feature objects.
+
+ For example, the following \c FeatureCollection has several Features and geometries:
+ \code
+ {
+ "type" : "FeatureCollection",
+ "properties" : {
+ "color" : "crimson"
+ },
+ "features" : [
+ {
+ "type" : "Feature",
+ "id" : "Poly",
+ "properties" : {
+ "text" : "This is a Feature with a Polygon"
+ },
+ "geometry" : {
+ "type" : "Polygon",
+ "coordinates" : [
+ [
+ [17.13, 51.11],
+ [30.54, 50.42],
+ [26.70, 58.36],
+ [17.13, 51.11]
+ ],
+ [
+ [23.46, 54.36],
+ [20.52, 51.91],
+ [28.25, 51.50],
+ [26.80, 54.36],
+ [23.46, 54.36]
+ ]
+ ]
+ }
+ },
+ {
+ "type" : "Feature",
+ "id" : "MultiLine",
+ "properties" : {
+ "text" : "This is a Feature with a MultiLineString",
+ "color" : "deepskyblue"
+ },
+ "geometry" : {
+ "type" : "MultiLineString",
+ "coordinates" : [
+ [[13.5, 43], [10.73, 59.92]],
+ [[9.15, 45], [-3.15, 58.90]]
+ ]
+ }
+ }
+ ]
+ }
+ \endcode
+ This GeoJSON object has a corresponding QVariantMap representation:
+ \code
+ {
+ type: "FeatureCollection"
+ data: [{
+ type: "MultiLineString"
+ data: [{
+ type: "LineString"
+ data: QGeoPath( [{45.000, 9.150}, {58.900, -3.150}] )
+ } {
+ type: "LineString"
+ data: QGeoPath( [{43.000, 13.500}, {59.920, 10.730}] )
+ }]
+ properties: { text: "This is a Feature with a MultiLineString" }
+ },
+ {
+ type: "Polygon"
+ data: QGeoPolygon( {51.110, 17.130},
+ {50.420, 30.540},
+ {58.360, 26.700},
+ {51.110, 17.130}
+ )
+ properties: { text: "This is a Feature with a Polygon" }
+ }
+ ]
+ }
+ \endcode
+
+ \section1 GeoJson Example
+
+ The \l{GeoJson Viewer (QML)}{GeoJson Viewer} example demonstrates the use of the GeoJsonData QML type to
+ load and visualize coordinates on a map.
*/
QDeclarativeGeoJsonData::QDeclarativeGeoJsonData(QObject *parent)
: QObject(parent)
{
}
QDeclarativeGeoJsonData::~QDeclarativeGeoJsonData()
{
}
/*!
\qmlproperty QVariant QtLocation::GeoJsonData::model
- A \l QVariant representation of the GeoJSON document that
- can be used to display the contents with delegates.
+ A QVariant representation of the GeoJSON document. QML
+ delegates can display the contents in views.
\since 6.7
*/
QVariant QDeclarativeGeoJsonData::model() const
{
return m_content;
}
void QDeclarativeGeoJsonData::setModel(const QVariant &model)
{
m_content = model;
emit modelChanged();
}
/*!
\qmlproperty QUrl QtLocation::GeoJsonData::sourceUrl
- The URL from which the GeoJSON document is read. Setting this
- property will change the \l model to represent the respective document.
+ The URL of a GeoJSON document. Setting this property loads the
+ document and binds the object to the \l model member.
\since 6.7
*/
QUrl QDeclarativeGeoJsonData::sourceUrl() const
{
return m_url;
}
/*!
\qmlmethod void QtLocation::GeoJsonData::clear()
- Delete all items in the \l model of the GeoJsonData.
+ Deletes all items bound to the \l model.
*/
void QDeclarativeGeoJsonData::clear()
{
m_content = QVariantList();
emit modelChanged();
}
/*!
\qmlmethod bool QtLocation::GeoJsonData::addItem(Item item)
- Add the \a item to the \l model of the GeoJsonData.
+ Adds the \a item to the \l model object.
- Returns \c true if the file was read successfully, \c false otherwise.
+ Returns \c true if adding is successful, \c false otherwise.
*/
void QDeclarativeGeoJsonData::addItem(QQuickItem *item)
{
QVariant entry;
if (auto *polyline = qobject_cast<QDeclarativePolylineMapItem *>(item))
entry = extractor::toVariant(polyline);
else if (auto *polygon = qobject_cast<QDeclarativePolygonMapItem *>(item))
entry = extractor::toVariant(polygon);
else if (auto *circle = qobject_cast<QDeclarativeCircleMapItem *>(item))
entry = extractor::toVariant(circle);
else if (auto *rectangle = qobject_cast<QDeclarativeRectangleMapItem *>(item))
entry = extractor::toVariant(rectangle);
else
return;
QVariantList geoJson = m_content.toList();
if (!geoJson.isEmpty()){
QVariantList geoData = (geoJson[0].toMap()[QStringLiteral("type")] == QStringLiteral("FeatureCollection")) ? geoJson[0].toMap()[QStringLiteral("data")].toList() : geoJson;
geoData.append(entry);
geoJson[0] = QVariantMap{{QStringLiteral("type"), QStringLiteral("FeatureCollection")}, {QStringLiteral("data"), geoData}};
}
else {
geoJson.append(entry);
}
m_content = geoJson;
emit modelChanged();
}
/*!
\qmlmethod bool QtLocation::GeoJsonData::open()
- Reload the content of the file at \l sourceUrl.
+ Loads the content of the file at \l sourceUrl.
- Returns \c true if the file was read successfully, \c false otherwise.
+ Returns \c true if opening is successful, \c false otherwise.
*/
bool QDeclarativeGeoJsonData::open()
{
return openUrl(m_url);
}
/*!
\qmlmethod bool QtLocation::GeoJsonData::openUrl(Url url)
- Open the GeoJson file at \a url and load its content. The property
- \l sourceUrl will be set to \a url if the file is read successfully.
+ Loads the GeoJson document at \a url and binds it to the \l model. The property
+ \l sourceUrl is set to \a url if opening the file is successful.
- Returns \c true if the file was read successfully, \c false otherwise.
+ Returns \c true if opening is successful, \c false otherwise.
*/
bool QDeclarativeGeoJsonData::openUrl(const QUrl &url)
{
// Reading GeoJSON file
QFile loadFile(url.toLocalFile());
if (!loadFile.open(QIODevice::ReadOnly)) {
qWarning() << "Error while opening the file: " << url;
qWarning() << loadFile.errorString();
return false;
}
// Load the GeoJSON file using Qt's API
QJsonParseError err;
QJsonDocument loadDoc(QJsonDocument::fromJson(loadFile.readAll(), &err));
if (err.error) {
qWarning() << "Parsing while importing the JSON document:\n" << err.errorString();
return false;
}
// Import geographic data to a QVariantList
m_content = QGeoJson::importGeoJson(loadDoc);
if (m_url != url) {
m_url = url;
emit sourceUrlChanged();
}
emit modelChanged();
return true;
}
/*!
\qmlmethod bool QtLocation::GeoJsonData::saveAs(Url url)
- The current \l model of the GeoJsonData object is saved under \a url.
- The \l sourceUrl property will be set to \a url.
+ Saves the \l model at \a url.
+ The \l sourceUrl property is set to \a url if successful.
- Returns \c true if the file was saved successfully, \c false otherwise.
+ Returns \c true if saving is successful, \c false otherwise.
*/
bool QDeclarativeGeoJsonData::saveAs(const QUrl &url)
{
if (m_url != url){
m_url = url;
emit sourceUrlChanged();
}
return save();
}
/*!
\qmlmethod bool QtLocation::GeoJsonData::save()
- The current \l model of the GeoJsonData object is saved under
- \l sourceUrl.
+ Saves the model at \l{sourceUrl}.
- Returns \c true if the file was saved successfully, \c false otherwise.
+ Returns \c true if saving is successful, \c false otherwise.
*/
bool QDeclarativeGeoJsonData::save()
{
return dumpGeoJSON(m_content.toList(), m_url);
}
/*!
\qmlmethod void QtLocation::GeoJsonData::setModelToMapContents(MapView mapItemView)
- All mapItems of \a mapItemView are added to the \l model of the GeoJsonData
- object.
- Previously stored mapItems are deleted from the \l model.
+ Adds all map items of \a mapItemView to the \l model of the GeoJsonData
+ object. Deletes previously stored map items from the \l model.
- Returns \c true if mapItemView is set successfully, \c false otherwise.
+ Returns \c true if setting is successful, \c false otherwise.
\sa addItem
*/
void QDeclarativeGeoJsonData::setModelToMapContents(QDeclarativeGeoMap *map)
{
m_content = toVariant(map);
emit modelChanged();
}
/*! \internal
A helper function to convert the children of a map to a \l QVariantList that
represents the items and that can be exported to a Json file.
Returns a \l QVariantList containing all data of the mapItems.
*/
QVariantList QDeclarativeGeoJsonData::toVariant(QDeclarativeGeoMap *map)
{
QVariantList res;
const QList<QObject*> mapChildren = map->children();
for (QObject *child : mapChildren) {
QVariant mapItemAsVariant = extractor::toVariant(child);
if (mapItemAsVariant.isValid())
res.append(mapItemAsVariant);
}
return res;
}
/*! \internal
A helper function to dump the VariantList \a geoJson into the file at \a url.
Returns \c true if the file was saved successfully, \c false otherwise.
*/
bool QDeclarativeGeoJsonData::dumpGeoJSON(const QVariantList &geoJson, const QUrl &url)
{
QJsonDocument json = QGeoJson::exportGeoJson(geoJson);
QFile jsonFile(url.toLocalFile());
if (!jsonFile.open(QIODevice::WriteOnly))
return false;
jsonFile.write(json.toJson());
jsonFile.close();
return true;
}
/*! \internal
A helper function to write a human interpretable representation of
\a geoJson into the file at \a url.
Returns \c true if the file was saved successfully, \c false otherwise.
*/
bool QDeclarativeGeoJsonData::writeDebug(const QVariantList &geoJson, const QUrl &url)
{
QString prettyPrint = QGeoJson::toString(geoJson);
QFile debugFile(url.toLocalFile());
if (!debugFile.open(QIODevice::WriteOnly))
return false;
debugFile.write(prettyPrint.toUtf8());
debugFile.close();
return true;
}
/*! \internal
A helper function to generate a human interpretable representation of
\a geoJson.
Returns a string with the human interpretable representation of \a geoJson.
*/
QString QDeclarativeGeoJsonData::toString(const QVariantList &geoJson)
{
return QGeoJson::toString(geoJson);
}
QT_END_NAMESPACE