path: root/plugins/cvs/cvs-plugin/src/com/intellij/cvsSupport2/ui/experts/importToCvs/ImportTree.java

/*
 * Copyright 2000-2011 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.cvsSupport2.ui.experts.importToCvs;

import com.intellij.CvsBundle;
import com.intellij.cvsSupport2.CvsUtil;
import com.intellij.cvsSupport2.cvsIgnore.IgnoredFilesInfo;
import com.intellij.cvsSupport2.cvsIgnore.IgnoredFilesInfoImpl;
import com.intellij.cvsSupport2.ui.experts.CvsWizard;
import com.intellij.cvsSupport2.util.CvsVfsUtil;
import com.intellij.ide.util.treeView.NodeDescriptor;
import com.intellij.ide.util.treeView.NodeRenderer;
import com.intellij.openapi.actionSystem.AnAction;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.Presentation;
import com.intellij.openapi.fileChooser.FileElement;
import com.intellij.openapi.fileChooser.FileSystemTree;
import com.intellij.openapi.fileTypes.FileTypeManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.IconLoader;
import com.intellij.openapi.vcs.ProjectLevelVcsManager;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VfsUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.ui.SimpleTextAttributes;
import com.intellij.util.IconUtil;
import com.intellij.util.PlatformIcons;
import com.intellij.util.containers.HashMap;
import com.intellij.util.containers.HashSet;
import org.jetbrains.annotations.Nullable;
import org.netbeans.lib.cvsclient.file.AbstractFileObject;
import org.netbeans.lib.cvsclient.file.ICvsFileSystem;
import org.netbeans.lib.cvsclient.util.IIgnoreFileFilter;

import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.File;
import java.util.Collection;
import java.util.Map;

/**
 * @author lesya
 */
public class ImportTree extends NodeRenderer {
  private final Collection<VirtualFile> myExcludedFiles = new HashSet<VirtualFile>();
  private final Collection<VirtualFile> myIncludedFiles = new HashSet<VirtualFile>();
  private final Project myProject;
  private final FileSystemTree myFileSystemTree;
  private final CvsWizard myWizard;

  public ImportTree(@Nullable Project project, FileSystemTree fileSystemTree, CvsWizard wizard) {
    myProject = project;
    myFileSystemTree = fileSystemTree;
    myWizard = wizard;
  }

  public void customizeCellRenderer(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
    if (customize(tree, value, selected, expanded, leaf, row, hasFocus)) return;
    super.customizeCellRenderer(tree, value, selected, expanded, leaf, row, hasFocus);
  }

  private boolean customize(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
    if (!(value instanceof DefaultMutableTreeNode)) {
      return false;
    }
    final DefaultMutableTreeNode node = (DefaultMutableTreeNode)value;
    final Object userObject = node.getUserObject();
    if (!(userObject instanceof NodeDescriptor)) {
      return false;
    }
    final NodeDescriptor descriptor = (NodeDescriptor)userObject;
    final Object element = descriptor.getElement();
    if (!(element instanceof FileElement)) {
      return false;
    }
    final FileElement fileElement = (FileElement)element;
    if (!isExcluded(fileElement)) {
      return false;
    }
    setIcon(IconLoader.getDisabledIcon(descriptor.getIcon()));
    final String text = tree.convertValueToText(value, selected, expanded, leaf, row, hasFocus);
    append(text, new SimpleTextAttributes(SimpleTextAttributes.STYLE_STRIKEOUT, tree.getForeground()));
    return true;
  }

  public AnAction createExcludeAction() {
    return new AnAction(CvsBundle.message("import.wizard.exclude.from.import.action.name"), null, PlatformIcons.DELETE_ICON) {
      public void update(AnActionEvent e) {
        final VirtualFile[] selectedFiles = myFileSystemTree.getSelectedFiles();
        final Presentation presentation = e.getPresentation();
        presentation.setEnabled(isAtLeastOneFileIncluded(selectedFiles));
      }

      public void actionPerformed(AnActionEvent e) {
        final VirtualFile[] selectedFiles = myFileSystemTree.getSelectedFiles();
        for (VirtualFile selectedFile : selectedFiles) {
          exclude(selectedFile);
        }
        myWizard.updateStep();
        myFileSystemTree.getTree().repaint();
      }
    };
  }

  private boolean isAtLeastOneFileIncluded(VirtualFile[] selectedFiles) {
    if (selectedFiles == null || selectedFiles.length == 0) return false;
    for (VirtualFile selectedFile : selectedFiles) {
      if (!isExcluded(selectedFile)) {
        return true;
      }
    }
    return false;
  }

