@SuppressWarnings("OverlyBroadCatchBlock")
private void multiCast(@NotNull Method method, Object[] args) {
try {
method.invoke(myBus.syncPublisher(AppTopics.FILE_DOCUMENT_SYNC), args);
} catch (ClassCastException e) {
LOG.error("Arguments: " + Arrays.toString(args), e);
} catch (Exception e) {
LOG.error(e);
}
// Allows pre-save document modification
for (FileDocumentManagerListener listener : getListeners()) {
try {
method.invoke(listener, args);
} catch (Exception e) {
LOG.error(e);
}
}
// stripping trailing spaces
try {
method.invoke(myTrailingSpacesStripper, args);
} catch (Exception e) {
LOG.error(e);
}
}
public boolean commitTransaction(final Document document) {
ApplicationManager.getApplication().assertIsDispatchThread();
final DocumentChangeTransaction documentChangeTransaction = removeTransaction(document);
if (documentChangeTransaction == null) return false;
final PsiFile changeScope = documentChangeTransaction.myChangeScope;
try {
mySyncDocument = document;
final PsiTreeChangeEventImpl fakeEvent = new PsiTreeChangeEventImpl(changeScope.getManager());
fakeEvent.setParent(changeScope);
fakeEvent.setFile(changeScope);
checkPsiModificationAllowed(fakeEvent);
doSync(
fakeEvent,
true,
new DocSyncAction() {
@Override
public void syncDocument(
@NotNull Document document, @NotNull PsiTreeChangeEventImpl event) {
doCommitTransaction(document, documentChangeTransaction);
}
});
myBus
.syncPublisher(PsiDocumentTransactionListener.TOPIC)
.transactionCompleted(document, changeScope);
} catch (Throwable e) {
myPsiDocumentManager.forceReload(
changeScope.getViewProvider().getVirtualFile(), changeScope.getViewProvider());
ExceptionUtil.rethrowAllAsUnchecked(e);
} finally {
mySyncDocument = null;
}
return true;
}
@Override
public void apply(CodeStyleSettings settings) {
boolean newValue = myEnabled.isSelected();
settings.getCustomSettings(EditorConfigSettings.class).ENABLED = newValue;
MessageBus bus = ApplicationManager.getApplication().getMessageBus();
bus.syncPublisher(EditorConfigSettings.EDITOR_CONFIG_ENABLED_TOPIC).valueChanged(newValue);
}
public boolean commitTransaction(final Document document) {
ApplicationManager.getApplication().assertIsDispatchThread();
final DocumentChangeTransaction documentChangeTransaction = removeTransaction(document);
if (documentChangeTransaction == null) return false;
final PsiElement changeScope = documentChangeTransaction.getChangeScope();
try {
mySyncDocument = document;
final PsiTreeChangeEventImpl fakeEvent = new PsiTreeChangeEventImpl(changeScope.getManager());
fakeEvent.setParent(changeScope);
fakeEvent.setFile(changeScope.getContainingFile());
doSync(
fakeEvent,
true,
new DocSyncAction() {
@Override
public void syncDocument(Document document, PsiTreeChangeEventImpl event) {
doCommitTransaction(document, documentChangeTransaction);
}
});
myBus
.syncPublisher(PsiDocumentTransactionListener.TOPIC)
.transactionCompleted(document, (PsiFile) changeScope);
} finally {
mySyncDocument = null;
}
return true;
}
@Override
public void after(@NotNull final List<? extends VFileEvent> events) {
incModificationCount();
for (FilePointerPartNode node : myPointersToUpdateUrl) {
synchronized (this) {
VirtualFilePointerImpl pointer = node.leaf;
String urlBefore = pointer.getUrlNoUpdate();
Pair<VirtualFile, String> after = node.update();
String urlAfter = after.second;
if (URL_COMPARATOR.compare(urlBefore, urlAfter) != 0) {
// url has changed, reinsert
FilePointerPartNode root = myPointers.get(pointer.getListener());
int useCount = node.useCount;
node.remove();
FilePointerPartNode newNode =
root.findPointerOrCreate(VfsUtilCore.urlToPath(urlAfter), 0, after);
VirtualFilePointerImpl existingPointer = newNode.leaf;
if (existingPointer != null) {
// can happen when e.g. file renamed to the existing file
// merge two pointers
pointer.myNode = newNode;
} else {
newNode.associate(pointer, after);
}
newNode.incrementUsageCount(useCount);
}
}
}
VirtualFilePointer[] pointersToFireArray = toPointers(myPointersToFire);
for (VirtualFilePointer pointer : pointersToFireArray) {
((VirtualFilePointerImpl) pointer).myNode.update();
}
for (EventDescriptor event : myEvents) {
event.fireAfter();
}
if (pointersToFireArray.length != 0) {
myBus.syncPublisher(VirtualFilePointerListener.TOPIC).validityChanged(pointersToFireArray);
}
myPointersToUpdateUrl = Collections.emptyList();
myEvents = Collections.emptyList();
myPointersToFire = Collections.emptyList();
for (FilePointerPartNode root : myPointers.values()) {
root.checkConsistency();
}
}
@RequiredWriteAction
@Override
public void processEvents(@NotNull List<VFileEvent> events) {
ApplicationManager.getApplication().assertWriteAccessAllowed();
List<VFileEvent> validated = validateEvents(events);
BulkFileListener publisher = myEventBus.syncPublisher(VirtualFileManager.VFS_CHANGES);
publisher.before(validated);
THashMap<VirtualFile, List<VFileEvent>> parentToChildrenEventsChanges = null;
for (VFileEvent event : validated) {
VirtualFile changedParent = null;
if (event instanceof VFileCreateEvent) {
changedParent = ((VFileCreateEvent) event).getParent();
((VFileCreateEvent) event).resetCache();
} else if (event instanceof VFileDeleteEvent) {
changedParent = ((VFileDeleteEvent) event).getFile().getParent();
}
if (changedParent != null) {
if (parentToChildrenEventsChanges == null)
parentToChildrenEventsChanges = new THashMap<VirtualFile, List<VFileEvent>>();
List<VFileEvent> parentChildrenChanges = parentToChildrenEventsChanges.get(changedParent);
if (parentChildrenChanges == null) {
parentToChildrenEventsChanges.put(
changedParent, parentChildrenChanges = new SmartList<VFileEvent>());
}
parentChildrenChanges.add(event);
} else {
applyEvent(event);
}
}
if (parentToChildrenEventsChanges != null) {
parentToChildrenEventsChanges.forEachEntry(
new TObjectObjectProcedure<VirtualFile, List<VFileEvent>>() {
@Override
public boolean execute(VirtualFile parent, List<VFileEvent> childrenEvents) {
applyChildrenChangeEvents(parent, childrenEvents);
return true;
}
});
parentToChildrenEventsChanges.clear();
}
publisher.after(validated);
}
public void startTransaction(@NotNull Project project, Document doc, PsiElement scope) {
LOG.assertTrue(!project.isDisposed());
Pair<DocumentChangeTransaction, Integer> pair = myTransactionsMap.get(doc);
if (pair == null) {
final PsiFile psiFile = scope != null ? scope.getContainingFile() : null;
pair =
new Pair<DocumentChangeTransaction, Integer>(
new DocumentChangeTransaction(doc, scope != null ? psiFile : null), 0);
myBus.syncPublisher(PsiDocumentTransactionListener.TOPIC).transactionStarted(doc, psiFile);
} else {
pair =
new Pair<DocumentChangeTransaction, Integer>(
pair.getFirst(), pair.getSecond().intValue() + 1);
}
myTransactionsMap.put(doc, pair);
}
private void notifyChangedExternally() {
myBus.syncPublisher(TOPIC).externalAnnotationsChangedExternally();
}
private void notifyAfterAnnotationChanging(
@NotNull PsiModifierListOwner owner, @NotNull String annotationFQName, boolean successful) {
myBus.syncPublisher(TOPIC).afterExternalAnnotationChanging(owner, annotationFQName, successful);
}
@Override
public void notifyDirectoryMappingChanged() {
myMessageBus.syncPublisher(VCS_CONFIGURATION_CHANGED).directoryMappingChanged();
}
private void severitiesChanged() {
myMessageBus.syncPublisher(SEVERITIES_CHANGED_TOPIC).run();
}
@Override
public void afterChange(boolean isPhysical) {
myMessageBus.syncPublisher(ANY_PSI_CHANGE_TOPIC).afterPsiChanged(isPhysical);
}
@TestOnly
public void doCommitTransaction(@NotNull Document document) {
doCommitTransaction(document, getTransaction(document));
myBus.syncPublisher(PsiDocumentTransactionListener.TOPIC).transactionCompleted(document, null);
}
@Override
public void before(@NotNull final List<? extends VFileEvent> events) {
List<FilePointerPartNode> toFireEvents = new ArrayList<FilePointerPartNode>();
List<FilePointerPartNode> toUpdateUrl = new ArrayList<FilePointerPartNode>();
VirtualFilePointer[] toFirePointers;
synchronized (this) {
incModificationCount();
for (VFileEvent event : events) {
if (event instanceof VFileDeleteEvent) {
final VFileDeleteEvent deleteEvent = (VFileDeleteEvent) event;
addPointersUnder(deleteEvent.getFile(), false, "", toFireEvents);
} else if (event instanceof VFileCreateEvent) {
final VFileCreateEvent createEvent = (VFileCreateEvent) event;
addPointersUnder(createEvent.getParent(), true, createEvent.getChildName(), toFireEvents);
} else if (event instanceof VFileCopyEvent) {
final VFileCopyEvent copyEvent = (VFileCopyEvent) event;
addPointersUnder(
copyEvent.getNewParent(), true, copyEvent.getFile().getName(), toFireEvents);
} else if (event instanceof VFileMoveEvent) {
final VFileMoveEvent moveEvent = (VFileMoveEvent) event;
VirtualFile eventFile = moveEvent.getFile();
addPointersUnder(moveEvent.getNewParent(), true, eventFile.getName(), toFireEvents);
List<FilePointerPartNode> nodes = new ArrayList<FilePointerPartNode>();
addPointersUnder(eventFile, false, "", nodes);
for (FilePointerPartNode pair : nodes) {
VirtualFile file = pair.leaf.getFile();
if (file != null) {
toUpdateUrl.add(pair);
}
}
} else if (event instanceof VFilePropertyChangeEvent) {
final VFilePropertyChangeEvent change = (VFilePropertyChangeEvent) event;
if (VirtualFile.PROP_NAME.equals(change.getPropertyName())) {
VirtualFile eventFile = change.getFile();
VirtualFile parent = eventFile.getParent(); // e.g. for LightVirtualFiles
addPointersUnder(parent, true, change.getNewValue().toString(), toFireEvents);
List<FilePointerPartNode> nodes = new ArrayList<FilePointerPartNode>();
addPointersUnder(eventFile, false, "", nodes);
for (FilePointerPartNode pair : nodes) {
VirtualFile file = pair.leaf.getFile();
if (file != null) {
toUpdateUrl.add(pair);
}
}
}
}
}
myEvents = new ArrayList<EventDescriptor>();
toFirePointers = toPointers(toFireEvents);
for (final VirtualFilePointerListener listener : myPointers.keySet()) {
if (listener == null) continue;
List<VirtualFilePointer> filtered =
ContainerUtil.filter(
toFirePointers,
new Condition<VirtualFilePointer>() {
@Override
public boolean value(VirtualFilePointer pointer) {
return ((VirtualFilePointerImpl) pointer).getListener() == listener;
}
});
if (!filtered.isEmpty()) {
EventDescriptor event =
new EventDescriptor(
listener, filtered.toArray(new VirtualFilePointer[filtered.size()]));
myEvents.add(event);
}
}
}
for (EventDescriptor descriptor : myEvents) {
descriptor.fireBefore();
}
if (!toFireEvents.isEmpty()) {
myBus.syncPublisher(VirtualFilePointerListener.TOPIC).beforeValidityChanged(toFirePointers);
}
myPointersToFire = toFireEvents;
myPointersToUpdateUrl = toUpdateUrl;
}
/** @noinspection UnusedParameters */
public ProjectManagerImpl(
VirtualFileManager virtualFileManager,
RecentProjectsManagerBase recentProjectsManager,
ProgressManager progressManager) {
myProgressManager = progressManager;
Application app = ApplicationManager.getApplication();
MessageBus messageBus = app.getMessageBus();
MessageBusConnection connection = messageBus.connect(app);
connection.subscribe(
StateStorage.STORAGE_TOPIC,
new StateStorage.Listener() {
@Override
public void storageFileChanged(
@NotNull final VirtualFileEvent event, @NotNull final StateStorage storage) {
VirtualFile file = event.getFile();
if (!file.isDirectory()
&& !(event.getRequestor() instanceof StateStorage.SaveSession)) {
saveChangedProjectFile(file, null, storage);
}
}
});
final ProjectManagerListener busPublisher = messageBus.syncPublisher(TOPIC);
addProjectManagerListener(
new ProjectManagerListener() {
@Override
public void projectOpened(final Project project) {
MessageBus messageBus = project.getMessageBus();
MessageBusConnection connection = messageBus.connect(project);
connection.subscribe(
StateStorage.STORAGE_TOPIC,
new StateStorage.Listener() {
@Override
public void storageFileChanged(
@NotNull final VirtualFileEvent event, @NotNull final StateStorage storage) {
VirtualFile file = event.getFile();
if (!file.isDirectory()
&& !(event.getRequestor() instanceof StateStorage.SaveSession)) {
saveChangedProjectFile(file, project, storage);
}
}
});
busPublisher.projectOpened(project);
for (ProjectManagerListener listener : getListeners(project)) {
listener.projectOpened(project);
}
}
@Override
public void projectClosed(Project project) {
busPublisher.projectClosed(project);
for (ProjectManagerListener listener : getListeners(project)) {
listener.projectClosed(project);
}
}
@Override
public boolean canCloseProject(Project project) {
for (ProjectManagerListener listener : getListeners(project)) {
if (!listener.canCloseProject(project)) {
return false;
}
}
return true;
}
@Override
public void projectClosing(Project project) {
busPublisher.projectClosing(project);
for (ProjectManagerListener listener : getListeners(project)) {
listener.projectClosing(project);
}
}
});
registerExternalProjectFileListener(virtualFileManager);
}
private void notifyStateChanged() {
myBus.syncPublisher(SHELF_TOPIC).stateChanged(new ChangeEvent(this));
}