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

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