VCS: changes view, for VirtualFiles in tree, don't wrap them into Filepath just to...
authorirengrig <Irina.Chernushina@jetbrains.com>
Wed, 10 Mar 2010 06:59:10 +0000 (09:59 +0300)
committerirengrig <Irina.Chernushina@jetbrains.com>
Wed, 10 Mar 2010 06:59:10 +0000 (09:59 +0300)
platform/vcs-api/src/com/intellij/openapi/vcs/Heavy.java [new file with mode: 0644]
platform/vcs-api/src/com/intellij/openapi/vcs/changes/FilePathsHelper.java [new file with mode: 0644]
platform/vcs-impl/src/com/intellij/openapi/vcs/FilePathImpl.java
platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ui/TreeModelBuilder.java

diff --git a/platform/vcs-api/src/com/intellij/openapi/vcs/Heavy.java b/platform/vcs-api/src/com/intellij/openapi/vcs/Heavy.java
new file mode 100644 (file)
index 0000000..60bcf30
--- /dev/null
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2000-2010 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.openapi.vcs;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.SOURCE)
+@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
+public @interface Heavy {
+}
diff --git a/platform/vcs-api/src/com/intellij/openapi/vcs/changes/FilePathsHelper.java b/platform/vcs-api/src/com/intellij/openapi/vcs/changes/FilePathsHelper.java
new file mode 100644 (file)
index 0000000..e30abfe
--- /dev/null
@@ -0,0 +1,24 @@
+package com.intellij.openapi.vcs.changes;
+
+import com.intellij.openapi.util.SystemInfo;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vcs.FilePath;
+import com.intellij.openapi.vfs.VirtualFile;
+
+public class FilePathsHelper {
+  private FilePathsHelper() {
+  }
+
+  public static String convertPath(final VirtualFile vf) {
+    return convertPath(vf.getPath());
+  }
+
+  public static String convertPath(final FilePath fp) {
+    return convertPath(fp.getPath());
+  }
+
+  public static String convertPath(final String s) {
+    String result = FileUtil.toSystemIndependentName(s);
+    return SystemInfo.isFileSystemCaseSensitive ? result : result.toUpperCase();
+  }
+}
index a29aa03ef312734dd7e20bf7b9954f987ee10c9c..fc41c6058ab948534c8d12880a793aa08e7c075b 100644 (file)
@@ -65,10 +65,12 @@ public class FilePathImpl implements FilePath {
     }
   }
 
+  @Heavy
   public FilePathImpl(VirtualFile virtualParent, String name, final boolean isDirectory) {
     this(virtualParent, name, isDirectory, null, false);
   }
 
+  @Heavy
   private FilePathImpl(VirtualFile virtualParent, String name, final boolean isDirectory, final boolean forDeleted) {
     this(virtualParent, name, isDirectory, null, forDeleted);
   }
