Revision control
Copy as Markdown
// Copyright (C) 2022 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
// Qt-Security score:significant reason:default
#include "qdeclarativepolylinemapitem_p.h"
#include "qdeclarativepolylinemapitem_p_p.h"
#include <QtCore/QScopedValueRollback>
#include <qnumeric.h>
#include <QPainterPath>
#include <QtGui/private/qtriangulatingstroker_p.h>
#include <QtPositioning/private/qlocationutils_p.h>
#include <QtPositioning/private/qdoublevector2d_p.h>
#include <QtPositioning/private/qwebmercator_p.h>
#include <QtPositioning/private/qclipperutils_p.h>
#include <QtPositioning/private/qgeopath_p.h>
#include <QtLocation/private/qgeomap_p.h>
#include <array>
QT_BEGIN_NAMESPACE
static bool get_line_intersection(const double p0_x,
const double p0_y,
const double p1_x,
const double p1_y,
const double p2_x,
const double p2_y,
const double p3_x,
const double p3_y,
double *i_x,
double *i_y,
double *i_t)
{
const double s10_x = p1_x - p0_x;
const double s10_y = p1_y - p0_y;
const double s32_x = p3_x - p2_x;
const double s32_y = p3_y - p2_y;
const double denom = s10_x * s32_y - s32_x * s10_y;
if (denom == 0.0)
return false; // Collinear
const bool denomPositive = denom > 0;
const double s02_x = p0_x - p2_x;
const double s02_y = p0_y - p2_y;
const double s_numer = s10_x * s02_y - s10_y * s02_x;
if ((s_numer < 0.0) == denomPositive)
return false; // No collision
const double t_numer = s32_x * s02_y - s32_y * s02_x;
if ((t_numer < 0.0) == denomPositive)
return false; // No collision
if (((s_numer > denom) == denomPositive) || ((t_numer > denom) == denomPositive))
return false; // No collision
// Collision detected
*i_t = t_numer / denom;
*i_x = p0_x + (*i_t * s10_x);
*i_y = p0_y + (*i_t * s10_y);
return true;
}
enum SegmentType {
NoIntersection,
OneIntersection,
TwoIntersections
};
static QList<QList<QDoubleVector2D> > clipLine(
const QList<QDoubleVector2D> &l,
const QList<QDoubleVector2D> &poly)
{
QList<QList<QDoubleVector2D> > res;
if (poly.size() < 2 || l.size() < 2)
return res;
// Step 1: build edges
std::vector<std::array<double, 4> > edges;
for (qsizetype i = 1; i < poly.size(); i++)
edges.push_back({ { poly.at(i-1).x(), poly.at(i-1).y(), poly.at(i).x(), poly.at(i).y() } });
edges.push_back({ { poly.at(poly.size()-1).x(), poly.at(poly.size()-1).y(), poly.at(0).x(), poly.at(0).y() } });
// Step 2: check each segment against each edge
QList<QDoubleVector2D> subLine;
std::array<double, 4> intersections = { { 0.0, 0.0, 0.0, 0.0 } };
for (qsizetype i = 0; i < l.size() - 1; ++i) {
SegmentType type = NoIntersection;
double t = -1; // valid values are in [0, 1]. Only written if intersects
double previousT = t;
double i_x, i_y;
const int firstContained = QClipperUtils::pointInPolygon(l.at(i), poly);
const int secondContained = QClipperUtils::pointInPolygon(l.at(i+1), poly);
if (firstContained && secondContained) { // Second most common condition, test early and skip inner loop if possible
if (!subLine.size())
subLine.push_back(l.at(i)); // the initial element has to be pushed now.
subLine.push_back(l.at(i+1));
continue;
}
for (unsigned int j = 0; j < edges.size(); ++j) {
const bool intersects = get_line_intersection(l.at(i).x(),
l.at(i).y(),
l.at(i+1).x(),
l.at(i+1).y(),
edges.at(j).at(0),
edges.at(j).at(1),
edges.at(j).at(2),
edges.at(j).at(3),
&i_x,
&i_y,
&t);
if (intersects) {
if (previousT >= 0.0) { //One intersection already hit
if (t < previousT) { // Reorder
intersections[2] = intersections[0];
intersections[3] = intersections[1];
intersections[0] = i_x;
intersections[1] = i_y;
} else {
intersections[2] = i_x;
intersections[3] = i_y;
}
type = TwoIntersections;
break; // no need to check anything else
} else { // First intersection
intersections[0] = i_x;
intersections[1] = i_y;
type = OneIntersection;
}
previousT = t;
}
}
if (type == NoIntersection) {
if (!firstContained && !secondContained) { // Both outside
subLine.clear();
} else if (firstContained && secondContained) {
// Handled above already.
} else { // Mismatch between PointInPolygon and get_line_intersection. Treat it as no intersection
if (subLine.size())
res.push_back(subLine);
subLine.clear();
}
} else if (type == OneIntersection) { // Need to check the following cases to avoid mismatch with PointInPolygon result.
if (firstContained <= 0 && secondContained > 0) { // subLine MUST be empty
if (!subLine.size())
subLine.push_back(QDoubleVector2D(intersections[0], intersections[1]));
subLine.push_back(l.at(i+1));
} else if (firstContained > 0 && secondContained <= 0) { // subLine MUST NOT be empty
if (!subLine.size())
subLine.push_back(l.at(i));
subLine.push_back(QDoubleVector2D(intersections[0], intersections[1]));
res.push_back(subLine);
subLine.clear();
} else {
if (subLine.size())
res.push_back(subLine);
subLine.clear();
}
} else { // Two
// restart strip
subLine.clear();
subLine.push_back(QDoubleVector2D(intersections[0], intersections[1]));
subLine.push_back(QDoubleVector2D(intersections[2], intersections[3]));
res.push_back(subLine);
subLine.clear();
}
}
if (subLine.size())
res.push_back(subLine);
return res;
}
/*!
\qmltype MapPolyline
\nativetype QDeclarativePolylineMapItem
\inqmlmodule QtLocation
\ingroup qml-QtLocation5-maps
\since QtLocation 5.0
\brief The MapPolyline type displays a polyline on a map.
The MapPolyline type displays a polyline on a map, specified in terms of an
ordered list of \l [QtPositioning]{geoCoordinate}{coordinates}.
Coordinates can be added or removed at any time using the \l addCoordinate and
\l removeCoordinate methods. They can also be modified like any other list element in QML:
\code
mapPolyline.path[0].latitude = 5;
\endcode
By default, the polyline is displayed as a 1-pixel thick black line. This
can be changed using the \l line.width and \l line.color properties.
\section2 Example Usage
The following snippet shows a MapPolyline with 4 points, making a shape
like the top part of a "question mark" (?), near Brisbane, Australia.
The line drawn is 3 pixels in width and green in color.
\code
Map {
MapPolyline {
line.width: 3
line.color: 'green'
path: [
{ latitude: -27, longitude: 153.0 },
{ latitude: -27, longitude: 154.1 },
{ latitude: -28, longitude: 153.5 },
{ latitude: -29, longitude: 153.5 }
]
}
}
\endcode
\image api-mappolyline.png {Green polyline on a map}
*/
/*!
\qmlproperty bool QtLocation::MapPolyline::autoFadeIn
This property holds whether the item automatically fades in when zooming into the map
starting from very low zoom levels. By default this is \c true.
Setting this property to \c false causes the map item to always have the opacity specified
with the \l QtQuick::Item::opacity property, which is 1.0 by default.
\since 5.14
*/
/*!
\qmlproperty enum QtLocation::MapPolyline::referenceSurface
This property determines the reference surface of the polyline. If it is set to
\l QLocation::ReferenceSurface::Map the polylines vertices are connected with straight
lines on the map. If it is set to \l QLocation::ReferenceSurface::Globe, the vertices
are connected following the great circle path, describing the shortest connection of
two points on a sphere.
Default value is \l QLocation::ReferenceSurface::Map.
\since 6.5
*/
QDeclarativeMapLineProperties::QDeclarativeMapLineProperties(QObject *parent)
: QObject(parent)
{
}
/*!
\internal
*/
QColor QDeclarativeMapLineProperties::color() const
{
return color_;
}
/*!
\internal
*/
void QDeclarativeMapLineProperties::setColor(const QColor &color)
{
if (color_ == color)
return;
color_ = color;
emit colorChanged(color_);
}
/*!
\internal
*/
qreal QDeclarativeMapLineProperties::width() const
{
return width_;
}
/*!
\internal
*/
void QDeclarativeMapLineProperties::setWidth(qreal width)
{
if (width_ == width)
return;
width_ = width;
emit widthChanged(width_);
}
/*!
\internal
*/
void QGeoMapPolylineGeometry::updateSourcePoints(const QGeoMap &map,
const QList<QDoubleVector2D> &basePath)
{
// A polygon consists of mutliple paths. This is usually a perimeter and multiple holes
// We move all paths into a single QPainterPath. The filling rule EvenOdd will then ensure that the paths are shown correctly
if (!sourceDirty_)
return;
const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(map.geoProjection());
srcPath_ = QPainterPath();
srcOrigin_ = p.mapProjectionToGeo(QDoubleVector2D(0, 0)); //avoid warning of NaN values if function is returned early
//0 Wrap the points around the globe if the path makes more sense that way.
// Ultimately, this is done if it is closer to walk around the day-border than the other direction
QVarLengthArray<QList<QDoubleVector2D>, 3> wrappedPaths;
wrappedPaths << QList<QDoubleVector2D>({basePath[0]});
wrappedPaths.last().reserve(basePath.size());
for (int i = 1; i < basePath.size(); i++) {
if (basePath[i].x() > wrappedPaths.last().last().x() + 0.5)
wrappedPaths.last() << basePath[i] - QDoubleVector2D(1.0, 0.0);
else if (basePath[i].x() < wrappedPaths.last().last().x() - 0.5)
wrappedPaths.last() << basePath[i] + QDoubleVector2D(1.0, 0.0);
else
wrappedPaths.last() << basePath[i];
}
//1 The bounding rectangle of the polygon and camera view are compared to determine if the polygon is visible
// The viewport is periodic in x-direction in the interval [-1; 1].
// The polygon (maybe) has to be ploted periodically too by shifting it by -1 or +1;
const QRectF cameraRect = QDeclarativeGeoMapItemUtils::boundingRectangleFromList(p.visibleGeometry());
QRectF itemRect;
for (const auto &path : wrappedPaths)
itemRect |= QDeclarativeGeoMapItemUtils::boundingRectangleFromList(path).adjusted(-1e-6, -1e-6, 2e-6, 2e-6); //TODO: Maybe use linewidth?
for (double xoffset : {-1.0, 1.0}) {
if (!cameraRect.intersects(itemRect.translated(QPointF(xoffset,0))))
continue;
wrappedPaths.append(QList<QDoubleVector2D>());
QList<QDoubleVector2D> &wP = wrappedPaths.last();
wP.reserve(wrappedPaths.first().size());
for (const QDoubleVector2D &coord : wrappedPaths.first())
wP.append(coord + QDoubleVector2D(xoffset, 0.0));
}
if (wrappedPaths.isEmpty()) // the polygon boundary rectangle does not overlap with the viewport rectangle
return;
//2 The polygons that are at least partially in the viewport are cliped to reduce their size
QList<QList<QDoubleVector2D>> clippedPaths;
const QList<QDoubleVector2D> &visibleRegion = p.visibleGeometryExpanded();
for (const auto &path : wrappedPaths) {
if (visibleRegion.size()) {
clippedPaths << clipLine(path, visibleRegion);
//TODO: Replace clipping with Clipper lib, similar to QPolygonMapItem
} else {
clippedPaths.append(path); //Do we really need this if there are no visible regions??
}
}
if (clippedPaths.isEmpty()) //the polygon is entirely outside visibleRegion
return;
QRectF bb;
for (const auto &path: clippedPaths)
bb |= QDeclarativeGeoMapItemUtils::boundingRectangleFromList(path);
//Offset by origin, find the maximum coordinate
maxCoord_ = 0.0;
srcOrigin_ = p.mapProjectionToGeo(QDoubleVector2D(bb.left(), bb.top()));
QDoubleVector2D origin = p.wrappedMapProjectionToItemPosition(p.geoToWrappedMapProjection(srcOrigin_)); //save way: redo all projections
for (const auto &path: clippedPaths) {
QDoubleVector2D lastAddedPoint;
for (qsizetype i = 0; i < path.size(); ++i) {
QDoubleVector2D point = p.wrappedMapProjectionToItemPosition(path.at(i));
point = point - origin; // (0,0) if point == origin
if (qMax(point.x(), point.y()) > maxCoord_)
maxCoord_ = qMax(point.x(), point.y());
if (i == 0) {
srcPath_.moveTo(point.toPointF());
lastAddedPoint = point;
} else {
if ((point - lastAddedPoint).manhattanLength() > 3 ||
i == path.size() - 1) {
srcPath_.lineTo(point.toPointF());
lastAddedPoint = point;
}
}
}
}
sourceBounds_ = srcPath_.boundingRect();
}
/*
* QDeclarativePolygonMapItem Private Implementations
*/
QDeclarativePolylineMapItemPrivate::~QDeclarativePolylineMapItemPrivate()
{
}
QDeclarativePolylineMapItemPrivateCPU::QDeclarativePolylineMapItemPrivateCPU(QDeclarativePolylineMapItem &poly)
: QDeclarativePolylineMapItemPrivate(poly)
{
m_shape = new QQuickShape(&m_poly);
m_shape->setObjectName("_qt_map_item_shape");
m_shape->setZ(-1);
m_shape->setContainsMode(QQuickShape::FillContains);
m_shapePath = new QQuickShapePath(m_shape);
m_painterPath = new QDeclarativeGeoMapPainterPath(m_shapePath);
auto pathElements = m_shapePath->pathElements();
pathElements.append(&pathElements, m_painterPath);
auto shapePaths = m_shape->data();
shapePaths.append(&shapePaths, m_shapePath);
}
QDeclarativePolylineMapItemPrivateCPU::~QDeclarativePolylineMapItemPrivateCPU()
{
delete m_shape;
}
void QDeclarativePolylineMapItemPrivateCPU::regenerateCache()
{
if (!m_poly.map() || m_poly.map()->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
return;
const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_poly.map()->geoProjection());
m_geopathProjected.clear();
if (m_poly.referenceSurface() == QLocation::ReferenceSurface::Globe) {
const QList<QGeoCoordinate> realPath = QDeclarativeGeoMapItemUtils::greaterCirclePath(m_poly.m_geopath.path());
m_geopathProjected.reserve(realPath.size());
for (const QGeoCoordinate &c : realPath)
m_geopathProjected << p.geoToMapProjection(c);
} else {
m_geopathProjected.reserve(m_poly.m_geopath.path().size());
const QList<QGeoCoordinate> path = m_poly.m_geopath.path();
for (const QGeoCoordinate &c : path)
m_geopathProjected << p.geoToMapProjection(c);
}
}
void QDeclarativePolylineMapItemPrivateCPU::updateCache()
{
if (!m_poly.map() || m_poly.map()->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
return;
const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_poly.map()->geoProjection());
m_geopathProjected << p.geoToMapProjection(m_poly.m_geopath.path().last());
}
void QDeclarativePolylineMapItemPrivateCPU::updatePolish()
{
if (m_poly.m_geopath.path().length() < 2) { // Possibly cleared
m_geometry.clear();
m_poly.setWidth(0);
m_poly.setHeight(0);
m_shape->setVisible(false);
return;
}
QScopedValueRollback<bool> rollback(m_poly.m_updatingGeometry);
m_poly.m_updatingGeometry = true;
const QGeoMap *map = m_poly.map();
const qreal borderWidth = m_poly.m_line.width();
m_geometry.updateSourcePoints(*map, m_geopathProjected);
const QRectF bb = m_geometry.sourceBoundingBox();
m_poly.setSize(bb.size() + QSizeF(borderWidth, borderWidth));
// it has to be shifted so that the center of the line is on the correct geocoord
m_poly.setPositionOnMap(m_geometry.origin(), -1 * bb.topLeft() + QPointF(borderWidth, borderWidth) * 0.5);
m_poly.setShapeTriangulationScale(m_shape, m_geometry.maxCoord_);
m_shapePath->setStrokeColor(m_poly.m_line.color());
m_shapePath->setStrokeWidth(borderWidth);
m_shapePath->setFillColor(Qt::transparent);
QPainterPath path = m_geometry.srcPath();
path.translate(-bb.left() + borderWidth * 0.5, -bb.top() + borderWidth * 0.5);
m_painterPath->setPath(path);
m_shape->setSize(m_poly.size());
m_shape->setOpacity(m_poly.zoomLevelOpacity());
m_shape->setVisible(true);
}
QSGNode *QDeclarativePolylineMapItemPrivateCPU::updateMapItemPaintNode(QSGNode *oldNode,
QQuickItem::UpdatePaintNodeData * /*data*/)
{
delete oldNode;
if (m_geometry.isScreenDirty() || !oldNode) {
m_geometry.markClean();
}
return nullptr;
}
bool QDeclarativePolylineMapItemPrivateCPU::contains(const QPointF &point) const
{
// With Shapes, do not just call
// m_shape->contains(m_poly.mapToItem(m_shape, point)) because that can
// only do FillContains at best, whereas the polyline relies on stroking.
const QPainterPath &path = m_shapePath->path();
const double &lineWidth = m_poly.m_line.width();
const QPointF p = m_poly.mapToItem(m_shape, point);
for (int i = 1; i < path.elementCount(); i++) {
if (path.elementAt(i).type == QPainterPath::MoveToElement)
continue;
const double dsqr = QDeclarativeGeoMapItemUtils::distanceSqrPointLine(p.x(), p.y(),
path.elementAt(i - 1).x, path.elementAt(i - 1).y,
path.elementAt(i).x, path.elementAt(i).y);
if (dsqr < 0.25 * lineWidth * lineWidth)
return true;
}
return false;
}
/*
* QDeclarativePolygonMapItem Implementation
*/
QDeclarativePolylineMapItem::QDeclarativePolylineMapItem(QQuickItem *parent)
: QDeclarativeGeoMapItemBase(parent), m_line(this),
m_d(new QDeclarativePolylineMapItemPrivateCPU(*this))
{
m_itemType = QGeoMap::MapPolyline;
m_geopath = QGeoPathEager();
setFlag(ItemHasContents, true);
QObject::connect(&m_line, &QDeclarativeMapLineProperties::colorChanged,
this, &QDeclarativePolylineMapItem::updateAfterLinePropertiesChanged);
QObject::connect(&m_line, &QDeclarativeMapLineProperties::widthChanged,
this, &QDeclarativePolylineMapItem::updateAfterLinePropertiesChanged);
QObject::connect(this, &QDeclarativePolylineMapItem::referenceSurfaceChanged,
this, [this]() { m_d->onGeoGeometryChanged(); });
}
QDeclarativePolylineMapItem::~QDeclarativePolylineMapItem()
{
}
/*!
\internal
*/
void QDeclarativePolylineMapItem::updateAfterLinePropertiesChanged()
{
m_d->onLinePropertiesChanged();
}
/*!
\internal
*/
void QDeclarativePolylineMapItem::setMap(QDeclarativeGeoMap *quickMap, QGeoMap *map)
{
QDeclarativeGeoMapItemBase::setMap(quickMap,map);
if (map)
m_d->onMapSet();
}
/*!
\qmlproperty list<coordinate> MapPolyline::path
This property holds the ordered list of coordinates which
define the polyline.
*/
QList<QGeoCoordinate> QDeclarativePolylineMapItem::path() const
{
return m_geopath.path();
}
void QDeclarativePolylineMapItem::setPath(const QList<QGeoCoordinate> &value)
{
setPathFromGeoList(value);
}
/*!
\qmlmethod void MapPolyline::setPath(geoPath path)
Sets the \a path using a geoPath type.
\since 5.10
\sa path
*/
void QDeclarativePolylineMapItem::setPath(const QGeoPath &path)
{
if (m_geopath.path() == path.path())
return;
m_geopath = QGeoPathEager(path);
m_d->onGeoGeometryChanged();
emit pathChanged();
}
/*!
\internal
*/
void QDeclarativePolylineMapItem::setPathFromGeoList(const QList<QGeoCoordinate> &path)
{
if (m_geopath.path() == path)
return;
m_geopath.setPath(path);
m_d->onGeoGeometryChanged();
emit pathChanged();
}
/*!
\qmlmethod int MapPolyline::pathLength()
Returns the number of coordinates of the polyline.
\since QtLocation 5.6
\sa path
*/
int QDeclarativePolylineMapItem::pathLength() const
{
return m_geopath.path().length();
}
/*!
\qmlmethod void MapPolyline::addCoordinate(coordinate)
Adds the specified \a coordinate to the end of the path.
\sa insertCoordinate, removeCoordinate, path
*/
void QDeclarativePolylineMapItem::addCoordinate(const QGeoCoordinate &coordinate)
{
if (!coordinate.isValid())
return;
m_geopath.addCoordinate(coordinate);
m_d->onGeoGeometryUpdated();
emit pathChanged();
}
/*!
\qmlmethod void MapPolyline::insertCoordinate(index, coordinate)
Inserts a \a coordinate to the path at the given \a index.
\since QtLocation 5.6
\sa addCoordinate, removeCoordinate, path
*/
void QDeclarativePolylineMapItem::insertCoordinate(int index, const QGeoCoordinate &coordinate)
{
if (index < 0 || index > m_geopath.path().length())
return;
m_geopath.insertCoordinate(index, coordinate);
m_d->onGeoGeometryChanged();
emit pathChanged();
}
/*!
\qmlmethod void MapPolyline::replaceCoordinate(index, coordinate)
Replaces the coordinate in the current path at the given \a index
with the new \a coordinate.
\since QtLocation 5.6
\sa addCoordinate, insertCoordinate, removeCoordinate, path
*/
void QDeclarativePolylineMapItem::replaceCoordinate(int index, const QGeoCoordinate &coordinate)
{
if (index < 0 || index >= m_geopath.path().length())
return;
m_geopath.replaceCoordinate(index, coordinate);
m_d->onGeoGeometryChanged();
emit pathChanged();
}
/*!
\qmlmethod coordinate MapPolyline::coordinateAt(index)
Gets the coordinate of the polyline at the given \a index.
If the index is outside the path's bounds then an invalid
coordinate is returned.
\since QtLocation 5.6
*/
QGeoCoordinate QDeclarativePolylineMapItem::coordinateAt(int index) const
{
if (index < 0 || index >= m_geopath.path().length())
return QGeoCoordinate();
return m_geopath.coordinateAt(index);
}
/*!
\qmlmethod coordinate MapPolyline::containsCoordinate(coordinate)
Returns true if the given \a coordinate is part of the path.
\since QtLocation 5.6
*/
bool QDeclarativePolylineMapItem::containsCoordinate(const QGeoCoordinate &coordinate)
{
return m_geopath.containsCoordinate(coordinate);
}
/*!
\qmlmethod void MapPolyline::removeCoordinate(coordinate)
Removes \a coordinate from the path. If there are multiple instances of the
same coordinate, the one added last is removed.
If \a coordinate is not in the path this method does nothing.
\sa addCoordinate, insertCoordinate, path
*/
void QDeclarativePolylineMapItem::removeCoordinate(const QGeoCoordinate &coordinate)
{
int length = m_geopath.path().length();
m_geopath.removeCoordinate(coordinate);
if (m_geopath.path().length() == length)
return;
m_d->onGeoGeometryChanged();
emit pathChanged();
}
/*!
\qmlmethod void MapPolyline::removeCoordinate(index)
Removes a coordinate from the path at the given \a index.
If \a index is invalid then this method does nothing.
\since QtLocation 5.6
\sa addCoordinate, insertCoordinate, path
*/
void QDeclarativePolylineMapItem::removeCoordinate(int index)
{
if (index < 0 || index >= m_geopath.path().length())
return;
m_geopath.removeCoordinate(index);
m_d->onGeoGeometryChanged();
emit pathChanged();
}
/*!
\qmlpropertygroup Location::MapPolyline::line
\qmlproperty int MapPolyline::line.width
\qmlproperty color MapPolyline::line.color
This property is part of the line property group. The line
property group holds the width and color used to draw the line.
The width is in pixels and is independent of the zoom level of the map.
The default values correspond to a black border with a width of 1 pixel.
For no line, use a width of 0 or a transparent color.
*/
QDeclarativeMapLineProperties *QDeclarativePolylineMapItem::line()
{
return &m_line;
}
/*!
\internal
*/
void QDeclarativePolylineMapItem::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
{
if (newGeometry.topLeft() == oldGeometry.topLeft() || !map() || !m_geopath.isValid() || m_updatingGeometry) {
QDeclarativeGeoMapItemBase::geometryChange(newGeometry, oldGeometry);
return;
}
// TODO: change the algorithm to preserve the distances and size!
QGeoCoordinate newCenter = map()->geoProjection().itemPositionToCoordinate(QDoubleVector2D(newGeometry.center()), false);
QGeoCoordinate oldCenter = map()->geoProjection().itemPositionToCoordinate(QDoubleVector2D(oldGeometry.center()), false);
if (!newCenter.isValid() || !oldCenter.isValid())
return;
double offsetLongi = newCenter.longitude() - oldCenter.longitude();
double offsetLati = newCenter.latitude() - oldCenter.latitude();
if (offsetLati == 0.0 && offsetLongi == 0.0)
return;
m_geopath.translate(offsetLati, offsetLongi);
m_d->onGeoGeometryChanged();
emit pathChanged();
// Not calling QDeclarativeGeoMapItemBase::geometryChange() as it will be called from a nested
// call to this function.
}
/*!
\internal
*/
void QDeclarativePolylineMapItem::afterViewportChanged(const QGeoMapViewportChangeEvent &event)
{
if (event.mapSize.isEmpty())
return;
m_d->afterViewportChanged();
}
/*!
\internal
*/
void QDeclarativePolylineMapItem::updatePolish()
{
if (!map() || map()->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
return;
m_d->updatePolish();
}
/*!
\internal
*/
QSGNode *QDeclarativePolylineMapItem::updateMapItemPaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
{
return m_d->updateMapItemPaintNode(oldNode, data);
}
bool QDeclarativePolylineMapItem::contains(const QPointF &point) const
{
return m_d->contains(point);
}
const QGeoShape &QDeclarativePolylineMapItem::geoShape() const
{
return m_geopath;
}
void QDeclarativePolylineMapItem::setGeoShape(const QGeoShape &shape)
{
const QGeoPath geopath(shape); // if shape isn't a path, path will be created as a default-constructed path
setPath(geopath);
}
//////////////////////////////////////////////////////////////////////
QT_END_NAMESPACE