code cleanup

src/main.rs

@@ -1,84 +1,40 @@
-use iced::widget::{Column, Id, TextInput, column, container, operation, text, text_input};
-use iced::{Background, Color, Element, Event, Task as Command};
-use iced::{Border, color};
+mod state;
+mod update;
+
+use crate::state::{Message, State};
+use crate::update::update;
+use iced::widget::{Column, TextInput, column, container, text, text_input};
+use iced::{Background, Border, Color, Element, Theme};
 use iced_layershell::application;
 use iced_layershell::reexport::Anchor;
-use iced_layershell::settings::{LayerShellSettings, Settings, StartMode};
-use iced_layershell::to_layer_message;
+use iced_layershell::settings::{LayerShellSettings, Settings};
 
-use crate::ffi::qalc_calculate;
-
-#[cxx::bridge]
-mod ffi {
-    unsafe extern "C++" {
-        include!("floating-calculator/src/qalc_bridge.h");
-        fn qalc_calculate(expression: &str, timeout_ms: i32) -> String;
-    }
-}
+const BORDER_RADIUS: f32 = 15.;
+const BORDER_WIDTH: f32 = 2.;
+const PADDING: f32 = 8.;
+const WINDOW_SIZE: (u32, u32) = (400, 400);
+const BG_ALPHA: f32 = 0.75;
 
 pub fn main() -> Result<(), iced_layershell::Error> {
-    let _ = ffi::qalc_calculate("", 2000);
-
-    let binded_output_name = std::env::args().nth(1);
-    let start_mode = match binded_output_name {
-        Some(output) => StartMode::TargetScreen(output),
-        None => StartMode::Active,
-    };
-
-    application(State::default, namespace, update, view)
-        .style(style)
-        .subscription(subscription)
-        .settings(Settings {
-            layer_settings: LayerShellSettings {
-                size: Some((400, 400)),
-                exclusive_zone: -1,
-                start_mode,
-                anchor: Anchor::empty(),
-                ..Default::default()
-            },
+    application(
+        State::default,
+        || "floating-calculator".into(),
+        update,
+        view,
+    )
+    .theme(theme)
+    .style(style)
+    .subscription(subscription)
+    .settings(Settings {
+        layer_settings: LayerShellSettings {
+            size: Some(WINDOW_SIZE),
+            exclusive_zone: -1,
+            anchor: Anchor::empty(),
             ..Default::default()
-        })
-        .run()
-}
-
-struct State {
-    current_message: String,
-    history: Vec<History>,
-    input_id: Id,
-}
-
-struct History {
-    promt: String,
-    output: String,
-}
-
-impl History {
-    fn new(promt: String, output: String) -> Self {
-        Self { promt, output }
-    }
-}
-
-impl Default for State {
-    fn default() -> Self {
-        Self {
-            current_message: String::new(),
-            history: Vec::new(),
-            input_id: Id::unique(),
-        }
-    }
-}
-
-#[to_layer_message]
-#[derive(Debug, Clone)]
-enum Message {
-    Init,
-    TextSubmit,
-    TextInput(String),
-    IcedEvent(Event),
-}
-
-fn namespace() -> String {
-    String::from("Iced qalc claculator")
+        },
+        ..Default::default()
+    })
+    .run()
 }
 
 fn subscription(_state: &State) -> iced::Subscription<Message> {
@@ -91,86 +47,70 @@ fn subscription(_state: &State) -> iced::Subscription<Message> {
     ])
 }
 
-fn update(state: &mut State, message: Message) -> Command<Message> {
-    use iced::keyboard::{Event::KeyReleased, Key, key::Named};
-
-    match message {
-        Message::Init => operation::focus(state.input_id.clone()),
-        Message::IcedEvent(event) => {
-            if let Event::Keyboard(KeyReleased {
-                key: Key::Named(Named::Escape),
-                ..
-            }) = event
-            {
-                return iced::exit();
-            }
-
-            Command::none()
-        }
-        Message::TextInput(text) => {
-            state.current_message = text;
-            Command::none()
-        }
-        Message::TextSubmit => {
-            let result = qalc_calculate(&state.current_message, 2000);
-            let history = History::new(std::mem::take(&mut state.current_message), result);
-
-            state.history.push(history);
-
-            Command::none()
-        }
-
-        _ => Command::none(),
-    }
-}
-
 fn view(state: &State) -> Element<'_, Message> {
-    let input: TextInput<'_, Message> =
-        TextInput::new("Type something here...", &state.current_message)
-            .on_input(Message::TextInput)
-            .on_submit(Message::TextSubmit)
-            .id(state.input_id.clone());
+    let input = TextInput::new("Type something here...", &state.current_message)
+        .on_input(Message::TextInput)
+        .on_submit(Message::TextSubmit)
+        .id(state.input_id.clone())
+        .style(input_style);
 
-    let input = input.style(|_theme, _status| text_input::Style {
-        background: Background::Color(Color::TRANSPARENT),
-        border: Border::default(),
-        icon: Color::TRANSPARENT,
-        placeholder: color!(0xbbbbbb),
-        value: Color::WHITE,
-        selection: color!(0x0000ff),
-    });
+    let history = state
+        .history
+        .iter()
+        .rev()
+        .map(|msg| column![text!("{}", msg.promt).size(12), text!(" {}", msg.output),].into());
 
     let content = Column::with_children(
         std::iter::once(input.into())
-            .chain(state.history.iter().rev().map(|msg| {
-                column![
-                    text!("{}", msg.promt).size(12).color(color!(0x999999)),
-                    text!(" {}", msg.output)
-                ]
-                .into()
-            }))
+            .chain(history)
             .collect::<Vec<Element<_>>>(),
     );
 
     container(content)
         .width(iced::Length::Fill)
         .height(iced::Length::Fill)
