//! A short-lived QML overlay hosted by KWin, not a persistent desktop effect.
//! Commands arrive on our parent's private stdin; only KWin can consume them.
use super::*;
use std::io::BufRead;
const OBJECT: &str = "/com/t3tools/KdeCapture/Feedback";
#[derive(Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct Options {
bounds: Bounds,
pid: u32,
flash: bool,
animate: bool,
}
#[derive(Deserialize, Serialize)]
#[serde(tag = "event", rename_all = "camelCase")]
enum Event {
Ready { animate: bool },
Landed,
Done,
}
struct Bridge {
owner: String,
commands: async_channel::Receiver<String>,
done: mpsc::SyncSender<()>,
}
impl Bridge {
fn authorize(&self, header: &zbus::message::Header<'_>) -> zbus::fdo::Result<()> {
if header.sender().map(|name| name.as_str()) == Some(self.owner.as_str()) {
Ok(())
} else {
Err(zbus::fdo::Error::AccessDenied("Not KWin".into()))
}
}
}
#[zbus::interface(name = "com.t3tools.KdeCapture.Feedback")]
impl Bridge {
// An async pending call is an event channel, not a timer or a blocking KWin call.
async fn next(
&self,
#[zbus(header)] header: zbus::message::Header<'_>,
) -> zbus::fdo::Result<String> {
self.authorize(&header)?;
Ok(self
.commands
.recv()
.await
.unwrap_or_else(|_| "{\"command\":\"close\"}".into()))
}
fn event(
&self,
value: &str,
#[zbus(header)] header: zbus::message::Header<'_>,
) -> zbus::fdo::Result<()> {
self.authorize(&header)?;
let event: Event = serde_json::from_str(value)
.map_err(|_| zbus::fdo::Error::InvalidArgs("Invalid feedback event".into()))?;
let mut stdout = std::io::stdout().lock();
let _ = writeln!(stdout, "{}", serde_json::to_string(&event).unwrap());
let _ = stdout.flush();
if matches!(event, Event::Done) {
let _ = self.done.try_send(());
}
Ok(())
}
}
pub(super) fn supported(connection: &Connection) -> bool {
let Ok(proxy) = Proxy::new(
connection,
"org.kde.KWin",
"/Scripting",
"org.freedesktop.DBus.Introspectable",
) else {
return false;
};
proxy
.call::<_, _, String>("Introspect", &())
.is_ok_and(|xml| xml.contains("name=\"loadDeclarativeScript\""))
}
pub(super) fn run(connection: &Connection, directory: &Path, options: &str) -> Result<()> {
let mut options: Options = serde_json::from_str(options)?;
if options.bounds.width == 0 || options.bounds.height == 0 || options.pid == 0 {
return Err("Invalid capture feedback geometry".into());
}
// Use KDE's config reader to respect config layering and the desktop's motion setting.
let factor = std::process::Command::new("kreadconfig6")
.args([
"--file",
"kdeglobals",
"--group",
"KDE",
"--key",
"AnimationDurationFactor",
"--default",
"1",
])
.output()?;
if !factor.status.success() {
return Err("Couldn't read KDE animation preferences".into());
}
let factor: f64 = String::from_utf8(factor.stdout)?.trim().parse()?;
if !factor.is_finite() || factor < 0.0 {
return Err("Invalid KDE animation preference".into());
}
options.animate &= factor > 0.0;
let owner = zbus::blocking::fdo::DBusProxy::new(connection)?
.get_name_owner("org.kde.KWin".try_into()?)?
.to_string();
let (send, commands) = async_channel::bounded(4);
let (done, finished) = mpsc::sync_channel(1);
connection.object_server().at(
OBJECT,
Bridge {
owner,
commands,
done,
},
)?;
// Subscribe before checking, so a lock racing setup can't expose the snapshot.
let locker = Proxy::new(
connection,
"org.freedesktop.ScreenSaver",
"/ScreenSaver",
"org.freedesktop.ScreenSaver",
)?;
let signals = locker.receive_signal("ActiveChanged")?;
if locker.call::<_, _, bool>("GetActive", &())? {
return Err("Screen is locked".into());
}
let lock_commands = send.clone();
std::thread::spawn(move || {
for signal in signals {
if signal
.body()
.deserialize::<(bool,)>()
.is_ok_and(|(active,)| active)
{
let _ = lock_commands.send_blocking("{\"command\":\"close\"}".into());
break;
}
}
});
std::thread::spawn(move || {
let mut input = std::io::stdin().lock();
loop {
let mut line = String::new();
match input.by_ref().take(8193).read_line(&mut line) {
Ok(0) | Err(_) => break,
Ok(_) if line.len() > 8192 => break,
_ => {
if send.send_blocking(line).is_err() {
return;
}
}
}
}
let _ = send.send_blocking("{\"command\":\"close\"}".into());
});
let path = directory.join("feedback.qml");
let name = format!("t3-capture-feedback-{}", std::process::id());
let bus = serde_json::to_string(
connection
.unique_name()
.ok_or("Missing bus identity")?
.as_str(),
)?;
let source = include_str!("feedback.qml")
.replace("/*OPTIONS*/ null", &serde_json::to_string(&options)?)
.replace("/*BUS*/ \"\"", &bus)
.replace("/*NAME*/ \"\"", &serde_json::to_string(&name)?)
.replace("/*FACTOR*/ 1", &factor.clamp(0.0, 3.0).to_string());
std::fs::write(&path, source)?;
std::fs::write(
directory.join("feedbackGeometry.js"),
include_str!("feedbackGeometry.js"),
)?;
let scripting = Proxy::new(
connection,
"org.kde.KWin",
"/Scripting",
"org.kde.kwin.Scripting",
)?;
let result = (|| {
let id: i32 = scripting.call(
"loadDeclarativeScript",
&(path.to_str().ok_or("Invalid script path")?, &name),
)?;
if id < 0 {
return Err("KWin could not load capture feedback".into());
}
let object = format!("/Scripting/Script{id}");
let loaded = Proxy::new(
connection,
"org.kde.KWin",
object.as_str(),
"org.kde.kwin.Script",
)?;
let _: () = loaded.call("run", &())?;
finished.recv_timeout(Duration::from_secs(12))?;
Ok(())
})();
let _: zbus::Result<bool> = scripting.call("unloadScript", &(&name,));
let _ = connection.object_server().remove::<Bridge, _>(OBJECT);
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_kwin_can_read_commands_or_acknowledge_feedback() {
let f = crate::transport_tests::Fixture::new();
let (send, commands) = async_channel::bounded(4);
let (done, finished) = mpsc::sync_channel(1);
// Build with the bridge registered so zbus waits for its method-call listener.
// Registering it after build can drop the first call while that listener starts.
let bridge = Builder::address(f.address.as_str())
.unwrap()
.method_timeout(DEADLINE)
.serve_at(
OBJECT,
Bridge {
owner: f._server.unique_name().unwrap().to_string(),
commands,
done,
},
)
.unwrap()
.build()
.unwrap();
let destination = bridge.unique_name().unwrap().to_string();
let stranger = Builder::address(f.address.as_str())
.unwrap()
.method_timeout(DEADLINE)
.build()
.unwrap();
let unrelated = Proxy::new(
&stranger,
destination.as_str(),
OBJECT,
"com.t3tools.KdeCapture.Feedback",
)
.unwrap();
let error = unrelated.call::<_, _, String>("Next", &()).unwrap_err();
assert!(
matches!(&error, zbus::Error::MethodError(name, _, _) if name.as_str() == "org.freedesktop.DBus.Error.AccessDenied"),
"{error:?}"
);
assert!(
unrelated
.call::<_, _, ()>("Event", &("{\"event\":\"done\"}",))
.is_err()
);
assert!(finished.try_recv().is_err());
let kwin = Proxy::new(
&f._server,
destination.clone(),
OBJECT,
"com.t3tools.KdeCapture.Feedback",
)
.unwrap();
// Event remains responsive while Next waits. No blocking the D-Bus executor.
let next = kwin.clone();
let request = std::thread::spawn(move || next.call::<_, _, String>("Next", &()).unwrap());
kwin.call::<_, _, ()>("Event", &("{\"event\":\"ready\",\"animate\":true}",))
.unwrap();
send.send_blocking("{\"command\":\"close\"}".into())
.unwrap();
assert_eq!(request.join().unwrap(), "{\"command\":\"close\"}");
kwin.call::<_, _, ()>("Event", &("{\"event\":\"done\"}",))
.unwrap();
finished.recv_timeout(DEADLINE).unwrap();
bridge.object_server().remove::<Bridge, _>(OBJECT).unwrap();
}
#[test]
fn capability_probe_rejects_missing_declarative_api_without_running_a_script() {
let f = crate::transport_tests::Fixture::new();
assert!(!supported(&f.client));
}
}