PlasmaZones v3.4.6

PlasmaZones v3.4.6

Added

• The support archive records KWin's own window rules: KWin has its own window rules, separate from PlasmaZones, and they move, resize and re-desktop windows on their own. A window being thrown across monitors can therefore have nothing to do with PlasmaZones, and there was no way to tell from a report. The archive now carries kwin-rules.txt. Window titles are removed from it, since a title can carry a document name or a web address and nothing about placement depends on it. The rule's application, its window class and its position, size and desktop settings are all kept (#1030).

Changed

• The daemon and the KWin effect must be the same build: this release changes the message they speak again, so a mismatched pair refuses to connect rather than misbehaving. Packagers should rebuild and ship both together (#1029, #1030).
• The support report says what it contains: both the report and the archive tell you up front that they record your machine hostname, the class and title of tracked windows, the match patterns from your window rules, and the make, model and serial number your monitors report over EDID, so you can look before attaching either to a public bug report. Home paths are still redacted, and that redaction now also works when your home directory is written with a trailing slash (#1031).
• Windowed fullscreen exits through one shared helper: two places unwound the fullscreen change notification by hand instead of using the helper that unwinds it for them. Both now go through the helper, so a later edit between the two halves cannot switch off the code that notices an application leaving fullscreen by itself (#1031).

Fixed

• A maximized scrolling window fills the screen instead of hanging off its edge: with the setting that keeps the focused column in the middle of the screen turned on, maximizing a scrolling window put it a gap's width past the left edge of the monitor, so a strip of it was off screen and the same strip of gap showed on the right. The width of the miss was whatever outer gap you had set, which is why it looked like a small alignment error rather than a placement one. A maximized column covers the screen gaps and all, and the part of PlasmaZones that decides where the window goes was measuring against the screen with the gaps already taken off, so the gap was subtracted twice. With that setting turned off the same miss happened when you moved focus back onto the maximized window from the window after it, and there it was as wide as both of your outer gaps together. Every way of arriving at a maximized column now puts it on the whole screen (#1033).
• A window snapped on one monitor is no longer recomputed onto another: when PlasmaZones was asked for a zone's position without being told which monitor to measure it against, it measured against the primary monitor and answered as though nothing were wrong. Callers had no way to tell that answer apart from a real one, so a window snapped into a zone on a second monitor could be handed the same zone's position on the primary monitor a moment later and move there, keeping its size and losing only the monitor it belonged to. On two monitors of the same resolution the two positions differ by nothing else, which is why it looked like the window jumping across the desktop on its own. A request that does not name a resolvable monitor is now refused instead of answered (#1032).
• Scrolling the strip from the keyboard leaves a fullscreen video too: making a video fullscreen on a scrolling monitor and then moving along the strip with the wheel dropped the fullscreen first, but the keyboard shortcuts did not. The strip carried on scrolling and parking the column behind a window that was still covering the screen, so what PlasmaZones thought was on screen and what you could see drifted apart until you left the fullscreen yourself. Every keyboard verb that acts on the strip now leaves the fullscreen first, width and height changes included (#1029).
• Switching virtual desktops quickly no longer confuses which windows belong where: the daemon tells the KWin effect which monitors are managed, and that message takes a moment to arrive while the desktop change itself is immediate. Switching desktops faster than the message travels meant the effect could act on an answer for the desktop it had already left, treating windows on the desktop it had arrived at as though they belonged to the one it came from. The answer now says which desktop it was worked out for, and the effect waits for the one that matches (#1030).
• A remembered floating position is checked against the monitor it is filed under: each remembered position is stored against a monitor, and nothing verified that the position was actually on that monitor. A mismatch was invisible, because the only check asked whether a position was on some monitor, which a wrong one is. Now that a window is only ever restored to a position remembered for the monitor it is on, such an entry would send it to the other monitor instead. PlasmaZones no longer files a position under a monitor it does not lie on, and ignores any already stored that way (#1030).
• Floating a window puts it back where it was, or leaves it alone: PlasmaZones remembers where a window was floating so it can be put back there. When it had nothing to go on it guessed twice over. It borrowed a position remembered for a different window of the same application, and it borrowed a position remembered on a different monitor, moving the window to that monitor. An application keeps only its last sixteen windows on record, so a window open a while could find that record full of windows that had since closed and be sent to wherever one of them had been. Snapping, tiling and scrolling each did this differently. All three now restore a window only to a position that window itself had, on the monitor it is on, and a window with nothing remembered stays where it is (#1030).
• A window put back where it was before tiling no longer lands on the wrong monitor: PlasmaZones remembers where a window sat before it was tiled so it can be put back, and those positions are stored per monitor as screen coordinates. Several paths handed back a position belonging to a different monitor, which moved the window there rather than merely resizing it. It happened on a virtual desktop switch, when a window stopped being tileable, and when a window was floated as part of a batch, because each took whichever remembered position it found first whatever monitor it was measured on. When nothing was remembered for the window it asked the daemon, which would answer with a position remembered for a different window of the same application, worked out against the monitor the daemon last had the window on rather than the one it is on now. A remembered position from another monitor now gives back only its size, so the window returns to the size it had without leaving the monitor it is on, and the daemon answers only for the window that asked. A window that moves to another monitor also updates where its position is remembered, instead of being stuck with the first monitor it was ever seen on (#1030).
• Extra windows past the tiling limit float instead of being left behind: with tiling on, opening more windows than the layout's window limit left the extra ones wherever the compositor had put them rather than floating them, which is what the overflow setting says should happen. Those windows were also invisible to the rest of PlasmaZones, so minimizing one and restoring it did nothing, the window held its place in the layout the whole time it was minimized, and focus follows mouse stopped working for the rest of the session because PlasmaZones went on believing the window was floating. The window limit is now applied by the same pass that floats overflow windows, so an extra window floats as it opens and returns to the layout when room frees up (#1030).
• Maximizing a scrolling window fills the screen and stays filled: pressing the maximize button or double-clicking the titlebar on a scrolling monitor gave the window the whole screen for a moment and then shrank it back to its old size in the middle of the screen, so the maximize looked like it had done nothing while the button stayed lit. Applications that pick their own size, such as Gwenview and Konsole, were the ones affected, because PlasmaZones remembers the size those windows settle on and was handing it back to them on the next redraw. A column filling the screen is now left out of that memory, and restoring one leaves the smaller column it returns to at its own size (#1031).
• The maximize path can be diagnosed from a support report: a maximize on a scrolling monitor wrote nothing to the log at any stage, on either side, so a report gathered right after reproducing the problem showed no sign that the button had been pressed. Claiming the request, dispatching it, refusing it and every reason for declining it are now recorded, along with the shape the column ends up with (#1031).
• Windowed fullscreen says what it did: Meta+Alt+Shift+F wrote nothing to the log whether it worked or not, and it has two refusals that look exactly like a dead keybinding from the user's side. The commonest one is that focus is on a floating window, which owns no column for the shortcut to act on. Both refusals now give their reason, the toggle records which window it acted on and which way it went, and the compositor records entering, adopting after a restart, reconciling an application's own exit, and releasing (#1031).
• The support report keeps the compositor log it was throwing away: the KWin Effect Logs section kept only journal lines containing the word "plasmazones", which was expected to match every line the effect writes because its log categories all start with it. KWin prints its own log lines without the category, so in practice only the ones that happened to name a PlasmaZones window survived, and on a live session that discarded more than three quarters of them. Worse, a report could say the effect had logged nothing while it was logging heavily, and the archive shipped without its kwin-effect.log at all. The whole compositor journal for the window is now kept, under the clearer heading Compositor Logs, still capped at 2000 lines (#1031).
• Windowed fullscreen says why it did nothing when a floating window has focus: pressing Meta+Alt+Shift+F while the window you are looking at is floating showed "no windows", which is the message for an empty strip and reads as nonsense when there is a window right in front of you. A floating window belongs to no column, so there is nothing for the shortcut to fill, and the message now says so (#1031).
• A maximized scrolling window is drawn where it actually is: a window that insists on its own size instead of taking the whole screen was drawn in the middle of the screen while it actually sat at the top-left corner, so clicks landed away from what you could see. A column maximized to the screen edges has nothing to centre a window within, because the column already is the whole screen, and neither the drawing nor the placement centres one there now. Windows that pick their own size on X11 are unaffected, since those are genuinely centred when they are placed (#1031).
• The support report redacts paths outside your home directory: home paths were replaced with ~, but if you point XDG_CONFIG_HOME or XDG_DATA_HOME somewhere outside your home directory, every config and data path in the report was written out in full, and those paths usually contain your username. They are now replaced with the name of the variable (#1031).
• The support report collector no longer stops when $HOME is unset: running the collector from a context with no home directory set, such as a systemd unit without User=, ended it with a shell error before it produced anything. It has a warning for exactly that case which could never be reached, because the first thing it did with the home directory came earlier. The warning now prints and the archive is written without home-path redaction, as intended (#1031).
• The support archive is readable only by you: the archive was written with whatever permissions the shell's default allowed, which on most systems means any other account on the machine could read it, and it is written to a shared temporary directory by default. It carries window titles, your window rules and your whole configuration. It is now created owner-only inside a private directory and moved into place, so another account cannot swap in a link and have the archive written somewhere it can read (#1031).
• The support report no longer ships files it cannot redact: pictures and other non-text files in your configuration, such as a shader pack's preview image, were copied into the archive exactly as they were. Image files routinely carry the folder they were made in, which usually contains your username, and nothing was replacing it. Those files are now left out and listed by name instead, and the report says so (#1031).
• A half-redacted file can no longer reach the support archive: three of the captures hid a failure while they were being cleaned of home paths, and the only check afterwards was whether the file was empty. A file that was cut off partway through was kept, with whatever had not been cleaned yet still in it. Each capture is now checked properly and dropped if it cannot be cleaned (#1031).
• One unreadable file no longer destroys the whole support archive: while copying your configuration, a single file that could not be read ended the collector, and the cleanup then deleted everything it had gathered. Nothing was printed to explain it. A file that cannot be staged is now reported and skipped, and the rest of the archive is still written (#1031).
• Interrupting the support collector no longer leaves it writing into a deleted folder: pressing Ctrl+C partway through deleted the staging folder and then carried on, so the run ended in a confusing error instead of stopping (#1031).
• Window rule descriptions and machine names are redacted in the support report: window titles were replaced, but the name you gave a rule was not, and in practice that name quotes the document or site the rule was made for (#1031).
• Windows past the tiling limit stay under control on every path: the fix for windows opening past the limit covered the case where tiling was on for the screen, and a second path was left. A window arriving while the screen was not tiling it kept a stale entry pointing at that screen, which is what made focus-follows-mouse stop and minimized windows hold their slot. Both paths now clean up after themselves, and a refused float repairs the entry instead of refusing forever (#1031).
• Unminimizing a window on a full screen no longer thrashes: the window was unfloated, the screen retiled, and the overflow pass immediately floated it again, so the compositor kept retrying a request that could never succeed. A window with nowhere to land now stays floating and comes back on its own when a slot frees up (#1031).
• Small windows keep their remembered position: any window narrower or shorter than 100 pixels was refused when PlasmaZones tried to remember where it had been floating, so small tool palettes and dialogs came back wherever the compositor happened to put them. The check was measuring visibility rather than which screen the window belonged to (#1031).
• A window no longer loses its remembered position when it moves between monitors: the old position was cleared before the new one was recorded, and several checks in between could stop the recording, leaving the window with nothing to return to for the rest of its life (#1031).
• Float-back works again for windows that only ever tiled: the remembered position was looked up under the snapping screen, which a window that has never been snapped does not have, so the lookup could not match anything (#1031).
• Remembered positions are found on subdivided monitors: a floating window's position is stored under the physical monitor while the rest of PlasmaZones asks by virtual screen, so the lookup missed and the window stayed where it was (#1031).
• Leaving windowed fullscreen restores the window properly: the check that cleared the maximized state read a flag that is still set at that moment on Wayland, so it always skipped, and KWin then put the window straight back to the maximized area over the restore (#1031).
• The desktop-switch guard works on subdivided monitors: the check that rejects an out-of-date screen announcement compared two different kinds of screen name, so it never matched and never rejected anything. It also read the desktop number through a wrapper it was not unwrapping, which made every number come out as zero (#1031).
• A closing window in a scrolling strip gets to finish its animation: the remaining columns moved into the gap the moment a window closed, so the closing window played its animation over a strip that had already settled. PlasmaZones waits out that animation before moving the neighbours, and that wait was being skipped on every close. Closing a window changes how many windows a monitor holds, and that count change had the monitor's scrolling settings re-resolved, which handed the strip back to be rebuilt a moment later whether or not anything about it had changed. The rebuild now waits like the rest of the close path (#1027).

Installation

Arch Linux (AUR):

yay -S plasmazones  # or plasmazones-bin

Arch Linux (manual):

sudo pacman -U plasmazones-3.4.6-*-x86_64.pkg.tar.zst

Debian testing/unstable (apt repository):
Tracks KDE as it lands in Debian and rebuilds when KWin moves.

sudo curl -fsSL https://download.opensuse.org/repositories/home:fuddlesworth/Debian_Unstable/Release.key -o /etc/apt/keyrings/plasmazones.asc
echo 'deb [signed-by=/etc/apt/keyrings/plasmazones.asc] https://download.opensuse.org/repositories/home:/fuddlesworth/Debian_Unstable/ /' | sudo tee /etc/apt/sources.list.d/plasmazones.list
sudo apt update
sudo apt install plasmazones

On Debian testing, swap Debian_Unstable for Debian_Testing in both lines. Packages are built for x86_64 only.

Debian (manual .deb):
Built on Debian unstable. Prefer the apt repository above, which rebuilds when KWin moves.

sudo dpkg -i plasmazones_3.4.6-*_amd64.deb
sudo apt-get install -f  # Install dependencies if needed

Fedora (COPR):

sudo dnf copr enable fuddlesworth/PlasmaZones
sudo dnf install plasmazones

Fedora (manual RPM):

# Fedora 44
sudo dnf install plasmazones-3.4.6-*.fc44.x86_64.rpm

openSUSE Tumbleweed (OBS):

sudo zypper addrepo https://download.opensuse.org/repositories/home:fuddlesworth/openSUSE_Tumbleweed/home:fuddlesworth.repo
sudo zypper refresh
sudo zypper install plasmazones

Universal Linux (AppDir):
For Fedora Atomic, Steam Deck, or non-root user installation:

tar xzf plasmazones-3.4.6-linux-x86_64.tar.gz
cd plasmazones-linux-x86_64
./install.sh

NixOS (flake):

# flake.nix inputs
plasmazones.url = "github:fuddlesworth/PlasmaZones";

# configuration.nix
programs.plasmazones.enable = true;

NixOS (without flakes):
Build this tag's source against your host's pkgs (no release asset needed):

# configuration.nix
environment.systemPackages = [
  (pkgs.callPackage
    "${builtins.fetchTarball "https://github.com/fuddlesworth/PlasmaZones/archive/v3.4.6.tar.gz"}/packaging/nix/package.nix"
    { version = "3.4.6"; })
];

Post-Installation

systemctl --user enable --now plasmazones.service
systemsettings kcm_plasmazones