qt-everywhere-src-5.14.1/qtlocation/src/location/maps/qgeomap.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2015 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$
 **
 ****************************************************************************/

 #include "qgeomap_p.h"
 #include "qgeomap_p_p.h"
 #include "qgeocameracapabilities_p.h"
 #include "qgeomappingmanagerengine_p.h"
 #include "qdeclarativegeomapitembase_p.h"
 #include "qgeomapobject_p.h"
 #include "qgeomapobject_p_p.h"
 #include <QDebug>
 #include <QRectF>

 QT_BEGIN_NAMESPACE

 QGeoMap::QGeoMap(QGeoMapPrivate &dd, QObject *parent)
     : QObject(dd,parent)
 {
 }

 QGeoMap::~QGeoMap()
 {
     Q_D(QGeoMap);
     clearParameters();
     for (QGeoMapObject *p : d->mapObjects())
         p->setMap(nullptr); // forces replacing pimpls with the default ones.
 }

 void QGeoMap::setViewportSize(const QSize& size)
 {
     Q_D(QGeoMap);
     if (size == d->m_viewportSize)
         return;
     d->m_viewportSize = size;
     d->m_geoProjection->setViewportSize(size);
     d->changeViewportSize(size);
 }

 QSize QGeoMap::viewportSize() const
 {
     Q_D(const QGeoMap);
     return d->m_viewportSize;
 }

 int QGeoMap::viewportWidth() const
 {
     Q_D(const QGeoMap);
     return d->m_viewportSize.width();
 }

 int QGeoMap::viewportHeight() const
 {
     Q_D(const QGeoMap);
     return d->m_viewportSize.height();
 }

 void QGeoMap::setCameraData(const QGeoCameraData &cameraData)
 {
     Q_D(QGeoMap);
     if (cameraData == d->m_cameraData)
         return;
     d->m_cameraData = cameraData;
     d->m_geoProjection->setCameraData(cameraData, false);
     d->changeCameraData(cameraData);
     emit cameraDataChanged(d->m_cameraData);
 }

 void QGeoMap::setCameraCapabilities(const QGeoCameraCapabilities &cameraCapabilities)
 {
     Q_D(QGeoMap);
     d->setCameraCapabilities(cameraCapabilities);
 }

 bool QGeoMap::handleEvent(QEvent *event)
 {
     Q_UNUSED(event);
     return false;
 }

 bool QGeoMap::setBearing(qreal bearing, const QGeoCoordinate &coordinate) //FIXME visibleArea
 {
     Q_D(QGeoMap);
     bool res = d->m_geoProjection->setBearing(bearing, coordinate);
     if (!res)
         return false;

     setCameraData(geoProjection().cameraData());
     return true;
 }

 bool QGeoMap::anchorCoordinateToPoint(const QGeoCoordinate &coordinate, const QPointF &anchorPoint)
 {
     Q_D(QGeoMap);
     QGeoCoordinate newCenter = geoProjection().anchorCoordinateToPoint(coordinate, anchorPoint);
     newCenter.setLatitude(qBound(d->m_minimumViewportLatitude, newCenter.latitude(), d->m_maximumViewportLatitude));
     QGeoCameraData data = cameraData();
     if (data.center() != newCenter) {
         data.setCenter(newCenter);
         setCameraData(data);
         return true;
     }
     return false;
 }

 bool QGeoMap::fitViewportToGeoRectangle(const QGeoRectangle &rectangle, const QMargins &borders)
 {
     Q_UNUSED(rectangle);
     Q_UNUSED(borders);
     return false;
 }

 QGeoShape QGeoMap::visibleRegion() const
 {
     return geoProjection().visibleRegion();
 }

 const QGeoCameraData &QGeoMap::cameraData() const
 {
     Q_D(const QGeoMap);
     return d->m_cameraData;
 }

 void QGeoMap::setActiveMapType(const QGeoMapType type)
 {
     Q_D(QGeoMap);
     if (type == d->m_activeMapType)
         return;
     d->m_activeMapType = type;
     d->setCameraCapabilities(d->m_engine->cameraCapabilities(type.mapId())); // emits
     d->changeActiveMapType(type);
     emit activeMapTypeChanged();
 }

 const QGeoMapType QGeoMap::activeMapType() const
 {
     Q_D(const QGeoMap);
     return d->m_activeMapType;
 }

 double QGeoMap::minimumZoom() const
 {
     Q_D(const QGeoMap);
     return d->m_geoProjection->minimumZoom();
 }

 double QGeoMap::maximumCenterLatitudeAtZoom(const QGeoCameraData &cameraData) const
 {
     Q_D(const QGeoMap);
     return d->maximumCenterLatitudeAtZoom(cameraData);
 }

 double QGeoMap::minimumCenterLatitudeAtZoom(const QGeoCameraData &cameraData) const
 {
     Q_D(const QGeoMap);
     return d->minimumCenterLatitudeAtZoom(cameraData);
 }

 double QGeoMap::mapWidth() const
 {
     Q_D(const QGeoMap);
     return d->mapWidth();
 }

 double QGeoMap::mapHeight() const
 {
     Q_D(const QGeoMap);
     return d->mapHeight();
 }

 const QGeoProjection &QGeoMap::geoProjection() const
 {
     Q_D(const QGeoMap);
     return *(d->m_geoProjection);
 }

 QGeoCameraCapabilities QGeoMap::cameraCapabilities() const
 {
     Q_D(const QGeoMap);
     return d->m_cameraCapabilities;
 }

 QGeoMap::Capabilities QGeoMap::capabilities() const
 {
     return Capabilities(QGeoMap::SupportsNothing);
 }

 void QGeoMap::prefetchData()
 {

 }

 void QGeoMap::clearData()
 {

 }

 void QGeoMap::addParameter(QGeoMapParameter *param)
 {
     Q_D(QGeoMap);
     if (param && !d->m_mapParameters.contains(param)) {
         d->m_mapParameters.append(param);
         d->addParameter(param);
     }
 }

 void QGeoMap::removeParameter(QGeoMapParameter *param)
 {
     Q_D(QGeoMap);
     if (param && d->m_mapParameters.contains(param)) {
         d->removeParameter(param);
         d->m_mapParameters.removeOne(param);
     }
 }

 void QGeoMap::clearParameters()
 {
     Q_D(QGeoMap);
     for (QGeoMapParameter *p : qAsConst(d->m_mapParameters))
         d->removeParameter(p);
     d->m_mapParameters.clear();
 }

 QGeoMap::ItemTypes QGeoMap::supportedMapItemTypes() const
 {
     Q_D(const QGeoMap);
     return d->supportedMapItemTypes();
 }

 void QGeoMap::addMapItem(QDeclarativeGeoMapItemBase *item)
 {
     Q_D(QGeoMap);
     if (item && !d->m_mapItems.contains(item) && d->supportedMapItemTypes() & item->itemType()) {
         d->m_mapItems.append(item);
         d->addMapItem(item);
     }
 }

 void QGeoMap::removeMapItem(QDeclarativeGeoMapItemBase *item)
 {
     Q_D(QGeoMap);
     if (item && d->m_mapItems.contains(item)) {
         d->removeMapItem(item);
         d->m_mapItems.removeOne(item);
     }
 }

 void QGeoMap::clearMapItems()
 {
     Q_D(QGeoMap);
     for (QDeclarativeGeoMapItemBase *p : d->m_mapItems)
         d->removeMapItem(p);
     d->m_mapItems.clear();
 }

 /*!
     Fills obj with a backend-specific pimpl.
 */
 bool QGeoMap::createMapObjectImplementation(QGeoMapObject *obj)
 {
     Q_D(QGeoMap);
     QExplicitlySharedDataPointer<QGeoMapObjectPrivate> pimpl =
             QExplicitlySharedDataPointer<QGeoMapObjectPrivate>(d->createMapObjectImplementation(obj));
     if (pimpl.constData())
         return obj->setImplementation(pimpl);
     return false;
 }

 /*!
     To be called in ~QGeoMapObjectPrivate overrides, if needed
 */
 void QGeoMap::removeMapObject(QGeoMapObject * /*obj*/)
 {
 }

 QList<QObject *> QGeoMap::mapObjectsAt(const QGeoCoordinate &/*coordinate*/) const
 {
     return QList<QObject *>();
 }

 void QGeoMap::setVisibleArea(const QRectF &visibleArea)
 {
     Q_D(QGeoMap);
     const QRectF &va = d->visibleArea();
     d->setVisibleArea(visibleArea);
     if (va != d->visibleArea())
         emit visibleAreaChanged();
 }

 QRectF QGeoMap::visibleArea() const
 {
     Q_D(const QGeoMap);
     return d->visibleArea();
 }

 QList<QGeoMapObject *> QGeoMap::mapObjects() const
 {
     Q_D(const QGeoMap);
     return d->mapObjects();
 }

 QString QGeoMap::copyrightsStyleSheet() const
 {
     return QStringLiteral("#copyright-root { background: rgba(255, 255, 255, 128) }");
 }

 void QGeoMap::setAcceptedGestures(bool pan, bool flick, bool pinch, bool rotate, bool tilt)
 {
     Q_UNUSED(pan);
     Q_UNUSED(flick);
     Q_UNUSED(pinch);
     Q_UNUSED(rotate);
     Q_UNUSED(tilt);
 }

 void QGeoMap::setCopyrightVisible(bool visible)
 {
     Q_D(QGeoMap);
     if (d->m_copyrightVisible == visible)
         return;

     d->m_copyrightVisible = visible;
 }

 QGeoMapPrivate::QGeoMapPrivate(QGeoMappingManagerEngine *engine, QGeoProjection *geoProjection)
     : QObjectPrivate(),
       m_geoProjection(geoProjection),
       m_engine(engine),
       m_activeMapType(QGeoMapType())
 {
     // Setting the default camera caps without emitting anything
     if (engine)
         m_cameraCapabilities = m_engine->cameraCapabilities(m_activeMapType.mapId());
 }

 QGeoMapPrivate::~QGeoMapPrivate()
 {
     if (m_geoProjection)
         delete m_geoProjection;
 }

 void QGeoMapPrivate::setCameraCapabilities(const QGeoCameraCapabilities &cameraCapabilities)
 {
     Q_Q(QGeoMap);
     if (m_cameraCapabilities == cameraCapabilities)
         return;
     QGeoCameraCapabilities oldCaps = m_cameraCapabilities;
     m_cameraCapabilities = cameraCapabilities;
     emit q->cameraCapabilitiesChanged(oldCaps);
 }

 const QGeoCameraCapabilities &QGeoMapPrivate::cameraCapabilities() const
 {
     return m_cameraCapabilities;
 }

 const QGeoMapPrivate *QGeoMapPrivate::get(const QGeoMap &map)
 {
     return map.d_func();
 }

 void QGeoMapPrivate::addParameter(QGeoMapParameter *param)
 {
     Q_UNUSED(param);
 }

 void QGeoMapPrivate::removeParameter(QGeoMapParameter *param)
 {
     Q_UNUSED(param);
 }

 QGeoMap::ItemTypes QGeoMapPrivate::supportedMapItemTypes() const
 {
     return QGeoMap::NoItem;
 }

 void QGeoMapPrivate::addMapItem(QDeclarativeGeoMapItemBase *item)
 {
     Q_UNUSED(item);
 }

 void QGeoMapPrivate::removeMapItem(QDeclarativeGeoMapItemBase *item)
 {
     Q_UNUSED(item);
 }

 QGeoMapObjectPrivate *QGeoMapPrivate::createMapObjectImplementation(QGeoMapObject *obj)
 {
     Q_UNUSED(obj);
     return nullptr;
 }

 QList<QGeoMapObject *> QGeoMapPrivate::mapObjects() const
 {
     return QList<QGeoMapObject *>();
 }

 double QGeoMapPrivate::mapWidth() const
 {
     if (m_geoProjection->projectionType() == QGeoProjection::ProjectionWebMercator)
         return static_cast<const QGeoProjectionWebMercator *>(m_geoProjection)->mapWidth();
     return 0; // override this for maps supporting other projections
 }

 double QGeoMapPrivate::mapHeight() const
 {
     if (m_geoProjection->projectionType() == QGeoProjection::ProjectionWebMercator)
         return static_cast<const QGeoProjectionWebMercator *>(m_geoProjection)->mapHeight();
     return 0; // override this for maps supporting other projections
 }

 void QGeoMapPrivate::setCopyrightVisible(bool visible)
 {
     m_copyrightVisible = visible;
 }

 bool QGeoMapPrivate::copyrightVisible() const
 {
     return m_copyrightVisible;
 }

 double QGeoMapPrivate::maximumCenterLatitudeAtZoom(const QGeoCameraData &cameraData) const
 {
     m_maximumViewportLatitude = m_geoProjection->maximumCenterLatitudeAtZoom(cameraData);
     return m_maximumViewportLatitude;
 }

 double QGeoMapPrivate::minimumCenterLatitudeAtZoom(const QGeoCameraData &cameraData) const
 {
     m_minimumViewportLatitude = m_geoProjection->minimumCenterLatitudeAtZoom(cameraData);
     return m_minimumViewportLatitude;
 }

 void QGeoMapPrivate::setVisibleArea(const QRectF &/*visibleArea*/)
 {

 }

 QRectF QGeoMapPrivate::visibleArea() const
 {
     return QRectF();
 }

 QRectF QGeoMapPrivate::clampVisibleArea(const QRectF &visibleArea) const
 {
     qreal xp = qMin<qreal>(visibleArea.x(), qMax(m_viewportSize.width() - 1, 0));
     qreal yp = qMin<qreal>(visibleArea.y(), qMax(m_viewportSize.height() - 1, 0));
     qreal w = qMin<qreal>(visibleArea.width(), qMax<qreal>(m_viewportSize.width() - xp, 0));
     qreal h = qMin<qreal>(visibleArea.height(), qMax<qreal>(m_viewportSize.height() - yp, 0));
     return QRectF(xp, yp, w, h);
 }

 QT_END_NAMESPACE
	/****************************************************************************
	**
	** Copyright (C) 2015 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$
	**
	****************************************************************************/

	#include "qgeomap_p.h"
	#include "qgeomap_p_p.h"
	#include "qgeocameracapabilities_p.h"
	#include "qgeomappingmanagerengine_p.h"
	#include "qdeclarativegeomapitembase_p.h"
	#include "qgeomapobject_p.h"
	#include "qgeomapobject_p_p.h"
	#include <QDebug>
	#include <QRectF>

	QT_BEGIN_NAMESPACE

	QGeoMap::QGeoMap(QGeoMapPrivate &dd, QObject *parent)
	: QObject(dd,parent)
	{
	}

	QGeoMap::~QGeoMap()
	{
	Q_D(QGeoMap);
	clearParameters();
	for (QGeoMapObject *p : d->mapObjects())
	p->setMap(nullptr); // forces replacing pimpls with the default ones.
	}

	void QGeoMap::setViewportSize(const QSize& size)
	{
	Q_D(QGeoMap);
	if (size == d->m_viewportSize)
	return;
	d->m_viewportSize = size;
	d->m_geoProjection->setViewportSize(size);
	d->changeViewportSize(size);
	}

	QSize QGeoMap::viewportSize() const
	{
	Q_D(const QGeoMap);
	return d->m_viewportSize;
	}

	int QGeoMap::viewportWidth() const
	{
	Q_D(const QGeoMap);
	return d->m_viewportSize.width();
	}

	int QGeoMap::viewportHeight() const
	{
	Q_D(const QGeoMap);
	return d->m_viewportSize.height();
	}

	void QGeoMap::setCameraData(const QGeoCameraData &cameraData)
	{
	Q_D(QGeoMap);
	if (cameraData == d->m_cameraData)
	return;
	d->m_cameraData = cameraData;
	d->m_geoProjection->setCameraData(cameraData, false);
	d->changeCameraData(cameraData);
	emit cameraDataChanged(d->m_cameraData);
	}

	void QGeoMap::setCameraCapabilities(const QGeoCameraCapabilities &cameraCapabilities)
	{
	Q_D(QGeoMap);
	d->setCameraCapabilities(cameraCapabilities);
	}

	bool QGeoMap::handleEvent(QEvent *event)
	{
	Q_UNUSED(event);
	return false;
	}

	bool QGeoMap::setBearing(qreal bearing, const QGeoCoordinate &coordinate) //FIXME visibleArea
	{
	Q_D(QGeoMap);
	bool res = d->m_geoProjection->setBearing(bearing, coordinate);
	if (!res)
	return false;

	setCameraData(geoProjection().cameraData());
	return true;
	}

	bool QGeoMap::anchorCoordinateToPoint(const QGeoCoordinate &coordinate, const QPointF &anchorPoint)
	{
	Q_D(QGeoMap);
	QGeoCoordinate newCenter = geoProjection().anchorCoordinateToPoint(coordinate, anchorPoint);
	newCenter.setLatitude(qBound(d->m_minimumViewportLatitude, newCenter.latitude(), d->m_maximumViewportLatitude));
	QGeoCameraData data = cameraData();
	if (data.center() != newCenter) {
	data.setCenter(newCenter);
	setCameraData(data);
	return true;
	}
	return false;
	}

	bool QGeoMap::fitViewportToGeoRectangle(const QGeoRectangle &rectangle, const QMargins &borders)
	{
	Q_UNUSED(rectangle);
	Q_UNUSED(borders);
	return false;
	}

	QGeoShape QGeoMap::visibleRegion() const
	{
	return geoProjection().visibleRegion();
	}

	const QGeoCameraData &QGeoMap::cameraData() const
	{
	Q_D(const QGeoMap);
	return d->m_cameraData;
	}

	void QGeoMap::setActiveMapType(const QGeoMapType type)
	{
	Q_D(QGeoMap);
	if (type == d->m_activeMapType)
	return;
	d->m_activeMapType = type;
	d->setCameraCapabilities(d->m_engine->cameraCapabilities(type.mapId())); // emits
	d->changeActiveMapType(type);
	emit activeMapTypeChanged();
	}

	const QGeoMapType QGeoMap::activeMapType() const
	{
	Q_D(const QGeoMap);
	return d->m_activeMapType;
	}

	double QGeoMap::minimumZoom() const
	{
	Q_D(const QGeoMap);
	return d->m_geoProjection->minimumZoom();
	}

	double QGeoMap::maximumCenterLatitudeAtZoom(const QGeoCameraData &cameraData) const
	{
	Q_D(const QGeoMap);
	return d->maximumCenterLatitudeAtZoom(cameraData);
	}

	double QGeoMap::minimumCenterLatitudeAtZoom(const QGeoCameraData &cameraData) const
	{
	Q_D(const QGeoMap);
	return d->minimumCenterLatitudeAtZoom(cameraData);
	}

	double QGeoMap::mapWidth() const
	{
	Q_D(const QGeoMap);
	return d->mapWidth();
	}

	double QGeoMap::mapHeight() const
	{
	Q_D(const QGeoMap);
	return d->mapHeight();
	}

	const QGeoProjection &QGeoMap::geoProjection() const
	{
	Q_D(const QGeoMap);
	return *(d->m_geoProjection);
	}

	QGeoCameraCapabilities QGeoMap::cameraCapabilities() const
	{
	Q_D(const QGeoMap);
	return d->m_cameraCapabilities;
	}

	QGeoMap::Capabilities QGeoMap::capabilities() const
	{
	return Capabilities(QGeoMap::SupportsNothing);
	}

	void QGeoMap::prefetchData()
	{

	}

	void QGeoMap::clearData()
	{

	}

	void QGeoMap::addParameter(QGeoMapParameter *param)
	{
	Q_D(QGeoMap);
	if (param && !d->m_mapParameters.contains(param)) {
	d->m_mapParameters.append(param);
	d->addParameter(param);
	}
	}

	void QGeoMap::removeParameter(QGeoMapParameter *param)
	{
	Q_D(QGeoMap);
	if (param && d->m_mapParameters.contains(param)) {
	d->removeParameter(param);
	d->m_mapParameters.removeOne(param);
	}
	}

	void QGeoMap::clearParameters()
	{
	Q_D(QGeoMap);
	for (QGeoMapParameter *p : qAsConst(d->m_mapParameters))
	d->removeParameter(p);
	d->m_mapParameters.clear();
	}

	QGeoMap::ItemTypes QGeoMap::supportedMapItemTypes() const
	{
	Q_D(const QGeoMap);
	return d->supportedMapItemTypes();
	}

	void QGeoMap::addMapItem(QDeclarativeGeoMapItemBase *item)
	{
	Q_D(QGeoMap);
	if (item && !d->m_mapItems.contains(item) && d->supportedMapItemTypes() & item->itemType()) {
	d->m_mapItems.append(item);
	d->addMapItem(item);
	}
	}

	void QGeoMap::removeMapItem(QDeclarativeGeoMapItemBase *item)
	{
	Q_D(QGeoMap);
	if (item && d->m_mapItems.contains(item)) {
	d->removeMapItem(item);
	d->m_mapItems.removeOne(item);
	}
	}

	void QGeoMap::clearMapItems()
	{
	Q_D(QGeoMap);
	for (QDeclarativeGeoMapItemBase *p : d->m_mapItems)
	d->removeMapItem(p);
	d->m_mapItems.clear();
	}

	/*!
	Fills obj with a backend-specific pimpl.
	*/
	bool QGeoMap::createMapObjectImplementation(QGeoMapObject *obj)
	{
	Q_D(QGeoMap);
	QExplicitlySharedDataPointer<QGeoMapObjectPrivate> pimpl =
	QExplicitlySharedDataPointer<QGeoMapObjectPrivate>(d->createMapObjectImplementation(obj));
	if (pimpl.constData())
	return obj->setImplementation(pimpl);
	return false;
	}

	/*!
	To be called in ~QGeoMapObjectPrivate overrides, if needed
	*/
	void QGeoMap::removeMapObject(QGeoMapObject * /obj/)
	{
	}

	QList<QObject > QGeoMap::mapObjectsAt(const QGeoCoordinate &/coordinate*/) const
	{
	return QList<QObject *>();
	}

	void QGeoMap::setVisibleArea(const QRectF &visibleArea)
	{
	Q_D(QGeoMap);
	const QRectF &va = d->visibleArea();
	d->setVisibleArea(visibleArea);
	if (va != d->visibleArea())
	emit visibleAreaChanged();
	}

	QRectF QGeoMap::visibleArea() const
	{
	Q_D(const QGeoMap);
	return d->visibleArea();
	}

	QList<QGeoMapObject *> QGeoMap::mapObjects() const
	{
	Q_D(const QGeoMap);
	return d->mapObjects();
	}

	QString QGeoMap::copyrightsStyleSheet() const
	{
	return QStringLiteral("#copyright-root { background: rgba(255, 255, 255, 128) }");
	}

	void QGeoMap::setAcceptedGestures(bool pan, bool flick, bool pinch, bool rotate, bool tilt)
	{
	Q_UNUSED(pan);
	Q_UNUSED(flick);
	Q_UNUSED(pinch);
	Q_UNUSED(rotate);
	Q_UNUSED(tilt);
	}

	void QGeoMap::setCopyrightVisible(bool visible)
	{
	Q_D(QGeoMap);
	if (d->m_copyrightVisible == visible)
	return;

	d->m_copyrightVisible = visible;
	}

	QGeoMapPrivate::QGeoMapPrivate(QGeoMappingManagerEngine engine, QGeoProjection geoProjection)
	: QObjectPrivate(),
	m_geoProjection(geoProjection),
	m_engine(engine),
	m_activeMapType(QGeoMapType())
	{
	// Setting the default camera caps without emitting anything
	if (engine)
	m_cameraCapabilities = m_engine->cameraCapabilities(m_activeMapType.mapId());
	}

	QGeoMapPrivate::~QGeoMapPrivate()
	{
	if (m_geoProjection)
	delete m_geoProjection;
	}

	void QGeoMapPrivate::setCameraCapabilities(const QGeoCameraCapabilities &cameraCapabilities)
	{
	Q_Q(QGeoMap);
	if (m_cameraCapabilities == cameraCapabilities)
	return;
	QGeoCameraCapabilities oldCaps = m_cameraCapabilities;
	m_cameraCapabilities = cameraCapabilities;
	emit q->cameraCapabilitiesChanged(oldCaps);
	}

	const QGeoCameraCapabilities &QGeoMapPrivate::cameraCapabilities() const
	{
	return m_cameraCapabilities;
	}

	const QGeoMapPrivate *QGeoMapPrivate::get(const QGeoMap &map)
	{
	return map.d_func();
	}

	void QGeoMapPrivate::addParameter(QGeoMapParameter *param)
	{
	Q_UNUSED(param);
	}

	void QGeoMapPrivate::removeParameter(QGeoMapParameter *param)
	{
	Q_UNUSED(param);
	}

	QGeoMap::ItemTypes QGeoMapPrivate::supportedMapItemTypes() const
	{
	return QGeoMap::NoItem;
	}

	void QGeoMapPrivate::addMapItem(QDeclarativeGeoMapItemBase *item)
	{
	Q_UNUSED(item);
	}

	void QGeoMapPrivate::removeMapItem(QDeclarativeGeoMapItemBase *item)
	{
	Q_UNUSED(item);
	}

	QGeoMapObjectPrivate QGeoMapPrivate::createMapObjectImplementation(QGeoMapObject obj)
	{
	Q_UNUSED(obj);
	return nullptr;
	}

	QList<QGeoMapObject *> QGeoMapPrivate::mapObjects() const
	{
	return QList<QGeoMapObject *>();
	}

	double QGeoMapPrivate::mapWidth() const
	{
	if (m_geoProjection->projectionType() == QGeoProjection::ProjectionWebMercator)
	return static_cast<const QGeoProjectionWebMercator *>(m_geoProjection)->mapWidth();
	return 0; // override this for maps supporting other projections
	}

	double QGeoMapPrivate::mapHeight() const
	{
	if (m_geoProjection->projectionType() == QGeoProjection::ProjectionWebMercator)
	return static_cast<const QGeoProjectionWebMercator *>(m_geoProjection)->mapHeight();
	return 0; // override this for maps supporting other projections
	}

	void QGeoMapPrivate::setCopyrightVisible(bool visible)
	{
	m_copyrightVisible = visible;
	}

	bool QGeoMapPrivate::copyrightVisible() const
	{
	return m_copyrightVisible;
	}

	double QGeoMapPrivate::maximumCenterLatitudeAtZoom(const QGeoCameraData &cameraData) const
	{
	m_maximumViewportLatitude = m_geoProjection->maximumCenterLatitudeAtZoom(cameraData);
	return m_maximumViewportLatitude;
	}

	double QGeoMapPrivate::minimumCenterLatitudeAtZoom(const QGeoCameraData &cameraData) const
	{
	m_minimumViewportLatitude = m_geoProjection->minimumCenterLatitudeAtZoom(cameraData);
	return m_minimumViewportLatitude;
	}

	void QGeoMapPrivate::setVisibleArea(const QRectF &/visibleArea/)
	{

	}

	QRectF QGeoMapPrivate::visibleArea() const
	{
	return QRectF();
	}

	QRectF QGeoMapPrivate::clampVisibleArea(const QRectF &visibleArea) const
	{
	qreal xp = qMin<qreal>(visibleArea.x(), qMax(m_viewportSize.width() - 1, 0));
	qreal yp = qMin<qreal>(visibleArea.y(), qMax(m_viewportSize.height() - 1, 0));
	qreal w = qMin<qreal>(visibleArea.width(), qMax<qreal>(m_viewportSize.width() - xp, 0));
	qreal h = qMin<qreal>(visibleArea.height(), qMax<qreal>(m_viewportSize.height() - yp, 0));
	return QRectF(xp, yp, w, h);
	}

	QT_END_NAMESPACE