* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
+ * \author Angus Leeming
* \author Guillaume Munch
*
* Full author contact details are available in file CREDITS.
FileSystemWatcher & FileSystemWatcher::instance()
{
- // This thread-safe because QFileSystemWatcher is thread-safe.
+ // This is thread-safe because QFileSystemWatcher is thread-safe.
static FileSystemWatcher f;
return f;
}
{}
-//static
-FileMonitorPtr FileSystemWatcher::monitor(FileName const & file_with_path)
+shared_ptr<FileMonitorGuard>
+FileSystemWatcher::getGuard(FileName const & filename)
{
- FileSystemWatcher & f = instance();
- string const filename = file_with_path.absFileName();
- weak_ptr<FileMonitorGuard> & wptr = f.store_[filename];
+ string const absfilename = filename.absFileName();
+ weak_ptr<FileMonitorGuard> & wptr = store_[absfilename];
if (shared_ptr<FileMonitorGuard> mon = wptr.lock())
- return make_unique<FileMonitor>(mon);
- auto mon = make_shared<FileMonitorGuard>(filename, f.qwatcher_.get());
+ return mon;
+ auto mon = make_shared<FileMonitorGuard>(absfilename, qwatcher_.get());
wptr = mon;
- return make_unique<FileMonitor>(mon);
+ return mon;
+}
+
+
+//static
+FileMonitorPtr FileSystemWatcher::monitor(FileName const & filename)
+{
+ return make_unique<FileMonitor>(instance().getGuard(filename));
+}
+
+
+//static
+ActiveFileMonitorPtr FileSystemWatcher::activeMonitor(FileName const & filename,
+ int interval)
+{
+ return make_unique<ActiveFileMonitor>(instance().getGuard(filename),
+ filename, interval);
}
FileMonitorGuard::FileMonitorGuard(string const & filename,
QFileSystemWatcher * qwatcher)
- : filename_(filename), qwatcher_(qwatcher)
+ : filename_(filename), qwatcher_(qwatcher), exists_(true)
{
+ if (filename.empty())
+ return;
QObject::connect(qwatcher, SIGNAL(fileChanged(QString const &)),
this, SLOT(notifyChange(QString const &)));
if (qwatcher_->files().contains(toqstr(filename)))
FileMonitorGuard::~FileMonitorGuard()
{
- qwatcher_->removePath(toqstr(filename_));
+ if (!filename_.empty())
+ qwatcher_->removePath(toqstr(filename_));
}
-void FileMonitorGuard::refresh(bool new_file)
+void FileMonitorGuard::refresh(bool const emit)
{
+ if (filename_.empty())
+ return;
QString const qfilename = toqstr(filename_);
- if(!qwatcher_->files().contains(qfilename)) {
- bool exists = QFile(qfilename).exists();
+ if (!qwatcher_->files().contains(qfilename)) {
+ bool const existed = exists_;
+ 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
- if (exists)
- LYXERR(Debug::FILES,
- "Could not add path to QFileSystemWatcher: "
- << filename_);
- if (new_file || !exists)
- QTimer::singleShot(1000, this, SLOT(refreshTrue()));
- else
- QTimer::singleShot(1000, this, SLOT(refreshFalse()));
- // Better (qt>=5.4):
- /*QTimer::singleShot(1000, this, [=](){
- refresh(new_file || !exists);
- });*/
- } else if (exists && new_file)
- Q_EMIT fileChanged();
+ {
+ 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_);
+ }
}
}
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).
- refresh();
+ // Therefore we must refresh.
+ refresh(false);
+ Q_EMIT fileChanged(exists_);
}
}
void FileMonitor::connectToFileMonitorGuard()
{
- QObject::connect(monitor_.get(), SIGNAL(fileChanged()),
- this, SLOT(changed()));
+ // Connections need to be asynchronous because the receiver can own this
+ // object and therefore is allowed to delete it.
+ // Qt signal:
+ QObject::connect(monitor_.get(), SIGNAL(fileChanged(bool)),
+ this, SIGNAL(fileChanged(bool)),
+ Qt::QueuedConnection);
+ // Boost signal:
+ QObject::connect(this, SIGNAL(fileChanged(bool)),
+ this, SLOT(changed(bool)));
}
-boost::signals2::connection
-FileMonitor::connect(sig::slot_type const & slot)
+signals2::connection FileMonitor::connect(slot const & slot)
{
return fileChanged_.connect(slot);
}
-void FileMonitor::disconnect()
-{
- fileChanged_.disconnect_all_slots();
- QObject::disconnect(this, SIGNAL(fileChanged()));
-}
-
-
-void FileMonitor::changed()
+void FileMonitor::changed(bool const exists)
{
// emit boost signal
- fileChanged_();
- Q_EMIT fileChanged();
+ fileChanged_(exists);
}
-FileMonitorBlocker FileMonitor::block(int delay)
+ActiveFileMonitor::ActiveFileMonitor(std::shared_ptr<FileMonitorGuard> monitor,
+ FileName const & filename, int interval)
+ : FileMonitor(monitor), filename_(filename), interval_(interval),
+ timestamp_(0), checksum_(0), cooldown_(true)
{
- FileMonitorBlocker blocker = blocker_.lock();
- if (!blocker)
- blocker_ = blocker = make_shared<FileMonitorBlockerGuard>(this);
- blocker->setDelay(delay);
- return blocker;
+ QObject::connect(this, SIGNAL(fileChanged(bool)), this, SLOT(setCooldown()));
+ QTimer::singleShot(interval_, this, SLOT(clearCooldown()));
+ filename_.refresh();
+ if (!filename_.exists())
+ return;
+ timestamp_ = filename_.lastModified();
+ checksum_ = filename_.checksum();
}
-FileMonitorBlockerGuard::FileMonitorBlockerGuard(FileMonitor * parent)
- : QObject(parent), parent_(parent), delay_(0)
+void ActiveFileMonitor::checkModified()
{
- QObject::disconnect(parent_->monitor_.get(), SIGNAL(fileChanged()),
- parent_, SLOT(changed()));
+ if (cooldown_)
+ return;
+
+ cooldown_ = true;
+ bool changed = false;
+ filename_.refresh();
+ bool exists = filename_.exists();
+ if (!exists) {
+ changed = timestamp_ || checksum_;
+ timestamp_ = 0;
+ checksum_ = 0;
+ } else {
+ time_t const new_timestamp = filename_.lastModified();
+
+ if (new_timestamp != timestamp_) {
+ timestamp_ = new_timestamp;
+
+ unsigned long const new_checksum = filename_.checksum();
+ if (new_checksum != checksum_) {
+ checksum_ = new_checksum;
+ changed = true;
+ }
+ }
+ }
+ if (changed)
+ Q_EMIT FileMonitor::fileChanged(exists);
+ QTimer::singleShot(interval_, this, SLOT(clearCooldown()));
}
-void FileMonitorBlockerGuard::setDelay(int delay)
+void ActiveFileMonitor::checkModifiedAsync()
{
- delay_ = max(delay_, delay);
+ if (!cooldown_)
+ QTimer::singleShot(0, this, SLOT(checkModified()));
}
-FileMonitorBlockerGuard::~FileMonitorBlockerGuard()
-{
- // closures can only copy local copies
- FileMonitor * parent = parent_;
- // parent is also our QObject::parent() so we are deleted before parent.
- // 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_, parent, SLOT(connectToFileMonitorGuard()));
-}
} // namespace support
} // namespace lyx
projects / lyx.git / blobdiff