[prev in list] [next in list] [prev in thread] [next in thread] 

List:       kde-commits
Subject:    KDE/kdeedu/marble/src/lib
From:       Bernhard Beschow <bbeschow () cs ! tu-berlin ! de>
Date:       2011-03-31 15:31:07
Message-ID: 20110331153107.09CDCAC8D4 () svn ! kde ! org
[Download RAW message or body]

SVN commit 1226644 by beschow:

StackedTileLoader: merge reloadTile(), tilesOnDisplay(), and reloadCachedTile() into \
reloadVisibleTiles(). Use reloadVisibleTiles() in TextureLayer::reload().

This patch does not only remove lots of unused and redundant code, but also seems \
more efficent, since tileUpdatesAvailable() is signalled only once rather than once \
for each cached tile in reloadCachedTile().

 M  +11 -74    StackedTileLoader.cpp  
 M  +2 -6      StackedTileLoader.h  
 M  +1 -9      TextureLayer.cpp  


--- trunk/KDE/kdeedu/marble/src/lib/StackedTileLoader.cpp #1226643:1226644
@@ -240,55 +240,6 @@
     return stackedTile;
 }
 
-// The tile to be reloaded might be (alternatively):
-// 1) in the "hash" (m_tilesOnDisplay), which means it is currently displayed
-// 2) not in the hash, but in the "cache", which means it is not currently displayed
-// 3) neither in "hash" nor in "cache"
-StackedTile* StackedTileLoader::reloadTile( TileId const & stackedTileId,
-                                            DownloadUsage const usage )
-{
-    StackedTile * const displayedTile = d->m_tilesOnDisplay.value( stackedTileId, 0 \
                );
-    if ( displayedTile ) {
-        reloadCachedTile( displayedTile, usage );
-        return displayedTile;
-    }
-    StackedTile * const cachedTile = d->m_tileCache.object( stackedTileId );
-    if ( cachedTile ) {
-        // It would be more correct to update the cost for the cache also, but let's \
                ignore it at
-        // least for now.
-        // Perhaps more relevant is, that as a consequence of leaving the tile in \
                the cache
-        // reloadCachedTile must not alter the cache to prevent this tile from being \
                deleted.
-        // So, all in all it might be better to take the tile out of the cache \
                before calling
-        // reloadCachedTile and put it in again afterwards.
-        // FIXME: discuss/decide
-        reloadCachedTile( cachedTile, usage );
-        return cachedTile;
-    }
-
-    QVector<QSharedPointer<TextureTile> > tiles;
-    QVector<GeoSceneTexture const *> const textureLayers = \
                d->findRelevantTextureLayers( stackedTileId );
-    QVector<GeoSceneTexture const *>::const_iterator pos = \
                textureLayers.constBegin();
-    QVector<GeoSceneTexture const *>::const_iterator const end = \
                textureLayers.constEnd();
-    for (; pos != end; ++pos ) {
-        GeoSceneTexture const * const textureLayer = *pos;
-        TileId const tileId( textureLayer->sourceDir(), stackedTileId.zoomLevel(),
-                             stackedTileId.x(), stackedTileId.y() );
-        QSharedPointer<TextureTile> const tile = d->m_tileLoader->reloadTile( \
                stackedTileId, tileId,
-                                                                              usage \
                );
-        if ( tile ) {
-            tile->setBlending( textureLayer->blending() );
-            tiles.append( tile );
-        }
-    }
-    Q_ASSERT( !tiles.isEmpty() );
-
-    StackedTile * const stackedTile = new StackedTile( stackedTileId, tiles );
-    d->m_tilesOnDisplay[ stackedTileId ] = stackedTile;
-    mergeDecorations( stackedTile );
-
-    return stackedTile;
-}
-
 void StackedTileLoader::downloadTile( TileId const & stackedTileId )
 {
     QVector<GeoSceneTexture const *> const textureLayers = \
d->findRelevantTextureLayers( stackedTileId ); @@ -307,17 +258,20 @@
     return d->m_tileCache.maxCost() / 1024;
 }
 