  public AnAction createIncludeAction() {
    return new AnAction(CvsBundle.message("import.wizard.include.to.import.action.name"), null, IconUtil.getAddIcon()) {
      public void update(AnActionEvent e) {
        final VirtualFile[] selectedFiles = myFileSystemTree.getSelectedFiles();
        final Presentation presentation = e.getPresentation();
        presentation.setEnabled(isAtLeastOneFileExcluded(selectedFiles));
      }

      public void actionPerformed(AnActionEvent e) {
        final VirtualFile[] selectedFiles = myFileSystemTree.getSelectedFiles();
        for (VirtualFile selectedFile : selectedFiles) {
          include(selectedFile);
        }
        myWizard.updateStep();
        myFileSystemTree.getTree().repaint();
      }
    };
  }

  private void include(VirtualFile selectedFile) {
    myExcludedFiles.remove(selectedFile);
    if (myProject == null) {
      return;
    }
    if (!isIgnoredByVcs(selectedFile)) {
      return;
    }
    final VirtualFile parent = selectedFile.getParent();
    if (parent != null && isIgnoredByVcs(parent)) {
      return;
    }
    for (final VirtualFile excludedFile : myExcludedFiles) {
      if (VfsUtil.isAncestor(excludedFile, selectedFile, true)) {
        return;
      }
    }
    myIncludedFiles.add(selectedFile);
  }

  private void exclude(VirtualFile selectedFile) {
    myExcludedFiles.add(selectedFile);
    myIncludedFiles.remove(selectedFile);
  }

  private boolean isAtLeastOneFileExcluded(VirtualFile[] selectedFiles) {
    if (selectedFiles == null || selectedFiles.length == 0) {
      return false;
    }
    for (VirtualFile selectedFile : selectedFiles) {
      if (myExcludedFiles.contains(selectedFile)) {
        return true;
      }
      if (myProject == null) {
        continue;
      }
      if (!isIgnoredByVcs(selectedFile)) {
        continue;
      }
      final VirtualFile parent = selectedFile.getParent();
      if (parent == null || isIgnoredByVcs(parent) || myExcludedFiles.contains(parent)) {
        continue;
      }
      if (!myIncludedFiles.contains(selectedFile)) {
        return true;
      }
    }
    return false;
  }

  private boolean isExcluded(FileElement fileElement) {
    final VirtualFile file = fileElement.getFile();
    if (file == null) {
      return false;
    }
    return isExcluded(file);
  }

  public boolean isExcluded(VirtualFile file) {
    for (final VirtualFile excludedFile : myExcludedFiles) {
      if (VfsUtil.isAncestor(excludedFile, file, false)) {
        return true;
      }
    }
    if (myProject == null || !isIgnoredByVcs(file)) {
      return false;
    }
    for (VirtualFile includedFile : myIncludedFiles) {
      if (VfsUtil.isAncestor(includedFile, file, false)) {
        return false;
      }
    }
    return true;
  }

  public IIgnoreFileFilter getIgnoreFileFilter() {
    final Collection<File> excludedFiles = new HashSet<File>();
    for (final VirtualFile excludedFile : myExcludedFiles) {
      excludedFiles.add(CvsVfsUtil.getFileFor(excludedFile));
    }
    final Collection<File> includedFiles = new HashSet<File>();
    for (VirtualFile includedFile : myIncludedFiles) {
      includedFiles.add(CvsVfsUtil.getFileFor(includedFile));
    }

    return new IIgnoreFileFilter() {
      private final Map<File, IgnoredFilesInfo> myParentToIgnoresMap = new HashMap<File, IgnoredFilesInfo>();

      public boolean shouldBeIgnored(AbstractFileObject abstractFileObject, ICvsFileSystem cvsFileSystem) {
        final File file = cvsFileSystem.getLocalFileSystem().getFile(abstractFileObject);
        if (file.isDirectory() && file.getName().equals(CvsUtil.CVS)) return true;

        if (FileTypeManager.getInstance().isFileIgnored(abstractFileObject.getName())) return true;
        if (myProject != null && !includedFiles.contains(file)) {
          final VirtualFile vFile = LocalFileSystem.getInstance().findFileByIoFile(file);
          if (vFile != null && isIgnoredByVcs(vFile)) {
            return true;
          }
        }

        if (excludedFiles.contains(file)) return true;
        final File parentFile = file.getParentFile();
        if (parentFile == null) return false;
        if (!myParentToIgnoresMap.containsKey(parentFile)) {
          myParentToIgnoresMap.put(parentFile, IgnoredFilesInfoImpl.createForFile(new File(parentFile, CvsUtil.CVS_IGNORE_FILE)));
        }
        return myParentToIgnoresMap.get(parentFile).shouldBeIgnored(file.getName());
      }
    };
  }

  private boolean isIgnoredByVcs(VirtualFile vFile) {
    return myProject != null && ProjectLevelVcsManager.getInstance(myProject).isIgnored(vFile);
  }
}