chore: 1.5.0

KDE's own middle-click paste is turned off along with everything else. Inside a
Chromium application the flag already settles it - with autoscroll on, Blink
stops pasting the primary selection - but everywhere else on the desktop middle
click goes on pasting, which is the thing this program exists to get away from.

KWin has a switch for it on a Wayland session, where the paste is a protocol
the compositor either offers or does not, and that is what gets written. It is
true from the next login on. What the key said before is recorded, so disable
puts it back, and a key that already said no is left alone and never switched
back on. X11 has no such switch and nothing is written there.

Off under Settings for anyone who wants the paste kept.

Makefile

@@ -8,7 +8,7 @@
 # Overridable so a packager can pass the version it is actually building
 # (`make VERSION=$pkgver`). The literal below is the fallback for builds
 # straight from a checkout, and is what a release tag has to carry.
-VERSION      ?= 1.3.0
+VERSION      ?= 1.5.0
 
 PREFIX       ?= /usr
 DESTDIR      ?=
@@ -23,13 +23,17 @@ MANDIR       ?= $(DATADIR)/man
 # distribution that still keeps /lib separate from /usr/lib says so here - and
 # only guessed at when there is no systemd installed to ask.
 #
-# A build with a prefix of its own keeps the units under that prefix instead.
-# systemd searches $(PREFIX)/lib/systemd/user as well, and a file outside the
-# prefix it was asked for is not this build's to place.
+# A build with a prefix of its own keeps the units under that prefix instead,
+# and under share rather than lib. systemd searches both for a system prefix,
+# but only share for a home one: $XDG_DATA_HOME/systemd/user is a search path
+# and ~/.local/lib/systemd/user is not, so an install into ~/.local that put
+# the units in lib would leave the watcher impossible to enable. That prefix is
+# the one an atomic distribution leaves a user - there is no writing to /usr on
+# Bazzite or Silverblue without layering a package and rebooting.
 ifeq ($(PREFIX),/usr)
 USERUNITDIR  ?= $(shell pkg-config --variable=systemduserunitdir systemd 2>/dev/null || echo /usr/lib/systemd/user)
 else
-USERUNITDIR  ?= $(PREFIX)/lib/systemd/user
+USERUNITDIR  ?= $(DATADIR)/systemd/user
 endif
 
 LINGUAS      := de

README.md

@@ -1,45 +1,9 @@
 # middleclick-autoscroll
 
-Middle-click autoscroll is a CLI for Linux that enables autoscroll in every application that supports it.
-Works with browsers, Electron apps like Discord and Spotify, Steam, and anything else that runs on Chromium under the hood.
+middleclick-autoscroll (what a great name, wow) is a CLI for linux that enables autoscroll in every application that supports it.
+Works with browsers, electron apps like discord and spotify, steam, and anything else that runs on chromium.
 
-There is no app list. My tool just looks at what uses chromium under the hood and applies the necessary steps to get it working.
-
-## How to install
-
-**Arch**
-
-```bash
-yay -S middleclick-autoscroll
-```
-
-**Fedora**
-
-```bash
-sudo curl -fsSL -o /etc/yum.repos.d/middleclick-autoscroll.repo \
-  https://felitendo.github.io/middleclick-autoscroll/middleclick-autoscroll.repo
-sudo dnf install middleclick-autoscroll
-```
-
-**Debian**
-
-```bash
-sudo install -d -m 0755 /etc/apt/keyrings
-curl -fsSL https://felitendo.github.io/middleclick-autoscroll/KEY.gpg \
-  | sudo gpg --dearmor -o /etc/apt/keyrings/middleclick-autoscroll.gpg
-echo "deb [signed-by=/etc/apt/keyrings/middleclick-autoscroll.gpg] https://felitendo.github.io/middleclick-autoscroll/deb ./" \
-  | sudo tee /etc/apt/sources.list.d/middleclick-autoscroll.list
-sudo apt update && sudo apt install middleclick-autoscroll
-```
-
-**openSUSE**
-
-```bash
-sudo rpm --import https://felitendo.github.io/middleclick-autoscroll/KEY.gpg
-sudo zypper addrepo --gpgcheck --refresh \
-  https://felitendo.github.io/middleclick-autoscroll/rpm middleclick-autoscroll
-sudo zypper install middleclick-autoscroll
-```
+This tool looks at which of your apps run chromium under the hood and applies the necessary steps to get autoscrolling working (often just a feature flag). One install, one command and autoscroll _✨just works✨_ (like on windows).
 
 ## How to use
 
@@ -54,6 +18,7 @@ Just run `middleclick-autoscroll`. This will open the configuration TUI that loo
   Not identified                 1 - see the applications list
   Steam                          ON
   New applications               ON
+  Middle-click paste             off
   Last applied                   2 minutes ago
 
   Applications pick this up the next time they are started.
@@ -67,9 +32,8 @@ Just run `middleclick-autoscroll`. This will open the configuration TUI that loo
   >
 ```
 
-`[1]` is all you need for the normal case. `[3]` lists every app that was found
-and what is being done with it, so you can leave a single one out or switch on
-an AppImage that couldn't be identified:
+Normally you just need to press `[1]` and the magic is done.
+Pressing `[3]` lets you see every app that was found and toggle each one individually. 
 
 ```
   Applications
@@ -82,54 +46,77 @@ an AppImage that couldn't be identified:
     Slack                              off
     Cursor                             cannot tell
 
