Implement create new from template (#1616)

Author: jeremypw

src/FolderManager/FileView.vala

@@ -31,6 +31,7 @@ public class Scratch.FolderManager.FileView : Code.Widgets.SourceList, Code.Pane
     public const string ACTION_RENAME_FOLDER = "rename-folder";
     public const string ACTION_DELETE = "delete";
     public const string ACTION_NEW_FILE = "new-file";
+    public const string ACTION_NEW_FROM_TEMPLATE = "new-from-template";
     public const string ACTION_NEW_FOLDER = "new-folder";
     public const string ACTION_CLOSE_FOLDER = "close-folder";
     public const string ACTION_CLOSE_OTHER_FOLDERS = "close-other-folders";
@@ -43,6 +44,7 @@ public class Scratch.FolderManager.FileView : Code.Widgets.SourceList, Code.Pane
         { ACTION_RENAME_FOLDER, action_rename_folder, "s" },
         { ACTION_DELETE, action_delete, "s" },
         { ACTION_NEW_FILE, add_new_file, "s" },
+        { ACTION_NEW_FROM_TEMPLATE, add_new_from_template, "(ss)" },
         { ACTION_NEW_FOLDER, add_new_folder, "s"},
         { ACTION_CLOSE_FOLDER, action_close_folder, "s"},
         { ACTION_CLOSE_OTHER_FOLDERS, action_close_other_folders, "s"}
@@ -363,6 +365,7 @@ public class Scratch.FolderManager.FileView : Code.Widgets.SourceList, Code.Pane
         plugins.hook_folder_item_change (source, dest, event);
     }
 
