mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-16 13:51:19 +01:00
feat(wm): transparency for the windows without the focus
The window in front of every container is see-through, unless its container has the focus on the focused monitor, so that the window being worked in stands out. The opacity of a window is a property KWin has: komorebi sets it through the bridge, as a fraction of 255, and KWin draws the window so. The window manager keeps the opacity it gave each window and, after every event and message, sends only the difference, makes a window opaque again when it should no longer be see-through, and makes every one opaque when it stops. Windows an ignore rule covers, and workspaces that do not tile, are left as they are. The patched border effect already draws a window again when its opacity changes, so the border follows it. komorebic gets transparency, transparency-alpha and toggle-transparency, and the state of the daemon says what the settings are. vm-features checks the pixels in the middle of a focused window and of one that is not. A monocled window is opaque on the focused monitor and see-through on another. komorebi.json takes transparency, transparency_alpha and transparency_ignore_rules.
This commit is contained in:
1 parent
abfa8c6a5c
commit
fa1e822e44
36 files changed
+974
-30
No files matched your search
@@ -70,7 +70,8 @@ without a checkout of the toolchain.
|
||||
the settings of KWin's it needs in the user's `kwinrc`, the parking desktop it
|
||||
hides the back of a stack and the windows behind a monocle on, and the borders
|
||||
and animations it has KWin draw (`kwin`), the border and animation settings and
|
||||
the look they make (`border_manager`, `animation`),
|
||||
the look they make (`border_manager`, `animation`), the opacity of the windows
|
||||
that do not have the focus (`transparency_manager`),
|
||||
the model of what it tiles (`monitor`, `workspace`, `container`, `window`), the
|
||||
window manager that keeps the model (`window_manager`), loads it from the
|
||||
backend (`desktop`) and changes it when the compositor reports an event
|
||||
@@ -259,7 +260,9 @@ komorebi gives each window the border color of what it is to the layout: the foc
|
||||
window, the others, a locked container, a floating window. `border`, `border-colour`,
|
||||
`border-width` and `border-offset` set it. Windows going to their places are
|
||||
animated by another effect, Geometry Change, which `animation`,
|
||||
`animation-duration` and `animation-style` turn on and set.
|
||||
`animation-duration` and `animation-style` turn on and set. `transparency` makes
|
||||
the windows that do not have the focus see-through, by the opacity KWin gives a
|
||||
window.
|
||||
|
||||
## Documentation
|
||||
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
```text
|
||||
Toggle transparency for unfocused windows
|
||||
|
||||
Usage: toggle-transparency
|
||||
|
||||
Options:
|
||||
-h, --help
|
||||
Print help
|
||||
|
||||
```
|
||||
@@ -0,0 +1,14 @@
|
||||
```text
|
||||
Set the alpha value for unfocused window transparency
|
||||
|
||||
Usage: transparency-alpha <ALPHA>
|
||||
|
||||
Arguments:
|
||||
<ALPHA>
|
||||
Alpha
|
||||
|
||||
Options:
|
||||
-h, --help
|
||||
Print help
|
||||
|
||||
```
|
||||
@@ -0,0 +1,14 @@
|
||||
```text
|
||||
Enable or disable transparency for unfocused windows
|
||||
|
||||
Usage: transparency <BOOLEAN_STATE>
|
||||
|
||||
Arguments:
|
||||
<BOOLEAN_STATE>
|
||||
[possible values: enable, disable]
|
||||
|
||||
Options:
|
||||
-h, --help
|
||||
Print help
|
||||
|
||||
```
|
||||
@@ -70,6 +70,8 @@ grows with the code: each part of the daemon that is added has its place here.
|
||||
- **Look**: how the compositor is asked to dress the windows, which it draws ([`Look`]):
|
||||
a border, with its width, its corner radius and two colors, and the animation of windows going
|
||||
to their places, with its duration and its easing curve.
|
||||
- **Opacity**: how opaque a window is drawn, 0 to 255, a property of the window in the compositor,
|
||||
which [`transparency_manager`] sets for the windows that do not have the focus.
|
||||
- **Effect**: a plugin of the compositor that changes how windows are drawn. KDE Rounded Corners
|
||||
is the effect that draws the border, and Geometry Change the one that animates windows.
|
||||
- **Compositor**: the program that owns the screen and the windows. On KDE Plasma it is
|
||||
@@ -822,6 +824,25 @@ once, when the effect is the stock one: every border is then the focused or the
|
||||
the look.
|
||||
[PLATFORM.md](PLATFORM.md#kwin-effects) has the effect, its settings and what was measured.
|
||||
|
||||
## Transparency
|
||||
|
||||
The opacity of a window is a property KWin has, so komorebi sets it ([`Backend::set_opacity`],
|
||||
which the KWin backend sends the bridge as an `opacity` command: `alpha / 255`) and the compositor
|
||||
draws the window so. [`transparency_manager`] holds the settings, as statics that `Transparency`,
|
||||
`ToggleTransparency` and `TransparencyAlpha` set and the `transparency` and `transparency_alpha`
|
||||
keys of the file give a value, and the rules for the ignored windows (`TRANSPARENCY_BLACKLIST`, set
|
||||
by the `transparency_ignore_rules` of the file). [`transparency_manager::apply`] is called
|
||||
before the first layout and after every event and every message: it works out
|
||||
[`transparency_manager::transparent_windows`], on the workspace each monitor shows (the window in
|
||||
front in every container, unless the container has the focus on the focused monitor; a monocled
|
||||
window only on a monitor that is not the focused one; none on a workspace that does not tile; none
|
||||
that a rule ignores), and sends the backend only what differs
|
||||
from what the window manager kept in [`WindowManager::opacity_applied`]. A window that should not
|
||||
be see-through any more is made opaque, and with transparency off every window is. When komorebi
|
||||
stops, [`transparency_manager::restore`] makes every window it changed opaque again. The border
|
||||
effect draws a window from a texture that has its opacity in it, and the build komorebi installs
|
||||
draws it again when the opacity changes ([PLATFORM.md](PLATFORM.md#the-patches)).
|
||||
|
||||
## The NixOS module
|
||||
|
||||
The flake exports one module under two names, `nixosModules.default` and
|
||||
@@ -918,6 +939,8 @@ module's unit.
|
||||
- [`border_manager`](../../komorebi/src/border_manager/mod.rs): the border settings, and the
|
||||
[`Look`] they make, which it asks the backend for.
|
||||
- [`animation`](../../komorebi/src/animation/mod.rs): the animation settings, which the look has.
|
||||
- [`transparency_manager`](../../komorebi/src/transparency_manager.rs): which windows are
|
||||
see-through, and the opacity they are given.
|
||||
- [`kwin::effects`](../../komorebi/src/kwin/effects.rs): the KWin effect that draws the border,
|
||||
its settings and the state komorebi keeps of it.
|
||||
- [`process_command`](../../komorebi/src/process_command.rs): the thread that listens on the
|
||||
@@ -1067,6 +1090,10 @@ the fake. The window manager is its only caller, through [`backend`]. The contra
|
||||
| A command that changes a stack is carried out with the animation off, and the animation is on again after it | framework path: the arms of [`WindowManager::process_command`] for the stack messages swap `ANIMATION_ENABLED_GLOBAL` for false and put the value back | `the_animation_is_on_again_after_a_command_that_changes_a_stack` | none |
|
||||
| The `animation` key of the file is the animation settings, and a file without it leaves them | framework path: `StaticConfig::apply_globals` sets them only when the key is there, and `duration` and `style` only when the key has one | `the_animation_key_of_the_file_is_the_animation_settings` | none |
|
||||
| Every style is a curve Qt has | test: [`AnimationStyle::qt_curve`] is a `match` of every style, and the test checks each against its name without the "Ease" | `every_style_is_a_curve_qt_has`, the doctest of `qt_curve`, `vm-features` (section D: two curves are in different places at the same moment) | a cubic Bézier is an ease out |
|
||||
| Only the windows the rules make see-through are, and only while transparency is on | framework path: [`transparency_manager::apply`] asks [`transparency_manager::transparent_windows`] and sends the difference from [`WindowManager::opacity_applied`] | `unfocused_windows_are_transparent_and_the_focused_one_is_not`, `turning_transparency_off_makes_everything_opaque_again`, `a_monocled_window_is_not_transparent`, `windows_the_rules_ignore_keep_their_opacity`, `vm-features` (section B) | none |
|
||||
| The `transparency` keys of the file are the settings, and a key the file leaves out has the default | framework path: `StaticConfig::apply_globals` stores `transparency` and `transparency_alpha` whether the file has them or not, and adds the ignore rules to `TRANSPARENCY_BLACKLIST` | `the_transparency_keys_of_the_file_are_the_transparency_settings` | none |
|
||||
| A window komorebi made see-through is opaque again when komorebi exits | framework path: [`WindowManager::stop`] and `main.rs` call [`transparency_manager::restore`] | `what_komorebi_made_see_through_is_opaque_again_when_it_exits` | `SIGKILL`: the windows stay as they were drawn |
|
||||
| What the backend sends for an opacity is what the bridge sets | tests: the `opacity` command of [`fixtures`] is what the backend's test sends and what the bridge's test answers with, checking the window's `opacity` | `the_commands_of_a_session_go_to_the_bridge_as_the_bridges_tests_answer_it`, `what the bridge sends for a session is what the daemon's tests read`, `a window is given the opacity it is asked for, and one KWin has not got is given back` | none |
|
||||
| The effect komorebi loaded is unloaded, and the user's settings of it are put back, when komorebi stops using it or exits | framework path: the effect's state unloads what komorebi loaded, and [`Kwinrc`] puts the group back | `one_group_can_be_put_back_while_the_others_stay_changed`, `vm-look` | `SIGKILL`: the next run puts the settings back when it stops |
|
||||
| Queries never block on the compositor | convention only | none | the KWin backend's `cursor_pos` waits up to 250 ms |
|
||||
| Only the backend module reaches the compositor | convention only | none | none |
|
||||
@@ -1202,7 +1229,9 @@ A window is shown, and ends up on a tile:
|
||||
[`komorebi/tests/animation.rs`](../../komorebi/tests/animation.rs), the messages that set the
|
||||
animation, [`komorebi/tests/animation_config.rs`](../../komorebi/tests/animation_config.rs), its
|
||||
key of the file, and [`komorebi/tests/animation_stack.rs`](../../komorebi/tests/animation_stack.rs),
|
||||
the stack commands that turn it off; [`komorebi/tests/border_colours.rs`](../../komorebi/tests/border_colours.rs) and
|
||||
the stack commands that turn it off; [`komorebi/tests/transparency.rs`](../../komorebi/tests/transparency.rs)
|
||||
and [`komorebi/tests/transparency_config.rs`](../../komorebi/tests/transparency_config.rs),
|
||||
transparency and its keys of the file; [`komorebi/tests/border_colours.rs`](../../komorebi/tests/border_colours.rs) and
|
||||
[`komorebi/tests/borders_off.rs`](../../komorebi/tests/borders_off.rs), the color of each
|
||||
window's border, and none with borders off;
|
||||
[`nix/tests/vm/suites/look`](../../nix/tests/vm/suites/look/test.py), the border in a real
|
||||
@@ -1293,6 +1322,12 @@ A window is shown, and ends up on a tile:
|
||||
[`border_manager::send_notification`]: ../../komorebi/src/border_manager/mod.rs
|
||||
[`BORDER_DRAWN`]: ../../komorebi/src/border_manager/mod.rs
|
||||
[`animation`]: ../../komorebi/src/animation/mod.rs
|
||||
[`transparency_manager`]: ../../komorebi/src/transparency_manager.rs
|
||||
[`transparency_manager::apply`]: ../../komorebi/src/transparency_manager.rs
|
||||
[`transparency_manager::transparent_windows`]: ../../komorebi/src/transparency_manager.rs
|
||||
[`transparency_manager::restore`]: ../../komorebi/src/transparency_manager.rs
|
||||
[`Backend::set_opacity`]: ../../komorebi/src/backend/mod.rs
|
||||
[`WindowManager::opacity_applied`]: ../../komorebi/src/window_manager.rs
|
||||
[`animation::movement_animation`]: ../../komorebi/src/animation/mod.rs
|
||||
[`animation::movement_style`]: ../../komorebi/src/animation/mod.rs
|
||||
[`AnimationStyle::qt_curve`]: ../../komorebi/src/core/animation.rs
|
||||
|
||||
@@ -460,6 +460,15 @@ one of Qt's curves, and is drawn as an ease out, the kind of curve a window movi
|
||||
wants. The stock Geometry Change has one curve, an exponential ease out, so komorebi's build of
|
||||
it reads a `Curve` setting ([PLATFORM.md](PLATFORM.md#the-patches)).
|
||||
|
||||
## Why does the window manager keep the opacity it gave each window?
|
||||
|
||||
So that the backend is told only what changed. `transparency_manager::apply`
|
||||
([`transparency_manager.rs`](../../komorebi/src/transparency_manager.rs)) is called after every
|
||||
event and every message, and most of them change no window's opacity: the window manager keeps
|
||||
the opacity it gave each window that is not opaque (`WindowManager::opacity_applied`), sends the
|
||||
difference, makes a window opaque again when it should no longer be see-through (and only if it is
|
||||
still there), and makes every one opaque when it stops.
|
||||
|
||||
## Why are the effects patched?
|
||||
|
||||
Because the stock effects lack what komorebi needs of them. Each patch leaves the effect
|
||||
|
||||
@@ -345,6 +345,10 @@ What the KWin scripting API offers a script, and what it does not, at time of wr
|
||||
uses, which `tsc` checks it against with ECMAScript 2016's library and nothing else. Node and
|
||||
TypeScript are needed only for those checks: in the session the bridge needs KWin alone.
|
||||
|
||||
- A window's `opacity` is a number from 0 to 1 that a script may set: `Window.opacity` is KWin's
|
||||
own property, so komorebi sets the opacity of a window by setting it, and the effect that
|
||||
draws the border has to draw the window again when it changes
|
||||
([The patches](#the-patches)).
|
||||
- `callDBus` sends a JavaScript number as a 32-bit integer, and a call whose arguments do not
|
||||
match the method's signature fails without a word. The bridge sends every argument as a
|
||||
JSON string.
|
||||
|
||||
+4
-2
@@ -59,8 +59,10 @@ explains the files of rules for particular applications it can name.
|
||||
[Quickstart and autostart](usage/quickstart-and-autostart.md) explains how to write an example
|
||||
configuration, how to start komorebi with Plasma without the module, and how to replace the
|
||||
configuration of a running daemon.
|
||||
[Borders](usage/borders.md) explains how komorebi has KWin draw a border around each window, and
|
||||
[Animation](usage/animation.md) how it has KWin animate the windows going to their places.
|
||||
[Borders](usage/borders.md) explains how komorebi has KWin draw a border around each window,
|
||||
[Animation](usage/animation.md) how it has KWin animate the windows going to their places, and
|
||||
[Transparency](usage/transparency.md) how it makes the windows that do not have the focus
|
||||
see-through.
|
||||
[Subscribing to notifications](usage/subscribing-to-notifications.md) explains how a program
|
||||
such as a status bar follows what komorebi does. The [CLI reference](cli/start.md) has a page
|
||||
for every `komorebic` command, generated from its help.
|
||||
|
||||
@@ -120,6 +120,17 @@ runs.
|
||||
settings as they are, and one that has it and leaves out `duration` or `style` leaves that one as it
|
||||
is; a value given for every kind of animation takes the settings of single kinds away.
|
||||
|
||||
### Transparency
|
||||
|
||||
| Key | Default | What it does |
|
||||
|---|---|---|
|
||||
| `transparency` | `false` | Whether the windows that do not have the focus are see-through |
|
||||
| `transparency_alpha` | `200` | How opaque they are, from 0 to 255 |
|
||||
| `transparency_ignore_rules` | none | Rules for the windows that are never see-through |
|
||||
|
||||
[Transparency](transparency.md) explains which windows are see-through. `transparency_ignore_rules`
|
||||
is a list of rules, which [Rules](#rules) describes, and has no command.
|
||||
|
||||
### Rules
|
||||
|
||||
| Key | What it does |
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
# Transparency
|
||||
|
||||
komorebi can make the windows that do not have the focus see-through, so that the one you are
|
||||
working in stands out. It does not draw anything itself: the opacity of a window is a property
|
||||
KWin has, which komorebi sets. Transparency is off by default.
|
||||
|
||||
## Turning it on
|
||||
|
||||
[`komorebic transparency`](../cli/transparency.md) turns transparency on or off,
|
||||
[`komorebic toggle-transparency`](../cli/toggle-transparency.md) switches it, and
|
||||
[`komorebic transparency-alpha`](../cli/transparency-alpha.md) sets how opaque a see-through window
|
||||
is, from 0 (not there at all) to 255 (not see-through): 200 by default.
|
||||
|
||||
```sh
|
||||
komorebic transparency enable
|
||||
komorebic transparency-alpha 150
|
||||
komorebic toggle-transparency
|
||||
```
|
||||
|
||||
## In komorebi.json
|
||||
|
||||
The same settings are keys of [`komorebi.json`](configuration.md#transparency): `transparency`,
|
||||
`transparency_alpha` and `transparency_ignore_rules`, a list of rules, as [Rules](rules.md)
|
||||
explains them, for the windows that are never see-through.
|
||||
|
||||
```json
|
||||
{
|
||||
"transparency": true,
|
||||
"transparency_alpha": 150,
|
||||
"transparency_ignore_rules": [
|
||||
{ "kind": "Exe", "id": "mpv", "matching_strategy": "Equals" }
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
The file sets them when the daemon starts and when the file changes. A file that leaves out
|
||||
`transparency` or `transparency_alpha` has the defaults, off and 200, so a change made with a
|
||||
command does not survive the file changing. The ignore rules add up, as the other rules do.
|
||||
|
||||
## Which windows are see-through
|
||||
|
||||
On the workspace each monitor shows, the window in front in every container is see-through unless
|
||||
its container has the focus on the focused monitor. A window on a monitor that is not the focused
|
||||
one is see-through, whatever its container. On a workspace with a monocle the monocled window is
|
||||
the only one that counts: it is opaque on the focused monitor and see-through on another. A
|
||||
workspace that does not tile has no see-through windows, and neither does a window that a rule
|
||||
keeps out of it: the rules are the `transparency_ignore_rules` of
|
||||
[`komorebi.json`](configuration.md#transparency), which no command sets.
|
||||
|
||||
Windows that are not in front, such as the other windows of a stack, are not on the screen and
|
||||
are left as they are. With transparency off, every window is opaque.
|
||||
|
||||
## What is put back
|
||||
|
||||
When komorebi exits, every window it made see-through is opaque again. A window that closes needs
|
||||
nothing.
|
||||
|
||||
## The border
|
||||
|
||||
The border effect draws a window from a texture that has the window's opacity in it. The build
|
||||
of the effect that the flake installs draws a window again when its opacity changes, so the border
|
||||
and the window change together. With the stock effect a change of opacity alone does not show
|
||||
until the window changes.
|
||||
@@ -70,6 +70,8 @@ pub enum Command {
|
||||
/// [`Backend::set_border_colours`]: the colors of each window's border, when they are not the
|
||||
/// ones given before.
|
||||
BorderColours(Vec<(u32, u32)>),
|
||||
/// [`Backend::set_opacity`]: the window, and how opaque it was asked to be.
|
||||
SetOpacity(u32, u8),
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
@@ -93,6 +95,8 @@ struct State {
|
||||
window_ws: HashMap<u32, usize>,
|
||||
/// the desktop each monitor (by id) shows
|
||||
shown: HashMap<u32, usize>,
|
||||
/// how opaque each window was last asked to be
|
||||
opacity: HashMap<u32, u8>,
|
||||
/// the border color each window was last given, `0xRRGGBB`
|
||||
border_colours: HashMap<u32, u32>,
|
||||
/// the look last applied, so that asking for it again is not a command
|
||||
@@ -368,6 +372,12 @@ impl FakeBackend {
|
||||
state.shown.insert(monitor_id, idx);
|
||||
}
|
||||
|
||||
/// Returns how opaque the window manager last asked this window to be, 255 being not see-through
|
||||
/// at all, which is what a window is until it is asked otherwise.
|
||||
pub fn opacity_of(&self, id: u32) -> u8 {
|
||||
self.state.lock().opacity.get(&id).copied().unwrap_or(255)
|
||||
}
|
||||
|
||||
/// Returns the border color the window manager last gave this window, `0xRRGGBB`, if it gave
|
||||
/// it one.
|
||||
pub fn border_colour_of(&self, id: u32) -> Option<u32> {
|
||||
@@ -604,6 +614,12 @@ impl Backend for FakeBackend {
|
||||
Ok(state.borders_drawn && look.border.is_some())
|
||||
}
|
||||
|
||||
fn set_opacity(&self, id: u32, alpha: u8) -> eyre::Result<()> {
|
||||
self.record(id, Command::SetOpacity(id, alpha), |state| {
|
||||
state.opacity.insert(id, alpha);
|
||||
})
|
||||
}
|
||||
|
||||
fn set_border_colours(&self, colours: &[(u32, u32)]) -> eyre::Result<bool> {
|
||||
let mut state = self.state.lock();
|
||||
let colours_now: HashMap<u32, u32> = colours.iter().copied().collect();
|
||||
@@ -945,6 +961,19 @@ mod tests {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_window_is_opaque_until_it_is_asked_to_be_otherwise() -> eyre::Result<()> {
|
||||
let fake = fake_with(&[1]);
|
||||
assert_eq!(fake.opacity_of(1), 255);
|
||||
|
||||
fake.set_opacity(1, 100)?;
|
||||
|
||||
assert_eq!(fake.opacity_of(1), 100);
|
||||
assert_eq!(fake.commands(), [Command::SetOpacity(1, 100)]);
|
||||
assert!(fake.set_opacity(9, 100).is_err());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn window_commands_leave_out_the_look() -> eyre::Result<()> {
|
||||
let fake = fake_with(&[1]);
|
||||
|
||||
@@ -442,6 +442,31 @@ pub trait Backend: Send + Sync + 'static {
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
/// Asks the compositor to draw the window with this opacity: 255 is not see-through at all.
|
||||
/// The default does nothing.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// When the window does not exist or is no longer alive.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// use komorebi::backend::Backend;
|
||||
/// use komorebi::backend::fake::FakeBackend;
|
||||
///
|
||||
/// let fake = FakeBackend::with_one_monitor();
|
||||
/// fake.open_window(7, "foot", "foot", "a terminal");
|
||||
/// assert_eq!(fake.opacity_of(7), 255);
|
||||
///
|
||||
/// fake.set_opacity(7, 150)?;
|
||||
/// assert_eq!(fake.opacity_of(7), 150);
|
||||
/// # Ok::<(), color_eyre::eyre::Report>(())
|
||||
/// ```
|
||||
fn set_opacity(&self, _id: u32, _alpha: u8) -> eyre::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// ---- provided ------------------------------------------------------------------------------
|
||||
|
||||
/// Called once as komorebi exits, after the window manager has put back what it moved, so that
|
||||
|
||||
@@ -473,6 +473,9 @@ pub enum SocketMessage {
|
||||
// WatchConfiguration(bool),
|
||||
// CompleteConfiguration,
|
||||
// AltFocusHack(bool),
|
||||
Transparency(bool),
|
||||
ToggleTransparency,
|
||||
TransparencyAlpha(u8),
|
||||
Animation(bool, Option<AnimationPrefix>),
|
||||
AnimationDuration(u64, Option<AnimationPrefix>),
|
||||
AnimationFps(u64),
|
||||
|
||||
@@ -80,9 +80,10 @@
|
||||
* What the daemon sends: the answer to `Poll` is a list of batches, each a list of commands. A
|
||||
* window command names the window by its `id`: `geo` sets its frame, `min` minimizes it (`v`) or
|
||||
* brings it back, `maximize` maximizes it (`v`) or restores it, `desktop` puts it on the desktop
|
||||
* `v` (and on no other), and `activate`, `raise` and `close` do what they say. `output_desktop`
|
||||
* shows the desktop `v` on one output, leaving the others as they are. A cursor query is
|
||||
* numbered by `token` so that its answer can be matched.
|
||||
* `v` (and on no other), `opacity` draws it with the opacity `v` (0 to 1, 1 being not see-through
|
||||
* at all), and `activate`, `raise` and `close` do what they say. `output_desktop` shows the desktop
|
||||
* `v` on one output, leaving the others as they are. A cursor query is numbered by `token` so that
|
||||
* its answer can be matched.
|
||||
*
|
||||
* @typedef {{ op: "cursor", token: number }} CursorQuery
|
||||
* @typedef {{ op: "output_desktop", output: string, v: string }} OutputDesktop
|
||||
@@ -93,7 +94,8 @@
|
||||
* @typedef {{ op: "raise", id: string }} Raise
|
||||
* @typedef {{ op: "close", id: string }} Close
|
||||
* @typedef {{ op: "desktop", id: string, v: string }} SetDesktop
|
||||
* @typedef {SetFrame | SetMinimized | SetMaximized | Activate | Raise | Close | SetDesktop} WindowCommand
|
||||
* @typedef {{ op: "opacity", id: string, v: number }} SetOpacity
|
||||
* @typedef {SetFrame | SetMinimized | SetMaximized | Activate | Raise | Close | SetDesktop | SetOpacity} WindowCommand
|
||||
* @typedef {CursorQuery | OutputDesktop | WindowCommand} Command
|
||||
* @typedef {{ batch: number, cmds: Command[] }} Batch
|
||||
*/
|
||||
@@ -470,6 +472,9 @@ function applyOne(c) {
|
||||
w.desktops = [d];
|
||||
break;
|
||||
}
|
||||
case "opacity":
|
||||
w.opacity = c.v;
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -80,6 +80,7 @@ function window({
|
||||
skipTaskbar: false,
|
||||
skipPager: false,
|
||||
skipSwitcher: false,
|
||||
opacity: 1,
|
||||
fullScreen: false,
|
||||
maximizeMode: 0,
|
||||
minSize: { width: 0, height: 0 },
|
||||
@@ -310,7 +311,7 @@ test("what the bridge sends for a session is what the daemon's tests read", () =
|
||||
// the client took the frame it was given to whole cells of its font
|
||||
terminal.frameGeometry = geometry(480.4, 270, 956, 532);
|
||||
|
||||
const [cursorQuery, windowCommands, workspaceCommands] = commands;
|
||||
const [cursorQuery, windowCommands, workspaceCommands, opacityCommand] = commands;
|
||||
assert.equal(k.events().at(-1).seq, cursorQuery.after_seq);
|
||||
k.workspace.cursorPos = { x: 1200, y: 700.5 };
|
||||
k.answer([cursorQuery.batch]);
|
||||
@@ -336,6 +337,13 @@ test("what the bridge sends for a session is what the daemon's tests read", () =
|
||||
k.workspace.setCurrentDesktopForScreen(first, DP1);
|
||||
|
||||
assert.deepStrictEqual(k.events(), events);
|
||||
|
||||
// and made see-through, which KWin does not report
|
||||
assert.equal(k.events().at(-1).seq, opacityCommand.after_seq);
|
||||
k.answer([opacityCommand.batch]);
|
||||
assert.equal(editor.opacity, 0.2);
|
||||
assert.deepStrictEqual(k.events(), events);
|
||||
|
||||
assert.deepStrictEqual(editor.frameGeometry, geometry(0, 0, 960, 1050));
|
||||
assert.equal(k.workspace.activeWindow, editor);
|
||||
assert.deepStrictEqual(k.raised, [editor]);
|
||||
@@ -577,6 +585,17 @@ test("a command for a window KWin no longer has is given back, and the rest are
|
||||
assert.deepStrictEqual(k.events().at(-1), { type: "failed", batch: 3, cmds: [gone], seq: 2 });
|
||||
});
|
||||
|
||||
test("a window is given the opacity it is asked for, and one KWin has not got is given back", () => {
|
||||
const w = window({ id: "{w}" });
|
||||
const k = kwin({ windows: [w] });
|
||||
const gone = { op: "opacity", id: "{gone}", v: 0.5 };
|
||||
|
||||
k.answer([{ batch: 2, cmds: [{ op: "opacity", id: "{w}", v: 0.8 }, gone] }]);
|
||||
|
||||
assert.equal(w.opacity, 0.8);
|
||||
assert.deepStrictEqual(k.events().at(-1), { type: "failed", batch: 2, cmds: [gone], seq: 2 });
|
||||
});
|
||||
|
||||
test("a command KWin throws on is printed and given back as failed", () => {
|
||||
const w = window({ id: "{w}" });
|
||||
const k = kwin({ windows: [w] });
|
||||
|
||||
@@ -32,5 +32,14 @@
|
||||
{"op": "output_desktop", "output": "DP-1", "v": "desktop-2"}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"after_seq": 20,
|
||||
"batch": {
|
||||
"batch": 4,
|
||||
"cmds": [
|
||||
{"op": "opacity", "id": "{0e5a1c3b-0000-4000-8000-00000000000a}", "v": 0.2}
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
Vendored
+2
@@ -74,6 +74,8 @@ interface KWinWindow {
|
||||
readonly skipPager: boolean;
|
||||
readonly skipSwitcher: boolean;
|
||||
minimized: boolean;
|
||||
/** How opaque the window is drawn, 0 to 1: 1 is not see-through at all. */
|
||||
opacity: number;
|
||||
readonly fullScreen: boolean;
|
||||
/** `KWin::MaximizeMode`: 0 restored, 1 vertically, 2 horizontally, 3 both ways. */
|
||||
readonly maximizeMode: number;
|
||||
|
||||
@@ -902,6 +902,13 @@ impl Backend for KWinBackend {
|
||||
})?
|
||||
}
|
||||
|
||||
fn set_opacity(&self, id: u32, alpha: u8) -> eyre::Result<()> {
|
||||
self.command(
|
||||
id,
|
||||
|uuid| json!({ "op": "opacity", "id": uuid, "v": f64::from(alpha) / 255.0 }),
|
||||
)
|
||||
}
|
||||
|
||||
fn set_border_colours(&self, colours: &[(u32, u32)]) -> eyre::Result<bool> {
|
||||
let shared = self.shared.clone();
|
||||
|
||||
@@ -1037,7 +1044,7 @@ mod tests {
|
||||
serde_json::from_str(include_str!("fixtures/commands.json")).unwrap();
|
||||
|
||||
// what the window manager asks of the backend, batch by batch
|
||||
let asks: [fn(&KWinBackend); 3] = [
|
||||
let asks: [fn(&KWinBackend); 4] = [
|
||||
|backend| {
|
||||
// nothing answers the query here, so the pointer is where the snapshot had it
|
||||
assert_eq!(backend.cursor_pos(), Some((481, 525)));
|
||||
@@ -1069,6 +1076,10 @@ mod tests {
|
||||
assert_eq!(backend.window_workspace(1), Some(1));
|
||||
assert_eq!(backend.current_workspaces(), [(monitor, 1)]);
|
||||
},
|
||||
|backend| {
|
||||
// 51 of 255 is a fifth
|
||||
backend.set_opacity(1, 51).unwrap();
|
||||
},
|
||||
];
|
||||
assert_eq!(asks.len(), commands.len());
|
||||
|
||||
|
||||
+5
-1
@@ -13,7 +13,8 @@
|
||||
//!
|
||||
//! On KDE Plasma the backend is [`kwin::KWinBackend`], which talks to a script it loads into KWin.
|
||||
//! The compositor also draws what the windows look like: [`border_manager`] asks the backend for
|
||||
//! the borders, and [`animation`] holds how windows are animated going to their places.
|
||||
//! the borders, [`animation`] holds how windows are animated going to their places, and
|
||||
//! [`transparency_manager`] makes the windows that do not have the focus see-through.
|
||||
//!
|
||||
//! The daemon also listens on a socket, `komorebi.sock` in [`struct@DATA_DIR`], for the messages
|
||||
//! in [`core::SocketMessage`]: [`process_command`] reads them and answers, with the window
|
||||
@@ -68,6 +69,7 @@ pub mod process_command;
|
||||
pub mod process_event;
|
||||
pub mod state;
|
||||
pub mod static_config;
|
||||
pub mod transparency_manager;
|
||||
pub mod window;
|
||||
pub mod window_manager;
|
||||
pub mod window_manager_event;
|
||||
@@ -151,6 +153,8 @@ lazy_static! {
|
||||
Arc::new(Mutex::new(HashMap::new()));
|
||||
/// Windows that are tiled even when an ignore rule covers them (`ManageRule`)
|
||||
static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![]));
|
||||
/// Windows that are never made see-through, whatever the rules of the transparency say
|
||||
pub static ref TRANSPARENCY_BLACKLIST: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![]));
|
||||
/// Windows that are never tiled, unless a manage rule says otherwise. Most of what would belong
|
||||
/// here (the panel, krunner, popups) is not a normal window and is filtered before rules run.
|
||||
pub static ref IGNORE_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(
|
||||
|
||||
@@ -234,10 +234,12 @@ fn main() -> eyre::Result<()> {
|
||||
|
||||
wm.lock().retile_all(false)?;
|
||||
|
||||
// and what the windows that are already there look like: their border colors
|
||||
// and what the windows that are already there look like: their border colors, how see-through
|
||||
// they are
|
||||
{
|
||||
let wm = wm.lock();
|
||||
let mut wm = wm.lock();
|
||||
border_manager::update_colours(&wm);
|
||||
komorebi::transparency_manager::apply(&mut wm);
|
||||
}
|
||||
|
||||
listen_for_commands(wm.clone());
|
||||
@@ -256,6 +258,7 @@ fn main() -> eyre::Result<()> {
|
||||
{
|
||||
let mut wm = wm.lock();
|
||||
wm.restore_all_windows(false)?;
|
||||
komorebi::transparency_manager::restore(&mut wm);
|
||||
}
|
||||
backend::backend().shutdown();
|
||||
|
||||
|
||||
@@ -11,8 +11,8 @@
|
||||
//! - **VisibleWindows**: what the compositor says about each window that can be seen on the
|
||||
//! workspace each monitor shows, by the id of the monitor, as JSON.
|
||||
//! - **Query**: one value as text, the answer to a [`StateQuery`].
|
||||
//! - **GlobalState**: the ignore and the manage rules and the data directory ([`GlobalState`]), as
|
||||
//! JSON.
|
||||
//! - **GlobalState**: the ignore and the manage rules, the transparency settings and the data
|
||||
//! directory ([`GlobalState`]), as JSON.
|
||||
//! - **SessionFloatRules**: the float rules **SessionFloatRule** added, as JSON.
|
||||
//! - **DebugWindow**: what [`Window::should_manage`] read of a window and which rules matched it
|
||||
//! ([`RuleDebug`]), as JSON, or nothing for a window that is not there.
|
||||
@@ -182,6 +182,10 @@
|
||||
//! handled. **BorderColour** sets the color of the border of one kind of window
|
||||
//! ([`WindowKind`]), and every message, once handled, tells the backend the color of each
|
||||
//! window's border ([`border_manager::update_colours`]).
|
||||
//! - **Transparency** and **ToggleTransparency** set whether the windows that do not have the
|
||||
//! focus are see-through, and **TransparencyAlpha** how opaque they are, 0 to 255; every message,
|
||||
//! once handled, has [`transparency_manager::apply`] make the windows as see-through as that
|
||||
//! says.
|
||||
//! - **Animation** sets whether windows are animated going to their places, **AnimationDuration**
|
||||
//! for how long, **AnimationStyle** the easing curve, and **AnimationFps** the frame rate that is
|
||||
//! stored and has nothing to map to (the compositor animates at the refresh rate of the
|
||||
@@ -240,6 +244,7 @@ use crate::notify_subscribers;
|
||||
use crate::state::GlobalState;
|
||||
use crate::state::State;
|
||||
use crate::static_config::StaticConfig;
|
||||
use crate::transparency_manager;
|
||||
use crate::window::RuleDebug;
|
||||
use crate::window::Window;
|
||||
use crate::window_manager::WindowManager;
|
||||
@@ -1971,6 +1976,16 @@ impl WindowManager {
|
||||
border_manager::destroy_all_borders()?;
|
||||
}
|
||||
}
|
||||
SocketMessage::Transparency(enable) => {
|
||||
transparency_manager::TRANSPARENCY_ENABLED.store(enable, Ordering::SeqCst);
|
||||
}
|
||||
SocketMessage::ToggleTransparency => {
|
||||
let current = transparency_manager::TRANSPARENCY_ENABLED.load(Ordering::SeqCst);
|
||||
transparency_manager::TRANSPARENCY_ENABLED.store(!current, Ordering::SeqCst);
|
||||
}
|
||||
SocketMessage::TransparencyAlpha(alpha) => {
|
||||
transparency_manager::TRANSPARENCY_ALPHA.store(alpha, Ordering::SeqCst);
|
||||
}
|
||||
SocketMessage::BorderColour(kind, r, g, b) => match kind {
|
||||
WindowKind::Single => {
|
||||
border_manager::FOCUSED.store(border_manager::pack(r, g, b), Ordering::SeqCst);
|
||||
@@ -2050,6 +2065,7 @@ impl WindowManager {
|
||||
|
||||
border_manager::send_notification();
|
||||
border_manager::update_colours(self);
|
||||
transparency_manager::apply(self);
|
||||
|
||||
tracing::info!("processed command: {message}");
|
||||
|
||||
|
||||
@@ -50,7 +50,8 @@
|
||||
//! Once an event about a managed window has been handled, every subscriber is sent a notification
|
||||
//! of it ([`notify_subscribers`]), the backend is asked for the look again
|
||||
//! ([`border_manager::send_notification`]), which it does nothing about unless a setting changed,
|
||||
//! and told the color of each window's border ([`border_manager::update_colours`]).
|
||||
//! told the color of each window's border ([`border_manager::update_colours`]), and the windows are
|
||||
//! made as see-through as the settings say ([`transparency_manager::apply`]).
|
||||
//!
|
||||
//! [`Window::should_manage`]: crate::window::Window::should_manage
|
||||
//! [`Monitor::assign_windows_to_workspaces`]: crate::monitor::Monitor::assign_windows_to_workspaces
|
||||
@@ -68,6 +69,7 @@ use crate::core::Layout;
|
||||
use crate::core::WindowContainerBehaviour;
|
||||
use crate::notify_subscribers;
|
||||
use crate::state::State;
|
||||
use crate::transparency_manager;
|
||||
use crate::window::RuleDebug;
|
||||
use crate::window::should_act;
|
||||
use crate::window_manager::WindowManager;
|
||||
@@ -145,6 +147,7 @@ impl WindowManager {
|
||||
// other windows are in view
|
||||
border_manager::send_notification();
|
||||
border_manager::update_colours(self);
|
||||
transparency_manager::apply(self);
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -517,6 +520,7 @@ impl WindowManager {
|
||||
|
||||
border_manager::send_notification();
|
||||
border_manager::update_colours(self);
|
||||
transparency_manager::apply(self);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
+19
-4
@@ -5,8 +5,8 @@
|
||||
//! subscribers in every [`Notification`]. [`State::has_been_modified`] decides whether an event or
|
||||
//! a message changed it, for the subscribers that want a notification only then.
|
||||
//!
|
||||
//! [`GlobalState`] is what the daemon has besides the window manager, the rules and the data
|
||||
//! directory, which it writes in answer to `GlobalState`.
|
||||
//! [`GlobalState`] is what the daemon has besides the window manager, the rules, the transparency
|
||||
//! and the data directory, which it writes in answer to `GlobalState`.
|
||||
//!
|
||||
//! [`SocketMessage::State`]: crate::core::SocketMessage::State
|
||||
//! [`Notification`]: crate::Notification
|
||||
@@ -16,6 +16,7 @@ use crate::DISPLAY_INDEX_PREFERENCES;
|
||||
use crate::HOME_DIR;
|
||||
use crate::IGNORE_IDENTIFIERS;
|
||||
use crate::MANAGE_IDENTIFIERS;
|
||||
use crate::TRANSPARENCY_BLACKLIST;
|
||||
use crate::WORKSPACE_MATCHING_RULES;
|
||||
use crate::core::MonocleFocusBehaviour;
|
||||
use crate::core::MoveBehaviour;
|
||||
@@ -36,8 +37,8 @@ use std::path::PathBuf;
|
||||
|
||||
/// What the daemon has that is not part of the window manager, as it answers
|
||||
/// [`SocketMessage::GlobalState`](crate::core::SocketMessage::GlobalState): the ignore and the manage
|
||||
/// rules, the indices the user gave the monitors, the workspace rules, and the configuration and
|
||||
/// the data directories
|
||||
/// rules, what the transparency is, the indices the user gave the monitors, the workspace rules,
|
||||
/// and the configuration and the data directories
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
@@ -49,6 +50,9 @@ use std::path::PathBuf;
|
||||
/// let json = serde_json::to_string(&state.ignore_identifiers)?;
|
||||
/// assert!(json.contains(r#""id":"org.kde.plasmashell""#), "{json}");
|
||||
/// assert!(state.manage_identifiers.is_empty());
|
||||
/// // nothing is see-through until it is asked for
|
||||
/// assert!(!state.transparency_enabled);
|
||||
/// assert_eq!(state.transparency_alpha, 200);
|
||||
/// assert!(state.display_index_preferences.is_empty());
|
||||
/// assert!(state.workspace_rules.is_empty());
|
||||
/// assert_eq!(state.configuration_dir, *komorebi::HOME_DIR);
|
||||
@@ -72,6 +76,12 @@ pub struct GlobalState {
|
||||
// pub stackbar_tab_width: i32,
|
||||
// pub stackbar_height: i32,
|
||||
// pub remove_titlebars: bool,
|
||||
/// Whether the windows that do not have the focus are see-through
|
||||
pub transparency_enabled: bool,
|
||||
/// How opaque a see-through window is, from 0 to 255
|
||||
pub transparency_alpha: u8,
|
||||
/// The rules for the windows that are never see-through
|
||||
pub transparency_blacklist: Vec<MatchingRule>,
|
||||
// #[serde(alias = "float_identifiers")]
|
||||
pub ignore_identifiers: Vec<MatchingRule>,
|
||||
pub manage_identifiers: Vec<MatchingRule>,
|
||||
@@ -91,6 +101,11 @@ pub struct GlobalState {
|
||||
impl Default for GlobalState {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
transparency_enabled: crate::transparency_manager::TRANSPARENCY_ENABLED
|
||||
.load(std::sync::atomic::Ordering::SeqCst),
|
||||
transparency_alpha: crate::transparency_manager::TRANSPARENCY_ALPHA
|
||||
.load(std::sync::atomic::Ordering::SeqCst),
|
||||
transparency_blacklist: TRANSPARENCY_BLACKLIST.lock().clone(),
|
||||
ignore_identifiers: IGNORE_IDENTIFIERS.lock().clone(),
|
||||
manage_identifiers: MANAGE_IDENTIFIERS.lock().clone(),
|
||||
display_index_preferences: DISPLAY_INDEX_PREFERENCES.read().clone(),
|
||||
|
||||
@@ -36,6 +36,7 @@ use crate::IGNORE_IDENTIFIERS;
|
||||
use crate::LAYOUT_DEFAULTS;
|
||||
use crate::MANAGE_IDENTIFIERS;
|
||||
use crate::REGEX_IDENTIFIERS;
|
||||
use crate::TRANSPARENCY_BLACKLIST;
|
||||
use crate::WORKSPACE_MATCHING_RULES;
|
||||
use crate::animation::ANIMATION_DURATION_GLOBAL;
|
||||
use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
|
||||
@@ -72,6 +73,7 @@ use crate::core::config_generation::WorkspaceMatchingRule;
|
||||
use crate::core::pathext::ResolvedPathBuf;
|
||||
use crate::monitor::Monitor;
|
||||
use crate::ring::Ring;
|
||||
use crate::transparency_manager;
|
||||
use crate::window::AspectRatio;
|
||||
use crate::window::PredefinedAspectRatio;
|
||||
use crate::window_manager::WindowManager;
|
||||
@@ -444,6 +446,15 @@ pub struct StaticConfig {
|
||||
// /// Active window border implementation (default: Komorebi)
|
||||
// #[serde(skip_serializing_if = "Option::is_none")]
|
||||
// pub border_implementation: Option<BorderImplementation>,
|
||||
/// Add transparency to unfocused windows (default: false)
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub transparency: Option<bool>,
|
||||
/// Alpha value for unfocused window transparency [[0-255]] (default: 200)
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub transparency_alpha: Option<u8>,
|
||||
/// Individual window transparency ignore rules
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub transparency_ignore_rules: Option<Vec<MatchingRule>>,
|
||||
/// Global default workspace padding
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
#[cfg_attr(feature = "schemars", schemars(extend("default" = DEFAULT_WORKSPACE_PADDING)))]
|
||||
@@ -624,6 +635,13 @@ impl From<&WindowManager> for StaticConfig {
|
||||
border_offset: Option::from(border_manager::BORDER_OFFSET.load(Ordering::SeqCst)),
|
||||
border_radius: Option::from(border_manager::BORDER_RADIUS.load(Ordering::SeqCst)),
|
||||
border: Option::from(border_manager::BORDER_ENABLED.load(Ordering::SeqCst)),
|
||||
transparency: Option::from(
|
||||
transparency_manager::TRANSPARENCY_ENABLED.load(Ordering::SeqCst),
|
||||
),
|
||||
transparency_alpha: Option::from(
|
||||
transparency_manager::TRANSPARENCY_ALPHA.load(Ordering::SeqCst),
|
||||
),
|
||||
transparency_ignore_rules: None,
|
||||
// border_style: Option::from(STYLE.load()),
|
||||
// border_z_order: None,
|
||||
// border_implementation: Option::from(IMPLEMENTATION.load()),
|
||||
@@ -796,6 +814,11 @@ impl StaticConfig {
|
||||
// border_manager::send_notification(None);
|
||||
// }
|
||||
//
|
||||
transparency_manager::TRANSPARENCY_ENABLED
|
||||
.store(self.transparency.unwrap_or(false), Ordering::SeqCst);
|
||||
transparency_manager::TRANSPARENCY_ALPHA
|
||||
.store(self.transparency_alpha.unwrap_or(200), Ordering::SeqCst);
|
||||
|
||||
let mut ignore_identifiers = IGNORE_IDENTIFIERS.lock();
|
||||
let mut regex_identifiers = REGEX_IDENTIFIERS.lock();
|
||||
let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
|
||||
@@ -803,6 +826,7 @@ impl StaticConfig {
|
||||
// let mut object_name_change_identifiers = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
|
||||
// let mut object_name_change_title_ignore_list = OBJECT_NAME_CHANGE_TITLE_IGNORE_LIST.lock();
|
||||
// let mut layered_identifiers = LAYERED_WHITELIST.lock();
|
||||
let mut transparency_blacklist = TRANSPARENCY_BLACKLIST.lock();
|
||||
// let mut slow_application_identifiers = SLOW_APPLICATION_IDENTIFIERS.lock();
|
||||
let mut floating_applications = FLOATING_APPLICATIONS.lock();
|
||||
// let mut no_titlebar_applications = NO_TITLEBAR.lock();
|
||||
@@ -857,6 +881,10 @@ impl StaticConfig {
|
||||
// )?;
|
||||
// }
|
||||
//
|
||||
if let Some(rules) = &mut self.transparency_ignore_rules {
|
||||
populate_rules(rules, &mut transparency_blacklist, &mut regex_identifiers)?;
|
||||
}
|
||||
//
|
||||
// if let Some(rules) = &mut self.slow_application_identifiers {
|
||||
// populate_rules(
|
||||
// rules,
|
||||
@@ -1055,6 +1083,7 @@ impl StaticConfig {
|
||||
.unmanaged_window_operation_behaviour
|
||||
.unwrap_or(OperationBehaviour::Op),
|
||||
resize_delta: value.resize_delta.unwrap_or(DEFAULT_RESIZE_DELTA),
|
||||
opacity_applied: HashMap::new(),
|
||||
mouse_follows_focus: value
|
||||
.mouse_follows_focus
|
||||
.unwrap_or(DEFAULT_MOUSE_FOLLOWS_FOCUS),
|
||||
|
||||
@@ -0,0 +1,153 @@
|
||||
//! Transparency for the windows that do not have the focus (`transparency`, `transparency_alpha`,
|
||||
//! `transparency_ignore_rules`, `komorebic transparency`).
|
||||
//!
|
||||
//! komorebi decides which windows are see-through, and the compositor draws them so: the opacity
|
||||
//! of a window is a property of KWin's, which the backend sets. [`apply`] is called whenever
|
||||
//! anything could have changed, and sends only what differs from what it sent before.
|
||||
//!
|
||||
//! The rules, on the workspace each monitor shows: the focused window of every container is
|
||||
//! see-through unless the container has the focus on the focused monitor; a monocled window is
|
||||
//! opaque, unless it is on a monitor that is not the focused one; a workspace that does not tile
|
||||
//! has no transparent windows; ignored windows never are. These are the rules of komorebi for
|
||||
//! Windows, where the settings come from.
|
||||
|
||||
use crate::REGEX_IDENTIFIERS;
|
||||
use crate::TRANSPARENCY_BLACKLIST;
|
||||
use crate::backend::backend;
|
||||
use crate::window::Window;
|
||||
use crate::window::should_act;
|
||||
use crate::window_manager::WindowManager;
|
||||
use std::collections::HashSet;
|
||||
use std::sync::atomic::AtomicBool;
|
||||
use std::sync::atomic::AtomicU8;
|
||||
use std::sync::atomic::Ordering;
|
||||
|
||||
pub static TRANSPARENCY_ENABLED: AtomicBool = AtomicBool::new(false);
|
||||
pub static TRANSPARENCY_ALPHA: AtomicU8 = AtomicU8::new(200);
|
||||
|
||||
/// The opacity of a window that is not see-through at all.
|
||||
const OPAQUE: u8 = 255;
|
||||
|
||||
/// Returns true if and only if `transparency_ignore_rules` match the window. A window whose title,
|
||||
/// executable, class or path cannot be read is not ignored.
|
||||
fn ignored(window: Window) -> bool {
|
||||
let blacklist = TRANSPARENCY_BLACKLIST.lock();
|
||||
if blacklist.is_empty() {
|
||||
return false;
|
||||
}
|
||||
|
||||
let (Some(title), Some(exe), Some(class), Some(path)) =
|
||||
(window.title(), window.exe(), window.class(), window.path())
|
||||
else {
|
||||
return false;
|
||||
};
|
||||
|
||||
let regex_identifiers = REGEX_IDENTIFIERS.lock();
|
||||
should_act(
|
||||
&title,
|
||||
&exe,
|
||||
&[class.as_str()],
|
||||
&path.to_string_lossy(),
|
||||
&blacklist,
|
||||
®ex_identifiers,
|
||||
)
|
||||
.is_some()
|
||||
}
|
||||
|
||||
/// Returns the windows that should be see-through now, by the rules in the [module docs](self),
|
||||
/// whether transparency is on or not.
|
||||
pub fn transparent_windows(wm: &WindowManager) -> Vec<u32> {
|
||||
let mut out = vec![];
|
||||
let focused_monitor_idx = wm.focused_monitor_idx();
|
||||
|
||||
for (monitor_idx, monitor) in wm.monitors().iter().enumerate() {
|
||||
let on_focused_monitor = monitor_idx == focused_monitor_idx;
|
||||
|
||||
// only what each monitor shows; the rest is not on screen
|
||||
let Some(workspace) = monitor.focused_workspace() else {
|
||||
continue;
|
||||
};
|
||||
|
||||
if !workspace.tile {
|
||||
continue;
|
||||
}
|
||||
|
||||
if let Some(monocle) = &workspace.monocle_container {
|
||||
if !on_focused_monitor
|
||||
&& let Some(window) = monocle.focused_window()
|
||||
&& !ignored(*window)
|
||||
{
|
||||
out.push(window.id);
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
for (idx, container) in workspace.containers().iter().enumerate() {
|
||||
if on_focused_monitor && idx == workspace.focused_container_idx() {
|
||||
continue;
|
||||
}
|
||||
|
||||
if let Some(window) = container.focused_window()
|
||||
&& !ignored(*window)
|
||||
{
|
||||
out.push(window.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
out
|
||||
}
|
||||
|
||||
/// Makes the windows as see-through as the settings and the state of the window manager say.
|
||||
///
|
||||
/// The backend is told only what differs from what it was last told, which the window manager
|
||||
/// keeps in [`WindowManager::opacity_applied`]: windows that should not be see-through any more
|
||||
/// are made opaque, and the others are given [`TRANSPARENCY_ALPHA`]. With transparency off, every
|
||||
/// window is opaque. A failure is logged.
|
||||
pub fn apply(wm: &mut WindowManager) {
|
||||
let alpha = TRANSPARENCY_ALPHA.load(Ordering::SeqCst);
|
||||
let wanted: HashSet<u32> = if TRANSPARENCY_ENABLED.load(Ordering::SeqCst) {
|
||||
transparent_windows(wm).into_iter().collect()
|
||||
} else {
|
||||
HashSet::new()
|
||||
};
|
||||
|
||||
// opaque again: everything that was see-through and should not be any more
|
||||
let no_longer: Vec<u32> = wm
|
||||
.opacity_applied
|
||||
.keys()
|
||||
.filter(|id| !wanted.contains(id))
|
||||
.copied()
|
||||
.collect();
|
||||
for id in no_longer {
|
||||
if backend().is_window(id)
|
||||
&& let Err(error) = backend().set_opacity(id, OPAQUE)
|
||||
{
|
||||
tracing::warn!("could not make window {id} opaque: {error}");
|
||||
}
|
||||
wm.opacity_applied.remove(&id);
|
||||
}
|
||||
|
||||
for id in wanted {
|
||||
if wm.opacity_applied.get(&id) == Some(&alpha) {
|
||||
continue;
|
||||
}
|
||||
|
||||
match backend().set_opacity(id, alpha) {
|
||||
Ok(()) => {
|
||||
wm.opacity_applied.insert(id, alpha);
|
||||
}
|
||||
Err(error) => tracing::warn!("could not make window {id} transparent: {error}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Makes every window komorebi made see-through opaque again, when komorebi exits.
|
||||
pub fn restore(wm: &mut WindowManager) {
|
||||
for (id, _) in wm.opacity_applied.drain() {
|
||||
if backend().is_window(id) {
|
||||
let _ = backend().set_opacity(id, OPAQUE);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -195,6 +195,11 @@ impl Window {
|
||||
backend().set_rect(self.id, rect)
|
||||
}
|
||||
|
||||
/// Asks the compositor to draw the window with this opacity, 255 being not see-through at all
|
||||
pub fn set_opacity(self, alpha: u8) -> eyre::Result<()> {
|
||||
backend().set_opacity(self.id, alpha)
|
||||
}
|
||||
|
||||
pub fn focus(self, mouse_follows_focus: bool) -> eyre::Result<()> {
|
||||
backend().focus(self.id, mouse_follows_focus)
|
||||
}
|
||||
|
||||
@@ -138,6 +138,9 @@ pub struct WindowManager {
|
||||
pub monocle_focus_behaviour: MonocleFocusBehaviour,
|
||||
/// Whether the pointer is moved to the window that is given the focus, which is the default
|
||||
pub mouse_follows_focus: bool,
|
||||
/// The opacity each window was last given by [`crate::transparency_manager`], for the ones that
|
||||
/// are not opaque
|
||||
pub opacity_applied: HashMap<u32, u8>,
|
||||
pub work_area_offset: Option<Rect>,
|
||||
/// The events the backend has reported and the window manager has yet to handle, from
|
||||
/// [`crate::window_manager_event_listener`]
|
||||
@@ -227,6 +230,7 @@ impl WindowManager {
|
||||
cross_monitor_move_behaviour: Default::default(),
|
||||
cross_boundary_behaviour: Default::default(),
|
||||
monocle_focus_behaviour: MonocleFocusBehaviour::default(),
|
||||
opacity_applied: HashMap::new(),
|
||||
mouse_follows_focus: true,
|
||||
work_area_offset: None,
|
||||
incoming_events: incoming,
|
||||
@@ -1307,10 +1311,11 @@ impl WindowManager {
|
||||
}
|
||||
|
||||
/// Stops the daemon: brings back the windows it has hidden, unless `ignore_restore` is set
|
||||
/// ([`WindowManager::restore_all_windows`]), connects to every subscriber and closes the
|
||||
/// connection without writing anything, removes the command socket, lets the backend give up
|
||||
/// what it set up in the compositor (the desktop hidden windows are parked on), and exits the
|
||||
/// process with status 0
|
||||
/// ([`WindowManager::restore_all_windows`]), makes every window komorebi made see-through
|
||||
/// opaque again ([`crate::transparency_manager::restore`]), connects to every subscriber and
|
||||
/// closes the connection without writing anything, removes the command socket, lets the
|
||||
/// backend give up what it set up in the compositor (the desktop hidden windows are parked
|
||||
/// on), and exits the process with status 0
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
@@ -1323,6 +1328,8 @@ impl WindowManager {
|
||||
|
||||
self.restore_all_windows(ignore_restore)?;
|
||||
|
||||
crate::transparency_manager::restore(self);
|
||||
|
||||
let sockets = SUBSCRIPTION_SOCKETS.lock();
|
||||
for path in (*sockets).values() {
|
||||
if let Ok(stream) = UnixStream::connect(path) {
|
||||
|
||||
@@ -45,10 +45,6 @@ const WINDOWS_ONLY: &[&str] = &[
|
||||
const NOT_YET: &[&str] = &[
|
||||
// a color for each kind of window's border, whose type is komorebi-themes' (49)
|
||||
"border_colours",
|
||||
// transparency (47)
|
||||
"transparency",
|
||||
"transparency_alpha",
|
||||
"transparency_ignore_rules",
|
||||
// focus follows mouse (48)
|
||||
"focus_follows_mouse",
|
||||
// themes (49)
|
||||
|
||||
@@ -0,0 +1,185 @@
|
||||
//! Transparency for the windows that do not have focus, against an in-memory desktop.
|
||||
//!
|
||||
//! Window ids are in the 30_000s; the transparency settings and the rule tables are process-wide,
|
||||
//! so the tests take turns.
|
||||
|
||||
use komorebi::TRANSPARENCY_BLACKLIST;
|
||||
use komorebi::backend::fake::FakeBackend;
|
||||
use komorebi::backend::with_backend;
|
||||
use komorebi::core::ApplicationIdentifier;
|
||||
use komorebi::core::SocketMessage;
|
||||
use komorebi::core::config_generation::IdWithIdentifier;
|
||||
use komorebi::core::config_generation::MatchingRule;
|
||||
use komorebi::core::config_generation::MatchingStrategy;
|
||||
use komorebi::state::GlobalState;
|
||||
use komorebi::transparency_manager;
|
||||
use komorebi::transparency_manager::TRANSPARENCY_ALPHA;
|
||||
use komorebi::transparency_manager::TRANSPARENCY_ENABLED;
|
||||
use komorebi::window::Window;
|
||||
use komorebi::window_manager::WindowManager;
|
||||
use komorebi::window_manager_event::KWinNotification;
|
||||
use komorebi::window_manager_event::SystemNotification;
|
||||
use komorebi::window_manager_event::WindowManagerEvent;
|
||||
use std::sync::Arc;
|
||||
|
||||
fn added(id: u32) -> WindowManagerEvent {
|
||||
WindowManagerEvent::Show(
|
||||
SystemNotification::KWin(KWinNotification::WindowAdded),
|
||||
Window::from(id),
|
||||
)
|
||||
}
|
||||
|
||||
fn focused(id: u32) -> WindowManagerEvent {
|
||||
WindowManagerEvent::FocusChange(
|
||||
SystemNotification::KWin(KWinNotification::WindowActivated),
|
||||
Window::from(id),
|
||||
)
|
||||
}
|
||||
|
||||
fn desktop() -> (Arc<FakeBackend>, WindowManager) {
|
||||
let fake = Arc::new(FakeBackend::with_one_monitor());
|
||||
let (_sender, receiver) = crossbeam_channel::bounded(1);
|
||||
static NEXT: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
|
||||
let socket = std::path::PathBuf::from(format!(
|
||||
"/tmp/kmf-{}-{}.sock",
|
||||
std::process::id(),
|
||||
NEXT.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
|
||||
));
|
||||
|
||||
let wm = with_backend(fake.clone(), || {
|
||||
let mut wm = WindowManager::new(receiver, Some(socket)).unwrap();
|
||||
wm.init().unwrap();
|
||||
wm
|
||||
});
|
||||
|
||||
(fake, wm)
|
||||
}
|
||||
|
||||
fn tiled(first: u32, count: u32) -> (Arc<FakeBackend>, WindowManager) {
|
||||
let (fake, mut wm) = desktop();
|
||||
with_backend(fake.clone(), || {
|
||||
for id in first..first + count {
|
||||
fake.open_window(id, "foot", "foot", &format!("terminal {id}"));
|
||||
wm.process_event(added(id)).unwrap();
|
||||
}
|
||||
});
|
||||
(fake, wm)
|
||||
}
|
||||
|
||||
fn command(fake: &Arc<FakeBackend>, wm: &mut WindowManager, message: SocketMessage) {
|
||||
with_backend(fake.clone(), || wm.process_command(message, Vec::new())).unwrap();
|
||||
}
|
||||
|
||||
static TRANSPARENCY: std::sync::Mutex<()> = std::sync::Mutex::new(());
|
||||
|
||||
/// The settings are process-wide, as they are on Windows: one test at a time, from the defaults
|
||||
fn transparency_settings() -> std::sync::MutexGuard<'static, ()> {
|
||||
let guard = TRANSPARENCY.lock().unwrap_or_else(|e| e.into_inner());
|
||||
TRANSPARENCY_ENABLED.store(false, std::sync::atomic::Ordering::SeqCst);
|
||||
TRANSPARENCY_ALPHA.store(200, std::sync::atomic::Ordering::SeqCst);
|
||||
TRANSPARENCY_BLACKLIST.lock().clear();
|
||||
guard
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unfocused_windows_are_transparent_and_the_focused_one_is_not() {
|
||||
let _settings = transparency_settings();
|
||||
let (fake, mut wm) = tiled(30_001, 3);
|
||||
command(&fake, &mut wm, SocketMessage::Transparency(true));
|
||||
command(&fake, &mut wm, SocketMessage::TransparencyAlpha(150));
|
||||
|
||||
// 30_003 is the one with focus
|
||||
assert_eq!(fake.opacity_of(30_003), 255);
|
||||
assert_eq!(fake.opacity_of(30_001), 150);
|
||||
assert_eq!(fake.opacity_of(30_002), 150);
|
||||
|
||||
// focus moves: the opacity goes with it
|
||||
with_backend(fake.clone(), || wm.process_event(focused(30_001))).unwrap();
|
||||
assert_eq!(fake.opacity_of(30_001), 255);
|
||||
assert_eq!(fake.opacity_of(30_003), 150);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn turning_transparency_off_makes_everything_opaque_again() {
|
||||
let _settings = transparency_settings();
|
||||
let (fake, mut wm) = tiled(30_011, 2);
|
||||
command(&fake, &mut wm, SocketMessage::Transparency(true));
|
||||
assert_eq!(fake.opacity_of(30_011), 200, "the default alpha");
|
||||
|
||||
command(&fake, &mut wm, SocketMessage::ToggleTransparency);
|
||||
assert_eq!(fake.opacity_of(30_011), 255);
|
||||
assert_eq!(fake.opacity_of(30_012), 255);
|
||||
|
||||
command(&fake, &mut wm, SocketMessage::ToggleTransparency);
|
||||
assert_eq!(fake.opacity_of(30_011), 200);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_monocled_window_is_not_transparent() {
|
||||
let _settings = transparency_settings();
|
||||
let (fake, mut wm) = tiled(30_021, 3);
|
||||
command(&fake, &mut wm, SocketMessage::Transparency(true));
|
||||
command(&fake, &mut wm, SocketMessage::ToggleMonocle);
|
||||
|
||||
assert_eq!(fake.opacity_of(30_023), 255, "the one filling the screen");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn windows_the_rules_ignore_keep_their_opacity() {
|
||||
let _settings = transparency_settings();
|
||||
let (fake, mut wm) = desktop();
|
||||
with_backend(fake.clone(), || {
|
||||
fake.open_window(30_031, "foot", "foot", "terminal");
|
||||
fake.open_window(30_032, "mpv", "mpv-player", "video");
|
||||
fake.open_window(30_033, "foot", "foot", "terminal 2");
|
||||
wm.process_event(added(30_031)).unwrap();
|
||||
wm.process_event(added(30_032)).unwrap();
|
||||
wm.process_event(added(30_033)).unwrap();
|
||||
});
|
||||
|
||||
TRANSPARENCY_BLACKLIST
|
||||
.lock()
|
||||
.push(MatchingRule::Simple(IdWithIdentifier {
|
||||
kind: ApplicationIdentifier::Class,
|
||||
id: String::from("mpv-player"),
|
||||
matching_strategy: Some(MatchingStrategy::Equals),
|
||||
}));
|
||||
|
||||
command(&fake, &mut wm, SocketMessage::Transparency(true));
|
||||
|
||||
assert_eq!(fake.opacity_of(30_031), 200);
|
||||
assert_eq!(
|
||||
fake.opacity_of(30_032),
|
||||
255,
|
||||
"a video player is never see-through"
|
||||
);
|
||||
|
||||
TRANSPARENCY_BLACKLIST.lock().clear();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn what_komorebi_made_see_through_is_opaque_again_when_it_exits() {
|
||||
let _settings = transparency_settings();
|
||||
let (fake, mut wm) = tiled(30_041, 2);
|
||||
command(&fake, &mut wm, SocketMessage::Transparency(true));
|
||||
assert_eq!(fake.opacity_of(30_041), 200);
|
||||
|
||||
with_backend(fake.clone(), || transparency_manager::restore(&mut wm));
|
||||
|
||||
assert_eq!(fake.opacity_of(30_041), 255);
|
||||
assert!(wm.opacity_applied.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_global_state_says_what_the_transparency_is() {
|
||||
let _settings = transparency_settings();
|
||||
let (fake, mut wm) = desktop();
|
||||
assert!(!GlobalState::default().transparency_enabled);
|
||||
|
||||
command(&fake, &mut wm, SocketMessage::Transparency(true));
|
||||
command(&fake, &mut wm, SocketMessage::TransparencyAlpha(90));
|
||||
|
||||
let state = GlobalState::default();
|
||||
assert!(state.transparency_enabled);
|
||||
assert_eq!(state.transparency_alpha, 90);
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
//! The transparency keys of `komorebi.json` are the transparency settings: the file sets them when
|
||||
//! the daemon starts and when it is read again (a message that tiles and applies the opacity), a key
|
||||
//! it leaves out has the default, the ignore rules keep windows opaque, and the settings come out
|
||||
//! again in the configuration the daemon generates.
|
||||
//!
|
||||
//! This file has one test because it changes the process-wide transparency settings, which every
|
||||
//! other test that tiles windows would see.
|
||||
|
||||
use color_eyre::eyre;
|
||||
use komorebi::backend::fake::FakeBackend;
|
||||
use komorebi::backend::with_backend;
|
||||
use komorebi::core::SocketMessage;
|
||||
use komorebi::static_config::StaticConfig;
|
||||
use komorebi::transparency_manager;
|
||||
use komorebi::window::Window;
|
||||
use komorebi::window_manager::WindowManager;
|
||||
use komorebi::window_manager_event::KWinNotification;
|
||||
use komorebi::window_manager_event::SystemNotification;
|
||||
use komorebi::window_manager_event::WindowManagerEvent;
|
||||
use parking_lot::Mutex;
|
||||
use std::os::unix::net::UnixListener;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::Ordering;
|
||||
|
||||
fn write_config(name: &str, json: &str) -> PathBuf {
|
||||
let path = PathBuf::from(format!(
|
||||
"/tmp/kmb-transp-{name}-{}.json",
|
||||
std::process::id()
|
||||
));
|
||||
std::fs::write(&path, json).unwrap();
|
||||
path
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_transparency_keys_of_the_file_are_the_transparency_settings() {
|
||||
let fake = Arc::new(FakeBackend::with_one_monitor());
|
||||
|
||||
let path = write_config(
|
||||
"on",
|
||||
r#"{
|
||||
"transparency": true,
|
||||
"transparency_alpha": 120,
|
||||
"transparency_ignore_rules": [
|
||||
{ "kind": "Exe", "id": "mpv", "matching_strategy": "Equals" }
|
||||
]
|
||||
}"#,
|
||||
);
|
||||
let (_sender, receiver) = crossbeam_channel::bounded(1);
|
||||
let socket = PathBuf::from(format!("/tmp/kmb-transp-{}.sock", std::process::id()));
|
||||
let listener = UnixListener::bind(&socket).unwrap();
|
||||
|
||||
let wm = with_backend(fake.clone(), || -> eyre::Result<WindowManager> {
|
||||
let mut wm = StaticConfig::preload(&path, receiver, Some(listener))?;
|
||||
wm.init()?;
|
||||
Ok(wm)
|
||||
})
|
||||
.unwrap();
|
||||
let wm = Arc::new(Mutex::new(wm));
|
||||
StaticConfig::postload(&path, &wm).unwrap();
|
||||
let _ = std::fs::remove_file(&socket);
|
||||
|
||||
assert!(transparency_manager::TRANSPARENCY_ENABLED.load(Ordering::SeqCst));
|
||||
assert_eq!(
|
||||
transparency_manager::TRANSPARENCY_ALPHA.load(Ordering::SeqCst),
|
||||
120
|
||||
);
|
||||
|
||||
// two windows, one of which the rules keep opaque, and the one without the focus is see-through
|
||||
with_backend(fake.clone(), || {
|
||||
for (id, exe) in [(46_001, "mpv"), (46_002, "foot"), (46_003, "foot")] {
|
||||
fake.open_window(id, exe, exe, &format!("window {id}"));
|
||||
wm.lock()
|
||||
.process_event(WindowManagerEvent::Show(
|
||||
SystemNotification::KWin(KWinNotification::WindowAdded),
|
||||
Window::from(id),
|
||||
))
|
||||
.unwrap();
|
||||
}
|
||||
});
|
||||
assert_eq!(fake.opacity_of(46_002), 120, "a window without the focus");
|
||||
assert_eq!(fake.opacity_of(46_003), 255, "the one with the focus");
|
||||
assert_eq!(fake.opacity_of(46_001), 255, "a window the rules ignore");
|
||||
|
||||
// and they come out again in the generated configuration
|
||||
let generated = StaticConfig::from(&*wm.lock());
|
||||
assert_eq!(generated.transparency, Some(true));
|
||||
assert_eq!(generated.transparency_alpha, Some(120));
|
||||
|
||||
// a file that is read again and leaves the keys out has the defaults
|
||||
let empty = write_config("empty", "{}");
|
||||
with_backend(fake.clone(), || {
|
||||
wm.lock()
|
||||
.process_command(
|
||||
SocketMessage::ReloadStaticConfiguration(empty.clone()),
|
||||
vec![],
|
||||
)
|
||||
.unwrap();
|
||||
});
|
||||
assert!(!transparency_manager::TRANSPARENCY_ENABLED.load(Ordering::SeqCst));
|
||||
assert_eq!(
|
||||
transparency_manager::TRANSPARENCY_ALPHA.load(Ordering::SeqCst),
|
||||
200
|
||||
);
|
||||
assert_eq!(fake.opacity_of(46_002), 255, "opaque again");
|
||||
|
||||
// the ignore rules add up, and are not asked again
|
||||
let more = write_config(
|
||||
"more",
|
||||
r#"{ "transparency_ignore_rules": [
|
||||
{ "kind": "Exe", "id": "mpv", "matching_strategy": "Equals" },
|
||||
{ "kind": "Class", "id": "vlc", "matching_strategy": "Equals" }
|
||||
] }"#,
|
||||
);
|
||||
with_backend(fake.clone(), || {
|
||||
wm.lock()
|
||||
.process_command(
|
||||
SocketMessage::ReloadStaticConfiguration(more.clone()),
|
||||
vec![],
|
||||
)
|
||||
.unwrap();
|
||||
});
|
||||
assert_eq!(komorebi::TRANSPARENCY_BLACKLIST.lock().len(), 2);
|
||||
|
||||
for file in [path, empty, more] {
|
||||
let _ = std::fs::remove_file(file);
|
||||
}
|
||||
}
|
||||
@@ -69,6 +69,8 @@
|
||||
//! - `border` sets whether the compositor draws a border around each window, `border-colour` the
|
||||
//! color of the border of a kind of window, and `border-width` and `border-offset` the room the
|
||||
//! layout leaves for it.
|
||||
//! - `transparency` and `toggle-transparency` set whether the windows that do not have the focus
|
||||
//! are see-through, and `transparency-alpha` how opaque they are.
|
||||
//! - `animation`, `animation-duration` and `animation-style` set whether windows are animated going
|
||||
//! to their places, for how long and with what easing, and `animation-fps` the frame rate that
|
||||
//! is stored and ignored.
|
||||
@@ -213,6 +215,7 @@ gen_enum_subcommand_args! {
|
||||
CycleLayout: CycleDirection,
|
||||
// WatchConfiguration: BooleanState,
|
||||
MouseFollowsFocus: BooleanState,
|
||||
Transparency: BooleanState,
|
||||
Query: StateQuery,
|
||||
CrossMonitorMoveBehaviour: MoveBehaviour,
|
||||
UnmanagedWindowOperationBehaviour: OperationBehaviour,
|
||||
@@ -758,6 +761,12 @@ struct BorderOffset {
|
||||
offset: i32,
|
||||
}
|
||||
|
||||
#[derive(Parser)]
|
||||
struct TransparencyAlpha {
|
||||
/// Alpha
|
||||
alpha: u8,
|
||||
}
|
||||
|
||||
#[derive(Parser)]
|
||||
struct Animation {
|
||||
#[clap(value_enum)]
|
||||
@@ -1229,6 +1238,14 @@ enum SubCommand {
|
||||
// /// Set the border implementation
|
||||
// #[clap(arg_required_else_help = true)]
|
||||
// BorderImplementation(BorderImplementation),
|
||||
/// Enable or disable transparency for unfocused windows
|
||||
#[clap(arg_required_else_help = true)]
|
||||
Transparency(Transparency),
|
||||
/// Set the alpha value for unfocused window transparency
|
||||
#[clap(arg_required_else_help = true)]
|
||||
TransparencyAlpha(TransparencyAlpha),
|
||||
/// Toggle transparency for unfocused windows
|
||||
ToggleTransparency,
|
||||
/// Enable or disable movement animations
|
||||
#[clap(arg_required_else_help = true)]
|
||||
Animation(Animation),
|
||||
@@ -2065,6 +2082,15 @@ fn main() -> eyre::Result<()> {
|
||||
SubCommand::BorderOffset(args) => {
|
||||
send_message(&SocketMessage::BorderOffset(args.offset))?;
|
||||
}
|
||||
SubCommand::Transparency(args) => {
|
||||
send_message(&SocketMessage::Transparency(args.boolean_state.into()))?;
|
||||
}
|
||||
SubCommand::TransparencyAlpha(args) => {
|
||||
send_message(&SocketMessage::TransparencyAlpha(args.alpha))?;
|
||||
}
|
||||
SubCommand::ToggleTransparency => {
|
||||
send_message(&SocketMessage::ToggleTransparency)?;
|
||||
}
|
||||
SubCommand::Animation(args) => {
|
||||
send_message(&SocketMessage::Animation(
|
||||
args.boolean_state.into(),
|
||||
|
||||
@@ -512,6 +512,23 @@ fn the_border_subcommands_send_what_they_are_given() {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_transparency_subcommands_send_what_they_are_given() {
|
||||
sends(
|
||||
&["transparency", "enable"],
|
||||
r#"{"type":"Transparency","content":true}"#,
|
||||
);
|
||||
sends(
|
||||
&["transparency", "disable"],
|
||||
r#"{"type":"Transparency","content":false}"#,
|
||||
);
|
||||
sends(
|
||||
&["transparency-alpha", "150"],
|
||||
r#"{"type":"TransparencyAlpha","content":150}"#,
|
||||
);
|
||||
sends(&["toggle-transparency"], r#"{"type":"ToggleTransparency"}"#);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_animation_subcommands_send_what_they_are_given() {
|
||||
sends(
|
||||
@@ -1190,11 +1207,14 @@ fn docgen_writes_the_help_of_every_subcommand_in_a_text_fence() {
|
||||
"toggle-mouse-follows-focus.md",
|
||||
"toggle-pause.md",
|
||||
"toggle-tiling.md",
|
||||
"toggle-transparency.md",
|
||||
"toggle-window-based-work-area-offset.md",
|
||||
"toggle-window-container-behaviour.md",
|
||||
"toggle-workspace-float-override.md",
|
||||
"toggle-workspace-layer.md",
|
||||
"toggle-workspace-window-container-behaviour.md",
|
||||
"transparency-alpha.md",
|
||||
"transparency.md",
|
||||
"unmanage.md",
|
||||
"unmanaged-window-operation-behaviour.md",
|
||||
"unstack-all.md",
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
# schema-sha256: 775a2171f74c90914b3de3fd6eed52485bd52cc19c881c90c56f60c36b91611e
|
||||
# schema-sha256: f46c8e0d1557a1e36d2bd123a2d02a4238b28f07146beafb9b5c5fb5825b09df
|
||||
{ lib, ... }:
|
||||
let
|
||||
animationStyle = (
|
||||
@@ -633,6 +633,21 @@ in
|
||||
default = "CenterAndResize";
|
||||
description = "Determines the placement of a new window when toggling to float";
|
||||
};
|
||||
transparency = lib.mkOption {
|
||||
type = (lib.types.nullOr lib.types.bool);
|
||||
default = null;
|
||||
description = "Add transparency to unfocused windows (default: false)";
|
||||
};
|
||||
transparency_alpha = lib.mkOption {
|
||||
type = (lib.types.nullOr lib.types.int);
|
||||
default = null;
|
||||
description = "Alpha value for unfocused window transparency [[0-255]] (default: 200)";
|
||||
};
|
||||
transparency_ignore_rules = lib.mkOption {
|
||||
type = (lib.types.nullOr (lib.types.listOf matchingRule));
|
||||
default = null;
|
||||
description = "Individual window transparency ignore rules";
|
||||
};
|
||||
unmanaged_window_operation_behaviour = lib.mkOption {
|
||||
type = (
|
||||
lib.types.nullOr (
|
||||
|
||||
@@ -325,6 +325,11 @@ mouse-follows-focus enable
|
||||
mouse-follows-focus disable
|
||||
toggle-mouse-follows-focus
|
||||
toggle-mouse-follows-focus
|
||||
transparency enable
|
||||
transparency-alpha 150
|
||||
toggle-transparency
|
||||
toggle-transparency
|
||||
transparency disable
|
||||
border enable
|
||||
border-width 8
|
||||
border-offset 1
|
||||
|
||||
@@ -6,6 +6,7 @@
|
||||
# A toggle-maximize: the window fills the work area, is the one on top, and goes back to its
|
||||
# tile. It runs on the daemon the session started with the module's unit, as on a user's
|
||||
# machine; the sections after it stop that daemon and start their own runs
|
||||
# B transparency: unfocused windows are see-through, the focused one is not
|
||||
# C border colors: every kind of window has its own: the focused window, the others, a locked
|
||||
# container that does not have the focus, a stack and a monocled window that have it, and a
|
||||
# floating window that has it
|
||||
@@ -195,6 +196,43 @@ checks.check(
|
||||
# sections after it start their own runs
|
||||
stop_komorebi()
|
||||
|
||||
print("== B. transparency")
|
||||
start_komorebi()
|
||||
kde.komorebic("transparency-alpha", "100")
|
||||
kde.komorebic("transparency", "enable")
|
||||
windows()
|
||||
|
||||
|
||||
def center_of(title: str) -> tuple[int, int]:
|
||||
frame = kde.rect(kde.wid(title))
|
||||
return frame.x + frame.w // 2, frame.y + frame.h // 2
|
||||
|
||||
|
||||
def middle_of(title: str, color: tuple[int, int, int]) -> bool:
|
||||
"""Returns true if and only if the middle of the window is `color` in a screenshot now."""
|
||||
return pixels.near(pixels.pixel(kde.shot(f"middle-{title}"), *center_of(title)), color)
|
||||
|
||||
|
||||
checks.check(
|
||||
"the focused window is its own color",
|
||||
kde.wait_for(lambda: middle_of("blue", BLUE), timeout=15),
|
||||
)
|
||||
checks.check(
|
||||
"an unfocused window is not: it lets the desktop through",
|
||||
kde.wait_for(lambda: not middle_of("red", RED), timeout=15),
|
||||
)
|
||||
kde.komorebic("transparency", "disable")
|
||||
checks.check(
|
||||
"with transparency off the unfocused window is opaque again",
|
||||
kde.wait_for(lambda: middle_of("red", RED), timeout=15),
|
||||
)
|
||||
kde.komorebic("toggle-transparency")
|
||||
checks.check(
|
||||
"toggled on, see-through again",
|
||||
kde.wait_for(lambda: not middle_of("red", RED), timeout=15),
|
||||
)
|
||||
stop_komorebi()
|
||||
|
||||
print("== C. border colors")
|
||||
start_komorebi()
|
||||
windows()
|
||||
|
||||
+27
@@ -303,6 +303,33 @@
|
||||
],
|
||||
"default": "CenterAndResize"
|
||||
},
|
||||
"transparency": {
|
||||
"description": "Add transparency to unfocused windows (default: false)",
|
||||
"type": [
|
||||
"boolean",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"transparency_alpha": {
|
||||
"description": "Alpha value for unfocused window transparency [[0-255]] (default: 200)",
|
||||
"type": [
|
||||
"integer",
|
||||
"null"
|
||||
],
|
||||
"format": "uint8",
|
||||
"maximum": 255,
|
||||
"minimum": 0
|
||||
},
|
||||
"transparency_ignore_rules": {
|
||||
"description": "Individual window transparency ignore rules",
|
||||
"type": [
|
||||
"array",
|
||||
"null"
|
||||
],
|
||||
"items": {
|
||||
"$ref": "#/$defs/MatchingRule"
|
||||
}
|
||||
},
|
||||
"unmanaged_window_operation_behaviour": {
|
||||
"description": "Determine what happens when commands are sent while an unmanaged window is in the foreground",
|
||||
"anyOf": [
|
||||
|
||||
Reference in new issue
Block a user