qdeclarativegeomapquickitem.cpp

Go to the documentation of this file.

// 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
 
#include "qdeclarativegeomapquickitem_p.h"
 
#include <QtCore/QScopedValueRollback>
#include <QtQml/qqmlinfo.h>
#include <QtQuick/QSGOpacityNode>
#include <QtPositioning/private/qdoublevector2d_p.h>
#include <QtQuick/private/qquickmousearea_p.h>
#include <QtLocation/private/qgeomap_p.h>
#include <QtLocation/private/qgeoprojection_p.h>
#include <QDebug>
#include <cmath>
 
QT_BEGIN_NAMESPACE
 
QMapQuickItemMatrix4x4::QMapQuickItemMatrix4x4(QObject *parent) : QQuickTransform(parent) { }
 
void QMapQuickItemMatrix4x4::setMatrix(const QMatrix4x4 &matrix)
{
    if (m_matrix == matrix)
        return;
    m_matrix = matrix;
    update();
}
 
void QMapQuickItemMatrix4x4::applyTo(QMatrix4x4 *matrix) const
{
    *matrix *= m_matrix;
}
 
 
QDeclarativeGeoMapQuickItem::QDeclarativeGeoMapQuickItem(QQuickItem *parent)
    : QDeclarativeGeoMapItemBase(parent)
{
    m_itemType = QGeoMap::MapQuickItem;
    setFlag(ItemHasContents, true);
    opacityContainer_ = new QQuickItem(this);
    opacityContainer_->setParentItem(this);
    opacityContainer_->setFlag(ItemHasContents, true);
}
 
QDeclarativeGeoMapQuickItem::~QDeclarativeGeoMapQuickItem() {}
 
void QDeclarativeGeoMapQuickItem::setCoordinate(const QGeoCoordinate &coordinate)
{
    if (coordinate_ == coordinate)
        return;
 
    coordinate_ = coordinate;
    geoshape_.setTopLeft(coordinate_);
    geoshape_.setBottomRight(coordinate_);
    // TODO: Handle zoomLevel != 0.0
    polishAndUpdate();
    emit coordinateChanged();
}
 
void QDeclarativeGeoMapQuickItem::setMap(QDeclarativeGeoMap *quickMap, QGeoMap *map)
{
    QDeclarativeGeoMapItemBase::setMap(quickMap,map);
    if (map && quickMap) {
        connect(map, &QGeoMap::cameraDataChanged,
                this, &QDeclarativeGeoMapQuickItem::polishAndUpdate);
        polishAndUpdate();
    }
}
 
void QDeclarativeGeoMapQuickItem::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
{
    if (!mapAndSourceItemSet_ || updatingGeometry_ ||
        newGeometry.topLeft() == oldGeometry.topLeft()) {
        QDeclarativeGeoMapItemBase::geometryChange(newGeometry, oldGeometry);
        return;
    }
 
    QGeoCoordinate newCoordinate = map()->geoProjection().
            itemPositionToCoordinate(QDoubleVector2D(x(), y()) + QDoubleVector2D(anchorPoint_), false);
 
    if (newCoordinate.isValid())
        setCoordinate(newCoordinate);
 
    // Not calling QDeclarativeGeoMapItemBase::geometryChange() as it will be called from a nested
    // call to this function.
}
 
QGeoCoordinate QDeclarativeGeoMapQuickItem::coordinate()
{
    return coordinate_;
}
 
void QDeclarativeGeoMapQuickItem::setSourceItem(QQuickItem *sourceItem)
{
    QQuickItem *item = qobject_cast<QQuickItem *>(sourceItem); // Workaround for QTBUG-72930
    if (sourceItem_.data() == item)
        return;
    sourceItem_ = item;
    polishAndUpdate();
    emit sourceItemChanged();
}
 
QQuickItem *QDeclarativeGeoMapQuickItem::sourceItem()
{
    return sourceItem_.data();
}
 
void QDeclarativeGeoMapQuickItem::afterChildrenChanged()
{
    const QList<QQuickItem *> kids = childItems();
    if (kids.size() > 0) {
        bool printedWarning = false;
        for (auto *i : kids) {
            if (i->flags() & QQuickItem::ItemHasContents
                    && !qobject_cast<QQuickMouseArea *>(i)
                    && sourceItem_.data() != i
                    && opacityContainer_ != i) {
                if (!printedWarning) {
                    qmlWarning(this) << "Use the sourceItem property for the contained item, direct children are not supported";
                    printedWarning = true;
                }
 
                qmlWarning(i) << "deleting this child";
                i->deleteLater();
            }
        }
    }
}
 
void QDeclarativeGeoMapQuickItem::setAnchorPoint(const QPointF &anchorPoint)
{
    if (anchorPoint == anchorPoint_)
        return;
    anchorPoint_ = anchorPoint;
    polishAndUpdate();
    emit anchorPointChanged();
}
 
QPointF QDeclarativeGeoMapQuickItem::anchorPoint() const
{
    return anchorPoint_;
}
 
void QDeclarativeGeoMapQuickItem::setZoomLevel(qreal zoomLevel)
{
    if (zoomLevel == zoomLevel_)
        return;
    zoomLevel_ = zoomLevel;
    // TODO: update geoshape_!
    polishAndUpdate();
    emit zoomLevelChanged();
}
 
