Implemented storing state of resource tree.

Author: JavaSaBr

src/com/ss/editor/model/workspace/Workspace.java

@@ -19,13 +19,18 @@
 import java.nio.file.LinkOption;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Supplier;
 
 import rlib.logging.Logger;
 import rlib.logging.LoggerManager;
+import rlib.util.StringUtils;
+import rlib.util.array.Array;
+import rlib.util.array.ArrayFactory;
 
 /**
  * The workspace.
@@ -34,7 +39,7 @@
  */
 public class Workspace implements Serializable {
 
-    public static final long serialVersionUID = 61;
+    public static final long serialVersionUID = 63;
 
     private static final Logger LOGGER = LoggerManager.getLogger(Workspace.class);
 
@@ -48,6 +53,11 @@ public class Workspace implements Serializable {
      */
     private transient Path assetFolder;
 
+    /**
+     * The list of expanded folders.
+     */
+    private volatile List<String> expandedFolders;
+
     /**
      * The table of opened files.
      */
@@ -78,6 +88,12 @@ public void notifyRestored() {
 
         if (editorStateMap == null) {
             editorStateMap = new HashMap<>();
+        } else {
+            editorStateMap.forEach((key, editorState) -> editorState.setChangeHandler(this::incrementChanges));
+        }
+
+        if (expandedFolders == null) {
+            expandedFolders = new ArrayList<>();
         }
     }
 
@@ -113,6 +129,31 @@ private Map<String, EditorState> getEditorStateMap() {
         return editorStateMap;
     }
 
+    /**
+     * @return the list of expanded folders.
+     */
+    public synchronized Array<Path> getExpandedFolders() {
+
+        final Array<Path> result = ArrayFactory.newArray(Path.class);
+        final Path assetFolder = getAssetFolder();
+
+        expandedFolders.forEach(path -> result.add(assetFolder.resolve(path)));
+
+        return result;
+    }
+
+    /**
+     * Update the list of expanded folders.
+     */
+    public synchronized void updateExpandedFolders(final Array<Path> folders) {
+        expandedFolders.clear();
+
+        final Path assetFolder = getAssetFolder();
+        folders.forEach(path -> expandedFolders.add(assetFolder.relativize(path).toString()));
+
+        incrementChanges();
+    }
+
     /**
      * Get the editor state for the file.
      *
@@ -138,7 +179,10 @@ public synchronized <T extends EditorState> T getEditorState(@NotNull final Path
         final Map<String, EditorState> editorStateMap = getEditorStateMap();
 
         if (stateFactory != null && !editorStateMap.containsKey(assetPath)) {
-            editorStateMap.put(assetPath, stateFactory.get());
+            final EditorState editorState = stateFactory.get();
+            editorState.setChangeHandler(this::incrementChanges);
+            editorStateMap.put(assetPath, editorState);
+            incrementChanges();
         }
 
         return unsafeCast(editorStateMap.get(assetPath));
@@ -161,14 +205,33 @@ public synchronized void updateEditorState(@NotNull final Path file, @NotNull fi
     /**
      * Remove the editor state.
      */
-    public synchronized void removeEditorState(@NotNull final Path file, @NotNull final EditorState editorState) {
+    public synchronized void removeEditorState(@NotNull final Path file) {
 
         final Path assetFile = EditorUtil.getAssetFile(getAssetFolder(), file);
         final String assetPath = EditorUtil.toAssetPath(assetFile);
 
         final Map<String, EditorState> editorStateMap = getEditorStateMap();
-        editorStateMap.remove(assetPath);
+        if (editorStateMap.remove(assetPath) == null) return;
+
+        incrementChanges();
+    }
+
+    /**
+     * Update the editor state for moved/renamed file.
+     */
+    public synchronized void updateEditorState(@NotNull final Path prevFile, @NotNull final Path newFile) {
+
+        final Path prevAssetFile = EditorUtil.getAssetFile(getAssetFolder(), prevFile);
+        final String prevAssetPath = EditorUtil.toAssetPath(prevAssetFile);
+
+        final Map<String, EditorState> editorStateMap = getEditorStateMap();
+        final EditorState editorState = editorStateMap.remove(prevAssetPath);
+        if (editorState == null) return;
 
+        final Path newAssetFile = EditorUtil.getAssetFile(getAssetFolder(), newFile);
+        final String newAssetPath = EditorUtil.toAssetPath(newAssetFile);
+
+        editorStateMap.put(newAssetPath, editorState);
         incrementChanges();
     }
 
@@ -201,7 +264,8 @@ public synchronized void addOpenedFile(@NotNull final Path file, @NotNull final
         final EditorDescription description = fileEditor.getDescription();
 
         final Map<String, String> openedFiles = getOpenedFiles();
-        openedFiles.put(assetPath, description.getEditorId());
+        final String previous = openedFiles.put(assetPath, description.getEditorId());
+        if (StringUtils.equals(previous, description.getEditorId())) return;
 
         incrementChanges();
     }
@@ -286,7 +350,7 @@ public void save() {
 
             channel.write(buffer);
 
-        } catch (IOException e) {
+        } catch (final IOException e) {
             LOGGER.warning(e);
         }
     }

src/com/ss/editor/ui/component/asset/AssetComponent.java

@@ -1,8 +1,12 @@
 package com.ss.editor.ui.component.asset;
 
 import com.ss.editor.config.EditorConfig;
+import com.ss.editor.manager.ExecutorManager;
+import com.ss.editor.manager.WorkspaceManager;
+import com.ss.editor.model.workspace.Workspace;
 import com.ss.editor.ui.component.ScreenComponent;
 import com.ss.editor.ui.component.asset.tree.ResourceTree;
+import com.ss.editor.ui.component.asset.tree.resource.FolderElement;
 import com.ss.editor.ui.component.asset.tree.resource.ResourceElement;
 import com.ss.editor.ui.component.asset.tree.resource.ResourceElementFactory;
 import com.ss.editor.ui.css.CSSIds;
@@ -36,6 +40,7 @@ public class AssetComponent extends VBox implements ScreenComponent {
 
     private static final Insets TREE_OFFSET = new Insets(6, 3, 0, 0);
 
+    private static final ExecutorManager EXECUTOR_MANAGER = ExecutorManager.getInstance();
     private static final FXEventManager FX_EVENT_MANAGER = FXEventManager.getInstance();
 
     /**
@@ -53,6 +58,11 @@ public class AssetComponent extends VBox implements ScreenComponent {
      */
     private ResourceTree resourceTree;
 
+    /**
+     * The flag for ignoring expand changes.
+     */
+    private boolean ignoreExpanded;
+
     public AssetComponent() {
         this.waitedFilesToSelect = ArrayFactory.newArray(Path.class);
         setId(CSSIds.ASSET_COMPONENT);
@@ -102,6 +112,11 @@ private void processEvent(final MovedFileEvent event) {
 
         final ResourceTree resourceTree = getResourceTree();
         resourceTree.notifyMoved(prevFile, newFile);
+
+        final WorkspaceManager workspaceManager = WorkspaceManager.getInstance();
+        final Workspace workspace = workspaceManager.getCurrentWorkspace();
+        if (workspace == null) return;
+        workspace.updateEditorState(prevFile, newFile);
     }
 
     /**
@@ -114,6 +129,11 @@ private void processEvent(final RenamedFileEvent event) {
 
         final ResourceTree resourceTree = getResourceTree();
         resourceTree.notifyRenamed(prevFile, newFile);
+
+        final WorkspaceManager workspaceManager = WorkspaceManager.getInstance();
+        final Workspace workspace = workspaceManager.getCurrentWorkspace();
+        if (workspace == null) return;
+        workspace.updateEditorState(prevFile, newFile);
     }
 
     /**
@@ -142,6 +162,11 @@ private void processEvent(final DeletedFileEvent event) {
 
         final ResourceTree resourceTree = getResourceTree();
         resourceTree.notifyDeleted(file);
+
+        final WorkspaceManager workspaceManager = WorkspaceManager.getInstance();
+        final Workspace workspace = workspaceManager.getCurrentWorkspace();
+        if (workspace == null) return;
+        workspace.removeEditorState(file);
     }
 
     /**
@@ -169,9 +194,12 @@ private void processRefresh() {
      * Create components.
      */
     private void createComponents() {
+        setIgnoreExpanded(true);
 
         this.barComponent = new AssetBarComponent();
         this.resourceTree = new ResourceTree(false);
+        this.resourceTree.setExpandHandler(this::updateExpanded);
+        this.resourceTree.setOnLoadHandler(this::handleTreeLoading);
 
         //FIXME пока он не нужен
         //FXUtils.addToPane(barComponent, this);
@@ -182,6 +210,62 @@ private void createComponents() {
         VBox.setMargin(resourceTree, TREE_OFFSET);
     }
 
+    /**
+     * Handle changing loading state of the tree.
+     */
+    private void handleTreeLoading(final Boolean finished) {
+
+        final WorkspaceManager workspaceManager = WorkspaceManager.getInstance();
+        final Workspace workspace = workspaceManager.getCurrentWorkspace();
+
+        if (finished && workspace != null) {
+            final Array<Path> expandedFolders = workspace.getExpandedFolders();
+            expandedFolders.forEach(path -> resourceTree.expandTo(path, false));
+        }
+
+        if (finished) {
+            EXECUTOR_MANAGER.addFXTask(() -> setIgnoreExpanded(false));
+        } else {
+            setIgnoreExpanded(true);
+        }
+    }
+
+    /**
+     * @return true if the expand listener is ignored.
+     */
+    public boolean isIgnoreExpanded() {
+        return ignoreExpanded;
+    }
+
+    /**
+     * @param ignoreExpanded the flag for ignoring expand changes.
+     */
+    public void setIgnoreExpanded(final boolean ignoreExpanded) {
+        this.ignoreExpanded = ignoreExpanded;
+    }
+
+    /**
+     * Handle changes count of expanded folders.
+     */
+    private void updateExpanded(final int count, final ResourceTree tree) {
+        if (isIgnoreExpanded()) return;
+
+        final WorkspaceManager workspaceManager = WorkspaceManager.getInstance();
+        final Workspace workspace = workspaceManager.getCurrentWorkspace();
+        if (workspace == null) return;
+
+        final Array<Path> expanded = ArrayFactory.newArray(Path.class);
+        final Array<TreeItem<ResourceElement>> allItems = UIUtils.getAllItems(tree);
+        allItems.stream().filter(TreeItem::isExpanded)
+                .filter(treeItem -> !treeItem.isLeaf())
+                .map(TreeItem::getValue)
+                .filter(element -> element instanceof FolderElement)
+                .map(ResourceElement::getFile)
+                .forEach(expanded::add);
+
+        workspace.updateExpandedFolders(expanded);
+    }
+
     /**
      * @return the toolbar of this component.
      */