transparency

reee.rs

@@ -0,0 +1,127 @@
+use iced::theme::Style;
+use iced::widget::{Column, Container, Id, TextInput, container, operation, text};
+use iced::{Background, Color, Element, Event, Task as Command, window};
+
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        include!("floating-calculator/src/qalc_bridge.h");
+        fn qalc_calculate(expression: &str, timeout_ms: i32) -> String;
+    }
+}
+
+pub fn main() -> iced::Result {
+    let _ = ffi::qalc_calculate("", 2000);
+
+    iced::application(State::default, State::update, State::view)
+        .title("Iced qalc calculator")
+        .subscription(State::subscription)
+        .style(style)
+        .window(window::Settings {
+            size: iced::Size::new(400.0, 400.0),
+            transparent: true,
+            decorations: false,
+            level: window::Level::AlwaysOnTop,
+            ..Default::default()
+        })
+        .run()
+}
+
+struct State {
+    initialized: bool,
+    current_message: String,
+    history: Vec<String>,
+    input_id: Id,
+}
+
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            initialized: false,
+            current_message: String::new(),
+            history: Vec::new(),
+            input_id: Id::unique(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+enum Message {
+    Init,
+    TextSubmit,
+    TextInput(String),
+    IcedEvent(Event),
+}
+
+impl State {
+    fn subscription(&self) -> iced::Subscription<Message> {
+        use iced::event;
+        use iced::futures::stream;
+
+        let init = if !self.initialized {
+            iced::Subscription::run_with("init", |_| stream::once(async { Message::Init }))
+        } else {
+            iced::Subscription::none()
+        };
+
+        iced::Subscription::batch([init, event::listen().map(Message::IcedEvent)])
+    }
+
+    fn update(&mut self, message: Message) -> Command<Message> {
+        use iced::keyboard::{Key, key::Named};
+
+        match message {
+            Message::Init => {
+                self.initialized = true;
+                operation::focus(self.input_id.clone())
+            }
+            Message::IcedEvent(event) => {
+                if let Event::Keyboard(iced::keyboard::Event::KeyReleased {
+                    key: Key::Named(Named::Escape),
+                    ..
+                }) = event
+                {
+                    return iced::exit();
+                }
+                Command::none()
+            }
+            Message::TextInput(t) => {
+                self.current_message = t;
+                Command::none()
+            }
+            Message::TextSubmit => {
+                self.history.push(ffi::qalc_calculate(
+                    &std::mem::take(&mut self.current_message),
+                    2000,
+                ));
+                Command::none()
+            }
+        }
+    }
+
+    fn view(&self) -> Container<'_, Message> {
+        let input: TextInput<'_, Message> =
+            TextInput::new("Type something here...", &self.current_message)
+                .on_input(Message::TextInput)
+                .on_submit(Message::TextSubmit)
+                .id(self.input_id.clone());
+
+        let content = Column::with_children(
+            std::iter::once(input.into())
+                .chain(self.history.iter().rev().map(|msg| text!("{msg}").into()))
+                .collect::<Vec<Element<_>>>(),
+        );
+
+        container(content).style(|_theme| container::Style {
+            background: Some(Background::Color(Color::TRANSPARENT)),
+            ..Default::default()
+        })
+    }
+}
+
+fn style(_state: &State, theme: &iced::Theme) -> Style {
+    Style {
+        background_color: Color::TRANSPARENT,
+        text_color: theme.palette().text,
+    }
+}