Implement fetching gcode metadata

Author: suchmememanyskill

moonraker-rs/src/moonraker_connection.rs

@@ -258,7 +258,7 @@ impl MoonrakerConnection {
                     else {
                         continue;
                     }
-                }, // TODO: This should eventually end
+                },
             }
         }
     }

moonraker-rs/src/requests/file_management.rs

@@ -1,3 +1,6 @@
+use std::path::PathBuf;
+
+use optional_struct::optional_struct;
 use serde::Deserialize;
 
 use crate::{error::Error, moonraker_connection::MoonrakerConnection};
@@ -10,21 +13,59 @@ pub struct MoonrakerFile {
     pub permissions: String,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, PartialEq, Clone)]
 pub struct MoonrakerFileThumbnail {
     pub width: i32,
     pub height: i32,
     pub size: i32,
+    #[serde(alias = "relative_path")]
     pub thumbnail_path: String,
 }
 
+#[optional_struct]
+#[derive(Debug, Deserialize, Default)]
+pub struct GcodeMetadata {
+    pub size: i32,
+    pub modified: f32,
+    pub uuid: String,
+    pub file_processors: Vec<String>,
+    pub slicer: String,
+    pub slicer_version: String,
+    pub gcode_start_byte: i32,
+    pub gcode_int_byte: i32,
+    pub object_height: f32,
+    pub estimated_time: f32,
+    pub nozzle_diameter: f32,
+    pub layer_height: f32,
+    pub first_layer_height: f32,
+    pub first_layer_extr_temp: f32,
+    pub first_layer_bed_temp: f32,
+    pub chamber_temp: f32,
+    pub filament_name: String,
+    pub filament_colors: Vec<String>,
+    pub extruder_colors: Vec<String>,
+    pub filament_temps: Vec<i32>,
+    pub filament_type: String,
+    pub filament_total: f32,
+    pub filament_change_count: i32,
+    pub filament_weight_total: f32,
+    pub filament_weights: Vec<f32>,
+    pub mmu_print: i32,
+    pub referenced_tools: Vec<i32>,
+    pub thumbnails: Vec<MoonrakerFileThumbnail>,
+    pub job_id: Option<String>,
+    pub print_start_time: Option<f32>,
+    pub filename: String,
+}
+
 pub trait FileManagementRequestHandler {
     async fn list_files(&self, root: &str) -> Result<Vec<MoonrakerFile>, Error>;
     async fn list_gcode_files(&self) -> Result<Vec<MoonrakerFile>, Error>;
     async fn get_thumbnails_for_file(
         &self,
         file: &str,
     ) -> Result<Vec<MoonrakerFileThumbnail>, Error>;
+    async fn get_gcode_metadata_for_file(&self, filename: &str) -> Result<GcodeMetadata, Error>;
 }
 
 impl FileManagementRequestHandler for MoonrakerConnection {
@@ -47,4 +88,75 @@ impl FileManagementRequestHandler for MoonrakerConnection {
         self.send_request("server.files.thumbnails", Some(args))
             .await
     }
+
+    async fn get_gcode_metadata_for_file(&self, filename: &str) -> Result<GcodeMetadata, Error>
+    {
+        let args = serde_json::json!({"filename": filename});
+        let gcode_metadata : OptionalGcodeMetadata = self.send_request("server.files.metadata", Some(args)).await?;
+
+        Ok(GcodeMetadata::from_optional(gcode_metadata))
+    }
 }
