486 lines
16 KiB
Rust
486 lines
16 KiB
Rust
use std::{path::PathBuf, sync::{Arc, Mutex}};
|
|
|
|
use log::{trace, info, debug, warn, error};
|
|
use tauri::{AppHandle, Manager, Url, WebviewUrl, WebviewWindowBuilder};
|
|
|
|
mod audio;
|
|
mod video;
|
|
mod frame_streamer;
|
|
mod renderer;
|
|
mod render_window;
|
|
|
|
|
|
#[derive(Default)]
|
|
struct AppState {
|
|
counter: u32,
|
|
}
|
|
|
|
struct RenderWindowState {
|
|
handle: Option<render_window::RenderWindowHandle>,
|
|
canvas_offset: (i32, i32), // Canvas position relative to window
|
|
canvas_size: (u32, u32),
|
|
}
|
|
|
|
// Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
|
|
#[tauri::command]
|
|
fn greet(name: &str) -> String {
|
|
format!("Hello, {}! You've been greeted from Rust!", name)
|
|
}
|
|
|
|
#[tauri::command]
|
|
fn trace(msg: String) {
|
|
trace!("{}",msg);
|
|
}
|
|
#[tauri::command]
|
|
fn info(msg: String) {
|
|
info!("{}",msg);
|
|
}
|
|
#[tauri::command]
|
|
fn debug(msg: String) {
|
|
debug!("{}",msg);
|
|
}
|
|
#[tauri::command]
|
|
fn warn(msg: String) {
|
|
warn!("{}",msg);
|
|
}
|
|
#[tauri::command]
|
|
fn error(msg: String) {
|
|
error!("{}",msg);
|
|
}
|
|
|
|
#[tauri::command]
|
|
fn get_frame_streamer_port(
|
|
frame_streamer: tauri::State<'_, Arc<Mutex<frame_streamer::FrameStreamer>>>,
|
|
) -> u16 {
|
|
let streamer = frame_streamer.lock().unwrap();
|
|
streamer.port()
|
|
}
|
|
|
|
// Render window commands
|
|
#[tauri::command]
|
|
fn render_window_create(
|
|
x: i32,
|
|
y: i32,
|
|
width: u32,
|
|
height: u32,
|
|
canvas_offset_x: i32,
|
|
canvas_offset_y: i32,
|
|
app: tauri::AppHandle,
|
|
state: tauri::State<'_, Arc<Mutex<RenderWindowState>>>,
|
|
) -> Result<(), String> {
|
|
let mut render_state = state.lock().unwrap();
|
|
|
|
if render_state.handle.is_some() {
|
|
return Err("Render window already exists".to_string());
|
|
}
|
|
|
|
let handle = render_window::spawn_render_window(x, y, width, height)?;
|
|
render_state.handle = Some(handle);
|
|
render_state.canvas_offset = (canvas_offset_x, canvas_offset_y);
|
|
render_state.canvas_size = (width, height);
|
|
|
|
// Start a background thread to poll main window position
|
|
let state_clone = state.inner().clone();
|
|
let app_clone = app.clone();
|
|
std::thread::spawn(move || {
|
|
let mut last_pos: Option<(i32, i32)> = None;
|
|
|
|
loop {
|
|
std::thread::sleep(std::time::Duration::from_millis(50));
|
|
|
|
if let Some(main_window) = app_clone.get_webview_window("main") {
|
|
if let Ok(pos) = main_window.outer_position() {
|
|
let current_pos = (pos.x, pos.y);
|
|
|
|
// Only update if position actually changed
|
|
if last_pos != Some(current_pos) {
|
|
eprintln!("[WindowSync] Main window position: {:?}", current_pos);
|
|
|
|
let render_state = state_clone.lock().unwrap();
|
|
if let Some(handle) = &render_state.handle {
|
|
let new_x = pos.x + render_state.canvas_offset.0;
|
|
let new_y = pos.y + render_state.canvas_offset.1;
|
|
handle.set_position(new_x, new_y);
|
|
last_pos = Some(current_pos);
|
|
} else {
|
|
break; // No handle, exit thread
|
|
}
|
|
}
|
|
} else {
|
|
break; // Window closed, exit thread
|
|
}
|
|
} else {
|
|
break; // Main window gone, exit thread
|
|
}
|
|
}
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tauri::command]
|
|
fn render_window_update_gradient(
|
|
top_r: f32,
|
|
top_g: f32,
|
|
top_b: f32,
|
|
top_a: f32,
|
|
bottom_r: f32,
|
|
bottom_g: f32,
|
|
bottom_b: f32,
|
|
bottom_a: f32,
|
|
state: tauri::State<'_, Arc<Mutex<RenderWindowState>>>,
|
|
) -> Result<(), String> {
|
|
let render_state = state.lock().unwrap();
|
|
|
|
if let Some(handle) = &render_state.handle {
|
|
handle.update_gradient(
|
|
[top_r, top_g, top_b, top_a],
|
|
[bottom_r, bottom_g, bottom_b, bottom_a],
|
|
);
|
|
Ok(())
|
|
} else {
|
|
Err("Render window not created".to_string())
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
fn render_window_set_position(
|
|
x: i32,
|
|
y: i32,
|
|
state: tauri::State<'_, Arc<Mutex<RenderWindowState>>>,
|
|
) -> Result<(), String> {
|
|
let render_state = state.lock().unwrap();
|
|
|
|
if let Some(handle) = &render_state.handle {
|
|
handle.set_position(x, y);
|
|
Ok(())
|
|
} else {
|
|
Err("Render window not created".to_string())
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
fn render_window_sync_position(
|
|
app: tauri::AppHandle,
|
|
state: tauri::State<'_, Arc<Mutex<RenderWindowState>>>,
|
|
) -> Result<(), String> {
|
|
let render_state = state.lock().unwrap();
|
|
|
|
if let Some(main_window) = app.get_webview_window("main") {
|
|
if let Ok(pos) = main_window.outer_position() {
|
|
if let Some(handle) = &render_state.handle {
|
|
let new_x = pos.x + render_state.canvas_offset.0;
|
|
let new_y = pos.y + render_state.canvas_offset.1;
|
|
eprintln!("[Manual Sync] Updating to ({}, {})", new_x, new_y);
|
|
handle.set_position(new_x, new_y);
|
|
Ok(())
|
|
} else {
|
|
Err("Render window not created".to_string())
|
|
}
|
|
} else {
|
|
Err("Could not get window position".to_string())
|
|
}
|
|
} else {
|
|
Err("Main window not found".to_string())
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
fn render_window_set_size(
|
|
width: u32,
|
|
height: u32,
|
|
state: tauri::State<'_, Arc<Mutex<RenderWindowState>>>,
|
|
) -> Result<(), String> {
|
|
let render_state = state.lock().unwrap();
|
|
|
|
if let Some(handle) = &render_state.handle {
|
|
handle.set_size(width, height);
|
|
Ok(())
|
|
} else {
|
|
Err("Render window not created".to_string())
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
fn render_window_close(
|
|
state: tauri::State<'_, Arc<Mutex<RenderWindowState>>>,
|
|
) -> Result<(), String> {
|
|
let mut render_state = state.lock().unwrap();
|
|
|
|
if let Some(handle) = render_state.handle.take() {
|
|
handle.close();
|
|
Ok(())
|
|
} else {
|
|
Err("Render window not created".to_string())
|
|
}
|
|
}
|
|
|
|
use tauri::PhysicalSize;
|
|
|
|
#[tauri::command]
|
|
async fn create_window(app: tauri::AppHandle, path: Option<String>) {
|
|
let state = app.state::<Mutex<AppState>>();
|
|
|
|
// Lock the mutex to get mutable access:
|
|
let mut state = state.lock().unwrap();
|
|
|
|
// Increment the counter and generate a unique window label
|
|
let window_label = format!("window{}", state.counter);
|
|
state.counter += 1;
|
|
|
|
// Build the new window with the unique label
|
|
let webview_window = WebviewWindowBuilder::new(&app, &window_label, WebviewUrl::App("index.html".into()))
|
|
.title("Lightningbeam")
|
|
.build()
|
|
.unwrap();
|
|
|
|
// Get the current monitor's screen size from the new window
|
|
if let Ok(Some(monitor)) = webview_window.current_monitor() {
|
|
let screen_size = monitor.size(); // Get the size of the monitor
|
|
let width = 4096;
|
|
let height = 4096;
|
|
|
|
// Set the window size to be the smaller of the specified size or the screen size
|
|
let new_width = width.min(screen_size.width as u32);
|
|
let new_height = height.min(screen_size.height as u32 - 100);
|
|
|
|
// Set the size using PhysicalSize
|
|
webview_window.set_size(tauri::Size::Physical(PhysicalSize::new(new_width, new_height)))
|
|
.expect("Failed to set window size");
|
|
} else {
|
|
eprintln!("Could not detect the current monitor.");
|
|
}
|
|
|
|
// Set the opened file if provided
|
|
if let Some(val) = path {
|
|
// Pass path data to the window via JavaScript
|
|
webview_window.eval(&format!("window.openedFiles = [\"{val}\"]")).unwrap();
|
|
|
|
// Set the window title if provided
|
|
webview_window.set_title(&val).expect("Failed to set window title");
|
|
}
|
|
}
|
|
|
|
|
|
fn handle_file_associations(app: AppHandle, files: Vec<PathBuf>) {
|
|
// -- Scope handling start --
|
|
|
|
// You can remove this block if you only want to know about the paths, but not actually "use" them in the frontend.
|
|
|
|
// This requires the `fs` tauri plugin and is required to make the plugin's frontend work:
|
|
use tauri_plugin_fs::FsExt;
|
|
let fs_scope = app.fs_scope();
|
|
|
|
// This is for the `asset:` protocol to work:
|
|
let asset_protocol_scope = app.asset_protocol_scope();
|
|
|
|
for file in &files {
|
|
// This requires the `fs` plugin:
|
|
let _ = fs_scope.allow_file(file);
|
|
|
|
// This is for the `asset:` protocol:
|
|
let _ = asset_protocol_scope.allow_file(file);
|
|
}
|
|
|
|
// -- Scope handling end --
|
|
|
|
let files = files
|
|
.into_iter()
|
|
.map(|f| {
|
|
let file = f.to_string_lossy().replace('\\', "\\\\"); // escape backslash
|
|
format!("\"{file}\"",) // wrap in quotes for JS array
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join(",");
|
|
warn!("{}",files);
|
|
|
|
let window = app.get_webview_window("main").unwrap();
|
|
window.eval(&format!("window.openedFiles = [{files}]")).unwrap();
|
|
}
|
|
|
|
#[cfg_attr(mobile, tauri::mobile_entry_point)]
|
|
pub fn run() {
|
|
// Initialize env_logger with Error level only
|
|
env_logger::Builder::from_default_env()
|
|
.filter_level(log::LevelFilter::Error)
|
|
.init();
|
|
|
|
// Initialize WebSocket frame streamer
|
|
let frame_streamer = frame_streamer::FrameStreamer::new()
|
|
.expect("Failed to start frame streamer");
|
|
eprintln!("[App] Frame streamer started on port {}", frame_streamer.port());
|
|
|
|
tauri::Builder::default()
|
|
.manage(Mutex::new(AppState::default()))
|
|
.manage(Arc::new(Mutex::new(audio::AudioState::default())))
|
|
.manage(Arc::new(Mutex::new(video::VideoState::default())))
|
|
.manage(Arc::new(Mutex::new(frame_streamer)))
|
|
.manage(Arc::new(Mutex::new(RenderWindowState {
|
|
handle: None,
|
|
canvas_offset: (0, 0),
|
|
canvas_size: (0, 0),
|
|
})))
|
|
.setup(|app| {
|
|
#[cfg(any(windows, target_os = "linux"))] // Windows/Linux needs different handling from macOS
|
|
{
|
|
let mut files = Vec::new();
|
|
|
|
// NOTICE: `args` may include URL protocol (`your-app-protocol://`)
|
|
// or arguments (`--`) if your app supports them.
|
|
// files may also be passed as `file://path/to/file`
|
|
for maybe_file in std::env::args().skip(1) {
|
|
// skip flags like -f or --flag
|
|
if maybe_file.starts_with('-') {
|
|
continue;
|
|
}
|
|
|
|
// handle `file://` path urls and skip other urls
|
|
if let Ok(url) = Url::parse(&maybe_file) {
|
|
// if let Ok(url) = url::Url::parse(&maybe_file) {
|
|
if let Ok(path) = url.to_file_path() {
|
|
files.push(path);
|
|
}
|
|
} else {
|
|
files.push(PathBuf::from(maybe_file))
|
|
}
|
|
}
|
|
|
|
handle_file_associations(app.handle().clone(), files);
|
|
}
|
|
#[cfg(debug_assertions)] // only include this code on debug builds
|
|
{
|
|
let window = app.get_webview_window("main").unwrap();
|
|
window.open_devtools();
|
|
window.close_devtools();
|
|
}
|
|
Ok(())
|
|
})
|
|
// .plugin(
|
|
// tauri_plugin_log::Builder::new()
|
|
// .filter(|metadata| {
|
|
// // ONLY allow Error-level logs, block everything else
|
|
// metadata.level() == log::Level::Error
|
|
// })
|
|
// .timezone_strategy(tauri_plugin_log::TimezoneStrategy::UseLocal)
|
|
// .format(|out, message, record| {
|
|
// let date = Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
|
|
// out.finish(format_args!(
|
|
// "{}[{}] {}",
|
|
// date,
|
|
// record.level(),
|
|
// message
|
|
// ))
|
|
// })
|
|
// .targets([
|
|
// Target::new(TargetKind::Stdout),
|
|
// // LogDir locations:
|
|
// // Linux: /home/user/.local/share/org.lightningbeam.core/logs
|
|
// // macOS: /Users/user/Library/Logs/org.lightningbeam.core/logs
|
|
// // Windows: C:\Users\user\AppData\Local\org.lightningbeam.core\logs
|
|
// Target::new(TargetKind::LogDir { file_name: Some("logs".to_string()) }),
|
|
// Target::new(TargetKind::Webview),
|
|
// ])
|
|
// .build()
|
|
// )
|
|
.plugin(tauri_plugin_dialog::init())
|
|
.plugin(tauri_plugin_fs::init())
|
|
.plugin(tauri_plugin_shell::init())
|
|
.invoke_handler(tauri::generate_handler![
|
|
greet, trace, debug, info, warn, error, create_window, get_frame_streamer_port,
|
|
render_window_create,
|
|
render_window_update_gradient,
|
|
render_window_set_position,
|
|
render_window_set_size,
|
|
render_window_sync_position,
|
|
render_window_close,
|
|
audio::audio_init,
|
|
audio::audio_reset,
|
|
audio::audio_play,
|
|
audio::audio_stop,
|
|
audio::audio_seek,
|
|
audio::audio_test_beep,
|
|
audio::audio_set_track_parameter,
|
|
audio::audio_create_track,
|
|
audio::audio_load_file,
|
|
audio::audio_add_clip,
|
|
audio::audio_move_clip,
|
|
audio::audio_trim_clip,
|
|
audio::audio_start_recording,
|
|
audio::audio_stop_recording,
|
|
audio::audio_pause_recording,
|
|
audio::audio_resume_recording,
|
|
audio::audio_start_midi_recording,
|
|
audio::audio_stop_midi_recording,
|
|
audio::audio_create_midi_clip,
|
|
audio::audio_add_midi_note,
|
|
audio::audio_load_midi_file,
|
|
audio::audio_get_midi_clip_data,
|
|
audio::audio_update_midi_clip_notes,
|
|
audio::audio_send_midi_note_on,
|
|
audio::audio_send_midi_note_off,
|
|
audio::audio_set_active_midi_track,
|
|
audio::audio_get_pool_file_info,
|
|
audio::audio_get_pool_waveform,
|
|
audio::graph_add_node,
|
|
audio::graph_add_node_to_template,
|
|
audio::graph_remove_node,
|
|
audio::graph_connect,
|
|
audio::graph_connect_in_template,
|
|
audio::graph_disconnect,
|
|
audio::graph_set_parameter,
|
|
audio::graph_set_output_node,
|
|
audio::graph_save_preset,
|
|
audio::graph_load_preset,
|
|
audio::graph_list_presets,
|
|
audio::graph_delete_preset,
|
|
audio::graph_get_state,
|
|
audio::graph_get_template_state,
|
|
audio::sampler_load_sample,
|
|
audio::multi_sampler_add_layer,
|
|
audio::multi_sampler_get_layers,
|
|
audio::multi_sampler_update_layer,
|
|
audio::multi_sampler_remove_layer,
|
|
audio::get_oscilloscope_data,
|
|
audio::automation_add_keyframe,
|
|
audio::automation_remove_keyframe,
|
|
audio::automation_get_keyframes,
|
|
audio::automation_set_name,
|
|
audio::automation_get_name,
|
|
audio::audio_serialize_pool,
|
|
audio::audio_load_pool,
|
|
audio::audio_resolve_missing_file,
|
|
audio::audio_serialize_track_graph,
|
|
audio::audio_load_track_graph,
|
|
video::video_load_file,
|
|
video::video_stream_frame,
|
|
video::video_set_cache_size,
|
|
video::video_get_pool_info,
|
|
])
|
|
// .manage(window_counter)
|
|
.build(tauri::generate_context!())
|
|
.expect("error while running tauri application")
|
|
.run(
|
|
#[allow(unused_variables)]
|
|
|app, event| {
|
|
#[cfg(any(target_os = "macos", target_os = "ios"))]
|
|
if let tauri::RunEvent::Opened { urls } = event {
|
|
let app = app.clone();
|
|
let files = urls
|
|
.into_iter()
|
|
.filter_map(|url| url.to_file_path().ok())
|
|
.map(|f| {
|
|
let file = f.to_string_lossy().replace('\\', "\\\\"); // escape backslash
|
|
format!("\"{file}\"",) // wrap in quotes for JS array
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
tauri::async_runtime::spawn(async move {
|
|
for path in files {
|
|
create_window(app.clone(), Some(path)).await;
|
|
}
|
|
});
|
|
}
|
|
},
|
|
);
|
|
}
|