diff --git a/src/FolderColumns.qml b/src/FolderColumns.qml index e8e26607..4542bd6b 100644 --- a/src/FolderColumns.qml +++ b/src/FolderColumns.qml @@ -21,6 +21,8 @@ Item { Selecting { id: selecting; view: here; pageStep: Math.max(1, Math.floor(here.height / 32) - 1) } function focusView() { here.forceActiveFocus() } + // The preview's ↑ and ↓: the row above or below in the current column. + function stepRow(direction) { direction < 0 ? here.decrementCurrentIndex() : here.incrementCurrentIndex() } function menuAnchor() { return here.currentItem } // Every column has a menu: on an item there, or on the column's folder. diff --git a/src/FolderGrid.qml b/src/FolderGrid.qml index e64bc139..27dbcaf1 100644 --- a/src/FolderGrid.qml +++ b/src/FolderGrid.qml @@ -11,6 +11,8 @@ GridView { signal cursorLetGo() function letGo() { selecting.letGo(); cursorLetGo() } function focusView() { forceActiveFocus() } + // The preview's ↑ and ↓: the tile above or below, as the arrow keys move here. + function stepRow(direction) { direction < 0 ? moveCurrentIndexUp() : moveCurrentIndexDown() } // Where the keyboard's menu (Alt+Return) opens: beside the cursor's item. function menuAnchor() { return currentItem } diff --git a/src/FolderList.qml b/src/FolderList.qml index 518cd483..2a79ebe9 100644 --- a/src/FolderList.qml +++ b/src/FolderList.qml @@ -14,6 +14,8 @@ FileListView { signal cursorLetGo() function letGo() { selecting.letGo(); cursorLetGo() } function focusView() { forceActiveFocus() } + // The preview's ↑ and ↓: the row above or below. + function stepRow(direction) { direction < 0 ? decrementCurrentIndex() : incrementCurrentIndex() } // Where the keyboard's menu (Alt+Return) opens: beside the cursor's item. function menuAnchor() { return currentItem } diff --git a/src/FolderPane.qml b/src/FolderPane.qml index aef2751c..7a377a5e 100644 --- a/src/FolderPane.qml +++ b/src/FolderPane.qml @@ -233,6 +233,14 @@ FocusScope { Connections { target: backend function onSelectRequested(name) { if (view.item) view.item.select(backend.folder.indexOf(name), false) } + function onSelectPathRequested(path) { + const row = backend.folder.indexOfPath(path) + if (view.item && row >= 0) + view.item.select(row, false) + } + // Followed now, not later as a re-read is: the preview waits for the + // new item before its next arrow. + function onStepRequested(direction) { if (view.item) { view.item.stepRow(direction); pane.follow() } } function onActivateRequested() { if (pane.host) { pane.host.raise(); pane.host.requestActivate() } } } diff --git a/src/PdfPreview.qml b/src/PdfPreview.qml index ec095231..e706afa2 100644 --- a/src/PdfPreview.qml +++ b/src/PdfPreview.qml @@ -6,6 +6,9 @@ import QtQuick.Pdf Item { id: pdf + // ↑ and ↓ move between the pages, or with only one, to the next item. + readonly property bool scrolls: doc.pageCount > 1 + function fit() { view.scaleToWidth(Math.min(width - 48, 960), height) } function zoomBy(factor) { view.renderScale = Math.max(0.1, Math.min(10, view.renderScale * factor)) } function scroll(direction) { page(direction) } diff --git a/src/PreviewWindow.qml b/src/PreviewWindow.qml index 2b710086..73543365 100644 --- a/src/PreviewWindow.qml +++ b/src/PreviewWindow.qml @@ -59,8 +59,24 @@ ApplicationWindow { Shortcut { sequence: "Left"; context: Qt.ApplicationShortcut; onActivated: win.rtl ? previewer.next() : previewer.previous() } Shortcut { sequence: "Right"; context: Qt.ApplicationShortcut; onActivated: win.rtl ? previewer.previous() : previewer.next() } Shortcut { sequences: ["Return", "Enter"]; context: Qt.ApplicationShortcut; onActivated: previewer.open() } - Shortcut { sequences: ["Up"]; context: Qt.ApplicationShortcut; onActivated: win.call("scroll", -1) } - Shortcut { sequences: ["Down"]; context: Qt.ApplicationShortcut; onActivated: win.call("scroll", 1) } + // ↑ and ↓ scroll what's taller than the window (a long text, a zoomed + // picture, a PDF); anything that fits moves to the item above or below, + // as the arrows do in the folder. + function upDown(direction) { + // A text still being read looks short; stepping past it then would + // skip a long one. The next press, once it's in, knows which. + if (previewer.readingText) + return + const v = win.view + const scrolls = v && typeof v.scroll === "function" + && (v.scrolls !== undefined ? v.scrolls : v.contentHeight > v.height + 1) + if (scrolls) + v.scroll(direction) + else + previewer.stepRow(direction) + } + Shortcut { sequences: ["Up"]; context: Qt.ApplicationShortcut; onActivated: win.upDown(-1) } + Shortcut { sequences: ["Down"]; context: Qt.ApplicationShortcut; onActivated: win.upDown(1) } Shortcut { sequences: [StandardKey.MoveToPreviousPage]; context: Qt.ApplicationShortcut; onActivated: win.call("page", -1) } Shortcut { sequences: [StandardKey.MoveToNextPage]; context: Qt.ApplicationShortcut; onActivated: win.call("page", 1) } Shortcut { sequences: [StandardKey.ZoomIn, "Ctrl+="]; context: Qt.ApplicationShortcut; onActivated: win.call("zoomBy", 1.25) } @@ -188,7 +204,7 @@ ApplicationWindow { visible: win.helpVisible onDismissed: win.helpVisible = false groups: [{ title: qsTr("Preview"), shortcuts: [ - [qsTr("Previous / next file"), win.rtl ? [["→"], ["←"]] : [["←"], ["→"]]], + [qsTr("Previous / next file"), (win.rtl ? [["→"], ["←"]] : [["←"], ["→"]]).concat([["↑"], ["↓"]])], [qsTr("Open in its app"), [["⏎"]]], [qsTr("Scroll"), [["↑", "↓"], ["Page Up"], ["Page Down"]]], [qsTr("Zoom in / out"), [["Ctrl", "="], ["Ctrl", "-"]]], diff --git a/src/backend.cpp b/src/backend.cpp index 878f98ba..e9614771 100644 --- a/src/backend.cpp +++ b/src/backend.cpp @@ -41,13 +41,8 @@ Backend::Backend(const QString &home, QObject *parent) }); // The preview reports each file it steps to, and the grid follows. connect(&m_preview, &QProcess::readyReadStandardOutput, this, [this] { - while (m_preview.canReadLine()) { - const QString shown = QString::fromUtf8(m_preview.readLine()).trimmed(); - m_previewed = shown; - const QFileInfo info(shown); - if (info.absolutePath() == path()) - emit selectRequested(info.fileName()); - } + while (m_preview.canReadLine()) + previewSaid(QString::fromUtf8(m_preview.readLine()).trimmed()); }); connect(&m_preview, &QProcess::stateChanged, this, &Backend::previewingChanged); connect(&m_preview, &QProcess::finished, this, [this](int, QProcess::ExitStatus status) { @@ -720,3 +715,22 @@ void Backend::setBusy(const QString &busy) { m_busy = busy; emit busyChanged(); } + +void Backend::previewSaid(const QString &shown) { + if (shown.startsWith("step ")) { + // The view moves and sends its new item right away (or nothing, at + // the first or last row); "stepped" after it lets the preview take + // the arrows that came meanwhile. + emit stepRequested(shown.mid(5).toInt() < 0 ? -1 : 1); + if (previewing()) + m_preview.write("stepped\n"); + return; + } + m_previewed = shown; + // Any file in the folder shown or below it: one in a folder opened in + // place (the list's tree) is a row too, and the cursor goes to it, so + // ↑ and ↓ step from there. + const QString here = path().endsWith('/') ? path() : path() + '/'; + if (shown.startsWith(here)) + emit selectPathRequested(shown); +} diff --git a/src/backend.h b/src/backend.h index 4e5ea958..4c066234 100644 --- a/src/backend.h +++ b/src/backend.h @@ -112,6 +112,9 @@ class Backend : public QObject { // Space: opens the large preview of a file in its own process, or closes // it when it's already open. Q_INVOKABLE void togglePreview(const QString &path); + // A line from the preview: the file it moved to, or "step -1"/"step 1" + // asking for the row above or below. + void previewSaid(const QString &line); // Ctrl+N: another window, on the folder this one shows. Q_INVOKABLE void newWindow(); // In a file chooser, opening a file picks it (chosen) rather than opening @@ -150,6 +153,12 @@ class Backend : public QObject { void newWindowRequested(const QString &path); void chosen(const QString &path); void selectRequested(const QString &name); + // The preview moved to `path`, in the folder shown or a folder opened in + // place in it: the cursor goes to its row. + void selectPathRequested(const QString &path); + // The preview's ↑ or ↓ on a file it can't scroll: move one row in the + // folder view, whose layout only this window knows. + void stepRequested(int direction); void activateRequested(); private: diff --git a/src/previewer.cpp b/src/previewer.cpp index 91735f27..6d6c2468 100644 --- a/src/previewer.cpp +++ b/src/previewer.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -191,14 +192,61 @@ QString Previewer::type() const { return QMimeDatabase().mimeTypeForName(m_readType.isEmpty() ? m_entries.at(m_index).mime : m_readType).comment(); } -void Previewer::next() { - if (m_index + 1 < m_entries.size()) - setIndex(m_index + 1, true); +void Previewer::next() { move(Move::Next); } +void Previewer::previous() { move(Move::Previous); } +void Previewer::stepRow(int direction) { move(direction < 0 ? Move::Up : Move::Down); } + +void Previewer::move(Move move) { + // Folio answers within milliseconds, sooner than a key repeats. + if (m_awaitingStep) + return; + // On its own, the preview has no rows: ↑ and ↓ go to the previous and + // next file. + if (!m_reporting && (move == Move::Up || move == Move::Down)) + move = move == Move::Up ? Move::Previous : Move::Next; + switch (move) { + case Move::Previous: + if (m_index > 0) + setIndex(m_index - 1, true); + break; + case Move::Next: + if (m_index + 1 < m_entries.size()) + setIndex(m_index + 1, true); + break; + case Move::Up: + case Move::Down: { + m_awaitingStep = true; + // A reply that never comes (a Folio too old to send it, or stuck) + // stills the arrows for a second, not for good. + const quint64 step = ++m_step; + QTimer::singleShot(1000, this, [this, step] { + if (step == m_step) + stepped(); + }); + report(move == Move::Up ? "step -1" : "step 1"); + break; + } + } +} + +void Previewer::stepped() { + m_awaitingStep = false; + ++m_step; } -void Previewer::previous() { - if (m_index > 0) - setIndex(m_index - 1, true); +void Previewer::receive(const QString &line) { + if (line == "stepped") + stepped(); + else if (!line.isEmpty()) + show(line); +} + +void Previewer::report(const QString &line) { + emit reported(line); + if (m_overStdio) { + std::fprintf(stdout, "%s\n", line.toUtf8().constData()); + std::fflush(stdout); + } } void Previewer::open() { @@ -218,6 +266,7 @@ void Previewer::setIndex(int index, bool report) { m_viewer = viewerFor(e.mime, e.isDir); m_text.clear(); m_readType.clear(); + m_readingText = false; // A folder's count and first pictures, and a text's opening part, are // read off the UI thread: a big folder, or any file on a slow mount, @@ -228,6 +277,8 @@ void Previewer::setIndex(int index, bool report) { // A file its extension could not name is named by what it holds, read with the rest and kept apart from the listing. const bool unnamed = e.mime == "application/octet-stream"; if (count || text || unnamed) { + // A file its name gave no type may turn out to be a long text. + m_readingText = text || unnamed; auto *watcher = new QFutureWatcher>(this); connect(watcher, &QFutureWatcherBase::finished, this, [this, watcher, generation, unnamed] { watcher->deleteLater(); @@ -240,6 +291,7 @@ void Previewer::setIndex(int index, bool report) { m_entries[m_index] = entry; m_text = read; m_viewer = viewerFor(entry.mime, entry.isDir); + m_readingText = false; // A ".txt" that turns out to be binary is shown as a plain file. if ((m_viewer == "text" || m_viewer == "markdown") && m_text.isEmpty() && entry.size > 0) m_viewer = "other"; @@ -261,14 +313,15 @@ void Previewer::setIndex(int index, bool report) { emit changed(); emit listed(); - if (report && m_reporting) { - std::fprintf(stdout, "%s\n", e.path.toUtf8().constData()); - std::fflush(stdout); - } + if (report && m_reporting) + this->report(e.path); } -void Previewer::connectToFolio() { +void Previewer::connectToFolio(bool overStdio) { m_reporting = true; + m_overStdio = overStdio; + if (!overStdio) + return; m_stdin = new QSocketNotifier(STDIN_FILENO, QSocketNotifier::Read, this); connect(m_stdin, &QSocketNotifier::activated, this, [this] { char buffer[4096]; @@ -281,10 +334,9 @@ void Previewer::connectToFolio() { m_pending.append(buffer, n); int newline; while ((newline = m_pending.indexOf('\n')) >= 0) { - const QString path = QString::fromUtf8(m_pending.left(newline)); + const QString line = QString::fromUtf8(m_pending.left(newline)); m_pending.remove(0, newline + 1); - if (!path.isEmpty()) - show(path); + receive(line); } }); } diff --git a/src/previewer.h b/src/previewer.h index 0bd4d1c2..b189df00 100644 --- a/src/previewer.h +++ b/src/previewer.h @@ -16,7 +16,11 @@ // // Talks to the Folio window that started it over stdin and stdout, one path // per line: Folio writes the item selected in its grid, the preview writes -// the item it steps to, and each side follows the other. +// the item it steps to, and each side follows the other. ↑ and ↓ are written +// as "step -1" and "step 1": rows belong to the folder view, so Folio moves +// its selection, sends the new item back, then "stepped". Arrows pressed +// before that are let go: taken from the old item, they'd undo the move, +// and replayed later, from a file not yet looked at, they'd skip it. class Previewer : public QObject { Q_OBJECT // Listing the folder only changes where the item sits among its @@ -28,6 +32,10 @@ class Previewer : public QObject { Q_PROPERTY(QString viewer READ viewer NOTIFY changed) Q_PROPERTY(QString url READ url NOTIFY changed) Q_PROPERTY(QString text READ text NOTIFY changed) + // A text's opening part, or the type of a file its name gave none, is + // still being read: until it's in, whether it's a long text (whether ↑ + // and ↓ scroll it or step past it) isn't known. + Q_PROPERTY(bool readingText READ readingText NOTIFY changed) Q_PROPERTY(QString type READ type NOTIFY changed) public: @@ -39,8 +47,12 @@ class Previewer : public QObject { // Shows the file right away, then lists its folder in the background so // the arrow keys can step to its neighbours. void start(const QString &path, bool showHidden, const QString &sort); - // Reads paths from stdin and reports steps on stdout. - void connectToFolio(); + // Reads paths from stdin and reports steps on stdout; the tests leave + // stdin and stdout alone and talk through receive() and reported(). + void connectToFolio(bool overStdio = true); + // One line from Folio: a path to show, or "stepped" once it has moved a + // row for ↑ or ↓. + void receive(const QString &line); // Shows another file; one in the same folder keeps the list. void show(const QString &path); // Lists the folder again, keeping the file shown: after a language @@ -53,10 +65,14 @@ class Previewer : public QObject { QString viewer() const { return m_viewer; } QString url() const; QString text() const { return m_text; } + bool readingText() const { return m_readingText; } QString type() const; Q_INVOKABLE void next(); Q_INVOKABLE void previous(); + // ↑ or ↓: the item above or below in the Folio window's view, or the + // previous or next file when the preview runs on its own. + Q_INVOKABLE void stepRow(int direction); Q_INVOKABLE void open(); // Which view shows a type: image, animated, thumbnail, video, audio, @@ -76,9 +92,15 @@ class Previewer : public QObject { void listed(); // The item was handed to its app, and the preview has done its part. void opened(); + // A line for Folio: the path stepped to, or "step -1" / "step 1". + void reported(const QString &line); private: + enum class Move { Previous, Next, Up, Down }; + void move(Move move); + void stepped(); void setIndex(int index, bool report); + void report(const QString &line); Opener m_opener; QVector m_entries; @@ -87,6 +109,7 @@ class Previewer : public QObject { QString m_text; // The type read from what the shown file holds when its name gave none, for this showing only: a file written since is read again. QString m_readType; + bool m_readingText = false; bool m_showHidden = false; QString m_sort = "name"; quint64 m_generation = 0; @@ -94,6 +117,11 @@ class Previewer : public QObject { // or skipped when they haven't started. std::shared_ptr> m_reading = std::make_shared>(0); bool m_reporting = false; + bool m_overStdio = false; + // Set from a "step" until Folio's "stepped"; the arrows pressed meanwhile + // are let go. + bool m_awaitingStep = false; + quint64 m_step = 0; QSocketNotifier *m_stdin = nullptr; QByteArray m_pending; }; diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index 6a0aeeb4..42dada32 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -7357,6 +7357,14 @@ private slots: QTRY_COMPARE_WITH_TIMEOUT(cursor(), home.filePath("files/alpha/z.txt"), 3000); QCOMPARE(folder->get(folder->indexOfPath(home.filePath("files/alpha/z.txt"))).value("selected").toBool(), true); QCOMPARE(folder->selectedCount(), 1); + + // The preview stepping to a file in the opened folder moves the + // cursor to its row, so ↑ and ↓ step from there; one outside the + // folder shown leaves it be. + backend.previewSaid(home.filePath("files/alpha/b.txt")); + QTRY_COMPARE(cursor(), home.filePath("files/alpha/b.txt")); + backend.previewSaid(home.filePath("elsewhere/x.txt")); + QCOMPARE(cursor(), home.filePath("files/alpha/b.txt")); } // Right-click selects the item under the pointer in a scrolled view too, @@ -7639,6 +7647,149 @@ private slots: QCOMPARE(buffers(), QVariantList(buffers().size(), 0)); } + void previewerStepsByRowOnItsOwn() + { + QTemporaryDir dir; + write(dir.filePath("a.png"), "a"); + write(dir.filePath("b.png"), "b"); + write(dir.filePath("c.png"), "c"); + + // Without a Folio window to ask for the row above or below, ↑ and ↓ + // fall back to the previous and next file. + Previewer previewer; + previewer.start(dir.filePath("b.png"), false, "name"); + QTRY_COMPARE(previewer.count(), 3); + QCOMPARE(previewer.index(), 1); + previewer.stepRow(1); + QCOMPARE(previewer.index(), 2); + previewer.stepRow(1); + QCOMPARE(previewer.index(), 2); + previewer.stepRow(-1); + previewer.stepRow(-1); + QCOMPARE(previewer.index(), 0); + } + + void previewerLetsArrowsGoUntilFolioHasStepped() + { + QTemporaryDir dir; + for (const char *name : {"a.png", "b.png", "c.png", "d.png"}) + write(dir.filePath(name), "x"); + + Previewer previewer; + previewer.connectToFolio(false); + QSignalSpy reported(&previewer, &Previewer::reported); + previewer.start(dir.filePath("a.png"), false, "name"); + QTRY_COMPARE(previewer.count(), 4); + + // ↓ then → and ↓ before Folio answers: they're let go, rather than + // taken from a.png (undoing the move) or replayed past c.png before + // it's been looked at. + previewer.stepRow(1); + previewer.next(); + previewer.stepRow(1); + QCOMPARE(reported.count(), 1); + QCOMPARE(reported.at(0).at(0).toString(), QString("step 1")); + previewer.receive(dir.filePath("c.png")); + previewer.receive("stepped"); + QCOMPARE(previewer.index(), 2); + QCOMPARE(reported.count(), 1); + // Once it has, the arrows are taken from where Folio moved to. + previewer.next(); + QCOMPARE(previewer.index(), 3); + QCOMPARE(reported.count(), 2); + QCOMPARE(reported.at(1).at(0).toString(), QFileInfo(dir.filePath("d.png")).absoluteFilePath()); + + // At the last row Folio doesn't move, and only says it has stepped. + previewer.stepRow(1); + previewer.receive("stepped"); + QCOMPARE(previewer.index(), 3); + previewer.previous(); + QCOMPARE(previewer.index(), 2); + + // A reply that never comes stills the arrows for a moment only. + previewer.stepRow(-1); + previewer.previous(); + QCOMPARE(previewer.index(), 2); + QTest::qWait(1100); + previewer.previous(); + QCOMPARE(previewer.index(), 1); + } + + void previewerSaysWhileItReadsText() + { + QTemporaryDir dir; + write(dir.filePath("long.txt"), QByteArray(4096, 'x')); + write(dir.filePath("b.png"), "b"); + + Previewer previewer; + previewer.start(dir.filePath("long.txt"), false, "name"); + QVERIFY(previewer.readingText()); + QTRY_VERIFY(!previewer.readingText()); + QCOMPARE(previewer.text().size(), 4096); + previewer.show(dir.filePath("b.png")); + QVERIFY(!previewer.readingText()); + + // A file its name gives no type might be a long text too, until + // what it holds has been read. + write(dir.filePath("NOTES"), QByteArray(4096, 'x')); + previewer.show(dir.filePath("NOTES")); + QVERIFY(previewer.readingText()); + QTRY_VERIFY(!previewer.readingText()); + QCOMPARE(previewer.viewer(), QString("text")); + } + + void previewStepsPastAOnePagePdf() + { + QTemporaryDir dir; + for (const char *name : {"one.pdf", "two.pdf"}) { + QPdfWriter pdf(dir.filePath(name)); + QPainter painter(&pdf); + if (QByteArray(name) == "two.pdf") + pdf.newPage(); + } + write(dir.filePath("z.png"), "z"); + + Previewer previewer; + previewer.connectToFolio(false); + QSignalSpy reported(&previewer, &Previewer::reported); + previewer.start(dir.filePath("two.pdf"), false, "name"); + Theme theme(dir.filePath("theme")); + Thumbnails thumbnails(dir.filePath("cache"), {dir.filePath("none")}); + QQmlEngine engine; + engine.rootContext()->setContextProperty("theme", &theme); + engine.rootContext()->setContextProperty("translator", QVariantMap{{"language", "en"}}); + engine.rootContext()->setContextProperty("previewer", &previewer); + engine.addImageProvider("thumb", new ThumbnailProvider(&thumbnails)); + QQmlComponent pdf(&engine); + pdf.setData("import QtQuick.Pdf\nPdfDocument {}\n", QUrl()); + if (pdf.isError()) + QSKIP("Qt PDF isn't installed"); + QQmlComponent component(&engine, QUrl("qrc:/PreviewWindow.qml")); + std::unique_ptr window(component.create()); + QVERIFY2(window, qPrintable(component.errorString())); + const auto pages = [&]() -> int { + auto *view = window->property("view").value(); + for (QObject *child : view ? view->children() : QObjectList()) + if (child->property("pageCount").isValid()) + return child->property("pageCount").toInt(); + return -1; + }; + const auto steps = [&] { + int n = 0; + for (const QList &line : reported) + n += line.at(0).toString().startsWith("step "); + return n; + }; + // Pages to turn take ↑ and ↓; a single page lets them move on. + QTRY_COMPARE(pages(), 2); + QMetaObject::invokeMethod(window.get(), "upDown", Q_ARG(QVariant, 1)); + QCOMPARE(steps(), 0); + previewer.show(dir.filePath("one.pdf")); + QTRY_COMPARE(pages(), 1); + QMetaObject::invokeMethod(window.get(), "upDown", Q_ARG(QVariant, 1)); + QCOMPARE(steps(), 1); + } + void themeFallsBack() { QTemporaryDir dir;