--- /dev/null
+commit 465cd79bcbab3e036cf86ab4682386c255a91eb6
+Author: Pavel Sanda <psanda@ucsd.edu>
+Date: Thu Nov 16 09:33:29 2017 -0800
+
+ move initialization so older gcc still works
+
+diff --git a/src/frontends/qt4/GuiView.cpp b/src/frontends/qt4/GuiView.cpp
+index 68ef3b9..b76138b 100644
+--- a/src/frontends/qt4/GuiView.cpp
++++ b/src/frontends/qt4/GuiView.cpp
+@@ -508,7 +508,7 @@ QSet<Buffer const *> GuiView::GuiViewPrivate::busyBuffers;
+
+ GuiView::GuiView(int id)
+ : d(*new GuiViewPrivate(this)), id_(id), closing_(false), busy_(0),
+- command_execute_(false), minibuffer_focus_(false), devel_mode_(false)
++ command_execute_(false), minibuffer_focus_(false), zoom_ratio_(1.0), devel_mode_(false)
+ {
+ connect(this, SIGNAL(bufferViewChanged()),
+ this, SLOT(onBufferViewChanged()));
+diff --git a/src/frontends/qt4/GuiView.h b/src/frontends/qt4/GuiView.h
+index ecf4e44..ed80ca3 100644
+--- a/src/frontends/qt4/GuiView.h
++++ b/src/frontends/qt4/GuiView.h
+@@ -472,7 +472,7 @@ private:
+
+ /// The rate from which the actual zoom value is calculated
+ /// from the default zoom pref
+- double zoom_ratio_ = 1.0;
++ double zoom_ratio_;
+ /// Minimum zoom percentage
+ static int const zoom_min_ = 10;
+
+
+commit de8c60ba2a3779b31a1d8526541a9583b076221c
+Author: Pavel Sanda <psanda@ucsd.edu>
+Date: Thu Nov 16 09:15:07 2017 -0800
+
+ Revert b30161b59 (Remove FileMonitorBlocker which does not work reliably on all platforms)
+
+diff --git a/src/Buffer.cpp b/src/Buffer.cpp
+index 9ec20e0..6e37ee9 100644
+--- a/src/Buffer.cpp
++++ b/src/Buffer.cpp
+@@ -383,6 +383,9 @@ public:
+ /// Notify or clear of external modification
+ void fileExternallyModified(bool exists);
+
++ /// Block notifications of external modifications
++ FileMonitorBlocker blockFileMonitor() { return file_monitor_->block(); }
++
+ /// has been externally modified? Can be reset by the user.
+ mutable bool externally_modified_;
+
+@@ -1379,6 +1382,7 @@ FileName Buffer::getBackupName() const {
+ // Should probably be moved to somewhere else: BufferView? GuiView?
+ bool Buffer::save() const
+ {
++ FileMonitorBlocker block = d->blockFileMonitor();
+ docstring const file = makeDisplayPath(absFileName(), 20);
+ d->filename.refresh();
+
+@@ -5344,7 +5348,8 @@ void Buffer::Impl::refreshFileMonitor()
+
+ void Buffer::Impl::fileExternallyModified(bool const exists)
+ {
+- // ignore notifications after our own saving operations
++ // prevent false positives, because FileMonitorBlocker is not enough on
++ // OSX.
+ if (checksum_ == filename.checksum()) {
+ LYXERR(Debug::FILES, "External modification but "
+ "checksum unchanged: " << filename);
+diff --git a/src/support/FileMonitor.cpp b/src/support/FileMonitor.cpp
+index c703d2b..2a794f2 100644
+--- a/src/support/FileMonitor.cpp
++++ b/src/support/FileMonitor.cpp
+@@ -202,6 +202,42 @@ void FileMonitor::changed(bool const exists)
+ }
+
+
++FileMonitorBlocker FileMonitor::block(int delay)
++{
++ FileMonitorBlocker blocker = blocker_.lock();
++ if (!blocker)
++ blocker_ = blocker = make_shared<FileMonitorBlockerGuard>(this);
++ blocker->setDelay(delay);
++ return blocker;
++}
++
++
++FileMonitorBlockerGuard::FileMonitorBlockerGuard(FileMonitor * monitor)
++ : monitor_(monitor), delay_(0)
++{
++ QObject::disconnect(monitor->monitor_.get(), SIGNAL(fileChanged(bool)),
++ monitor, SLOT(changed(bool)));
++}
++
++
++void FileMonitorBlockerGuard::setDelay(int delay)
++{
++ delay_ = max(delay_, delay);
++}
++
++
++FileMonitorBlockerGuard::~FileMonitorBlockerGuard()
++{
++ if (!monitor_)
++ return;
++ // Even if delay_ is 0, the QTimer is necessary. Indeed, the notifications
++ // from QFileSystemWatcher that we meant to ignore are not going to be
++ // treated immediately, so we must yield to give us the opportunity to
++ // ignore them.
++ QTimer::singleShot(delay_, monitor_, SLOT(connectToFileMonitorGuard()));
++}
++
++
+ ActiveFileMonitor::ActiveFileMonitor(std::shared_ptr<FileMonitorGuard> monitor,
+ FileName const & filename, int interval)
+ : FileMonitor(monitor), filename_(filename), interval_(interval),
+diff --git a/src/support/FileMonitor.h b/src/support/FileMonitor.h
+index 14aa834..fdf2bca 100644
+--- a/src/support/FileMonitor.h
++++ b/src/support/FileMonitor.h
+@@ -60,6 +60,12 @@ typedef std::unique_ptr<ActiveFileMonitor> ActiveFileMonitorPtr;
+ /// monitor.connect(...);
+ /// (stops watching the first)
+ ///
++/// Block notifications for the duration of a scope:
++/// {
++/// FileMonitorBlocker block = monitor.block();
++/// ...
++/// }
++///
+ /// Reset connections:
+ /// monitor.disconnect();
+ /// or the disconnect method of the connection object for the boost signal.
+@@ -125,10 +131,27 @@ private:
+ };
+
+
++class FileMonitorBlockerGuard : public QObject
++{
++ Q_OBJECT
++ QPointer<FileMonitor> monitor_;
++ int delay_;
++
++public:
++ FileMonitorBlockerGuard(FileMonitor * monitor);
++ ~FileMonitorBlockerGuard();
++ void setDelay(int delay);
++};
++
++
++typedef std::shared_ptr<FileMonitorBlockerGuard> FileMonitorBlocker;
++
++
+ /// Main class
+ class FileMonitor : public QObject
+ {
+ Q_OBJECT
++ friend class FileMonitorBlockerGuard;
+
+ public:
+ FileMonitor(std::shared_ptr<FileMonitorGuard> monitor);
+@@ -142,6 +165,20 @@ public:
+ void disconnect();
+ /// absolute path being tracked
+ std::string const & filename() { return monitor_->filename(); }
++ /// Creates a guard that blocks notifications. Copyable. Notifications from
++ /// this monitor are blocked as long as there are copies of the
++ /// FileMonitorBlocker around.
++ /// \param delay is the amount waited in ms after expiration of the guard
++ /// before reconnecting. It can be used to slow down incoming events
++ /// accordingly. A value of 0 is still made asynchronous, because of the
++ /// fundamentally asynchronous nature of QFileSystemWatcher. To catch one's
++ /// own file operations, a value of 0 for delay is sufficient with the
++ /// inotify backend (e.g. Linux); for OSX (kqueue), a value of 100ms is
++ /// unsufficient and more tests need to be done in combination with
++ /// flushing/syncing to disk in order to understand how to catch one's own
++ /// operations reliably. No feedback about Windows. See
++ /// <https://www.mail-archive.com/lyx-devel@lists.lyx.org/msg200252.html>.
++ FileMonitorBlocker block(int delay = 0);
+ /// Make sure the good file is being monitored, after e.g. a move or a
+ /// deletion. See <https://bugreports.qt.io/browse/QTBUG-46483>. This is
+ /// called automatically.
+@@ -162,6 +199,8 @@ private:
+ sig fileChanged_;
+ /// the unique watch for our file
+ std::shared_ptr<FileMonitorGuard> const monitor_;
++ ///
++ std::weak_ptr<FileMonitorBlockerGuard> blocker_;
+ };
+
+
+
+commit ab4584d9a5747aad2c23cf7b26ee05a30de89bc9
+Author: Pavel Sanda <psanda@ucsd.edu>
+Date: Thu Nov 16 09:22:11 2017 -0800
+
+ Revert b30161b591264f : If the external modification is a deletion, do not ask for reloading.
+
+diff --git a/src/Buffer.cpp b/src/Buffer.cpp
+index 6e37ee9..b83f872 100644
+--- a/src/Buffer.cpp
++++ b/src/Buffer.cpp
+@@ -380,15 +380,15 @@ public:
+ // Make sure the file monitor monitors the good file.
+ void refreshFileMonitor();
+
++ /// has it been notified of an external modification?
++ bool isExternallyModified() const { return externally_modified_; }
++
+ /// Notify or clear of external modification
+- void fileExternallyModified(bool exists);
++ void fileExternallyModified(bool modified);
+
+ /// Block notifications of external modifications
+ FileMonitorBlocker blockFileMonitor() { return file_monitor_->block(); }
+
+- /// has been externally modified? Can be reset by the user.
+- mutable bool externally_modified_;
+-
+ private:
+ /// So we can force access via the accessors.
+ mutable Buffer const * parent_buffer;
+@@ -397,6 +397,9 @@ private:
+ int char_count_;
+ int blank_count_;
+
++ /// has been externally modified? Can be reset by the user.
++ mutable bool externally_modified_;
++
+ FileMonitorPtr file_monitor_;
+ };
+
+@@ -438,8 +441,9 @@ Buffer::Impl::Impl(Buffer * owner, FileName const & file, bool readonly_,
+ bibfile_cache_valid_(false), cite_labels_valid_(false), preview_error_(false),
+ inset(0), preview_loader_(0), cloned_buffer_(cloned_buffer),
+ clone_list_(0), doing_export(false),
+- tracked_changes_present_(0), externally_modified_(false), parent_buffer(0),
+- word_count_(0), char_count_(0), blank_count_(0)
++ tracked_changes_present_(0), parent_buffer(0),
++ word_count_(0), char_count_(0), blank_count_(0),
++ externally_modified_(false)
+ {
+ refreshFileMonitor();
+ if (!cloned_buffer_) {
+@@ -5338,29 +5342,26 @@ void Buffer::Impl::refreshFileMonitor()
+ // The previous file monitor is invalid
+ // This also destroys the previous file monitor and all its connections
+ file_monitor_ = FileSystemWatcher::monitor(filename);
++ fileExternallyModified(false);
+ // file_monitor_ will be destroyed with *this, so it is not going to call a
+ // destroyed object method.
+- file_monitor_->connect([this](bool exists) {
+- fileExternallyModified(exists);
+- });
++ file_monitor_->connect([this](){ fileExternallyModified(true); });
+ }
+
+
+ void Buffer::Impl::fileExternallyModified(bool const exists)
+ {
+- // prevent false positives, because FileMonitorBlocker is not enough on
+- // OSX.
+- if (checksum_ == filename.checksum()) {
++ if (modified) {
++ // prevent false positives, because FileMonitorBlocker is not enough on
++ // OSX.
++ if (filename.exists() && checksum_ == filename.checksum()) {
+ LYXERR(Debug::FILES, "External modification but "
+- "checksum unchanged: " << filename);
++ "checksum unchanged: " << filename);
+ return;
++ }
++ lyx_clean = bak_clean = false;
+ }
+- lyx_clean = bak_clean = false;
+- // If the file has been deleted, only mark the file as dirty since it is
+- // pointless to prompt for reloading. If later a file is moved into this
+- // location, then the externally modified warning will appear then.
+- if (exists)
+- externally_modified_ = true;
++ externally_modified_ = modified;
+ // Update external modification notification.
+ // Dirty buffers must be visible at all times.
+ if (wa_ && wa_->unhide(owner_))
+@@ -5373,15 +5374,13 @@ void Buffer::Impl::fileExternallyModified(bool const exists)
+
+ bool Buffer::notifiesExternalModification() const
+ {
+- return d->externally_modified_;
++ return d->isExternallyModified();
+ }
+
+
+ void Buffer::clearExternalModification() const
+ {
+- d->externally_modified_ = false;
+- if (d->wa_)
+- d->wa_->updateTitles();
++ d->fileExternallyModified(false);
+ }
+
+
+diff --git a/src/graphics/GraphicsCacheItem.cpp b/src/graphics/GraphicsCacheItem.cpp
+index f54ce80..576ad92 100644
+--- a/src/graphics/GraphicsCacheItem.cpp
++++ b/src/graphics/GraphicsCacheItem.cpp
+@@ -220,7 +220,7 @@ void CacheItem::Impl::startMonitor()
+ return;
+ monitor_ = FileSystemWatcher::activeMonitor(filename_);
+ // Disconnected at the same time as this is destroyed.
+- monitor_->connect([=](bool /* exists */){ startLoading(); });
++ monitor_->connect([=](){ startLoading(); });
+ }
+
+
+diff --git a/src/insets/RenderPreview.cpp b/src/insets/RenderPreview.cpp
+index df0ac64..18882fc 100644
+--- a/src/insets/RenderPreview.cpp
++++ b/src/insets/RenderPreview.cpp
+@@ -304,7 +304,7 @@ void RenderMonitoredPreview::startMonitoring() const
+ {
+ if (!monitoring()) {
+ monitor_ = FileSystemWatcher::activeMonitor(filename_);
+- monitor_->connect([this](bool /* exists */){ changed_(); });
++ monitor_->connect(changed_);
+ }
+ }
+
+diff --git a/src/support/FileMonitor.cpp b/src/support/FileMonitor.cpp
+index 2a794f2..f1fefb8 100644
+--- a/src/support/FileMonitor.cpp
++++ b/src/support/FileMonitor.cpp
+@@ -118,37 +118,31 @@ FileMonitorGuard::~FileMonitorGuard()
+ }
+
+
+-void FileMonitorGuard::refresh(bool const emit)
++void FileMonitorGuard::refresh()
+ {
+ if (filename_.empty())
+ return;
+ QString const qfilename = toqstr(filename_);
+- if (!qwatcher_->files().contains(qfilename)) {
+- bool const existed = exists_;
+- exists_ = QFile(qfilename).exists();
++ if(!qwatcher_->files().contains(qfilename)) {
++ bool exists = QFile(qfilename).exists();
+ #if (QT_VERSION >= 0x050000)
+- if (exists_ && !qwatcher_->addPath(qfilename))
++ if (!exists || !qwatcher_->addPath(qfilename))
+ #else
+ auto add_path = [&]() {
+ qwatcher_->addPath(qfilename);
+ return qwatcher_->files().contains(qfilename);
+ };
+- if (exists_ && !add_path())
++ if (!exists || !add_path())
+ #endif
+ {
+- LYXERR(Debug::FILES,
+- "Could not add path to QFileSystemWatcher: " << filename_);
+- QTimer::singleShot(5000, this, SLOT(refresh()));
+- } else {
+- if (!exists_)
+- // The standard way to overwrite a file is to delete it and
+- // create a new file with the same name. Therefore if the file
+- // has just been deleted, it is smart to check not too long
+- // after whether it has been recreated.
+- QTimer::singleShot(existed ? 100 : 2000, this, SLOT(refresh()));
+- if (existed != exists_ && emit)
+- Q_EMIT fileChanged(exists_);
+- }
++ if (exists)
++ LYXERR(Debug::FILES,
++ "Could not add path to QFileSystemWatcher: "
++ << filename_);
++ QTimer::singleShot(2000, this, SLOT(refresh()));
++ } else if (exists && !exists_)
++ Q_EMIT fileChanged();
++ setExists(exists);
+ }
+ }
+
+@@ -156,12 +150,11 @@ void FileMonitorGuard::refresh(bool const emit)
+ void FileMonitorGuard::notifyChange(QString const & path)
+ {
+ if (path == toqstr(filename_)) {
++ Q_EMIT fileChanged();
+ // If the file has been modified by delete-move, we are notified of the
+ // deletion but we no longer track the file. See
+ // <https://bugreports.qt.io/browse/QTBUG-46483> (not a bug).
+- // Therefore we must refresh.
+- refresh(false);
+- Q_EMIT fileChanged(exists_);
++ refresh();
+ }
+ }
+
+@@ -169,15 +162,17 @@ void FileMonitorGuard::notifyChange(QString const & path)
+ FileMonitor::FileMonitor(std::shared_ptr<FileMonitorGuard> monitor)
+ : monitor_(monitor)
+ {
+- connectToFileMonitorGuard();
++ QObject::connect(monitor_.get(), SIGNAL(fileChanged()),
++ this, SLOT(changed()));
+ refresh();
+ }
+
+
+-void FileMonitor::connectToFileMonitorGuard()
++void FileMonitor::reconnectToFileMonitorGuard()
+ {
+- QObject::connect(monitor_.get(), SIGNAL(fileChanged(bool)),
+- this, SLOT(changed(bool)));
++ monitor_->setExists(true);
++ QObject::connect(monitor_.get(), SIGNAL(fileChanged()),
++ this, SLOT(changed()));
+ }
+
+
+@@ -190,15 +185,15 @@ signals2::connection FileMonitor::connect(slot const & slot)
+ void FileMonitor::disconnect()
+ {
+ fileChanged_.disconnect_all_slots();
+- QObject::disconnect(this, SIGNAL(fileChanged(bool)));
++ QObject::disconnect(this, SIGNAL(fileChanged()));
+ }
+
+
+-void FileMonitor::changed(bool const exists)
++void FileMonitor::changed()
+ {
+ // emit boost signal
+- fileChanged_(exists);
+- Q_EMIT fileChanged(exists);
++ fileChanged_();
++ Q_EMIT fileChanged();
+ }
+
+
+@@ -215,8 +210,8 @@ FileMonitorBlocker FileMonitor::block(int delay)
+ FileMonitorBlockerGuard::FileMonitorBlockerGuard(FileMonitor * monitor)
+ : monitor_(monitor), delay_(0)
+ {
+- QObject::disconnect(monitor->monitor_.get(), SIGNAL(fileChanged(bool)),
+- monitor, SLOT(changed(bool)));
++ QObject::disconnect(monitor->monitor_.get(), SIGNAL(fileChanged()),
++ monitor, SLOT(changed()));
+ }
+
+
+@@ -234,7 +229,7 @@ FileMonitorBlockerGuard::~FileMonitorBlockerGuard()
+ // from QFileSystemWatcher that we meant to ignore are not going to be
+ // treated immediately, so we must yield to give us the opportunity to
+ // ignore them.
+- QTimer::singleShot(delay_, monitor_, SLOT(connectToFileMonitorGuard()));
++ QTimer::singleShot(delay_, monitor_, SLOT(reconnectToFileMonitorGuard()));
+ }
+
+
+@@ -243,9 +238,8 @@ ActiveFileMonitor::ActiveFileMonitor(std::shared_ptr<FileMonitorGuard> monitor,
+ : FileMonitor(monitor), filename_(filename), interval_(interval),
+ timestamp_(0), checksum_(0), cooldown_(true)
+ {
+- QObject::connect(this, SIGNAL(fileChanged(bool)), this, SLOT(setCooldown()));
++ QObject::connect(this, SIGNAL(fileChanged()), this, SLOT(setCooldown()));
+ QTimer::singleShot(interval_, this, SLOT(clearCooldown()));
+- filename_.refresh();
+ if (!filename_.exists())
+ return;
+ timestamp_ = filename_.lastModified();
+@@ -260,9 +254,7 @@ void ActiveFileMonitor::checkModified()
+
+ cooldown_ = true;
+ bool changed = false;
+- filename_.refresh();
+- bool exists = filename_.exists();
+- if (!exists) {
++ if (!filename_.exists()) {
+ changed = timestamp_ || checksum_;
+ timestamp_ = 0;
+ checksum_ = 0;
+@@ -280,7 +272,7 @@ void ActiveFileMonitor::checkModified()
+ }
+ }
+ if (changed)
+- FileMonitor::changed(exists);
++ FileMonitor::changed();
+ QTimer::singleShot(interval_, this, SLOT(clearCooldown()));
+ }
+
+diff --git a/src/support/FileMonitor.h b/src/support/FileMonitor.h
+index fdf2bca..5e516bb 100644
+--- a/src/support/FileMonitor.h
++++ b/src/support/FileMonitor.h
+@@ -108,16 +108,18 @@ public:
+ ~FileMonitorGuard();
+ /// absolute path being tracked
+ std::string const & filename() { return filename_; }
++ /// if false, emit fileChanged() when we notice the existence of the file
++ void setExists(bool exists) { exists_ = exists; }
+
+ public Q_SLOTS:
+ /// Make sure it is being monitored, after e.g. a deletion. See
+ /// <https://bugreports.qt.io/browse/QTBUG-46483>. This is called
+ /// automatically.
+- void refresh(bool emit = true);
++ void refresh();
+
+ Q_SIGNALS:
+ /// Connect to this to be notified when the file changes
+- void fileChanged(bool exists) const;
++ void fileChanged() const;
+
+ private Q_SLOTS:
+ /// Receive notifications from the QFileSystemWatcher
+@@ -126,7 +128,6 @@ private Q_SLOTS:
+ private:
+ std::string const filename_;
+ QFileSystemWatcher * qwatcher_;
+- /// for emitting fileChanged() when the file is created or deleted
+ bool exists_;
+ };
+
+@@ -156,7 +157,7 @@ class FileMonitor : public QObject
+ public:
+ FileMonitor(std::shared_ptr<FileMonitorGuard> monitor);
+
+- typedef signals2::signal<void(bool)> sig;
++ typedef signals2::signal<void()> sig;
+ typedef sig::slot_type slot;
+ /// Connect and you'll be informed when the file has changed.
+ signals2::connection connect(slot const &);
+@@ -176,7 +177,7 @@ public:
+ /// inotify backend (e.g. Linux); for OSX (kqueue), a value of 100ms is
+ /// unsufficient and more tests need to be done in combination with
+ /// flushing/syncing to disk in order to understand how to catch one's own
+- /// operations reliably. No feedback about Windows. See
++ /// operations reliably. No feedback from Windows yet. See
+ /// <https://www.mail-archive.com/lyx-devel@lists.lyx.org/msg200252.html>.
+ FileMonitorBlocker block(int delay = 0);
+ /// Make sure the good file is being monitored, after e.g. a move or a
+@@ -186,13 +187,13 @@ public:
+
+ Q_SIGNALS:
+ /// Connect to this to be notified when the file changes
+- void fileChanged(bool exists) const;
++ void fileChanged() const;
+
+ protected Q_SLOTS:
+ /// Receive notifications from the FileMonitorGuard
+- void changed(bool exists);
++ void changed();
+ ///
+- void connectToFileMonitorGuard();
++ void reconnectToFileMonitorGuard();
+
+ private:
+ /// boost signal
+
+commit f1c415f3b0ae9ddea5548742f5300e86e95480f2
+Author: Pavel Sanda <psanda@ucsd.edu>
+Date: Thu Nov 16 09:24:31 2017 -0800
+
+ Revert 2058faaa3bd: Prevent false positives in external modifications
+
+diff --git a/src/Buffer.cpp b/src/Buffer.cpp
+index b83f872..48391f9 100644
+--- a/src/Buffer.cpp
++++ b/src/Buffer.cpp
+@@ -387,7 +387,7 @@ public:
+ void fileExternallyModified(bool modified);
+
+ /// Block notifications of external modifications
+- FileMonitorBlocker blockFileMonitor() { return file_monitor_->block(); }
++ FileMonitorBlocker blockFileMonitor() { return file_monitor_->block(10); }
+
+ private:
+ /// So we can force access via the accessors.
+@@ -5351,16 +5351,8 @@ void Buffer::Impl::refreshFileMonitor()
+
+ void Buffer::Impl::fileExternallyModified(bool const exists)
+ {
+- if (modified) {
+- // prevent false positives, because FileMonitorBlocker is not enough on
+- // OSX.
+- if (filename.exists() && checksum_ == filename.checksum()) {
+- LYXERR(Debug::FILES, "External modification but "
+- "checksum unchanged: " << filename);
+- return;
+- }
++ if (modified)
+ lyx_clean = bak_clean = false;
+- }
+ externally_modified_ = modified;
+ // Update external modification notification.
+ // Dirty buffers must be visible at all times.
+diff --git a/src/support/FileMonitor.h b/src/support/FileMonitor.h
+index 5e516bb..49f12cb 100644
+--- a/src/support/FileMonitor.h
++++ b/src/support/FileMonitor.h
+@@ -167,18 +167,11 @@ public:
+ /// absolute path being tracked
+ std::string const & filename() { return monitor_->filename(); }
+ /// Creates a guard that blocks notifications. Copyable. Notifications from
+- /// this monitor are blocked as long as there are copies of the
+- /// FileMonitorBlocker around.
++ /// this monitor are blocked as long as there are copies around.
+ /// \param delay is the amount waited in ms after expiration of the guard
+- /// before reconnecting. It can be used to slow down incoming events
+- /// accordingly. A value of 0 is still made asynchronous, because of the
+- /// fundamentally asynchronous nature of QFileSystemWatcher. To catch one's
+- /// own file operations, a value of 0 for delay is sufficient with the
+- /// inotify backend (e.g. Linux); for OSX (kqueue), a value of 100ms is
+- /// unsufficient and more tests need to be done in combination with
+- /// flushing/syncing to disk in order to understand how to catch one's own
+- /// operations reliably. No feedback from Windows yet. See
+- /// <https://www.mail-archive.com/lyx-devel@lists.lyx.org/msg200252.html>.
++ /// before reconnecting. This delay thing is to deal with asynchronous
++ /// notifications in a not so elegant fashion. But it can also be used to
++ /// slow down incoming events.
+ FileMonitorBlocker block(int delay = 0);
+ /// Make sure the good file is being monitored, after e.g. a move or a
+ /// deletion. See <https://bugreports.qt.io/browse/QTBUG-46483>. This is
+
+commit 96a893b5564404f80a2fd42b7a559d3306babce2
+Author: Pavel Sanda <psanda@ucsd.edu>
+Date: Thu Nov 16 09:25:19 2017 -0800
+
+ Revert db581113: roperly track the lifetime of signals2::slots (#8261)
+
+diff --git a/src/Converter.cpp b/src/Converter.cpp
+index 664a4bb..6e26ed2 100644
+--- a/src/Converter.cpp
++++ b/src/Converter.cpp
+@@ -786,6 +786,20 @@ bool Converters::scanLog(Buffer const & buffer, string const & /*command*/,
+ }
+
+
++namespace {
++
++class ShowMessage
++ : public boost::signals2::trackable {
++public:
++ ShowMessage(Buffer const & b) : buffer_(b) {}
++ void operator()(docstring const & msg) const { buffer_.message(msg); }
++private:
++ Buffer const & buffer_;
++};
++
++}
++
++
+ bool Converters::runLaTeX(Buffer const & buffer, string const & command,
+ OutputParams const & runparams, ErrorList & errorList)
+ {
+@@ -798,12 +812,8 @@ bool Converters::runLaTeX(Buffer const & buffer, string const & command,
+ buffer.filePath(), buffer.layoutPos(),
+ buffer.lastPreviewError());
+ TeXErrors terr;
+- // The connection closes itself at the end of the scope when latex is
+- // destroyed. One cannot close (and destroy) buffer while the converter is
+- // running.
+- latex.message.connect([&buffer](docstring const & msg){
+- buffer.message(msg);
+- });
++ ShowMessage show(buffer);
++ latex.message.connect(show);
+ int const result = latex.run(terr);
+
+ if (result & LaTeX::ERRORS)
+diff --git a/src/LaTeX.h b/src/LaTeX.h
+index 0b46c60..b2d6ac0 100644
+--- a/src/LaTeX.h
++++ b/src/LaTeX.h
+@@ -18,7 +18,8 @@
+
+ #include "support/docstring.h"
+ #include "support/FileName.h"
+-#include "support/signals.h"
++
++#include <boost/signals2.hpp>
+
+ #include <vector>
+ #include <set>
+@@ -147,7 +148,7 @@ public:
+ };
+
+ /// This signal emits an informative message
+- signals2::signal<void(docstring)> message;
++ boost::signals2::signal<void(docstring)> message;
+
+
+ /**
+diff --git a/src/Server.cpp b/src/Server.cpp
+index 8953c78..debb8a9 100644
+--- a/src/Server.cpp
++++ b/src/Server.cpp
+@@ -55,7 +55,8 @@
+ #include "support/lassert.h"
+ #include "support/lstrings.h"
+ #include "support/os.h"
+-#include "support/signals.h"
++
++#include "support/bind.h"
+
+ #include <iostream>
+
+@@ -858,12 +859,8 @@ int LyXComm::startPipe(string const & file, bool write)
+ }
+
+ if (!write) {
+- // Make sure not to call read_ready after destruction.
+- weak_ptr<void> tracker = tracker_.p();
+- theApp()->registerSocketCallback(fd, [=](){
+- if (!tracker.expired())
+- read_ready();
+- });
++ theApp()->registerSocketCallback(fd,
++ bind(&LyXComm::read_ready, this));
+ }
+
+ return fd;
+diff --git a/src/Server.h b/src/Server.h
+index 40021da..1a46c89 100644
+--- a/src/Server.h
++++ b/src/Server.h
+@@ -14,7 +14,7 @@
+ #ifndef SERVER_H
+ #define SERVER_H
+
+-#include "support/signals.h"
++#include <boost/signals2/trackable.hpp>
+
+ #include <vector>
+
+@@ -30,7 +30,7 @@ namespace lyx {
+ class Server;
+
+
+-/** This class manages the pipes used for communicating with clients.
++/** This class managed the pipes used for communicating with clients.
+ Usage: Initialize with pipe-filename-base, client class to receive
+ messages, and callback-function that will be called with the messages.
+ When you want to send, use "send()".
+@@ -38,7 +38,7 @@ class Server;
+ a clean string interface.
+ */
+ #ifndef _WIN32
+-class LyXComm {
++class LyXComm : public boost::signals2::trackable {
+ #else
+ class LyXComm : public QObject {
+ Q_OBJECT
+@@ -189,9 +189,6 @@ private:
+
+ /// Did we defer loading of files to another instance?
+ bool deferred_loading_;
+-
+- /// Track object's liveness
+- support::Trackable tracker_;
+ };
+
+
+diff --git a/src/frontends/qt4/GuiView.cpp b/src/frontends/qt4/GuiView.cpp
+index c587460..68ef3b9 100644
+--- a/src/frontends/qt4/GuiView.cpp
++++ b/src/frontends/qt4/GuiView.cpp
+@@ -529,8 +529,7 @@ GuiView::GuiView(int id)
+
+ // Start autosave timer
+ if (lyxrc.autosave) {
+- // The connection is closed when this is destroyed.
+- d.autosave_timeout_.timeout.connect([this](){ autoSave();});
++ d.autosave_timeout_.timeout.connect(bind(&GuiView::autoSave, this));
+ d.autosave_timeout_.setTimeout(lyxrc.autosave * 1000);
+ d.autosave_timeout_.start();
+ }
+diff --git a/src/frontends/qt4/GuiWorkArea.cpp b/src/frontends/qt4/GuiWorkArea.cpp
+index fe7082d..d7c7b00 100644
+--- a/src/frontends/qt4/GuiWorkArea.cpp
++++ b/src/frontends/qt4/GuiWorkArea.cpp
+@@ -320,10 +320,9 @@ void GuiWorkArea::init()
+
+ d->setCursorShape(Qt::IBeamCursor);
+
+- // This connection is closed at the same time as this is destroyed.
+- d->synthetic_mouse_event_.timeout.timeout.connect([this](){
+- generateSyntheticMouseEvent();
+- });
++ d->synthetic_mouse_event_.timeout.timeout.connect(
++ bind(&GuiWorkArea::generateSyntheticMouseEvent,
++ this));
+
+ LYXERR(Debug::GUI, "viewport width: " << viewport()->width()
+ << " viewport height: " << viewport()->height());
+diff --git a/src/graphics/GraphicsCacheItem.cpp b/src/graphics/GraphicsCacheItem.cpp
+index 576ad92..306dcdb 100644
+--- a/src/graphics/GraphicsCacheItem.cpp
++++ b/src/graphics/GraphicsCacheItem.cpp
+@@ -29,6 +29,7 @@
+ #include "support/lassert.h"
+ #include "support/unique_ptr.h"
+
++#include "support/bind.h"
+ #include "support/TempFile.h"
+
+ using namespace std;
+@@ -38,7 +39,7 @@ namespace lyx {
+
+ namespace graphics {
+
+-class CacheItem::Impl {
++class CacheItem::Impl : public boost::signals2::trackable {
+ public:
+
+ ///
+@@ -49,7 +50,7 @@ public:
+ /**
+ * If no file conversion is needed, then tryDisplayFormat() calls
+ * loadImage() directly.
+- * \return true if a conversion is necessary and no error occurred.
++ * \return true if a conversion is necessary and no error occurred.
+ */
+ bool tryDisplayFormat(FileName & filename, string & from);
+
+@@ -119,7 +120,10 @@ public:
+ ImageStatus status_;
+
+ /// This signal is emitted when the image loading status changes.
+- signals2::signal<void()> statusChanged;
++ boost::signals2::signal<void()> statusChanged;
++
++ /// The connection of the signal ConvProcess::finishedConversion,
++ boost::signals2::connection cc_;
+
+ ///
+ unique_ptr<Converter> converter_;
+@@ -195,7 +199,7 @@ ImageStatus CacheItem::status() const
+ }
+
+
+-signals2::connection CacheItem::connect(slot_type const & slot) const
++boost::signals2::connection CacheItem::connect(slot_type const & slot) const
+ {
+ return pimpl_->statusChanged.connect(slot);
+ }
+@@ -219,7 +223,6 @@ void CacheItem::Impl::startMonitor()
+ if (monitor_)
+ return;
+ monitor_ = FileSystemWatcher::activeMonitor(filename_);
+- // Disconnected at the same time as this is destroyed.
+ monitor_->connect([=](){ startLoading(); });
+ }
+
+@@ -251,6 +254,9 @@ void CacheItem::Impl::reset()
+
+ status_ = WaitingToLoad;
+
++ if (cc_.connected())
++ cc_.disconnect();
++
+ if (converter_)
+ converter_.reset();
+ }
+@@ -274,6 +280,7 @@ void CacheItem::Impl::imageConverted(bool success)
+ file_to_load_ = converter_ ? FileName(converter_->convertedFile())
+ : FileName();
+ converter_.reset();
++ cc_.disconnect();
+
+ success = !file_to_load_.empty() && file_to_load_.isReadableFile();
+
+@@ -442,13 +449,9 @@ void CacheItem::Impl::convertToDisplayFormat()
+ // Connect a signal to this->imageConverted and pass this signal to
+ // the graphics converter so that we can load the modified file
+ // on completion of the conversion process.
+- converter_ = make_unique<Converter>(doc_file_, filename,
+- to_file_base.absFileName(),
++ converter_ = make_unique<Converter>(doc_file_, filename, to_file_base.absFileName(),
+ from, to_);
+- // Connection is closed at the same time as *this is destroyed.
+- converter_->connect([this](bool success){
+- imageConverted(success);
+- });
++ converter_->connect(bind(&Impl::imageConverted, this, _1));
+ converter_->startConversion();
+ }
+
+diff --git a/src/graphics/GraphicsCacheItem.h b/src/graphics/GraphicsCacheItem.h
+index 6f7f968..9cee2b8 100644
+--- a/src/graphics/GraphicsCacheItem.h
++++ b/src/graphics/GraphicsCacheItem.h
+@@ -30,7 +30,7 @@
+
+ #include "GraphicsTypes.h"
+
+-#include "support/signals.h"
++#include <boost/signals2.hpp>
+
+
+ namespace lyx {
+@@ -82,9 +82,9 @@ public:
+ /** Connect and you'll be informed when the loading status of the image
+ * changes.
+ */
+- typedef signals2::signal<void()>::slot_type slot_type;
++ typedef boost::signals2::signal<void()>::slot_type slot_type;
+ ///
+- signals2::connection connect(slot_type const &) const;
++ boost::signals2::connection connect(slot_type const &) const;
+
+ private:
+ /// noncopyable
+diff --git a/src/graphics/GraphicsConverter.cpp b/src/graphics/GraphicsConverter.cpp
+index 598e108..63b6a44 100644
+--- a/src/graphics/GraphicsConverter.cpp
++++ b/src/graphics/GraphicsConverter.cpp
+@@ -27,6 +27,7 @@
+ #include "support/lstrings.h"
+ #include "support/os.h"
+
++#include "support/bind.h"
+ #include "support/TempFile.h"
+
+ #include <sstream>
+@@ -39,12 +40,10 @@ namespace lyx {
+
+ namespace graphics {
+
+-class Converter::Impl {
++class Converter::Impl : public boost::signals2::trackable {
+ public:
+ ///
+- Impl(FileName const & doc_fname,
+- FileName const & from_file, string const & to_file_base,
+- string const & from_format, string const & to_format);
++ Impl(FileName const &, FileName const &, string const &, string const &, string const &);
+
+ ///
+ void startConversion();
+@@ -59,9 +58,9 @@ public:
+ /** At the end of the conversion process inform the outside world
+ * by emitting a signal.
+ */
+- typedef signals2::signal<void(bool)> sig;
++ typedef boost::signals2::signal<void(bool)> SignalType;
+ ///
+- sig finishedConversion;
++ SignalType finishedConversion;
+
+ ///
+ FileName const doc_fname_;
+@@ -75,8 +74,6 @@ public:
+ bool valid_process_;
+ ///
+ bool finished_;
+- ///
+- Trackable tracker_;
+ };
+
+
+@@ -88,8 +85,8 @@ bool Converter::isReachable(string const & from_format_name,
+
+
+ Converter::Converter(FileName const & doc_fname,
+- FileName const & from_file, string const & to_file_base,
+- string const & from_format, string const & to_format)
++ FileName const & from_file, string const & to_file_base,
++ string const & from_format, string const & to_format)
+ : pimpl_(new Impl(doc_fname, from_file, to_file_base, from_format, to_format))
+ {}
+
+@@ -106,7 +103,7 @@ void Converter::startConversion() const
+ }
+
+
+-signals2::connection Converter::connect(slot_type const & slot) const
++boost::signals2::connection Converter::connect(slot_type const & slot) const
+ {
+ return pimpl_->finishedConversion.connect(slot);
+ }
+@@ -191,10 +188,9 @@ void Converter::Impl::startConversion()
+ return;
+ }
+
+- ForkedCall::sigPtr ptr = ForkedCallQueue::add(script_command_);
+- ptr->connect(ForkedCall::slot([this](pid_t pid, int retval){
+- converted(pid, retval);
+- }).track_foreign(tracker_.p()));
++ ForkedCall::SignalTypePtr ptr =
++ ForkedCallQueue::add(script_command_);
++ ptr->connect(bind(&Impl::converted, this, _1, _2));
+ }
+
+
+diff --git a/src/graphics/GraphicsConverter.h b/src/graphics/GraphicsConverter.h
+index c038029..d3d0b81 100644
+--- a/src/graphics/GraphicsConverter.h
++++ b/src/graphics/GraphicsConverter.h
+@@ -17,8 +17,7 @@
+ #ifndef GRAPHICSCONVERTER_H
+ #define GRAPHICSCONVERTER_H
+
+-#include "support/signals.h"
+-
++#include <boost/signals2.hpp>
+
+ namespace lyx {
+
+@@ -48,12 +47,11 @@ public:
+ /** Connect and you'll be informed when the conversion process has
+ * finished.
+ * If the conversion is successful, then the listener is passed \c true.
+- * The connection is closed when this is destroyed.
+ */
+- typedef signals2::signal<void(bool)> sig_type;
++ typedef boost::signals2::signal<void(bool)> sig_type;
+ typedef sig_type::slot_type slot_type;
+ ///
+- signals2::connection connect(slot_type const &) const;
++ boost::signals2::connection connect(slot_type const &) const;
+
+ /** If the conversion is successful, this returns the name of the
+ * resulting file.
+diff --git a/src/graphics/GraphicsLoader.cpp b/src/graphics/GraphicsLoader.cpp
+index 683f092..3503aba 100644
+--- a/src/graphics/GraphicsLoader.cpp
++++ b/src/graphics/GraphicsLoader.cpp
+@@ -107,17 +107,16 @@ void LoaderQueue::loadNext()
+
+
+ LoaderQueue::LoaderQueue() : timer(s_millisecs_, Timeout::ONETIME),
+- running_(false)
++ running_(false)
+ {
+- // Disconnected when this is destroyed
+- timer.timeout.connect([this](){ loadNext(); });
++ timer.timeout.connect(bind(&LoaderQueue::loadNext, this));
+ }
+
+
+ void LoaderQueue::startLoader()
+ {
+ LYXERR(Debug::GRAPHICS, "LoaderQueue: waking up");
+- running_ = true;
++ running_ = true ;
+ timer.setTimeout(s_millisecs_);
+ timer.start();
+ }
+@@ -164,7 +163,7 @@ void LoaderQueue::touch(Cache::ItemPtr const & item)
+
+ typedef std::shared_ptr<Image> ImagePtr;
+
+-class Loader::Impl {
++class Loader::Impl : public boost::signals2::trackable {
+ friend class Loader;
+ public:
+ ///
+@@ -193,9 +192,9 @@ 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.
+- signals2::signal<void()> signal_;
+- /// The connection of the signal statusChanged
+- signals2::scoped_connection connection_;
++ boost::signals2::signal<void()> signal_;
++ /// The connection of the signal StatusChanged
++ boost::signals2::connection sc_;
+
+ double displayPixelRatio() const
+ {
+@@ -364,7 +363,7 @@ void Loader::setDisplayPixelRatio(double scale)
+ }
+
+
+-signals2::connection Loader::connect(slot const & slot) const
++boost::signals2::connection Loader::connect(slot_type const & slot) const
+ {
+ return pimpl_->signal_.connect(slot);
+ }
+@@ -406,7 +405,7 @@ void Loader::Impl::resetFile(FileName const & file)
+ // signal needs to be disconnected.
+ try {
+ // This can in theory throw a BufferException
+- connection_.disconnect();
++ sc_.disconnect();
+ } catch (...) {
+ LYXERR(Debug::GRAPHICS, "Unable to disconnect signal.");
+ }
+@@ -435,8 +434,7 @@ void Loader::Impl::resetFile(FileName const & file)
+ if (continue_monitoring && !cached_item_->monitoring())
+ cached_item_->startMonitoring();
+
+- // This is a scoped connection
+- connection_ = cached_item_->connect([this](){ statusChanged(); });
++ sc_ = cached_item_->connect(bind(&Impl::statusChanged, this));
+ }
+
+
+diff --git a/src/graphics/GraphicsLoader.h b/src/graphics/GraphicsLoader.h
+index 0a299cb..62ea303 100644
+--- a/src/graphics/GraphicsLoader.h
++++ b/src/graphics/GraphicsLoader.h
+@@ -26,7 +26,7 @@
+
+ #include "GraphicsTypes.h"
+
+-#include "support/signals.h"
++#include <boost/signals2.hpp>
+
+ namespace lyx {
+
+@@ -70,7 +70,7 @@ public:
+ */
+ void startLoading() const;
+
+- /** Tries to reload the image.
++ /** Tries to reload the image.
+ */
+ void reload() const;
+
+@@ -90,10 +90,10 @@ public:
+ /** Connect and you'll be informed when the loading status of the image
+ * changes.
+ */
+- typedef signals2::signal<void()> sig;
+- typedef sig::slot_type slot;
++ typedef boost::signals2::signal<void()> sig_type;
++ typedef sig_type::slot_type slot_type;
+ ///
+- signals2::connection connect(slot const &) const;
++ boost::signals2::connection connect(slot_type const &) const;
+
+ /** The loaded image with Pixmap set.
+ * If the Pixmap is not yet set (see status() for why...), returns 0.
+diff --git a/src/graphics/PreviewImage.cpp b/src/graphics/PreviewImage.cpp
+index b80bf94..da0f1e2 100644
+--- a/src/graphics/PreviewImage.cpp
++++ b/src/graphics/PreviewImage.cpp
+@@ -20,6 +20,7 @@
+
+ #include "support/FileName.h"
+
++#include "support/bind.h"
+
+ using namespace std;
+ using namespace lyx::support;
+@@ -27,7 +28,7 @@ using namespace lyx::support;
+ namespace lyx {
+ namespace graphics {
+
+-class PreviewImage::Impl {
++class PreviewImage::Impl : public boost::signals2::trackable {
+ public:
+ ///
+ Impl(PreviewImage & p, PreviewLoader & l,
+@@ -104,14 +105,15 @@ PreviewLoader & PreviewImage::previewLoader() const
+ }
+
+
+-PreviewImage::Impl::Impl(PreviewImage & p, PreviewLoader & l, string const & s,
+- FileName const & bf, double af)
++PreviewImage::Impl::Impl(PreviewImage & p, PreviewLoader & l,
++ string const & s,
++ FileName const & bf,
++ double af)
+ : parent_(p), ploader_(l), iloader_(l.buffer().fileName(), bf),
+ snippet_(s), ascent_frac_(af)
+ {
+ iloader_.setDisplayPixelRatio(l.displayPixelRatio());
+- // This connection is destroyed at the same time as this.
+- iloader_.connect([this](){ statusChanged(); });
++ iloader_.connect(bind(&Impl::statusChanged, this));
+ }
+
+
+diff --git a/src/graphics/PreviewLoader.cpp b/src/graphics/PreviewLoader.cpp
+index 22b0f23..c6f4d06 100644
+--- a/src/graphics/PreviewLoader.cpp
++++ b/src/graphics/PreviewLoader.cpp
+@@ -38,6 +38,7 @@
+ #include "support/ForkedCalls.h"
+ #include "support/lstrings.h"
+
++#include "support/bind.h"
+ #include "support/TempFile.h"
+
+ #include <atomic>
+@@ -166,7 +167,7 @@ typedef InProgressProcesses::value_type InProgressProcess;
+ namespace lyx {
+ namespace graphics {
+
+-class PreviewLoader::Impl {
++class PreviewLoader::Impl : public boost::signals2::trackable {
+ public:
+ ///
+ Impl(PreviewLoader & p, Buffer const & b);
+@@ -187,7 +188,7 @@ public:
+ void refreshPreviews();
+
+ /// Emit this signal when an image is ready for display.
+- signals2::signal<void(PreviewImage const &)> imageReady;
++ boost::signals2::signal<void(PreviewImage const &)> imageReady;
+
+ Buffer const & buffer() const { return buffer_; }
+
+@@ -238,8 +239,6 @@ private:
+
+ /// We don't own this
+ static lyx::Converter const * pconverter_;
+-
+- signals2::scoped_connection connection_;
+ };
+
+
+@@ -297,7 +296,7 @@ void PreviewLoader::refreshPreviews()
+ }
+
+
+-signals2::connection PreviewLoader::connect(slot const & slot) const
++boost::signals2::connection PreviewLoader::connect(slot_type const & slot) const
+ {
+ return pimpl_->imageReady.connect(slot);
+ }
+@@ -708,12 +707,12 @@ void PreviewLoader::Impl::startLoading(bool wait)
+ << " " << quoteName(latexfile.toFilesystemEncoding())
+ << " --dpi " << font_scaling_factor_;
+
+- // FIXME XHTML
++ // FIXME XHTML
+ // The colors should be customizable.
+ if (!buffer_.isExporting()) {
+ ColorCode const fg = PreviewLoader::foregroundColor();
+ ColorCode const bg = PreviewLoader::backgroundColor();
+- cs << " --fg " << theApp()->hexName(fg)
++ cs << " --fg " << theApp()->hexName(fg)
+ << " --bg " << theApp()->hexName(bg);
+ }
+
+@@ -737,11 +736,9 @@ void PreviewLoader::Impl::startLoading(bool wait)
+ }
+
+ // Initiate the conversion from LaTeX to bitmap images files.
+- ForkedCall::sigPtr convert_ptr = make_shared<ForkedCall::sig>();
+- // This is a scoped connection
+- connection_ = convert_ptr->connect([this](pid_t pid, int retval){
+- finishedGenerating(pid, retval);
+- });
++ ForkedCall::SignalTypePtr
++ convert_ptr(new ForkedCall::SignalType);
++ convert_ptr->connect(bind(&Impl::finishedGenerating, this, _1, _2));
+
+ ForkedCall call(buffer_.filePath());
+ int ret = call.startScript(command, convert_ptr);
+diff --git a/src/graphics/PreviewLoader.h b/src/graphics/PreviewLoader.h
+index ca22a9f..3239ffc 100644
+--- a/src/graphics/PreviewLoader.h
++++ b/src/graphics/PreviewLoader.h
+@@ -18,8 +18,7 @@
+ #ifndef PREVIEWLOADER_H
+ #define PREVIEWLOADER_H
+
+-#include "support/signals.h"
+-
++#include <boost/signals2.hpp>
+ #include <QObject>
+
+ #include "ColorCode.h"
+@@ -77,10 +76,10 @@ public:
+ * has been created and is ready for loading through
+ * lyx::graphics::PreviewImage::image().
+ */
+- typedef signals2::signal<void(PreviewImage const &)> sig;
+- typedef sig::slot_type slot;
++ typedef boost::signals2::signal<void(PreviewImage const &)> sig_type;
++ typedef sig_type::slot_type slot_type;
+ ///
+- signals2::connection connect(slot const &) const;
++ boost::signals2::connection connect(slot_type const &) const;
+
+ /** When PreviewImage has finished loading the image file into memory,
+ * it tells the PreviewLoader to tell the outside world
+diff --git a/src/insets/InsetExternal.cpp b/src/insets/InsetExternal.cpp
+index 1f0f5f2..e1130bf 100644
+--- a/src/insets/InsetExternal.cpp
++++ b/src/insets/InsetExternal.cpp
+@@ -39,6 +39,7 @@
+
+ #include "graphics/PreviewLoader.h"
+
++#include "support/bind.h"
+ #include "support/convert.h"
+ #include "support/debug.h"
+ #include "support/ExceptionMessage.h"
+@@ -426,6 +427,7 @@ InsetExternal::InsetExternal(Buffer * buf)
+ // Mouse hover is not copied and remains empty
+ InsetExternal::InsetExternal(InsetExternal const & other)
+ : Inset(other),
++ boost::signals2::trackable(),
+ params_(other.params_),
+ renderer_(other.renderer_->clone(this))
+ {}
+@@ -652,7 +654,6 @@ void InsetExternal::updatePreview() const
+ case PREVIEW_INSTANT: {
+ renderer_ = make_unique<RenderMonitoredPreview>(this);
+ RenderMonitoredPreview * preview_ptr = renderer_->asMonitoredPreview();
+- // This connection is closed at the same time as this is destroyed.
+ preview_ptr->connect([=]() { fileChanged(); });
+ add_preview_and_start_loading(*preview_ptr, *this, buffer());
+ break;
+diff --git a/src/insets/InsetExternal.h b/src/insets/InsetExternal.h
+index 75b7f70..4a15be1 100644
+--- a/src/insets/InsetExternal.h
++++ b/src/insets/InsetExternal.h
+@@ -19,6 +19,8 @@
+ #include "support/FileName.h"
+ #include "support/unique_ptr.h"
+
++#include <boost/signals2/trackable.hpp>
++
+
+ namespace lyx {
+
+@@ -88,7 +90,7 @@ private:
+ class RenderBase;
+
+ ///
+-class InsetExternal : public Inset
++class InsetExternal : public Inset, public boost::signals2::trackable
+ {
+ // Disable assignment operator, since it is not used, and it is too
+ // complicated to implement it consistently with the copy constructor
+diff --git a/src/insets/RenderPreview.cpp b/src/insets/RenderPreview.cpp
+index 18882fc..948ddb9 100644
+--- a/src/insets/RenderPreview.cpp
++++ b/src/insets/RenderPreview.cpp
+@@ -31,6 +31,8 @@
+ #include "support/lassert.h"
+ #include "support/lstrings.h"
+
++#include "support/bind.h"
++
+ using namespace std;
+ using namespace lyx::support;
+
+@@ -75,11 +77,19 @@ RenderPreview::RenderPreview(Inset const * inset)
+ RenderPreview::RenderPreview(RenderPreview const & other,
+ Inset const * inset)
+ : RenderBase(other),
++ boost::signals2::trackable(),
+ snippet_(other.snippet_),
+ parent_(inset)
+ {}
+
+
++RenderPreview::~RenderPreview()
++{
++ if (ploader_connection_.connected())
++ ploader_connection_.disconnect();
++}
++
++
+ RenderBase * RenderPreview::clone(Inset const * inset) const
+ {
+ return new RenderPreview(*this, inset);
+@@ -231,12 +241,10 @@ void RenderPreview::addPreview(docstring const & latex_snippet,
+ // If this is the first time of calling, connect to the
+ // PreviewLoader signal that'll inform us when the preview image
+ // is ready for loading.
+- if (!ploader_connection_.connected())
+- // This is a scoped connection.
+- ploader_connection_ =
+- ploader.connect([this](graphics::PreviewImage const & pi){
+- imageReady(pi);
+- });
++ if (!ploader_connection_.connected()) {
++ ploader_connection_ = ploader.connect(
++ bind(&RenderPreview::imageReady, this, _1));
++ }
+
+ ploader.add(snippet_);
+ }
+@@ -288,7 +296,8 @@ void RenderMonitoredPreview::draw(PainterInfo & pi, int x, int y) const
+ }
+
+
+-signals2::connection RenderMonitoredPreview::connect(slot const & slot)
++boost::signals2::connection
++RenderMonitoredPreview::connect(ChangedSig::slot_type const & slot)
+ {
+ return changed_.connect(slot);
+ }
+diff --git a/src/insets/RenderPreview.h b/src/insets/RenderPreview.h
+index 2f83aff..42d944d 100644
+--- a/src/insets/RenderPreview.h
++++ b/src/insets/RenderPreview.h
+@@ -21,8 +21,10 @@
+ #include "support/docstring.h"
+ #include "support/FileMonitor.h"
+ #include "support/FileName.h"
+-#include "support/signals.h"
+
++#include <boost/signals2.hpp>
++#include <boost/signals2/trackable.hpp>
++#include <boost/signals2/connection.hpp>
+
+ namespace lyx {
+
+@@ -38,7 +40,7 @@ class PreviewLoader;
+ } // namespace graphics
+
+
+-class RenderPreview : public RenderBase {
++class RenderPreview : public RenderBase, public boost::signals2::trackable {
+ public:
+ /// Return true if preview is enabled in text (from LyXRC::preview)
+ static bool previewText();
+@@ -47,6 +49,7 @@ public:
+
+ RenderPreview(Inset const *);
+ RenderPreview(RenderPreview const &, Inset const *);
++ ~RenderPreview();
+ RenderBase * clone(Inset const *) const;
+
+ /// Compute the size of the object, returned in dim
+@@ -101,7 +104,7 @@ private:
+ /** Store the connection to the preview loader so that we connect
+ * only once.
+ */
+- signals2::scoped_connection ploader_connection_;
++ boost::signals2::connection ploader_connection_;
+
+ /// Inform the core that the inset has changed.
+ Inset const * parent_;
+@@ -121,17 +124,15 @@ public:
+ void stopMonitoring() const;
+
+ /// Connect and you'll be informed when the file changes.
+- /// Do not forget to track objects used by the slot.
+- typedef signals2::signal<void()> sig;
+- typedef sig::slot_type slot;
+- signals2::connection connect(slot const & slot);
++ typedef boost::signals2::signal<void()> ChangedSig;
++ boost::signals2::connection connect(ChangedSig::slot_type const &);
+
+ /// equivalent to dynamic_cast
+ virtual RenderMonitoredPreview * asMonitoredPreview() { return this; }
+
+ private:
+ /// This signal is emitted if the file is modified
+- sig changed_;
++ ChangedSig changed_;
+ ///
+ mutable support::ActiveFileMonitorPtr monitor_;
+ ///
+diff --git a/src/support/FileMonitor.cpp b/src/support/FileMonitor.cpp
+index f1fefb8..30a4170 100644
+--- a/src/support/FileMonitor.cpp
++++ b/src/support/FileMonitor.cpp
+@@ -176,7 +176,8 @@ void FileMonitor::reconnectToFileMonitorGuard()
+ }
+
+
+-signals2::connection FileMonitor::connect(slot const & slot)
++boost::signals2::connection
++FileMonitor::connect(sig::slot_type const & slot)
+ {
+ return fileChanged_.connect(slot);
+ }
+diff --git a/src/support/FileMonitor.h b/src/support/FileMonitor.h
+index 49f12cb..23302ed 100644
+--- a/src/support/FileMonitor.h
++++ b/src/support/FileMonitor.h
+@@ -17,7 +17,6 @@
+ #define FILEMONITOR_H
+
+ #include "support/FileName.h"
+-#include "support/signals.h"
+
+ #include <memory>
+
+@@ -25,6 +24,8 @@
+ #include <QObject>
+ #include <QPointer>
+
++#include <boost/signals2.hpp>
++
+
+ namespace lyx {
+ namespace support {
+@@ -157,10 +158,9 @@ class FileMonitor : public QObject
+ public:
+ FileMonitor(std::shared_ptr<FileMonitorGuard> monitor);
+
+- typedef signals2::signal<void()> sig;
+- typedef sig::slot_type slot;
++ typedef boost::signals2::signal<void()> sig;
+ /// Connect and you'll be informed when the file has changed.
+- signals2::connection connect(slot const &);
++ boost::signals2::connection connect(sig::slot_type const &);
+ /// disconnect all slots connected to the boost signal fileChanged_ or to
+ /// the qt signal fileChanged()
+ void disconnect();
+diff --git a/src/support/ForkedCalls.cpp b/src/support/ForkedCalls.cpp
+index f81c1d2..93be6a4 100644
+--- a/src/support/ForkedCalls.cpp
++++ b/src/support/ForkedCalls.cpp
+@@ -58,7 +58,7 @@ namespace {
+ //
+ /////////////////////////////////////////////////////////////////////
+
+-class Murder {
++class Murder : public boost::signals2::trackable {
+ public:
+ //
+ static void killItDead(int secs, pid_t pid)
+@@ -83,8 +83,7 @@ private:
+ Murder(int secs, pid_t pid)
+ : timeout_(1000*secs, Timeout::ONETIME), pid_(pid)
+ {
+- // Connection is closed with this.
+- timeout_.timeout.connect([this](){ kill(); });
++ timeout_.timeout.connect(lyx::bind(&Murder::kill, this));
+ timeout_.start();
+ }
+
+@@ -278,7 +277,7 @@ ForkedCall::ForkedCall(string const & path, string const & lpath)
+ int ForkedCall::startScript(Starttype wait, string const & what)
+ {
+ if (wait != Wait) {
+- retval_ = startScript(what, sigPtr());
++ retval_ = startScript(what, SignalTypePtr());
+ return retval_;
+ }
+
+@@ -288,7 +287,7 @@ int ForkedCall::startScript(Starttype wait, string const & what)
+ }
+
+
+-int ForkedCall::startScript(string const & what, sigPtr signal)
++int ForkedCall::startScript(string const & what, SignalTypePtr signal)
+ {
+ command_ = commandPrep(trim(what));
+ signal_ = signal;
+@@ -436,13 +435,13 @@ int ForkedCall::generateChild()
+ namespace ForkedCallQueue {
+
+ /// A process in the queue
+-typedef pair<string, ForkedCall::sigPtr> Process;
++typedef pair<string, ForkedCall::SignalTypePtr> Process;
+ /** Add a process to the queue. Processes are forked sequentially
+ * only one is running at a time.
+ * Connect to the returned signal and you'll be informed when
+ * the process has ended.
+ */
+-ForkedCall::sigPtr add(string const & process);
++ForkedCall::SignalTypePtr add(string const & process);
+
+ /// in-progress queue
+ static queue<Process> callQueue_;
+@@ -457,10 +456,10 @@ void stopCaller();
+ ///
+ void callback(pid_t, int);
+
+-ForkedCall::sigPtr add(string const & process)
++ForkedCall::SignalTypePtr add(string const & process)
+ {
+- ForkedCall::sigPtr ptr;
+- ptr.reset(new ForkedCall::sig);
++ ForkedCall::SignalTypePtr ptr;
++ ptr.reset(new ForkedCall::SignalType);
+ callQueue_.push(Process(process, ptr));
+ if (!running_)
+ startCaller();
+diff --git a/src/support/ForkedCalls.h b/src/support/ForkedCalls.h
+index 8a4bf1d..eececc0 100644
+--- a/src/support/ForkedCalls.h
++++ b/src/support/ForkedCalls.h
+@@ -14,8 +14,8 @@
+ #ifndef FORKEDCALLS_H
+ #define FORKEDCALLS_H
+
+-#include "support/signals.h"
+ #include "support/strfwd.h"
++#include <boost/signals2.hpp>
+
+ #ifdef HAVE_SYS_TYPES_H
+ # include <sys/types.h>
+@@ -44,7 +44,7 @@ public:
+ ///
+ virtual std::shared_ptr<ForkedProcess> clone() const = 0;
+
+- /** A Signal signal can be emitted once the forked process
++ /** A SignalType signal can be emitted once the forked process
+ * has finished. It passes:
+ * the PID of the child and;
+ * the return value from the child.
+@@ -53,8 +53,7 @@ public:
+ * we can return easily to C++ methods, rather than just globally
+ * accessible functions.
+ */
+- typedef signals2::signal<void(pid_t, int)> sig;
+- typedef sig::slot_type slot;
++ typedef boost::signals2::signal<void(pid_t, int)> SignalType;
+
+ /** The signal is connected in the calling routine to the desired
+ * slot. We pass a shared_ptr rather than a reference to the signal
+@@ -62,10 +61,9 @@ public:
+ * class (and hence the signal) to be destructed before the forked
+ * call is complete.
+ *
+- * Use Slot::track or Signal::scoped_connection to ensure that the
+- * connection is closed before the slot expires.
++ * It doesn't matter if the slot disappears, SigC takes care of that.
+ */
+- typedef std::shared_ptr<sig> sigPtr;
++ typedef std::shared_ptr<SignalType> SignalTypePtr;
+
+ /** Invoking the following methods makes sense only if the command
+ * is running asynchronously!
+@@ -116,7 +114,7 @@ protected:
+ pid_t fork();
+
+ /// Callback function
+- sigPtr signal_;
++ SignalTypePtr signal_;
+
+ /// identifying command (for display in the GUI perhaps).
+ std::string command_;
+@@ -138,7 +136,7 @@ private:
+ };
+
+
+-/**
++/**
+ * An instance of class ForkedCall represents a single child process.
+ *
+ * Class ForkedCall uses fork() and execvp() to lauch the child process.
+@@ -177,7 +175,7 @@ public:
+ int startScript(Starttype, std::string const & what);
+
+ ///
+- int startScript(std::string const & what, sigPtr ptr);
++ int startScript(std::string const & what, SignalTypePtr);
+
+ private:
+ ///
+@@ -197,7 +195,7 @@ private:
+
+ namespace ForkedCallQueue {
+
+-ForkedCall::sigPtr add(std::string const & process);
++ForkedCall::SignalTypePtr add(std::string const & process);
+ /// Query whether the queue is running a forked process now.
+ bool running();
+
+diff --git a/src/support/Makefile.am b/src/support/Makefile.am
+index d3c902c..9865d6f 100644
+--- a/src/support/Makefile.am
++++ b/src/support/Makefile.am
+@@ -93,7 +93,6 @@ liblyxsupport_a_SOURCES = \
+ qstring_helpers.h \
+ regex.h \
+ RefChanger.h \
+- signals.h \
+ socktools.cpp \
+ socktools.h \
+ strfwd.h \
+diff --git a/src/support/Timeout.h b/src/support/Timeout.h
+index eef78db..042ed45 100644
+--- a/src/support/Timeout.h
++++ b/src/support/Timeout.h
+@@ -12,7 +12,7 @@
+ #ifndef TIMEOUT_H
+ #define TIMEOUT_H
+
+-#include "support/signals.h"
++#include <boost/signals2.hpp>
+
+
+ namespace lyx {
+@@ -40,7 +40,7 @@ public:
+ /// restart the timer
+ void restart();
+ /// signal emitted on timer expiry
+- signals2::signal<void()> timeout;
++ boost::signals2::signal<void()> timeout;
+ /// emit the signal
+ void emit();
+ /// set the timer type
+diff --git a/src/support/signals.h b/src/support/signals.h
+deleted file mode 100644
+index 7d4d116..0000000
+--- a/src/support/signals.h
++++ /dev/null
+@@ -1,49 +0,0 @@
+-// -*- C++ -*-
+-/**
+- * \file signals.h
+- * This file is part of LyX, the document processor.
+- * Licence details can be found in the file COPYING.
+- *
+- * \author Guillaume Munch
+- *
+- * Full author contact details are available in file CREDITS.
+- */
+-
+-#ifndef LYX_SIGNALS_H
+-#define LYX_SIGNALS_H
+-
+-#include "boost/signals2.hpp"
+-
+-#include <memory>
+-
+-namespace lyx {
+-
+-namespace signals2 = ::boost::signals2;
+-
+-namespace support {
+-
+-/// A small utility to use with signals2::slot_type::track_foreign when the
+-/// parent object is not handled by a shared_ptr, or to track the lifetime of an
+-/// object. Using Trackable to track lifetimes is less thread-safe than tracking
+-/// their parents directly with a shared_ptr as recommended by signals2, but it
+-/// makes it easier for transitioning old code. (Essentially because Trackable
+-/// will not prevent the deletion of the parent by a concurrent thread.)
+-class Trackable {
+-public:
+- Trackable() : p_(std::make_shared<int>(0)) {}
+- Trackable(Trackable const &) : Trackable() {}
+- Trackable(Trackable &&) : Trackable() {}
+- Trackable & operator=(Trackable const &) { return *this; }
+- Trackable & operator=(Trackable &&) { return *this; }
+- // This weak pointer lets you know if the parent object has been destroyed
+- std::weak_ptr<void> p() const { return p_; }
+-private:
+- std::shared_ptr<void> const p_;
+-};
+-
+-} // namespace support
+-
+-} // namespace lyx
+-
+-
+-#endif
+
+commit c6b1ee490c9467230ba7033bd15feb4753832c4b
+Author: Pavel Sanda <psanda@ucsd.edu>
+Date: Thu Nov 16 09:38:27 2017 -0800
+
+ one forgotten line in rejects
+
+diff --git a/src/Buffer.cpp b/src/Buffer.cpp
+index 48391f9..1945b71 100644
+--- a/src/Buffer.cpp
++++ b/src/Buffer.cpp
+@@ -5349,7 +5349,7 @@ void Buffer::Impl::refreshFileMonitor()
+ }
+
+
+-void Buffer::Impl::fileExternallyModified(bool const exists)
++void Buffer::Impl::fileExternallyModified(bool modified)
+ {
+ if (modified)
+ lyx_clean = bak_clean = false;
projects / features.git / commitdiff