vcs-impl/src/com/intellij/openapi/vcs/changes/ChangeListManagerImpl.java

   1 package com.intellij.openapi.vcs.changes;
   2
   3 import com.intellij.ide.highlighter.WorkspaceFileType;
   4 import com.intellij.lifecycle.AtomicSectionsAware;
   5 import com.intellij.lifecycle.ControlledAlarmFactory;
   6 import com.intellij.lifecycle.SlowlyClosingAlarm;
   7 import com.intellij.openapi.application.ApplicationManager;
   8 import com.intellij.openapi.application.ModalityState;
   9 import com.intellij.openapi.components.ProjectComponent;
  10 import com.intellij.openapi.diagnostic.Logger;
  11 import com.intellij.openapi.progress.EmptyProgressIndicator;
  12 import com.intellij.openapi.progress.ProcessCanceledException;
  13 import com.intellij.openapi.progress.ProgressIndicator;
  14 import com.intellij.openapi.project.DumbAwareRunnable;
  15 import com.intellij.openapi.project.Project;
  16 import com.intellij.openapi.startup.StartupManager;
  17 import com.intellij.openapi.ui.Messages;
  18 import com.intellij.openapi.util.*;
  19 import com.intellij.openapi.util.io.FileUtil;
  20 import com.intellij.openapi.vcs.*;
  21 import com.intellij.openapi.vcs.changes.ui.CommitHelper;
  22 import com.intellij.openapi.vcs.checkin.CheckinEnvironment;
  23 import com.intellij.openapi.vcs.checkin.CheckinHandler;
  24 import com.intellij.openapi.vcs.readOnlyHandler.ReadonlyStatusHandlerImpl;
  25 import com.intellij.openapi.vfs.VirtualFile;
  26 import com.intellij.util.ConcurrencyUtil;
  27 import com.intellij.util.Consumer;
  28 import com.intellij.util.EventDispatcher;
  29 import com.intellij.util.containers.MultiMap;
  30 import com.intellij.util.messages.Topic;
  31 import org.jdom.Element;
  32 import org.jetbrains.annotations.NonNls;
  33 import org.jetbrains.annotations.NotNull;
  34 import org.jetbrains.annotations.Nullable;
  35
  36 import javax.swing.*;
  37 import java.io.File;
  38 import java.util.*;
  39 import java.util.concurrent.ExecutorService;
  40 import java.util.concurrent.ScheduledExecutorService;
  41
  42 /**
  43  * @author max
  44  */
  45 public class ChangeListManagerImpl extends ChangeListManagerEx implements ProjectComponent, ChangeListOwner, JDOMExternalizable {
  46   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.vcs.changes.ChangeListManagerImpl");
  47
  48   private final Project myProject;
  49   private final ChangesViewManager myChangesViewManager;
  50   private final FileStatusManager myFileStatusManager;
  51   private final UpdateRequestsQueue myUpdater;
  52
  53   @SuppressWarnings({"FieldAccessedSynchronizedAndUnsynchronized"})
  54   private static final ScheduledExecutorService ourUpdateAlarm = ConcurrencyUtil.newSingleScheduledThreadExecutor("Change List Updater");
  55
  56   private final Modifier myModifier;
  57
  58   private FileHolderComposite myComposite;
  59
  60   private final ChangeListWorker myWorker;
  61   private VcsException myUpdateException = null;
  62
  63   @SuppressWarnings({"FieldAccessedSynchronizedAndUnsynchronized"})
  64   private final EventDispatcher<ChangeListListener> myListeners = EventDispatcher.create(ChangeListListener.class);
  65
  66   private final Object myDataLock = new Object();
  67
  68   private final List<CommitExecutor> myExecutors = new ArrayList<CommitExecutor>();
  69
  70   private final IgnoredFilesComponent myIgnoredIdeaLevel;
  71   private ProgressIndicator myUpdateChangesProgressIndicator;
  72
  73   public static final Key<Object> DOCUMENT_BEING_COMMITTED_KEY = new Key<Object>("DOCUMENT_BEING_COMMITTED");
  74
  75   public static final Topic<LocalChangeListsLoadedListener> LISTS_LOADED = new Topic<LocalChangeListsLoadedListener>(
  76     "LOCAL_CHANGE_LISTS_LOADED", LocalChangeListsLoadedListener.class);
  77
  78   private boolean myShowLocalChangesInvalidated;
  79
  80   private final DelayedNotificator myDelayedNotificator;
  81
  82   private final VcsListener myVcsListener = new VcsListener() {
  83     public void directoryMappingChanged() {
  84       VcsDirtyScopeManager.getInstanceChecked(myProject).markEverythingDirty();
  85       scheduleUpdate();
  86     }
  87   };
  88
  89   public static ChangeListManagerImpl getInstanceImpl(final Project project) {
  90     return (ChangeListManagerImpl) project.getComponent(ChangeListManager.class);
  91   }
  92
  93   public ChangeListManagerImpl(final Project project) {
  94     myProject = project;
  95     myChangesViewManager = ChangesViewManager.getInstance(myProject);
  96     myFileStatusManager = FileStatusManager.getInstance(myProject);
  97     myComposite = new FileHolderComposite(project);
  98     myIgnoredIdeaLevel = new IgnoredFilesComponent(myProject);
  99     myUpdater = new UpdateRequestsQueue(myProject, ourUpdateAlarm, new ActualUpdater());
 100
 101     myWorker = new ChangeListWorker(myProject, new MyChangesDeltaForwarder(myProject, ourUpdateAlarm));
 102     myDelayedNotificator = new DelayedNotificator(myListeners, ourUpdateAlarm);
 103     myModifier = new Modifier(myWorker, myDelayedNotificator);
 104   }
 105
 106   public void projectOpened() {
 107     initializeForNewProject();
 108
 109     if (ApplicationManager.getApplication().isUnitTestMode()) {
 110       myWorker.initialized();
 111       myUpdater.initialized();
 112       ProjectLevelVcsManager.getInstance(myProject).addVcsListener(myVcsListener);
 113     }
 114     else {
 115       StartupManager.getInstance(myProject).registerPostStartupActivity(new DumbAwareRunnable() {
 116         public void run() {
 117           myWorker.initialized();
 118           myUpdater.initialized();
 119           broadcastStateAfterLoad();
 120           ProjectLevelVcsManager.getInstance(myProject).addVcsListener(myVcsListener);
 121         }
 122       });
 123     }
 124   }
 125
 126   private void broadcastStateAfterLoad() {
 127     final List<LocalChangeList> listCopy;
 128     synchronized (myDataLock) {
 129       listCopy = getChangeListsCopy();
 130     }
 131     if (! listCopy.isEmpty()) {
 132       myProject.getMessageBus().syncPublisher(LISTS_LOADED).processLoadedLists(listCopy);
 133     }
 134   }
 135
 136   private void initializeForNewProject() {
 137     synchronized (myDataLock) {
 138       if (myWorker.isEmpty()) {
 139         final LocalChangeList list = myWorker.addChangeList(VcsBundle.message("changes.default.changlist.name"), null);
 140         setDefaultChangeList(list);
 141
 142         if (myIgnoredIdeaLevel.isEmpty()) {
 143           final String name = myProject.getName();
 144           myIgnoredIdeaLevel.add(IgnoredBeanFactory.ignoreFile(name + WorkspaceFileType.DOT_DEFAULT_EXTENSION, myProject));
 145           myIgnoredIdeaLevel.add(IgnoredBeanFactory.ignoreFile(Project.DIRECTORY_STORE_FOLDER + "/workspace.xml", myProject));
 146         }
 147       }
 148     }
 149   }
 150
 151   public void projectClosed() {
 152     ProjectLevelVcsManager.getInstance(myProject).removeVcsListener(myVcsListener);
 153
 154     synchronized (myDataLock) {
 155       if (myUpdateChangesProgressIndicator != null) {
 156         myUpdateChangesProgressIndicator.cancel();
 157       }
 158     }
 159
 160     myUpdater.stop();
 161   }
 162
 163   @NotNull @NonNls
 164   public String getComponentName() {
 165     return "ChangeListManager";
 166   }
 167
 168   public void initComponent() {
 169   }
 170
 171   public void disposeComponent() {
 172   }
 173
 174   /**
 175    * update itself might produce actions done on AWT thread (invoked-after),
 176    * so waiting for its completion on AWT thread is not good
 177    *
 178    * runnable is invoked on AWT thread
 179    */
 180   public void invokeAfterUpdate(final Runnable afterUpdate, final InvokeAfterUpdateMode mode, final String title, final ModalityState state) {
 181     myUpdater.invokeAfterUpdate(afterUpdate, mode, title, null, state);
 182   }
 183
 184   public void invokeAfterUpdate(final Runnable afterUpdate, final InvokeAfterUpdateMode mode, final String title,
 185                                 final Consumer<VcsDirtyScopeManager> dirtyScopeManagerFiller, final ModalityState state) {
 186     myUpdater.invokeAfterUpdate(afterUpdate, mode, title, dirtyScopeManagerFiller, state);
 187   }
 188
 189   static class DisposedException extends RuntimeException {}
 190
 191   public void scheduleUpdate() {
 192     myUpdater.schedule(true);
 193   }
 194
 195   public void scheduleUpdate(boolean updateUnversionedFiles) {
 196     myUpdater.schedule(updateUnversionedFiles);
 197   }
 198
 199   private class ActualUpdater implements LocalChangesUpdater {
 200     public void execute(boolean updateUnversioned, AtomicSectionsAware atomicSectionsAware) {
 201       updateImmediately(updateUnversioned, atomicSectionsAware);
 202     }
 203   }
 204
 205   private void updateImmediately(final boolean updateUnversionedFiles, final AtomicSectionsAware atomicSectionsAware) {
 206     FileHolderComposite composite;
 207     ChangeListWorker changeListWorker;
 208
 209     final VcsDirtyScopeManagerImpl dirtyScopeManager;
 210     try {
 211       dirtyScopeManager = ((VcsDirtyScopeManagerImpl) VcsDirtyScopeManager.getInstanceChecked(myProject));
 212     }
 213     catch(ProcessCanceledException ex) {
 214       return;
 215     }
 216     catch(Exception ex) {
 217       LOG.error(ex);
 218       return;
 219     }
 220     final VcsInvalidated invalidated = dirtyScopeManager.retrieveScopes();
 221     if (invalidated == null || invalidated.isEmpty()) {
 222       return;
 223     }
 224     final boolean wasEverythingDirty = invalidated.isEverythingDirty();
 225     final List<VcsDirtyScope> scopes = invalidated.getScopes();
 226
 227     try {
 228       checkIfDisposed();
 229
 230       // copy existsing data to objects that would be updated.
 231       // mark for "modifier" that update started (it would create duplicates of modification commands done by user during update;
 232       // after update of copies of objects is complete, it would apply the same modifications to copies.)
 233       synchronized (myDataLock) {
 234         changeListWorker = myWorker.copy();
 235         composite = updateUnversionedFiles ? (FileHolderComposite) myComposite.copy() : myComposite;
 236         myModifier.enterUpdate();
 237         if (wasEverythingDirty) {
 238           myUpdateException = null;
 239         }
 240         if (updateUnversionedFiles && wasEverythingDirty) {
 241           composite.cleanAll();
 242         }
 243       }
 244       if (wasEverythingDirty) {
 245         changeListWorker.notifyStartProcessingChanges(null);
 246       }
 247       myChangesViewManager.scheduleRefresh();
 248
 249       final ChangeListManagerGate gate = changeListWorker.createSelfGate();
 250
 251       // do actual requests about file statuses
 252       final UpdatingChangeListBuilder builder = new UpdatingChangeListBuilder(changeListWorker, composite, new Getter<Boolean>() {
 253         public Boolean get() {
 254           return myUpdater.isStopped();
 255         }
 256       }, updateUnversionedFiles, myIgnoredIdeaLevel, gate);
 257
 258       myUpdateChangesProgressIndicator = new EmptyProgressIndicator() {
 259         @Override
 260         public boolean isCanceled() {
 261           return myUpdater.isStopped() || atomicSectionsAware.shouldExitAsap();
 262         }
 263         @Override
 264         public void checkCanceled() {
 265           checkIfDisposed();
 266           atomicSectionsAware.checkShouldExit();
 267         }
 268       };
 269       for (final VcsDirtyScope scope : scopes) {
 270         atomicSectionsAware.checkShouldExit();
 271
 272         final AbstractVcs vcs = scope.getVcs();
 273         if (vcs == null) continue;
 274
 275         myChangesViewManager.updateProgressText(VcsBundle.message("changes.update.progress.message", vcs.getDisplayName()), false);
 276         if (! wasEverythingDirty) {
 277           changeListWorker.notifyStartProcessingChanges(scope);
 278         }
 279         if (updateUnversionedFiles && !wasEverythingDirty) {
 280           composite.cleanScope(scope);
 281         }
 282         actualUpdate(wasEverythingDirty, composite, builder, scope, vcs, changeListWorker, gate);
 283         if (myUpdateException != null) break;
 284       }
 285
 286       final boolean takeChanges = (myUpdateException == null);
 287
 288       synchronized (myDataLock) {
 289         // do same modifications to change lists as was done during update + do delayed notifications
 290         if (wasEverythingDirty) {
 291           changeListWorker.notifyDoneProcessingChanges(myDelayedNotificator.getProxyDispatcher());
 292         }
 293         myModifier.exitUpdate();
 294         // should be applied for notifications to be delivered (they were delayed)
 295         myModifier.apply(changeListWorker);
 296         myModifier.clearQueue();
 297         // update member from copy
 298         if (takeChanges) {
 299           myWorker.takeData(changeListWorker);
 300         }
 301
 302         if (takeChanges && updateUnversionedFiles) {
 303           boolean statusChanged = !myComposite.equals(composite);
 304           myComposite = composite;
 305           if (statusChanged) {
 306             myDelayedNotificator.getProxyDispatcher().unchangedFileStatusChanged();
 307           }
 308         }
 309
 310         if (takeChanges) {
 311           updateIgnoredFiles(false);
 312         }
 313         myShowLocalChangesInvalidated = false;
 314       }
 315       myChangesViewManager.scheduleRefresh();
 316     }
 317     catch (DisposedException e) {
 318       // OK, we're finishing all the stuff now.
 319     }
 320     catch(ProcessCanceledException e) {
 321       // OK, we're finishing all the stuff now.
 322     }
 323     catch(Exception ex) {
 324       LOG.error(ex);
 325     }
 326     catch(AssertionError ex) {
 327       LOG.error(ex);
 328     }
 329     finally {
 330       synchronized (myDataLock) {
 331         myDelayedNotificator.getProxyDispatcher().changeListUpdateDone();
 332         myChangesViewManager.scheduleRefresh();
 333       }
 334     }
 335   }
 336
 337   private void actualUpdate(final boolean wasEverythingDirty, final FileHolderComposite composite, final UpdatingChangeListBuilder builder,
 338                             final VcsDirtyScope scope, final AbstractVcs vcs, final ChangeListWorker changeListWorker,
 339                             final ChangeListManagerGate gate) {
 340     try {
 341       final ChangeProvider changeProvider = vcs.getChangeProvider();
 342       if (changeProvider != null) {
 343         final FoldersCutDownWorker foldersCutDownWorker = new FoldersCutDownWorker();
 344         try {
 345           builder.setCurrent(scope, foldersCutDownWorker);
 346           changeProvider.getChanges(scope, builder, myUpdateChangesProgressIndicator, gate);
 347         }
 348         catch (VcsException e) {
 349           LOG.info(e);
 350           if (myUpdateException == null) {
 351             myUpdateException = e;
 352           }
 353         }
 354         composite.getIgnoredFileHolder().calculateChildren();
 355       }
 356     }
 357     finally {
 358       if ((! myUpdater.isStopped()) && !wasEverythingDirty) {
 359         changeListWorker.notifyDoneProcessingChanges(myDelayedNotificator.getProxyDispatcher());
 360       }
 361     }
 362   }
 363
 364   private void checkIfDisposed() {
 365     if (myUpdater.isStopped()) throw new DisposedException();
 366   }
 367
 368   static boolean isUnder(final Change change, final VcsDirtyScope scope) {
 369     final ContentRevision before = change.getBeforeRevision();
 370     final ContentRevision after = change.getAfterRevision();
 371     return before != null && scope.belongsTo(before.getFile()) || after != null && scope.belongsTo(after.getFile());
 372   }
 373
 374   public List<LocalChangeList> getChangeListsCopy() {
 375     synchronized (myDataLock) {
 376       return myWorker.getListsCopy();
 377     }
 378   }
 379
 380   /**
 381    * @deprecated
 382    * this method made equivalent to {@link #getChangeListsCopy()} so to don't be confused by method name,
 383    * better use {@link #getChangeListsCopy()}
 384    */
 385   @NotNull
 386   public List<LocalChangeList> getChangeLists() {
 387     synchronized (myDataLock) {
 388       return getChangeListsCopy();
 389     }
 390   }
 391
 392   public List<File> getAffectedPaths() {
 393     synchronized (myDataLock) {
 394       return myWorker.getAffectedPaths();
 395     }
 396   }
 397
 398   @NotNull
 399   public List<VirtualFile> getAffectedFiles() {
 400     synchronized (myDataLock) {
 401       return myWorker.getAffectedFiles();
 402     }
 403   }
 404
 405   List<VirtualFile> getUnversionedFiles() {
 406     return new ArrayList<VirtualFile>(myComposite.getVFHolder(FileHolder.HolderType.UNVERSIONED).getFiles());
 407   }
 408
 409   List<VirtualFile> getModifiedWithoutEditing() {
 410     return new ArrayList<VirtualFile>(myComposite.getVFHolder(FileHolder.HolderType.MODIFIED_WITHOUT_EDITING).getFiles());
 411   }
 412
 413   /**
 414    * @return only roots for ignored folders, and ignored files
 415    */
 416   List<VirtualFile> getIgnoredFiles() {
 417     return new ArrayList<VirtualFile>(myComposite.getIgnoredFileHolder().getBranchToFileMap().values());
 418   }
 419
 420   public List<VirtualFile> getLockedFolders() {
 421     return new ArrayList<VirtualFile>(myComposite.getVFHolder(FileHolder.HolderType.LOCKED).getFiles());
 422   }
 423
 424   Map<VirtualFile, LogicalLock> getLogicallyLockedFolders() {
 425     return new HashMap<VirtualFile, LogicalLock>(((LogicallyLockedHolder) myComposite.get(FileHolder.HolderType.LOGICALLY_LOCKED)).getMap());
 426   }
 427
 428   public boolean isLogicallyLocked(final VirtualFile file) {
 429     return ((LogicallyLockedHolder) myComposite.get(FileHolder.HolderType.LOGICALLY_LOCKED)).getMap().containsKey(file);
 430   }
 431
 432   public boolean isContainedInLocallyDeleted(final FilePath filePath) {
 433     synchronized (myDataLock) {
 434       return myWorker.isContainedInLocallyDeleted(filePath);
 435     }
 436   }
 437
 438   public List<LocallyDeletedChange> getDeletedFiles() {
 439     synchronized (myDataLock) {
 440       return myWorker.getLocallyDeleted().getFiles();
 441     }
 442   }
 443
 444   MultiMap<String, VirtualFile> getSwitchedFilesMap() {
 445     synchronized (myDataLock) {
 446       return myWorker.getSwitchedHolder().getBranchToFileMap();
 447     }
 448   }
 449
 450   public VcsException getUpdateException() {
 451     return myUpdateException;
 452   }
 453
 454   public boolean isFileAffected(final VirtualFile file) {
 455     synchronized (myDataLock) {
 456       return myWorker.getStatus(file) != null;
 457     }
 458   }
 459
 460   @Nullable
 461   public LocalChangeList findChangeList(final String name) {
 462     synchronized (myDataLock) {
 463       return myWorker.getCopyByName(name);
 464     }
 465   }
 466
 467   @Override
 468   public LocalChangeList getChangeList(String id) {
 469     synchronized (myDataLock) {
 470       return myWorker.getChangeList(id);
 471     }
 472   }
 473
 474   public LocalChangeList addChangeList(@NotNull String name, final String comment) {
 475     synchronized (myDataLock) {
 476       final LocalChangeList changeList = myModifier.addChangeList(name, comment);
 477       myChangesViewManager.scheduleRefresh();
 478       return changeList;
 479     }
 480   }
 481
 482   public void removeChangeList(final String name) {
 483     synchronized (myDataLock) {
 484       myModifier.removeChangeList(name);
 485       myChangesViewManager.scheduleRefresh();
 486     }
 487   }
 488
 489   public void removeChangeList(LocalChangeList list) {
 490     removeChangeList(list.getName());
 491   }
 492
 493   /**
 494    * does no modification to change lists, only notification is sent
 495    */
 496   @NotNull
 497   public Runnable prepareForChangeDeletion(final Collection<Change> changes) {
 498     final Map<String, LocalChangeList> lists = new HashMap<String, LocalChangeList>();
 499     final Map<String, List<Change>> map;
 500     synchronized (myDataLock) {
 501       map = myWorker.listsForChanges(changes, lists);
 502     }
 503     return new Runnable() {
 504       public void run() {
 505         final ChangeListListener multicaster = myDelayedNotificator.getProxyDispatcher();
 506         synchronized (myDataLock) {
 507           for (Map.Entry<String, List<Change>> entry : map.entrySet()) {
 508             final List<Change> changes = entry.getValue();
 509             for (Iterator<Change> iterator = changes.iterator(); iterator.hasNext();) {
 510               final Change change = iterator.next();
 511               if (getChangeList(change) != null) {
 512                 // was not actually rolled back
 513                 iterator.remove();
 514               }
 515             }
 516             multicaster.changesRemoved(changes, lists.get(entry.getKey()));
 517           }
 518         }
 519       }
 520     };
 521   }
 522
 523   public void setDefaultChangeList(@NotNull LocalChangeList list) {
 524     synchronized (myDataLock) {
 525       myModifier.setDefault(list.getName());
 526       myChangesViewManager.scheduleRefresh();
 527     }
 528   }
 529
 530   @Nullable
 531   public LocalChangeList getDefaultChangeList() {
 532     synchronized (myDataLock) {
 533       return myWorker.getDefaultListCopy();
 534     }
 535   }
 536
 537   @NotNull
 538   public Collection<LocalChangeList> getInvolvedListsFilterChanges(final Collection<Change> changes, final List<Change> validChanges) {
 539     synchronized (myDataLock) {
 540       return myWorker.getInvolvedListsFilterChanges(changes, validChanges);
 541     }
 542   }
 543
 544   @Nullable
 545   public LocalChangeList getChangeList(Change change) {
 546     synchronized (myDataLock) {
 547       return myWorker.listForChange(change);
 548     }
 549   }
 550
 551   @Override
 552   public String getChangeListNameIfOnlyOne(final Change[] changes) {
 553     synchronized (myDataLock) {
 554       return myWorker.listNameIfOnlyOne(changes);
 555     }
 556   }
 557
 558   /**
 559    * @deprecated
 560    * better use normal comparison, with equals
 561    */
 562   @Nullable
 563   public LocalChangeList getIdentityChangeList(Change change) {
 564     synchronized (myDataLock) {
 565       final List<LocalChangeList> lists = myWorker.getListsCopy();
 566       for (LocalChangeList list : lists) {
 567         for(Change oldChange: list.getChanges()) {
 568           if (oldChange == change) {
 569             return list;
 570           }
 571         }
 572       }
 573       return null;
 574     }
 575   }
 576
 577   @Override
 578   public boolean isInUpdate() {
 579     synchronized (myDataLock) {
 580       return myModifier.isInsideUpdate() || myShowLocalChangesInvalidated;
 581     }
 582   }
 583
 584   @Nullable
 585   public Change getChange(VirtualFile file) {
 586     synchronized (myDataLock) {
 587       final LocalChangeList list = myWorker.getListCopy(file);
 588       if (list != null) {
 589         for (Change change : list.getChanges()) {
 590           final ContentRevision afterRevision = change.getAfterRevision();
 591           if (afterRevision != null) {
 592             String revisionPath = FileUtil.toSystemIndependentName(afterRevision.getFile().getIOFile().getPath());
 593             if (FileUtil.pathsEqual(revisionPath, file.getPath())) return change;
 594           }
 595           final ContentRevision beforeRevision = change.getBeforeRevision();
 596           if (beforeRevision != null) {
 597             String revisionPath = FileUtil.toSystemIndependentName(beforeRevision.getFile().getIOFile().getPath());
 598             if (FileUtil.pathsEqual(revisionPath, file.getPath())) return change;
 599           }
 600         }
 601       }
 602
 603       return null;
 604     }
 605   }
 606
 607   @Nullable
 608   public Change getChange(final FilePath file) {
 609     synchronized (myDataLock) {
 610       return myWorker.getChangeForPath(file);
 611     }
 612   }
 613
 614   public boolean isUnversioned(VirtualFile file) {
 615     return myComposite.getVFHolder(FileHolder.HolderType.UNVERSIONED).containsFile(file);
 616   }
 617
 618   @NotNull
 619   public FileStatus getStatus(VirtualFile file) {
 620     synchronized (myDataLock) {
 621       if (myComposite.getVFHolder(FileHolder.HolderType.UNVERSIONED).containsFile(file)) return FileStatus.UNKNOWN;
 622       if (myComposite.getVFHolder(FileHolder.HolderType.MODIFIED_WITHOUT_EDITING).containsFile(file)) return FileStatus.HIJACKED;
 623       if (myComposite.getIgnoredFileHolder().containsFile(file)) return FileStatus.IGNORED;
 624
 625       final FileStatus status = myWorker.getStatus(file);
 626       if (status != null) {
 627         return status;
 628       }
 629       if (myWorker.isSwitched(file)) return FileStatus.SWITCHED;
 630       return FileStatus.NOT_CHANGED;
 631     }
 632   }
 633
 634   @NotNull
 635   public Collection<Change> getChangesIn(VirtualFile dir) {
 636     return getChangesIn(new FilePathImpl(dir));
 637   }
 638
 639   @NotNull
 640   public Collection<Change> getChangesIn(final FilePath dirPath) {
 641     synchronized (myDataLock) {
 642       return myWorker.getChangesIn(dirPath);
 643     }
 644   }
 645
 646   public void moveChangesTo(LocalChangeList list, final Change[] changes) {
 647     synchronized (myDataLock) {
 648       myModifier.moveChangesTo(list.getName(), changes);
 649     }
 650     SwingUtilities.invokeLater(new Runnable() {
 651       public void run() {
 652         myChangesViewManager.refreshView();
 653       }
 654     });
 655   }
 656
 657   public void addUnversionedFiles(final LocalChangeList list, @NotNull final List<VirtualFile> files) {
 658     final List<VcsException> exceptions = new ArrayList<VcsException>();
 659     ChangesUtil.processVirtualFilesByVcs(myProject, files, new ChangesUtil.PerVcsProcessor<VirtualFile>() {
 660       public void process(final AbstractVcs vcs, final List<VirtualFile> items) {
 661         final CheckinEnvironment environment = vcs.getCheckinEnvironment();
 662         if (environment != null) {
 663           final List<VcsException> result = environment.scheduleUnversionedFilesForAddition(items);
 664           if (result != null) {
 665             exceptions.addAll(result);
 666           }
 667         }
 668       }
 669     });
 670
 671     if (exceptions.size() > 0) {
 672       StringBuilder message = new StringBuilder(VcsBundle.message("error.adding.files.prompt"));
 673       for(VcsException ex: exceptions) {
 674         message.append("\n").append(ex.getMessage());
 675       }
 676       Messages.showErrorDialog(myProject, message.toString(), VcsBundle.message("error.adding.files.title"));
 677     }
 678
 679     for (VirtualFile file : files) {
 680       myFileStatusManager.fileStatusChanged(file);
 681     }
 682     VcsDirtyScopeManager.getInstance(myProject).filesDirty(files, null);
 683
 684     if (!list.isDefault()) {
 685       // find the changes for the added files and move them to the necessary changelist
 686       invokeAfterUpdate(new Runnable() {
 687         public void run() {
 688           synchronized (myDataLock) {
 689             List<Change> changesToMove = new ArrayList<Change>();
 690             final LocalChangeList defaultList = getDefaultChangeList();
 691             for(Change change: defaultList.getChanges()) {
 692               final ContentRevision afterRevision = change.getAfterRevision();
 693               if (afterRevision != null) {
 694                 VirtualFile vFile = afterRevision.getFile().getVirtualFile();
 695                 if (files.contains(vFile)) {
 696                   changesToMove.add(change);
 697                 }
 698               }
 699             }
 700
 701             if (changesToMove.size() > 0) {
 702               moveChangesTo(list, changesToMove.toArray(new Change[changesToMove.size()]));
 703             }
 704           }
 705
 706           myChangesViewManager.scheduleRefresh();
 707         }
 708       },  InvokeAfterUpdateMode.BACKGROUND_NOT_CANCELLABLE, VcsBundle.message("change.lists.manager.add.unversioned"), null);
 709     } else {
 710       myChangesViewManager.scheduleRefresh();
 711     }
 712   }
 713
 714   public Project getProject() {
 715     return myProject;
 716   }
 717
 718   public void addChangeListListener(ChangeListListener listener) {
 719     myListeners.addListener(listener);
 720   }
 721
 722
 723   public void removeChangeListListener(ChangeListListener listener) {
 724     myListeners.removeListener(listener);
 725   }
 726
 727   public void registerCommitExecutor(CommitExecutor executor) {
 728     myExecutors.add(executor);
 729   }
 730
 731   public void commitChanges(LocalChangeList changeList, List<Change> changes) {
 732     doCommit(changeList, changes, false);
 733   }
 734
 735   private boolean doCommit(final LocalChangeList changeList, final List<Change> changes, final boolean synchronously) {
 736     return new CommitHelper(myProject, changeList, changes, changeList.getName(),
 737                      changeList.getComment(), new ArrayList<CheckinHandler>(), false, synchronously, null).doCommit();
 738   }
 739
 740   public void commitChangesSynchronously(LocalChangeList changeList, List<Change> changes) {
 741     doCommit(changeList, changes, true);
 742   }
 743
 744   public boolean commitChangesSynchronouslyWithResult(final LocalChangeList changeList, final List<Change> changes) {
 745     return doCommit(changeList, changes, true);
 746   }
 747
 748   @SuppressWarnings({"unchecked"})
 749   public void readExternal(Element element) throws InvalidDataException {
 750     if (! myProject.isDefault()) {
 751       synchronized (myDataLock) {
 752         myIgnoredIdeaLevel.clear();
 753         new ChangeListManagerSerialization(myIgnoredIdeaLevel, myWorker).readExternal(element);
 754         if ((! myWorker.isEmpty()) && getDefaultChangeList() == null) {
 755           setDefaultChangeList(myWorker.getListsCopy().get(0));
 756         }
 757       }
 758     }
 759   }
 760
 761   public void writeExternal(Element element) throws WriteExternalException {
 762     if (! myProject.isDefault()) {
 763       final IgnoredFilesComponent ignoredFilesComponent;
 764       final ChangeListWorker worker;
 765       synchronized (myDataLock) {
 766         ignoredFilesComponent = new IgnoredFilesComponent(myProject);
 767         ignoredFilesComponent.add(myIgnoredIdeaLevel.getFilesToIgnore());
 768         worker = myWorker.copy();
 769       }
 770       new ChangeListManagerSerialization(ignoredFilesComponent, worker).writeExternal(element);
 771     }
 772   }
 773
 774   // used in TeamCity
 775   public void reopenFiles(List<FilePath> paths) {
 776     final ReadonlyStatusHandlerImpl readonlyStatusHandler = (ReadonlyStatusHandlerImpl)ReadonlyStatusHandlerImpl.getInstance(myProject);
 777     final boolean savedOption = readonlyStatusHandler.getState().SHOW_DIALOG;
 778     readonlyStatusHandler.getState().SHOW_DIALOG = false;
 779     try {
 780       readonlyStatusHandler.ensureFilesWritable(collectFiles(paths));
 781     }
 782     finally {
 783       readonlyStatusHandler.getState().SHOW_DIALOG = savedOption;
 784     }
 785   }
 786
 787   public List<CommitExecutor> getRegisteredExecutors() {
 788     return Collections.unmodifiableList(myExecutors);
 789   }
 790
 791   public void addFilesToIgnore(final IgnoredFileBean... filesToIgnore) {
 792     myIgnoredIdeaLevel.add(filesToIgnore);
 793     updateIgnoredFiles(true);
 794   }
 795
 796   public void setFilesToIgnore(final IgnoredFileBean... filesToIgnore) {
 797     myIgnoredIdeaLevel.set(filesToIgnore);
 798     updateIgnoredFiles(true);
 799   }
 800
 801   private void updateIgnoredFiles(final boolean checkIgnored) {
 802     synchronized (myDataLock) {
 803       List<VirtualFile> unversionedFiles = myComposite.getVFHolder(FileHolder.HolderType.UNVERSIONED).getFiles();
 804       //List<VirtualFile> ignoredFiles = myComposite.getVFHolder(FileHolder.HolderType.IGNORED).getFiles();
 805       boolean somethingChanged = false;
 806       for(VirtualFile file: unversionedFiles) {
 807         if (isIgnoredFile(file)) {
 808           somethingChanged = true;
 809           myComposite.getVFHolder(FileHolder.HolderType.UNVERSIONED).removeFile(file);
 810           myComposite.getIgnoredFileHolder().addFile(file, "", false);
 811         }
 812       }
 813       /*if (checkIgnored) {
 814         for(VirtualFile file: ignoredFiles) {
 815           if (!isIgnoredFile(file)) {
 816             somethingChanged = true;
 817             // the file may have been reported as ignored by the VCS, so we can't directly move it to unversioned files
 818             VcsDirtyScopeManager.getInstance(myProject).fileDirty(file);
 819           }
 820         }
 821       }*/
 822       if (somethingChanged) {
 823         myFileStatusManager.fileStatusesChanged();
 824         myChangesViewManager.scheduleRefresh();
 825       }
 826     }
 827   }
 828
 829   public IgnoredFileBean[] getFilesToIgnore() {
 830     return myIgnoredIdeaLevel.getFilesToIgnore();
 831   }
 832
 833   public boolean isIgnoredFile(@NotNull VirtualFile file) {
 834     return myIgnoredIdeaLevel.isIgnoredFile(file);
 835   }
 836
 837   @Nullable
 838   public String getSwitchedBranch(final VirtualFile file) {
 839     synchronized (myDataLock) {
 840       return myWorker.getBranchForFile(file);
 841     }
 842   }
 843
 844   @Override
 845   public String getDefaultListName() {
 846     synchronized (myDataLock) {
 847       return myWorker.getDefaultListName();
 848     }
 849   }
 850
 851   private static VirtualFile[] collectFiles(final List<FilePath> paths) {
 852     final ArrayList<VirtualFile> result = new ArrayList<VirtualFile>();
 853     for (FilePath path : paths) {
 854       if (path.getVirtualFile() != null) {
 855         result.add(path.getVirtualFile());
 856       }
 857     }
 858
 859     return result.toArray(new VirtualFile[result.size()]);
 860   }
 861
 862   public boolean setReadOnly(final String name, final boolean value) {
 863     synchronized (myDataLock) {
 864       final boolean result = myModifier.setReadOnly(name, value);
 865       myChangesViewManager.scheduleRefresh();
 866       return result;
 867     }
 868   }
 869
 870   public boolean editName(@NotNull final String fromName, @NotNull final String toName) {
 871     synchronized (myDataLock) {
 872       final boolean result = myModifier.editName(fromName, toName);
 873       myChangesViewManager.scheduleRefresh();
 874       return result;
 875     }
 876   }
 877
 878   public String editComment(@NotNull final String fromName, final String newComment) {
 879     synchronized (myDataLock) {
 880       final String oldComment = myModifier.editComment(fromName, newComment);
 881       myChangesViewManager.scheduleRefresh();
 882       return oldComment;
 883     }
 884   }
 885
 886   /**
 887    * Can be called only from not AWT thread; to do smthg after ChangeListManager refresh, call invokeAfterUpdate
 888    */
 889   public boolean ensureUpToDate(final boolean canBeCanceled) {
 890     final EnsureUpToDateFromNonAWTThread worker = new EnsureUpToDateFromNonAWTThread(myProject);
 891     worker.execute();
 892     return worker.isDone();
 893   }
 894
 895   // only a light attempt to show that some dirty scope request is asynchronously coming
 896   // for users to see changes are not valid
 897   // (commit -> asynch synch VFS -> asynch vcs dirty scope)
 898   public void showLocalChangesInvalidated() {
 899     synchronized (myDataLock) {
 900       myShowLocalChangesInvalidated = true;
 901     }
 902   }
 903
 904   private static class MyChangesDeltaForwarder implements PlusMinus<Pair<String, AbstractVcs>> {
 905     private SlowlyClosingAlarm myAlarm;
 906     private RemoteRevisionsCache myRevisionsCache;
 907     private final ProjectLevelVcsManager myVcsManager;
 908
 909     public MyChangesDeltaForwarder(final Project project, final ExecutorService service) {
 910       myAlarm = ControlledAlarmFactory.createOnSharedThread(project, "changes delta consumer forwarder", service);
 911       myRevisionsCache = RemoteRevisionsCache.getInstance(project);
 912       myVcsManager = ProjectLevelVcsManager.getInstance(project);
 913     }
 914
 915     public void plus(final Pair<String, AbstractVcs> stringAbstractVcsPair) {
 916       myAlarm.addRequest(new Runnable() {
 917         public void run() {
 918           myRevisionsCache.plus(getCorrectedPair(stringAbstractVcsPair));
 919         }
 920       });
 921     }
 922
 923     public void minus(final Pair<String, AbstractVcs> stringAbstractVcsPair) {
 924       myAlarm.addRequest(new Runnable() {
 925         public void run() {
 926           myRevisionsCache.minus(getCorrectedPair(stringAbstractVcsPair));
 927         }
 928       });
 929     }
 930
 931     private Pair<String, AbstractVcs> getCorrectedPair(final Pair<String, AbstractVcs> stringAbstractVcsPair) {
 932       Pair<String, AbstractVcs> correctedPair = stringAbstractVcsPair;
 933       if (stringAbstractVcsPair.getSecond() == null) {
 934         final String path = stringAbstractVcsPair.getFirst();
 935         correctedPair = new Pair<String, AbstractVcs>(path, myVcsManager.findVcsByName(findVcs(path).getName()));
 936       }
 937       return correctedPair;
 938     }
 939
 940     @Nullable
 941     private VcsKey findVcs(final String path) {
 942       // does not matter directory or not
 943       final AbstractVcs vcs = myVcsManager.getVcsFor(FilePathImpl.create(new File(path), false));
 944       return vcs == null ? null : vcs.getKeyInstanceMethod();
 945     }
 946   }
 947 }