File indexing completed on 2024-05-05 03:49:20

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2011 Dennis Nienhüser <nienhueser@kde.org>
 //
 
 #include "Tracking.h"
 
 #include "MarbleQuickItem.h"
 #include "MarbleModel.h"
 #include "PositionTracking.h"
 #include "RenderPlugin.h"
 #include "ViewportParams.h"
 #include "AutoNavigation.h"
 
 namespace Marble {
 
 Tracking::Tracking( QObject* parent) : QObject( parent ),
     m_showTrack( true ),
     m_positionSource( nullptr ),
     m_positionMarker( nullptr ),
     m_marbleQuickItem( nullptr ),
     m_hasLastKnownPosition( false ),
     m_autoNavigation( nullptr ),
     m_positionMarkerType( None )
 {
     connect( &m_lastKnownPosition, SIGNAL(longitudeChanged()), this, SLOT(setHasLastKnownPosition()) );
     connect( &m_lastKnownPosition, SIGNAL(latitudeChanged()), this, SLOT(setHasLastKnownPosition()) );
 }
 
 bool Tracking::showTrack() const
 {
     return m_showTrack;
 }
 
 void Tracking::setShowTrack( bool show )
 {
     if ( show != m_showTrack ) {
         if ( m_marbleQuickItem ) {
             m_marbleQuickItem->model()->positionTracking()->setTrackVisible( show );
             m_marbleQuickItem->update();
         }
 
         m_showTrack = show;
         emit showTrackChanged();
     }
 }
 
 PositionSource* Tracking::positionSource()
 {
     return m_positionSource;
 }
 
 void Tracking::setPositionSource( PositionSource* source )
 {
     if ( source != m_positionSource ) {
         m_positionSource = source;
         if ( source ) {
             connect( source, SIGNAL(positionChanged()),
                     this, SLOT(updatePositionMarker()) );
             connect( source, SIGNAL(positionChanged()),
                     this, SLOT(updateLastKnownPosition()) );
             connect( source, SIGNAL(hasPositionChanged()),
                     this, SLOT(updatePositionMarker()) );
             connect( source, SIGNAL(positionChanged()),
                      this, SIGNAL(distanceChanged()) );
         }
         emit positionSourceChanged();
     }
 }
 
 MarbleQuickItem* Tracking::map()
 {
     return m_marbleQuickItem;
 }
 
 void Tracking::setMap( MarbleQuickItem* item )
 {
     if ( item != m_marbleQuickItem ) {
         m_marbleQuickItem = item;
 
         if ( m_marbleQuickItem ) {
             m_marbleQuickItem->model()->positionTracking()->setTrackVisible( showTrack() );
             setShowPositionMarkerPlugin( m_positionMarkerType == Arrow );
 
             connect( m_marbleQuickItem, SIGNAL(visibleLatLonAltBoxChanged()), this, SLOT(updatePositionMarker()) );
             connect( m_marbleQuickItem, SIGNAL(mapThemeChanged()), this, SLOT(updatePositionMarker()) );
         }
 
         emit mapChanged();
     }
 }
 
 void Tracking::setPositionMarker( QObject* marker )
 {
     if ( marker != m_positionMarker ) {
         m_positionMarker = marker;
         emit positionMarkerChanged();
     }
 }
 
 QObject* Tracking::positionMarker()
 {
     return m_positionMarker;
 }
 
 void Tracking::updatePositionMarker()
 {
     if ( m_marbleQuickItem && m_positionMarker && m_positionMarkerType == Circle ) {
         Coordinate* position = nullptr;
         bool visible = (m_marbleQuickItem->model()->planetId() == QLatin1String("earth"));
         if ( m_positionSource && m_positionSource->hasPosition() ) {
             position = m_positionSource->position();
         } else if ( hasLastKnownPosition() ) {
             position = lastKnownPosition();
         } else {
             visible = false;
         }
 
         qreal x(0), y(0);
         if ( position ) {
             Marble::GeoDataCoordinates const pos( position->longitude(), position->latitude(), 0.0, GeoDataCoordinates::Degree );
             visible = visible && m_marbleQuickItem->map()->viewport()->screenCoordinates( pos.longitude(), pos.latitude(), x, y );
             QQuickItem* item = qobject_cast<QQuickItem*>( m_positionMarker );
             if ( item ) {
                 item->setVisible( visible );
                 if ( visible ) {
                     item->setX( x - item->width() / 2.0 );
                     item->setY( y - item->height() / 2.0 );
                 }
             }
         }
     } else if ( m_positionMarkerType != Circle ) {
         QQuickItem* item = qobject_cast<QQuickItem*>( m_positionMarker );
         if ( item ) {
             item->setVisible( false );
         }
     }
 }
 
 void Tracking::updateLastKnownPosition()
 {
     if ( m_positionSource && m_positionSource->hasPosition() ) {
         setLastKnownPosition( m_positionSource->position() );
     }
 }
 
 void Tracking::setHasLastKnownPosition()
 {
     if ( !m_hasLastKnownPosition ) {
         m_hasLastKnownPosition = true;
         emit hasLastKnownPositionChanged();
     }
 }
 
 void Tracking::setShowPositionMarkerPlugin( bool visible )
 {
     if ( m_marbleQuickItem ) {
         QList<RenderPlugin*> const renderPlugins = m_marbleQuickItem->map()->renderPlugins();
         for( RenderPlugin* renderPlugin: renderPlugins ) {
             Q_ASSERT( renderPlugin );
             if (renderPlugin->nameId() == QLatin1String("positionMarker")) {
                 renderPlugin->setEnabled( true );
                 renderPlugin->setVisible( visible );
             }
         }
    }
 }
 
 bool Tracking::hasLastKnownPosition() const
 {
     return m_hasLastKnownPosition;
 }
 
 Coordinate * Tracking::lastKnownPosition()
 {
     return &m_lastKnownPosition;
 }
 
 void Tracking::setLastKnownPosition( Coordinate* lastKnownPosition )
 {
     if ( lastKnownPosition && *lastKnownPosition != m_lastKnownPosition ) {
         m_lastKnownPosition.setCoordinates( lastKnownPosition->coordinates() );
         emit lastKnownPositionChanged();
     }
 }
 
 bool Tracking::autoCenter() const
 {
     if ( m_autoNavigation ) {
         return m_autoNavigation->recenterMode() != Marble::AutoNavigation::DontRecenter;
     }
 
     return false;
 }
 
 void Tracking::setAutoCenter( bool enabled )
 {
     if ( autoCenter() != enabled ) {
         if ( enabled && !m_autoNavigation && m_marbleQuickItem ) {
             m_autoNavigation = new Marble::AutoNavigation( m_marbleQuickItem->model(), m_marbleQuickItem->map()->viewport(), this );
             connect( m_autoNavigation, SIGNAL(zoomIn(FlyToMode)),
                      m_marbleQuickItem, SLOT(zoomIn()) );
             connect( m_autoNavigation, SIGNAL(zoomOut(FlyToMode)),
                      m_marbleQuickItem, SLOT(zoomOut()) );
             connect( m_autoNavigation, SIGNAL(centerOn(GeoDataCoordinates,bool)),
                      m_marbleQuickItem, SLOT(centerOn(GeoDataCoordinates)) );
 
             connect( m_marbleQuickItem, SIGNAL(visibleLatLonAltBoxChanged()),
                      m_autoNavigation, SLOT(inhibitAutoAdjustments()) );
         }
 
         if ( m_autoNavigation ) {
             m_autoNavigation->setRecenter( Marble::AutoNavigation::RecenterOnBorder );
         }
 
         emit autoCenterChanged();
     }
 }
 
 bool Tracking::autoZoom() const
 {
     if ( m_autoNavigation ) {
         return m_autoNavigation->autoZoom();
     }
 
     return false;
 }
 
 void Tracking::setAutoZoom( bool enabled )
 {
     if ( autoZoom() != enabled ) {
         if ( enabled && !m_autoNavigation && m_marbleQuickItem ) {
             m_autoNavigation = new Marble::AutoNavigation( m_marbleQuickItem->model(), m_marbleQuickItem->map()->viewport(), this );
             connect( m_autoNavigation, SIGNAL(zoomIn(FlyToMode)),
                      m_marbleQuickItem, SLOT(zoomIn()) );
             connect( m_autoNavigation, SIGNAL(zoomOut(FlyToMode)),
                      m_marbleQuickItem, SLOT(zoomOut()) );
             connect( m_autoNavigation, SIGNAL(centerOn(GeoDataCoordinates,bool)),
                      m_marbleQuickItem, SLOT(centerOn(GeoDataCoordinates)) );
 
             connect( m_marbleQuickItem, SIGNAL(visibleLatLonAltBoxChanged()),
                      m_autoNavigation, SLOT(inhibitAutoAdjustments()) );
         }
 
         if ( m_autoNavigation ) {
             m_autoNavigation->setAutoZoom( enabled );
         }
 
         emit autoZoomChanged();
     }
 }
 
 Tracking::PositionMarkerType Tracking::positionMarkerType() const
 {
     return m_positionMarkerType;
 }
 
 void Tracking::setPositionMarkerType( Tracking::PositionMarkerType type )
 {
     setShowPositionMarkerPlugin( type == Arrow );
     if ( type != m_positionMarkerType ) {
         m_positionMarkerType = type;
         emit positionMarkerTypeChanged();
     }
 }
 
 double Tracking::distance() const
 {
     return m_marbleQuickItem ? m_marbleQuickItem->model()->positionTracking()->length( m_marbleQuickItem->model()->planetRadius() ) : 0.0;
 }
 
 void Tracking::saveTrack( const QString &fileName )
 {
     if ( m_marbleQuickItem ) {
         /** @todo FIXME: replace the file:// prefix on QML side */
         QString target = fileName.startsWith( QLatin1String( "file://" ) ) ? fileName.mid( 7 ) : fileName;
         m_marbleQuickItem->model()->positionTracking()->saveTrack( target );
     }
 }
 
 void Tracking::openTrack(const QString &fileName)
 {
     if ( m_marbleQuickItem ) {
         /** @todo FIXME: replace the file:// prefix on QML side */
         QString target = fileName.startsWith( QLatin1String( "file://" ) ) ? fileName.mid( 7 ) : fileName;
         m_marbleQuickItem->model()->addGeoDataFile( target );
     }
 }
 
 void Tracking::clearTrack()
 {
     if ( m_marbleQuickItem ) {
         m_marbleQuickItem->model()->positionTracking()->clearTrack();
     }
 }
 
 }
 
 #include "moc_Tracking.cpp"