File indexing completed on 2024-04-28 15:16:02

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2014 Sanjiban Bairagya <sanjiban22393@gmail.com>
 //
 
 #include "PlaybackAnimatedUpdateItem.h"
 
 #include "GeoDataAnimatedUpdate.h"
 #include "GeoDataDocument.h"
 #include "GeoDataPlacemark.h"
 #include "GeoDataCreate.h"
 #include "GeoDataUpdate.h"
 #include "GeoDataDelete.h"
 #include "GeoDataChange.h"
 #include "GeoDataFolder.h"
 #include "GeoDataGroundOverlay.h"
 #include "GeoDataPhotoOverlay.h"
 #include "GeoDataScreenOverlay.h"
 
 #include <QString>
 
 namespace Marble
 {
 PlaybackAnimatedUpdateItem::PlaybackAnimatedUpdateItem( GeoDataAnimatedUpdate* animatedUpdate )
 {
     m_animatedUpdate = animatedUpdate;
     m_rootDocument = rootDocument( m_animatedUpdate );
     m_playing = false;
 }
 
 const GeoDataAnimatedUpdate* PlaybackAnimatedUpdateItem::animatedUpdate() const
 {
     return m_animatedUpdate;
 }
 
 double PlaybackAnimatedUpdateItem::duration() const
 {
     return m_animatedUpdate->duration();
 }
 
 void PlaybackAnimatedUpdateItem::play()
 {
     if( m_playing ){
         return;
     }
     m_playing = true;
 
     if ( !m_rootDocument || !m_animatedUpdate->update() ) {
         return;
     }
 
     // Apply updates of elements
     if ( m_animatedUpdate->update()->change() ) {
         QVector<GeoDataPlacemark*> placemarkList = m_animatedUpdate->update()->change()->placemarkList();
         for( int i = 0; i < placemarkList.size(); i++ ){
             GeoDataPlacemark* placemark = placemarkList.at( i );
             QString targetId = placemark->targetId();
             if( targetId.isEmpty() ) {
                 continue;
             }
             if( placemark->isBalloonVisible() ){
                 GeoDataFeature* feature = findFeature( m_rootDocument, targetId );
                 if (auto placemark = geodata_cast<GeoDataPlacemark>(feature)) {
                     emit balloonShown(placemark);
                 }
             } else {
                 emit balloonHidden();
             }
         }
     }
 
     // Create new elements
     if( m_animatedUpdate->update()->create() ){
         for( int index = 0; index < m_animatedUpdate->update()->create()->size(); ++index ) {
             GeoDataFeature* child = m_animatedUpdate->update()->create()->child( index );
             if( child &&
                     (geodata_cast<GeoDataDocument>(child)||
                      geodata_cast<GeoDataFolder>(child))) {
                 GeoDataContainer *addContainer = static_cast<GeoDataContainer*>( child );
                 QString targetId = addContainer->targetId();
                 GeoDataFeature* feature = findFeature( m_rootDocument, targetId );
                 if( feature &&
                         (geodata_cast<GeoDataDocument>(feature) ||
                          geodata_cast<GeoDataFolder>(feature))) {
                     GeoDataContainer* container = static_cast<GeoDataContainer*>( feature );
                     for( int i = 0; i < addContainer->size(); ++i ) {
                         emit added( container, addContainer->child( i ), -1 );
                         if (auto placemark = geodata_cast<GeoDataPlacemark>(addContainer->child(i)))
                         {
                             if( placemark->isBalloonVisible() ) {
                                 emit balloonShown( placemark );
                             }
                         }
                     }
                 }
 
             }
         }
     }
 
     // Delete elements
     if( m_animatedUpdate->update()->getDelete() ){
         for( int index = 0; index < m_animatedUpdate->update()->getDelete()->size(); ++index ) {
             GeoDataFeature* child = m_animatedUpdate->update()->getDelete()->child( index );
             QString targetId = child->targetId();
             if( targetId.isEmpty() ) {
                 continue;
             }
             GeoDataFeature* feature = findFeature( m_rootDocument, targetId );
             if (feature && canDelete(*feature)) {
                 m_deletedObjects.append( feature );
                 emit removed( feature );
                 if (auto placemark = geodata_cast<GeoDataPlacemark>(feature))
                 {
                     if( placemark->isBalloonVisible() ) {
                         emit balloonHidden();
                     }
                 }
             }
         }
     }
 }
 
 GeoDataFeature* PlaybackAnimatedUpdateItem::findFeature(GeoDataFeature* feature, const QString& id ) const
 {
     if ( feature && feature->id() == id ){
         return feature;
     }
 
     GeoDataContainer *container = dynamic_cast<GeoDataContainer*>( feature );
     if ( container ){
         QVector<GeoDataFeature*>::Iterator end = container->end();
         QVector<GeoDataFeature*>::Iterator iter = container->begin();
         for( ; iter != end; ++iter ){
             GeoDataFeature *foundFeature = findFeature( *iter, id );
             if ( foundFeature ){
                 return foundFeature;
             }
         }
     }
     return nullptr;
 }
 
 GeoDataDocument *PlaybackAnimatedUpdateItem::rootDocument( GeoDataObject* object ) const
 {
     if( !object || !object->parent() ){
         GeoDataDocument* document = dynamic_cast<GeoDataDocument*>( object );
         return document;
     } else {
         return rootDocument( object->parent() );
     }
     return nullptr;
 }
 
 void PlaybackAnimatedUpdateItem::pause()
 {
     //do nothing
 }
 
 void PlaybackAnimatedUpdateItem::seek( double position )
 {
     Q_UNUSED( position );
     play();
 }
 
 void PlaybackAnimatedUpdateItem::stop()
 {
     if( !m_playing ){
         return;
     }
     m_playing = false;
 
     if ( m_animatedUpdate->update()->change() ) {
         QVector<GeoDataPlacemark*> placemarkList = m_animatedUpdate->update()->change()->placemarkList();
         for( int i = 0; i < placemarkList.size(); i++ ){
             GeoDataPlacemark* placemark = placemarkList.at( i );
             QString targetId = placemark->targetId();
             if( targetId.isEmpty() ) {
                 continue;
             }
             GeoDataFeature* feature = findFeature( m_rootDocument, targetId );
             if( placemark->isBalloonVisible() ){
                 if (geodata_cast<GeoDataPlacemark>(feature)) {
                     emit balloonHidden();
                 }
             } else {
                 emit balloonShown( static_cast<GeoDataPlacemark*>( feature ) );
             }
         }
     }
 
     if( m_animatedUpdate->update()->create() ){
         for( int index = 0; index < m_animatedUpdate->update()->create()->size(); ++index ) {
             GeoDataFeature* feature = m_animatedUpdate->update()->create()->child( index );
             if( feature &&
                     (geodata_cast<GeoDataDocument>(feature) ||
                      geodata_cast<GeoDataFolder>(feature))) {
                 GeoDataContainer* container = static_cast<GeoDataContainer*>( feature );
                 for( int i = 0; i < container->size(); ++i ) {
 
                     emit removed( container->child( i ) );
                     if (auto placemark = geodata_cast<GeoDataPlacemark>(container->child(i)))
                     {
                         if( placemark->isBalloonVisible() ) {
                             emit balloonHidden();
                         }
                     }
                 }
             }
         }
     }
 
     for( GeoDataFeature* feature: m_deletedObjects ) {
         if( feature->targetId().isEmpty() ) {
             continue;
         }
         GeoDataFeature* target = findFeature( m_rootDocument, feature->targetId() );
         if ( target ) {
             /** @todo Do we have to note the original row position and restore it? */
             Q_ASSERT( dynamic_cast<GeoDataContainer*>( target ) );
             emit added( static_cast<GeoDataContainer*>( target ), feature, -1 );
             if (auto placemark = geodata_cast<GeoDataPlacemark>(feature))
             {
                 if( placemark->isBalloonVisible() ) {
                     emit balloonShown( placemark );
                 }
             }
         } // else the root document was modified in an unfortunate way and we cannot restore it at this point
     }
     m_deletedObjects.clear();
 }
 
 bool PlaybackAnimatedUpdateItem::isApplied() const
 {
     return m_playing;
 }
 
 bool PlaybackAnimatedUpdateItem::canDelete(const GeoDataFeature &feature)
 {
     return  geodata_cast<GeoDataDocument>(&feature) ||
             geodata_cast<GeoDataFolder>(&feature) ||
             geodata_cast<GeoDataGroundOverlay>(&feature) ||
             geodata_cast<GeoDataPlacemark>(&feature) ||
             geodata_cast<GeoDataScreenOverlay>(&feature) ||
             geodata_cast<GeoDataPhotoOverlay>(&feature);
 }
 
 }
 
 #include "moc_PlaybackAnimatedUpdateItem.cpp"