platform/vcs-impl/src/com/intellij/openapi/vcs/changes/committed/OutdatedVersionNotifier.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.committed;
  17
  18 import com.intellij.openapi.application.ApplicationManager;
  19 import com.intellij.openapi.components.ProjectComponent;
  20 import com.intellij.openapi.diagnostic.Logger;
  21 import com.intellij.openapi.fileEditor.FileEditor;
  22 import com.intellij.openapi.fileEditor.FileEditorManager;
  23 import com.intellij.openapi.fileEditor.FileEditorManagerEvent;
  24 import com.intellij.openapi.fileEditor.FileEditorManagerListener;
  25 import com.intellij.openapi.project.Project;
  26 import com.intellij.openapi.util.Key;
  27 import com.intellij.openapi.util.Pair;
  28 import com.intellij.openapi.vcs.VcsBundle;
  29 import com.intellij.openapi.vcs.changes.Change;
  30 import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList;
  31 import com.intellij.openapi.vfs.VirtualFile;
  32 import com.intellij.ui.EditorNotificationPanel;
  33 import com.intellij.util.Consumer;
  34 import com.intellij.util.messages.MessageBus;
  35 import org.jetbrains.annotations.NonNls;
  36 import org.jetbrains.annotations.NotNull;
  37 import org.jetbrains.annotations.Nullable;
  38
  39 import java.text.DateFormat;
  40 import java.util.List;
  41
  42 /**
  43  * @author yole
  44  */
  45 public class OutdatedVersionNotifier implements ProjectComponent {
  46   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.vcs.changes.committed.OutdatedVersionNotifier");
  47
  48   private final FileEditorManager myFileEditorManager;
  49   private final CommittedChangesCache myCache;
  50   private final Project myProject;
  51   private static final Key<OutdatedRevisionPanel> PANEL_KEY = new Key<OutdatedRevisionPanel>("OutdatedRevisionPanel");
  52   private volatile boolean myIncomingChangesRequested;
  53
  54   public OutdatedVersionNotifier(FileEditorManager fileEditorManager,
  55                                  CommittedChangesCache cache,
  56                                  MessageBus messageBus, Project project) {
  57     myFileEditorManager = fileEditorManager;
  58     myCache = cache;
  59     myProject = project;
  60     messageBus.connect().subscribe(CommittedChangesCache.COMMITTED_TOPIC, new CommittedChangesAdapter() {
  61       public void incomingChangesUpdated(@Nullable final List<CommittedChangeList> receivedChanges) {
  62         if (myCache.getCachedIncomingChanges() == null) {
  63           requestLoadIncomingChanges();
  64         }
  65         else {
  66           updateAllEditorsLater();
  67         }
  68       }
  69     });
  70   }
  71
  72   private void requestLoadIncomingChanges() {
  73     debug("Requesting load of incoming changes");
  74     if (!myIncomingChangesRequested) {
  75       myIncomingChangesRequested = true;
  76       myCache.loadIncomingChangesAsync(new Consumer<List<CommittedChangeList>>() {
  77         public void consume(final List<CommittedChangeList> committedChangeLists) {
  78           myIncomingChangesRequested = false;
  79           updateAllEditorsLater();
  80         }
  81       });
  82     }
  83   }
  84
  85   private static void debug(@NonNls String message) {
  86     LOG.debug(message);
  87   }
  88
  89   public void projectOpened() {
  90     final FileEditorManagerListener myFileEditorManagerListener = new MyFileEditorManagerListener();
  91     myFileEditorManager.addFileEditorManagerListener(myFileEditorManagerListener, myProject);
  92   }
  93
  94   public void projectClosed() {
  95   }
  96
  97   @NonNls
  98   @NotNull
  99   public String getComponentName() {
 100     return "OutdatedVersionNotifier";
 101   }
 102
 103   public void initComponent() {
 104   }
 105
 106   public void disposeComponent() {
 107   }
 108
 109   private void updateAllEditorsLater() {
 110     debug("Queueing update of editors");
 111     ApplicationManager.getApplication().invokeLater(new Runnable() {
 112       public void run() {
 113         updateAllEditors();
 114       }
 115     });
 116   }
 117
 118   private void updateAllEditors() {
 119     if (myCache.getCachedIncomingChanges() == null) {
 120       requestLoadIncomingChanges();
 121       return;
 122     }
 123     debug("Updating editors");
 124     final VirtualFile[] files = myFileEditorManager.getOpenFiles();
 125     for(VirtualFile file: files) {
 126       final Pair<CommittedChangeList,Change> pair = myCache.getIncomingChangeList(file);
 127       final FileEditor[] fileEditors = myFileEditorManager.getEditors(file);
 128       for(FileEditor editor: fileEditors) {
 129         final OutdatedRevisionPanel oldPanel = editor.getUserData(PANEL_KEY);
 130         if (pair != null) {
 131           if (oldPanel != null) {
 132             oldPanel.setChangeList(pair.first, pair.second);
 133           }
 134           else {
 135             initPanel(pair.first, pair.second, editor);
 136           }
 137         }
 138         else if (oldPanel != null) {
 139           myFileEditorManager.removeTopComponent(editor, oldPanel);
 140           editor.putUserData(PANEL_KEY, null);
 141         }
 142       }
 143     }
 144   }
 145
 146   private void initPanel(final CommittedChangeList list, final Change c, final FileEditor editor) {
 147     final OutdatedRevisionPanel component = new OutdatedRevisionPanel(list, c);
 148     editor.putUserData(PANEL_KEY, component);
 149     myFileEditorManager.addTopComponent(editor, component);
 150   }
 151
 152   private class MyFileEditorManagerListener implements FileEditorManagerListener {
 153     public void fileOpened(FileEditorManager source, VirtualFile file) {
 154       if (myCache.getCachedIncomingChanges() == null) {
 155         requestLoadIncomingChanges();
 156       }
 157       else {
 158         final Pair<CommittedChangeList, Change> pair = myCache.getIncomingChangeList(file);
 159         if (pair != null) {
 160           final FileEditor[] fileEditors = source.getEditors(file);
 161           for(FileEditor editor: fileEditors) {
 162             initPanel(pair.first, pair.second, editor);
 163           }
 164         }
 165       }
 166     }
 167
 168     public void fileClosed(FileEditorManager source, VirtualFile file) {
 169     }
 170
 171     public void selectionChanged(FileEditorManagerEvent event) {
 172     }
 173   }
 174
 175   private static class OutdatedRevisionPanel extends EditorNotificationPanel {
 176     private CommittedChangeList myChangeList;
 177
 178     public OutdatedRevisionPanel(CommittedChangeList changeList, final Change c) {
 179       super();
 180       createActionLabel(VcsBundle.message("outdated.version.show.diff.action"), "Compare.LastVersion");
 181       createActionLabel(VcsBundle.message("outdated.version.update.project.action"), "Vcs.UpdateProject");
 182       myChangeList = changeList;
 183       updateLabelText(c);
 184     }
 185
 186     private void updateLabelText(final Change c) {
 187       final DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
 188       String comment = myChangeList.getComment();
 189       int pos = comment.indexOf("\n");
 190       if (pos >= 0) {
 191         comment = comment.substring(0, pos).trim() + "...";
 192       }
 193       final String key = c.getType() == Change.Type.DELETED ? "outdated.version.text.deleted" : "outdated.version.text";
 194       myLabel.setText(VcsBundle.message(key, myChangeList.getCommitterName(),
 195                                         dateFormat.format(myChangeList.getCommitDate()), comment));
 196     }
 197
 198     public void setChangeList(final CommittedChangeList changeList, final Change c) {
 199       myChangeList = changeList;
 200       updateLabelText(c);
 201     }
 202   }
 203 }