+
+impl GcodeMetadata {
+    pub fn from_optional(optional: OptionalGcodeMetadata) -> Self {
+        Self {
+            size: optional.size.unwrap_or_default(),
+            modified: optional.modified.unwrap_or_default(),
+            uuid: optional.uuid.unwrap_or_default(),
+            file_processors: optional.file_processors.unwrap_or_default(),
+            slicer: optional.slicer.unwrap_or_default(),
+            slicer_version: optional.slicer_version.unwrap_or_default(),
+            gcode_start_byte: optional.gcode_start_byte.unwrap_or_default(),
+            gcode_int_byte: optional.gcode_int_byte.unwrap_or_default(),
+            object_height: optional.object_height.unwrap_or_default(),
+            estimated_time: optional.estimated_time.unwrap_or_default(),
+            nozzle_diameter: optional.nozzle_diameter.unwrap_or_default(),
+            layer_height: optional.layer_height.unwrap_or_default(),
+            first_layer_height: optional.first_layer_height.unwrap_or_default(),
+            first_layer_extr_temp: optional.first_layer_extr_temp.unwrap_or_default(),
+            first_layer_bed_temp: optional.first_layer_bed_temp.unwrap_or_default(),
+            chamber_temp: optional.chamber_temp.unwrap_or_default(),
+            filament_name: optional.filament_name.unwrap_or_default(),
+            filament_colors: optional.filament_colors.unwrap_or_default(),
+            extruder_colors: optional.extruder_colors.unwrap_or_default(),
+            filament_temps: optional.filament_temps.unwrap_or_default(),
+            filament_type: optional.filament_type.unwrap_or_default(),
+            filament_total: optional.filament_total.unwrap_or_default(),
+            filament_change_count: optional.filament_change_count.unwrap_or_default(),
+            filament_weight_total: optional.filament_weight_total.unwrap_or_default(),
+            filament_weights: optional.filament_weights.unwrap_or_default(),
+            mmu_print: optional.mmu_print.unwrap_or_default(),
+            referenced_tools: optional.referenced_tools.unwrap_or_default(),
+            thumbnails: optional.thumbnails.unwrap_or_default(),
+            job_id: optional.job_id.clone(),
+            print_start_time: optional.print_start_time.clone(),
+            filename: optional.filename.unwrap_or_default(),
+        }
+    }
+
+    pub fn absolute_thumbnails(&self) -> Vec<MoonrakerFileThumbnail>
+    {
+        let buf = PathBuf::from(&self.filename);
+        let base_path = buf
+            .parent()
+            .and_then(|f| Some(f.to_str().unwrap()))
+            .unwrap_or("");
+
+        self.thumbnails
+            .iter()
+            .map(|f| {
+                MoonrakerFileThumbnail {
+                    width: f.width,
+                    height: f.height,
+                    size: f.size,
+                    thumbnail_path: if base_path.is_empty() {
+                        f.thumbnail_path.clone()
+                    } else {
+                        format!("{}/{}", base_path, f.thumbnail_path)
+                    }
+                }
+            })
+            .collect()
+    }
+}

src/main.rs

@@ -81,21 +81,22 @@ async fn main() -> Result<(), Box<dyn Error>> {
     });
 
     register_filesystem_list_files(&ui, &moonraker_connection);
-    register_filesystem_download_thumbnails(&ui, &moonraker_connection);
+    register_filesystem_fetch_metadata(&ui, &moonraker_connection);
 
     register_temperature_set_new_target_temperature(&ui, &moonraker_connection);
 
     register_util_image_exists(&ui);
     register_util_format_bytes(&ui);
     register_util_prettify_name(&ui);
-    register_create_temperature_lists(&ui);
-    register_convert_temperature_back(&ui);
+    register_util_time_in_seconds_to_string(&ui);
+    register_util_create_temperature_lists(&ui);
+    register_util_convert_temperature_back(&ui);
 
     register_printer_emergency_stop(&ui, &moonraker_connection);
     register_printer_firmware_restart(&ui, &moonraker_connection);
     register_printer_restart(&ui, &moonraker_connection);
 
-    let gcode_command_config = &config.gcode_commands.unwrap_or(OptionalGcodeCommands::default());
+    let gcode_command_config = &config.gcode_commands.unwrap_or_default();
     register_extruder_extrude(&ui, &moonraker_connection, gcode_command_config);
     register_extruder_retract(&ui, &moonraker_connection, gcode_command_config);
     register_extruder_load_filament(&ui, &moonraker_connection, gcode_command_config);

…nctions/filesystem_download_thumbnail.rs …i_functions/filesystem_fetch_metadata.rssrc/ui_functions/filesystem_download_thumbnail.rs renamed to src/ui_functions/filesystem_fetch_metadata.rs src/ui_functions/filesystem_download_thumbnail.rs renamed to src/ui_functions/filesystem_fetch_metadata.rs

@@ -1,19 +1,19 @@
 use std::sync::Arc;
 
 use moonraker_rs::{moonraker_connection::{MoonrakerConnection}, requests::FileManagementRequestHandler};
-use slint::{ComponentHandle, Image, Model, Rgba8Pixel, SharedPixelBuffer, VecModel};
+use slint::{ComponentHandle, Image, Model, Rgba8Pixel, SharedPixelBuffer, SharedString, VecModel};
 use tokio::sync::Mutex;
 
 use crate::{AppWindow, Filesystem, MoonrakerFile};
 
