diff options
Diffstat (limited to 'desktop-plasma/patches')
12 files changed, 598 insertions, 168 deletions
diff --git a/desktop-plasma/patches/kde-apps/dolphin/0001-Ignore-trailing-slashes-when-comparing-place-URLs.patch b/desktop-plasma/patches/kde-apps/dolphin/0001-Ignore-trailing-slashes-when-comparing-place-URLs.patch deleted file mode 100644 index 385da80..0000000 --- a/desktop-plasma/patches/kde-apps/dolphin/0001-Ignore-trailing-slashes-when-comparing-place-URLs.patch +++ /dev/null @@ -1,73 +0,0 @@ -From 046ddcf5607e597cd6290147bf7ee10c08e526dd Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?Wolfgang=20M=C3=BCller?= <wolf@oriole.systems> -Date: Thu, 19 Sep 2024 11:46:09 +0200 -Subject: [PATCH] Ignore trailing slashes when comparing place URLs - -There's two locations where place URLs are compared in Dolphin. One -is in DolphinContextMenu::placeExists, which determines whether or not -to show an "Add to Places" context menu entry. The other one is in -DolphinViewContainer::caption, which provides the place name for use in -the window title, if applicable. - -Neither of these functions correctly normalize the URL to account for -trailing slashes. Whilst placeExists() does not even attempt it, -caption() was changed in 681d8bb6c (Fix wrong window titles, 2019-09-15) -to support this using a regular expression. - -However, caption() fails to escape the URL before incorporating it in -the regular expression, leading to failed matches and errors like the -following when browsing to directories that do not happen to make up a -valid regular expression: - - QString(View)::contains(): called on an invalid QRegularExpression - object (pattern is '\A(?:file:///home/foo/[Z-A]/?)\z') - -Instead of relying on complex and possibly brittle regular expressions, -use KFilePlacesModel's closestItem() function to find the closest -matching URL and then finally check whether the normalized URLs match -exactly. ---- - src/dolphincontextmenu.cpp | 5 ++--- - src/dolphinviewcontainer.cpp | 9 ++++----- - 2 files changed, 6 insertions(+), 8 deletions(-) - -diff --git a/src/dolphincontextmenu.cpp b/src/dolphincontextmenu.cpp -index 68f6dbd21..3ce1d1d51 100644 ---- a/src/dolphincontextmenu.cpp -+++ b/src/dolphincontextmenu.cpp -@@ -381,9 +381,8 @@ bool DolphinContextMenu::placeExists(const QUrl &url) const - { - const KFilePlacesModel *placesModel = DolphinPlacesModelSingleton::instance().placesModel(); - -- const auto &matchedPlaces = placesModel->match(placesModel->index(0, 0), KFilePlacesModel::UrlRole, url, 1, Qt::MatchExactly); -- -- return !matchedPlaces.isEmpty(); -+ QModelIndex url_index = placesModel->closestItem(url); -+ return url_index.isValid() && placesModel->url(url_index).matches(url, QUrl::StripTrailingSlash); - } - - QAction *DolphinContextMenu::createPasteAction() -diff --git a/src/dolphinviewcontainer.cpp b/src/dolphinviewcontainer.cpp -index ef76042b8..e55519d04 100644 ---- a/src/dolphinviewcontainer.cpp -+++ b/src/dolphinviewcontainer.cpp -@@ -552,12 +552,11 @@ QString DolphinViewContainer::caption() const - } - - KFilePlacesModel *placesModel = DolphinPlacesModelSingleton::instance().placesModel(); -- const QString pattern = url().adjusted(QUrl::StripTrailingSlash).toString(QUrl::FullyEncoded).append("/?"); -- const auto &matchedPlaces = -- placesModel->match(placesModel->index(0, 0), KFilePlacesModel::UrlRole, QRegularExpression::anchoredPattern(pattern), 1, Qt::MatchRegularExpression); - -- if (!matchedPlaces.isEmpty()) { -- return placesModel->text(matchedPlaces.first()); -+ QModelIndex url_index = placesModel->closestItem(url()); -+ -+ if (url_index.isValid() && placesModel->url(url_index).matches(url(), QUrl::StripTrailingSlash)) { -+ return placesModel->text(url_index); - } - - if (!url().isLocalFile()) { --- -2.46.0 - diff --git a/desktop-plasma/patches/kde-apps/dolphin/0001-Kitemlistcontroller-only-accept-doubleclick-for-left.patch b/desktop-plasma/patches/kde-apps/dolphin/0001-Kitemlistcontroller-only-accept-doubleclick-for-left.patch new file mode 100644 index 0000000..b8a53a1 --- /dev/null +++ b/desktop-plasma/patches/kde-apps/dolphin/0001-Kitemlistcontroller-only-accept-doubleclick-for-left.patch @@ -0,0 +1,106 @@ +From 531244611f11bfee9f6b9f2efd98ed418d860b3d Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?M=C3=A9ven=20Car?= <meven@kde.org> +Date: Wed, 31 Jul 2024 11:00:32 +0200 +Subject: [PATCH 1/4] Kitemlistcontroller: only accept doubleclick for left + mouse button + +Add test for double-click activation. + +BUG: 485295 +--- + src/kitemviews/kitemlistcontroller.cpp | 2 +- + src/tests/kitemlistcontrollertest.cpp | 58 ++++++++++++++++++++++++++ + 2 files changed, 59 insertions(+), 1 deletion(-) + +diff --git a/src/kitemviews/kitemlistcontroller.cpp b/src/kitemviews/kitemlistcontroller.cpp +index 392dc410e..997e6623b 100644 +--- a/src/kitemviews/kitemlistcontroller.cpp ++++ b/src/kitemviews/kitemlistcontroller.cpp +@@ -713,7 +713,7 @@ bool KItemListController::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event, + } + } + +- if (event->button() & Qt::RightButton) { ++ if (event->button() & ~Qt::LeftButton) { + return false; + } + +diff --git a/src/tests/kitemlistcontrollertest.cpp b/src/tests/kitemlistcontrollertest.cpp +index cb921781d..18ad1186d 100644 +--- a/src/tests/kitemlistcontrollertest.cpp ++++ b/src/tests/kitemlistcontrollertest.cpp +@@ -620,6 +620,41 @@ void KItemListControllerTest::testMouseClickActivation() + mouseReleaseEvent.setButton(Qt::LeftButton); + mouseReleaseEvent.setButtons(Qt::NoButton); + ++ QGraphicsSceneMouseEvent mouseDoubleClickEvent(QEvent::GraphicsSceneMouseDoubleClick); ++ mouseDoubleClickEvent.setPos(pos); ++ mouseDoubleClickEvent.setButton(Qt::LeftButton); ++ mouseDoubleClickEvent.setButtons(Qt::LeftButton); ++ ++ QGraphicsSceneMouseEvent mouseRightPressEvent(QEvent::GraphicsSceneMousePress); ++ mouseRightPressEvent.setPos(pos); ++ mouseRightPressEvent.setButton(Qt::RightButton); ++ mouseRightPressEvent.setButtons(Qt::RightButton); ++ ++ QGraphicsSceneMouseEvent mouseRightReleaseEvent(QEvent::GraphicsSceneMouseRelease); ++ mouseRightReleaseEvent.setPos(pos); ++ mouseRightReleaseEvent.setButton(Qt::RightButton); ++ mouseRightReleaseEvent.setButtons(Qt::NoButton); ++ ++ QGraphicsSceneMouseEvent mouseRightDoubleClickEvent(QEvent::GraphicsSceneMouseDoubleClick); ++ mouseRightDoubleClickEvent.setPos(pos); ++ mouseRightDoubleClickEvent.setButton(Qt::RightButton); ++ mouseRightDoubleClickEvent.setButtons(Qt::RightButton); ++ ++ QGraphicsSceneMouseEvent mouseBackPressEvent(QEvent::GraphicsSceneMousePress); ++ mouseBackPressEvent.setPos(pos); ++ mouseBackPressEvent.setButton(Qt::BackButton); ++ mouseBackPressEvent.setButtons(Qt::BackButton); ++ ++ QGraphicsSceneMouseEvent mouseBackReleaseEvent(QEvent::GraphicsSceneMouseRelease); ++ mouseBackReleaseEvent.setPos(pos); ++ mouseBackReleaseEvent.setButton(Qt::BackButton); ++ mouseBackReleaseEvent.setButtons(Qt::NoButton); ++ ++ QGraphicsSceneMouseEvent mouseBackDoubleClickEvent(QEvent::GraphicsSceneMouseDoubleClick); ++ mouseBackDoubleClickEvent.setPos(pos); ++ mouseBackDoubleClickEvent.setButton(Qt::BackButton); ++ mouseBackDoubleClickEvent.setButtons(Qt::BackButton); ++ + QSignalSpy spyItemActivated(m_controller, &KItemListController::itemActivated); + + // Default setting: single click activation. +@@ -638,6 +673,29 @@ void KItemListControllerTest::testMouseClickActivation() + spyItemActivated.clear(); + QVERIFY(m_view->controller()->selectionManager()->hasSelection()); + ++ // emulation of double click according to https://doc.qt.io/qt-6/qgraphicsscene.html#mouseDoubleClickEvent ++ m_view->event(&mousePressEvent); ++ m_view->event(&mouseReleaseEvent); ++ m_view->event(&mouseDoubleClickEvent); ++ m_view->event(&mouseReleaseEvent); ++ QCOMPARE(spyItemActivated.count(), 1); ++ spyItemActivated.clear(); ++ QVERIFY2(!m_view->controller()->selectionManager()->hasSelection(), "An item should not be implicitly selected during activation. @see bug 424723"); ++ ++ // right mouse button should not trigger activation ++ m_view->event(&mouseRightPressEvent); ++ m_view->event(&mouseRightReleaseEvent); ++ m_view->event(&mouseRightDoubleClickEvent); ++ m_view->event(&mouseRightReleaseEvent); ++ QCOMPARE(spyItemActivated.count(), 0); ++ ++ // back mouse button should not trigger activation ++ m_view->event(&mouseBackPressEvent); ++ m_view->event(&mouseBackReleaseEvent); ++ m_view->event(&mouseBackDoubleClickEvent); ++ m_view->event(&mouseBackReleaseEvent); ++ QCOMPARE(spyItemActivated.count(), 0); ++ + // Enforce single click activation in the controller. + m_controller->setSingleClickActivationEnforced(true); + m_view->event(&mousePressEvent); +-- +2.47.0 + diff --git a/desktop-plasma/patches/kde-apps/dolphin/0001-TerminalPanel-Send-End-instead-of-Ctrl-E-to-move-to-.patch b/desktop-plasma/patches/kde-apps/dolphin/0001-TerminalPanel-Send-End-instead-of-Ctrl-E-to-move-to-.patch new file mode 100644 index 0000000..6b11063 --- /dev/null +++ b/desktop-plasma/patches/kde-apps/dolphin/0001-TerminalPanel-Send-End-instead-of-Ctrl-E-to-move-to-.patch @@ -0,0 +1,33 @@ +From b65e53ac65c265dad3dca5c6687873f035d7c949 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Wolfgang=20M=C3=BCller?= <wolf@oriole.systems> +Date: Tue, 8 Oct 2024 15:36:33 +0200 +Subject: [PATCH] TerminalPanel: Send End instead of Ctrl-E to move to the end + of the line + +When using fish in vi mode it does not have Ctrl-E mapped to go to the +end of the line. Instead use the End key, which should be mapped in all +modes. +--- + src/panels/terminal/terminalpanel.cpp | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/src/panels/terminal/terminalpanel.cpp b/src/panels/terminal/terminalpanel.cpp +index 5b17023a3..dfdc896ff 100644 +--- a/src/panels/terminal/terminalpanel.cpp ++++ b/src/panels/terminal/terminalpanel.cpp +@@ -251,10 +251,10 @@ void TerminalPanel::sendCdToTerminal(const QString &dir, HistoryPolicy addToHist + return; + } + +- // Send prior Ctrl-E, Ctrl-U to ensure the line is empty. This is ++ // Send prior End, Ctrl-U to ensure the line is empty. This is + // mandatory, otherwise sending a 'cd x\n' to a prompt with 'rm -rf *' + // would result in data loss. +- m_terminal->sendInput(QStringLiteral("\x05\x15")); ++ m_terminal->sendInput(QStringLiteral("\x1B[F\x15")); + + // We want to ignore the currentDirectoryChanged(QString) signal, which we will receive after + // the directory change, because this directory change is not caused by a "cd" command that the +-- +2.46.2 + diff --git a/desktop-plasma/patches/kde-apps/dolphin/0002-Only-accept-left-mouse-button-for-double-click-actio.patch b/desktop-plasma/patches/kde-apps/dolphin/0002-Only-accept-left-mouse-button-for-double-click-actio.patch new file mode 100644 index 0000000..9fd79a6 --- /dev/null +++ b/desktop-plasma/patches/kde-apps/dolphin/0002-Only-accept-left-mouse-button-for-double-click-actio.patch @@ -0,0 +1,32 @@ +From fbdbe93e3d6b25fc4a40af4c9c3fe337794452ba Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?M=C3=A9ven=20Car?= <meven@kde.org> +Date: Tue, 13 Aug 2024 11:01:43 +0200 +Subject: [PATCH 2/4] Only accept left mouse button for double click actions + +Such + * double click background + +BUG: 485295 +--- + src/dolphinmainwindow.cpp | 5 ++++- + 1 file changed, 4 insertions(+), 1 deletion(-) + +diff --git a/src/dolphinmainwindow.cpp b/src/dolphinmainwindow.cpp +index 8bc066455..bf605fa96 100644 +--- a/src/dolphinmainwindow.cpp ++++ b/src/dolphinmainwindow.cpp +@@ -2922,7 +2922,10 @@ bool DolphinMainWindow::isItemVisibleInAnyView(const QString &urlOfItem) + + void DolphinMainWindow::slotDoubleClickViewBackground(Qt::MouseButton button) + { +- Q_UNUSED(button) // might be of use later ++ if (button == Qt::MouseButton::LeftButton) { ++ // only handle left mouse button for now ++ return; ++ } + + GeneralSettings *settings = GeneralSettings::self(); + QString clickAction = settings->doubleClickViewAction(); +-- +2.47.0 + diff --git a/desktop-plasma/patches/kde-apps/dolphin/0003-Fix-double-click-view-background-feature.patch b/desktop-plasma/patches/kde-apps/dolphin/0003-Fix-double-click-view-background-feature.patch new file mode 100644 index 0000000..ee6c343 --- /dev/null +++ b/desktop-plasma/patches/kde-apps/dolphin/0003-Fix-double-click-view-background-feature.patch @@ -0,0 +1,30 @@ +From 123eec787f0198b91c3bfdb17262df0c5e9a8c28 Mon Sep 17 00:00:00 2001 +From: Felix Ernst <felixernst@zohomail.eu> +Date: Mon, 14 Oct 2024 14:44:47 +0200 +Subject: [PATCH 3/4] Fix double-click view background feature + +c934e803647674b4692668f047b6ffa18121982a was meant to change the +double-click view background feature to only allow double-clicks +with the left mouse button. However, it mistakenly did the exact +opposite and allowed every double-click except ones with the left +mouse button to trigger the feature. This one-liner fixes this. +--- + src/dolphinmainwindow.cpp | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/dolphinmainwindow.cpp b/src/dolphinmainwindow.cpp +index bf605fa96..9b2c0f97e 100644 +--- a/src/dolphinmainwindow.cpp ++++ b/src/dolphinmainwindow.cpp +@@ -2922,7 +2922,7 @@ bool DolphinMainWindow::isItemVisibleInAnyView(const QString &urlOfItem) + + void DolphinMainWindow::slotDoubleClickViewBackground(Qt::MouseButton button) + { +- if (button == Qt::MouseButton::LeftButton) { ++ if (button != Qt::MouseButton::LeftButton) { + // only handle left mouse button for now + return; + } +-- +2.47.0 + diff --git a/desktop-plasma/patches/kde-apps/dolphin/0004-kitemlistcontroller-process-forward-back-buttons-whe.patch b/desktop-plasma/patches/kde-apps/dolphin/0004-kitemlistcontroller-process-forward-back-buttons-whe.patch new file mode 100644 index 0000000..d0fa8eb --- /dev/null +++ b/desktop-plasma/patches/kde-apps/dolphin/0004-kitemlistcontroller-process-forward-back-buttons-whe.patch @@ -0,0 +1,47 @@ +From dd38c471458760b1795ac2cc0017bc5b5924b70b Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Wolfgang=20M=C3=BCller?= <wolf@oriole.systems> +Date: Mon, 14 Oct 2024 18:43:28 +0200 +Subject: [PATCH 4/4] kitemlistcontroller: process forward/back buttons when + double-clicking + +Tapping the forward or back mouse buttons quickly enough makes Dolphin +interpret the action as a double-click of the button in question and +handle it in mouseDoubleClickEvent() instead of its normal button +handler. This means that certain button presses might seem delayed or +"swallowed" when quickly navigating forwards or backwards through the +history. + +Since a double-click of the forward or back button is currently +meaningless, fix this by emitting a normal mouseButtonPressed event for +those buttons in the double-click handler and skipping any further event +processing. + +Co-authored-by: Felix Ernst <felixernst@zohomail.eu> +CCBUG: 485295 +--- + src/kitemviews/kitemlistcontroller.cpp | 9 +++++++++ + 1 file changed, 9 insertions(+) + +diff --git a/src/kitemviews/kitemlistcontroller.cpp b/src/kitemviews/kitemlistcontroller.cpp +index 997e6623b..821e1b75f 100644 +--- a/src/kitemviews/kitemlistcontroller.cpp ++++ b/src/kitemviews/kitemlistcontroller.cpp +@@ -700,6 +700,15 @@ bool KItemListController::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event, + const QPointF pos = transform.map(event->pos()); + const std::optional<int> index = m_view->itemAt(pos); + ++ if (event->button() & (Qt::ForwardButton | Qt::BackButton)) { ++ // "Forward" and "Back" are reserved for quickly navigating through the ++ // history. Double-clicking those buttons should be interpreted as two ++ // separate button presses. We arrive here for the second click, which ++ // we now react to just as we would for a singular click ++ Q_EMIT mouseButtonPressed(index.value_or(-1), event->button()); ++ return false; ++ } ++ + if (!index.has_value()) { + Q_EMIT doubleClickViewBackground(event->button()); + return false; +-- +2.47.0 + diff --git a/desktop-plasma/patches/kde-frameworks/kio/0001-KFilePlacesView-have-setUrl-handle-trailing-slashes-.patch b/desktop-plasma/patches/kde-frameworks/kio/0001-KFilePlacesView-have-setUrl-handle-trailing-slashes-.patch deleted file mode 100644 index 09b3415..0000000 --- a/desktop-plasma/patches/kde-frameworks/kio/0001-KFilePlacesView-have-setUrl-handle-trailing-slashes-.patch +++ /dev/null @@ -1,91 +0,0 @@ -From 9140e58ea4ec9034d75fc7a3572cf0789dd4bb32 Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?Wolfgang=20M=C3=BCller?= <wolf@oriole.systems> -Date: Fri, 20 Sep 2024 09:23:18 +0200 -Subject: [PATCH] KFilePlacesView: have setUrl() handle trailing slashes in - place URLs - -Whilst KFilePlacesView::setUrl() correctly strips its argument when -comparing it to place URLs, it fails to strip the place URL itself. This -means that if a place URL contains a trailing slash, it is not correctly -highlighted in the place view. - -Instead of comparing both QUrl objects directly, use QUrl::matches, -which allows us to pass QUrl::StripTrailingSlash to both. - -Add a test case for this behaviour as well. ---- - autotests/kfileplacesviewtest.cpp | 37 +++++++++++++++++++++++++++++ - src/filewidgets/kfileplacesview.cpp | 2 +- - 2 files changed, 38 insertions(+), 1 deletion(-) - -diff --git a/autotests/kfileplacesviewtest.cpp b/autotests/kfileplacesviewtest.cpp -index 673bec37b..e70979eb3 100644 ---- a/autotests/kfileplacesviewtest.cpp -+++ b/autotests/kfileplacesviewtest.cpp -@@ -34,6 +34,8 @@ private Q_SLOTS: - - void testUrlChanged_data(); - void testUrlChanged(); -+ void testSetUrl_data(); -+ void testSetUrl(); - - private: - QTemporaryDir m_tmpHome; -@@ -100,6 +102,41 @@ void KFilePlacesViewTest::testUrlChanged() - QCOMPARE(args.at(0).toUrl().toString(), expectedUrl); - } - -+void KFilePlacesViewTest::testSetUrl_data() -+{ -+ QTest::addColumn<QUrl>("place"); -+ QTest::addColumn<QUrl>("url"); -+ -+ QString testPath = QString("file://%1/testSetUrl").arg(m_tmpHome.path()); -+ QUrl bareUrl = QUrl(testPath); -+ QUrl trailingUrl = QUrl(testPath.append("/")); -+ -+ QTest::newRow("place-bare-url-bare") << bareUrl << bareUrl; -+ QTest::newRow("place-bare-url-trailing") << bareUrl << trailingUrl; -+ QTest::newRow("place-trailing-url-bare") << trailingUrl << bareUrl; -+ QTest::newRow("place-trailing-url-trailing") << trailingUrl << trailingUrl; -+} -+ -+void KFilePlacesViewTest::testSetUrl() -+{ -+ QFETCH(QUrl, place); -+ QFETCH(QUrl, url); -+ -+ KFilePlacesView pv; -+ KFilePlacesModel pm; -+ pv.setModel(&pm); -+ -+ pm.addPlace("testSetUrl", place); -+ QModelIndex added = pm.closestItem(place); -+ -+ QSignalSpy selectionChangedSpy(pv.selectionModel(), &QItemSelectionModel::selectionChanged); -+ pv.setUrl(url); -+ -+ QVERIFY(!selectionChangedSpy.isEmpty()); -+ const QList<QVariant> args = selectionChangedSpy.takeFirst(); -+ QVERIFY(args.at(0).value<QItemSelection>().indexes().contains(added)); -+} -+ - QTEST_MAIN(KFilePlacesViewTest) - - #include "kfileplacesviewtest.moc" -diff --git a/src/filewidgets/kfileplacesview.cpp b/src/filewidgets/kfileplacesview.cpp -index dd4830353..c8eefde78 100644 ---- a/src/filewidgets/kfileplacesview.cpp -+++ b/src/filewidgets/kfileplacesview.cpp -@@ -1037,7 +1037,7 @@ void KFilePlacesView::setUrl(const QUrl &url) - - d->m_currentUrl = url; - -- if (placesModel->url(index) == url.adjusted(QUrl::StripTrailingSlash)) { -+ if (placesModel->url(index).matches(url, QUrl::StripTrailingSlash)) { - selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect); - } else { - selectionModel()->clear(); --- -2.46.0 - diff --git a/desktop-plasma/patches/kde-frameworks/kio/0001-Pass-arguments-to-weltschmerz-correctly.patch b/desktop-plasma/patches/kde-frameworks/kio/0001-Pass-arguments-to-weltschmerz-correctly.patch index b7e19fb..087c21b 100644 --- a/desktop-plasma/patches/kde-frameworks/kio/0001-Pass-arguments-to-weltschmerz-correctly.patch +++ b/desktop-plasma/patches/kde-frameworks/kio/0001-Pass-arguments-to-weltschmerz-correctly.patch @@ -1,4 +1,4 @@ -From 532a7c03a4c5cc26a1f06ce4882b1d2010b6c44d Mon Sep 17 00:00:00 2001 +From 5dee62540628f2bebbe783bae0cf5a564d1c333f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wolfgang=20M=C3=BCller?= <wolf@oriole.systems> Date: Tue, 10 Sep 2024 23:11:02 +0200 Subject: [PATCH] Pass arguments to weltschmerz correctly @@ -34,7 +34,7 @@ index 63c924737..b2851077e 100644 KShell::Errors err; diff --git a/src/gui/kterminallauncherjob.cpp b/src/gui/kterminallauncherjob.cpp -index edd99327b..beb80b090 100644 +index edd99327b..1feca99c3 100644 --- a/src/gui/kterminallauncherjob.cpp +++ b/src/gui/kterminallauncherjob.cpp @@ -136,7 +136,11 @@ void KTerminalLauncherJob::determineFullCommand(bool fallbackToKonsoleService /* @@ -43,7 +43,7 @@ index edd99327b..beb80b090 100644 if (!d->m_command.isEmpty()) { - exec += QLatin1String(" -e ") + d->m_command; + if (exec == QLatin1String("weltschmerz")) { -+ exec += d->m_command; ++ exec += QLatin1String(" ") + d->m_command; + } else { + exec += QLatin1String(" -e ") + d->m_command; + } @@ -51,5 +51,5 @@ index edd99327b..beb80b090 100644 #else const QString windowsTerminal = QStringLiteral("wt.exe"); -- -2.46.0 +2.46.2 diff --git a/desktop-plasma/patches/kde-frameworks/kio:6/0001-TrashSizeCache-Use-correct-iterator-flags.patch b/desktop-plasma/patches/kde-frameworks/kio:6/0001-TrashSizeCache-Use-correct-iterator-flags.patch new file mode 100644 index 0000000..a24e1c0 --- /dev/null +++ b/desktop-plasma/patches/kde-frameworks/kio:6/0001-TrashSizeCache-Use-correct-iterator-flags.patch @@ -0,0 +1,29 @@ +From 241eb504801bc4ee12555fa2c8737b409383ba5c Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Wolfgang=20M=C3=BCller?= <wolf@oriole.systems> +Date: Fri, 4 Oct 2024 16:27:40 +0200 +Subject: [PATCH] TrashSizeCache: Use correct flags for QDirIterator + +When calculating the size of the trash we walk through all files in the +trash path using QDirIterator. In 0ab81b6ba (trashimpl: optimize +TrashSizeCache::calculateSize, 2023-09-05) its invocation was changed to +include the QDir::NoDotAndDotDot filter. +--- + src/kioworkers/trash/trashsizecache.cpp | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/kioworkers/trash/trashsizecache.cpp b/src/kioworkers/trash/trashsizecache.cpp +index 81e71f4b9..e67618554 100644 +--- a/src/kioworkers/trash/trashsizecache.cpp ++++ b/src/kioworkers/trash/trashsizecache.cpp +@@ -146,7 +146,7 @@ TrashSizeCache::SizeAndModTime TrashSizeCache::scanFilesInTrash(ScanFilesInTrash + + // Iterate over the actual trashed files. + // Orphan items (no .fileinfo) still take space. +- QDirIterator it(mTrashPath + QLatin1String("/files/"), QDir::NoDotAndDotDot); ++ QDirIterator it(mTrashPath + QLatin1String("/files/"), QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot); + qint64 sum = 0; + qint64 max_mtime = 0; + const auto checkMaxTime = [&max_mtime](const qint64 lastModTime) { +-- +2.46.2 + diff --git a/desktop-plasma/patches/kde-plasma/plasma-workspace/0001-weather-dwd-fix-icon-for-condition-2.patch b/desktop-plasma/patches/kde-plasma/plasma-workspace/0001-weather-dwd-fix-icon-for-condition-2.patch new file mode 100644 index 0000000..382ac00 --- /dev/null +++ b/desktop-plasma/patches/kde-plasma/plasma-workspace/0001-weather-dwd-fix-icon-for-condition-2.patch @@ -0,0 +1,69 @@ +From 2af745e41bf2639a3a4a81855f500ce147a3a731 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Wolfgang=20M=C3=BCller?= <wolf@oriole.systems> +Date: Tue, 15 Oct 2024 18:38:57 +0200 +Subject: [PATCH 1/3] weather/dwd: fix icon for condition 2 +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Condition 2, "Sonne, leicht bewölkt", indicates a sunny day with few +clouds. Use the more specific FewCloudsDay condition icon instead of +PartlyCloudyDay, which is already correctly used for condition 3. +--- + dataengines/weather/ions/dwd/ion_dwd.cpp | 40 ++++++------------------ + 1 file changed, 10 insertions(+), 30 deletions(-) + +diff --git a/dataengines/weather/ions/dwd/ion_dwd.cpp b/dataengines/weather/ions/dwd/ion_dwd.cpp +index 83e193d70b..5909b5f5e9 100644 +--- a/dataengines/weather/ions/dwd/ion_dwd.cpp ++++ b/dataengines/weather/ions/dwd/ion_dwd.cpp +@@ -86,36 +86,16 @@ QMap<QString, IonInterface::ConditionIcons> DWDIon::setupDayIconMappings() const + { + // DWD supplies it's own icon number which we can use to determine a condition + +- return QMap<QString, ConditionIcons>{{QStringLiteral("1"), ClearDay}, +- {QStringLiteral("2"), PartlyCloudyDay}, +- {QStringLiteral("3"), PartlyCloudyDay}, +- {QStringLiteral("4"), Overcast}, +- {QStringLiteral("5"), Mist}, +- {QStringLiteral("6"), Mist}, +- {QStringLiteral("7"), LightRain}, +- {QStringLiteral("8"), Rain}, +- {QStringLiteral("9"), Rain}, +- {QStringLiteral("10"), LightRain}, +- {QStringLiteral("11"), Rain}, +- {QStringLiteral("12"), Flurries}, +- {QStringLiteral("13"), RainSnow}, +- {QStringLiteral("14"), LightSnow}, +- {QStringLiteral("15"), Snow}, +- {QStringLiteral("16"), Snow}, +- {QStringLiteral("17"), Hail}, +- {QStringLiteral("18"), LightRain}, +- {QStringLiteral("19"), Rain}, +- {QStringLiteral("20"), Flurries}, +- {QStringLiteral("21"), RainSnow}, +- {QStringLiteral("22"), LightSnow}, +- {QStringLiteral("23"), Snow}, +- {QStringLiteral("24"), Hail}, +- {QStringLiteral("25"), Hail}, +- {QStringLiteral("26"), Thunderstorm}, +- {QStringLiteral("27"), Thunderstorm}, +- {QStringLiteral("28"), Thunderstorm}, +- {QStringLiteral("29"), Thunderstorm}, +- {QStringLiteral("30"), Thunderstorm}, ++ return QMap<QString, ConditionIcons>{{QStringLiteral("1"), ClearDay}, {QStringLiteral("2"), FewCloudsDay}, {QStringLiteral("3"), PartlyCloudyDay}, ++ {QStringLiteral("4"), Overcast}, {QStringLiteral("5"), Mist}, {QStringLiteral("6"), Mist}, ++ {QStringLiteral("7"), LightRain}, {QStringLiteral("8"), Rain}, {QStringLiteral("9"), Rain}, ++ {QStringLiteral("10"), LightRain}, {QStringLiteral("11"), Rain}, {QStringLiteral("12"), Flurries}, ++ {QStringLiteral("13"), RainSnow}, {QStringLiteral("14"), LightSnow}, {QStringLiteral("15"), Snow}, ++ {QStringLiteral("16"), Snow}, {QStringLiteral("17"), Hail}, {QStringLiteral("18"), LightRain}, ++ {QStringLiteral("19"), Rain}, {QStringLiteral("20"), Flurries}, {QStringLiteral("21"), RainSnow}, ++ {QStringLiteral("22"), LightSnow}, {QStringLiteral("23"), Snow}, {QStringLiteral("24"), Hail}, ++ {QStringLiteral("25"), Hail}, {QStringLiteral("26"), Thunderstorm}, {QStringLiteral("27"), Thunderstorm}, ++ {QStringLiteral("28"), Thunderstorm}, {QStringLiteral("29"), Thunderstorm}, {QStringLiteral("30"), Thunderstorm}, + {QStringLiteral("31"), ClearWindyDay}}; + } + +-- +2.47.0 + diff --git a/desktop-plasma/patches/kde-plasma/plasma-workspace/0002-weather-dwd-Use-more-robust-parsing-for-timestamps.patch b/desktop-plasma/patches/kde-plasma/plasma-workspace/0002-weather-dwd-Use-more-robust-parsing-for-timestamps.patch new file mode 100644 index 0000000..22b9713 --- /dev/null +++ b/desktop-plasma/patches/kde-plasma/plasma-workspace/0002-weather-dwd-Use-more-robust-parsing-for-timestamps.patch @@ -0,0 +1,66 @@ +From 85f11eeabd8d0a7cef8ef76a129e1b4ec4c82f3e Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Wolfgang=20M=C3=BCller?= <wolf@oriole.systems> +Date: Thu, 17 Oct 2024 13:50:47 +0200 +Subject: [PATCH 2/3] weather/dwd: Use more robust parsing for timestamps + +When parsing the observationDateTime from the DWD API, we directly +convert a QMap lookup by using toLongLong(). For invalid values, or when +the map lookup returns QVariant() for a missing key, this will return 0, +creating a valid date at millisecond offset 0. Later in the code there +is a check for observationDateTime.isNull() which will therefore never +return true. + +For a more robust check, use a helper function parseDateFromMSecs() +which will make sure the conversion to qint64 succeeded before creating +the QDateTime instance. If the conversion fails for any reason, we +instead return a null datetime by simply calling the empty QDateTime() +constructor. These null datetimes will indicate isNull() correctly. +--- + dataengines/weather/ions/dwd/ion_dwd.cpp | 11 +++++++++-- + dataengines/weather/ions/dwd/ion_dwd.h | 1 + + 2 files changed, 10 insertions(+), 2 deletions(-) + +diff --git a/dataengines/weather/ions/dwd/ion_dwd.cpp b/dataengines/weather/ions/dwd/ion_dwd.cpp +index 5909b5f5e9..9ab9ce5a0b 100644 +--- a/dataengines/weather/ions/dwd/ion_dwd.cpp ++++ b/dataengines/weather/ions/dwd/ion_dwd.cpp +@@ -498,8 +498,7 @@ void DWDIon::parseMeasureData(const QString source, QJsonDocument doc) + QVariantMap weatherMap = doc.object().toVariantMap(); + + if (!weatherMap.isEmpty()) { +- QDateTime time = QDateTime::fromMSecsSinceEpoch(weatherMap[QStringLiteral("time")].toLongLong()); +- weatherData.observationDateTime = time; ++ weatherData.observationDateTime = parseDateFromMSecs(weatherMap[QStringLiteral("time")]); + + QString condIconNumber = weatherMap[QStringLiteral("icon")].toString(); + if (condIconNumber != QLatin1String("")) { +@@ -669,6 +668,14 @@ float DWDIon::parseNumber(QVariant number) + return static_cast<float>(intValue) / 10; + } + ++QDateTime DWDIon::parseDateFromMSecs(QVariant timestamp) ++{ ++ bool isValid = false; ++ const qint64 msecs = timestamp.toLongLong(&isValid); ++ ++ return isValid ? QDateTime::fromMSecsSinceEpoch(msecs) : QDateTime(); ++} ++ + QString DWDIon::roundWindDirections(int windDirection) + { + QString roundedWindDirection = QString::number(qRound(((float)windDirection) / 100) * 10); +diff --git a/dataengines/weather/ions/dwd/ion_dwd.h b/dataengines/weather/ions/dwd/ion_dwd.h +index dc86bd43ce..38b9ce3cac 100644 +--- a/dataengines/weather/ions/dwd/ion_dwd.h ++++ b/dataengines/weather/ions/dwd/ion_dwd.h +@@ -135,6 +135,7 @@ private: + QString extractString(QByteArray array, int start, int length); + QString roundWindDirections(int windDirection); + float parseNumber(QVariant number); ++ QDateTime parseDateFromMSecs(QVariant timestamp); + + private: + // Key dicts +-- +2.47.0 + diff --git a/desktop-plasma/patches/kde-plasma/plasma-workspace/0003-weather-dwd-Add-support-for-night-time-icons.patch b/desktop-plasma/patches/kde-plasma/plasma-workspace/0003-weather-dwd-Add-support-for-night-time-icons.patch new file mode 100644 index 0000000..45d1330 --- /dev/null +++ b/desktop-plasma/patches/kde-plasma/plasma-workspace/0003-weather-dwd-Add-support-for-night-time-icons.patch @@ -0,0 +1,182 @@ +From 63a5abc6b1eb409ca5cdb06a96860af2d1d74994 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Wolfgang=20M=C3=BCller?= <wolf@oriole.systems> +Date: Thu, 17 Oct 2024 17:36:41 +0200 +Subject: [PATCH 3/3] weather/dwd: Add support for night-time icons + +The DWD Ion currently shows only day-time icons which feels a bit off +when checking the weather after dusk or at night. Implement the missing +night-time icons and use sunrise and sunset times from DWD's forecast +endpoint to accurately determine when to switch. This will only affect +the display of the current conditions, the forecast icons will continue +to be displayed as day-time only. + +Since we need to have both observation data (for the current observation +time) and forecast data (for sunrise and sunset times), only determine +the icon at a very late stage in updateWeather(). Additionally, make +sure to safely fall back to day-time only icons if we could not fetch +sunrise or sunset times. +--- + dataengines/weather/ions/dwd/ion_dwd.cpp | 70 ++++++++++++++++++------ + dataengines/weather/ions/dwd/ion_dwd.h | 8 ++- + 2 files changed, 59 insertions(+), 19 deletions(-) + +diff --git a/dataengines/weather/ions/dwd/ion_dwd.cpp b/dataengines/weather/ions/dwd/ion_dwd.cpp +index 9ab9ce5a0b..e4a1c1dc74 100644 +--- a/dataengines/weather/ions/dwd/ion_dwd.cpp ++++ b/dataengines/weather/ions/dwd/ion_dwd.cpp +@@ -82,21 +82,38 @@ void DWDIon::deleteForecasts() + } + } + ++QMap<QString, IonInterface::ConditionIcons> DWDIon::getUniversalIcons() const ++{ ++ return QMap<QString, ConditionIcons>{ ++ {QStringLiteral("4"), Overcast}, {QStringLiteral("5"), Mist}, {QStringLiteral("6"), Mist}, {QStringLiteral("7"), LightRain}, ++ {QStringLiteral("8"), Rain}, {QStringLiteral("9"), Rain}, {QStringLiteral("10"), LightRain}, {QStringLiteral("11"), Rain}, ++ {QStringLiteral("12"), Flurries}, {QStringLiteral("13"), RainSnow}, {QStringLiteral("14"), LightSnow}, {QStringLiteral("15"), Snow}, ++ {QStringLiteral("16"), Snow}, {QStringLiteral("17"), Hail}, {QStringLiteral("18"), LightRain}, {QStringLiteral("19"), Rain}, ++ {QStringLiteral("20"), Flurries}, {QStringLiteral("21"), RainSnow}, {QStringLiteral("22"), LightSnow}, {QStringLiteral("23"), Snow}, ++ {QStringLiteral("24"), Hail}, {QStringLiteral("25"), Hail}, {QStringLiteral("26"), Thunderstorm}, {QStringLiteral("27"), Thunderstorm}, ++ {QStringLiteral("28"), Thunderstorm}, {QStringLiteral("29"), Thunderstorm}, {QStringLiteral("30"), Thunderstorm}}; ++} ++ + QMap<QString, IonInterface::ConditionIcons> DWDIon::setupDayIconMappings() const + { +- // DWD supplies it's own icon number which we can use to determine a condition ++ QMap<QString, ConditionIcons> universalIcons = getUniversalIcons(); ++ QMap<QString, ConditionIcons> dayIcons = {{QStringLiteral("1"), ClearDay}, ++ {QStringLiteral("2"), FewCloudsDay}, ++ {QStringLiteral("3"), PartlyCloudyDay}, ++ {QStringLiteral("31"), ClearWindyDay}}; ++ dayIcons.insert(universalIcons); ++ return dayIcons; ++} + +- return QMap<QString, ConditionIcons>{{QStringLiteral("1"), ClearDay}, {QStringLiteral("2"), FewCloudsDay}, {QStringLiteral("3"), PartlyCloudyDay}, +- {QStringLiteral("4"), Overcast}, {QStringLiteral("5"), Mist}, {QStringLiteral("6"), Mist}, +- {QStringLiteral("7"), LightRain}, {QStringLiteral("8"), Rain}, {QStringLiteral("9"), Rain}, +- {QStringLiteral("10"), LightRain}, {QStringLiteral("11"), Rain}, {QStringLiteral("12"), Flurries}, +- {QStringLiteral("13"), RainSnow}, {QStringLiteral("14"), LightSnow}, {QStringLiteral("15"), Snow}, +- {QStringLiteral("16"), Snow}, {QStringLiteral("17"), Hail}, {QStringLiteral("18"), LightRain}, +- {QStringLiteral("19"), Rain}, {QStringLiteral("20"), Flurries}, {QStringLiteral("21"), RainSnow}, +- {QStringLiteral("22"), LightSnow}, {QStringLiteral("23"), Snow}, {QStringLiteral("24"), Hail}, +- {QStringLiteral("25"), Hail}, {QStringLiteral("26"), Thunderstorm}, {QStringLiteral("27"), Thunderstorm}, +- {QStringLiteral("28"), Thunderstorm}, {QStringLiteral("29"), Thunderstorm}, {QStringLiteral("30"), Thunderstorm}, +- {QStringLiteral("31"), ClearWindyDay}}; ++QMap<QString, IonInterface::ConditionIcons> DWDIon::setupNightIconMappings() const ++{ ++ QMap<QString, ConditionIcons> universalIcons = getUniversalIcons(); ++ QMap<QString, ConditionIcons> nightIcons = {{QStringLiteral("1"), ClearNight}, ++ {QStringLiteral("2"), FewCloudsNight}, ++ {QStringLiteral("3"), PartlyCloudyNight}, ++ {QStringLiteral("31"), ClearWindyNight}}; ++ nightIcons.insert(universalIcons); ++ return nightIcons; + } + + QMap<QString, IonInterface::WindDirections> DWDIon::setupWindIconMappings() const +@@ -119,6 +136,12 @@ QMap<QString, IonInterface::ConditionIcons> const &DWDIon::dayIcons() const + return dval; + } + ++QMap<QString, IonInterface::ConditionIcons> const &DWDIon::nightIcons() const ++{ ++ static QMap<QString, ConditionIcons> const dval = setupNightIconMappings(); ++ return dval; ++} ++ + QMap<QString, IonInterface::WindDirections> const &DWDIon::windIcons() const + { + static QMap<QString, WindDirections> const wval = setupWindIconMappings(); +@@ -448,6 +471,10 @@ void DWDIon::parseForecastData(const QString source, QJsonDocument doc) + weatherData.gustSpeedAlt = parseNumber(dayMap[QStringLiteral("windGust")]); + QString windDirection = roundWindDirections(dayMap[QStringLiteral("windDirection")].toInt()); + weatherData.windDirectionAlt = getWindDirectionIcon(windIcons(), windDirection); ++ ++ // Also fetch today's sunrise and sunset times to determine whether to pick day or night icons ++ weatherData.sunriseTime = parseDateFromMSecs(dayMap[QStringLiteral("sunrise")].toLongLong()); ++ weatherData.sunsetTime = parseDateFromMSecs(dayMap[QStringLiteral("sunset")].toLongLong()); + } + + forecasts.append(forecast); +@@ -500,10 +527,7 @@ void DWDIon::parseMeasureData(const QString source, QJsonDocument doc) + if (!weatherMap.isEmpty()) { + weatherData.observationDateTime = parseDateFromMSecs(weatherMap[QStringLiteral("time")]); + +- QString condIconNumber = weatherMap[QStringLiteral("icon")].toString(); +- if (condIconNumber != QLatin1String("")) { +- weatherData.conditionIcon = getWeatherIcon(dayIcons(), condIconNumber); +- } ++ weatherData.condIconNumber = weatherMap[QStringLiteral("icon")].toString(); + + bool windIconValid = false; + const int windDirection = weatherMap[QStringLiteral("winddirection")].toInt(&windIconValid); +@@ -573,8 +597,8 @@ void DWDIon::updateWeather(const QString &source) + else + data.insert(QStringLiteral("Observation Timestamp"), QDateTime::currentDateTime()); + +- if (!weatherData.conditionIcon.isEmpty()) +- data.insert(QStringLiteral("Condition Icon"), weatherData.conditionIcon); ++ if (!weatherData.condIconNumber.isEmpty()) ++ data.insert(QStringLiteral("Condition Icon"), getWeatherIcon(isNightTime(weatherData) ? nightIcons() : dayIcons(), weatherData.condIconNumber)); + + if (!qIsNaN(weatherData.temperature)) + data.insert(QStringLiteral("Temperature"), weatherData.temperature); +@@ -717,6 +741,16 @@ QString DWDIon::camelCaseString(const QString text) + return result; + } + ++bool DWDIon::isNightTime(const WeatherData &weatherData) ++{ ++ if (weatherData.sunriseTime.isNull() || weatherData.sunsetTime.isNull()) { ++ // default to daytime icons if we're missing sunrise/sunset times ++ return false; ++ } ++ ++ return weatherData.observationDateTime < weatherData.sunriseTime || weatherData.observationDateTime > weatherData.sunsetTime; ++} ++ + K_PLUGIN_CLASS_WITH_JSON(DWDIon, "ion-dwd.json") + + #include "ion_dwd.moc" +diff --git a/dataengines/weather/ions/dwd/ion_dwd.h b/dataengines/weather/ions/dwd/ion_dwd.h +index 38b9ce3cac..c1ed8651b6 100644 +--- a/dataengines/weather/ions/dwd/ion_dwd.h ++++ b/dataengines/weather/ions/dwd/ion_dwd.h +@@ -40,8 +40,10 @@ public: + + // Current observation information. + QDateTime observationDateTime; ++ QDateTime sunriseTime; ++ QDateTime sunsetTime; + +- QString conditionIcon; ++ QString condIconNumber; + QString windDirection; + float temperature; + float humidity; +@@ -110,10 +112,13 @@ private Q_SLOTS: + void forecast_slotJobFinished(KJob *); + + private: ++ QMap<QString, ConditionIcons> getUniversalIcons() const; + QMap<QString, ConditionIcons> setupDayIconMappings() const; ++ QMap<QString, ConditionIcons> setupNightIconMappings() const; + QMap<QString, WindDirections> setupWindIconMappings() const; + + QMap<QString, ConditionIcons> const &dayIcons() const; ++ QMap<QString, ConditionIcons> const &nightIcons() const; + QMap<QString, WindDirections> const &windIcons() const; + + void findPlace(const QString &searchText); +@@ -134,6 +139,7 @@ private: + QString camelCaseString(const QString text); + QString extractString(QByteArray array, int start, int length); + QString roundWindDirections(int windDirection); ++ bool isNightTime(const WeatherData &weatherData); + float parseNumber(QVariant number); + QDateTime parseDateFromMSecs(QVariant timestamp); + +-- +2.47.0 + |