qreal QDeclarativeGeoMapQuickItem::zoomLevel() const
{
    return zoomLevel_;
}
 
const QGeoShape &QDeclarativeGeoMapQuickItem::geoShape() const
{
    // TODO: return a QGeoRectangle representing the bounding geo rectangle of the quick item
    // when zoomLevel_ is != 0.0
    return geoshape_;
}
 
void QDeclarativeGeoMapQuickItem::setGeoShape(const QGeoShape &shape)
{
    if (shape == geoshape_)
        return;
 
    const QGeoRectangle rect = shape.boundingGeoRectangle();
    geoshape_ = rect;
    coordinate_ = rect.center();
 
    // TODO: Handle zoomLevel != 0.0
    polishAndUpdate();
    emit coordinateChanged();
 
}
 
void QDeclarativeGeoMapQuickItem::updatePolish()
{
    if (!quickMap() && sourceItem_) {
        mapAndSourceItemSet_ = false;
        sourceItem_.data()->setParentItem(0);
        return;
    }
 
    if (!quickMap() || !map() || !sourceItem_) {
        mapAndSourceItemSet_ = false;
        return;
    }
 
    if (!mapAndSourceItemSet_ && quickMap() && map() && sourceItem_) {
        mapAndSourceItemSet_ = true;
        sourceItem_.data()->setParentItem(opacityContainer_);
        sourceItem_.data()->setTransformOrigin(QQuickItem::TopLeft);
        connect(sourceItem_.data(), &QQuickItem::xChanged,
                this, &QDeclarativeGeoMapQuickItem::polishAndUpdate);
        connect(sourceItem_.data(), &QQuickItem::yChanged,
                this, &QDeclarativeGeoMapQuickItem::polishAndUpdate);
        connect(sourceItem_.data(), &QQuickItem::widthChanged,
                this, &QDeclarativeGeoMapQuickItem::polishAndUpdate);
        connect(sourceItem_.data(), &QQuickItem::heightChanged,
                this, &QDeclarativeGeoMapQuickItem::polishAndUpdate);
    }
 
    if (!coordinate_.isValid()) {
        opacityContainer_->setVisible(false);
        return;
    } else {
        opacityContainer_->setVisible(true);
    }
 
    QScopedValueRollback<bool> rollback(updatingGeometry_);
    updatingGeometry_ = true;
 
    opacityContainer_->setOpacity(zoomLevelOpacity());
 
    setWidth(sourceItem_.data()->width());
    setHeight(sourceItem_.data()->height());
    if (zoomLevel_ != 0.0 // zoom level initialized to 0.0. If it's different, it has been set explicitly.
            && map()->geoProjection().projectionType() == QGeoProjection::ProjectionWebMercator) { // Currently unsupported on any other projection
        const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(map()->geoProjection());
 
        if (!matrix_) {
            matrix_ = new QMapQuickItemMatrix4x4(this);
            matrix_->appendToItem(opacityContainer_);
        }
        matrix_->setMatrix(p.quickItemTransformation(coordinate(), anchorPoint_, zoomLevel_));
        setPosition(QPointF(0,0));
    } else {
        if (map()->geoProjection().projectionType() == QGeoProjection::ProjectionWebMercator) {
            const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(map()->geoProjection());
            if (map()->cameraData().tilt() > 0.0
                    && !p.isProjectable(p.geoToWrappedMapProjection(coordinate()))) {
                // if the coordinate is behind the camera, we use the transformation to get the item out of the way
                if (!matrix_) {
                    matrix_ = new QMapQuickItemMatrix4x4(this);
                    matrix_->appendToItem(opacityContainer_);
                }
                matrix_->setMatrix(p.quickItemTransformation(coordinate(), anchorPoint_, map()->cameraData().zoomLevel()));
                setPosition(QPointF(0,0));
            } else { // All good, rendering screen-aligned
                if (matrix_)
                    matrix_->setMatrix(QMatrix4x4());
                setPositionOnMap(coordinate(), anchorPoint_);
            }
        } else { // On other projections we can only currently test if coordinateToItemPosition returns a valid position
            if (map()->cameraData().tilt() > 0.0
                    && qIsNaN(map()->geoProjection().coordinateToItemPosition(coordinate(), false).x())) {
                opacityContainer_->setVisible(false);
            } else {
                if (matrix_)
                    matrix_->setMatrix(QMatrix4x4());
                setPositionOnMap(coordinate(), anchorPoint_);
            }
        }
    }
}
 
void QDeclarativeGeoMapQuickItem::afterViewportChanged(const QGeoMapViewportChangeEvent &event)
{
    Q_UNUSED(event);
    if (event.mapSize.width() <= 0 || event.mapSize.height() <= 0)
        return;
 
    polishAndUpdate();
}
 
qreal QDeclarativeGeoMapQuickItem::scaleFactor()
{
    qreal scale = 1.0;
    // use 1+x to avoid fuzzy compare against zero
    if (!qFuzzyCompare(1.0 + zoomLevel_, 1.0))
        scale = std::pow(0.5, zoomLevel_ - map()->cameraData().zoomLevel());
    return scale;
}
 
QT_END_NAMESPACE