Stacked tile removal zValue check, doxygen generating class diagrams

[situare] / src / map / mapfetcher.h

diff --git a/src/map/mapfetcher.h b/src/map/mapfetcher.h
index 81571da..af3818d 100644 (file)
--- a/src/map/mapfetcher.h
+++ b/src/map/mapfetcher.h
@@ -3,6 +3,7 @@
    Copyright (C) 2010  Ixonos Plc. Authors:
 
        Jussi Laitinen - jussi.laitinen@ixonos.com
+       Sami Rämö - sami.ramo@ixonos.com
 
    Situare is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
@@ -25,8 +26,6 @@
 #include <QtCore>
 #include <QNetworkAccessManager>
 
-#include "mapfetcher.h"
-
 class QNetworkReply;
 class QUrl;
 
@@ -34,11 +33,27 @@ class QUrl;
 * @brief MapFetcher handles requests to get map tiles.
 *
 * @author Jussi Laitinen jussi.laitinen@ixonos.com
+* @author Sami Rämö sami.ramo@ixonos.com
 */
 class MapFetcher : public QObject
 {
     Q_OBJECT
 
+    /**
+    * @brief Type for download requests
+    *
+    * @typedef Request
+    */    
+    /**
+    * @brief Struct for download requests
+    *
+    * @struct _Request
+    */
+    typedef struct _Request {
+        bool cacheChecked; ///< Is this request already checked from the cache
+        QUrl url; ///< URL
+    } Request;
+
 public:
     /**
     * @brief Constructor for MapFetcher.
@@ -51,15 +66,33 @@ public:
 /*******************************************************************************
  * CLASS SPECIFIC MEMBER FUNCTIONS AND SLOTS
  ******************************************************************************/
+public:
+    /**
+    * @brief Set size of the download queue
+    *
+    * @param size New size
+    */
+    void setDownloadQueueSize(int size);
+
 public slots:
     /**
-    * @brief Fetch image from given URL.
+    * @brief Enqueue fetching of map image
     *
-    * @param url URL to image
+    * Image fetching is triggered after events have been processed
+    * so the UI stays responsive.
+    *
+    * @param url URL of the image to be fetched
     */
-    void fetchMapImage(const QUrl &url);
+    void enqueueFetchMapImage(QUrl url);
 
 private:
+
+    /**
+    * @brief Limit pending requests list size to m_pendingRequestsSize
+    *
+    */
+    void limitPendingRequestsListSize();
+
     /**
     * @brief Loads image from cache if it's available and emits imageReveived
     * signal with url and image. If image is in cache returns true, false
@@ -70,6 +103,18 @@ private:
     */
     bool loadImageFromCache(const QUrl &url);
 
+    /**
+    * @brief Find first item based on criteria if the request is already checked from the cache
+    *
+    * If cacheChecked is true, then returns index of the first request which is already
+    * checked from the cache. If cacheChecked is false then returns first item which
+    * isn't checked from the cache. Returns -1 if the item is not found.
+    *
+    * @param cacheChecked Search criteria
+    * @return Index of the first matching request, or -1 if not found.
+    */
+    int newestRequestIndex(bool cacheChecked);
+
 private slots:
 
     /**
@@ -82,6 +127,16 @@ private slots:
     void downloadFinished(QNetworkReply *reply);
 
     /**
+    * @brief Check next request if it is found from cache
+    *
+    * Next queued request, which is not already checked against cache, is taken
+    * from the queue and checked against cache. If not found from cache, then
+    * cache checked flag is set. New download is started if there aren't too
+    * many simultaneus downloads already running.
+    */
+    void checkNextRequestFromCache();
+
+    /**
     * @brief This slot is called when next download is started. Takes url
     * from queue, sends request and puts request to download queue.
     */
@@ -112,12 +167,13 @@ signals:
  * DATA MEMBERS
  ******************************************************************************/
 private:
-    static const int MAX_PARALLEL_DOWNLOADS = 2;
-    static const int DOWNLOAD_QUEUE_SIZE = 50;
+    static const int MAX_PARALLEL_DOWNLOADS = 2; ///< Max simultaneous parallel downloads
 
     QList<QNetworkReply*> m_currentDownloads; ///< List of current downloads
-    QQueue<QUrl> m_downloadQueue;             ///< Queue of pending requests
-    QNetworkAccessManager *m_manager;       ///< Network access manager
+    int m_pendingRequestsSize; ///< Max number of pending requests
+    bool m_fetchMapImagesTimerRunning; ///< is the singleshot timer already running
+    QNetworkAccessManager *m_manager; ///< Network access manager
+    QList<Request> m_pendingRequests; ///< List of map image fetching requests
 };
 
 #endif