+    // This only works when the list is stable (nothing being added, expanded etc)
     private void rename_file (string path) {
         this.select_path (path);
         if (this.start_editing_item (selected)) {
@@ -458,9 +461,10 @@ public class Scratch.FolderManager.FileView : Code.Widgets.SourceList, Code.Pane
 
     private void add_new_file (SimpleAction action, Variant? param) {
         // Using "path" of parent folder from params, call `on_add_new (false)` on `FolderItem`
-        var path = param.get_string ();
+        var path = param != null ? param.get_string () : null;
 
         if (path == null || path == "") {
+            critical ("No path");
             return;
         }
 
@@ -472,6 +476,25 @@ public class Scratch.FolderManager.FileView : Code.Widgets.SourceList, Code.Pane
         folder.on_add_new (false);
     }
 
+    private void add_new_from_template (SimpleAction action, Variant? param) {
+        // Using "path" of parent folder from params, call `on_add_new (false)` on `FolderItem`
+        // var path = param.get_string ();
+        string? parent_path = null, template_path = null;
+        param.@get ("(ss)", out parent_path, out template_path);
+
+        //Do we need this check?
+        if (parent_path == null || parent_path == "") {
+            return;
+        }
+
+        var folder = find_path (root, parent_path) as FolderItem;
+        if (folder == null) {
+            return;
+        }
+
+        folder.on_add_template (template_path);
+    }
+
     private void action_launch_app_with_file_path (SimpleAction action, Variant? param) {
         var params = param.get_strv ();
         Utils.launch_app_with_file (params[1], params[0]);

src/FolderManager/FolderItem.vala

@@ -24,6 +24,7 @@ namespace Scratch.FolderManager {
      * Monitored for changes inside the directory.
      */
     public class FolderItem : Item {
+        private const uint RENAME_AFTER_NEW_DELAY_MSEC = 500;
         private GLib.FileMonitor monitor;
         private bool children_loaded = false;
         private bool has_dummy;
@@ -35,6 +36,8 @@ namespace Scratch.FolderManager {
             }
         }
 
+        public signal void children_finished_loading ();
+
         public FolderItem (File file, FileView view) {
             Object (file: file, view: view);
         }
@@ -107,6 +110,8 @@ namespace Scratch.FolderManager {
             if (root != null) {
                 root.child_folder_loaded (this); //Updates child status emblens
             }
+
+            children_finished_loading ();
         }
 
         private void on_toggled () {
@@ -237,12 +242,106 @@ namespace Scratch.FolderManager {
             new_menu.append_item (new_folder_item);
             new_menu.append_item (new_file_item);
 
+            //Append any templates/template folders.
+            unowned string? template_path = GLib.Environment.get_user_special_dir (GLib.UserDirectory.TEMPLATES);
+            if (template_path != null) {
+                var template_submenu = new Menu ();
+                uint template_count = load_templates_from_folder (GLib.File.new_for_path (template_path), template_submenu);
+                if (template_count > 0) {
+                    if (template_count > MAX_TEMPLATES) {
+                        template_submenu.append_item (new MenuItem (_("…too many templates"), null));
+                    }
+
+                    new_menu.append_submenu (_("Templates"), template_submenu);
+                }
+            }
+
             var new_item = new GLib.MenuItem.submenu (_("New"), new_menu);
             new_item.set_submenu (new_menu);
 
             return new_item;
         }
 
+        // Recursively load templates from folder and subfolders keeping count of total menuitems
+        const int MAX_TEMPLATES = 2048;
+        private uint load_templates_from_folder (GLib.File template_folder, Menu template_submenu) {
+            GLib.List<GLib.File> template_list = null;
+            GLib.List<GLib.File> folder_list = null;
+
+            GLib.FileEnumerator enumerator;
+            var flags = GLib.FileQueryInfoFlags.NOFOLLOW_SYMLINKS;
+            uint count = 0;
+            try {
+                enumerator = template_folder.enumerate_children ("standard::*", flags, null);
+                GLib.File location;
+                GLib.FileInfo? info = enumerator.next_file (null);
+
+                while (count < MAX_TEMPLATES && (info != null)) {
+                    if (!info.get_attribute_boolean (GLib.FileAttribute.STANDARD_IS_BACKUP)) {
+                        location = template_folder.get_child (info.get_name ());
+                        if (info.get_file_type () == GLib.FileType.DIRECTORY) {
+                            folder_list.prepend (location);
+                        } else {
+                            template_list.prepend (location);
+                        }
+
+                        count ++;
+                    }
+
+                    info = enumerator.next_file (null);
+                }
+            } catch (GLib.Error error) {
+                return 0;
+            }
+
+            folder_list.sort ((a, b) => {
+                return strcmp (a.get_basename ().down (), b.get_basename ().down ());
+            });
+
+            unowned List<GLib.File> fl = folder_list;
+            while (fl != null && count < MAX_TEMPLATES) {
+                var folder = fl.data;
+                var folder_submenu = new Menu ();
+                var folder_submenuitem = new MenuItem.submenu (
+                    folder.get_basename (),
+                    folder_submenu
+                );
+
+                var sub_count = load_templates_from_folder (folder, folder_submenu);
+                if (sub_count > 0) {
+                    template_submenu.append_item (folder_submenuitem);
+                    count += sub_count;
+                } else {
+                    count -= 1;  // Adjust count for ignored folder
+                }
+
+                fl = fl.next;
+            }
+
+            if (count > MAX_TEMPLATES) {
+                warning ("too many templates! %u", count);
+                return count;
+            }
+
+            template_list.sort ((a, b) => {
+                return strcmp (a.get_basename ().down (), b.get_basename ().down ());
+            });
+
+            template_list.@foreach ((template) => {
+                var template_menuitem = new MenuItem (
+                    template.get_basename (),
+                    GLib.Action.print_detailed_name (
+                        FileView.ACTION_PREFIX + FileView.ACTION_NEW_FROM_TEMPLATE,
+                        new Variant ("(ss)", this.path, template.get_path ())
+                    )
+                );
+
+                template_submenu.append_item (template_menuitem);
+            });
+
+            return count;
+        }
+
         public void remove_all_badges () {
             foreach (var child in children) {
                 remove_badge (child);
@@ -263,7 +362,7 @@ namespace Scratch.FolderManager {
                 has_dummy = false;
             }
 
-            ((Code.Widgets.SourceList.ExpandableItem)this).add (item);
+            base.add (item);
         }
 
         public new void remove (Code.Widgets.SourceList.Item item) {
@@ -337,7 +436,6 @@ namespace Scratch.FolderManager {
                         if (source.query_exists () == false) {
                             return;
                         }
-
                         var path_item = find_item_for_path (source.get_path ());
                         if (path_item == null) {
                             var file = new File (source.get_path ());
@@ -386,26 +484,111 @@ namespace Scratch.FolderManager {
             return null;
         }
 
-        public void on_add_new (bool is_folder) {
+        public void on_add_template (string template_path) {
+            // Expand folder before trying to copy template so that child appears for renaming
+            if (!expanded) {
+                expanded = true;  // causes async loading of children
+                ulong once = 0;
+                once = children_finished_loading.connect (() => {
+                    this.disconnect (once);
+                    copy_template (template_path);
+                });
+            } else {
+                copy_template (template_path);
+            }
+        }
+
+        private void copy_template (string template_path) {
             if (!file.is_executable) {
                 // This is necessary to avoid infinite loop below
                 warning ("Unable to open parent folder");
                 return;
             }
 
-            unowned string name = is_folder ? _("untitled folder") : _("new file");
+            var template_file = GLib.File.new_for_path (template_path);
+            name = template_file.get_basename ();
             var new_file = file.file.get_child (name);
             var n = 1;
+            while (new_file.query_exists ()) {
+                new_file = file.file.get_child (("%s %d").printf (name, n));
+                n++;
+            }
+
+            name = new_file.get_basename ();
+
+            //Assume templates are small and can be copied without problems
+            try {
+                template_file.copy (
+                    new_file,
+                    TARGET_DEFAULT_MODIFIED_TIME | TARGET_DEFAULT_PERMS | NOFOLLOW_SYMLINKS,
+                    null, //No cancellable
+                    null  //No progress
+                );
+            } catch (Error e) {
+                warning ("Error copying template %s", e.message);
+                return;
+            }
 
+            // Wait for monitor to pickup file creation and add new item
+            ulong once = 0;
+            once = child_added.connect (() => {
+                this.disconnect (once);
+                var path = new_file.get_path ();
+                // Still need to wait for sourcelist to become stable and editable
+                //TODO Find a better way
+                Timeout.add (RENAME_AFTER_NEW_DELAY_MSEC, () => {
+                    var rename_action = Utils.action_from_group (FileView.ACTION_RENAME_FILE, view.actions);
+                    if (rename_action != null && rename_action.enabled) {
+                        rename_action.activate (path);
+                    } else {
+                        critical ("Rename action not available");
+                    }
+
+                    return Source.REMOVE;
+                });
+            });
+        }
+
+        public void on_add_new (bool is_folder) {
+            if (!file.is_executable) {
+                // This is necessary to avoid infinite loop below
+                warning ("Unable to open parent folder");
+                return;
+            }
+
+
+            var name = is_folder ? _("untitled folder") : _("new file");
+            var new_file = file.file.get_child (name);
+            var n = 1;
             while (new_file.query_exists ()) {
                 new_file = file.file.get_child (("%s %d").printf (name, n));
                 n++;
             }
-            expanded = true;
-            var rename_item = new RenameItem (new_file.get_basename (), is_folder);
+
+            name = new_file.get_basename ();
+
+            // Expand folder before trying to rename
+            if (!expanded) {
+                ulong once = 0;
+                once = children_finished_loading.connect (() => {
+                    this.disconnect (once);
+                    rename_new (name, is_folder);
+                });
+
+                expanded = true;  // causes async loading of children
+            } else {
+                rename_new (name, is_folder);
+            }
+        }
+
+        private void rename_new (string name, bool is_folder) requires (!view.editing) {
+            var rename_item = new RenameItem (name, is_folder);
             add (rename_item);
-            /* Start editing after finishing signal handler */
-            GLib.Idle.add (() => {
+
+            // Wait until can start editing
+            // For some reason using an Idle does not work properly here - the editable gets drawn in the wrong place
+            //TODO Find a way to detect when the sourcelist is stable and can be edited
+            Timeout.add (RENAME_AFTER_NEW_DELAY_MSEC, () => {
                 if (view.start_editing_item (rename_item)) {
                     ulong once = 0;
                     once = rename_item.edited.connect (() => {
@@ -414,7 +597,7 @@ namespace Scratch.FolderManager {
                         var new_name = rename_item.name;
                         try {
                             var gfile = file.file.get_child_for_display_name (new_name);
-                            if (is_folder) {
+                            if (rename_item.is_folder) {
                                 gfile.make_directory ();
                             } else {
                                 gfile.create (FileCreateFlags.NONE);
@@ -431,45 +614,16 @@ namespace Scratch.FolderManager {
                             return Source.CONTINUE;
                         } else {
                             remove (rename_item);
+                            return Source.REMOVE;
                         }
-
-                        return Source.REMOVE;
                     });
                 } else {
+                    critical ("Failed to rename new item");
                     remove (rename_item);
                 }
 
-
                 return Source.REMOVE;
             });
         }
     }
-
-    internal class RenameItem : Code.Widgets.SourceList.Item {
-        public bool is_folder { get; construct; }
-
-        public RenameItem (string name, bool is_folder) {
-            Object (
-                name: name,
-                is_folder: is_folder
-            );
-        }
-
-        construct {
-            editable = true;
-            edited.connect (on_edited);
-
-            if (is_folder) {
-                icon = GLib.ContentType.get_icon ("inode/directory");
-            } else {
-                icon = GLib.ContentType.get_icon ("text");
-            }
-        }
-
-        private void on_edited (string new_name) {
-            if (new_name != "") {
-                name = new_name;
-            }
-        }
-    }
 }