Implement Save/SaveAs distinction and prompting user for saves

Author: vdrn

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rust_graph"
-version = "0.6.0"
+version = "0.7.0"
 edition = "2024"
 authors = ["Vedran Maric <valinion@gmail.com>"]
 description = "Graphing calculator with f32 support."

Cargo.toml

@@ -1008,13 +1008,17 @@ pub fn setup_jump_offsets<F: EvalexprFloat>(node: &mut FlatNode<F>) {
 	for i in 0..node.ops.len() {
 		match &node.ops[i] {
 			FlatOperator::JumpIfFalse { id, .. } | FlatOperator::Jump { id, .. } => {
-				let pos = node.ops[i..]
+				let Some( pos) = node.ops[i..]
 					.iter()
 					.position(|op| match op {
 						FlatOperator::Label { id: other_id } => id == other_id,
 						_ => false,
-					})
-					.unwrap();
+					})else{
+            println!("No label {id} found for jump at {i}");
+            println!("{node:?}");
+            panic!()
+
+          };
 				match &mut node.ops[i] {
 					FlatOperator::JumpIfFalse { offset, .. } | FlatOperator::Jump { offset, .. } => {
 						*offset = Some(NonZeroU32::new(pos as u32).unwrap());

evalexpr/src/flat_node/variable_inlining.rs

@@ -4,7 +4,6 @@ use serde::{Deserialize, Serialize};
 
 use crate::entry::ColorEntryType;
 
-
 pub struct ProcessedColors<T: EvalexprFloat> {
 	pub colors: Vec<(u64, ProcessedColor<T>)>,
 }

src/color.rs

@@ -1,7 +1,7 @@
 use alloc::sync::Arc;
-use send_wrapper::SendWrapper;
 use core::cell::RefCell;
 use core::num::NonZeroU64;
+use send_wrapper::SendWrapper;
 
 use eframe::egui::{self, Mesh, Rect};
 use eframe::egui_wgpu::wgpu::util::DeviceExt as _;
@@ -111,7 +111,7 @@ pub fn init_mesh_renderer(cc: &eframe::CreationContext) -> Option<()> {
 			index_capacity:  0,
 			vertex_count:    0,
 			index_count:     0,
-      index_scratch:   Vec::with_capacity(1024),
+			index_scratch:   Vec::with_capacity(1024),
 		}),
 	}));
 
@@ -123,12 +123,12 @@ struct BufferState {
 	vertex_capacity: usize,
 	vertex_count:    usize,
 
-	index_buffer:    Option<wgpu::Buffer>,
-	index_capacity:  usize,
-	index_count:     usize,
+	index_buffer:   Option<wgpu::Buffer>,
+	index_capacity: usize,
+	index_count:    usize,
 
-  /// used for offseting current mesh indices
-  index_scratch:   Vec<u32>,
+	/// used for offseting current mesh indices
+	index_scratch: Vec<u32>,
 }
 
 struct MeshRenderResources {
@@ -153,9 +153,8 @@ impl egui_wgpu::CallbackTrait for MeshCallback {
 		egui_encoder: &mut wgpu::CommandEncoder, resources: &mut egui_wgpu::CallbackResources,
 	) -> Vec<wgpu::CommandBuffer> {
 		let mesh_resources: &mut SendWrapper<MeshRenderResources> = resources.get_mut().unwrap();
-    let mesh_resources: &mut MeshRenderResources = mesh_resources;
-    let state = &mut mesh_resources.state.borrow_mut();
-
+		let mesh_resources: &mut MeshRenderResources = mesh_resources;
+		let state = &mut mesh_resources.state.borrow_mut();
 
 		if state.index_count == 0 {
 			// uniform is always be the same within one frame, so we only need to update it the first time.
@@ -221,7 +220,7 @@ impl egui_wgpu::CallbackTrait for MeshCallback {
 			state.index_capacity = new_capacity;
 		}
 
-		// write vertices 
+		// write vertices
 		let vertex_offset = (state.vertex_count * size_of::<egui::epaint::Vertex>()) as u64;
 		queue.write_buffer(
 			state.vertex_buffer.as_ref().unwrap(),
@@ -231,10 +230,10 @@ impl egui_wgpu::CallbackTrait for MeshCallback {
 
 		// we have to adjust indices by the current vertex offset
 		let base_vertex = state.vertex_count as u32;
-    state.index_scratch.clear();
-    for idx in self.mesh.indices.iter() {
-      state.index_scratch.push(*idx + base_vertex);
-    }
+		state.index_scratch.clear();
+		for idx in self.mesh.indices.iter() {
+			state.index_scratch.push(*idx + base_vertex);
+		}
 		let index_offset = (state.index_count * size_of::<u32>()) as u64;
 		queue.write_buffer(
 			state.index_buffer.as_ref().unwrap(),
@@ -253,7 +252,7 @@ impl egui_wgpu::CallbackTrait for MeshCallback {
 		callback_resources: &egui_wgpu::CallbackResources,
 	) {
 		let mesh_resources: &SendWrapper<MeshRenderResources> = callback_resources.get().unwrap();
-    let mesh_resources :&MeshRenderResources = mesh_resources;
+		let mesh_resources: &MeshRenderResources = mesh_resources;
 		let state = &mut mesh_resources.state.borrow_mut();
 
 		// we draw everything in the first pain callback
@@ -270,7 +269,7 @@ impl egui_wgpu::CallbackTrait for MeshCallback {
 		render_pass.set_index_buffer(index_buffer.slice(..), wgpu::IndexFormat::Uint32);
 		render_pass.draw_indexed(0..(state.index_count as u32), 0, 0..1);
 
-    // reset counts back to 0, so we only draw in the first callback
+		// reset counts back to 0, so we only draw in the first callback
 		state.vertex_count = 0;
 		state.index_count = 0;
 	}

src/custom_rendering/mesh_renderer.rs

@@ -67,7 +67,9 @@ impl<T: EvalexprFloat> GraphState<T> {
 		// TODO: very inefficient converting to json and back
 		let mut ser_output = Vec::with_capacity(1024);
 		persistence::serialize_graph_state_to_json(&mut ser_output, self)?;
-		persistence::deserialize_graph_state_from_json(name, &ser_output)
+		let mut graph_state = persistence::deserialize_graph_state_from_json(&ser_output)?;
+		graph_state.name = name; // ensure name is preserved
+		Ok(graph_state)
 	}
 }
 

src/graph_ui.rs

@@ -1,5 +1,6 @@
 use core::time::Duration;
-use std::{sync::mpsc, time::Instant};
+use std::sync::mpsc;
+use std::time::Instant;
 
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
@@ -16,9 +17,9 @@ struct FinishedWork {
 }
 pub type ExecutionResult = Result<(u64, RawPlotElements), (u64, String)>;
 pub struct PlotElementsScheduler {
-	scheduled:   bool,
-	deferred:    Option<ScheduledWork>,
-	average:     (Duration, usize),
+	scheduled:       bool,
+	deferred:        Option<ScheduledWork>,
+	average:         (Duration, usize),
 	latest_received: Option<Instant>,
 
 	sx: mpsc::SyncSender<FinishedWork>,