GuiTabular.cpp: don't hardcode decimal align combobox item

[lyx.git] / src / graphics / GraphicsLoader.cpp

diff --git a/src/graphics/GraphicsLoader.cpp b/src/graphics/GraphicsLoader.cpp
index 5545ed194e4075b5585d6fdfbf3effa5c11b5c01..36f2839446bbd12f5e0e4cc4b9cf9860f217e438 100644 (file)
--- a/src/graphics/GraphicsLoader.cpp
+++ b/src/graphics/GraphicsLoader.cpp
@@ -16,21 +16,21 @@
 #include "GraphicsImage.h"
 #include "GraphicsParams.h"
 #include "GraphicsCache.h"
-#include "support/debug.h"
 
+#include "support/debug.h"
 #include "support/Timeout.h"
 
-#include <boost/bind.hpp>
+#include "support/bind.h"
 
 #include <set>
 #include <queue>
 
 using namespace std;
+using namespace lyx::support;
 
 namespace lyx {
 namespace graphics {
 
-using support::FileName;
 
 /////////////////////////////////////////////////////////////////////
 //
@@ -50,11 +50,11 @@ private:
        /// This class is a singleton class... use LoaderQueue::get() instead
        LoaderQueue();
        /// The in-progress loading queue (elements are unique here).
-       std::list<Cache::ItemPtr> cache_queue_;
+       list<Cache::ItemPtr> cache_queue_;
        /// Used to make the insertion of new elements faster.
-       std::set<Cache::ItemPtr> cache_set_;
+       set<Cache::ItemPtr> cache_set_;
        /// Newly touched elements go here. loadNext moves them to cache_queue_
-       std::queue<Cache::ItemPtr> bucket_;
+       queue<Cache::ItemPtr> bucket_;
        ///
        Timeout timer;
        ///
@@ -96,7 +96,7 @@ void LoaderQueue::loadNext()
                if (ptr->status() == WaitingToLoad)
                        ptr->startLoading();
        }
-       if (cache_queue_.size()) {
+       if (!cache_queue_.empty()) {
                startLoader();
        } else {
                stopLoader();
@@ -107,7 +107,7 @@ void LoaderQueue::loadNext()
 LoaderQueue::LoaderQueue() : timer(s_millisecs_, Timeout::ONETIME),
                             running_(false)
 {
-       timer.timeout.connect(boost::bind(&LoaderQueue::loadNext, this));
+       timer.timeout.connect(bind(&LoaderQueue::loadNext, this));
 }
 
 
@@ -142,7 +142,7 @@ void LoaderQueue::touch(Cache::ItemPtr const & item)
                list<Cache::ItemPtr>::iterator
                        end = cache_queue_.end();
 
-               it = std::find(it, end, item);
+               it = find(it, end, item);
                if (it != end)
                        cache_queue_.erase(it);
        }
@@ -159,7 +159,7 @@ void LoaderQueue::touch(Cache::ItemPtr const & item)
 //
 /////////////////////////////////////////////////////////////////////
 
-typedef boost::shared_ptr<Image> ImagePtr;
+typedef shared_ptr<Image> ImagePtr;
 
 class Loader::Impl : public boost::signals::trackable {
 public:
@@ -207,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);
 }
 
 
@@ -245,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);
@@ -279,6 +279,12 @@ void Loader::startLoading() const
 }
 
 
+void Loader::reload() const 
+{
+       pimpl_->cached_item_->startLoading();
+}
+
+
 void Loader::startMonitoring() const
 {
        if (!pimpl_->cached_item_.get())
@@ -362,7 +368,11 @@ 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;
@@ -382,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));
 }
 
 
@@ -407,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_.get()) {
+               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_);
 
@@ -433,6 +448,12 @@ void Loader::Impl::startLoading()
        if (status_ != WaitingToLoad)
                return;
 
+       if (cached_item_->tryDisplayFormat()) {
+               status_ = Loaded;
+               createPixmap();
+               return;
+       }
+
        LoaderQueue::get().touch(cached_item_);
 }