-pub fn register_filesystem_download_thumbnails(ui: &AppWindow, moonraker_connection : &Arc<MoonrakerConnection>)
+pub fn register_filesystem_fetch_metadata(ui: &AppWindow, moonraker_connection : &Arc<MoonrakerConnection>)
 {
     let mutex = Arc::new(Mutex::new(()));
     let ui_weak = ui.as_weak();
     let moonraker_connection = moonraker_connection.clone();
 
     ui.global::<Filesystem>()
-        .on_download_thumbnail(move |global_index| {
+        .on_fetch_metadata(move |global_index| {
             let mutex = mutex.clone();
             let ui_weak = ui_weak.clone();
             let moonraker_connection = moonraker_connection.clone();
@@ -42,13 +42,21 @@ pub fn register_filesystem_download_thumbnails(ui: &AppWindow, moonraker_connect
                     }
 
                     // TODO: Error handling
-                    let files = moonraker_connection
-                        .get_thumbnails_for_file(&file.path)
+                    let metadata = moonraker_connection
+                        .get_gcode_metadata_for_file(&file.path)
                         .await
                         .unwrap();
+
+                    file.filament_used_gram = metadata.filament_weight_total;
+                    file.filament_type = SharedString::from(&metadata.filament_type);
+                    file.height_mm = metadata.object_height;
+                    file.estimated_time_s = metadata.estimated_time;
+                    file.layer_height_mm = metadata.layer_height;
+                    file.nozzle_diameter_mm = metadata.nozzle_diameter;
+
+                    let files = metadata.absolute_thumbnails();
                     println!("Thumbnails for {}: {:?}", file.path, files);
-                    let possible_target =
-                        files.into_iter().find(|f| f.width == 32 && f.height == 32);
+                    let possible_target = files.into_iter().find(|f| f.width == 32 && f.height == 32);
 
                     if let Some(target) = possible_target {
                         let data = moonraker_connection
@@ -67,8 +75,9 @@ pub fn register_filesystem_download_thumbnails(ui: &AppWindow, moonraker_connect
 
                         file.thumbnail = Image::from_rgba8(shared_buf);
                         println!("Set thumbnail for file {}", file.path);
-                        non_optional_files.set_vec(unwrapped_files);
                     }
+
+                    non_optional_files.set_vec(unwrapped_files);
                 }
             })
             .unwrap();

src/ui_functions/filesystem_list_files.rs

@@ -48,18 +48,16 @@ pub fn register_filesystem_list_files(ui : &AppWindow, moonraker_connection : &A
                     modified: f.modified,
                     size: f.size,
                     permissions: SharedString::from(&f.permissions),
-                    thumbnail: Image::default(),
+                    ..MoonrakerFile::default()
                 })
                 .collect();
 
             ui.global::<Filesystem>()
                 .set_files(ModelRc::new(Rc::new(VecModel::from(converted_files))));
             ui.global::<Filesystem>().set_loading(false);
-            ui.global::<Filesystem>().invoke_download_thumbnail(0);
-            ui.global::<Filesystem>().invoke_download_thumbnail(1);
-            ui.global::<Filesystem>().invoke_download_thumbnail(2);
-            ui.global::<Filesystem>().invoke_download_thumbnail(3);
-            ui.global::<Filesystem>().invoke_download_thumbnail(4);
+            for i in 0..5 {
+                ui.global::<Filesystem>().invoke_fetch_metadata(i);
+            }
         })
         .unwrap();
     });

src/ui_functions/mod.rs

@@ -1,5 +1,5 @@
 pub mod util_format_bytes;
-pub mod filesystem_download_thumbnail;
+pub mod filesystem_fetch_metadata;
 pub mod util_image_exists;
 pub mod filesystem_list_files;
 pub mod util_prettify_name;
@@ -11,9 +11,10 @@ pub mod printer_execute_gcode_command;
 pub mod util_create_temperature_list; 
 pub mod settings_set_ui_settings;
 pub mod quick_action_execute;
+pub mod util_time_in_seconds_to_string;
 
 pub use util_format_bytes::*;
-pub use filesystem_download_thumbnail::*;
+pub use filesystem_fetch_metadata::*;
 pub use util_image_exists::*;
 pub use filesystem_list_files::*;
 pub use util_prettify_name::*;
@@ -24,4 +25,5 @@ pub use printer_firmware_restart::*;
 pub use printer_execute_gcode_command::*;
 pub use util_create_temperature_list::*;
 pub use settings_set_ui_settings::*;
