X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fgraphics%2FGraphicsLoader.cpp;h=4ec5c9aed92f50a3443a82741f9429bfa0eab199;hb=f887efedf11c198d9b6cc19911fa0a32a93496f3;hp=e175ba5c754dda37aa10b46cad2b29cd0ee6f32b;hpb=75ce50098937e10d1bb81afb2c34a6a8df968c46;p=lyx.git diff --git a/src/graphics/GraphicsLoader.cpp b/src/graphics/GraphicsLoader.cpp index e175ba5c75..4ec5c9aed9 100644 --- a/src/graphics/GraphicsLoader.cpp +++ b/src/graphics/GraphicsLoader.cpp @@ -15,21 +15,151 @@ #include "GraphicsCacheItem.h" #include "GraphicsImage.h" #include "GraphicsParams.h" -#include "LoaderQueue.h" +#include "GraphicsCache.h" -#include "callback.h" +#include "support/debug.h" +#include "support/Timeout.h" -#include +#include "support/bind.h" +#include +#include -using std::string; - +using namespace std; +using namespace lyx::support; namespace lyx { +namespace graphics { -using support::FileName; -namespace graphics { +///////////////////////////////////////////////////////////////////// +// +// LoaderQueue +// +///////////////////////////////////////////////////////////////////// + +class LoaderQueue { +public: + /// Use this to request that the item is loaded. + void touch(Cache::ItemPtr const & item); + /// Query whether the clock is ticking. + bool running() const; + ///get the and only instance of the class + static LoaderQueue & get(); +private: + /// This class is a singleton class... use LoaderQueue::get() instead + LoaderQueue(); + /// The in-progress loading queue (elements are unique here). + list cache_queue_; + /// Used to make the insertion of new elements faster. + set cache_set_; + /// Newly touched elements go here. loadNext moves them to cache_queue_ + queue bucket_; + /// + Timeout timer; + /// + bool running_; + + /** This is the 'threaded' method, that does the loading in the + * background. + */ + void loadNext(); + /// + void startLoader(); + /// + void stopLoader(); +}; + + +//static int s_numimages_ = 5; +//static int s_millisecs_ = 500; + +// FIXME THREAD +static int s_numimages_ = 10; +static int s_millisecs_ = 500; + +LoaderQueue & LoaderQueue::get() +{ + static LoaderQueue singleton; + return singleton; +} + + +void LoaderQueue::loadNext() +{ + LYXERR(Debug::GRAPHICS, "LoaderQueue: " + << cache_queue_.size() << " items in the queue"); + int counter = s_numimages_; + while (!cache_queue_.empty() && counter--) { + Cache::ItemPtr ptr = cache_queue_.front(); + cache_set_.erase(ptr); + cache_queue_.pop_front(); + if (ptr->status() == WaitingToLoad) + ptr->startLoading(); + } + if (!cache_queue_.empty()) + startLoader(); + else + stopLoader(); +} + + +LoaderQueue::LoaderQueue() : timer(s_millisecs_, Timeout::ONETIME), + running_(false) +{ + timer.timeout.connect(bind(&LoaderQueue::loadNext, this)); +} + + +void LoaderQueue::startLoader() +{ + LYXERR(Debug::GRAPHICS, "LoaderQueue: waking up"); + running_ = true ; + timer.setTimeout(s_millisecs_); + timer.start(); +} + + +void LoaderQueue::stopLoader() +{ + timer.stop(); + running_ = false ; + LYXERR(Debug::GRAPHICS, "LoaderQueue: I'm going to sleep"); +} + + +bool LoaderQueue::running() const +{ + return running_ ; +} + + +void LoaderQueue::touch(Cache::ItemPtr const & item) +{ + if (! cache_set_.insert(item).second) { + list::iterator + it = cache_queue_.begin(); + list::iterator + end = cache_queue_.end(); + + it = find(it, end, item); + if (it != end) + cache_queue_.erase(it); + } + cache_queue_.push_front(item); + if (!running_) + startLoader(); +} + + + +///////////////////////////////////////////////////////////////////// +// +// GraphicsLoader +// +///////////////////////////////////////////////////////////////////// + +typedef shared_ptr ImagePtr; class Loader::Impl : public boost::signals::trackable { public: @@ -55,7 +185,7 @@ public: */ Cache::ItemPtr cached_item_; /// We modify a local copy of the image once it is loaded. - Image::ImagePtr image_; + ImagePtr image_; /// This signal is emitted when the image loading status changes. boost::signal signal_; /// The connection of the signal StatusChanged @@ -77,10 +207,10 @@ Loader::Loader() {} -Loader::Loader(FileName const & file, DisplayType type) +Loader::Loader(FileName const & file, bool display) : pimpl_(new Impl) { - reset(file, type); + reset(file, display); } @@ -100,7 +230,9 @@ Loader::Loader(Loader const & other) Loader::~Loader() -{} +{ + delete pimpl_; +} Loader & Loader::operator=(Loader const & other) @@ -113,10 +245,10 @@ Loader & Loader::operator=(Loader const & other) } -void Loader::reset(FileName const & file, DisplayType type) const +void Loader::reset(FileName const & file, bool display) const { Params params; - params.display = type; + params.display = display; pimpl_->resetParams(params); pimpl_->resetFile(file); @@ -141,15 +273,21 @@ void Loader::reset(Params const & params) const void Loader::startLoading() const { - if (pimpl_->status_ != WaitingToLoad || !pimpl_->cached_item_.get()) + if (pimpl_->status_ != WaitingToLoad || !pimpl_->cached_item_) return; pimpl_->startLoading(); } +void Loader::reload() const +{ + pimpl_->cached_item_->startLoading(); +} + + void Loader::startMonitoring() const { - if (!pimpl_->cached_item_.get()) + if (!pimpl_->cached_item_) return; pimpl_->cached_item_->startMonitoring(); @@ -158,7 +296,7 @@ void Loader::startMonitoring() const bool Loader::monitoring() const { - if (!pimpl_->cached_item_.get()) + if (!pimpl_->cached_item_) return false; return pimpl_->cached_item_->monitoring(); @@ -167,7 +305,7 @@ bool Loader::monitoring() const unsigned long Loader::checksum() const { - if (!pimpl_->cached_item_.get()) + if (!pimpl_->cached_item_) return 0; return pimpl_->cached_item_->checksum(); @@ -177,7 +315,7 @@ unsigned long Loader::checksum() const FileName const & Loader::filename() const { static FileName const empty; - return pimpl_->cached_item_.get() ? + return pimpl_->cached_item_ ? pimpl_->cached_item_->filename() : empty; } @@ -208,14 +346,13 @@ Loader::Impl::Impl() Loader::Impl::~Impl() { - if (!quitting) - resetFile(FileName()); + resetFile(FileName()); } void Loader::Impl::resetFile(FileName const & file) { - FileName const old_file = cached_item_.get() ? + FileName const old_file = cached_item_ ? cached_item_->filename() : FileName(); if (file == old_file) @@ -231,13 +368,17 @@ void Loader::Impl::resetFile(FileName const & file) // signal needs to be disconnected. sc_.disconnect(); cached_item_.reset(); - Cache::get().remove(old_file); + if (status_ != Converting) { + Cache::get().remove(old_file); + } else { + //TODO remove cache item when it is not busy any more, see #7163 + } } - status_ = cached_item_.get() ? cached_item_->status() : WaitingToLoad; + status_ = cached_item_ ? cached_item_->status() : WaitingToLoad; image_.reset(); - if (cached_item_.get() || file.empty()) + if (cached_item_ || file.empty()) return; Cache & gc = Cache::get(); @@ -251,7 +392,7 @@ void Loader::Impl::resetFile(FileName const & file) if (continue_monitoring && !cached_item_->monitoring()) cached_item_->startMonitoring(); - sc_ = cached_item_->connect(boost::bind(&Impl::statusChanged, this)); + sc_ = cached_item_->connect(bind(&Impl::statusChanged, this)); } @@ -261,14 +402,14 @@ void Loader::Impl::resetParams(Params const & params) return; params_ = params; - status_ = cached_item_.get() ? cached_item_->status() : WaitingToLoad; + status_ = cached_item_ ? cached_item_->status() : WaitingToLoad; image_.reset(); } void Loader::Impl::statusChanged() { - status_ = cached_item_.get() ? cached_item_->status() : WaitingToLoad; + status_ = cached_item_ ? cached_item_->status() : WaitingToLoad; createPixmap(); signal_(); } @@ -276,16 +417,21 @@ void Loader::Impl::statusChanged() void Loader::Impl::createPixmap() { - if (!cached_item_.get() || - params_.display == NoDisplay || status_ != Loaded) + if (!params_.display || status_ != Loaded) return; - image_.reset(cached_item_->image()->clone()); + if (!cached_item_) { + LYXERR(Debug::GRAPHICS, "pixmap not cached yet"); + return; + } + + if (!cached_item_->image()) { + // There must have been a problem reading the file. + LYXERR(Debug::GRAPHICS, "Graphics file not loaded."); + return; + } - // These do nothing if there's nothing to do - image_->clip(params_); - image_->rotate(params_); - image_->scale(params_); + image_.reset(cached_item_->image()->clone()); bool const success = image_->setPixmap(params_); @@ -302,6 +448,12 @@ void Loader::Impl::startLoading() if (status_ != WaitingToLoad) return; + if (cached_item_->tryDisplayFormat()) { + status_ = Loaded; + createPixmap(); + return; + } + LoaderQueue::get().touch(cached_item_); }