windows.rs

src-tauri/src/windows.rs

1. //! The two windows, the tray and the global shortcut.
2. //!
3. //! On macOS both windows sit on native vibrancy (the frosted material behind
4. //! the glass panels). Elsewhere the window is opaque and the page paints its
5. //! own backdrop.
7. use std::time::{Duration, Instant};
9. use tauri::menu::{Menu, MenuItem, PredefinedMenuItem};
10. use tauri::tray::TrayIconBuilder;
11. use tauri::{AppHandle, Emitter, Manager, WebviewUrl, WebviewWindowBuilder, WindowEvent};
12. use tauri_plugin_global_shortcut::GlobalShortcutExt;
14. use crate::commands::{load_settings, spend};
15. use crate::state::{lock, AppState};
17. pub const QUICK_WIDTH: f64 = 640.0;
18. /// The quick window's height with no answer, and the most it grows to. The
19. /// interface has the same two numbers in `src/lib/theme.ts`.
20. pub const QUICK_HEIGHT: f64 = 76.0;
21. pub const QUICK_MAX: f64 = 560.0;
22. /// Losing focus this soon after the quick window appears is the show itself, not a click away.
23. const BLUR_GRACE: Duration = Duration::from_millis(150);
25. pub fn create_windows(app: &AppHandle) -> tauri::Result<()> {
26. let main = WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html".into()))
27. .title("Cortex")
28. .inner_size(1100.0, 720.0)
29. .min_inner_size(720.0, 480.0)
30. .visible(false); // shown by window_ready once the page has painted
31. #[cfg(target_os = "macos")]
32. let main = {
33. use tauri::window::{Effect, EffectState, EffectsBuilder};
34. main.transparent(true)
35. .title_bar_style(tauri::TitleBarStyle::Overlay)
36. .hidden_title(true)
37. .effects(EffectsBuilder::new().effect(Effect::Sidebar).state(EffectState::FollowsWindowActiveState).build())
38. };
39. let main = main.build()?;
40. let handle = app.clone();
41. main.on_window_event(move |ev| {
42. if let WindowEvent::CloseRequested { api, .. } = ev {
43. // Closing hides; Quit (menu, tray, Cmd+Q) quits.
44. api.prevent_close();
45. if let Some(w) = handle.get_webview_window("main") {
46. let _ = w.hide();
47. }
48. }
49. });
51. let quick = WebviewWindowBuilder::new(app, "quick", WebviewUrl::App("quick.html".into()))
52. .title("Cortex quick prompt")
53. .inner_size(QUICK_WIDTH, QUICK_HEIGHT)
54. .decorations(false)
55. .resizable(false)
56. .always_on_top(true)
57. .skip_taskbar(true)
58. .visible_on_all_workspaces(true)
59. .visible(false);
60. #[cfg(target_os = "macos")]
61. let quick = {
62. use tauri::window::{Effect, EffectState, EffectsBuilder};
63. quick
64. .transparent(true)
65. .effects(EffectsBuilder::new().effect(Effect::HudWindow).state(EffectState::Active).radius(14.0).build())
66. };
67. let quick = quick.build()?;
68. let handle = app.clone();
69. quick.on_window_event(move |ev| {
70. if let WindowEvent::Focused(false) = ev {
71. let state = handle.state::<AppState>();
72. let recent = lock(&state.quick_shown_at).is_some_and(|t| t.elapsed() < BLUR_GRACE);
73. let dialog = *lock(&state.dialog_open);
74. if !recent && !dialog {
75. hide_quick(&handle);
76. }
77. }
78. });
79. Ok(())
80. }
82. pub fn show_main(app: &AppHandle) {
83. #[cfg(target_os = "macos")]
84. let _ = app.show();
85. if let Some(w) = app.get_webview_window("main") {
86. let _ = w.unminimize();
87. let _ = w.show();
88. let _ = w.set_focus();
89. }
90. }
92. pub fn toggle_quick(app: &AppHandle) {
93. let Some(w) = app.get_webview_window("quick") else { return };
94. if w.is_visible().unwrap_or(false) {
95. hide_quick(app);
96. return;
97. }
98. #[cfg(target_os = "macos")]
99. let _ = app.show();
100. *lock(&app.state::<AppState>().quick_shown_at) = Some(Instant::now());
101. let _ = w.set_size(tauri::LogicalSize::new(QUICK_WIDTH, QUICK_HEIGHT));
102. // Center on the monitor under the cursor, a third of the way down.
103. if let (Ok(pos), Ok(monitors)) = (app.cursor_position(), app.available_monitors()) {
104. if let Some(m) = monitors.iter().find(|m| {
105. let (p, s) = (m.position(), m.size());
106. pos.x >= p.x as f64
107. && pos.x < (p.x + s.width as i32) as f64
108. && pos.y >= p.y as f64
109. && pos.y < (p.y + s.height as i32) as f64
110. }) {
111. let scale = m.scale_factor();
112. let (p, s) = (m.position(), m.size());
113. let x = p.x as f64 + (s.width as f64 - QUICK_WIDTH * scale) / 2.0;
114. let y = p.y as f64 + s.height as f64 / 3.0;
115. let _ = w.set_position(tauri::PhysicalPosition::new(x, y));
116. }
117. }
118. let _ = w.show();
119. let _ = w.set_focus();
120. let _ = w.emit("quick-shown", ());
121. }
123. pub fn hide_quick(app: &AppHandle) {
124. if let Some(w) = app.get_webview_window("quick") {
125. let _ = w.hide();
126. }
127. }
129. /// Swap the global shortcut. On failure the old one is put back.
130. pub fn set_shortcut(app: &AppHandle, old: &str, new: &str) -> Result<(), String> {
131. let gs = app.global_shortcut();
132. let _ = gs.unregister(old);
133. match gs.register(new) {
134. Ok(()) => Ok(()),
135. Err(err) => {
136. let _ = gs.register(old);
137. Err(format!("Could not use {new}: {err}"))
138. }
139. }
140. }
142. /// Set the main window's macOS material. The blur strength is fixed by macOS
143. /// for each material; they differ in how much tint and light they let through.
144. pub fn apply_material(app: &AppHandle, material: &str) {
145. #[cfg(target_os = "macos")]
146. {
147. use tauri::window::{Effect, EffectState, EffectsBuilder};
148. let effect = match material {
149. "window" => Effect::UnderWindowBackground,
150. "fullscreen" => Effect::FullScreenUI,
151. "hud" => Effect::HudWindow,
152. _ => Effect::Sidebar,
153. };
154. if let Some(w) = app.get_webview_window("main") {
155. let _ = w
156. .set_effects(EffectsBuilder::new().effect(effect).state(EffectState::FollowsWindowActiveState).build());
157. }
158. }
159. #[cfg(not(target_os = "macos"))]
160. let _ = (app, material);
161. }
163. pub fn apply_theme(app: &AppHandle, theme: &str) {
164. let t = match theme {
165. "light" => Some(tauri::Theme::Light),
166. "dark" => Some(tauri::Theme::Dark),
167. _ => None,
168. };
169. for label in ["main", "quick"] {
170. if let Some(w) = app.get_webview_window(label) {
171. let _ = w.set_theme(t);
172. }
173. }
174. }
176. fn spend_label(app: &AppHandle) -> String {
177. match spend(&app.state::<AppState>()) {
178. Ok(s) => {
179. let mut label = format!("This month: {}", cortex_core::cost::format_usd(s.month_nanousd));
180. if let Some(b) = s.budget_usd {
181. label.push_str(&format!(" of ${b:.2}"));
182. }
183. label
184. }
185. Err(_) => "This month: unavailable".into(),
186. }
187. }
189. pub fn refresh_tray_spend(app: &AppHandle) {
190. let label = spend_label(app);
191. if let Some(item) = lock(&app.state::<AppState>().tray_spend).as_ref() {
192. let _ = item.set_text(label);
193. }
194. }
196. pub fn create_tray(app: &AppHandle) -> tauri::Result<()> {
197. let new_chat = MenuItem::with_id(app, "new", "New chat", true, None::<&str>)?;
198. let quick = MenuItem::with_id(app, "quick", "Quick prompt", true, None::<&str>)?;
199. let spend_item = MenuItem::with_id(app, "spend", spend_label(app), false, None::<&str>)?;
200. let settings = MenuItem::with_id(app, "settings", "Settings", true, None::<&str>)?;
201. let quit = MenuItem::with_id(app, "quit", "Quit Cortex", true, None::<&str>)?;
202. let sep = || PredefinedMenuItem::separator(app);
203. let menu = Menu::with_items(app, &[&new_chat, &quick, &sep()?, &spend_item, &sep()?, &settings, &quit])?;
204. let icon = tauri::image::Image::from_bytes(include_bytes!("../icons/tray.png"))?;
205. TrayIconBuilder::with_id("cortex")
206. .icon(icon)
207. .icon_as_template(true)
208. .tooltip("Cortex")
209. .menu(&menu)
210. .show_menu_on_left_click(true)
211. .on_menu_event(|app, event| match event.id.as_ref() {
212. "new" => {
213. show_main(app);
214. let _ = app.emit_to("main", "new-chat", ());
215. }
216. "quick" => toggle_quick(app),
217. "settings" => {
218. show_main(app);
219. let _ = app.emit_to("main", "open-settings", ());
220. }
221. "quit" => app.exit(0),
222. _ => {}
223. })
224. .build(app)?;
225. *lock(&app.state::<AppState>().tray_spend) = Some(spend_item);
226. Ok(())
227. }
229. pub fn register_initial_shortcut(app: &AppHandle) {
230. let shortcut = load_settings(&app.state::<AppState>()).shortcut;
231. if let Err(err) = app.global_shortcut().register(shortcut.as_str()) {
232. eprintln!("cortex: shortcut {shortcut} unavailable: {err}");
233. }
234. }