-QList<TileId> StackedTileLoader::tilesOnDisplay() const
+void StackedTileLoader::reloadVisibleTiles()
 {
-    QList<TileId> result;
-    QHash<TileId, StackedTile*>::const_iterator pos = \
                d->m_tilesOnDisplay.constBegin();
-    QHash<TileId, StackedTile*>::const_iterator const end = \
                d->m_tilesOnDisplay.constEnd();
-    for (; pos != end; ++pos ) {
-        if ( pos.value()->used() ) {
-            result.append( pos.key() );
+    foreach ( StackedTile * const displayedTile, d->m_tilesOnDisplay.values() ) {
+        Q_ASSERT( displayedTile != 0 );
+        foreach ( QSharedPointer<TextureTile> const & tile, *displayedTile->tiles() \
) { +            // it's debatable here, whether DownloadBulk or DownloadBrowse \
should be used +            // but since "reload" or "refresh" seems to be a common \
action of a browser and it +            // allows for more connections (in our \
model), use "DownloadBrowse" +            d->m_tileLoader->reloadTile( tile, \
DownloadBrowse );  }
+        mergeDecorations( displayedTile );
     }
-    return result;
+
+    emit tileUpdatesAvailable();
 }
 
 int StackedTileLoader::maximumTileLevel() const
@@ -459,23 +413,6 @@
     d->m_layerDecorator.paint( "maps/" + d->m_textureLayers.at( 0 )->sourceDir() );
 }
 
-// This method should not alter m_tileCache, as the given tile is managed
-// by the cache and may be evicted at any time (that is usually when inserting
-// other tiles in the cache)
-void StackedTileLoader::reloadCachedTile( StackedTile * const cachedTile,
-                                          DownloadUsage const usage )
-{
-    Q_ASSERT( cachedTile );
-    QVector<QSharedPointer<TextureTile> > * tiles = cachedTile->tiles();
-    QVector<QSharedPointer<TextureTile> >::const_iterator pos = tiles->constBegin();
-    QVector<QSharedPointer<TextureTile> >::const_iterator const end = \
                tiles->constEnd();
-    for (; pos != end; ++pos ) {
-        d->m_tileLoader->reloadTile( *pos, usage );
     }
-    mergeDecorations( cachedTile );
-    emit tileUpdateAvailable( cachedTile->id() );
-}
 
-}
-
 #include "StackedTileLoader.moc"
--- trunk/KDE/kdeedu/marble/src/lib/StackedTileLoader.h #1226643:1226644
@@ -92,7 +92,6 @@
          *                      and the zoom level.
          */
         StackedTile* loadTile( TileId const &stackedTileId );
-        StackedTile* reloadTile( TileId const & stackedTileId, DownloadUsage const \
);  void downloadTile( TileId const & stackedTileId );
 
         /**
@@ -121,11 +120,9 @@
         quint64 volatileCacheLimit() const;
 
         /**
-         * @brief Returns a list of TileIds of the tiles which are currently
-         *        displayed. This is used for example for the map reload
-         *        functionality.
+         * @brief Reloads the tiles that are currently displayed.
          */
-        QList<TileId> tilesOnDisplay() const;
+        void reloadVisibleTiles();
 
         /**
          * Returns the highest level in which some tiles are theoretically
@@ -168,7 +165,6 @@
     private:
         Q_DISABLE_COPY( StackedTileLoader )
         void mergeDecorations( StackedTile * const ) const;
-        void reloadCachedTile( StackedTile * const cachedTile, DownloadUsage const \
);  
         StackedTileLoaderPrivate* const d;
 };
--- trunk/KDE/kdeedu/marble/src/lib/TextureLayer.cpp #1226643:1226644
@@ -215,16 +215,8 @@
 
 void TextureLayer::reload()
 {
-    QList<TileId> displayed = d->m_tileLoader.tilesOnDisplay();
-    QList<TileId>::const_iterator pos = displayed.constBegin();
-    QList<TileId>::const_iterator const end = displayed.constEnd();
-    for (; pos != end; ++pos ) {
-        // it's debatable here, whether DownloadBulk or DownloadBrowse should be \
                used
-        // but since "reload" or "refresh" seems to be a common action of a browser \
                and it
-        // allows for more connections (in our model), use "DownloadBrowse"
-        d->m_tileLoader.reloadTile( *pos, DownloadBrowse );
+    d->m_tileLoader.reloadVisibleTiles();
     }
-}
 
 void TextureLayer::downloadTile( const TileId &tileId )
 {


[prev in list] [next in list] [prev in thread] [next in thread]