index 4ff479b52113d82cba2f8d610253b8b33378c28a..96dda65b38c8329bb1118acd525a6d81b646dbf9 100644 (file)
@@ -48,7 +48,7 @@ public class TreeModelBuilder {
   private final ChangesBrowserNode root;
   private boolean myPolicyInitialized;
   private ChangesGroupingPolicy myPolicy;
-  private final HashMap<String, ChangesBrowserNode> myFoldersCache;
+  private HashMap<String, ChangesBrowserNode> myFoldersCache;
 
   public TreeModelBuilder(final Project project, final boolean showFlatten) {
     myProject = project;
@@ -171,7 +171,7 @@ public class TreeModelBuilder {
   }
 
   private void resetGrouping() {
-    myFoldersCache.clear();
+    myFoldersCache = new HashMap<String, ChangesBrowserNode>();
     myPolicyInitialized = false;
   }
 
@@ -235,26 +235,29 @@ public class TreeModelBuilder {
   private void buildLocallyDeletedPaths(final Collection<LocallyDeletedChange> locallyDeletedChanges, final ChangesBrowserNode baseNode) {
     final ChangesGroupingPolicy policy = createGroupingPolicy();
     for (LocallyDeletedChange change : locallyDeletedChanges) {
-      ChangesBrowserNode oldNode = myFoldersCache.get(change.getPresentableUrl());
+      final String key = FilePathsHelper.convertPath(change.getPresentableUrl());
+      ChangesBrowserNode oldNode = myFoldersCache.get(key);
       if (oldNode == null) {
         final ChangesBrowserNode node = ChangesBrowserNode.create(myProject, change);
         final ChangesBrowserNode parent = getParentNodeFor(node, policy, baseNode);
         model.insertNodeInto(node, parent, parent.getChildCount());
-        myFoldersCache.put(change.getPresentableUrl(), node);
+        myFoldersCache.put(key, node);
       }
     }
   }
 
-  public void buildFilePaths(final Collection<FilePath> filePaths, final ChangesBrowserNode baseNode) {
+  private void buildFilePaths(final Collection<FilePath> filePaths, final ChangesBrowserNode baseNode) {
     final ChangesGroupingPolicy policy = createGroupingPolicy();
     for (FilePath file : filePaths) {
       assert file != null;
-      ChangesBrowserNode oldNode = myFoldersCache.get(file.getIOFile().getAbsolutePath());
+      // todo: or path from filepath?
+      final String pathKey = FilePathsHelper.convertPath(file.getIOFile().getAbsolutePath());
+      ChangesBrowserNode oldNode = myFoldersCache.get(pathKey);
       if (oldNode == null) {
         final ChangesBrowserNode node = ChangesBrowserNode.create(myProject, file);
         final ChangesBrowserNode parentNode = getParentNodeFor(node, policy, baseNode);
         model.insertNodeInto(node, parentNode, 0);
-        myFoldersCache.put(file.getIOFile().getAbsolutePath(), node);
+        myFoldersCache.put(pathKey, node);
       }
     }
   }
@@ -326,9 +329,9 @@ public class TreeModelBuilder {
 
   private void insertChangeNode(final Object change, final ChangesGroupingPolicy policy,
                                 final ChangesBrowserNode listNode, final Computable<ChangesBrowserNode> nodeCreator) {
-    final FilePath nodePath = getPathForObject(change);
-    ChangesBrowserNode oldNode = (nodePath == null) ? null : myFoldersCache.get(nodePath.getIOFile().getAbsolutePath());
-    ChangesBrowserNode node = nodeCreator.compute();
+    final String pathKey = getKey(change);
+    ChangesBrowserNode oldNode = (pathKey == null) ? null : myFoldersCache.get(pathKey);
+    final ChangesBrowserNode node = nodeCreator.compute();
     if (oldNode != null) {
       for(int i=oldNode.getChildCount()-1; i >= 0; i--) {
         MutableTreeNode child = (MutableTreeNode) model.getChild(oldNode, i);
@@ -339,32 +342,36 @@ public class TreeModelBuilder {
       int index = model.getIndexOfChild(parent, oldNode);
       model.removeNodeFromParent(oldNode);
       model.insertNodeInto(node, parent, index);
-      myFoldersCache.put(nodePath.getIOFile().getAbsolutePath(), node);
     }
     else {
       ChangesBrowserNode parentNode = getParentNodeFor(node, policy, listNode);
       model.insertNodeInto(node, parentNode, model.getChildCount(parentNode));
-      // ?
-      if (nodePath != null) {
-        myFoldersCache.put(nodePath.getIOFile().getAbsolutePath(), node);
-      }
+    }
+
+    if (pathKey != null) {
+      myFoldersCache.put(pathKey, node);
     }
   }
 
   private void sortNodes() {
-    TreeUtil.sort(model, new Comparator() {
-      public int compare(final Object n1, final Object n2) {
-        final ChangesBrowserNode node1 = (ChangesBrowserNode)n1;
-        final ChangesBrowserNode node2 = (ChangesBrowserNode)n2;
+    // todo static instance + think
+    TreeUtil.sort(model, MyChangesBrowserNodeComparator.getInstance());
+
+    model.nodeStructureChanged((TreeNode)model.getRoot());
+  }
 
-        final int classdiff = node1.getSortWeight() - node2.getSortWeight();
-        if (classdiff != 0) return classdiff;
+  private static class MyChangesBrowserNodeComparator implements Comparator<ChangesBrowserNode> {
+    private static final MyChangesBrowserNodeComparator ourInstance = new MyChangesBrowserNodeComparator();
 
-        return node1.compareUserObjects(node2.getUserObject());
-      }
-   });
+    public static MyChangesBrowserNodeComparator getInstance() {
+      return ourInstance;
+    }
 
-    model.nodeStructureChanged((TreeNode)model.getRoot());
+    public int compare(ChangesBrowserNode node1, ChangesBrowserNode node2) {
+      final int classdiff = node1.getSortWeight() - node2.getSortWeight();
+      if (classdiff != 0) return classdiff;
+      return node1.compareUserObjects(node2.getUserObject());
+    }
   }
 
   private static void collapseDirectories(DefaultTreeModel model, ChangesBrowserNode node) {
@@ -388,6 +395,26 @@ public class TreeModelBuilder {
     }
   }
 
+  // todo: temporal
+  private static String getKey(final Object o) {
+    if (o instanceof Change) {
+      return FilePathsHelper.convertPath(ChangesUtil.getFilePath((Change) o));
+    }
+    else if (o instanceof VirtualFile) {
+      return FilePathsHelper.convertPath((VirtualFile) o);
+    }
+    else if (o instanceof FilePath) {
+      // todo ? or path from filepath
+      return FilePathsHelper.convertPath(((FilePath) o).getIOFile().getAbsolutePath());
+    } else if (o instanceof ChangesBrowserLogicallyLockedFile) {
+      return FilePathsHelper.convertPath(((ChangesBrowserLogicallyLockedFile) o).getUserObject());
+    } else if (o instanceof LocallyDeletedChange) {
+      return FilePathsHelper.convertPath(((LocallyDeletedChange) o).getPath());
+    }
+
+    return null;
+  }
+
   public static FilePath getPathForObject(Object o) {
     if (o instanceof Change) {
       return ChangesUtil.getFilePath((Change)o);
@@ -425,7 +452,7 @@ public class TreeModelBuilder {
       return rootNode;
     }
 
-    final String parentKey = parentPath.getIOFile().getAbsolutePath();
+    final String parentKey = FilePathsHelper.convertPath(parentPath);
     ChangesBrowserNode parentNode = myFoldersCache.get(parentKey);
     if (parentNode == null) {
       parentNode = ChangesBrowserNode.create(myProject, parentPath);
@@ -440,7 +467,7 @@ public class TreeModelBuilder {
   public DefaultTreeModel clearAndGetModel() {
     root.removeAllChildren();
     model = new DefaultTreeModel(root);
-    myFoldersCache.clear();
+    myFoldersCache = new HashMap<String, ChangesBrowserNode>();
     myPolicyInitialized = false;
     return model;
   }