-pub use quick_action_execute::*;
+pub use quick_action_execute::*;
+pub use util_time_in_seconds_to_string::*;

src/ui_functions/util_create_temperature_list.rs

@@ -2,7 +2,7 @@ use slint::{ComponentHandle, Model, ModelRc, SharedString, VecModel};
 
 use crate::{AppWindow, Utils};
 
-pub fn register_create_temperature_lists(ui : &AppWindow)
+pub fn register_util_create_temperature_lists(ui : &AppWindow)
 {
     ui.global::<Utils>().on_create_temperature_lists(|presets| {
         let presets = presets.as_any().downcast_ref::<VecModel<i32>>().unwrap();
@@ -20,7 +20,7 @@ pub fn register_create_temperature_lists(ui : &AppWindow)
     });
 }
 
-pub fn register_convert_temperature_back(ui : &AppWindow)
+pub fn register_util_convert_temperature_back(ui : &AppWindow)
 {
     ui.global::<Utils>().on_convert_temperature_back(|f| {
         let s = f.trim_end_matches("°C");

src/ui_functions/util_time_in_seconds_to_string.rs

@@ -0,0 +1,21 @@
+use slint::{ComponentHandle, SharedString};
+
+use crate::{AppWindow, Utils};
+
+pub fn register_util_time_in_seconds_to_string(ui : &AppWindow)
+{
+    ui.global::<Utils>().on_time_in_seconds_to_string(|f: f32| {
+        let total_seconds = f.round() as i32;
+        let hours = total_seconds / 3600;
+        let minutes = (total_seconds % 3600) / 60;
+        let seconds = total_seconds % 60;
+
+        if hours > 0 {
+            SharedString::from(format!("{}h{:02}m", hours, minutes))
+        } else if total_seconds >= 60 {
+            SharedString::from(format!("{}m", minutes))
+        } else {
+            SharedString::from(format!("{}s", seconds))
+        }
+    });
+} 

ui/components/page.slint

@@ -1,30 +1,13 @@
 import { StyleMetrics } from "std-widgets.slint";
 
 export component Page inherits Rectangle {
-    in property <string> header <=> h.text;
-    width: 100%; 
-    height: 100%;
+    in property <string> header;
 
-    VerticalLayout {
-        width: 100%;
-        height: 100%;
-        HorizontalLayout { 
-            x: 10px;
-            h := Text {
-                font-weight: 900;
-                horizontal-alignment: left;
-                y: 2px;
-            }
-            padding-bottom: 4px;
-            vertical-stretch: 0;
-        }
-
-        GridLayout {
-            padding: StyleMetrics.layout-padding / 2;
-            Rectangle {
-                vertical-stretch: 1;
-                @children
-            }
+    GridLayout {
+        padding: StyleMetrics.layout-padding / 2;
+        Rectangle {
+            vertical-stretch: 1;
+            @children
         }
     }
 }

ui/pages/file-list-page.slint

@@ -20,7 +20,7 @@ export component FileListPage inherits Page
         width: 200px;
     }
 
-    if !Filesystem.loading && selected_file.path == "": ScrollView {
+    if !Filesystem.loading && selected_file.path == "": Flickable {
         VerticalLayout {
             for f in Filesystem.files: Rectangle {
                 height: 40px;
@@ -39,7 +39,7 @@ export component FileListPage inherits Page
                         width: 32px;
                     }
                     Text { text: f.path; horizontal-stretch: 1; vertical-alignment: center; overflow: elide; }
-                    Text { text: Utils.format_bytes(f.size); horizontal-alignment: right; vertical-alignment: center; }
+                    Text { text: f.filament-type != "" ? f.filament_type + " - " + Utils.time_in_seconds_to_string(f.estimated-time-s) : Utils.time_in_seconds_to_string(f.estimated-time-s); horizontal-alignment: right; vertical-alignment: center; }
                 }
             }
         }
@@ -54,7 +54,7 @@ export component FileListPage inherits Page
             Text { text: "Size: " + Utils.format_bytes(selected_file.size); }
             Text { text: "Modified: " + selected_file.modified; }
             Text { text: "Permissions: " + selected_file.permissions; }
-            Button { text: "Close"; clicked => { root.selected_file = {}; Filesystem.download_thumbnail(thumbnail_index); thumbnail_index += 1; } }
+            Button { text: "Close"; clicked => { root.selected_file = {}; thumbnail_index += 1; } }
         }
     }
 }