oiupoyt/scythe
1
1
Fork 0
Code Issues Pull requests Projects Releases 2 Packages Wiki Activity
scythe/src/overlay_egui.rs

2837 lines
134 KiB
Rust
Raw Blame History

use eframe::egui;
use egui::{Color32, CornerRadius, FontId, Margin, Stroke, Vec2};
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{channel, Receiver, Sender};
use std::time::{Duration, Instant, SystemTime};
use crate::config::ScytheConfig;
use crate::ipc::{self, Command, DaemonStatus};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ShadowPlayView {
MainHud,
Settings,
Gallery,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeybindAction {
Menu,
SaveReplay,
ToggleRecord,
ToggleCursor,
}
pub fn setup_custom_fonts(ctx: &egui::Context) {
let mut fonts = egui::FontDefinitions::default();
fonts.font_data.insert(
"modern_sans".to_owned(),
Arc::new(egui::FontData::from_static(include_bytes!("../assets/fonts/AdwaitaSans-Regular.ttf"))),
);
fonts.families
.entry(egui::FontFamily::Proportional)
.or_default()
.insert(0, "modern_sans".to_owned());
ctx.set_fonts(fonts);
}
fn format_egui_key(key: egui::Key) -> Option<String> {
match key {
egui::Key::Escape => None,
egui::Key::Space => Some("Space".to_string()),
egui::Key::Tab => Some("Tab".to_string()),
egui::Key::Enter => Some("Return".to_string()),
egui::Key::Backspace => Some("BackSpace".to_string()),
egui::Key::Insert => Some("Insert".to_string()),
egui::Key::Delete => Some("Delete".to_string()),
egui::Key::Home => Some("Home".to_string()),
egui::Key::End => Some("End".to_string()),
egui::Key::PageUp => Some("Page_Up".to_string()),
egui::Key::PageDown => Some("Page_Down".to_string()),
_ => {
let name = format!("{:?}", key);
if name.starts_with("Num") && name.len() > 3 {
Some(name[3..].to_string())
} else {
Some(name)
}
}
}
}
fn probe_duration_sec(path: &std::path::Path) -> f32 {
let mut cmd = std::process::Command::new("ffprobe");
cmd.args([
"-v", "error",
"-show_entries", "format=duration",
"-of", "default=noprint_wrappers=1:nokey=1",
])
.arg(path);
#[cfg(target_os = "windows")]
{
use std::os::windows::process::CommandExt;
cmd.creation_flags(0x08000000);
}
let out = cmd.output();
if let Ok(out) = out {
let text = String::from_utf8_lossy(&out.stdout);
if let Ok(val) = text.trim().parse::<f32>() {
return val;
}
}
0.0
}
fn trim_clip(
input_path: &std::path::Path,
start_sec: f32,
end_sec: f32,
) -> Result<PathBuf, String> {
let stem = input_path.file_stem().unwrap_or_default().to_string_lossy();
let ext = input_path.extension().unwrap_or_default().to_string_lossy();
let parent = input_path.parent().unwrap_or_else(|| std::path::Path::new("."));
let mut out_path = parent.join(format!("{}_trimmed.{}", stem, ext));
let mut counter = 1;
while out_path.exists() {
out_path = parent.join(format!("{}_trimmed_{}.{}", stem, counter, ext));
counter += 1;
}
let mut cmd = std::process::Command::new("ffmpeg");
cmd.args([
"-y",
"-ss", &format!("{:.2}", start_sec),
"-to", &format!("{:.2}", end_sec),
"-i",
])
.arg(input_path)
.args([
"-c", "copy",
"-avoid_negative_ts", "make_zero",
])
.arg(&out_path);
#[cfg(target_os = "windows")]
{
use std::os::windows::process::CommandExt;
cmd.creation_flags(0x08000000);
}
let res = cmd.output().map_err(|e| format!("Failed to spawn ffmpeg: {}", e))?;
if res.status.success() {
Ok(out_path)
} else {
let err_str = String::from_utf8_lossy(&res.stderr);
Err(format!("FFmpeg trim failed: {}", err_str.lines().last().unwrap_or("Unknown error")))
}
}
fn play_clip(path: &std::path::Path) {
let p = path.to_path_buf();
std::thread::spawn(move || {
#[cfg(target_os = "windows")]
{
use windows::core::HSTRING;
use windows::Win32::UI::Shell::ShellExecuteW;
use windows::Win32::UI::WindowsAndMessaging::SW_SHOWNORMAL;
let path_str = p.to_string_lossy().to_string();
unsafe {
let _ = ShellExecuteW(
None,
windows::core::w!("open"),
&HSTRING::from(&path_str),
None,
None,
SW_SHOWNORMAL,
);
}
}
#[cfg(not(target_os = "windows"))]
{
if std::process::Command::new("mpv").arg(&p).spawn().is_err()
&& std::process::Command::new("vlc").arg(&p).spawn().is_err()
{
let _ = std::process::Command::new("xdg-open").arg(&p).spawn();
}
}
});
}
fn render_vu_meter(ui: &mut egui::Ui, level: f32, width: f32, height: f32, label: &str) {
let (rect, _) = ui.allocate_exact_size(Vec2::new(width, height), egui::Sense::hover());
let clamped = level.clamp(0.0, 1.0);
let bg_color = Color32::from_rgb(14, 14, 16);
let border_stroke = Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 20));
ui.painter().rect(rect, CornerRadius::ZERO, bg_color, border_stroke, egui::StrokeKind::Inside);
let fill_w = (rect.width() * clamped).max(0.0);
if fill_w > 0.5 {
let fill_rect = egui::Rect::from_min_size(rect.min, Vec2::new(fill_w, rect.height()));
let fill_color = if clamped > 0.85 {
Color32::from_rgb(239, 68, 68)
} else if clamped > 0.65 {
Color32::from_rgb(234, 179, 8)
} else {
Color32::from_rgb(34, 197, 94)
};
ui.painter().rect_filled(fill_rect, CornerRadius::ZERO, fill_color);
}
if clamped > 0.05 {
let tick_x = rect.left() + rect.width() * clamped;
ui.painter().line_segment(
[egui::pos2(tick_x, rect.top()), egui::pos2(tick_x, rect.bottom())],
Stroke::new(1.5_f32, Color32::WHITE),
);
}
if !label.is_empty() {
ui.painter().text(
rect.left_center() + Vec2::new(3.0, 0.0),
egui::Align2::LEFT_CENTER,
label,
FontId::proportional(8.5),
Color32::from_rgba_unmultiplied(255, 255, 255, 200),
);
}
}
#[derive(Debug, Clone)]
pub struct VideoClipInfo {
pub filename: String,
pub path: PathBuf,
pub size_bytes: u64,
pub modified: SystemTime,
pub is_replay: bool,
}
fn scan_recordings(dir_str: &str) -> Vec<VideoClipInfo> {
let dir = ScytheConfig::expand_tilde(dir_str);
let mut clips = Vec::new();
if let Ok(entries) = std::fs::read_dir(&dir) {
for entry in entries.flatten() {
let path = entry.path();
if path.is_file()
&& let Some(ext) = path.extension() {
let ext_str = ext.to_string_lossy().to_lowercase();
if ext_str == "mp4" || ext_str == "mkv" {
let filename = path.file_name().unwrap_or_default().to_string_lossy().to_string();
let is_replay = filename.to_lowercase().starts_with("replay");
let size_bytes = entry.metadata().map(|m| m.len()).unwrap_or(0);
let modified = entry.metadata().and_then(|m| m.modified()).unwrap_or(SystemTime::UNIX_EPOCH);
clips.push(VideoClipInfo {
filename,
path,
size_bytes,
modified,
is_replay,
});
}
}
}
}
clips.sort_by_key(|b| std::cmp::Reverse(b.modified));
clips
}
// Cross-platform helper to reveal or open directories
fn open_folder(path: &std::path::Path) {
let p = path.to_path_buf();
std::thread::spawn(move || {
let is_file = p.is_file();
let folder = if is_file {
p.parent().unwrap_or(&p).to_path_buf()
} else {
p.clone()
};
let _ = std::fs::create_dir_all(&folder);
#[cfg(target_os = "windows")]
{
use std::os::windows::process::CommandExt;
if is_file {
let p_str = p.to_string_lossy().replace('/', "\\");
let _ = std::process::Command::new("explorer.exe")
.arg(format!("/select,{}", p_str))
.creation_flags(0x08000000)
.spawn();
} else {
let f_str = folder.to_string_lossy().replace('/', "\\");
let _ = std::process::Command::new("explorer.exe")
.arg(&f_str)
.creation_flags(0x08000000)
.spawn();
}
}
#[cfg(target_os = "macos")]
{
let _ = std::process::Command::new("open").arg(&folder).spawn();
}
#[cfg(not(any(target_os = "windows", target_os = "macos")))]
{
let _ = std::process::Command::new("xdg-open").arg(&folder).spawn();
}
});
}
// Cross-platform folder picker dialog
fn pick_folder(current_dir: &str, tx: Sender<String>, is_active: Arc<AtomicBool>) {
is_active.store(true, Ordering::SeqCst);
let cur = current_dir.to_string();
let flag = is_active.clone();
std::thread::spawn(move || {
#[cfg(target_os = "windows")]
{
use std::os::windows::process::CommandExt;
let clean_cur = cur.replace('/', "\\").replace('\'', "''");
let script = format!(
"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms') | Out-Null; \
$f = New-Object System.Windows.Forms.FolderBrowserDialog; \
$f.Description = 'Select Recordings Directory'; \
$f.UseDescriptionForTitle = $true; \
if (Test-Path '{}') {{ $f.SelectedPath = '{}' }}; \
if ($f.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {{ Write-Output $f.SelectedPath }}",
clean_cur, clean_cur
);
let mut cmd = std::process::Command::new("powershell.exe");
cmd.args(["-NoProfile", "-NonInteractive", "-WindowStyle", "Hidden", "-STA", "-Command", &script]);
cmd.creation_flags(0x08000000);
if let Ok(out) = cmd.output() {
let sel = String::from_utf8_lossy(&out.stdout).trim().to_string();
if !sel.is_empty() {
let _ = tx.send(sel);
}
}
flag.store(false, Ordering::SeqCst);
}
#[cfg(not(target_os = "windows"))]
{
// Dynamically ensure Hyprland floats, pins, and focuses the folder picker dialog on top
let _ = std::process::Command::new("hyprctl")
.args(["eval", r#"hl.window_rule({ match = { title = "Select Recordings Directory" }, float = true, pin = true, stay_focused = true, center = true })"#])
.output();
let _ = std::process::Command::new("hyprctl")
.args(["eval", r#"hl.window_rule({ match = { class = "org.kde.kdialog" }, float = true, pin = true, stay_focused = true, center = true })"#])
.output();
let _ = std::process::Command::new("hyprctl")
.args(["eval", r#"hl.window_rule({ match = { class = "kdialog" }, float = true, pin = true, stay_focused = true, center = true })"#])
.output();
if let Ok(out) = std::process::Command::new("kdialog")
.args(["--title", "Select Recordings Directory", "--getexistingdirectory", &cur])
.output()
{
let sel = String::from_utf8_lossy(&out.stdout).trim().to_string();
if !sel.is_empty() {
let _ = tx.send(sel);
flag.store(false, Ordering::SeqCst);
return;
}
}
if let Ok(out) = std::process::Command::new("zenity")
.args(["--title=Select Recordings Directory", "--file-selection", "--directory", &format!("--filename={}", cur)])
.output()
{
let sel = String::from_utf8_lossy(&out.stdout).trim().to_string();
if !sel.is_empty() {
let _ = tx.send(sel);
flag.store(false, Ordering::SeqCst);
return;
}
}
}
flag.store(false, Ordering::SeqCst);
});
}
fn spawn_daemon_process() {
let mut cmd = if let Ok(mut path) = std::env::current_exe() {
path.pop();
#[cfg(target_os = "windows")]
let primary = path.join("scythe-daemon.exe");
#[cfg(not(target_os = "windows"))]
let primary = path.join("scythe-daemon");
if primary.exists() {
std::process::Command::new(primary)
} else {
#[cfg(target_os = "windows")]
{ std::process::Command::new("scythe-daemon.exe") }
#[cfg(not(target_os = "windows"))]
{ std::process::Command::new("scythe-daemon") }
}
} else {
#[cfg(target_os = "windows")]
{ std::process::Command::new("scythe-daemon.exe") }
#[cfg(not(target_os = "windows"))]
{ std::process::Command::new("scythe-daemon") }
};
#[cfg(target_os = "windows")]
{
use std::os::windows::process::CommandExt;
cmd.creation_flags(0x08000000); // CREATE_NO_WINDOW
}
let _ = cmd
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.spawn();
}
// Asynchronous daemon command dispatcher to avoid blocking the egui render loop
fn async_send_command(cmd: Command) {
std::thread::spawn(move || {
let _ = ipc::send_command(cmd);
});
}
// Helper to render mechanical keyboard keycap badges
#[allow(dead_code)]
fn render_keycap(ui: &mut egui::Ui, text: &str) {
egui::Frame::NONE
.fill(Color32::from_rgb(18, 20, 26))
.stroke(Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 26)))
.corner_radius(CornerRadius::ZERO)
.inner_margin(Margin::symmetric(7_i8, 3_i8))
.show(ui, |ui| {
ui.label(
egui::RichText::new(text)
.font(FontId::monospace(9.5))
.strong()
.color(Color32::from_rgb(220, 222, 228)),
);
});
}
pub fn resolve_accent_color(accent: &str) -> Color32 {
match accent.to_lowercase().as_str() {
"green" | "emerald" => Color32::from_rgb(34, 197, 94),
"cyan" | "ice" => Color32::from_rgb(6, 182, 212),
"purple" | "violet" => Color32::from_rgb(168, 85, 247),
"amber" | "orange" => Color32::from_rgb(245, 158, 11),
"red" | "crimson" => Color32::from_rgb(239, 68, 68),
"blue" | "sapphire" => Color32::from_rgb(56, 189, 248),
_ => Color32::from_rgb(56, 189, 248),
}
}
// Clickable keycap button for interactive rebinding
fn render_keycap_button(
ui: &mut egui::Ui,
text: &str,
listening: bool,
accent: Color32,
) -> bool {
let (fill, stroke, text_color, label_text) = if listening {
(
Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 32),
Stroke::new(1.5_f32, accent),
accent,
"PRESS KEYS...".to_string(),
)
} else {
(
Color32::from_rgba_unmultiplied(20, 22, 30, 210),
Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 24)),
Color32::from_rgb(220, 220, 228),
text.to_string(),
)
};
let btn = egui::Button::new(
egui::RichText::new(label_text)
.font(FontId::monospace(10.5))
.strong()
.color(text_color),
)
.fill(fill)
.stroke(stroke)
.corner_radius(CornerRadius::ZERO)
.min_size(Vec2::new(130.0, 26.0));
ui.add(btn).clicked()
}
// Modern sleek rounded button
fn squared_button(ui: &mut egui::Ui, text: &str, active: bool, accent: Color32) -> bool {
let fill = if active {
accent
} else {
Color32::from_rgba_unmultiplied(255, 255, 255, 12)
};
let stroke = if active {
Stroke::new(1.0_f32, accent)
} else {
Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 24))
};
let text_color = if active {
Color32::from_rgb(10, 10, 12)
} else {
Color32::from_rgb(215, 215, 220)
};
let btn = egui::Button::new(egui::RichText::new(text).size(11.5).strong().color(text_color))
.fill(fill)
.stroke(stroke)
.corner_radius(CornerRadius::ZERO);
ui.add(btn).clicked()
}
#[allow(dead_code)]
fn pill_button(ui: &mut egui::Ui, text: &str, active: bool, accent: Color32) -> bool {
squared_button(ui, text, active, accent)
}
// Sleek Modern Switch Toggle
fn toggle_switch(ui: &mut egui::Ui, on: &mut bool, accent: Color32) -> egui::Response {
let desired_size = egui::vec2(38.0, 20.0);
let (rect, mut response) = ui.allocate_exact_size(desired_size, egui::Sense::click());
if response.clicked() {
*on = !*on;
response.mark_changed();
}
response.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Checkbox, ui.is_enabled(), *on, ""));
if ui.is_rect_visible(rect) {
let how_on = ui.ctx().animate_bool(response.id, *on);
let bg_color = if *on {
accent
} else {
Color32::from_rgb(26, 28, 34)
};
let stroke = Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 28));
ui.painter().rect(rect, CornerRadius::ZERO, bg_color, stroke, egui::StrokeKind::Inside);
let knob_w = rect.height() - 4.0;
let knob_x = egui::lerp((rect.left() + 2.0)..=(rect.right() - knob_w - 2.0), how_on);
let knob_rect = egui::Rect::from_min_size(egui::pos2(knob_x, rect.top() + 2.0), egui::vec2(knob_w, knob_w));
ui.painter().rect_filled(knob_rect, CornerRadius::ZERO, Color32::WHITE);
}
response
}
// Minimal Squared Vector Icon Renderers (Clean, Sleek & Modern)
fn draw_replay_icon(painter: &egui::Painter, center: egui::Pos2, radius: f32, is_active: bool, accent: Color32) {
let color = if is_active {
accent
} else {
Color32::from_rgb(150, 150, 155)
};
// 1. Sleek circular track ring with high-contrast active accent
let ring_r = radius * 0.94;
let track_alpha = if is_active { 190 } else { 110 };
let stroke = Stroke::new(
1.8_f32,
Color32::from_rgba_unmultiplied(color.r(), color.g(), color.b(), track_alpha),
);
painter.circle_stroke(center, ring_r, stroke);
// 2. Dual Rewind Triangles ◀ ◀ (Iconic instant replay / rewind navigation)
let tri_h = radius * 0.46;
let tri_w = radius * 0.32;
let gap = radius * 0.08;
// Left triangle ◀ (pointing left)
let t1_tip = center + Vec2::new(-tri_w - gap * 0.5, 0.0);
let t1_top = center + Vec2::new(-gap * 0.5, -tri_h);
let t1_bot = center + Vec2::new(-gap * 0.5, tri_h);
painter.add(egui::Shape::convex_polygon(
vec![t1_tip, t1_top, t1_bot],
color,
Stroke::NONE,
));
// Right triangle ◀ (pointing left)
let t2_tip = center + Vec2::new(gap * 0.5, 0.0);
let t2_top = center + Vec2::new(tri_w + gap * 0.5, -tri_h);
let t2_bot = center + Vec2::new(tri_w + gap * 0.5, tri_h);
painter.add(egui::Shape::convex_polygon(
vec![t2_tip, t2_top, t2_bot],
color,
Stroke::NONE,
));
}
fn draw_record_icon(painter: &egui::Painter, center: egui::Pos2, radius: f32, is_recording: bool, _anim_time: f32) {
let half = radius * 0.88;
let arm = radius * 0.36;
if is_recording {
let red_bright = Color32::from_rgb(239, 68, 68);
// Viewfinder corner brackets (Red)
let stroke = Stroke::new(2.2_f32, red_bright);
// Top-left
painter.line_segment([center + Vec2::new(-half + arm, -half), center + Vec2::new(-half, -half)], stroke);
painter.line_segment([center + Vec2::new(-half, -half), center + Vec2::new(-half, -half + arm)], stroke);
// Top-right
painter.line_segment([center + Vec2::new(half - arm, -half), center + Vec2::new(half, -half)], stroke);
painter.line_segment([center + Vec2::new(half, -half), center + Vec2::new(half, -half + arm)], stroke);
// Bottom-left
painter.line_segment([center + Vec2::new(-half + arm, half), center + Vec2::new(-half, half)], stroke);
painter.line_segment([center + Vec2::new(-half, half), center + Vec2::new(-half, half - arm)], stroke);
// Bottom-right
painter.line_segment([center + Vec2::new(half - arm, half), center + Vec2::new(half, half)], stroke);
painter.line_segment([center + Vec2::new(half, half), center + Vec2::new(half, half - arm)], stroke);
// Center recording core (completely static, solid and crisp, no bobbing/pulsing)
let core_r = radius * 0.42;
painter.circle_filled(center, core_r, red_bright);
} else {
let frame_color = Color32::from_rgb(150, 150, 155);
let core_color = Color32::from_rgb(203, 213, 225);
// Viewfinder corner brackets (Slate)
let stroke = Stroke::new(2.0_f32, frame_color);
// Top-left
painter.line_segment([center + Vec2::new(-half + arm, -half), center + Vec2::new(-half, -half)], stroke);
painter.line_segment([center + Vec2::new(-half, -half), center + Vec2::new(-half, -half + arm)], stroke);
// Top-right
painter.line_segment([center + Vec2::new(half - arm, -half), center + Vec2::new(half, -half)], stroke);
painter.line_segment([center + Vec2::new(half, -half), center + Vec2::new(half, -half + arm)], stroke);
// Bottom-left
painter.line_segment([center + Vec2::new(-half + arm, half), center + Vec2::new(-half, half)], stroke);
painter.line_segment([center + Vec2::new(-half, half), center + Vec2::new(-half, half - arm)], stroke);
// Bottom-right
painter.line_segment([center + Vec2::new(half - arm, half), center + Vec2::new(half, half)], stroke);
painter.line_segment([center + Vec2::new(half, half), center + Vec2::new(half, half - arm)], stroke);
// Center standby dot
painter.circle_filled(center, radius * 0.35, core_color);
}
}
fn draw_settings_icon(painter: &egui::Painter, center: egui::Pos2, radius: f32, color: Color32) {
let track_h = radius * 1.05;
let track_spacing = radius * 0.48;
let track_stroke = Stroke::new(1.8_f32, Color32::from_rgba_unmultiplied(color.r(), color.g(), color.b(), 140));
// 3 vertical tracks
let xs = [-track_spacing, 0.0, track_spacing];
for &x_off in &xs {
let x = center.x + x_off;
painter.line_segment(
[egui::pos2(x, center.y - track_h), egui::pos2(x, center.y + track_h)],
track_stroke,
);
}
// 3 slider knobs positioned at different heights for dynamic equalizer / settings look
let knob_w = radius * 0.42;
let knob_h = radius * 0.22;
let knob_offsets = [
(-track_spacing, -track_h * 0.35),
(0.0, track_h * 0.40),
(track_spacing, -track_h * 0.10),
];
for (x_off, y_off) in knob_offsets {
let knob_rect = egui::Rect::from_center_size(
center + Vec2::new(x_off, y_off),
Vec2::new(knob_w, knob_h),
);
painter.rect_filled(knob_rect, CornerRadius::ZERO, color);
}
}
// Modern Sleek Action Card Renderer
#[allow(clippy::too_many_arguments)]
fn render_action_card(
ui: &mut egui::Ui,
width: f32,
height: f32,
title: &str,
is_active: bool,
dropdown_open: bool,
draw_icon: impl FnOnce(&egui::Painter, egui::Pos2),
status_text: &str,
status_color: Color32,
sub_text: &str,
accent: Color32,
) -> bool {
let (raw_rect, response) = ui.allocate_exact_size(Vec2::new(width, height), egui::Sense::click());
let rect = egui::Rect::from_min_size(
egui::pos2(raw_rect.left().round(), raw_rect.top().round()),
Vec2::new(width.round(), height.round()),
);
let hovered = response.hovered();
let painter = ui.painter();
// Neutral translucent black card fill (pure black, zero blue hue, zero accent fill)
let bg = if dropdown_open {
Color32::from_rgba_unmultiplied(18, 18, 18, 175)
} else if hovered {
Color32::from_rgba_unmultiplied(22, 22, 22, 180)
} else {
Color32::from_rgba_unmultiplied(10, 10, 10, 155)
};
painter.rect_filled(rect, CornerRadius::ZERO, bg);
// ONLY the selected card gets the accent outline and revamped smooth glowing bloom
if dropdown_open {
let shadow = egui::Shadow {
offset: [0, 0],
blur: 24,
spread: 1,
color: Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 140),
};
painter.add(shadow.as_shape(rect, CornerRadius::ZERO));
// Crisp 1px core accent outline for the selected card
painter.rect_stroke(
rect,
CornerRadius::ZERO,
Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 230)),
egui::StrokeKind::Inside,
);
}
// Card Title (clean modern sans typography)
painter.text(
egui::pos2(rect.center().x, rect.top() + 25.0),
egui::Align2::CENTER_CENTER,
title,
FontId::proportional(14.0),
if is_active { accent } else { Color32::WHITE },
);
// Centered vector icon (no ambient fill circle)
let icon_center = egui::pos2(rect.center().x, rect.top() + 85.0);
draw_icon(painter, icon_center);
// Status subtitle (e.g. "01:23" or "Not recording" / "Buffer 60s")
painter.text(
egui::pos2(rect.center().x, rect.bottom() - 32.0),
egui::Align2::CENTER_CENTER,
status_text,
FontId::proportional(11.5),
status_color,
);
// Secondary hint
painter.text(
egui::pos2(rect.center().x, rect.bottom() - 14.0),
egui::Align2::CENTER_CENTER,
sub_text,
FontId::proportional(10.0),
Color32::from_rgb(130, 135, 145),
);
response.clicked()
}
// Modern Sleek Translucent Dropdown Action Menu Container
fn render_dropdown_menu(
ui: &mut egui::Ui,
card_width: f32,
accent: Color32,
add_contents: impl FnOnce(&mut egui::Ui),
) {
ui.add_space(6.0);
let shadow = egui::Shadow {
offset: [0, 0],
blur: 20,
spread: 1,
color: Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 90),
};
egui::Frame::NONE
.fill(Color32::from_rgba_unmultiplied(10, 10, 10, 185))
.stroke(Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 180)))
.shadow(shadow)
.corner_radius(CornerRadius::ZERO)
.inner_margin(Margin::ZERO)
.show(ui, |ui| {
ui.spacing_mut().item_spacing = Vec2::ZERO;
ui.set_width(card_width);
ui.set_min_width(card_width);
ui.set_max_width(card_width);
add_contents(ui);
});
}
// Remade Dropdown Action Menu Item (Left-Aligned, Subtitles, Hotkey Badges, Left Indicator)
fn render_menu_item(
ui: &mut egui::Ui,
title: &str,
subtitle: Option<&str>,
hotkey_hint: Option<&str>,
is_active: bool,
accent: Color32,
is_last: bool,
) -> bool {
let (raw_rect, response) = ui.allocate_exact_size(Vec2::new(ui.available_width(), 44.0), egui::Sense::click());
let rect = egui::Rect::from_min_size(
egui::pos2(raw_rect.left().round(), raw_rect.top().round()),
Vec2::new(raw_rect.width().round(), 44.0),
);
let hovered = response.hovered();
let bg = if hovered {
Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 36)
} else {
Color32::TRANSPARENT
};
ui.painter().rect_filled(rect, CornerRadius::ZERO, bg);
// Left vertical accent indicator bar on hover
if hovered {
let left_bar = egui::Rect::from_min_size(rect.min, Vec2::new(3.0, rect.height()));
ui.painter().rect_filled(left_bar, CornerRadius::ZERO, accent);
}
// Left-aligned Title
let title_color = if hovered {
accent
} else if is_active {
Color32::WHITE
} else {
Color32::from_rgb(222, 226, 234)
};
let title_y = if subtitle.is_some() { rect.top() + 13.0 } else { rect.center().y };
ui.painter().text(
egui::pos2(rect.left() + 14.0, title_y),
egui::Align2::LEFT_CENTER,
title,
FontId::proportional(12.5),
title_color,
);
// Subtitle under Title
if let Some(sub) = subtitle {
ui.painter().text(
egui::pos2(rect.left() + 14.0, rect.bottom() - 12.0),
egui::Align2::LEFT_CENTER,
sub,
FontId::proportional(10.0),
Color32::from_rgb(135, 140, 150),
);
}
// Right-aligned Hotkey Badge (dynamically sized to fit user-configured hotkeys)
if let Some(hk) = hotkey_hint {
let badge_w = (hk.len() as f32 * 6.5 + 14.0).max(52.0);
let badge_rect = egui::Rect::from_center_size(
egui::pos2(rect.right() - badge_w / 2.0 - 10.0, rect.center().y),
Vec2::new(badge_w, 18.0),
);
ui.painter().rect_filled(
badge_rect,
CornerRadius::ZERO,
Color32::from_rgba_unmultiplied(255, 255, 255, 14),
);
ui.painter().rect_stroke(
badge_rect,
CornerRadius::ZERO,
Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 22)),
egui::StrokeKind::Inside,
);
ui.painter().text(
badge_rect.center(),
egui::Align2::CENTER_CENTER,
hk,
FontId::monospace(9.0),
if hovered { accent } else { Color32::from_rgb(180, 185, 195) },
);
}
// Clean subtle 1px divider between items (not drawn on last item so it stays flush)
if !is_last && !hovered {
ui.painter().line_segment(
[egui::pos2(rect.left() + 8.0, rect.bottom()), egui::pos2(rect.right() - 8.0, rect.bottom())],
Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 14)),
);
}
response.clicked()
}
// Section card helper for Settings view
fn render_section_card(ui: &mut egui::Ui, header: &str, accent: Color32, add_contents: impl FnOnce(&mut egui::Ui)) {
egui::Frame::NONE
.fill(Color32::from_rgba_unmultiplied(16, 17, 21, 240))
.stroke(Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 20)))
.corner_radius(CornerRadius::ZERO)
.inner_margin(Margin::symmetric(16_i8, 12_i8))
.show(ui, |ui| {
ui.set_width(ui.available_width());
ui.label(
egui::RichText::new(header)
.size(11.5)
.strong()
.color(accent),
);
ui.add_space(6.0);
add_contents(ui);
});
}
pub struct ScytheOverlayApp {
config: ScytheConfig,
status: DaemonStatus,
daemon_connected: bool,
current_view: ShadowPlayView,
replay_dropdown_open: bool,
record_dropdown_open: bool,
output_dir: String,
replay_sec: u32,
bitrate_mbps: u32,
target_fps: u32,
video_codec: String,
audio_mode_idx: usize,
show_cursor: bool,
mic_volume_pct: u32,
system_volume_pct: u32,
mic_vu: f32,
sys_vu: f32,
selected_clip_idx: Option<usize>,
trim_start_sec: f32,
trim_end_sec: f32,
trim_status_msg: Option<(String, Instant)>,
clip_duration_sec: f32,
anim_time: f32,
status_rx: Receiver<DaemonStatus>,
folder_tx: Sender<String>,
folder_rx: Receiver<String>,
folder_picking_active: Arc<AtomicBool>,
clips: Vec<VideoClipInfo>,
initial_pos_set: bool,
listening_keybind: Option<KeybindAction>,
fps_input_str: String,
bitrate_input_str: String,
replay_sec_input_str: String,
panel_rect: egui::Rect,
frame_count: u32,
update_status: Arc<std::sync::Mutex<crate::updater::UpdateStatus>>,
update_dismissed: bool,
auto_check_updates: bool,
autostart_replay: bool,
autostart_overlay: bool,
hud_notification: Option<HudNotification>,
}
#[derive(Clone, Debug)]
pub struct HudNotification {
pub title: String,
pub subtitle: String,
pub icon: crate::overlay::ToastIcon,
pub start_time: Instant,
pub duration_secs: f32,
}
pub type VrecOverlayApp = ScytheOverlayApp;
impl Default for ScytheOverlayApp {
fn default() -> Self {
Self::new()
}
}
impl ScytheOverlayApp {
pub fn new() -> Self {
let config = ScytheConfig::load();
let replay_sec = config.replay_duration_sec;
let bitrate_mbps = (config.record_bitrate_kbps / 1000).max(1);
let target_fps = config.fps;
let output_dir = config.output_directory.clone();
let show_cursor = config.show_cursor;
let video_codec = config.video_codec.clone();
let mic_volume_pct = (config.mic_volume * 100.0).round().clamp(0.0, 200.0) as u32;
let system_volume_pct = (config.system_volume * 100.0).round().clamp(0.0, 200.0) as u32;
let audio_mode_idx = match config.audio_mode.as_str() {
"mic" => 1,
"both" => 2,
"muted" => 3,
_ => 0,
};
let (status_tx, status_rx) = channel::<DaemonStatus>();
std::thread::spawn(move || {
loop {
if let Ok(s) = ipc::query_status() {
let _ = status_tx.send(s);
}
std::thread::sleep(Duration::from_millis(150));
}
});
let (folder_tx, folder_rx) = channel::<String>();
let folder_picking_active = Arc::new(AtomicBool::new(false));
let clips = scan_recordings(&output_dir);
let fps_input_str = target_fps.to_string();
let bitrate_input_str = bitrate_mbps.to_string();
let replay_sec_input_str = replay_sec.to_string();
let auto_check_updates = config.auto_check_updates;
let autostart_replay = config.autostart_replay;
let autostart_overlay = config.autostart_overlay;
let update_status = Arc::new(std::sync::Mutex::new(crate::updater::UpdateStatus::Idle));
if auto_check_updates {
crate::updater::spawn_update_check(update_status.clone());
}
Self {
config,
status: DaemonStatus::default(),
daemon_connected: false,
current_view: ShadowPlayView::MainHud,
replay_dropdown_open: false,
record_dropdown_open: false,
output_dir,
replay_sec,
bitrate_mbps,
target_fps,
video_codec,
audio_mode_idx,
show_cursor,
mic_volume_pct,
system_volume_pct,
mic_vu: 0.0,
sys_vu: 0.0,
selected_clip_idx: None,
trim_start_sec: 0.0,
trim_end_sec: 30.0,
trim_status_msg: None,
clip_duration_sec: 0.0,
anim_time: 0.0,
status_rx,
folder_tx,
folder_rx,
folder_picking_active,
clips,
initial_pos_set: false,
listening_keybind: None,
fps_input_str,
bitrate_input_str,
replay_sec_input_str,
panel_rect: egui::Rect::NOTHING,
frame_count: 0,
update_status,
update_dismissed: false,
auto_check_updates,
autostart_replay,
autostart_overlay,
hud_notification: None,
}
}
pub fn show_hud_notification(&mut self, title: &str, subtitle: &str, icon: crate::overlay::ToastIcon) {
self.hud_notification = Some(HudNotification {
title: title.to_string(),
subtitle: subtitle.to_string(),
icon,
start_time: Instant::now(),
duration_secs: 2.8,
});
}
pub fn accent_color(&self) -> Color32 {
resolve_accent_color(&self.config.accent_color)
}
pub fn accent_alpha(&self, alpha: u8) -> Color32 {
let c = self.accent_color();
Color32::from_rgba_unmultiplied(c.r(), c.g(), c.b(), alpha)
}
pub fn refresh_clips(&mut self) {
self.clips = scan_recordings(&self.output_dir);
}
fn poll_async_events(&mut self) {
while let Ok(s) = self.status_rx.try_recv() {
let target_mic = s.mic_level_peak;
let target_sys = s.system_level_peak;
self.mic_vu = if target_mic > self.mic_vu {
target_mic
} else {
self.mic_vu * 0.85 + target_mic * 0.15
};
self.sys_vu = if target_sys > self.sys_vu {
target_sys
} else {
self.sys_vu * 0.85 + target_sys * 0.15
};
self.status = s;
self.daemon_connected = true;
}
while let Ok(new_dir) = self.folder_rx.try_recv() {
if !new_dir.is_empty() {
self.output_dir = new_dir.clone();
self.config.output_directory = new_dir;
let _ = self.config.save();
async_send_command(Command::ReloadConfig);
self.refresh_clips();
}
}
}
pub fn update_window_size(&self, _ctx: &egui::Context) {
// Fullscreen surface handles internal layout dynamically without window resize jitter
}
pub fn switch_view(&mut self, view: ShadowPlayView, _ctx: &egui::Context) {
self.current_view = view;
self.listening_keybind = None;
self.replay_dropdown_open = false;
self.record_dropdown_open = false;
}
fn render_main_hud(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
let anim_time = self.anim_time;
let is_recording = self.status.is_recording;
let rec_dur = self.status.recording_duration_sec;
let is_replay_active = self.status.is_replay_active;
let accent = self.accent_color();
let screen_w = ui.available_width();
let card_w = 210.0;
let card_h = 185.0;
let card_gap = 14.0;
let total_cards_w = 3.0 * card_w + 2.0 * card_gap;
let left_pad = ((screen_w - total_cards_w) / 2.0).max(10.0);
let top_pad = 70.0;
let hud_rect = egui::Rect::from_min_size(
egui::pos2(left_pad, top_pad),
egui::vec2(
total_cards_w,
card_h + 120.0,
),
);
self.panel_rect = hud_rect;
ui.allocate_new_ui(egui::UiBuilder::new().max_rect(hud_rect), |ui| {
ui.vertical_centered(|ui| {
// Voluntary, non-intrusive Update Notification Banner
let cur_update = self.update_status.lock().ok().map(|g| g.clone()).unwrap_or_default();
if let crate::updater::UpdateStatus::Available(ref info) = cur_update
&& !self.update_dismissed {
egui::Frame::NONE
.fill(Color32::from_rgba_unmultiplied(12, 13, 16, 250))
.stroke(Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 160)))
.corner_radius(CornerRadius::ZERO)
.inner_margin(Margin::symmetric(14_i8, 7_i8))
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label(
egui::RichText::new(format!("UPDATE: v{}", info.version))
.size(11.5)
.strong()
.color(accent),
);
ui.label(
egui::RichText::new(format!("(Installed: v{})", crate::updater::CURRENT_VERSION))
.size(10.5)
.color(Color32::from_rgb(150, 150, 155)),
);
ui.add_space(8.0);
if squared_button(ui, "DOWNLOAD", true, accent) {
crate::updater::open_browser_url(&info.html_url);
}
ui.add_space(4.0);
if squared_button(ui, "DISMISS", false, accent) {
self.update_dismissed = true;
}
});
});
ui.add_space(8.0);
}
ui.horizontal_top(|ui| {
ui.spacing_mut().item_spacing = Vec2::new(card_gap, 0.0);
// =========================================================================
// CARD 1: INSTANT REPLAY
// =========================================================================
ui.vertical(|ui| {
ui.set_width(card_w);
ui.set_min_width(card_w);
ui.set_max_width(card_w);
let card1_clicked = render_action_card(
ui,
card_w,
card_h,
"INSTANT REPLAY",
is_replay_active,
self.replay_dropdown_open,
|painter, center| {
draw_replay_icon(painter, center, 24.0, is_replay_active, accent);
},
if is_replay_active { "Turned on" } else { "Turned off" },
if is_replay_active { accent } else { Color32::from_rgb(150, 150, 155) },
"(Click for menu)",
accent,
);
if card1_clicked {
self.replay_dropdown_open = !self.replay_dropdown_open;
self.record_dropdown_open = false;
}
if self.replay_dropdown_open {
render_dropdown_menu(ui, card_w, accent, |ui| {
let toggle_title = if is_replay_active { "Turn off" } else { "Turn on" };
let toggle_sub = if is_replay_active { "Stop background buffer" } else { "Capture continuous replay" };
if render_menu_item(ui, toggle_title, Some(toggle_sub), None, is_replay_active, accent, false) {
let mut cfg = ScytheConfig::load();
cfg.replay_enabled = !cfg.replay_enabled;
let _ = cfg.save();
ScytheConfig::notify_daemon_reload();
self.config.replay_enabled = cfg.replay_enabled;
self.status.is_replay_active = cfg.replay_enabled;
self.replay_dropdown_open = false;
}
let save_hk = self.config.save_hotkey.trim();
let save_hk_opt = if save_hk.is_empty() { None } else { Some(save_hk) };
if render_menu_item(ui, "Save Replay", Some("Export buffer to file"), save_hk_opt, false, accent, true) {
if is_replay_active {
async_send_command(Command::SaveReplay);
self.show_hud_notification("INSTANT REPLAY", "Saved to Videos", crate::overlay::ToastIcon::Replay);
} else {
self.show_hud_notification("INSTANT REPLAY", "Replay is turned off", crate::overlay::ToastIcon::Error);
}
self.replay_dropdown_open = false;
}
});
}
});
// =========================================================================
// CARD 2: RECORD
// =========================================================================
ui.vertical(|ui| {
ui.set_width(card_w);
ui.set_min_width(card_w);
ui.set_max_width(card_w);
let rec_status_str = if is_recording {
let mins = rec_dur / 60;
let secs = rec_dur % 60;
format!("Recording {:02}:{:02}", mins, secs)
} else {
"Not recording".to_string()
};
let card2_clicked = render_action_card(
ui,
card_w,
card_h,
"RECORD",
is_recording,
self.record_dropdown_open,
|painter, center| {
draw_record_icon(painter, center, 24.0, is_recording, anim_time);
},
&rec_status_str,
if is_recording { Color32::from_rgb(239, 68, 68) } else { Color32::from_rgb(150, 150, 155) },
"(Click for menu)",
accent,
);
if card2_clicked {
self.record_dropdown_open = !self.record_dropdown_open;
self.replay_dropdown_open = false;
}
if self.record_dropdown_open {
render_dropdown_menu(ui, card_w, accent, |ui| {
let rec_toggle_title = if is_recording { "Stop Recording" } else { "Start Recording" };
let rec_toggle_sub = if is_recording { "Finalize and save video" } else { "Capture video to disk" };
let rec_hk = self.config.record_hotkey.trim();
let rec_hk_opt = if rec_hk.is_empty() { None } else { Some(rec_hk) };
if render_menu_item(ui, rec_toggle_title, Some(rec_toggle_sub), rec_hk_opt, is_recording, accent, true) {
async_send_command(Command::ToggleRecording);
if is_recording {
self.show_hud_notification("RECORDING", "Recording saved", crate::overlay::ToastIcon::Save);
} else {
self.show_hud_notification("RECORDING", "Recording started", crate::overlay::ToastIcon::Record);
}
self.record_dropdown_open = false;
}
});
}
});
// =========================================================================
// CARD 3: SETTINGS
// =========================================================================
ui.vertical(|ui| {
ui.set_width(card_w);
ui.set_min_width(card_w);
ui.set_max_width(card_w);
let card3_clicked = render_action_card(
ui,
card_w,
card_h,
"SETTINGS",
false,
false,
|painter, center| {
draw_settings_icon(painter, center, 24.0, Color32::from_rgb(150, 150, 155));
},
"Hardware & Tuning",
Color32::from_rgb(150, 150, 155),
"(Click to open)",
accent,
);
if card3_clicked {
self.replay_dropdown_open = false;
self.record_dropdown_open = false;
self.switch_view(ShadowPlayView::Settings, ctx);
}
});
});
});
});
}
fn render_settings_view(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
let screen_w = ui.available_width();
let screen_h = ui.available_height();
let modal_w = 680.0_f32;
let modal_h = (screen_h - 40.0).clamp(660.0, 920.0);
let left_pad = ((screen_w - modal_w) / 2.0).max(10.0);
let top_pad = ((screen_h - modal_h) / 2.0).max(15.0);
let accent = self.accent_color();
let modal_rect = egui::Rect::from_min_size(egui::pos2(left_pad, top_pad), egui::vec2(modal_w, modal_h));
self.panel_rect = modal_rect;
ui.allocate_new_ui(egui::UiBuilder::new().max_rect(modal_rect), |ui| {
egui::Frame::NONE
.fill(Color32::from_rgba_unmultiplied(11, 12, 15, 252))
.stroke(Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 140)))
.corner_radius(CornerRadius::ZERO)
.inner_margin(Margin::symmetric(24_i8, 20_i8))
.show(ui, |ui| {
ui.set_width(modal_w - 48.0);
// Portrait Header: Back Button, Title, Close Hint (No X button)
ui.horizontal(|ui| {
let back_btn = egui::Button::new(
egui::RichText::new("< BACK")
.size(11.5)
.strong()
.color(accent),
)
.fill(Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 24))
.stroke(Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 160)))
.corner_radius(CornerRadius::ZERO);
if ui.add(back_btn).clicked() {
self.switch_view(ShadowPlayView::MainHud, ctx);
return;
}
ui.add_space(14.0);
ui.label(
egui::RichText::new("SETTINGS")
.font(FontId::proportional(15.0))
.strong()
.color(Color32::WHITE),
);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
egui::Frame::NONE
.fill(Color32::from_rgba_unmultiplied(255, 255, 255, 12))
.stroke(Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 22)))
.corner_radius(CornerRadius::ZERO)
.inner_margin(Margin::symmetric(9_i8, 4_i8))
.show(ui, |ui| {
ui.label(
egui::RichText::new("ESC TO CLOSE")
.size(10.5)
.strong()
.color(Color32::from_rgb(160, 160, 168)),
);
});
});
});
ui.add_space(14.0);
let scroll_h = modal_h - 115.0;
egui::ScrollArea::vertical()
.max_height(scroll_h)
.auto_shrink([false, false])
.show(ui, |ui| {
// -----------------------------------------------------------------
// SECTION 1: SYSTEM & STARTUP
// -----------------------------------------------------------------
render_section_card(ui, "SYSTEM & STARTUP", accent, |ui| {
// Autostart Instant Replay
ui.horizontal(|ui| {
ui.vertical(|ui| {
ui.label(egui::RichText::new("Autostart Instant Replay").size(12.5).strong().color(Color32::WHITE));
ui.label(egui::RichText::new("Automatically launch the background recording engine on login so replay is always ready.").size(10.5).color(Color32::from_rgb(150, 150, 155)));
});
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
let mut ar = self.autostart_replay;
if toggle_switch(ui, &mut ar, accent).changed() {
self.autostart_replay = ar;
self.config.autostart_replay = ar;
self.config.autostart = ar;
let _ = self.config.save();
if ar {
spawn_daemon_process();
}
self.show_hud_notification(
"AUTOSTART REPLAY",
if ar { "Enabled: Starts on login" } else { "Disabled" },
crate::overlay::ToastIcon::Info,
);
}
});
});
ui.add_space(8.0);
ui.separator();
ui.add_space(8.0);
// Autostart HUD Overlay
ui.horizontal(|ui| {
ui.vertical(|ui| {
ui.label(egui::RichText::new("Autostart HUD Overlay").size(12.5).strong().color(Color32::WHITE));
ui.label(egui::RichText::new("Automatically open the HUD overlay menu when logging into your desktop session.").size(10.5).color(Color32::from_rgb(150, 150, 155)));
});
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
let mut ao = self.autostart_overlay;
if toggle_switch(ui, &mut ao, accent).changed() {
self.autostart_overlay = ao;
self.config.autostart_overlay = ao;
let _ = self.config.save();
self.show_hud_notification(
"AUTOSTART OVERLAY",
if ao { "Enabled: Opens on login" } else { "Disabled" },
crate::overlay::ToastIcon::Info,
);
}
});
});
});
ui.add_space(10.0);
// -----------------------------------------------------------------
// SECTION 2: DISPLAY & CAPTURE
// -----------------------------------------------------------------
render_section_card(ui, "DISPLAY & CAPTURE", accent, |ui| {
// Record Mouse Cursor
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Record Mouse Cursor").size(12.0).strong().color(Color32::WHITE));
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
let mut cur = self.show_cursor;
if toggle_switch(ui, &mut cur, accent).changed() {
self.show_cursor = cur;
self.config.show_cursor = cur;
let _ = self.config.save();
async_send_command(Command::ToggleCursor);
self.show_hud_notification(
"MOUSE CURSOR",
if cur { "Visible in recording" } else { "Hidden from recording" },
crate::overlay::ToastIcon::Cursor,
);
}
});
});
ui.add_space(8.0);
ui.separator();
ui.add_space(8.0);
// Framerate (FPS) with direct input and presets
ui.label(egui::RichText::new("Target Framerate (FPS):").size(12.0).strong().color(Color32::WHITE));
ui.add_space(4.0);
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Custom:").size(11.0).color(Color32::from_rgb(150, 150, 155)));
let edit_resp = ui.add(
egui::TextEdit::singleline(&mut self.fps_input_str)
.desired_width(55.0)
.font(FontId::monospace(11.5))
);
if edit_resp.changed()
&& let Ok(parsed) = self.fps_input_str.trim().parse::<u32>()
&& (15..=360).contains(&parsed) {
self.target_fps = parsed;
}
ui.add_space(8.0);
for fps in [30, 60, 120, 144, 240] {
if squared_button(ui, &fps.to_string(), self.target_fps == fps, accent) {
self.target_fps = fps;
self.fps_input_str = fps.to_string();
}
}
});
ui.add_space(8.0);
// Video Bitrate (Mbps) with direct input, presets, and slider
ui.label(egui::RichText::new("Video Bitrate:").size(12.0).strong().color(Color32::WHITE));
ui.add_space(4.0);
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Custom:").size(11.0).color(Color32::from_rgb(150, 150, 155)));
let edit_resp = ui.add(
egui::TextEdit::singleline(&mut self.bitrate_input_str)
.desired_width(55.0)
.font(FontId::monospace(11.5))
);
if edit_resp.changed()
&& let Ok(parsed) = self.bitrate_input_str.trim().parse::<u32>()
&& (1..=300).contains(&parsed) {
self.bitrate_mbps = parsed;
}
ui.label(egui::RichText::new("Mbps").size(10.5).color(Color32::from_rgb(150, 150, 155)));
ui.add_space(8.0);
for mbps in [10, 20, 35, 50, 80] {
if squared_button(ui, &format!("{}M", mbps), self.bitrate_mbps == mbps, accent) {
self.bitrate_mbps = mbps;
self.bitrate_input_str = mbps.to_string();
}
}
ui.add_space(6.0);
let mut br = self.bitrate_mbps;
if ui.add(egui::Slider::new(&mut br, 5..=150).suffix(" Mbps").step_by(5.0)).changed() {
self.bitrate_mbps = br;
self.bitrate_input_str = br.to_string();
}
});
ui.add_space(8.0);
// Instant Replay Buffer Duration with direct input and presets
ui.label(egui::RichText::new("Instant Replay Buffer Duration:").size(12.0).strong().color(Color32::WHITE));
ui.add_space(4.0);
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Custom (sec):").size(11.0).color(Color32::from_rgb(150, 150, 155)));
let edit_resp = ui.add(
egui::TextEdit::singleline(&mut self.replay_sec_input_str)
.desired_width(55.0)
.font(FontId::monospace(11.5))
);
if edit_resp.changed()
&& let Ok(parsed) = self.replay_sec_input_str.trim().parse::<u32>()
&& (5..=1800).contains(&parsed) {
self.replay_sec = parsed;
}
ui.label(egui::RichText::new("sec").size(10.5).color(Color32::from_rgb(150, 150, 155)));
ui.add_space(8.0);
for sec in [15, 30, 60, 120, 300] {
let label = if sec >= 60 { format!("{}m", sec / 60) } else { format!("{}s", sec) };
if squared_button(ui, &label, self.replay_sec == sec, accent) {
self.replay_sec = sec;
self.replay_sec_input_str = sec.to_string();
}
}
});
ui.add_space(8.0);
// Encoder Codec
ui.label(egui::RichText::new("Encoder Codec:").size(12.0).strong().color(Color32::WHITE));
ui.add_space(4.0);
ui.horizontal(|ui| {
for (codec_key, label) in [("h264", "H.264"), ("hevc", "HEVC / H.265"), ("av1", "AV1")] {
if squared_button(ui, label, self.video_codec == codec_key, accent) {
self.video_codec = codec_key.to_string();
}
}
});
});
ui.add_space(10.0);
// -----------------------------------------------------------------
// SECTION 2: AUDIO CONFIGURATION
// -----------------------------------------------------------------
render_section_card(ui, "AUDIO CONFIGURATION", accent, |ui| {
ui.label(egui::RichText::new("Audio Source:").size(12.0).strong().color(Color32::WHITE));
ui.add_space(4.0);
ui.horizontal(|ui| {
let modes = [("system", "System"), ("mic", "Microphone"), ("both", "Both"), ("muted", "Muted")];
for (idx, (_, m_label)) in modes.iter().enumerate() {
if squared_button(ui, m_label, self.audio_mode_idx == idx, accent) {
self.audio_mode_idx = idx;
}
}
});
ui.add_space(8.0);
// Mic Volume + VU
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Mic Vol:").size(12.0).strong().color(Color32::WHITE));
let mut mv = self.mic_volume_pct;
if ui.add(egui::Slider::new(&mut mv, 0..=200).suffix("%")).changed() {
self.mic_volume_pct = mv;
}
ui.add_space(6.0);
render_vu_meter(ui, self.mic_vu, 65.0, 18.0, "MIC");
});
ui.add_space(8.0);
// System Audio Volume + VU
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Sys Vol:").size(12.0).strong().color(Color32::WHITE));
let mut sv = self.system_volume_pct;
if ui.add(egui::Slider::new(&mut sv, 0..=200).suffix("%")).changed() {
self.system_volume_pct = sv;
}
ui.add_space(6.0);
render_vu_meter(ui, self.sys_vu, 65.0, 18.0, "SYS");
});
});
ui.add_space(10.0);
// -----------------------------------------------------------------
// SECTION 3: KEYBOARD SHORTCUTS (INTERACTIVE REBINDING)
// -----------------------------------------------------------------
render_section_card(ui, "KEYBOARD SHORTCUTS (CLICK TO REBIND)", accent, |ui| {
let binds = [
(KeybindAction::Menu, "Menu Overlay", &self.config.menu_hotkey),
(KeybindAction::SaveReplay, "Save Instant Replay", &self.config.save_hotkey),
(KeybindAction::ToggleRecord, "Start / Stop Record", &self.config.record_hotkey),
(KeybindAction::ToggleCursor, "Toggle Mouse Cursor", &self.config.cursor_hotkey),
];
for (action, label, current_hotkey) in binds {
let is_listening = self.listening_keybind == Some(action);
ui.horizontal(|ui| {
ui.label(
egui::RichText::new(label)
.size(12.0)
.color(if is_listening { accent } else { Color32::from_rgb(203, 213, 225) }),
);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if render_keycap_button(ui, current_hotkey, is_listening, accent) {
if is_listening {
self.listening_keybind = None;
} else {
self.listening_keybind = Some(action);
}
}
});
});
ui.add_space(6.0);
}
if self.listening_keybind.is_some() {
ui.add_space(4.0);
ui.label(
egui::RichText::new("Listening... Press your desired key combination or Esc to cancel.")
.size(11.0)
.strong()
.color(accent),
);
}
ui.add_space(4.0);
ui.horizontal(|ui| {
if squared_button(ui, "Reset Hotkeys to Defaults", false, accent) {
let old_menu = self.config.menu_hotkey.clone();
let old_save = self.config.save_hotkey.clone();
let old_rec = self.config.record_hotkey.clone();
let old_cur = self.config.cursor_hotkey.clone();
crate::hyprland_binds::unbind_hotkey_async(&old_menu);
crate::hyprland_binds::unbind_hotkey_async(&old_save);
crate::hyprland_binds::unbind_hotkey_async(&old_rec);
crate::hyprland_binds::unbind_hotkey_async(&old_cur);
self.config.menu_hotkey = "Alt+Z".to_string();
self.config.save_hotkey = "Ctrl+Shift+R".to_string();
self.config.record_hotkey = "Ctrl+Shift+F9".to_string();
self.config.cursor_hotkey = "Ctrl+Shift+F10".to_string();
let _ = self.config.save();
crate::hyprland_binds::register_hyprland_binds_async(&self.config);
crate::config::ScytheConfig::notify_daemon_reload();
self.show_hud_notification("KEYBINDS", "Restored default hotkeys", crate::overlay::ToastIcon::Info);
}
});
});
ui.add_space(10.0);
// -----------------------------------------------------------------
// SECTION 5: STORAGE & FILE NAMING
// -----------------------------------------------------------------
render_section_card(ui, "STORAGE & FILE NAMING", accent, |ui| {
ui.label(egui::RichText::new("Save Folder:").size(12.0).strong().color(Color32::WHITE));
ui.add_space(3.0);
ui.horizontal(|ui| {
ui.add(egui::TextEdit::singleline(&mut self.output_dir).desired_width(340.0));
if squared_button(ui, "Change", false, accent) {
pick_folder(&self.output_dir, self.folder_tx.clone(), self.folder_picking_active.clone());
}
if squared_button(ui, "Open", false, accent) {
open_folder(&ScytheConfig::expand_tilde(&self.output_dir));
}
});
ui.add_space(8.0);
ui.separator();
ui.add_space(8.0);
ui.label(egui::RichText::new("Default File Naming Format:").size(12.0).strong().color(Color32::WHITE));
ui.add_space(3.0);
let sample_replay = ScytheConfig::format_video_filename("Replay", "mp4");
let sample_record = ScytheConfig::format_video_filename("Recording", "mp4");
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Template:").size(11.0).color(Color32::from_rgb(150, 150, 155)));
ui.label(egui::RichText::new("Prefix-Timestamp_Date_Month_Year.mp4").size(11.0).font(FontId::monospace(11.0)).color(accent));
});
ui.add_space(2.0);
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Instant Replay:").size(11.0).color(Color32::from_rgb(150, 150, 155)));
ui.label(egui::RichText::new(&sample_replay).size(11.0).font(FontId::monospace(11.0)).color(Color32::WHITE));
});
ui.add_space(2.0);
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Manual Record:").size(11.0).color(Color32::from_rgb(150, 150, 155)));
ui.label(egui::RichText::new(&sample_record).size(11.0).font(FontId::monospace(11.0)).color(Color32::WHITE));
});
});
ui.add_space(10.0);
// -----------------------------------------------------------------
// SECTION 5: ACCENT COLOR THEME (AT THE BOTTOM)
// -----------------------------------------------------------------
render_section_card(ui, "ACCENT COLOR THEME", accent, |ui| {
ui.label(egui::RichText::new("Select Interface Accent Color:").size(12.0).strong().color(Color32::WHITE));
ui.add_space(6.0);
ui.horizontal_wrapped(|ui| {
let palettes = [
("blue", "Charming Blue", Color32::from_rgb(56, 189, 248)),
("cyan", "Cyber Cyan", Color32::from_rgb(6, 182, 212)),
("green", "Emerald Green", Color32::from_rgb(34, 197, 94)),
("purple", "Royal Purple", Color32::from_rgb(168, 85, 247)),
("amber", "Sunset Amber", Color32::from_rgb(245, 158, 11)),
("red", "Crimson Red", Color32::from_rgb(239, 68, 68)),
];
for (id, name, col) in palettes {
let is_sel = self.config.accent_color.to_lowercase() == id;
let bg = if is_sel {
Color32::from_rgba_unmultiplied(col.r(), col.g(), col.b(), 50)
} else {
Color32::from_rgba_unmultiplied(col.r(), col.g(), col.b(), 16)
};
// Colored border with each color's respective look
let stroke = Stroke::new(if is_sel { 2.0_f32 } else { 1.2_f32 }, col);
let btn = egui::Button::new(
egui::RichText::new(name)
.size(11.5)
.strong()
.color(if is_sel { Color32::WHITE } else { Color32::from_rgb(226, 232, 240) }),
)
.fill(bg)
.stroke(stroke)
.corner_radius(CornerRadius::ZERO)
.min_size(Vec2::new(140.0, 30.0));
if ui.add(btn).clicked() {
self.config.accent_color = id.to_string();
let _ = self.config.save();
self.show_hud_notification("THEME ACCENT", &format!("Selected: {}", name), crate::overlay::ToastIcon::Info);
}
}
});
});
ui.add_space(10.0);
// -----------------------------------------------------------------
// SECTION 6: ABOUT & AUTO-UPDATES
// -----------------------------------------------------------------
render_section_card(ui, "ABOUT & AUTO-UPDATES", accent, |ui| {
ui.horizontal(|ui| {
ui.label(
egui::RichText::new(format!("Installed Version: v{}", crate::updater::CURRENT_VERSION))
.size(12.0)
.strong()
.color(Color32::WHITE),
);
ui.add_space(10.0);
let cur_status = self.update_status.lock().ok().map(|g| g.clone()).unwrap_or_default();
match cur_status {
crate::updater::UpdateStatus::Idle => {
if squared_button(ui, "Check for Updates", false, accent) {
crate::updater::spawn_update_check(self.update_status.clone());
}
}
crate::updater::UpdateStatus::Checking => {
ui.label(
egui::RichText::new("Checking for updates...")
.size(11.5)
.color(Color32::from_rgb(150, 150, 155)),
);
}
crate::updater::UpdateStatus::UpToDate { version } => {
ui.label(
egui::RichText::new(format!("✓ Up to date (v{})", version))
.size(11.5)
.color(Color32::from_rgb(34, 197, 94))
.strong(),
);
ui.add_space(6.0);
if squared_button(ui, "Check Again", false, accent) {
crate::updater::spawn_update_check(self.update_status.clone());
}
}
crate::updater::UpdateStatus::Available(info) => {
ui.label(
egui::RichText::new(format!("New version available: v{}", info.version))
.size(11.5)
.color(Color32::from_rgb(245, 158, 11))
.strong(),
);
ui.add_space(6.0);
if squared_button(ui, "VIEW RELEASE / DOWNLOAD", true, accent) {
crate::updater::open_browser_url(&info.html_url);
}
}
crate::updater::UpdateStatus::Failed(err) => {
ui.label(
egui::RichText::new(format!("Offline or error: {}", err))
.size(11.0)
.color(Color32::from_rgb(239, 68, 68)),
);
ui.add_space(6.0);
if squared_button(ui, "Retry", false, accent) {
crate::updater::spawn_update_check(self.update_status.clone());
}
}
}
});
ui.add_space(6.0);
ui.checkbox(
&mut self.auto_check_updates,
egui::RichText::new("Automatically check for updates on startup")
.size(11.5)
.color(Color32::from_rgb(226, 232, 240)),
);
});
ui.add_space(14.0);
// BOTTOM ACTIONS (RESET DEFAULTS + APPLY & SAVE)
ui.horizontal(|ui| {
let reset_btn = egui::Button::new(
egui::RichText::new("RESET DEFAULTS")
.font(FontId::proportional(11.5))
.color(Color32::from_rgb(180, 180, 190)),
)
.fill(Color32::from_rgba_unmultiplied(255, 255, 255, 14))
.stroke(Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 28)))
.corner_radius(CornerRadius::ZERO)
.min_size(Vec2::new(135.0, 38.0));
if ui.add(reset_btn).clicked() {
let def = ScytheConfig::default();
self.target_fps = def.fps;
self.fps_input_str = def.fps.to_string();
self.bitrate_mbps = def.record_bitrate_kbps / 1000;
self.bitrate_input_str = self.bitrate_mbps.to_string();
self.replay_sec = def.replay_duration_sec;
self.replay_sec_input_str = def.replay_duration_sec.to_string();
self.video_codec = def.video_codec;
self.show_cursor = def.show_cursor;
self.mic_volume_pct = (def.mic_volume * 100.0) as u32;
self.system_volume_pct = (def.system_volume * 100.0) as u32;
self.autostart_replay = def.autostart_replay;
self.autostart_overlay = def.autostart_overlay;
self.show_hud_notification("DEFAULTS", "Settings restored to defaults", crate::overlay::ToastIcon::Info);
}
ui.add_space(8.0);
let apply_btn = egui::Button::new(
egui::RichText::new("APPLY & SAVE SETTINGS")
.font(FontId::proportional(12.5))
.strong()
.color(Color32::from_rgb(11, 18, 4)),
)
.fill(accent)
.stroke(Stroke::NONE)
.corner_radius(CornerRadius::ZERO)
.min_size(Vec2::new(ui.available_width(), 38.0));
if ui.add(apply_btn).clicked() {
self.config.show_cursor = self.show_cursor;
self.config.fps = self.target_fps;
self.config.record_bitrate_kbps = self.bitrate_mbps * 1000;
self.config.replay_bitrate_kbps = self.bitrate_mbps * 1000;
self.config.video_codec = self.video_codec.clone();
self.config.replay_duration_sec = self.replay_sec;
self.config.output_directory = self.output_dir.clone();
self.config.mic_volume = self.mic_volume_pct as f32 / 100.0;
self.config.system_volume = self.system_volume_pct as f32 / 100.0;
self.config.audio_mode = match self.audio_mode_idx {
1 => "mic".to_string(),
2 => "both".to_string(),
3 => "muted".to_string(),
_ => "system".to_string(),
};
self.config.auto_check_updates = self.auto_check_updates;
self.config.autostart_replay = self.autostart_replay;
self.config.autostart_overlay = self.autostart_overlay;
self.config.autostart = self.autostart_replay;
let _ = self.config.save();
crate::hyprland_binds::register_hyprland_binds(&self.config);
crate::config::ScytheConfig::notify_daemon_reload();
self.show_hud_notification("SETTINGS", "Settings Saved & Applied!", crate::overlay::ToastIcon::Info);
self.switch_view(ShadowPlayView::MainHud, ctx);
}
});
});
});
});
}
fn render_gallery_view(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
let screen_w = ui.available_width();
let screen_h = ui.available_height();
let modal_w = 740.0_f32;
let modal_h = (screen_h - 70.0).clamp(520.0, 700.0);
let left_pad = ((screen_w - modal_w) / 2.0).max(10.0);
let top_pad = ((screen_h - modal_h) / 2.0).max(20.0);
let accent = self.accent_color();
let modal_rect = egui::Rect::from_min_size(egui::pos2(left_pad, top_pad), egui::vec2(modal_w, modal_h));
self.panel_rect = modal_rect;
ui.allocate_new_ui(egui::UiBuilder::new().max_rect(modal_rect), |ui| {
egui::Frame::NONE
.fill(Color32::from_rgba_unmultiplied(11, 12, 15, 252))
.stroke(Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 140)))
.corner_radius(CornerRadius::ZERO)
.inner_margin(Margin::symmetric(20_i8, 16_i8))
.show(ui, |ui| {
ui.set_width(modal_w - 40.0);
// Header with Back Button and Refresh
ui.horizontal(|ui| {
let back_btn = egui::Button::new(
egui::RichText::new("< BACK TO SETTINGS")
.size(11.5)
.strong()
.color(accent),
)
.fill(Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 24))
.stroke(Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 160)))
.corner_radius(CornerRadius::ZERO);
if ui.add(back_btn).clicked() {
self.switch_view(ShadowPlayView::Settings, ctx);
return;
}
ui.add_space(12.0);
ui.label(
egui::RichText::new("GALLERY & CLIP TRIMMER")
.font(FontId::proportional(15.0))
.strong()
.color(Color32::WHITE),
);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if squared_button(ui, "REFRESH", false, accent) {
self.refresh_clips();
}
ui.add_space(4.0);
if squared_button(ui, "OPEN FOLDER", false, accent) {
open_folder(&ScytheConfig::expand_tilde(&self.output_dir));
}
});
});
ui.add_space(10.0);
if let Some((msg, ts)) = &self.trim_status_msg
&& ts.elapsed() < Duration::from_secs(4) {
egui::Frame::NONE
.fill(Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 25))
.stroke(Stroke::new(1.0_f32, accent))
.corner_radius(CornerRadius::ZERO)
.inner_margin(Margin::symmetric(10_i8, 6_i8))
.show(ui, |ui| {
ui.label(
egui::RichText::new(msg)
.size(11.5)
.strong()
.color(accent),
);
});
ui.add_space(8.0);
}
// Main two-column split
ui.horizontal(|ui| {
// Left Column: Clips List
ui.vertical(|ui| {
ui.set_width(280.0);
ui.label(egui::RichText::new(format!("RECORDED CLIPS ({})", self.clips.len())).size(11.0).strong().color(Color32::from_rgb(150, 150, 155)));
ui.add_space(4.0);
egui::ScrollArea::vertical()
.max_height(modal_h - 120.0)
.id_salt("gallery_clips_scroll")
.show(ui, |ui| {
if self.clips.is_empty() {
ui.label(egui::RichText::new("No recordings found yet.\nPress hotkeys to capture clips.").size(11.0).color(Color32::from_rgb(120, 120, 126)));
} else {
for (idx, clip) in self.clips.iter().enumerate() {
let is_sel = self.selected_clip_idx == Some(idx);
let card_bg = if is_sel {
Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), 35)
} else {
Color32::from_rgba_unmultiplied(255, 255, 255, 10)
};
let border = if is_sel {
Stroke::new(1.0_f32, accent)
} else {
Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 20))
};
let resp = egui::Frame::NONE
.fill(card_bg)
.stroke(border)
.corner_radius(CornerRadius::ZERO)
.inner_margin(Margin::symmetric(8_i8, 6_i8))
.show(ui, |ui| {
ui.set_width(260.0);
ui.horizontal(|ui| {
let badge_col = if clip.is_replay { accent } else { Color32::from_rgb(239, 68, 68) };
let badge_txt = if clip.is_replay { "REPLAY" } else { "REC" };
let (b_rect, _) = ui.allocate_exact_size(Vec2::new(44.0, 16.0), egui::Sense::hover());
ui.painter().rect_filled(b_rect, CornerRadius::ZERO, badge_col);
ui.painter().text(b_rect.center(), egui::Align2::CENTER_CENTER, badge_txt, FontId::monospace(8.5), Color32::from_rgb(11, 18, 4));
ui.add_space(4.0);
let size_mb = clip.size_bytes as f64 / (1024.0 * 1024.0);
ui.label(egui::RichText::new(format!("{:.1} MB", size_mb)).size(10.0).color(Color32::from_rgb(150, 150, 155)));
});
ui.add_space(2.0);
ui.label(egui::RichText::new(&clip.filename).size(10.5).strong().color(Color32::WHITE));
});
if resp.response.interact(egui::Sense::click()).clicked() {
self.selected_clip_idx = Some(idx);
let dur = probe_duration_sec(&clip.path);
self.clip_duration_sec = dur;
self.trim_start_sec = 0.0;
self.trim_end_sec = if dur > 0.0 { dur } else { 30.0 };
}
ui.add_space(4.0);
}
}
});
});
ui.add_space(16.0);
// Right Column: Preview, Details & Trimmer
ui.vertical(|ui| {
ui.set_width(modal_w - 320.0);
if let Some(idx) = self.selected_clip_idx {
if idx < self.clips.len() {
let clip = self.clips[idx].clone();
let size_mb = clip.size_bytes as f64 / (1024.0 * 1024.0);
render_section_card(ui, "CLIP DETAILS", accent, |ui| {
ui.horizontal(|ui| {
ui.label(egui::RichText::new("File:").size(11.0).strong().color(Color32::WHITE));
ui.label(egui::RichText::new(&clip.filename).size(11.0).color(Color32::from_rgb(203, 213, 225)));
});
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Size:").size(11.0).strong().color(Color32::WHITE));
ui.label(egui::RichText::new(format!("{:.2} MB ({} bytes)", size_mb, clip.size_bytes)).size(10.5).color(Color32::from_rgb(150, 150, 155)));
});
if self.clip_duration_sec > 0.0 {
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Duration:").size(11.0).strong().color(Color32::WHITE));
let total_s = self.clip_duration_sec as u32;
ui.label(egui::RichText::new(format!("{:02}:{:02} ({:.1}s)", total_s / 60, total_s % 60, self.clip_duration_sec)).size(10.5).color(accent));
});
}
ui.add_space(6.0);
ui.horizontal(|ui| {
let play_btn = egui::Button::new(egui::RichText::new("PLAY VIDEO").size(11.0).strong().color(Color32::from_rgb(11, 18, 4)))
.fill(accent)
.stroke(Stroke::NONE)
.corner_radius(CornerRadius::ZERO);
if ui.add(play_btn).clicked() {
play_clip(&clip.path);
}
if squared_button(ui, "SHOW IN FOLDER", false, accent) {
open_folder(&clip.path);
}
let del_btn = egui::Button::new(egui::RichText::new("DELETE").size(11.0).strong().color(Color32::from_rgb(239, 68, 68)))
.fill(Color32::from_rgba_unmultiplied(239, 68, 68, 20))
.stroke(Stroke::new(1.0_f32, Color32::from_rgb(239, 68, 68)))
.corner_radius(CornerRadius::ZERO);
if ui.add(del_btn).clicked() {
let _ = std::fs::remove_file(&clip.path);
self.trim_status_msg = Some((format!("Deleted {}", clip.filename), Instant::now()));
self.selected_clip_idx = None;
self.refresh_clips();
}
});
});
ui.add_space(10.0);
// LOSSLESS TRIMMER SECTION
render_section_card(ui, "LOSSLESS VIDEO TRIMMER", accent, |ui| {
let max_dur = if self.clip_duration_sec > 0.0 { self.clip_duration_sec } else { 300.0 };
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Start Trim:").size(11.0).strong().color(Color32::WHITE));
let mut s = self.trim_start_sec;
if ui.add(egui::Slider::new(&mut s, 0.0..=max_dur).suffix("s")).changed() {
self.trim_start_sec = s.min(self.trim_end_sec);
}
});
ui.add_space(4.0);
ui.horizontal(|ui| {
ui.label(egui::RichText::new("End Trim:").size(11.0).strong().color(Color32::WHITE));
let mut e = self.trim_end_sec;
if ui.add(egui::Slider::new(&mut e, 0.0..=max_dur).suffix("s")).changed() {
self.trim_end_sec = e.max(self.trim_start_sec);
}
});
let trimmed_dur = (self.trim_end_sec - self.trim_start_sec).max(0.0);
ui.add_space(4.0);
ui.label(egui::RichText::new(format!("Trimmed output length: {:.1}s (Instant lossless copy)", trimmed_dur)).size(10.5).color(Color32::from_rgb(150, 150, 155)));
ui.add_space(8.0);
let trim_btn = egui::Button::new(egui::RichText::new("TRIM & EXPORT COPY").size(11.5).strong().color(Color32::from_rgb(11, 18, 4)))
.fill(accent)
.stroke(Stroke::NONE)
.corner_radius(CornerRadius::ZERO)
.min_size(Vec2::new(ui.available_width(), 32.0));
if ui.add(trim_btn).clicked() {
match trim_clip(&clip.path, self.trim_start_sec, self.trim_end_sec) {
Ok(out) => {
let fname = out.file_name().unwrap_or_default().to_string_lossy().to_string();
self.trim_status_msg = Some((format!("Exported trimmed clip: {}", fname), Instant::now()));
self.refresh_clips();
}
Err(e) => {
self.trim_status_msg = Some((format!("Trim failed: {}", e), Instant::now()));
}
}
}
});
}
} else {
render_section_card(ui, "CLIP PREVIEW & TRIMMER", accent, |ui| {
ui.add_space(40.0);
ui.vertical_centered(|ui| {
ui.label(egui::RichText::new("No clip selected").font(FontId::proportional(13.0)).strong().color(Color32::from_rgb(150, 150, 155)));
ui.add_space(6.0);
ui.label(egui::RichText::new("Select a recording or instant replay from the list on the left to inspect, play, or losslessly trim.").size(10.5).color(Color32::from_rgb(120, 120, 126)));
});
ui.add_space(40.0);
});
}
});
});
});
});
}
fn render_slide_notification(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
let accent = self.accent_color();
if let Some(notif) = &self.hud_notification {
let elapsed = notif.start_time.elapsed().as_secs_f32();
if elapsed < notif.duration_secs {
ctx.request_repaint(); // 60 FPS animation
let slide_x = if elapsed < 0.35 {
let t = (elapsed / 0.35).min(1.0);
let ease = 1.0 - (1.0 - t).powi(3);
(1.0 - ease) * 360.0
} else if elapsed < notif.duration_secs - 0.40 {
0.0
} else {
let t = ((elapsed - (notif.duration_secs - 0.40)) / 0.40).min(1.0);
let ease = t.powi(3);
ease * 360.0
};
let screen_w = ui.available_width();
let card_w = 320.0;
let card_h = 56.0;
let toast_rect = egui::Rect::from_min_size(
egui::pos2(screen_w - card_w - 28.0 + slide_x, 28.0),
egui::vec2(card_w, card_h),
);
let painter = ui.painter();
// Drop shadow
painter.rect_filled(
toast_rect.translate(Vec2::new(0.0, 4.0)),
CornerRadius::ZERO,
Color32::from_rgba_unmultiplied(0, 0, 0, 140),
);
// Modern sleek dark glass toast card
painter.rect(
toast_rect,
CornerRadius::ZERO,
Color32::from_rgba_unmultiplied(12, 13, 16, 252),
Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 30)),
egui::StrokeKind::Inside,
);
// Left vertical accent bar
let line_color = if notif.icon == crate::overlay::ToastIcon::Record {
Color32::from_rgb(239, 68, 68)
} else {
accent
};
let accent_line = egui::Rect::from_min_size(toast_rect.min + Vec2::new(1.0, 1.0), Vec2::new(3.5, toast_rect.height() - 2.0));
painter.rect_filled(accent_line, CornerRadius::ZERO, line_color);
// Left icon area (32x32 at center-left)
let icon_center = egui::pos2(toast_rect.left() + 24.0, toast_rect.center().y);
match notif.icon {
crate::overlay::ToastIcon::Replay => {
draw_replay_icon(painter, icon_center, 9.5, true, accent);
}
crate::overlay::ToastIcon::Record => {
painter.circle_filled(icon_center, 5.5, Color32::from_rgb(239, 68, 68));
painter.circle_stroke(icon_center, 9.5, Stroke::new(1.2_f32, Color32::from_rgba_unmultiplied(239, 68, 68, 120)));
}
crate::overlay::ToastIcon::Save => {
let c = icon_center;
let p1 = c + Vec2::new(-5.5, 0.0);
let p2 = c + Vec2::new(-1.5, 4.0);
let p3 = c + Vec2::new(5.5, -4.0);
painter.line_segment([p1, p2], Stroke::new(2.2_f32, accent));
painter.line_segment([p2, p3], Stroke::new(2.2_f32, accent));
}
crate::overlay::ToastIcon::Cursor => {
let c = icon_center;
painter.text(c, egui::Align2::CENTER_CENTER, "⯈", FontId::proportional(14.0), accent);
}
crate::overlay::ToastIcon::Error => {
let c = icon_center;
let red = Color32::from_rgb(239, 68, 68);
painter.line_segment([c + Vec2::new(-4.0, -4.0), c + Vec2::new(4.0, 4.0)], Stroke::new(2.0_f32, red));
painter.line_segment([c + Vec2::new(4.0, -4.0), c + Vec2::new(-4.0, 4.0)], Stroke::new(2.0_f32, red));
}
crate::overlay::ToastIcon::Info => {
painter.circle_filled(icon_center, 5.0, accent);
}
}
// Text stack (Title + Subtitle)
let text_left = toast_rect.left() + 48.0;
painter.text(
egui::pos2(text_left, toast_rect.top() + 19.0),
egui::Align2::LEFT_CENTER,
&notif.title,
FontId::proportional(12.5),
Color32::WHITE,
);
painter.text(
egui::pos2(text_left, toast_rect.top() + 37.0),
egui::Align2::LEFT_CENTER,
&notif.subtitle,
FontId::proportional(11.0),
Color32::from_rgb(160, 160, 168),
);
} else {
self.hud_notification = None;
}
}
}
}
impl eframe::App for ScytheOverlayApp {
fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
[0.0, 0.0, 0.0, 0.0]
}
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
self.poll_async_events();
self.mic_vu = (self.mic_vu * 0.94).max(0.0);
self.sys_vu = (self.sys_vu * 0.94).max(0.0);
self.anim_time += 0.033;
if self.listening_keybind.is_some() || self.hud_notification.is_some() {
ctx.request_repaint();
} else {
ctx.request_repaint_after(Duration::from_millis(16));
}
self.frame_count += 1;
// Auto-position, DWM transparency, and size to monitor on launch
if !self.initial_pos_set && self.frame_count >= 2 {
if let Some(monitor_size) = ctx.input(|i| i.viewport().monitor_size)
&& monitor_size.x > 100.0 && monitor_size.y > 100.0 {
ctx.send_viewport_cmd(egui::ViewportCommand::OuterPosition(egui::pos2(0.0, 0.0)));
ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(monitor_size));
}
#[cfg(target_os = "windows")]
apply_windows_transparency("Scythe");
ctx.send_viewport_cmd(egui::ViewportCommand::Visible(true));
self.initial_pos_set = true;
}
// Handle interactive keybind recording mode
if let Some(action) = self.listening_keybind {
let mut captured_combo: Option<String> = None;
ctx.input(|i| {
for event in &i.events {
if let egui::Event::Key { key, pressed: true, modifiers, .. } = event {
if *key == egui::Key::Escape {
captured_combo = Some("CANCEL".to_string());
break;
}
if let Some(key_name) = format_egui_key(*key) {
let k_lower = key_name.to_lowercase();
if ["alt", "ctrl", "control", "shift", "super", "meta", "command"].contains(&k_lower.as_str()) {
continue;
}
let mut parts = Vec::new();
if modifiers.ctrl {
parts.push("Ctrl");
}
if modifiers.alt {
parts.push("Alt");
}
if modifiers.shift {
parts.push("Shift");
}
if modifiers.command && !modifiers.ctrl {
parts.push("Super");
}
parts.push(&key_name);
captured_combo = Some(parts.join("+"));
break;
}
}
}
});
if let Some(combo) = captured_combo {
if combo == "CANCEL" {
self.listening_keybind = None;
} else {
let (action_name, old_key) = match action {
KeybindAction::Menu => {
let old = self.config.menu_hotkey.clone();
self.config.menu_hotkey = combo.clone();
("Menu Overlay", old)
}
KeybindAction::SaveReplay => {
let old = self.config.save_hotkey.clone();
self.config.save_hotkey = combo.clone();
("Instant Replay", old)
}
KeybindAction::ToggleRecord => {
let old = self.config.record_hotkey.clone();
self.config.record_hotkey = combo.clone();
("Record Toggle", old)
}
KeybindAction::ToggleCursor => {
let old = self.config.cursor_hotkey.clone();
self.config.cursor_hotkey = combo.clone();
("Cursor Toggle", old)
}
};
crate::hyprland_binds::unbind_hotkey_async(&old_key);
let _ = self.config.save();
crate::hyprland_binds::register_hyprland_binds_async(&self.config);
crate::config::ScytheConfig::notify_daemon_reload();
self.show_hud_notification("KEYBIND", &format!("Bound {}: {}", action_name, combo), crate::overlay::ToastIcon::Info);
self.listening_keybind = None;
}
}
} else {
// Normal Escape handling
if !self.folder_picking_active.load(Ordering::SeqCst) && ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
if self.replay_dropdown_open || self.record_dropdown_open {
self.replay_dropdown_open = false;
self.record_dropdown_open = false;
} else {
ctx.send_viewport_cmd(egui::ViewportCommand::Close);
crate::ipc::clean_overlay_pid();
std::process::exit(0);
}
}
// Click outside active panel on darkened background to dismiss
if !self.folder_picking_active.load(Ordering::SeqCst) && ctx.input(|i| i.pointer.primary_clicked())
&& let Some(pos) = ctx.input(|i| i.pointer.interact_pos())
&& self.panel_rect.width() > 10.0 && !self.panel_rect.expand(6.0).contains(pos) {
if self.replay_dropdown_open || self.record_dropdown_open {
self.replay_dropdown_open = false;
self.record_dropdown_open = false;
} else {
ctx.send_viewport_cmd(egui::ViewportCommand::Close);
crate::ipc::clean_overlay_pid();
std::process::exit(0);
}
}
}
let mut visuals = egui::Visuals::dark();
visuals.panel_fill = Color32::TRANSPARENT;
visuals.window_fill = Color32::TRANSPARENT;
visuals.widgets.noninteractive.corner_radius = CornerRadius::ZERO;
visuals.widgets.inactive.corner_radius = CornerRadius::ZERO;
visuals.widgets.hovered.corner_radius = CornerRadius::ZERO;
visuals.widgets.active.corner_radius = CornerRadius::ZERO;
visuals.widgets.open.corner_radius = CornerRadius::ZERO;
visuals.selection.bg_fill = self.accent_color();
ctx.set_visuals(visuals);
// Background screen darkening scrim (translucent dimming so background remains visible)
egui::CentralPanel::default()
.frame(egui::Frame::NONE.fill(Color32::from_rgba_unmultiplied(0, 0, 0, 80)))
.show(ctx, |ui| {
match self.current_view {
ShadowPlayView::MainHud => self.render_main_hud(ctx, ui),
ShadowPlayView::Settings => self.render_settings_view(ctx, ui),
ShadowPlayView::Gallery => self.render_gallery_view(ctx, ui),
}
self.render_slide_notification(ctx, ui);
});
}
}
#[cfg(target_os = "windows")]
pub fn apply_windows_transparency(title: &str) {
unsafe {
use windows::Win32::UI::WindowsAndMessaging::{
EnumWindows, GetWindowThreadProcessId, SetClassLongPtrW, GCLP_HBRBACKGROUND,
};
use windows::Win32::System::Threading::GetCurrentProcessId;
use windows::Win32::Foundation::{BOOL, HWND, LPARAM};
use windows::Win32::Graphics::Dwm::DwmExtendFrameIntoClientArea;
use windows::Win32::UI::Controls::MARGINS;
use windows::Win32::System::LibraryLoader::{GetModuleHandleA, GetProcAddress};
let my_pid = GetCurrentProcessId();
let is_overlay = title == "Scythe";
unsafe extern "system" fn enum_proc(hwnd: HWND, lparam: LPARAM) -> BOOL {
unsafe {
let (my_pid, is_overlay) = {
let ptr = lparam.0 as *const (u32, bool);
*ptr
};
let mut proc_id = 0u32;
GetWindowThreadProcessId(hwnd, Some(&mut proc_id));
if proc_id == my_pid {
// 1. Set window class background brush to 0 (NULL) to prevent GDI white flash
#[cfg(target_pointer_width = "64")]
let _ = SetClassLongPtrW(hwnd, GCLP_HBRBACKGROUND, 0);
// 2. Extend DWM frame margins into the client area
let margins = MARGINS {
cxLeftWidth: -1,
cxRightWidth: -1,
cyTopHeight: -1,
cyBottomHeight: -1,
};
let _ = DwmExtendFrameIntoClientArea(hwnd, &margins);
// 3. Set AccentPolicy via SetWindowCompositionAttribute for true transparency/blur
#[repr(C)]
struct AccentPolicy {
accent_state: u32,
accent_flags: u32,
gradient_color: u32,
animation_id: u32,
}
#[repr(C)]
struct WindowCompositionAttributeData {
attribute: u32, // WCA_ACCENT_POLICY = 19
data: *mut AccentPolicy,
size_of_data: usize,
}
type SetWindowCompositionAttributeFn =
unsafe extern "system" fn(HWND, *mut WindowCompositionAttributeData) -> BOOL;
if let Ok(user32) = GetModuleHandleA(windows::core::s!("user32.dll")) {
if let Some(proc) = GetProcAddress(user32, windows::core::s!("SetWindowCompositionAttribute")) {
let set_wca: SetWindowCompositionAttributeFn = std::mem::transmute(proc);
let mut policy = if is_overlay {
AccentPolicy {
accent_state: 3, // ACCENT_ENABLE_BLURBEHIND
accent_flags: 2,
gradient_color: 0x99101014, // Translucent dark obsidian tint
animation_id: 0,
}
} else {
AccentPolicy {
accent_state: 2, // ACCENT_ENABLE_TRANSPARENTGRADIENT
accent_flags: 2,
gradient_color: 0x00000000, // Fully transparent
animation_id: 0,
}
};
let mut data = WindowCompositionAttributeData {
attribute: 19,
data: &mut policy,
size_of_data: std::mem::size_of::<AccentPolicy>(),
};
let _ = set_wca(hwnd, &mut data);
}
}
}
BOOL(1)
}
}
let ctx_data = (my_pid, is_overlay);
let _ = EnumWindows(Some(enum_proc), LPARAM(&ctx_data as *const _ as isize));
}
}
#[cfg(not(target_os = "windows"))]
pub fn query_focused_monitor_rect() -> (f32, f32, f32, f32) {
// 1. hyprctl monitors -j (Hyprland/Wayland)
if let Ok(out) = std::process::Command::new("hyprctl").args(["monitors", "-j"]).output()
&& let Ok(v) = serde_json::from_slice::<Vec<serde_json::Value>>(&out.stdout) {
let focused = v.iter().find(|m| m["focused"].as_bool().unwrap_or(false))
.or_else(|| v.first());
if let Some(m) = focused {
let x = m["x"].as_f64().unwrap_or(0.0) as f32;
let y = m["y"].as_f64().unwrap_or(0.0) as f32;
let w = m["width"].as_f64().unwrap_or(1920.0) as f32;
let h = m["height"].as_f64().unwrap_or(1080.0) as f32;
let scale = m["scale"].as_f64().unwrap_or(1.0) as f32;
let lw = if scale > 0.0 { w / scale } else { w };
let lh = if scale > 0.0 { h / scale } else { h };
let lx = if scale > 0.0 { x / scale } else { x };
let ly = if scale > 0.0 { y / scale } else { y };
if lw > 320.0 && lh > 200.0 {
return (lx, ly, lw, lh);
}
}
}
// 2. xrandr fallback (X11 / XWayland)
if let Ok(out) = std::process::Command::new("xrandr").output()
&& let Ok(text) = std::str::from_utf8(&out.stdout) {
for line in text.lines() {
if line.contains(" connected") {
for part in line.split_whitespace() {
if part.contains('x') && part.contains('+') {
let parts: Vec<&str> = part.split('+').collect();
if parts.len() >= 3 {
let dims: Vec<&str> = parts[0].split('x').collect();
if dims.len() == 2
&& let (Ok(w), Ok(h), Ok(x), Ok(y)) = (
dims[0].parse::<f32>(),
dims[1].parse::<f32>(),
parts[1].parse::<f32>(),
parts[2].parse::<f32>(),
)
&& w > 320.0 && h > 200.0 {
return (x, y, w, h);
}
}
}
}
}
}
}
(0.0, 0.0, 1920.0, 1080.0)
}
pub fn run_egui_overlay() {
#[cfg(target_os = "windows")]
let (screen_x, screen_y, screen_w, screen_h): (f32, f32, f32, f32) = unsafe {
use windows::Win32::UI::WindowsAndMessaging::{GetSystemMetrics, SM_CXSCREEN, SM_CYSCREEN};
let w = GetSystemMetrics(SM_CXSCREEN) as f32;
let h = GetSystemMetrics(SM_CYSCREEN) as f32;
let sw = if w > 100.0 { w } else { 1920.0 };
let sh = if h > 100.0 { h } else { 1080.0 };
(0.0, 0.0, sw, sh)
};
#[cfg(not(target_os = "windows"))]
let (screen_x, screen_y, screen_w, screen_h) = query_focused_monitor_rect();
let options = eframe::NativeOptions {
viewport: egui::ViewportBuilder::default()
.with_title("Scythe")
.with_app_id("scythe-overlay")
.with_position([screen_x, screen_y])
.with_inner_size([screen_w, screen_h])
.with_maximized(false)
.with_resizable(false)
.with_decorations(false)
.with_transparent(true)
.with_visible(false)
.with_always_on_top(),
..Default::default()
};
let _ = eframe::run_native(
"scythe-overlay",
options,
Box::new(|cc| {
setup_custom_fonts(&cc.egui_ctx);
Ok(Box::new(ScytheOverlayApp::new()))
}),
);
crate::ipc::clean_overlay_pid();
}
pub struct ShadowPlayToastApp {
title: String,
subtitle: String,
icon: crate::overlay::ToastIcon,
accent: Color32,
created_at: Instant,
duration: Duration,
initial_setup: bool,
}
impl eframe::App for ShadowPlayToastApp {
fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
[0.0, 0.0, 0.0, 0.0]
}
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
if !self.initial_setup {
if let Some(mon_size) = ctx.input(|i| i.viewport().monitor_size) {
let toast_w = 340.0;
let target_x = (mon_size.x - toast_w - 28.0).max(10.0);
let target_y = 28.0;
ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(Vec2::new(toast_w, 64.0)));
ctx.send_viewport_cmd(egui::ViewportCommand::OuterPosition(egui::pos2(target_x, target_y)));
}
#[cfg(target_os = "windows")]
apply_windows_transparency("Scythe Notification");
ctx.send_viewport_cmd(egui::ViewportCommand::Visible(true));
self.initial_setup = true;
}
let elapsed = self.created_at.elapsed().as_secs_f32();
let total_dur = self.duration.as_secs_f32();
if elapsed >= total_dur {
crate::ipc::clean_toast_pid();
ctx.send_viewport_cmd(egui::ViewportCommand::Close);
return;
}
ctx.request_repaint_after(Duration::from_millis(16));
let slide_x = if elapsed < 0.35 {
let t = (elapsed / 0.35).min(1.0);
let ease = 1.0 - (1.0 - t).powi(3);
(1.0 - ease) * 340.0
} else if elapsed < total_dur - 0.40 {
0.0
} else {
let t = ((elapsed - (total_dur - 0.40)) / 0.40).min(1.0);
let ease = t.powi(3);
ease * 340.0
};
let mut visuals = egui::Visuals::dark();
visuals.panel_fill = Color32::TRANSPARENT;
visuals.window_fill = Color32::TRANSPARENT;
ctx.set_visuals(visuals);
egui::CentralPanel::default()
.frame(egui::Frame::NONE.fill(Color32::TRANSPARENT))
.show(ctx, |ui| {
let rect = egui::Rect::from_min_size(
egui::pos2(slide_x + 10.0, 4.0),
Vec2::new(320.0, 56.0),
);
let painter = ui.painter();
// Drop shadow
painter.rect_filled(
rect.translate(Vec2::new(0.0, 4.0)),
CornerRadius::ZERO,
Color32::from_rgba_unmultiplied(0, 0, 0, 140),
);
// Modern sleek dark glass toast card
painter.rect(
rect,
CornerRadius::ZERO,
Color32::from_rgba_unmultiplied(12, 13, 16, 252),
Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 30)),
egui::StrokeKind::Inside,
);
// Left accent line
let line_color = if self.icon == crate::overlay::ToastIcon::Record {
Color32::from_rgb(239, 68, 68)
} else {
self.accent
};
let accent_line = egui::Rect::from_min_size(rect.min + Vec2::new(1.0, 1.0), Vec2::new(3.5, rect.height() - 2.0));
painter.rect_filled(accent_line, CornerRadius::ZERO, line_color);
// Left icon area (32x32 at center-left)
let icon_center = egui::pos2(rect.left() + 24.0, rect.center().y);
match self.icon {
crate::overlay::ToastIcon::Replay => {
draw_replay_icon(painter, icon_center, 9.5, true, self.accent);
}
crate::overlay::ToastIcon::Record => {
painter.circle_filled(icon_center, 5.5, Color32::from_rgb(239, 68, 68));
painter.circle_stroke(icon_center, 9.5, Stroke::new(1.2_f32, Color32::from_rgba_unmultiplied(239, 68, 68, 120)));
}
crate::overlay::ToastIcon::Save => {
let c = icon_center;
let p1 = c + Vec2::new(-5.5, 0.0);
let p2 = c + Vec2::new(-1.5, 4.0);
let p3 = c + Vec2::new(5.5, -4.0);
painter.line_segment([p1, p2], Stroke::new(2.2_f32, self.accent));
painter.line_segment([p2, p3], Stroke::new(2.2_f32, self.accent));
}
crate::overlay::ToastIcon::Cursor => {
let c = icon_center;
painter.text(c, egui::Align2::CENTER_CENTER, "⯈", FontId::proportional(14.0), self.accent);
}
crate::overlay::ToastIcon::Error => {
let c = icon_center;
let red = Color32::from_rgb(239, 68, 68);
painter.line_segment([c + Vec2::new(-4.0, -4.0), c + Vec2::new(4.0, 4.0)], Stroke::new(2.0_f32, red));
painter.line_segment([c + Vec2::new(4.0, -4.0), c + Vec2::new(-4.0, 4.0)], Stroke::new(2.0_f32, red));
}
crate::overlay::ToastIcon::Info => {
painter.circle_filled(icon_center, 5.0, self.accent);
}
}
// Text stack (Title + Subtitle)
let text_left = rect.left() + 48.0;
painter.text(
egui::pos2(text_left, rect.top() + 19.0),
egui::Align2::LEFT_CENTER,
&self.title,
FontId::proportional(12.5),
Color32::WHITE,
);
painter.text(
egui::pos2(text_left, rect.top() + 37.0),
egui::Align2::LEFT_CENTER,
&self.subtitle,
FontId::proportional(11.0),
Color32::from_rgb(160, 160, 168),
);
});
}
}
pub fn run_egui_toast(title: &str, subtitle: &str, icon: crate::overlay::ToastIcon) {
let cfg = ScytheConfig::load();
let accent = resolve_accent_color(&cfg.accent_color);
let toast_w: f32 = 340.0;
let toast_h: f32 = 64.0;
let toast_pid_path = crate::ipc::get_toast_pid_path();
if let Ok(prev_pid_str) = std::fs::read_to_string(&toast_pid_path)
&& let Ok(prev_pid) = prev_pid_str.trim().parse::<u32>() {
#[cfg(target_os = "windows")]
unsafe {
use windows::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE};
if let Ok(h) = OpenProcess(PROCESS_TERMINATE, false, prev_pid) {
let _ = TerminateProcess(h, 0);
let _ = windows::Win32::Foundation::CloseHandle(h);
}
}
#[cfg(not(target_os = "windows"))]
unsafe {
let _ = libc::kill(prev_pid as i32, libc::SIGKILL);
}
}
let _ = std::fs::create_dir_all(toast_pid_path.parent().unwrap_or(std::path::Path::new(".")));
let _ = std::fs::write(&toast_pid_path, std::process::id().to_string());
#[cfg(target_os = "windows")]
let (mon_x, screen_w): (f32, f32) = unsafe {
use windows::Win32::UI::WindowsAndMessaging::{GetSystemMetrics, SM_CXSCREEN};
let w = GetSystemMetrics(SM_CXSCREEN) as f32;
let sw = if w > 100.0 { w } else { 1920.0 };
(0.0, sw)
};
#[cfg(not(target_os = "windows"))]
let (mon_x, _mon_y, screen_w, _screen_h) = query_focused_monitor_rect();
let pos_x = (mon_x + screen_w - toast_w - 28.0).max(10.0);
let pos_y = 28.0;
let options = eframe::NativeOptions {
viewport: egui::ViewportBuilder::default()
.with_title("Scythe Notification")
.with_app_id("scythe-toast")
.with_position([pos_x, pos_y])
.with_inner_size([toast_w, toast_h])
.with_decorations(false)
.with_transparent(true)
.with_visible(false)
.with_always_on_top()
.with_resizable(false),
..Default::default()
};
let app = ShadowPlayToastApp {
title: title.to_string(),
subtitle: subtitle.to_string(),
icon,
accent,
created_at: Instant::now(),
duration: Duration::from_millis(2800),
initial_setup: false,
};
// Watchdog thread to guarantee exit after duration
let watchdog_pid_path = toast_pid_path.clone();
std::thread::spawn(move || {
std::thread::sleep(Duration::from_millis(5000));
let _ = std::fs::remove_file(watchdog_pid_path);
std::process::exit(0);
});
let _ = eframe::run_native(
"scythe-toast",
options,
Box::new(|cc| {
setup_custom_fonts(&cc.egui_ctx);
Ok(Box::new(app))
}),
);
crate::ipc::clean_toast_pid();
}
Reference in a new issue View git blame Copy permalink