/*!
Associates the QGeoMapData instance \a mapData with this map object.
This will create an appropriate QGeoMapObjectInfo instance for
this QGeoMapObject and will connect the appropriate signals to it
so that it can be kept up to date.
\since 1.1
*/
void QGeoMapObject::setMapData(QGeoMapData *mapData)
{
if (d_ptr->mapData == mapData)
return;
if (d_ptr->info) {
delete d_ptr->info;
d_ptr->info = 0;
}
d_ptr->mapData = mapData;
if (!d_ptr->mapData)
return;
d_ptr->info = mapData->createMapObjectInfo(this);
if (!d_ptr->info)
return;
connect(d_ptr->mapData,
SIGNAL(windowSizeChanged(QSizeF)),
d_ptr->info,
SLOT(windowSizeChanged(QSizeF)));
connect(d_ptr->mapData,
SIGNAL(zoomLevelChanged(qreal)),
d_ptr->info,
SLOT(zoomLevelChanged(qreal)));
connect(d_ptr->mapData,
SIGNAL(centerChanged(QGeoCoordinate)),
d_ptr->info,
SLOT(centerChanged(QGeoCoordinate)));
connect(this,
SIGNAL(zValueChanged(int)),
d_ptr->info,
SLOT(zValueChanged(int)));
connect(this,
SIGNAL(visibleChanged(bool)),
d_ptr->info,
SLOT(visibleChanged(bool)));
connect(this,
SIGNAL(selectedChanged(bool)),
d_ptr->info,
SLOT(selectedChanged(bool)));
connect(this,
SIGNAL(originChanged(QGeoCoordinate)),
d_ptr->info,
SLOT(originChanged(QGeoCoordinate)));
connect(this,
SIGNAL(transformTypeChanged(QGeoMapObject::TransformType)),
d_ptr->info,
SLOT(transformTypeChanged(QGeoMapObject::TransformType)));
connect(this,
SIGNAL(unitsChanged(QGeoMapObject::CoordinateUnit)),
d_ptr->info,
SLOT(unitsChanged(QGeoMapObject::CoordinateUnit)));
d_ptr->info->init();
}
/*!
\internal
*/
void QDeclarativeGeoMap::mapZoomLevelChanged(qreal zoom)
{
if (zoom == m_zoomLevel)
return;
m_zoomLevel = zoom;
emit zoomLevelChanged(m_zoomLevel);
}
DiagramToolBar::DiagramToolBar(DiagramView* diagram) : QToolBar("Diagram")
{
QList<QAction*> actions = diagram->actions();
mDiagram = diagram;
mDiagramZoomCombo = new QComboBox();
for(int i = 0; i < DiagramView::kZoomLevels.size(); i++)
mDiagramZoomCombo->addItem(QString::number(DiagramView::kZoomLevels[i] * 100) + "%");
mDiagramZoomCombo->setEditable(true);
connect(mDiagramZoomCombo, SIGNAL(currentIndexChanged(const QString&)), this, SLOT(updateDiagramZoomLevel(const QString&)));
connect(mDiagram, SIGNAL(zoomLevelChanged(qreal)), this, SLOT(updateDiagramZoomCombo(qreal)));
QFontMetrics fontMetrics(mDiagramZoomCombo->font());
mDiagramZoomCombo->setMinimumWidth(fontMetrics.width("8888.8888%") + 16);
setObjectName("DiagramToolBar");
addAction(actions[DiagramView::RotateAction]);
addAction(actions[DiagramView::RotateBackAction]);
addAction(actions[DiagramView::FlipAction]);
addSeparator();
addAction(actions[DiagramView::ZoomInAction]);
addWidget(mDiagramZoomCombo);
addAction(actions[DiagramView::ZoomOutAction]);
addAction(actions[DiagramView::ZoomFitAction]);
}
/*!
\internal
*/
void QDeclarativeGeoMap::mapZoomLevelChanged(qreal zoom)
{
if (zoom == zoomLevel_)
return;
zoomLevel_ = zoom;
emit zoomLevelChanged(zoomLevel_);
}
void DesktopInfo::setZoomLevel(double zoomLevel)
{
if (zoomLevel != s_zoomLevel)
{
s_zoomLevel = zoomLevel;
emit zoomLevelChanged(zoomLevel);
}
}
void QgsLayoutView::scaleSafe( double scale )
{
double currentScale = transform().m11();
scale *= currentScale;
scale = qBound( MIN_VIEW_SCALE, scale, MAX_VIEW_SCALE );
setTransform( QTransform::fromScale( scale, scale ) );
emit zoomLevelChanged();
updateRulers();
}
void ZoomAction::setZoomLevel(double zoomLevel)
{
if (zoomLevel < .1)
m_zoomLevel = 0.1;
else if (zoomLevel > 16.0)
m_zoomLevel = 16.0;
else
m_zoomLevel = zoomLevel;
emit zoomLevelChanged(m_zoomLevel);
}
void KeyboardLayoutEditor::setZoomLevel(int zoomLevel)
{
if (zoomLevel != m_zoomLevel)
{
m_zoomLevel = zoomLevel;
emit zoomLevelChanged();
const double zoomFactor = pow(2.0, zoomLevel / 2.0);
m_zoomFactorLabel->setText(ki18n("%1%").subs(zoomFactor * 100, 0, 'f', 0).toString());
m_zoomOutToolButton->setEnabled(zoomLevel > m_zoomSlider->minimum());
m_zoomInToolButton->setEnabled(zoomLevel < m_zoomSlider->maximum());
}
}
void ZoomAction::setZoomLevel(double zoomLevel)
{
if (zoomLevel < .1) {
m_zoomLevel = 0.1;
} else if (zoomLevel > 16.0) {
m_zoomLevel = 16.0;
} else {
m_zoomLevel = zoomLevel;
}
emit zoomLevelChanged(m_zoomLevel);
}
/*!
\qmlproperty qreal Map::zoomLevel
This property holds the zoom level for the map.
Larger values for the zoom level provide more detail.
The default value is 8.0.
*/
void QDeclarativeGraphicsGeoMap::setZoomLevel(qreal zoomLevel)
{
if (mapData_) {
mapData_->setZoomLevel(zoomLevel);
} else {
if (zoomLevel_ == zoomLevel)
return;
zoomLevel_ = zoomLevel;
emit zoomLevelChanged(zoomLevel_);
}
}
void MapWidget::zoomOut(double zoomFactor)
{
if (magnification.GetMagnification()/zoomFactor<1) {
magnification.SetMagnification(1);
}
else {
magnification.SetMagnification(magnification.GetMagnification()/zoomFactor);
}
TriggerMapRendering();
emit zoomLevelChanged();
emit zoomLevelNameChanged();
}
/*!
\qmlproperty real QtLocation::Map::zoomLevel
This property holds the zoom level for the map.
Larger values for the zoom level provide more detail. Zoom levels
are always non-negative. The default value is 8.0.
*/
void QDeclarativeGeoMap::setZoomLevel(qreal zoomLevel)
{
if (zoomLevel_ == zoomLevel || zoomLevel < 0)
return;
if ((zoomLevel < minimumZoomLevel()
|| (maximumZoomLevel() >= 0 && zoomLevel > maximumZoomLevel())))
return;
zoomLevel_ = zoomLevel;
if (mappingManagerInitialized_)
map_->mapController()->setZoom(zoomLevel_);
emit zoomLevelChanged(zoomLevel);
}
void MapWidget::zoomIn(double zoomFactor)
{
if (magnification.GetMagnification()*zoomFactor>800000) {
magnification.SetMagnification(800000);
}
else {
magnification.SetMagnification(magnification.GetMagnification()*zoomFactor);
}
TriggerMapRendering();
emit zoomLevelChanged();
emit zoomLevelNameChanged();
}
void QgsComposerView::setZoomLevel( double zoomLevel )
{
double dpi = QgsApplication::desktop()->logicalDpiX();
//monitor dpi is not always correct - so make sure the value is sane
if (( dpi < 60 ) || ( dpi > 250 ) )
dpi = 72;
//desired pixel width for 1mm on screen
double scale = zoomLevel * dpi / 25.4;
setTransform( QTransform::fromScale( scale , scale ) );
updateRulers();
update();
emit zoomLevelChanged();
}
/*!
\qmlproperty real QtLocation::Map::zoomLevel
This property holds the zoom level for the map.
Larger values for the zoom level provide more detail. Zoom levels
are always non-negative. The default value is 8.0.
*/
void QDeclarativeGeoMap::setZoomLevel(qreal zoomLevel)
{
if (m_zoomLevel == zoomLevel || zoomLevel < 0)
return;
if ((zoomLevel < minimumZoomLevel()
|| (maximumZoomLevel() >= 0 && zoomLevel > maximumZoomLevel())))
return;
m_zoomLevel = zoomLevel;
m_validRegion = false;
if (m_mappingManagerInitialized)
m_map->mapController()->setZoom(m_zoomLevel);
emit zoomLevelChanged(zoomLevel);
}
void QQuickMapboxGL::setZoomLevel(qreal zoom)
{
zoom = qMin(m_maximumZoomLevel, zoom);
zoom = qMax(m_minimumZoomLevel, zoom);
if (m_zoomLevel == zoom) {
return;
}
m_zoomLevel = zoom;
m_syncState |= ZoomNeedsSync;
update();
emit zoomLevelChanged(m_zoomLevel);
}
ZoomWidget::ZoomWidget(QWidget *parent)
: QFrame(parent),
ui(new Ui::ZoomWidget)
{
ui->setupUi(this);
setDisplayedZoomLevel(ui->zoomSlider->value());
connect(ui->zoomSlider, &QSlider::valueChanged,
[this] (int value){
setDisplayedZoomLevel(value);
});
connect(ui->zoomSlider, &QSlider::valueChanged,
[this] (int value) {
emit zoomLevelChanged((qreal)value / 100);
});
}
void QgsLayoutView::zoomWidth()
{
//get current visible part of scene
QRect viewportRect( 0, 0, viewport()->width(), viewport()->height() );
QRectF visibleRect = mapToScene( viewportRect ).boundingRect();
double verticalCenter = ( visibleRect.top() + visibleRect.bottom() ) / 2.0;
// expand out visible rect to include left/right edges of scene
// centered on current visible vertical center
// note that we can't have a 0 height rect - fitInView doesn't handle that
// so we just set a very small height instead.
const double tinyHeight = 0.01;
QRectF targetRect( scene()->sceneRect().left(),
verticalCenter - tinyHeight,
scene()->sceneRect().width(),
tinyHeight * 2 );
fitInView( targetRect, Qt::KeepAspectRatio );
emit zoomLevelChanged();
updateRulers();
}
void QgsLayoutView::setZoomLevel( double level )
{
if ( currentLayout()->units() == QgsUnitTypes::LayoutPixels )
{
setTransform( QTransform::fromScale( level, level ) );
}
else
{
double dpi = QgsApplication::desktop()->logicalDpiX();
//monitor dpi is not always correct - so make sure the value is sane
if ( ( dpi < 60 ) || ( dpi > 1200 ) )
dpi = 72;
//desired pixel width for 1mm on screen
level = qBound( MIN_VIEW_SCALE, level, MAX_VIEW_SCALE );
double mmLevel = currentLayout()->convertFromLayoutUnits( level, QgsUnitTypes::LayoutMillimeters ).length() * dpi / 25.4;
setTransform( QTransform::fromScale( mmLevel, mmLevel ) );
}
emit zoomLevelChanged();
updateRulers();
}
void CartesianWidget::setZoomLevel(int level)
{
mzoomLevel = level;
if (level == 0) {
setZoom(1.0);
}
if (level < 0)
{
int lvl = (1-level)/3.0;
setZoom(pow(2,level)*pow(0.8, lvl));
}
if (level > 0)
{
int lvl = -(level+1)/3.0;
setZoom(pow(2,level)*pow(0.8, lvl));
}
emit zoomLevelChanged(level);
}
void QgsComposerView::wheelZoom( QWheelEvent * event )
{
//get mouse wheel zoom behaviour settings
QSettings mySettings;
int wheelAction = mySettings.value( "/qgis/wheel_action", 2 ).toInt();
double zoomFactor = mySettings.value( "/qgis/zoom_factor", 2 ).toDouble();
if (( QgsMapCanvas::WheelAction )wheelAction == QgsMapCanvas::WheelNothing )
{
return;
}
if ( event->modifiers() & Qt::ControlModifier )
{
//holding ctrl while wheel zooming results in a finer zoom
zoomFactor = 1.0 + ( zoomFactor - 1.0 ) / 10.0;
}
//caculate zoom scale factor
bool zoomIn = event->delta() > 0;
double scaleFactor = ( zoomIn ? 1 / zoomFactor : zoomFactor );
//get current visible part of scene
QRect viewportRect( 0, 0, viewport()->width(), viewport()->height() );
QgsRectangle visibleRect = QgsRectangle( mapToScene( viewportRect ).boundingRect() );
//transform the mouse pos to scene coordinates
QPointF scenePoint = mapToScene( event->pos() );
//adjust view center according to wheel action setting
switch (( QgsMapCanvas::WheelAction )wheelAction )
{
case QgsMapCanvas::WheelZoomAndRecenter:
{
centerOn( scenePoint.x(), scenePoint.y() );
break;
}
case QgsMapCanvas::WheelZoomToMouseCursor:
{
QgsPoint oldCenter( visibleRect.center() );
QgsPoint newCenter( scenePoint.x() + (( oldCenter.x() - scenePoint.x() ) * scaleFactor ),
scenePoint.y() + (( oldCenter.y() - scenePoint.y() ) * scaleFactor ) );
centerOn( newCenter.x(), newCenter.y() );
break;
}
default:
break;
}
//zoom composition
if ( zoomIn )
{
scale( zoomFactor, zoomFactor );
}
else
{
scale( 1 / zoomFactor, 1 / zoomFactor );
}
//update composition for new zoom
emit zoomLevelChanged();
updateRulers();
update();
//redraw cached map items
QList<QGraphicsItem *> itemList = composition()->items();
QList<QGraphicsItem *>::iterator itemIt = itemList.begin();
for ( ; itemIt != itemList.end(); ++itemIt )
{
QgsComposerMap* mypItem = dynamic_cast<QgsComposerMap *>( *itemIt );
if (( mypItem ) && ( mypItem->previewMode() == QgsComposerMap::Render ) )
{
mypItem->updateCachedImage();
}
}
}
void EditorWidget::zoomLevelChanged()
{
// Let people know that the zoom level has changed
emit zoomLevelChanged(zoomLevel());
}
void QgsLayoutView::zoomFull()
{
fitInView( scene()->sceneRect(), Qt::KeepAspectRatio );
updateRulers();
emit zoomLevelChanged();
}
void QgsLayoutView::emitZoomLevelChanged()
{
emit zoomLevelChanged();
}
void QgsLayoutView::resizeEvent( QResizeEvent *event )
{
QGraphicsView::resizeEvent( event );
emit zoomLevelChanged();
}
QTM_BEGIN_NAMESPACE
/*!
\class QGraphicsGeoMap
\brief The QGraphicsGeoMap class is used to display a map and manager the
interactions between the user and the map.
\inmodule QtLocation
\since 1.1
\ingroup maps-mapping
Most of the functionality is provided by QGeoMappingManager, which
handles most aspects of the display.
The map viewport can be panned, the zoom level can be changed and the
center coordinate of the viewport can be set explicitly.
The screenPositionToCoordinate() and coordinateToScreenPoisition()
functions can be used to convert between positions on the screen and
global coordinates.
Mouse and keyboard events should be handled by subclassing QGraphicsGeoMap
and providing implementations of the event handling functions present in
QGraphicsWidget.
*/
/*!
\enum QGraphicsGeoMap::MapType
Describes a type of map data.
\value NoMap
Indicates a lack of map valid data.
\value StreetMap
The map data is a graphical representation of streets and building boundaries.
\value SatelliteMapDay
The map data is composed of images collected by satellites during the daytime.
\value SatelliteMapNight
The map data is composed of images collected by satellites during the nighttime.
\value TerrainMap
The map data is a graphical representation of terrain features. This may also
include some of the information provided by QGraphicsGeoMap::StreetMap.
*/
/*!
\enum QGraphicsGeoMap::ConnectivityMode
Describes the method of obtaining the mapping data.
\value NoConnectivity
There is no map data.
\value OfflineMode
The map data will come from an offline source.
\value OnlineMode
The map data will come from an online source.
\value HybridMode
The map data will come from a combination of offline and online sources.
*/
/*!
Creates a new mapping widget, with the mapping operations managed by
\a manager, and the specified \a parent.
Note that the \a manager will typically be accessed from an instance of
QGeoServiceProvider:
\code
QGeoServiceProvider serviceProvider("nokia");
QGeoMappingManager *manager = serviceProvider.mappingManager();
QGraphicsGeoMap *widget = new QGraphicsGeoMap(manager);
\endcode
*/
QGraphicsGeoMap::QGraphicsGeoMap(QGeoMappingManager *manager, QGraphicsItem *parent)
: QGraphicsWidget(parent),
d_ptr(new QGraphicsGeoMapPrivate())
{
Q_ASSERT(manager != 0);
d_ptr->manager = manager;
d_ptr->mapData = d_ptr->manager->createMapData();
d_ptr->mapData->init();
connect(d_ptr->mapData,
SIGNAL(updateMapDisplay(QRectF)),
this,
SLOT(updateMapDisplay(QRectF)));
setMapType(QGraphicsGeoMap::StreetMap);
d_ptr->mapData->setWindowSize(size());
connect(d_ptr->mapData,
SIGNAL(zoomLevelChanged(qreal)),
this,
SIGNAL(zoomLevelChanged(qreal)));
connect(d_ptr->mapData,
SIGNAL(bearingChanged(qreal)),
this,
SIGNAL(bearingChanged(qreal)));
connect(d_ptr->mapData,
SIGNAL(tiltChanged(qreal)),
this,
SIGNAL(tiltChanged(qreal)));
connect(d_ptr->mapData,
SIGNAL(mapTypeChanged(QGraphicsGeoMap::MapType)),
this,
SIGNAL(mapTypeChanged(QGraphicsGeoMap::MapType)));
connect(d_ptr->mapData,
SIGNAL(centerChanged(QGeoCoordinate)),
this,
SIGNAL(centerChanged(QGeoCoordinate)));
connect(d_ptr->mapData,
SIGNAL(connectivityModeChanged(QGraphicsGeoMap::ConnectivityMode)),
this,
SIGNAL(connectivityModeChanged(QGraphicsGeoMap::ConnectivityMode)));
setFlag(QGraphicsItem::ItemIsFocusable);
setFocus();
setMinimumSize(QSizeF(0, 0));
setPreferredSize(QSizeF(500, 500));
}
void QgsComposerView::resizeEvent( QResizeEvent* event )
{
QGraphicsView::resizeEvent( event );
emit zoomLevelChanged();
updateRulers();
}
void MapGraphicsView::setScene(MapGraphicsScene * scene)
{
/*
Create New Stuff
*/
//Create a private QGraphicsScene that our (also private) QGraphicsView will use
PrivateQGraphicsScene * childScene = new PrivateQGraphicsScene(scene,
this,
this);
//The QGraphicsScene needs to know when our zoom level changes so it can notify objects
connect(this,
SIGNAL(zoomLevelChanged(quint8)),
childScene,
SLOT(handleZoomLevelChanged()));
//Create a QGraphicsView that handles drawing for us
PrivateQGraphicsView * childView = new PrivateQGraphicsView(childScene, this);
connect(childView,
SIGNAL(hadMouseDoubleClickEvent(QMouseEvent*)),
this,
SLOT(handleChildMouseDoubleClick(QMouseEvent*)));
connect(childView,
SIGNAL(hadMouseMoveEvent(QMouseEvent*)),
this,
SLOT(handleChildMouseMove(QMouseEvent*)));
connect(childView,
SIGNAL(hadMousePressEvent(QMouseEvent*)),
this,
SLOT(handleChildMousePress(QMouseEvent*)));
connect(childView,
SIGNAL(hadMouseReleaseEvent(QMouseEvent*)),
this,
SLOT(handleChildMouseRelease(QMouseEvent*)));
connect(childView,
SIGNAL(hadWheelEvent(QWheelEvent*)),
this,
SLOT(handleChildViewScrollWheel(QWheelEvent*)));
connect(childView,
SIGNAL(hadContextMenuEvent(QContextMenuEvent*)),
this,
SLOT(handleChildViewContextMenu(QContextMenuEvent*)));
//Insert new stuff
if (this->layout() != 0)
delete this->layout();
this->setLayout(new QVBoxLayout(this));
this->layout()->addWidget(childView);
// set resize anchor of child QGraphicsView to center so the center
// position doesn't change when the view gets resized
childView->setResizeAnchor(QGraphicsView::AnchorViewCenter);
//Delete old stuff if applicable
if (!_childView.isNull())
delete _childView;
if (!_childScene.isNull())
delete _childScene;
//Set new stuff
_childView = childView;
_childScene = childScene;
_scene = scene;
this->resetQGSSceneSize();
//Reset the drag mode for the new child view
this->setDragMode(this->dragMode());
_childView->setMouseTracking(true);
}
void WebView::applyZoom()
{
setZoomFactor(qreal(zoomLevels().at(m_currentZoomLevel)) / 100.0);
emit zoomLevelChanged(m_currentZoomLevel);
}
int CameraWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0:
on_sendCameraCommand_clicked();
break;
case 1:
on_ExposureComp_clicked();
break;
case 2:
on_exposureCompenstaion_sliderMoved((*reinterpret_cast< int(*)>(_a[1])));
break;
case 3:
on_manualExposureSlider_sliderMoved((*reinterpret_cast< int(*)>(_a[1])));
break;
case 4:
on_panSlider_sliderMoved((*reinterpret_cast< int(*)>(_a[1])));
break;
case 5:
on_tiltSlider_sliderMoved((*reinterpret_cast< int(*)>(_a[1])));
break;
case 6:
on_doublePanTiltRate_clicked();
break;
case 7:
on_panRightButton_released();
break;
case 8:
on_panRightButton_pressed();
break;
case 9:
on_panLeftButton_released();
break;
case 10:
on_panLeftButton_pressed();
break;
case 11:
on_tiltDownButton_released();
break;
case 12:
on_tiltDownButton_pressed();
break;
case 13:
on_tiltUpButton_released();
break;
case 14:
on_tiltUpButton_pressed();
break;
case 15:
on_zoomOutButton_released();
break;
case 16:
on_zoomOutButton_pressed();
break;
case 17:
on_zoomInButton_released();
break;
case 18:
on_zoomInButton_pressed();
break;
case 19:
panPositionChanged((*reinterpret_cast< int(*)>(_a[1])));
break;
case 20:
zoomLevelChanged((*reinterpret_cast< int(*)>(_a[1])));
break;
case 21:
tiltPositionChanged((*reinterpret_cast< int(*)>(_a[1])));
break;
default:
;
}
_id -= 22;
}
return _id;
}