-        .padding(8.)
-        .style(|_theme| container::Style {
-            text_color: Some(Color::WHITE),
-            background: Some(iced::Background::Color(Color::from_rgba8(30, 30, 46, 0.75))),
-            border: iced::Border::default()
-                .rounded(15.)
-                .color(color!(0xaaaaff))
-                .width(2.),
-            ..Default::default()
-        })
+        .padding(PADDING)
+        .style(container_style)
         .into()
 }
 
+fn input_style(theme: &iced::Theme, _status: text_input::Status) -> text_input::Style {
+    let ext = theme.extended_palette();
+    text_input::Style {
+        background: Background::Color(Color::TRANSPARENT),
+        border: Border::default(),
+        icon: Color::TRANSPARENT,
+        placeholder: ext.background.weak.text,
+        value: ext.background.base.text,
+        selection: ext.primary.weak.color,
+    }
+}
+
+fn container_style(theme: &iced::Theme) -> container::Style {
+    let ext = theme.extended_palette();
+    let mut bg = ext.background.base.color;
+    bg.a = BG_ALPHA;
+
+    container::Style {
+        text_color: Some(ext.background.base.text),
+        background: Some(Background::Color(bg)),
+        border: Border::default()
+            .rounded(BORDER_RADIUS)
+            .color(ext.primary.base.color)
+            .width(BORDER_WIDTH),
+        ..Default::default()
+    }
+}
+
+fn theme(_state: &State) -> Theme {
+    match dark_light::detect() {
+        Ok(dark_light::Mode::Light) => Theme::Light,
+        _ => Theme::CatppuccinMocha,
+    }
+}
+
 fn style(_state: &State, theme: &iced::Theme) -> iced::theme::Style {
-    use iced::theme::Style;
-    Style {
+    iced::theme::Style {
         background_color: Color::TRANSPARENT,
         text_color: theme.palette().text,
     }

src/qalc_bridge.cc

@@ -1,5 +1,5 @@
 #include "floating-calculator/src/qalc_bridge.h"
-#include "floating-calculator/src/main.rs.h"
+#include "floating-calculator/src/update.rs.h"
 #include <libqalculate/qalculate.h>
 
 Calculator create_calculator() {

src/state.rs

@@ -0,0 +1,39 @@
+use iced::Event;
+use iced::widget::Id;
+use iced_layershell::to_layer_message;
+
+pub struct State {
+    pub current_message: String,
+    pub history: Vec<History>,
+    pub input_id: Id,
+}
+
+pub struct History {
+    pub promt: String,
+    pub output: String,
+}
+
+impl History {
+    pub fn new(promt: String, output: String) -> Self {
+        Self { promt, output }
+    }
+}
+
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            current_message: String::new(),
+            history: Vec::new(),
+            input_id: Id::unique(),
+        }
+    }
+}
+
+#[to_layer_message]
+#[derive(Debug, Clone)]
+pub enum Message {
+    Init,
+    TextSubmit,
+    TextInput(String),
+    IcedEvent(Event),
+}

src/update.rs

@@ -0,0 +1,45 @@
+use crate::state::{History, Message, State};
+use iced::keyboard::Event::KeyReleased;
+use iced::keyboard::key::{Key, Named};
+use iced::widget::operation;
+use iced::{Event, Task as Command};
+
+#[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 update(state: &mut State, message: Message) -> Command<Message> {
+    match message {
+        Message::Init => operation::focus(state.input_id.clone()),
+
+        Message::IcedEvent(event) => {
+            if let Event::Keyboard(KeyReleased {
+                key: Key::Named(Named::Escape),
+                ..
+            }) = event
+            {
+                return iced::exit();
+            }
+            Command::none()
+        }
+
+        Message::TextInput(text) => {
+            state.current_message = text;
+            Command::none()
+        }
+
+        Message::TextSubmit => {
+            let result = ffi::qalc_calculate(&state.current_message, 2000);
+            let history = History::new(std::mem::take(&mut state.current_message), result);
+
+            state.history.push(history);
+            Command::none()
+        }
+
+        _ => Command::none(),
+    }
+}

src/view.rs

@@ -0,0 +1,43 @@
+fn view(state: &State) -> Element<'_, Message> {
+    let input: TextInput<'_, Message> =
+        TextInput::new("Type something here...", &state.current_message)
+            .on_input(Message::TextInput)
+            .on_submit(Message::TextSubmit)
+            .id(state.input_id.clone());
+
+    let input = input.style(|_theme, _status| text_input::Style {
+        background: Background::Color(Color::TRANSPARENT),
+        border: Border::default(),
+        icon: Color::TRANSPARENT,
+        placeholder: color!(0xbbbbbb),
+        value: Color::WHITE,
+        selection: color!(0x0000ff),
+    });
+
+    let content = Column::with_children(
+        std::iter::once(input.into())
+            .chain(state.history.iter().rev().map(|msg| {
+                column![
+                    text!("{}", msg.promt).size(12).color(color!(0x999999)),
+                    text!(" {}", msg.output)
+                ]
+                .into()
+            }))
+            .collect::<Vec<Element<_>>>(),
+    );
+
+    container(content)
+        .width(iced::Length::Fill)
+        .height(iced::Length::Fill)
+        .padding(8.)
+        .style(|_theme| container::Style {
+            text_color: Some(Color::WHITE),
+            background: Some(iced::Background::Color(Color::from_rgba8(30, 30, 46, 0.75))),
+            border: iced::Border::default()
+                .rounded(15.)
+                .color(color!(0xaaaaff))
+                .width(2.),
+            ..Default::default()
+        })
+        .into()
+}