com.intellij.openapi.vcs.history.VcsHistoryProvider Java Examples

protected boolean isEnabled(VcsContext context) {
  Project project = context.getProject();
  if (project == null) return false;

  VcsSelection selection = VcsSelectionUtil.getSelection(context);
  if (selection == null) return false;

  VirtualFile file = FileDocumentManager.getInstance().getFile(selection.getDocument());
  if (file == null) return false;

  final ProjectLevelVcsManagerImpl vcsManager = (ProjectLevelVcsManagerImpl)ProjectLevelVcsManager.getInstance(project);
  final BackgroundableActionEnabledHandler handler = vcsManager.getBackgroundableActionHandler(VcsBackgroundableActions.HISTORY_FOR_SELECTION);
  if (handler.isInProgress(VcsBackgroundableActions.keyFrom(file))) return false;

  AbstractVcs activeVcs = ProjectLevelVcsManager.getInstance(project).getVcsFor(file);
  if (activeVcs == null) return false;

  VcsHistoryProvider provider = activeVcs.getVcsBlockHistoryProvider();
  if (provider == null) return false;

  if (!AbstractVcs.fileInVcsByFileStatus(project, VcsUtil.getFilePath(file))) return false;
  return true;
}
 

@Override
public VcsHistoryProvider getVcsHistoryProvider() {
    if (myHistoryProvider == null) {
        myHistoryProvider = new TFSHistoryProvider(myProject);
    }
    return myHistoryProvider;
}
 

@Override
public void showFileHistory(VcsHistoryProvider vcsHistoryProvider,
                            AnnotationProvider annotationProvider,
                            FilePath path,
                            String repositoryPath,
                            AbstractVcs vcs) {
  throw new UnsupportedOperationException();
}
 

private static boolean isEnabled(@Nonnull Project project, @Nonnull FilePath path, @Nonnull VirtualFile fileOrParent) {
  boolean result = false;
  AbstractVcs vcs = ChangesUtil.getVcsForFile(fileOrParent, project);

  if (vcs != null) {
    VcsHistoryProvider provider = vcs.getVcsHistoryProvider();

    result = provider != null &&
             (provider.supportsHistoryForDirectories() || !path.isDirectory()) &&
             AbstractVcs.fileInVcsByFileStatus(project, fileOrParent) &&
             provider.canShowHistoryFor(fileOrParent);
  }

  return result;
}
 

@Override
protected void actionPerformed(@Nonnull VcsContext context) {
  Project project = context.getProject();
  Pair<FilePath, VirtualFile> pair = getPathAndParentFile(context);
  FilePath path = assertNotNull(pair.first);
  VirtualFile fileOrParent = assertNotNull(pair.second);
  AbstractVcs vcs = assertNotNull(ChangesUtil.getVcsForFile(fileOrParent, project));
  VcsHistoryProvider provider = assertNotNull(vcs.getVcsHistoryProvider());

  AbstractVcsHelper.getInstance(project).showFileHistory(provider, vcs.getAnnotationProvider(), path, null, vcs);
}
 

@Override
@Nullable
public VcsHistoryProvider getVcsHistoryProvider() {
    return historyProvider;
}
 

@Override
@Nullable
public VcsHistoryProvider getVcsBlockHistoryProvider() {
    return getVcsHistoryProvider();
}
 

@Override
public void showFileHistory(VcsHistoryProvider vcsHistoryProvider, FilePath path, AbstractVcs vcs, String repositoryPath) {
  throw new UnsupportedOperationException();
}
 

public abstract void showFileHistory(@Nonnull VcsHistoryProvider historyProvider,
@Nonnull FilePath path,
@Nonnull AbstractVcs vcs,
@javax.annotation.Nullable String repositoryPath);
 

public abstract void showFileHistory(@Nonnull VcsHistoryProvider historyProvider,
@Nullable AnnotationProvider annotationProvider,
@Nonnull FilePath path,
@Nullable String repositoryPath,
@Nonnull final AbstractVcs vcs);
 

@Nullable
public VcsHistoryProvider getVcsHistoryProvider() {
  return null;
}
 

@Nullable
public VcsHistoryProvider getVcsBlockHistoryProvider() {
  return null;
}