X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fgraphics%2FGraphicsLoader.cpp;h=f0a09340916f649b2df3e5fe75968d87aa59ab1a;hb=c0a59871813d853ba455ec8d39be61db4f4b2848;hp=c5a6326d82460683c97e3541119e310cd151da3c;hpb=2e79520f6b482391da9d8ebf3dbfc4ec3dc58bca;p=lyx.git

diff --git a/src/graphics/GraphicsLoader.cpp b/src/graphics/GraphicsLoader.cpp
index c5a6326d82..f0a0934091 100644
--- a/src/graphics/GraphicsLoader.cpp
+++ b/src/graphics/GraphicsLoader.cpp
@@ -16,24 +16,22 @@
 #include "GraphicsImage.h"
 #include "GraphicsParams.h"
 #include "GraphicsCache.h"
-#include "debug.h"
 
+#include "support/debug.h"
+#include "support/lassert.h"
 #include "support/Timeout.h"
 
-#include <boost/bind.hpp>
-
-#include <set>
 #include <queue>
+#include <memory>
+#include <set>
 
-using std::string;
-using std::endl;
-using std::list;
-
+using namespace std;
+using namespace lyx::support;
 
 namespace lyx {
+
 namespace graphics {
 
-using support::FileName;
 
 /////////////////////////////////////////////////////////////////////
 //
@@ -53,11 +51,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;
 	///
@@ -74,11 +72,11 @@ private:
 };
 
 
-//static int s_numimages_ = 5;
-//static int s_millisecs_ = 500;
 
-static int s_numimages_ = 10;
-static int s_millisecs_ = 500;
+//static int const s_numimages_ = 5;
+static int const s_numimages_ = 10;
+static int const s_millisecs_ = 500;
+
 
 LoaderQueue & LoaderQueue::get()
 {
@@ -92,32 +90,32 @@ void LoaderQueue::loadNext()
 	LYXERR(Debug::GRAPHICS, "LoaderQueue: "
 		<< cache_queue_.size() << " items in the queue");
 	int counter = s_numimages_;
-	while (cache_queue_.size() && counter--) {
+	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_.size()) {
+	if (!cache_queue_.empty())
 		startLoader();
-	} else {
+	else
 		stopLoader();
-	}
 }
 
 
 LoaderQueue::LoaderQueue() : timer(s_millisecs_, Timeout::ONETIME),
-			     running_(false)
+                             running_(false)
 {
-	timer.timeout.connect(boost::bind(&LoaderQueue::loadNext, this));
+	// Disconnected when this is destroyed
+	timer.timeout.connect([this](){ loadNext(); });
 }
 
 
 void LoaderQueue::startLoader()
 {
 	LYXERR(Debug::GRAPHICS, "LoaderQueue: waking up");
-	running_ = true ;
+	running_ = true;
 	timer.setTimeout(s_millisecs_);
 	timer.start();
 }
@@ -145,7 +143,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);
 	}
@@ -162,12 +160,13 @@ void LoaderQueue::touch(Cache::ItemPtr const & item)
 //
 /////////////////////////////////////////////////////////////////////
 
-typedef boost::shared_ptr<Image> ImagePtr;
+typedef std::shared_ptr<Image> ImagePtr;
 
-class Loader::Impl : public boost::signals::trackable {
+class Loader::Impl {
+	friend class Loader;
 public:
 	///
-	Impl();
+	Impl(FileName const & doc_file);
 	///
 	~Impl();
 	///
@@ -181,6 +180,8 @@ public:
 	///
 	Params const & params() const { return params_; }
 
+	///
+	FileName doc_file_;
 	/// The loading status of the image.
 	ImageStatus status_;
 	/** Must store a copy of the cached item to ensure that it is not
@@ -190,9 +191,18 @@ public:
 	/// We modify a local copy of the image once it is loaded.
 	ImagePtr image_;
 	/// This signal is emitted when the image loading status changes.
-	boost::signal<void()> signal_;
-	/// The connection of the signal StatusChanged 	
-	boost::signals::connection sc_;
+	signals2::signal<void()> signal_;
+	/// The connection of the signal statusChanged
+	signals2::scoped_connection connection_;
+
+	double displayPixelRatio() const
+	{
+		return params_.pixel_ratio;
+	}
+	void setDisplayPixelRatio(double scale)
+	{
+		params_.pixel_ratio = scale;
+	}
 
 private:
 	///
@@ -205,27 +215,35 @@ private:
 };
 
 
-Loader::Loader()
-	: pimpl_(new Impl)
+Loader::Loader(FileName const & doc_file)
+	: pimpl_(new Impl(doc_file))
 {}
 
 
-Loader::Loader(FileName const & file, DisplayType type)
-	: pimpl_(new Impl)
+Loader::Loader(FileName const & doc_file, FileName const & file, bool display)
+	: pimpl_(new Impl(doc_file))
 {
-	reset(file, type);
+	reset(file, display);
 }
 
 
-Loader::Loader(FileName const & file, Params const & params)
-	: pimpl_(new Impl)
+Loader::Loader(FileName const & doc_file, FileName const & file, Params const & params)
+	: pimpl_(new Impl(doc_file))
 {
 	reset(file, params);
 }
 
 
+Loader::Loader(FileName const & doc_file, Loader const & other)
+	: pimpl_(new Impl(doc_file))
+{
+	Params const & params = other.pimpl_->params();
+	reset(params.filename, params);
+}
+
+
 Loader::Loader(Loader const & other)
-	: pimpl_(new Impl)
+	: pimpl_(new Impl(other.pimpl_->doc_file_))
 {
 	Params const & params = other.pimpl_->params();
 	reset(params.filename, params);
@@ -240,7 +258,10 @@ Loader::~Loader()
 
 Loader & Loader::operator=(Loader const & other)
 {
+  LASSERT(false, /**/);
 	if (this != &other) {
+		delete pimpl_;
+		pimpl_ = new Impl(other.pimpl_->doc_file_);
 		Params const & params = other.pimpl_->params();
 		reset(params.filename, params);
 	}
@@ -248,10 +269,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);
@@ -276,15 +297,22 @@ 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_
+	    || pimpl_->cached_item_->status() == Converting)
 		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();
