* 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.
*
#ifndef FILEMONITOR_H
#define FILEMONITOR_H
+#include <memory>
+
+#include <QFileSystemWatcher>
+#include <QObject>
+
#include <boost/signals2.hpp>
+
namespace lyx {
namespace support {
class FileName;
-class FileMonitor
+///
+/// FileMonitor, a file monitor based on QFileSystemWatcher
+///
+
+class FileMonitor;
+class FileMonitorGuard;
+using FileMonitorPtr = std::unique_ptr<FileMonitor>;
+
+///
+/// Watch a file:
+/// FileMonitorPtr monitor = FileSystemWatcher::monitor(file_with_path);
+/// monitor.connect(...); //(using boost::signals2), or:
+/// connect(monitor, SIGNAL(fileChanged()),...); // (using Qt)
+///
+/// Remember that a unique_ptr is automatically deleted at the end of a scope if
+/// it has not been moved, or when assigned. When that happens, the signal
+/// object is deleted and therefore all the connections are closed. The file
+/// ceases being tracked when all the monitors for a file have been deleted.
+///
+/// Stop watching:
+/// * as determined statically by the scope, or
+/// * dynamically, using:
+/// monitor = nullptr;
+///
+/// Watch a different file:
+/// monitor = FileSystemWatcher::monitor(file_with_path2);
+/// 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.
+///
+class FileSystemWatcher
+{
+public:
+ // as described above
+ static FileMonitorPtr monitor(FileName const & file_with_path);
+ // Output whether the paths tracked by qwatcher_ and the active
+ // FileMonitorGuards are in correspondence.
+ static void debug();
+private:
+ FileSystemWatcher();
+ // A global instance is created automatically on first call to monitor
+ static FileSystemWatcher & instance();
+ // Caches the monitor guards but allow them to be destroyed
+ std::map<std::string, std::weak_ptr<FileMonitorGuard>> store_;
+ // This class is a wrapper for QFileSystemWatcher
+ std::unique_ptr<QFileSystemWatcher> const qwatcher_;
+};
+
+
+// Must be unique per path
+// Ends the watch when deleted
+class FileMonitorGuard : public QObject
+{
+ Q_OBJECT
+
+public:
+ /// Start the watch
+ FileMonitorGuard(std::string const & filename,
+ QFileSystemWatcher * qwatcher);
+ /// End the watch
+ ~FileMonitorGuard();
+ /// absolute path being tracked
+ std::string const & filename() { return filename_; }
+ /// Make sure it is being monitored, after e.g. a deletion. See
+ /// <https://bugreports.qt.io/browse/QTBUG-46483>. This is called
+ /// automatically.
+ /// \param new_file If true, emit fileChanged if the file exists and was
+ /// successfully added.
+ void refresh(bool new_file = false);
+
+Q_SIGNALS:
+ /// Connect to this to be notified when the file changes
+ void fileChanged() const;
+
+private Q_SLOTS:
+ /// Receive notifications from the QFileSystemWatcher
+ void notifyChange(QString const & path);
+
+private:
+ std::string const filename_;
+ QFileSystemWatcher * qwatcher_;
+};
+
+
+class FileMonitorBlockerGuard : public QObject
{
+ Q_OBJECT
+ FileMonitor * parent_;
+ int delay_;
+
public:
- /** Once monitoring begins, the file will be monitored every
- * interval ms.
- *
- * FIXME: rewrite and simplify using an encapsulation of QFileSystemWatcher.
- */
- FileMonitor(FileName const & file_with_path, int interval);
-
- /// Destructor
- ~FileMonitor();
-
- ///
- void reset(FileName const & file_with_path) const;
-
- ///
- FileName const & filename() const;
-
- /// Begin monitoring the file
- void start() const;
- ///
- void stop() const;
- ///
- bool monitoring() const;
-
- /** The checksum is recomputed whenever the file is modified.
- * If the file is not being monitored, then the checksum will be
- * recomputed each time this function is called.
- */
- unsigned long checksum() const;
+ FileMonitorBlockerGuard(FileMonitor * parent);
+ ~FileMonitorBlockerGuard();
+ void setDelay(int delay);
+};
+
+
+using FileMonitorBlocker = std::shared_ptr<FileMonitorBlockerGuard>;
+
+/// Main class
+class FileMonitor : public QObject
+{
+ Q_OBJECT
+ friend class FileMonitorBlockerGuard;
+
+public:
+ FileMonitor(std::shared_ptr<FileMonitorGuard> monitor);
+
+ using sig = boost::signals2::signal<void()>;
/// Connect and you'll be informed when the file has changed.
- typedef boost::signals2::signal<void()> FileChangedSig;
- typedef FileChangedSig::slot_type slot_type;
- ///
- boost::signals2::connection connect(slot_type const &) 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();
+ /// 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 around.
+ /// \param delay is the amount waited in ms after expiration of the guard
+ /// 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
+ /// called automatically.
+ void refresh() { return monitor_->refresh(); }
+
+Q_SIGNALS:
+ /// Connect to this to be notified when the file changes
+ void fileChanged() const;
+
+private Q_SLOTS:
+ /// Receive notifications from the FileMonitorGuard
+ void changed();
private:
- /// noncopyable
- FileMonitor(FileMonitor const &);
- void operator=(FileMonitor const &);
-
- /// Use the Pimpl idiom to hide the internals.
- class Impl;
- /// The pointer never changes although *pimpl_'s contents may.
- Impl * const pimpl_;
+ void connectToFileMonitorGuard();
+ // boost signal
+ sig fileChanged_;
+ // the unique watch for our file
+ std::shared_ptr<FileMonitorGuard> const monitor_;
+ //
+ std::weak_ptr<FileMonitorBlockerGuard> blocker_;
};
+
+
} // namespace support
} // namespace lyx