-  Anything not identified is left alone until it is turned on here.
   Up/Down select - Space turns one on or off - q goes back
 ```
 
-`[4]` has the same switches per category - browsers, Electron and CEF apps,
-Flatpaks, snaps, autostart entries, Steam, Spotify - plus a field for extra
-Chromium arguments.
+You can also press `[4]` for more settings.
+
+## How to install
+
+**Arch (for the cachyos enjoyers)**
+
+```bash
+yay -S middleclick-autoscroll
+```
+
+**Fedora (for the mentally stable)**
+
+```bash
+sudo curl -fsSL -o /etc/yum.repos.d/middleclick-autoscroll.repo \
+  https://felitendo.github.io/middleclick-autoscroll/middleclick-autoscroll.repo
+sudo dnf install middleclick-autoscroll
+```
+
+**Bazzite (for the reboot enjoyers)**
+
+```bash
+sudo curl -fsSL -o /etc/yum.repos.d/middleclick-autoscroll.repo \
+  https://felitendo.github.io/middleclick-autoscroll/middleclick-autoscroll.repo
+sudo rpm-ostree install middleclick-autoscroll
+systemctl reboot
+```
+
+**Debian (for the elderly)**
+
+```bash
+sudo install -d -m 0755 /etc/apt/keyrings
+curl -fsSL https://felitendo.github.io/middleclick-autoscroll/KEY.gpg \
+  | sudo gpg --dearmor -o /etc/apt/keyrings/middleclick-autoscroll.gpg
+echo "deb [signed-by=/etc/apt/keyrings/middleclick-autoscroll.gpg] https://felitendo.github.io/middleclick-autoscroll/deb ./" \
+  | sudo tee /etc/apt/sources.list.d/middleclick-autoscroll.list
+sudo apt update && sudo apt install middleclick-autoscroll
+```
+
+**openSUSE (for the both of you)**
+
+```bash
+sudo rpm --import https://felitendo.github.io/middleclick-autoscroll/KEY.gpg
+sudo zypper addrepo --gpgcheck --refresh \
+  https://felitendo.github.io/middleclick-autoscroll/rpm middleclick-autoscroll
+sudo zypper install middleclick-autoscroll
+```
 
 ## How it works
 
 Blink (the engine in Chromium, Electron, and CEF) already has autoscroll, but
-it's off on Linux because middle click does primary-selection paste there. This
-flag turns it on:
+it's off on Linux by default because middle click normally pastes the clipboard (??).
+This flag turns it on:
 
 --enable-blink-features=MiddleClickAutoscroll
 
 But doing that for every app is kinda bothersome and it also might break with updates.
 That's why I created this small tool to automate that.
 
-Browsers get the same thing asked for differently:
+Browsers get the same thing but this time without "blink":
 
 --enable-features=MiddleClickAutoscroll
 
-Both mean the same feature - Blink generates a matching feature name for each of
-its runtime flags - but the first one is on Chromium's list of flags worth
-warning about, so a browser started with it shows a yellow "unsupported
-command-line flag" bar over every page. The second one is not on that list, so
-there's no bar. It only works from Chromium 124 on, which is why apps that
-embed something older (Steam's CEF, older Electron) keep the first one - they
-have no such bar to begin with. Helium, which carries the feature under its own
-name, is asked for `HeliumMiddleClickAutoscroll` alongside it.
+But both do the same ¯\_(ツ)_/¯
 
 New apps are picked up by a systemd path unit that watches the
-relevant directories. Without systemd, `middleclick-autoscroll apply` does the
+relevant directories. If you hate systemd; `middleclick-autoscroll apply` does the
 same thing manually.
 
-## Steam
-
-Steam's web UI supports autoscroll but has no way to pass extra arguments to its
-helper, so the program patches the script that starts it. Steam checks its own
-files at every start and repairs whatever looks changed, so the patch is written
-to look unchanged.
-
-As a fallback, for the case where that isn't possible, `-noverifyfiles` goes on
-everything that starts Steam: its launcher, its autostart entry, and the
-shortcuts it writes for single games. That one means Steam won't auto-repair
-damaged files on its own just so you're aware of that.
-
 ## Commands
 
 | Command | |

doc/middleclick-autoscroll.1.scd

@@ -142,23 +142,22 @@ that checks its files finds nothing to repair, and the argument survives
 however Steam was started - from the menu, from a game shortcut, from a
 launcher like Heroic or Lutris, from a terminal.
 
-That is what has to work, because there is no way to make every possible way of
-starting Steam carry an argument. *-noverifyfiles* is the second line rather
-than the first: it covers the case where the script has no comments left to pay
-for the argument and the patch has to grow the file. It goes on Steam's
-launcher entry, on its entry in _~/.config/autostart_, which Steam writes as
-soon as it is set to run at login, and on the shortcuts Steam writes for single
-games, on the desktop and in the menu alike. A game is not an application this
-program has anything to offer and none of them is listed under *Applications*,
-but starting one is a Steam start like any other. The trade-off of the switch
-is that Steam no longer repairs a damaged installation on its own; that is why
-Steam is a switch of its own in the settings.
+That is what has to work, because it is the only thing that does. A patch that
+changes the length is never written, whatever else could be done to cover for
+it: Steam checks its files at the shutdown it runs itself as well as at a start
+it was given arguments for, and that one carries no arguments of anybody's. One
+wrong length costs the whole client package downloaded, extracted and installed
+again, and a client that quits at the end of it instead of coming up.
 
-A patch that does change the size is still held back while the client is
-running: Steam puts its own copy back, the two would only undo each other, and
-the helper is started once, at the start, so patching again would not help that
-session anyway. It goes in at the next apply with Steam closed. A patch that
-keeps the size has nothing to wait for and goes in either way.
+So where the comments cannot pay for the argument, or a client update has
+changed how the helper is started, nothing is written and the status screen
+says Steam is not patched. Nothing goes on Steam's launcher entry, its
+autostart entry or the shortcuts it writes for single games either, and Steam
+goes on repairing its own installation.
+
+An installation patched by an earlier version, which appended where the
+comments were short, is written again to fit at the next apply, or taken back
+if it cannot be made to.
 
 A client update brings a new version of the script. The watcher notices and
 patches it again, and the copy kept for undoing is replaced with the new
@@ -173,6 +172,35 @@ and has a configuration file with a slot for extra arguments; that slot is
 where the flag goes. Installed as a plain package, a Flatpak or a snap, it is
 an ordinary desktop entry and needs nothing special.
 
+# MIDDLE-CLICK PASTE
+
+Inside a Chromium application the argument settles this on its own: with
+autoscroll on, Blink stops pasting the primary selection on middle click,
+because the button is doing something else now. Everywhere else on the desktop
+middle click goes on pasting, so the desktop's own switch for it is turned off
+too.
+
+KDE has such a switch, and only for a Wayland session, where the paste is a
+protocol the compositor either offers or does not:
+
+	~/.config/kwinrc, [Wayland], EnablePrimarySelection=false
+
+It is written with *kwriteconfig6*, the same tool System Settings uses, because
+kwinrc has a cascade behind it and entries a distribution can mark immutable;
+an edit that reaches past all that writes something KDE goes on to ignore. KWin
+reads the key once, while it starts, so the change is true from the next login
+on rather than straight away.
+
+What the key said before is recorded, and *disable* puts that back. A key that
+already said *false* before any of this is left alone and not recorded either,
+so a paste the user switched off themselves is never switched back on.
+
+On X11 there is nothing to switch. The primary selection is part of X itself
+and every toolkit reaches for it on its own; no one place can say no. The
+status screen leaves the row out where there is nothing to report.
+
+Turn it off under *Settings* to keep the desktop's middle-click paste.
+
 # WHAT CANNOT BE DETECTED
 
 An AppImage keeps its payload in a compressed filesystem, so there is no way to
@@ -191,6 +219,11 @@ _~/.local/state/middleclick-autoscroll/ledger_
 _~/.local/state/middleclick-autoscroll/backup/_
 	Copies of the files that are edited in place rather than shadowed.
 
+_~/.config/kwinrc_
+	KDE's own configuration. One key in it, *EnablePrimarySelection*, is
+	written when the desktop's middle-click paste is turned off, and put
+	back by *disable*.
+
 _~/.cache/middleclick-autoscroll/detect_
 	Which programs were found to be Chromium, keyed by size and modification
 	time. Safe to delete.
@@ -208,7 +241,7 @@ up at the next *apply* rather than on their own.
 
 # SEE ALSO
 
-*systemctl*(1), *flatpak*(1), *snap*(8)
+*systemctl*(1), *flatpak*(1), *snap*(8), *kwriteconfig6*(1)
 
 # AUTHORS
 

po/de.po

@@ -43,9 +43,6 @@ msgstr "nicht erkennbar"
 msgid "not patched yet"
 msgstr "noch nicht gepatcht"
 
-msgid "waiting until Steam is closed"
-msgstr "wartet, bis Steam geschlossen ist"
-
 
 #. Status block
 msgid "Autoscroll"
@@ -66,6 +63,9 @@ msgstr "%d – siehe Anwendungsliste"
 msgid "Steam"
 msgstr "Steam"
 
+msgid "Middle-click paste"
+msgstr "Mittelklick-Einfügen"
+
 msgid "New applications"
 msgstr "Neue Anwendungen"
 
@@ -115,6 +115,9 @@ msgstr "Programme, die sich beim Anmelden selbst starten"
 msgid "Spotify"
 msgstr "Spotify"
 
+msgid "Turn off KDE's middle-click paste"
+msgstr "KDEs Mittelklick-Einfügen abschalten"
+
 msgid "Apply to newly installed applications"
 msgstr "Auf neu installierte Anwendungen anwenden"
 
@@ -155,9 +158,6 @@ msgstr "Autoscroll ist für %d Anwendungen an."
 msgid "Applications that are already running pick this up when they are restarted."
 msgstr "Bereits laufende Anwendungen übernehmen das nach einem Neustart."
 
-msgid "Steam's launcher now skips its file check, which is what keeps the change from being undone at every start."
-msgstr "Steams Startereintrag überspringt jetzt die Dateiprüfung – nur so bleibt die Änderung bei jedem Start erhalten."
-
 msgid "Could not start the watcher for newly installed applications."
 msgstr "Die Überwachung neu installierter Anwendungen konnte nicht gestartet werden."
 
@@ -179,11 +179,14 @@ msgstr "Auf %d Anwendungen angewendet."
 msgid "Already applied to %d applications."
 msgstr "Bereits auf %d Anwendungen angewendet."
 
-msgid "Steam starts its interface in a way this version does not recognise; leaving it alone."
-msgstr "Steam startet seine Oberfläche auf eine Art, die diese Version nicht kennt; Steam bleibt unangetastet."
+msgid "Steam starts its interface in a way this version cannot change without Steam noticing; leaving it alone."
+msgstr "Steam startet seine Oberfläche auf eine Art, die diese Version nicht ändern kann, ohne dass Steam es merkt; Steam bleibt unangetastet."
 
-msgid "Steam is running and has put its own file back; the change waits until Steam is closed."
-msgstr "Steam läuft und hat seine eigene Datei wiederhergestellt; die Änderung wird nachgeholt, sobald Steam geschlossen ist."
+msgid "Steam's interface cannot be given the flag without leaving a file Steam would reinstall; the change has been taken back."
+msgstr "Steams Oberfläche lässt sich das Flag nicht geben, ohne eine Datei zu hinterlassen, die Steam neu installieren würde; die Änderung wurde zurückgenommen."
+
+msgid "Middle click stops pasting at the next login."
+msgstr "Mittelklick fügt ab der nächsten Anmeldung nichts mehr ein."
 
 
 #. Help

po/middleclick-autoscroll.pot

@@ -43,9 +43,6 @@ msgstr ""
 msgid "not patched yet"
 msgstr ""
 
-msgid "waiting until Steam is closed"
-msgstr ""
-
 
 #. Status block
 msgid "Autoscroll"
@@ -66,6 +63,9 @@ msgstr ""
 msgid "Steam"
 msgstr ""
 
+msgid "Middle-click paste"
+msgstr ""
+
 msgid "New applications"
 msgstr ""
 
@@ -115,6 +115,9 @@ msgstr ""
 msgid "Spotify"
 msgstr ""
 
+msgid "Turn off KDE's middle-click paste"
+msgstr ""
+
 msgid "Apply to newly installed applications"
 msgstr ""
 
@@ -155,9 +158,6 @@ msgstr ""
 msgid "Applications that are already running pick this up when they are restarted."
 msgstr ""
 
-msgid "Steam's launcher now skips its file check, which is what keeps the change from being undone at every start."
-msgstr ""
-
 msgid "Could not start the watcher for newly installed applications."
 msgstr ""
 
@@ -179,10 +179,13 @@ msgstr ""
 msgid "Already applied to %d applications."
 msgstr ""
 
-msgid "Steam starts its interface in a way this version does not recognise; leaving it alone."
+msgid "Steam starts its interface in a way this version cannot change without Steam noticing; leaving it alone."
 msgstr ""
 
-msgid "Steam is running and has put its own file back; the change waits until Steam is closed."
+msgid "Steam's interface cannot be given the flag without leaving a file Steam would reinstall; the change has been taken back."
+msgstr ""
+
+msgid "Middle click stops pasting at the next login."
 msgstr ""
 
 

src/lib/apply.sh

@@ -103,7 +103,9 @@ mca_apply() {
 				mca_desktop_apply "$id" "$file" "$(mca_flags "$kind")"
 				;;
 			steam)
-				mca_steam_desktop_apply "$id" "$file" "$packaging"
+				# Nothing is done to the entry itself: what Steam needs is
+				# in its own installation, and the same patch serves every
+				# way of starting the client.
 				if (( ! steam_done )); then
 					mca_steam_apply
 					steam_done=1
@@ -118,34 +120,25 @@ mca_apply() {
 		mca_steam_apply
 	fi
 
-	# The shortcuts Steam writes for single games. They are not applications
-	# and are not offered as ones, but starting a game with Steam closed is a
-	# Steam start like any other: without the switch the client finds the
-	# patched helper script, puts its own back, and the interface loses
-	# autoscroll for the rest of the session.
-	if [[ $CFG_STEAM == yes ]]; then
-		for i in "${!MCA_STEAM_LINKS[@]}"; do
-			mca_steam_desktop_apply "${MCA_STEAM_LINKS[i]}" \
-				"${MCA_STEAM_LINK_FILES[i]}" "${MCA_STEAM_LINK_PACK[i]}"
-		done
-	fi
-
-	# Steam's autostart entry carries Steam's own switch and follows the Steam
-	# setting, not this one - leaving it out while Steam is patched is what puts
-	# the client in an update loop - so both are checked inside.
-	if [[ $CFG_AUTOSTART == yes || $CFG_STEAM == yes ]]; then
+	# Autostart entries. A Chromium application that starts itself at login
+	# points straight at its binary and never reads the entry in the menu, so
+	# Discord at login used to behave differently from Discord from the menu.
+	if [[ $CFG_AUTOSTART == yes ]]; then
 		mca_autostart_apply
 	fi
 
-	# Shortcuts on the desktop itself. Nothing above has seen them - the XDG
-	# search path does not go there - and a game started from one starts Steam
-	# without its switch, which is the difference between autoscroll working
-	# and autoscroll working most of the time. Each entry is gated on its own,
-	# so there is nothing to check out here.
+	# Shortcuts on the desktop itself, which nothing above has seen: the XDG
+	# search path does not go there. Each entry is gated on its own, so there is
+	# nothing to check out here.
 	mca_shortcuts_apply
 
 	[[ $CFG_SPOTIFY == yes ]] && mca_spotify_apply
 
+	# Not about any one application: middle click goes on pasting everywhere
+	# else on the desktop, and KDE is the one desktop that can be told not to.
+	# See kde.sh.
+	[[ $CFG_PASTE == yes ]] && mca_kde_paste_apply
+
 	mca_prune_orphans
 
 	if (( MCA_CHANGES )) && mca_have update-desktop-database; then

src/lib/common.sh

@@ -45,10 +45,14 @@ MCA_BROWSER_FLAG="--enable-features=MiddleClickAutoscroll,HeliumMiddleClickAutos
 MCA_FEATURE="MiddleClickAutoscroll"
 MCA_BROWSER_FEATURES="MiddleClickAutoscroll,HeliumMiddleClickAutoscroll"
 
-# Bumped when the flags above change. An installation that was set up by a
-# version with a different answer is taken back and done again once, because a
-# file that is already patched is otherwise left alone. See mca_apply.
-MCA_FLAG_SCHEME=2
+# Bumped when the flags above change, and when what gets written where does.
+# An installation that was set up by a version with a different answer is taken
+# back and done again once, because a file that is already patched is otherwise
+# left alone. See mca_apply.
+#
+# 3 is what takes -noverifyfiles back out of the Steam entries an older version
+# put it in.
+MCA_FLAG_SCHEME=3
 
 MCA_LIBDIR="${MCA_LIBDIR:-@LIBDIR@}"
 MCA_LOCALEDIR="${MCA_LOCALEDIR:-@LOCALEDIR@}"
@@ -274,9 +278,12 @@ mca_state_write() {
 #   shadow  <generated desktop entry>   <source entry it was generated from>
 #   inplace <edited file>               <basename of its backup copy>
 #   flags   <flag file>                 created | appended | merged
+#   kwin    <kwinrc>                    what EnablePrimarySelection said before
 #
-# `inplace` and `flags` differ in how they are undone: a backup is restored
-# wholesale, a flag file only loses the one line that was added to it.
+# The kinds differ in how they are undone: a backup is restored wholesale, a
+# flag file only loses the one line that was added to it, and kwinrc gets one
+# key written back - it is a file KDE writes to itself, and putting a whole
+# copy of it back would take everything else settled since with it.
 
 mca_ledger_add() {
 	local kind="$1" path="$2" detail="${3:-}"
@@ -289,6 +296,25 @@ mca_ledger_add() {
 	printf '%s\t%s\t%s\n' "$kind" "$path" "$detail" >> "$MCA_LEDGER"
 }
 
+# mca_ledger_has <path>
+# Whether the ledger still knows about that file. Worth asking because the copy
+# kept beside it is named after the path and outlives a ledger that was lost or
+# truncated: a file nothing has a record of any more is one nothing would ever
+# look at again.
+mca_ledger_has() {
+	[[ -f $MCA_LEDGER ]] || return 1
+	awk -F'\t' -v p="$1" '$2 == p { found = 1 } END { exit !found }' "$MCA_LEDGER"
+}
+
+# mca_ledger_detail <path>
+# The third column of that file's line, empty when the ledger has none. What it
+# means is the kind's business; for `kwin` it is the value to put back.
+mca_ledger_detail() {
+	[[ -f $MCA_LEDGER ]] || return 1
+	awk -F'\t' -v p="$1" '$2 == p { d = $3 } END { if (!length(d)) exit 1; print d }' \
+		"$MCA_LEDGER"
+}
+
 mca_ledger_forget() {
 	local path="$1" tmp
 	[[ -f $MCA_LEDGER ]] || return 0

src/lib/config.sh

@@ -144,6 +144,7 @@ mca_config_load() {
 	CFG_STEAM=no;      mca_config_bool PatchSteam       yes && CFG_STEAM=yes
 	CFG_SPOTIFY=no;    mca_config_bool PatchSpotify     yes && CFG_SPOTIFY=yes
 	CFG_WATCH=no;      mca_config_bool WatchNewApps     yes && CFG_WATCH=yes
+	CFG_PASTE=no;      mca_config_bool DisablePaste     yes && CFG_PASTE=yes
 
 	CFG_EXTRA_FLAGS="$(mca_config_get ExtraFlags '')"
 

src/lib/detect.sh

@@ -223,6 +223,46 @@ mca_exec_is_steam_link() {
 	mca_prog_is_steam "$prog"
 }
 
+# _mca_prog_is_steam_name <program>
+# The launcher under one of the names Valve and the distributions give it.
+_mca_prog_is_steam_name() {
+	case "${1##*/}" in
+		steam|steam-runtime|steam-native|steam-jupiter) return 0 ;;
+	esac
+	return 1
+}
+
+# _mca_prog_is_steam_wrapper <program>
+# Whether a script in front of the client is a way of starting Steam. People
+# put one there to add a switch of their own, and an entry pointing at it is a
+# Steam start like any other - but the script is not named after Steam, so
+# nothing above recognises it.
+#
+# Getting this wrong is worse than it sounds: such a script tends to mention
+# the flag it is there to add, which is one of the markers that say "Chromium"
+# to the hint scan. The entry then ends up being handled as an application and
+# is given the flag on its command line, where Steam ignores it, instead of
+# being handed to the Steam module that knows how to reach the web helper.
+#
+# Only the handover is followed, and only one step of it: the client's own
+# launcher is already recognised by name, so a wrapper in front of it is the
+# whole of what is left.
+_mca_prog_is_steam_wrapper() {
+	local prog="$1" head='' target
+
+	[[ $prog == /* && -f $prog && -r $prog ]] || return 1
+
+	# Two characters, read in the shell: the scan asks this about every program
+	# on the system, and most of them are binaries whose first line is the whole
+	# file.
+	read -r -N 2 head < "$prog" 2>/dev/null || return 1
+	[[ $head == '#!' ]] || return 1
+
+	target="$(_mca_script_target "$prog")" || return 1
+	[[ -n $target ]] || return 1
+	_mca_prog_is_steam_name "$target"
+}
+
 # mca_prog_is_steam <program>
 # Whether running this program starts the Steam client. Every packaging is in
 # here and every name Valve and the distributions give the launcher, because
@@ -234,10 +274,9 @@ mca_exec_is_steam_link() {
 mca_prog_is_steam() {
 	local prog="$1"
 
-	case "${prog##*/}" in
-		steam|steam-runtime|steam-native|steam-jupiter) return 0 ;;
-	esac
-	[[ $prog == flatpak:com.valvesoftware.Steam || $prog == snap:steam ]]
+	_mca_prog_is_steam_name "$prog" && return 0
+	[[ $prog == flatpak:com.valvesoftware.Steam || $prog == snap:steam ]] && return 0
+	_mca_prog_is_steam_wrapper "$prog"
 }
 
 # ---------------------------------------------------------------------------
@@ -576,16 +615,6 @@ MCA_PROGS=()      # resolved program, or a Flatpak app id or a snap name
 MCA_KINDS=()      # app | browser | steam | unknown | no
 MCA_PACKAGING=()  # native | flatpak | snap
 
-# The shortcuts Steam writes for single games. Not applications of their own - a
-# game is whatever engine it was built with, and none of those reads a Chromium
-# argument - so they are kept apart from the list rather than listed as
-# something that got switched on. They do start Steam, which is why they are
-# kept at all: the Steam module gives them Steam's own switch.
-MCA_STEAM_LINKS=()       # desktop file id
-MCA_STEAM_LINK_FILES=()  # the entry that is in effect for it
-MCA_STEAM_LINK_PACK=()   # native | flatpak | snap, which decides where the
-                         # switch goes on the command line
-
 # A scan reads every desktop entry on the system, so the menu does it once and
 # then redraws from what it found. Applying rescans on its own, so nothing else
 # has to remember to invalidate this.
@@ -603,7 +632,6 @@ mca_scan() {
 
 	MCA_IDS=(); MCA_FILES=(); MCA_NAMES=(); MCA_PROGS=(); MCA_KINDS=()
 	MCA_PACKAGING=()
-	MCA_STEAM_LINKS=(); MCA_STEAM_LINK_FILES=(); MCA_STEAM_LINK_PACK=()
 
 	# Pass one: read the entries and work out what each of them starts. No
 	# detection yet - that needs a stat per program, and those are collected so
@@ -643,18 +671,12 @@ mca_scan() {
 				prog="snap:$MCA_PROG"
 			fi
 
-			if mca_exec_is_steam_link "$exec_line" "$prog"; then
-				MCA_STEAM_LINKS+=("$id")
-				MCA_STEAM_LINK_FILES+=("$file")
-				if [[ $prog == flatpak:* ]]; then
-					MCA_STEAM_LINK_PACK+=(flatpak)
-				elif [[ $prog == snap:* ]]; then
-					MCA_STEAM_LINK_PACK+=(snap)
-				else
-					MCA_STEAM_LINK_PACK+=(native)
-				fi
-				continue
-			fi
+			# The shortcuts Steam writes for single games are not
+			# applications of their own - a game is whatever engine it was
+			# built with, and none of those reads a Chromium argument - and
+			# starting the client through one needs nothing on its command
+			# line either.
+			mca_exec_is_steam_link "$exec_line" "$prog" && continue
 
 			c_ids+=("$id"); c_files+=("$file"); c_names+=("$name")
 			c_progs+=("$prog")

src/lib/kde.sh

@@ -0,0 +1,167 @@
+# shellcheck shell=bash
+#
+# KDE's middle-click paste.
+#
+# Inside a Chromium application the flag settles this on its own: with
+# autoscroll on, Blink stops pasting the primary selection on middle click,
+# because the button is doing something else now. Everywhere else on the
+# desktop middle click goes on pasting, which is the behaviour this whole
+# program exists to get away from - so the desktop's own switch for it is
+# turned off too.
+#
+# KWin has such a switch, and only for a Wayland session, where the paste is a
+# protocol the compositor either offers or does not:
+#
+#   ~/.config/kwinrc, [Wayland], EnablePrimarySelection=false
+#
+# On X11 there is nothing to switch. The primary selection is part of X itself
+# and every toolkit reaches for it on its own; no one place can say no.
+#
+# KWin reads the key once, while it starts, so what is written here is true
+# from the next login on rather than straight away.
+
+MCA_KWINRC="${MCA_XDG_CONFIG}/kwinrc"
+MCA_KWIN_GROUP="Wayland"
+MCA_KWIN_KEY="EnablePrimarySelection"
+
+# The kconfig command line tools, whichever generation this session has. They
+# are what System Settings writes kwinrc with, and worth the fork: the file has
+# a cascade behind it - /etc/xdg, the kdedefaults directory - and entries a
+# distribution can mark immutable, and an edit that reaches past all that with
+# sed writes something KDE goes on to ignore.
+MCA_KDE_TOOL=''
+MCA_KDE_TOOL_LOOKED=0
+
+_mca_kde_tool() {
+	local gen
+
+	if (( ! MCA_KDE_TOOL_LOOKED )); then
+		MCA_KDE_TOOL_LOOKED=1
+		for gen in 6 5; do
+			if mca_have "kreadconfig$gen" && mca_have "kwriteconfig$gen"; then
+				MCA_KDE_TOOL="$gen"
+				break
+			fi
+		done
+	fi
+
+	[[ -n $MCA_KDE_TOOL ]] || return 1
+	printf '%s\n' "$MCA_KDE_TOOL"
+}
+
+# mca_kde_session
+# Whether this is a KWin Wayland session.
+mca_kde_session() {
+	local desktop="${XDG_CURRENT_DESKTOP:-}"
+
+	# The watcher is a systemd service, and one started before the session
+	# imported its environment sees none of these variables. A running
+	# kwin_wayland answers both halves of the question at once, and is what
+	# such a run ends up going by.
+	if [[ -z $desktop && -z ${KDE_FULL_SESSION:-} ]]; then
+		mca_have pgrep || return 1
+		pgrep -u "$(id -u)" -x kwin_wayland > /dev/null 2>&1
+		return
+	fi
+
+	# XDG_CURRENT_DESKTOP is the one every desktop sets, and the one to go by
+	# wherever it is set; KDE_FULL_SESSION is what answers when it is not.
+	[[ -z $desktop || ${desktop^^} == *KDE* ]] || return 1
+
+	[[ ${XDG_SESSION_TYPE:-} == wayland || -n ${WAYLAND_DISPLAY:-} ]]
+}
+
+mca_kde_available() {
+	mca_kde_session && _mca_kde_tool > /dev/null
+}
+
+# mca_kde_read [file]
+# What the key says now, lowercased, empty when it is not set at all.
+mca_kde_read() {
+	local file="${1:-$MCA_KWINRC}" gen val
+	gen="$(_mca_kde_tool)" || return 1
+
+	# kreadconfig creates the file it is pointed at, and the status screen -
+	# which asks on every redraw - has no business writing anything. A file
+	# that is not there has no value in it to read anyway.
+	[[ -f $file ]] || return 0
+
+	val="$("kreadconfig$gen" --file "$file" --group "$MCA_KWIN_GROUP" \
+		--key "$MCA_KWIN_KEY" 2>/dev/null)"
+	printf '%s\n' "${val,,}"
+}
+
+# mca_kde_write [file] <value>
+# An empty value takes the key back out rather than writing nothing into it -
+# a key that is missing and a key that says nothing are not the same thing to
+# KDE, and only the first one is what an untouched kwinrc looks like.
+mca_kde_write() {
+	local file="$1" value="$2" gen
+	gen="$(_mca_kde_tool)" || return 1
+
+	if [[ -z $value ]]; then
+		"kwriteconfig$gen" --file "$file" --group "$MCA_KWIN_GROUP" \
+			--key "$MCA_KWIN_KEY" --delete 2>/dev/null
+	else
+		"kwriteconfig$gen" --file "$file" --group "$MCA_KWIN_GROUP" \
+			--key "$MCA_KWIN_KEY" "$value" 2>/dev/null
+	fi
+}
+
+# mca_kde_paste_apply
+# Turns the paste off, and remembers what the key said before so that undoing
+# puts that back rather than a guess.
+#
+# A key that already says false without the ledger knowing about it was set by
+# the user or by the distribution. That one is left alone and nothing is
+# recorded, so `disable` cannot switch a paste back on that this program never
+# switched off.
+mca_kde_paste_apply() {
+	local current previous changed=0
+
+	mca_kde_available || return 1
+	current="$(mca_kde_read)" || return 1
+
+	if mca_ledger_has "$MCA_KWINRC"; then
+		# Ours already. What goes back is the value recorded the first time
+		# round, not what reading the file now would say - that is false, and
+		# false is what is being undone.
+		previous="$(mca_ledger_detail "$MCA_KWINRC")" || previous=unset
+	elif [[ $current == false ]]; then
+		return 0
+	else
+		previous="${current:-unset}"
+	fi
+
+	if [[ $current != false ]]; then
+		mca_kde_write "$MCA_KWINRC" false || return 1
+		MCA_CHANGES=$(( MCA_CHANGES + 1 ))
+		changed=1
+	fi
+
+	mca_ledger_add kwin "$MCA_KWINRC" "$previous"
+
+	(( changed )) && mca_note "$(mca_msg "Middle click stops pasting at the next login.")"
+	return 0
+}
+
+# mca_kde_paste_revert <file> <previous value>
+mca_kde_paste_revert() {
+	local file="$1" previous="$2"
+
+	_mca_kde_tool > /dev/null || return 1
+	[[ -f $file ]] || return 1
+
+	# Only what is still recognisably ours. A key somebody has since put a
+	# value of their own into is theirs now.
+	[[ "$(mca_kde_read "$file")" == false ]] || return 1
+
+	[[ $previous == unset ]] && previous=''
+	mca_kde_write "$file" "$previous" || return 1
+
+	# Nothing was in the file but the key, which means there was no file before
+	# this program wrote one. An empty kwinrc says nothing that its absence
+	# does not say better.
+	[[ -s $file ]] || rm -f -- "$file"
+	return 0
+}

src/lib/menu.sh

@@ -178,9 +178,6 @@ mca_ui_status() {
 	if mca_steam_installed; then
 		if mca_steam_patched; then
 			_mca_row "$(mca_msg "Steam")" "$(_mca_onoff yes)"
-		elif [[ $CFG_STEAM == yes && $CFG_ENABLED == yes ]] && mca_steam_waiting; then
-			_mca_row "$(mca_msg "Steam")" \
-				"${MCA_C_DIM}$(mca_msg "waiting until Steam is closed")${MCA_C_RESET}"
 		elif [[ $CFG_STEAM == yes && $CFG_ENABLED == yes ]]; then
 			_mca_row "$(mca_msg "Steam")" \
 				"${MCA_C_YELLOW}$(mca_msg "not patched yet")${MCA_C_RESET}"
@@ -197,6 +194,18 @@ mca_ui_status() {
 		fi
 	fi
 
+	# Not an ON/OFF like the rows around it: what is being reported is the state
+	# of the paste, not of a switch, and off is the state this program is after.
+	if mca_kde_available; then
+		if [[ "$(mca_kde_read)" == false ]]; then
+			_mca_row "$(mca_msg "Middle-click paste")" \
+				"${MCA_C_GREEN}$(mca_msg "off")${MCA_C_RESET}"
+		else
+			_mca_row "$(mca_msg "Middle-click paste")" \
+				"${MCA_C_DIM}$(mca_msg "on")${MCA_C_RESET}"
+		fi
+	fi
+
 	_mca_row "$(mca_msg "Last applied")" "$(mca_time_ago "$last")"
 
 	if [[ $CFG_ENABLED == yes ]]; then
@@ -219,6 +228,7 @@ MCA_SETTINGS=(
 	"PatchAutostart|bool|yes|Programs that start themselves at login"
 	"PatchSteam|bool|yes|Steam"
 	"PatchSpotify|bool|yes|Spotify"
+	"DisablePaste|bool|yes|Turn off KDE's middle-click paste"
 	"WatchNewApps|bool|yes|Apply to newly installed applications"
 	"ExtraFlags|text||Additional Chromium arguments"
 )

src/lib/patch.sh

@@ -410,15 +410,6 @@ mca_desktop_apply() {
 #   The desktop folder, where a shortcut somebody dragged out of the menu -
 #   or asked Steam for - lives and nowhere else.
 #
-# Steam is in both, even though it is not a Chromium process itself: its
-# entries need -noverifyfiles exactly like the menu one. The autostart entry is
-# the one most likely to exist, because Steam writes it as soon as "run at
-# startup" is ticked; without it a Steam started at login restores the patched
-# web helper script and the watcher patches it back, over and over. The desktop
-# ones are the gap behind "autoscroll works, except sometimes": starting a game
-# from the desktop is a Steam start like any other, and a Steam start without
-# the switch costs the interface its autoscroll for the rest of the session.
-#
 # Neither can be shadowed from anywhere, so both are edited where they stand,
 # with the original kept.
 
@@ -426,16 +417,27 @@ mca_desktop_apply() {
 # One desktop entry that lives outside the XDG search path, edited where it is
 # because there is nowhere to shadow it from.
 #
-# Anything that starts Steam gets Steam's own switch; a Chromium application
-# gets the flag. What decides whether a Chromium application here is in scope
-# differs by where the entry came from, which is what the gate says: an
-# autostart entry follows the autostart setting, a shortcut follows the same
-# rules as the application it is a shortcut to.
+# What decides whether an application here is in scope differs by where the
+# entry came from, which is what the gate says: an autostart entry follows the
+# autostart setting, a shortcut follows the same rules as the application it is
+# a shortcut to.
 _mca_entry_patch_inplace() {
 	local file="$1" gate="$2"
-	local id prog packaging=native content backup kind
+	local id prog packaging=native content backup kind copy
 
-	grep -q "^$MCA_MARK_INPLACE=" "$file" 2>/dev/null && return 0
+	# Already ours, and normally that is the end of it: what is in there is what
+	# this version put there. Not so for a file the ledger has no record of -
+	# nothing would ever look at that one again, neither the undo a change of
+	# flags goes through nor this, which leaves a marked file alone, and it would
+	# keep an answer from an older version for good. The copy taken before the
+	# edit is named after the path and is still there, so the file goes back to
+	# what it was and is written again below.
+	if grep -q "^$MCA_MARK_INPLACE=" "$file" 2>/dev/null; then
+		mca_ledger_has "$file" && return 0
+		copy="$MCA_BACKUPDIR/$(mca_backup_name "$file")"
+		[[ -f $copy ]] || return 0
+		cp -p -- "$copy" "$file" 2>/dev/null || return 0
+	fi
 
 	_mca_desktop_read "$file"
 	[[ -n $DE_EXEC ]] || return 0
@@ -456,30 +458,29 @@ _mca_entry_patch_inplace() {
 		packaging=snap
 	fi
 
-	if mca_prog_is_steam "$prog"; then
-		[[ $CFG_STEAM == yes ]] || return 0
-		content="$(_mca_desktop_transform "$file" "$MCA_MARK_INPLACE" \
-			"$MCA_STEAM_LAUNCH_FLAG" "$(mca_steam_flag_position "$packaging")")"
+	# An entry that starts Steam is left where it is. Steam takes nothing
+	# from a command line that would help, and what it does take belongs to
+	# the web helper script in its own installation.
+	mca_prog_is_steam "$prog" && return 0
+
+	case "$packaging" in
+		flatpak) mca_flatpak_is_chromium "${prog#flatpak:}" || return 0 ;;
+		snap)    mca_snap_is_chromium "${prog#snap:}" || return 0 ;;
+		*)       mca_is_chromium "$prog" || return 0 ;;
+	esac
+
+	mca_desktop_is_browser && kind=browser || kind=app
+
+	if [[ $gate == autostart ]]; then
+		[[ $CFG_AUTOSTART == yes ]] || return 0
 	else
-		case "$packaging" in
-			flatpak) mca_flatpak_is_chromium "${prog#flatpak:}" || return 0 ;;
-			snap)    mca_snap_is_chromium "${prog#snap:}" || return 0 ;;
-			*)       mca_is_chromium "$prog" || return 0 ;;
-		esac
-
-		mca_desktop_is_browser && kind=browser || kind=app
-
-		if [[ $gate == autostart ]]; then
-			[[ $CFG_AUTOSTART == yes ]] || return 0
-		else
-			id="${file##*/}"; id="${id%.desktop}"
-			mca_kind_wanted "$kind" "$id" "$packaging" || return 0
-		fi
-
-		content="$(_mca_desktop_transform "$file" "$MCA_MARK_INPLACE" \
-			"$(mca_flags "$kind")")"
+		id="${file##*/}"; id="${id%.desktop}"
+		mca_kind_wanted "$kind" "$id" "$packaging" || return 0
 	fi
 
+	content="$(_mca_desktop_transform "$file" "$MCA_MARK_INPLACE" \
+		"$(mca_flags "$kind")")"
+
 	[[ -n $content ]] || return 0
 	[[ "$content" == "$(< "$file")" ]] && return 0
 
@@ -645,6 +646,10 @@ mca_revert_all() {
 				mca_steam_revert "$path" "$detail" \
 					&& MCA_CHANGES=$(( MCA_CHANGES + 1 ))
 				;;
+			kwin)
+				mca_kde_paste_revert "$path" "$detail" \
+					&& MCA_CHANGES=$(( MCA_CHANGES + 1 ))
+				;;
 		esac
 	done < <(tac "$MCA_LEDGER" 2>/dev/null)
 

src/lib/steam.sh

@@ -18,25 +18,19 @@
 # and the flag survives however Steam was started - from the menu, from a game
 # shortcut, from a launcher like Heroic, from a terminal.
 #
-# That is the part that has to work, because there is no way to make every
-# possible way of starting Steam carry an argument. -noverifyfiles on the
-# launcher entries is the second line rather than the first: it covers the case
-# where the script has no comments left to pay for the flag and the patch has
-# to grow the file. The trade-off is real and belongs to the user, so it is a
-# switch of its own rather than part of the general application handling: with
-# verification off, Steam no longer repairs a damaged installation by itself.
-#
-# A patch that does change the size still has to stay out of the way of a
-# client that is already running, or the two programs spend the session undoing
-# each other: Steam restores the script, the watcher patches it again, Steam
-# restores it again, and the client never gets past its update dialog. A patch
-# that keeps the size is invisible to that check and goes in either way.
+# A patch that changes the length is not an option, and no switch covers for
+# one. Steam checks its files at a start it was given arguments for, but also
+# at the shutdown it runs itself - and that one has no -noverifyfiles on its
+# command line, whatever the session was started with. What a single wrong
+# length costs is the whole client package downloaded, extracted and installed
+# again, and a client that quits at the end of it instead of coming up. So the
+# flag either fits in the space the comments give back, or it is not written at
+# all: no autoscroll in the interface is a smaller thing than a client that
+# reinstalls itself.
 #
 # The file comes back on every client update, and the watcher re-applies the
 # patch when that happens.
 
-MCA_STEAM_LAUNCH_FLAG='-noverifyfiles'
-
 # Every place a Steam installation is known to live, resolved and de-duplicated
 # because ~/.steam/steam is normally a symlink into ~/.local/share.
 #
@@ -88,24 +82,6 @@ mca_steam_installed() {
 	return 1
 }
 
-# mca_steam_running
-# Steam records its own process id beside its installation while it runs. The
-# file outlives a crash, so the id is checked rather than believed.
-mca_steam_running() {
-	local f pid
-	for f in \
-		"$HOME/.steam/steam.pid" \
-		"$HOME/.var/app/com.valvesoftware.Steam/.steam/steam.pid" \
-		"$HOME/snap/steam/common/.steam/steam.pid"
-	do
-		[[ -r $f ]] || continue
-		pid="$(< "$f")"
-		[[ $pid =~ ^[0-9]+$ ]] || continue
-		kill -0 "$pid" 2>/dev/null && return 0
-	done
-	return 1
-}
-
 # mca_steam_script_patched <script>
 mca_steam_script_patched() {
 	grep -q -- "$MCA_FEATURE" "$1" 2>/dev/null
@@ -120,26 +96,6 @@ mca_steam_patched() {
 	return 1
 }
 
-# mca_steam_deferred <script>
-# Whether the patch is being held back rather than simply missing: the script
-# was patched before, its own copy is back, and Steam is still running. See
-# mca_steam_apply for why that is left alone.
-mca_steam_deferred() {
-	[[ -e "$MCA_BACKUPDIR/$(mca_backup_name "$1")" ]] && mca_steam_running
-}
-
-# mca_steam_waiting
-# The same question for the status screen, which has no script in hand.
-mca_steam_waiting() {
-	local root script
-	while IFS= read -r root; do
-		script="$(mca_steam_script "$root")" || continue
-		mca_steam_script_patched "$script" && continue
-		mca_steam_deferred "$script" && return 0
-	done < <(mca_steam_roots)
-	return 1
-}
-
 # _mca_steam_exec_line <script>
 # The line number of the command that starts the web helper: the last
 # uncommented line that both names steamwebhelper and forwards "$@". Both the
@@ -154,27 +110,25 @@ _mca_steam_exec_line() {
 	' "$1" 2>/dev/null
 }
 
-# _mca_steam_build <script> <flags> <reclaim: 0|1>
+# _mca_steam_build <script> <flags>
 # The patched script on stdout: the flags appended to the line that starts the
-# web helper, and - when asked for - the same number of bytes taken back out of
-# the script's comments, so that the file Steam finds is the length Steam wrote
-# down. Everything else - setting up the container runtime, deciding whether
-# the sandbox can be used - is left alone.
+# web helper, and the same number of bytes taken back out of the script's
+# comments, so that the file Steam finds is the length Steam wrote down.
+# Everything else - setting up the container runtime, deciding whether the
+# sandbox can be used - is left alone.
 #
 # Comments are eaten from the bottom up, so the header that says what the
 # script is for is the last thing to lose anything, and the '#' itself always
 # stays: a line that loses it stops being a comment and starts being a command.
 # Fails when the comments are too short to pay for the flags.
 _mca_steam_build() {
-	local script="$1" flags="$2" reclaim="$3" lineno need=0
+	local script="$1" flags="$2" lineno need
 
 	lineno="$(_mca_steam_exec_line "$script")"
 	[[ -n $lineno ]] || return 1
 
-	if (( reclaim )); then
-		need="$(printf '%s' " $flags" | wc -c)"
-		need="${need//[^0-9]/}"
-	fi
+	need="$(printf '%s' " $flags" | wc -c)"
+	need="${need//[^0-9]/}"
 
 	# LC_ALL=C so awk counts bytes: a comment with an accent in it is shorter
 	# in characters than it is on disk, and it is the disk that Steam measures.
@@ -222,44 +176,50 @@ _mca_steam_refresh_backup() {
 	cp -p -- "$script" "$MCA_BACKUPDIR/$name" 2>/dev/null || true
 }
 
-# _mca_steam_reneutralise <script> <flags>
-# An earlier version of this program patched by appending and left the script
-# longer than Steam expects, which is a patch that only survives because
-# -noverifyfiles is there to stop Steam looking. If the same flags can be made
-# to fit, they are: the file goes back to the length and the timestamp Steam
-# wrote down and stops depending on that switch.
+# _mca_steam_settle <script> <flags>
+# The script is already patched. Whether that is a patch Steam can live with is
+# a question of length: an earlier version of this program appended the flag
+# where the comments could not pay for it, which leaves the script longer than
+# the file Steam wrote down - and a client that checks its files reinstalls
+# itself over that, then quits instead of starting.
 #
-# The new copy is built from the untouched original that was kept when the
-# script was first patched, never from the patched file - patching a patched
-# file is how a flag ends up in there twice.
-_mca_steam_reneutralise() {
+# Rebuilt from the untouched original kept when the script was first patched,
+# never from the patched file, the flag either fits this time or the original
+# goes back and Steam is left with a client it recognises.
+_mca_steam_settle() {
 	local script="$1" flags="$2" name copy out
 
 	name="$(mca_backup_name "$script")"
 	copy="$MCA_BACKUPDIR/$name"
-	[[ -f $copy ]] || return 1
 
-	# Already the length Steam expects: there is nothing to gain.
-	(( $(wc -c < "$script") == $(wc -c < "$copy") )) && return 1
+	# Nothing to compare against, so nothing can be said about the length.
+	[[ -f $copy ]] || return 0
 
-	out="$(_mca_steam_build "$copy" "$flags" 1)" || return 1
-	_mca_steam_same_size "$copy" "$out" || return 1
+	# Already the length Steam expects: the patch is a good one.
+	(( $(wc -c < "$script") == $(wc -c < "$copy") )) && return 0
 
-	if mca_write_if_changed "$script" "$out"$'\n'; then
-		MCA_CHANGES=$(( MCA_CHANGES + 1 ))
+	if out="$(_mca_steam_build "$copy" "$flags")" && _mca_steam_same_size "$copy" "$out"; then
+		if mca_write_if_changed "$script" "$out"$'\n'; then
+			MCA_CHANGES=$(( MCA_CHANGES + 1 ))
+		fi
+		chmod +x -- "$script" 2>/dev/null || true
+		touch -r "$copy" -- "$script" 2>/dev/null || true
+		mca_ledger_add steam "$script" "$name"
+		return 0
 	fi
-	chmod +x -- "$script" 2>/dev/null || true
-	touch -r "$copy" -- "$script" 2>/dev/null || true
-	mca_ledger_add steam "$script" "$name"
+
+	mca_steam_revert "$script" "$name"
+	mca_ledger_forget "$script"
+	mca_note "$(mca_msg "Steam's interface cannot be given the flag without leaving a file Steam would reinstall; the change has been taken back.")"
 	return 0
 }
 
 # mca_steam_apply
-# Puts the flags into every Steam installation that has the script, preferring
-# the patch that keeps the file's size and falling back to the one that does
-# not. Returns 1 when there is no Steam to patch at all.
+# Puts the flags into every Steam installation that has the script, and only
+# where that can be done without changing how long the file is. Returns 1 when
+# there is no Steam to patch at all.
 mca_steam_apply() {
-	local root script backup flags found=0 out neutral
+	local root script backup flags found=0 out
 
 	flags="$(mca_flags)"
 
@@ -268,35 +228,21 @@ mca_steam_apply() {
 		found=1
 
 		if mca_steam_script_patched "$script"; then
-			_mca_steam_reneutralise "$script" "$flags" || true
+			_mca_steam_settle "$script" "$flags"
 			continue
 		fi
 
 		_mca_steam_refresh_backup "$script"
 
-		neutral=1
-		if ! { out="$(_mca_steam_build "$script" "$flags" 1)" \
+		# Either the comments can pay for the flag or nothing is written.
+		# A longer file is one Steam reinstalls itself over; a client update
+		# that changed how the helper is started leaves no line to patch at
+		# all. Both end here, and this script is what starts Steam's entire
+		# interface, so leaving it alone is the only safe answer to either.
+		if ! { out="$(_mca_steam_build "$script" "$flags")" \
 			&& _mca_steam_same_size "$script" "$out"; }
 		then
-			neutral=0
-			out="$(_mca_steam_build "$script" "$flags" 0)" || {
-				# A client update changed how the helper is started. Leaving
-				# the file alone is the only safe answer: this script is what
-				# starts Steam's entire interface.
-				mca_note "$(mca_msg "Steam starts its interface in a way this version does not recognise; leaving it alone.")"
-				continue
-			}
-		fi
-
-		# The patch has to grow the file, and it is not patched now but was
-		# before: Steam has just put its own copy back. Patching it again
-		# while the client watches is what turns one size mismatch into an
-		# endless update dialog, and it would not help this session anyway -
-		# the helper is started once, at the start. The patch waits for the
-		# next apply with Steam closed. A patch that keeps the size has
-		# nothing to wait for.
-		if (( ! neutral )) && mca_steam_deferred "$script"; then
-			mca_note "$(mca_msg "Steam is running and has put its own file back; the change waits until Steam is closed.")"
+			mca_note "$(mca_msg "Steam starts its interface in a way this version cannot change without Steam noticing; leaving it alone.")"
 			continue
 		fi
 
@@ -339,23 +285,3 @@ mca_steam_revert() {
 	chmod +x -- "$script" 2>/dev/null || true
 	return 0
 }
-
-# mca_steam_flag_position <packaging>
-# Where Steam's own switch goes on a command line. Straight after the program
-# for a native or snap entry, because Steam reads its options before the
-# steam:// argument that the right-click actions pass. For a Flatpak the first
-# token is flatpak itself, which would take the switch for one of its own and
-# refuse to start, so there it goes at the end of the arguments - after the
-# application id, where flatpak hands everything on to Steam.
-mca_steam_flag_position() {
-	[[ ${1:-native} == flatpak ]] && { printf 'before-fields\n'; return; }
-	printf 'after-program\n'
-}
-
-# mca_steam_desktop_apply <id> <source entry> [packaging]
-# Steam restores its own files at every start unless it is told not to verify
-# them, so the launcher entry carries that switch.
-mca_steam_desktop_apply() {
-	mca_desktop_apply "$1" "$2" "$MCA_STEAM_LAUNCH_FLAG" \
-		"$(mca_steam_flag_position "${3:-native}")"
-}

src/middleclick-autoscroll

@@ -17,7 +17,7 @@ set -uo pipefail
 
 MCA_LIBDIR="${MCA_LIBDIR:-@LIBDIR@}"
 
-for _mod in common config detect patch steam apply menu; do
+for _mod in common config detect patch steam kde apply menu; do
 	# shellcheck source=/dev/null
 	if ! source "$MCA_LIBDIR/$_mod.sh"; then
 		printf 'middleclick-autoscroll: cannot load %s/%s.sh\n' "$MCA_LIBDIR" "$_mod" >&2
@@ -56,10 +56,6 @@ mca_do_enable() {
 
 	mca_ok "$(mca_msg "Autoscroll is on for %d applications." "$MCA_N_ON")"
 
-	if [[ $CFG_STEAM == yes ]] && mca_steam_installed; then
-		mca_note "$(mca_msg "Steam's launcher now skips its file check, which is what keeps the change from being undone at every start.")"
-	fi
-
 	mca_note "$(mca_msg "Applications that are already running pick this up when they are restarted.")"
 }