src/graphics/LoaderQueue.h

   1 // -*- C++ -*-
   2 /**
   3  *  \file LoaderQueue.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  *  \author Alfredo Braunstein
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  *
  11  * This implements a threaded service queue which loads images on background.
  12  * In order to request an image loading you call touch() with the pointer to
  13  * the cached image. Then it will try to satisfy the request as soon as
  14  * posible (that's it: after finishing an eventual loading on progress)
  15  * touch() returns inmediately, in order not tu disrupt the flow of the main
  16  * thread.
  17  * The service thread is the method loadNext(). It's actually not a thread,
  18  * but implemented with a timer that comes back every x msec.
  19  */
  20
  21 #ifndef LOADERQUEUE_H
  22 #define LOADERQUEUE_H
  23
  24 #include "GraphicsCache.h"
  25 #include "GraphicsCacheItem.h"
  26
  27 #include "frontends/Timeout.h"
  28
  29 #include <set>
  30 #include <queue>
  31
  32 namespace grfx {
  33
  34 class LoaderQueue {
  35 public:
  36         /// Use this to request that the item is loaded.
  37         void touch(Cache::ItemPtr const & item);
  38         /// Query whether the clock is ticking.
  39         bool running() const;
  40         ///get the and only instance of the class
  41         static LoaderQueue & get();
  42         /** Adjusts the queue priority:
  43          *  numimages is the number of images loaded in a particular call
  44          *  from the timer.
  45          *  millisecs is the time interval between calls.
  46          *  Higher numimages, lower millisecs means higher priority.
  47          */
  48         static void setPriority(int numimages , int millisecs);
  49 private:
  50         /// This class is a singleton class... use LoaderQueue::get() instead
  51         LoaderQueue();
  52         /// The in-progress loading queue (elements are unique here).
  53         std::list<Cache::ItemPtr> cache_queue_;
  54         /// Used to make the insertion of new elements faster.
  55         std::set<Cache::ItemPtr> cache_set_;
  56         /// Newly touched elements go here. loadNext moves them to cache_queue_
  57         std::queue<Cache::ItemPtr> bucket_;
  58         ///
  59         Timeout timer;
  60         ///
  61         bool running_;
  62         ///
  63         static int s_numimages_ ;
  64         ///
  65         static int s_millisecs_ ;
  66
  67         /** This is the 'threaded' method, that does the loading in the
  68          *  background.
  69          */
  70         void loadNext();
  71         ///
  72         void startLoader();
  73         ///
  74         void stopLoader();
  75 };
  76
  77 } // namespace grfx
  78
  79 #endif // LOADERQUEUE_H