import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@NotNull
public static Map<VirtualFile, VcsLogProvider> findLogProviders(@NotNull Collection<VcsRoot> roots, @NotNull Project project) {
  Map<VirtualFile, VcsLogProvider> logProviders = ContainerUtil.newHashMap();
  VcsLogProvider[] allLogProviders = Extensions.getExtensions(LOG_PROVIDER_EP, project);
  for (VcsRoot root : roots) {
    AbstractVcs vcs = root.getVcs();
    VirtualFile path = root.getPath();
    if (vcs == null || path == null) {
      LOG.error("Skipping invalid VCS root: " + root);
      continue;
    }

    for (VcsLogProvider provider : allLogProviders) {
      if (provider.getSupportedVcs().equals(vcs.getKeyInstanceMethod())) {
        logProviders.put(path, provider);
        break;
      }
    }
  }
  return logProviders;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@NotNull
private Map<VirtualFile, Repository> findNewRoots(@NotNull Set<VirtualFile> knownRoots) {
  Map<VirtualFile, Repository> newRootsMap = ContainerUtil.newHashMap();
  for (VcsRoot root : myVcsManager.getAllVcsRoots()) {
    VirtualFile rootPath = root.getPath();
    if (rootPath != null && !knownRoots.contains(rootPath)) {
      AbstractVcs vcs = root.getVcs();
      VcsRepositoryCreator repositoryCreator = getRepositoryCreator(vcs);
      if (repositoryCreator == null) continue;
      Repository repository = repositoryCreator.createRepositoryIfValid(rootPath);
      if (repository != null) {
        newRootsMap.put(rootPath, repository);
      }
    }
  }
  return newRootsMap;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@NotNull
public Collection<VcsRoot> detect(@Nullable VirtualFile startDir) {
  if (startDir == null || myCheckers.length == 0) {
    return Collections.emptyList();
  }

  final Set<VcsRoot> roots = scanForRootsInsideDir(startDir);
  roots.addAll(scanForRootsInContentRoots());
  for (VcsRoot root : roots) {
    if (startDir.equals(root.getPath())) {
      return roots;
    }
  }
  List<VcsRoot> rootsAbove = scanForSingleRootAboveDir(startDir);
  roots.addAll(rootsAbove);
  return roots;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@NotNull
private Set<VcsRoot> scanForRootsInContentRoots() {
  Set<VcsRoot> vcsRoots = new HashSet<VcsRoot>();
  if (myProject.isDisposed()) return vcsRoots;

  VirtualFile[] roots = myProjectManager.getContentRoots();
  for (VirtualFile contentRoot : roots) {

    Set<VcsRoot> rootsInsideRoot = scanForRootsInsideDir(contentRoot);
    boolean shouldScanAbove = true;
    for (VcsRoot root : rootsInsideRoot) {
      if (contentRoot.equals(root.getPath())) {
        shouldScanAbove = false;
      }
    }
    if (shouldScanAbove) {
      List<VcsRoot> rootsAbove = scanForSingleRootAboveDir(contentRoot);
      rootsInsideRoot.addAll(rootsAbove);
    }
    vcsRoots.addAll(rootsInsideRoot);
  }
  return vcsRoots;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@NotNull
private Set<VcsRoot> scanForRootsInsideDir(@NotNull final VirtualFile dir, final int depth) {
  final Set<VcsRoot> roots = new HashSet<VcsRoot>();
  if (depth > MAXIMUM_SCAN_DEPTH) {
    // performance optimization via limitation: don't scan deep though the whole VFS, 2 levels under a content root is enough
    return roots;
  }

  if (myProject.isDisposed() || !dir.isDirectory()) {
    return roots;
  }
  List<AbstractVcs> vcsList = getVcsListFor(dir);
  for (AbstractVcs vcs : vcsList) {
    roots.add(new VcsRoot(vcs, dir));
  }
  for (VirtualFile child : dir.getChildren()) {
    roots.addAll(scanForRootsInsideDir(child, depth + 1));
  }
  return roots;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@NotNull
private List<VcsRoot> scanForSingleRootAboveDir(@NotNull final VirtualFile dir) {
  List<VcsRoot> roots = new ArrayList<VcsRoot>();
  if (myProject.isDisposed()) {
    return roots;
  }

  VirtualFile par = dir.getParent();
  while (par != null) {
    List<AbstractVcs> vcsList = getVcsListFor(par);
    for (AbstractVcs vcs : vcsList) {
      roots.add(new VcsRoot(vcs, par));
    }
    if (!roots.isEmpty()) {
      return roots;
    }
    par = par.getParent();
  }
  return roots;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@Nullable
private VirtualFile getRootForPath(@NotNull FilePath file, @NotNull Collection<VirtualFile> rootsToSave) {
  final VirtualFile vf = ChangesUtil.findValidParentUnderReadAction(file);
  if (vf == null) {
    return null;
  }
  VirtualFile rootCandidate = null;
  for (VcsRoot root : myRoots) {
    if (VfsUtilCore.isAncestor(root.getPath(), vf, false)) {
      if (rootCandidate == null || VfsUtil.isAncestor(rootCandidate, root.getPath(), true)) { // in the case of nested roots choose the closest root
        rootCandidate = root.getPath();
      }
    }
  }
  if (! rootsToSave.contains(rootCandidate)) return null;
  return rootCandidate;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@NotNull
@Override
protected CheckinHandler createVcsHandler(final CheckinProjectPanel panel) {
  return new CheckinHandler() {
    @Nullable
    public RefreshableOnComponent getAfterCheckinConfigurationPanel(Disposable parentDisposable) {
      final Project project = panel.getProject();
      final CvsVcs2 cvs = CvsVcs2.getInstance(project);
      final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(project);
      final Collection<VirtualFile> roots = panel.getRoots();
      final Collection<FilePath> files = new HashSet<FilePath>();
      for (VirtualFile root : roots) {
        final VcsRoot vcsRoot = vcsManager.getVcsRootObjectFor(root);
        if (vcsRoot == null || vcsRoot.getVcs() != cvs) {
          continue;
        }
        files.add(VcsContextFactory.SERVICE.getInstance().createFilePathOn(root));
      }
      return new AdditionalOptionsPanel(CvsConfiguration.getInstance(project), files, project);
    }
  };
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@Nullable
public static VcsWatchRequest create(@NotNull VcsRoot root) {
    AbstractVcs vcs = root.getVcs();
    if (vcs == null || root.getPath() == null) {
        return null;
    }

    if (Utils.isPluginEnabled("Git4Idea") && vcs instanceof GitVcs) {
        return new GitWatchRequest(vcs, root.getPath());
    } else if (Utils.isPluginEnabled("hg4idea") && vcs instanceof HgVcs) {
        return new HgWatchRequest(vcs, root.getPath());
    } else if (Utils.isPluginEnabled("Subversion") && vcs instanceof SvnVcs) {
        return new SvnWatchRequest(vcs, root.getPath());
    }

    return null;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
public void fileDirty(@NotNull final VirtualFile file) {
  try {
    final AbstractVcs vcs = myGuess.getVcsForDirty(file);
    if (vcs == null) return;
    if (LOG.isDebugEnabled()) {
      LOG.debug("file dirty: " + file + "; " + ReflectionUtil.findCallerClass(2));
    }
    final VcsRoot root = new VcsRoot(vcs, file);
    takeDirt(new Consumer<DirtBuilder>() {
      public void consume(DirtBuilder dirtBuilder) {
        dirtBuilder.addDirtyFile(root);
      }
    });
  } catch (ProcessCanceledException ignore) {
  }
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
public void dirDirtyRecursively(final VirtualFile dir) {
  try {
    final AbstractVcs vcs = myGuess.getVcsForDirty(dir);
    if (vcs == null) return;
    if (LOG.isDebugEnabled()) {
      LOG.debug("dir dirty recursively: " + dir + "; " + ReflectionUtil.findCallerClass(2));
    }
    final VcsRoot root = new VcsRoot(vcs, dir);
    takeDirt(new Consumer<DirtBuilder>() {
      public void consume(DirtBuilder dirtBuilder) {
        dirtBuilder.addDirtyDirRecursively(root);
      }
    });
  } catch (ProcessCanceledException ignore) {
  }
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
/**
 * Builds recursively nested {@link FileTreeNode} nodes structure.
 *
 * @param file    current {@link VirtualFile} instance
 * @param vcsRoot {@link VcsRoot} of given file
 * @return leaf
 */
@NotNull
private FileTreeNode createDirectoryNodes(@NotNull VirtualFile file, @Nullable VcsRoot vcsRoot) {
    final FileTreeNode node = nodes.get(file);
    if (node != null) {
        return node;
    }

    final FileTreeNode newNode = new FileTreeNode(project, file, vcsRoot);
    nodes.put(file, newNode);

    if (nodes.size() != 1) {
        final VirtualFile parent = file.getParent();
        if (parent != null) {
            createDirectoryNodes(parent, null).add(newNode);
        }
    }

    return newNode;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
/**
 * Creates scroll panel with templates tree in it.
 *
 * @return scroll panel
 */
private JScrollPane createTreeScrollPanel() {
    for (Map.Entry<VirtualFile, VcsRoot> entry : files.entrySet()) {
        createDirectoryNodes(entry.getKey(), entry.getValue());
    }

    final FileTreeRenderer renderer = new FileTreeRenderer();

    tree = new CheckboxTree(renderer, root);
    tree.setCellRenderer(renderer);
    tree.setRootVisible(true);
    tree.setShowsRootHandles(false);
    UIUtil.setLineStyleAngled(tree);
    TreeUtil.installActions(tree);

    final JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(tree);
    scrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    TreeUtil.expandAll(tree);

    tree.getModel().addTreeModelListener(treeModelListener);
    treeExpander = new DefaultTreeExpander(tree);

    return scrollPane;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
/**
 * {@link IgnoreManager.TrackedIgnoredListener} method implementation to handle incoming files.
 *
 * @param files tracked and ignored files list
 */
@Override
public void handleFiles(@NotNull final ConcurrentMap<VirtualFile, VcsRoot> files) {
    if (!settings.isInformTrackedIgnored() || notificationShown || myProject.getBaseDir() == null) {
        return;
    }

    notificationShown = true;
    Notify.show(
            myProject,
            IgnoreBundle.message("notification.untrack.title", Utils.getVersion()),
            IgnoreBundle.message("notification.untrack.content"),
            NotificationType.INFORMATION,
            new NotificationListener() {
                @Override
                public void hyperlinkUpdate(@NotNull Notification notification, @NotNull HyperlinkEvent event) {
                    if (DISABLE_ACTION.equals(event.getDescription())) {
                        settings.setInformTrackedIgnored(false);
                    } else {
                        new UntrackFilesDialog(myProject, files).show();
                    }
                    notification.expire();
                }
            }
    );
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
private boolean showInVcsRoot(final Project project, final VcsRoot root, Entity changeset) throws VcsException {
    final AbstractVcs vcs = root.getVcs();
    if(vcs == null) {
        return false;
    }
    final VcsRevisionNumber revision = createRevision(vcs.getName(), changeset.getPropertyValue("rev"));
    if(revision == null) {
        return false;
    }
    CommittedChangesProvider committedChangesProvider = vcs.getCommittedChangesProvider();
    if(committedChangesProvider == null) {
        return false;
    }
    Pair oneList = committedChangesProvider.getOneList(root.getPath(), revision);
    if(oneList != null && oneList.getFirst() != null) {
        UIUtil.invokeAndWaitIfNeeded(new Runnable() {
            @Override
            public void run() {
                ShowAllAffectedGenericAction.showSubmittedFiles(project, revision, root.getPath(), vcs.getKeyInstanceMethod());
            }
        });
        return true;
    } else {
        return false;
    }
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
private VcsRoot findRepository(Project project, Entity repository) {
    String location = repository.getPropertyValue("location");
    String alias = repository.getPropertyValue("alias");

    VcsRoot[] vcsRoots = ProjectLevelVcsManager.getInstance(project).getAllVcsRoots();
    for(VcsRoot root: vcsRoots) {
        AbstractVcs vcs = root.getVcs();
        if(vcs == null) {
            continue;
        }
        RevisionFactory revisionFactory = findFactory(vcs.getName());
        if(revisionFactory != null && revisionFactory.matches(root, location, alias)) {
            return root;
        }
    }

    return null;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
public VcsLogManager(@Nonnull Project project,
                     @Nonnull VcsLogTabsProperties uiProperties,
                     @Nonnull Collection<VcsRoot> roots,
                     boolean scheduleRefreshImmediately,
                     @Nullable Runnable recreateHandler) {
  myProject = project;
  myUiProperties = uiProperties;
  myRecreateMainLogHandler = recreateHandler;

  Map<VirtualFile, VcsLogProvider> logProviders = findLogProviders(roots, myProject);
  myLogData = new VcsLogData(myProject, logProviders, new MyFatalErrorsHandler());
  myPostponableRefresher = new PostponableLogRefresher(myLogData);
  myTabsLogRefresher = new VcsLogTabsWatcher(myProject, myPostponableRefresher, myLogData);

  refreshLogOnVcsEvents(logProviders, myPostponableRefresher, myLogData);

  myColorManager = new VcsLogColorManagerImpl(logProviders.keySet());

  if (scheduleRefreshImmediately) {
    scheduleInitialization();
  }

  Disposer.register(project, this);
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@Nonnull
public static Map<VirtualFile, VcsLogProvider> findLogProviders(@Nonnull Collection<VcsRoot> roots, @Nonnull Project project) {
  Map<VirtualFile, VcsLogProvider> logProviders = ContainerUtil.newHashMap();
  VcsLogProvider[] allLogProviders = Extensions.getExtensions(LOG_PROVIDER_EP, project);
  for (VcsRoot root : roots) {
    AbstractVcs vcs = root.getVcs();
    VirtualFile path = root.getPath();
    if (vcs == null || path == null) {
      LOG.error("Skipping invalid VCS root: " + root);
      continue;
    }

    for (VcsLogProvider provider : allLogProviders) {
      if (provider.getSupportedVcs().equals(vcs.getKeyInstanceMethod())) {
        logProviders.put(path, provider);
        break;
      }
    }
  }
  return logProviders;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@Nonnull
private Map<VirtualFile, Repository> findNewRoots(@Nonnull Set<VirtualFile> knownRoots) {
  Map<VirtualFile, Repository> newRootsMap = ContainerUtil.newHashMap();
  for (VcsRoot root : myVcsManager.getAllVcsRoots()) {
    VirtualFile rootPath = root.getPath();
    if (rootPath != null && !knownRoots.contains(rootPath)) {
      AbstractVcs vcs = root.getVcs();
      VcsRepositoryCreator repositoryCreator = getRepositoryCreator(vcs);
      if (repositoryCreator == null) continue;
      Repository repository = repositoryCreator.createRepositoryIfValid(rootPath);
      if (repository != null) {
        newRootsMap.put(rootPath, repository);
      }
    }
  }
  return newRootsMap;
}
 

import com.intellij.openapi.vcs.VcsRoot; //导入依赖的package包/类
@Nonnull
public Collection<VcsRoot> detect(@Nullable VirtualFile startDir) {
  if (startDir == null || myCheckers.length == 0) {
    return Collections.emptyList();
  }

  final Set<VcsRoot> roots = scanForRootsInsideDir(startDir);
  roots.addAll(scanForRootsInContentRoots());
  for (VcsRoot root : roots) {
    if (startDir.equals(root.getPath())) {
      return roots;
    }
  }
  List<VcsRoot> rootsAbove = scanForSingleRootAboveDir(startDir);
  roots.addAll(rootsAbove);
  return roots;
}