Clone container ui

Author: ranfdev

src/application.rs

@@ -23,10 +23,9 @@ use std::rc::Rc;
 
 use adw::prelude::*;
 use adw::subclass::prelude::*;
-use gettextrs::gettext;
 use gtk::{gio, glib};
 
-use crate::config::{self, VERSION};
+use crate::config;
 use crate::distrobox::{Distrobox, DistroboxCommandRunnerResponse, FlatpakCommandRunner};
 use crate::fakers::{CommandRunner, RealCommandRunner};
 use crate::root_store::RootStore;

src/container.rs

@@ -1,5 +1,5 @@
 use crate::{
-    distrobox::{ContainerInfo, ExportableApp, Status},
+    distrobox::{ContainerInfo, CreateArgs, CreateArgName, ExportableApp, Status},
     distrobox_task::DistroboxTask,
     fakers::CommandRunner,
     gtk_utils::TypedListStore,
@@ -273,22 +273,6 @@ impl Container {
                 Ok(())
             });
     }
-    pub fn clone_to(&self, target_name: &str) {
-        let this = self.clone();
-        let target_name_clone = target_name.to_string();
-        let task = self
-            .root_store()
-            .create_task(&this.name(), "clone", move |task| async move {
-                let child = this
-                    .root_store()
-                    .distrobox()
-                    .clone_to(&this.name(), &target_name_clone)
-                    .await?;
-                task.handle_child_output(child).await?;
-                Ok(())
-            });
-        self.root_store().view_task(&task);
-    }
     pub fn delete(&self) {
         let this = self.clone();
         self.root_store()

src/dialogs/create_distrobox_dialog.rs

@@ -6,6 +6,8 @@ use tracing::error;
 
 use crate::distrobox::{self, CreateArgName, CreateArgs, Error};
 use crate::root_store::RootStore;
+use crate::container::Container;
+use crate::sidebar_row::SidebarRow;
 
 use std::path::PathBuf;
 use std::{cell::RefCell, rc::Rc};
@@ -42,6 +44,38 @@ mod imp {
         pub init_row: adw::SwitchRow,
         pub volume_rows: Rc<RefCell<Vec<adw::EntryRow>>>,
         pub scrolled_window: gtk::ScrolledWindow,
+        #[property(get, set=Self::set_clone_src, nullable)]
+        pub clone_src: RefCell<Option<Container>>,
+        // transient widget used to show the source container info when cloning
+        pub clone_sidebar: RefCell<Option<SidebarRow>>,
+        pub cloning_content: gtk::Box,
+        pub view_switcher: adw::InlineViewSwitcher,
+    }
+
+    impl CreateDistroboxDialog {
+        fn set_clone_src(&self, value: Option<Container>) {
+            // store the value
+            self.clone_src.replace(value.clone());
+
+            if let Some(sidebar_row) = self.clone_sidebar.borrow_mut().take() {
+                self.cloning_content.remove(&sidebar_row);
+            }
+
+            if let Some(container) = value {
+                self.image_row.set_visible(false);
+                self.cloning_content.set_visible(true);
+                self.view_switcher.set_visible(false);
+                let sidebar_row = SidebarRow::new(&container);
+                // insert at the top of the cloning_content box
+                self.cloning_content.append(&sidebar_row);
+                self.clone_sidebar.replace(Some(sidebar_row));
+            } else {
+                // no clone source, ensure image row is visible
+                self.image_row.set_visible(true);
+                self.cloning_content.set_visible(false);
+                self.view_switcher.set_visible(true);
+            }
+        }
     }
 
     #[derived_properties]
@@ -56,15 +90,35 @@ mod imp {
             // Create view switcher and stack
             let view_stack = adw::ViewStack::new();
 
-            // Create GUI creation page
-            let gui_page = gtk::Box::new(gtk::Orientation::Vertical, 12);
-            gui_page.set_margin_start(12);
-            gui_page.set_margin_end(12);
-            gui_page.set_margin_top(12);
-            gui_page.set_margin_bottom(12);
+            self.content.set_margin_start(12);
+            self.content.set_margin_end(12);
+            self.content.set_margin_top(12);
+            self.content.set_margin_bottom(12);
+            self.content.set_spacing(12);
+            self.content.set_orientation(gtk::Orientation::Vertical);
+
+
+            // Create cloning_content box with header and sidebar
+            self.cloning_content.set_orientation(gtk::Orientation::Vertical);
+            self.cloning_content.set_spacing(12);
+            self.cloning_content.set_visible(false);
+
+            // Create header box with "Cloning" label
+            let cloning_header = gtk::Box::new(gtk::Orientation::Horizontal, 12);
+            cloning_header.set_homogeneous(false);
+
+            let cloning_label = gtk::Label::new(Some("Cloning"));
+            cloning_label.set_halign(gtk::Align::Start);
+            cloning_label.add_css_class("title-3");
+
+            cloning_header.set_hexpand(true);
+            cloning_header.append(&cloning_label);
+
+            self.cloning_content.append(&cloning_header);
+            self.content.append(&self.cloning_content);
+
             let preferences_group = adw::PreferencesGroup::new();
             preferences_group.set_title("Settings");
-
             self.name_row.set_title("Name");
 
             self.image_row
@@ -133,8 +187,8 @@ mod imp {
             preferences_group.add(&self.init_row);
 
             let volumes_group = self.obj().build_volumes_group();
-            gui_page.append(&preferences_group);
-            gui_page.append(&volumes_group);
+            self.content.append(&preferences_group);
+            self.content.append(&volumes_group);
 
             let create_btn = gtk::Button::with_label("Create");
             create_btn.set_halign(gtk::Align::Center);
@@ -148,7 +202,14 @@ mod imp {
                         let res = obj.extract_create_args().await;
                         obj.update_errors(&res);
                         if let Ok(create_args) = res {
-                            obj.root_store().create_container(create_args);
+                            // If cloning from a source, delegate to clone_container, otherwise create normally
+                            if let Some(src) = obj.clone_src() {
+                                obj.root_store()
+                                    .clone_container(&src.name(), create_args);
+                            } else {
+                                obj.root_store().create_container(create_args);
+                            }
+                            obj.close();
                         }
                     });
                 }
@@ -157,7 +218,7 @@ mod imp {
             create_btn.add_css_class("pill");
             create_btn.set_margin_top(12);
 
-            gui_page.append(&create_btn);
+            self.content.append(&create_btn);
 
             // Create page for assemble from file
             let assemble_page = gtk::Box::new(gtk::Orientation::Vertical, 12);
@@ -261,22 +322,22 @@ mod imp {
             });
 
             // Add pages to view stack
-            view_stack.add_titled(&gui_page, Some("create"), "Guided");
+            view_stack.add_titled(&self.content, Some("create"), "Guided");
             view_stack.add_titled(&assemble_page, Some("assemble-file"), "From File");
             view_stack.add_titled(&url_page, Some("assemble-url"), "From URL");
 
+
             // Create a box to hold the view switcher and content
             let content_box = gtk::Box::new(gtk::Orientation::Vertical, 0);
 
             // Add inline view switcher
-            let view_switcher = adw::InlineViewSwitcher::new();
-            view_switcher.set_stack(Some(&view_stack));
-            view_switcher.set_margin_start(12);
-            view_switcher.set_margin_end(12);
-            view_switcher.set_margin_top(12);
-            view_switcher.set_margin_bottom(12);
-
-            content_box.append(&view_switcher);
+            self.view_switcher.set_stack(Some(&view_stack));
+            self.view_switcher.set_margin_start(12);
+            self.view_switcher.set_margin_end(12);
+            self.view_switcher.set_margin_top(12);
+            self.view_switcher.set_margin_bottom(12);
+
+            content_box.append(&self.view_switcher);
             content_box.append(&view_stack);
 
             // Wrap content_box in a scrolled window

src/dialogs/preferences_dialog.rs

@@ -4,7 +4,7 @@ use crate::terminal_combo_row::TerminalComboRow;
 use adw::prelude::*;
 use adw::subclass::prelude::*;
 use glib::{clone, derived_properties, Properties};
-use gtk::{gio, glib};
+use gtk::glib;
 use std::cell::RefCell;
 use tracing::error;
 

src/distrobox/mod.rs

@@ -672,7 +672,10 @@ impl Distrobox {
     }
 
     /// Lists only the binaries that have already been exported from the container.
-    pub async fn get_exported_binaries(&self, box_name: &str) -> Result<Vec<ExportableBinary>, Error> {
+    pub async fn get_exported_binaries(
+        &self,
+        box_name: &str,
+    ) -> Result<Vec<ExportableBinary>, Error> {
         let mut cmd = dbcmd();
         cmd.args([
             "enter",
@@ -684,33 +687,33 @@ impl Distrobox {
         // Example output: '/usr/bin/vim' | /home/user/.local/bin/vim
         let output = self.cmd_output_string(cmd).await?;
         debug!(binaries_output = output);
-        
+
         let mut binaries = Vec::new();
         for line in output.lines() {
             if line.is_empty() || !line.contains('|') {
                 continue;
             }
-            
+
             let parts: Vec<&str> = line.split('|').collect();
             if parts.len() >= 2 {
                 let source_path = parts[0].trim().to_string();
                 // For some reason distrobox formats the source path between single quotes, so we need to remove those
                 let source_path = source_path.trim_matches('\'').to_string();
 
                 let exported_path_str = parts[1].trim();
-                
+
                 // Only include binaries that have a non-empty exported path. It should always be the case, but BoxBuddy defensively checks it.
                 // In this case we try to follow BoxBuddy's behavior to keep consistency for users.
                 if !exported_path_str.is_empty() {
                     let exported_path = exported_path_str.to_string();
-                    
+
                     // Extract binary name from source path
                     let name = Path::new(&source_path)
                         .file_name()
                         .and_then(|n| n.to_str())
                         .unwrap_or(&source_path)
                         .to_string();
-                    
+
                     binaries.push(ExportableBinary {
                         name,
                         source_path,
@@ -719,7 +722,7 @@ impl Distrobox {
                 }
             }
         }
-        
+
         Ok(binaries)
     }
 
@@ -774,7 +777,8 @@ impl Distrobox {
         // If it doesn't contain a '/' it's likely just a binary name
         let resolved_path = if !binary_name_or_path.contains('/') {
             // Resolve the binary name to its full path using 'which'
-            self.resolve_binary_path(container, binary_name_or_path).await?
+            self.resolve_binary_path(container, binary_name_or_path)
+                .await?
         } else {
             binary_name_or_path.to_string()
         };
@@ -789,21 +793,25 @@ impl Distrobox {
     }
 
     /// Resolves a binary name to its full path using 'which' inside the container
-    async fn resolve_binary_path(&self, container: &str, binary_name: &str) -> Result<String, Error> {
+    async fn resolve_binary_path(
+        &self,
+        container: &str,
+        binary_name: &str,
+    ) -> Result<String, Error> {
         let mut cmd = dbcmd();
         cmd.args(["enter", "--name", container, "--", "which", binary_name]);
-        
+
         let output = self.cmd_output_string(cmd).await?;
         let path = output.trim();
-        
+
         if path.is_empty() {
             return Err(Error::CommandFailed {
                 exit_code: Some(1),
                 command: format!("which {}", binary_name),
                 stderr: format!("Binary '{}' not found in container", binary_name),
             });
         }
-        
+
         Ok(path.to_string())
     }
 
@@ -848,8 +856,7 @@ impl Distrobox {
         cmd.arg("assemble").arg("create").arg("--file").arg(url);
         self.cmd_spawn(cmd)
     }
-    // create
-    pub async fn create(&self, args: CreateArgs) -> Result<Box<dyn Child + Send>, Error> {
+    fn create_cmd(args: CreateArgs) -> Command {
         let mut cmd = dbcmd();
         cmd.arg("create").arg("--yes");
         if !args.image.is_empty() {
@@ -872,6 +879,11 @@ impl Distrobox {
         for volume in args.volumes {
             cmd.arg("--volume").arg(volume.to_string());
         }
+        cmd
+    }
+    // create
+    pub async fn create(&self, args: CreateArgs) -> Result<Box<dyn Child + Send>, Error> {
+        let cmd = Self::create_cmd(args);
         self.cmd_spawn(cmd)
     }
     // create --compatibility
@@ -897,18 +909,16 @@ impl Distrobox {
         cmd.arg("enter").arg(name);
         cmd
     }
-    // clone
-    pub async fn clone_to(
+    // clone from an existing container using create args to customize the clone
+    pub async fn clone_from(
         &self,
         source_name: &str,
-        target_name: &str,
+        args: CreateArgs,
     ) -> Result<Box<dyn Child + Send>, Error> {
-        let mut cmd = dbcmd();
-        cmd.arg("create")
-            .arg("--name")
-            .arg(target_name)
-            .arg("--clone")
-            .arg(source_name);
+        let mut cmd = Self::create_cmd(args);
+        cmd.remove_flag_value_arg("--image");
+        cmd.remove_flag_arg("--yes");
+        cmd.arg("--clone").arg(source_name);
         self.cmd_spawn(cmd)
     }
     // list | ls

src/fakers/command.rs

@@ -1,5 +1,7 @@
 use std::{
-    ffi::{OsStr, OsString}, fmt::Display, process::Stdio
+    ffi::{OsStr, OsString},
+    fmt::Display,
+    process::Stdio,
 };
 
 #[derive(Debug, Clone)]
@@ -85,6 +87,21 @@ impl Command {
         self.args.push(arg.as_ref().to_owned());
         self
     }
+
+    // removes the first occurrence of an arg by name and its value
+    pub fn remove_flag_value_arg(&mut self, name: &str) -> &mut Command {
+        self.args.iter().position(|x| x == name).map(|index| {
+            self.args.remove(index);
+            self.args.remove(index); // same index, as the vector has shifted
+        });
+        self
+    }
+    pub fn remove_flag_arg(&mut self, name: &str) -> &mut Command {
+        self.args.iter().position(|x| x == name).map(|index| {
+            self.args.remove(index);
+        });
+        self
+    }
 }
 
 impl Display for Command {