@@ -293,26 +321,26 @@ void Loader::startMonitoring() const
 
 bool Loader::monitoring() const
 {
-	if (!pimpl_->cached_item_.get())
+	if (!pimpl_->cached_item_)
 		return false;
 
 	return pimpl_->cached_item_->monitoring();
 }
 
 
-unsigned long Loader::checksum() const
+void Loader::checkModifiedAsync() const
 {
-	if (!pimpl_->cached_item_.get())
-		return 0;
+	if (!pimpl_->cached_item_)
+		return;
 
-	return pimpl_->cached_item_->checksum();
+	pimpl_->cached_item_->checkModifiedAsync();
 }
 
 
 FileName const & Loader::filename() const
 {
 	static FileName const empty;
-	return pimpl_->cached_item_.get() ?
+	return pimpl_->cached_item_ ?
 		pimpl_->cached_item_->filename() : empty;
 }
 
@@ -323,7 +351,19 @@ ImageStatus Loader::status() const
 }
 
 
-boost::signals::connection Loader::connect(slot_type const & slot) const
+double Loader::displayPixelRatio() const
+{
+	return pimpl_->displayPixelRatio();
+}
+
+
+void Loader::setDisplayPixelRatio(double scale)
+{
+	pimpl_->setDisplayPixelRatio(scale);
+}
+
+
+signals2::connection Loader::connect(slot const & slot) const
 {
 	return pimpl_->signal_.connect(slot);
 }
@@ -335,8 +375,8 @@ Image const * Loader::image() const
 }
 
 
-Loader::Impl::Impl()
-	: status_(WaitingToLoad)
+Loader::Impl::Impl(FileName const & doc_file)
+	: doc_file_(doc_file), status_(WaitingToLoad)
 {
 }
 
@@ -349,7 +389,7 @@ Loader::Impl::~Impl()
 
 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)
@@ -363,20 +403,29 @@ void Loader::Impl::resetFile(FileName const & file)
 		continue_monitoring = cached_item_->monitoring();
 		// cached_item_ is going to be reset, so the connected
 		// signal needs to be disconnected.
-		sc_.disconnect();
+		try {
+			// This can in theory throw a BufferException
+			connection_.disconnect();
+		} catch (...) {
+			LYXERR(Debug::GRAPHICS, "Unable to disconnect signal.");
+		}
 		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();
 	if (!gc.inCache(file))
-		gc.add(file);
+		gc.add(file, doc_file_);
 
 	// We /must/ make a local copy of this.
 	cached_item_ = gc.item(file);
@@ -385,7 +434,8 @@ 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));
+	// This is a scoped connection
+	connection_ = cached_item_->connect([this](){ statusChanged(); });
 }
 
 
@@ -395,14 +445,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_();
 }
@@ -410,16 +460,31 @@ void Loader::Impl::statusChanged()
 
 void Loader::Impl::createPixmap()
 {
-	if (!cached_item_.get() ||
-	    params_.display == NoDisplay || status_ != Loaded)
+	if (!params_.display || status_ != Loaded)
 		return;
 
+	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;
+	}
+
 	image_.reset(cached_item_->image()->clone());
 
-	// These do nothing if there's nothing to do
-	image_->clip(params_);
-	image_->rotate(params_);
-	image_->scale(params_);
+	if (params_.pixel_ratio == 1.0) {
+		string filename = cached_item_->filename().absFileName();
+		size_t idx = filename.find_last_of('.');
+		if (idx != string::npos && idx > 3) {
+			if (filename.substr(idx - 3, 3) == "@2x") {
+				params_.pixel_ratio = 2.0;
+			}
+		}
+	}
 
 	bool const success = image_->setPixmap(params_);
 
@@ -436,6 +501,12 @@ void Loader::Impl::startLoading()
 	if (status_ != WaitingToLoad)
 		return;
 
+	if (cached_item_->tryDisplayFormat()) {
+		status_ = Loaded;
+		createPixmap();
+		return;
+	}
+
 	LoaderQueue::get().touch(cached_item_);
 }