/**
* Cancel previously registered action and schedules (new) action to be executed when all
* documents are committed.
*
* @param key the (unique) id of the action.
* @param action The action to be executed after automatic commit. This action will overwrite any
* action which was registered under this key earlier. The action will be executed in EDT.
* @return true if action has been run immediately, or false if action was scheduled for execution
* later.
*/
public boolean cancelAndRunWhenAllCommitted(
@NonNls @NotNull Object key, @NotNull final Runnable action) {
ApplicationManager.getApplication().assertIsDispatchThread();
if (myProject.isDisposed()) {
action.run();
return true;
}
if (myUncommittedDocuments.isEmpty()) {
action.run();
if (!hasUncommitedDocuments()) {
assert actionsWhenAllDocumentsAreCommitted.isEmpty() : actionsWhenAllDocumentsAreCommitted;
}
return true;
}
actionsWhenAllDocumentsAreCommitted.put(key, action);
return false;
}
/**
* Schedules action to be executed when all documents are committed.
*
* @return true if action has been run immediately, or false if action was scheduled for execution
* later.
*/
@Override
public boolean performWhenAllCommitted(@NotNull final Runnable action) {
ApplicationManager.getApplication().assertIsDispatchThread();
assert !myProject.isDisposed() : "Already disposed: " + myProject;
if (myUncommittedDocuments.isEmpty()) {
action.run();
return true;
}
CompositeRunnable actions =
(CompositeRunnable) actionsWhenAllDocumentsAreCommitted.get(PERFORM_ALWAYS_KEY);
if (actions == null) {
actions = new CompositeRunnable();
actionsWhenAllDocumentsAreCommitted.put(PERFORM_ALWAYS_KEY, actions);
}
actions.add(action);
myDocumentCommitProcessor.log(
"PDI: added performWhenAllCommitted", null, false, action, myUncommittedDocuments);
return false;
}
@Override
@Nullable
public VirtualFileSystemEntry findRoot(
@NotNull String basePath, @NotNull NewVirtualFileSystem fs) {
if (basePath.isEmpty()) {
LOG.error("Invalid root, fs=" + fs);
return null;
}
String rootUrl = normalizeRootUrl(basePath, fs);
myRootsLock.readLock().lock();
try {
VirtualFileSystemEntry root = myRoots.get(rootUrl);
if (root != null) return root;
} finally {
myRootsLock.readLock().unlock();
}
final VirtualFileSystemEntry newRoot;
int rootId = FSRecords.findRootRecord(rootUrl);
VfsData.Segment segment = VfsData.getSegment(rootId, true);
VfsData.DirectoryData directoryData = new VfsData.DirectoryData();
if (fs instanceof ArchiveFileSystem) {
String parentPath =
basePath.substring(0, basePath.indexOf(ArchiveFileSystem.ARCHIVE_SEPARATOR));
VirtualFile parentFile = LocalFileSystem.getInstance().findFileByPath(parentPath);
if (parentFile == null) return null;
FileType type = FileTypeRegistry.getInstance().getFileTypeByFileName(parentFile.getName());
if (!(type instanceof ArchiveFileType)) return null;
newRoot = new ArchiveRoot(fs, rootId, segment, directoryData, parentFile);
} else {
newRoot = new FsRoot(fs, rootId, segment, directoryData, basePath);
}
FileAttributes attributes =
fs.getAttributes(
new StubVirtualFile() {
@NotNull
@Override
public String getPath() {
return newRoot.getPath();
}
@Nullable
@Override
public VirtualFile getParent() {
return null;
}
});
if (attributes == null || !attributes.isDirectory()) {
return null;
}
boolean mark = false;
myRootsLock.writeLock().lock();
try {
VirtualFileSystemEntry root = myRoots.get(rootUrl);
if (root != null) return root;
VfsData.initFile(rootId, segment, -1, directoryData);
mark = writeAttributesToRecord(rootId, 0, newRoot, fs, attributes);
myRoots.put(rootUrl, newRoot);
myRootsById.put(rootId, newRoot);
} finally {
myRootsLock.writeLock().unlock();
}
if (!mark && attributes.lastModified != FSRecords.getTimestamp(rootId)) {
newRoot.markDirtyRecursively();
}
LOG.assertTrue(
rootId == newRoot.getId(),
"root=" + newRoot + " expected=" + rootId + " actual=" + newRoot.getId());
return newRoot;
}
private void createActions(ToolbarDecorator decorator) {
final Consumer<BaseInjection> consumer =
new Consumer<BaseInjection>() {
public void consume(final BaseInjection injection) {
addInjection(injection);
}
};
final Factory<BaseInjection> producer =
new NullableFactory<BaseInjection>() {
public BaseInjection create() {
final InjInfo info = getSelectedInjection();
return info == null ? null : info.injection;
}
};
for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
ContainerUtil.addAll(myAddActions, support.createAddActions(myProject, consumer));
final AnAction action = support.createEditAction(myProject, producer);
myEditActions.put(
support.getId(),
action == null
? AbstractLanguageInjectionSupport.createDefaultEditAction(myProject, producer)
: action);
mySupports.put(support.getId(), support);
}
Collections.sort(
myAddActions,
new Comparator<AnAction>() {
public int compare(final AnAction o1, final AnAction o2) {
return Comparing.compare(
o1.getTemplatePresentation().getText(), o2.getTemplatePresentation().getText());
}
});
decorator.disableUpDownActions();
decorator.setAddActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
return !myAddActions.isEmpty();
}
});
decorator.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
performAdd(button);
}
});
decorator.setRemoveActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
boolean enabled = false;
for (InjInfo info : getSelectedInjections()) {
if (!info.bundled) {
enabled = true;
break;
}
}
return enabled;
}
});
decorator.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
performRemove();
}
});
decorator.setEditActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
AnAction edit = getEditAction();
if (edit != null) edit.update(e);
return edit != null && edit.getTemplatePresentation().isEnabled();
}
});
decorator.setEditAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
performEditAction();
}
});
decorator.addExtraAction(
new DumbAwareActionButton("Duplicate", "Duplicate", PlatformIcons.COPY_ICON) {
@Override
public boolean isEnabled() {
return getEditAction() != null;
}
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
final InjInfo injection = getSelectedInjection();
if (injection != null) {
addInjection(injection.injection.copy());
// performEditAction(e);
}
}
});
decorator.addExtraAction(
new DumbAwareActionButton(
"Enable Selected Injections",
"Enable Selected Injections",
PlatformIcons.SELECT_ALL_ICON) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
performSelectedInjectionsEnabled(true);
}
});
decorator.addExtraAction(
new DumbAwareActionButton(
"Disable Selected Injections",
"Disable Selected Injections",
PlatformIcons.UNSELECT_ALL_ICON) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
performSelectedInjectionsEnabled(false);
}
});
new DumbAwareAction("Toggle") {
@Override
public void update(@NotNull AnActionEvent e) {
SpeedSearchSupply supply = SpeedSearchSupply.getSupply(myInjectionsTable);
e.getPresentation().setEnabled(supply == null || !supply.isPopupActive());
}
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
performToggleAction();
}
}.registerCustomShortcutSet(
new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0)), myInjectionsTable);
if (myInfos.length > 1) {
AnActionButton shareAction =
new DumbAwareActionButton("Move to IDE Scope", null, PlatformIcons.IMPORT_ICON) {
{
addCustomUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
CfgInfo cfg = getTargetCfgInfo(getSelectedInjections());
e.getPresentation()
.setText(
cfg == getDefaultCfgInfo()
? "Move to IDE Scope"
: "Move to Project Scope");
return cfg != null;
}
});
}
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
final List<InjInfo> injections = getSelectedInjections();
final CfgInfo cfg = getTargetCfgInfo(injections);
if (cfg == null) return;
for (InjInfo info : injections) {
if (info.cfgInfo == cfg) continue;
if (info.bundled) continue;
info.cfgInfo.injectionInfos.remove(info);
cfg.addInjection(info.injection);
}
final int[] selectedRows = myInjectionsTable.getSelectedRows();
myInjectionsTable.getListTableModel().setItems(getInjInfoList(myInfos));
TableUtil.selectRows(myInjectionsTable, selectedRows);
}
@Nullable
private CfgInfo getTargetCfgInfo(final List<InjInfo> injections) {
CfgInfo cfg = null;
for (InjInfo info : injections) {
if (info.bundled) {
continue;
}
if (cfg == null) cfg = info.cfgInfo;
else if (cfg != info.cfgInfo) return info.cfgInfo;
}
if (cfg == null) return null;
for (CfgInfo info : myInfos) {
if (info != cfg) return info;
}
throw new AssertionError();
}
};
shareAction.setShortcut(
new CustomShortcutSet(
KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, InputEvent.SHIFT_DOWN_MASK)));
decorator.addExtraAction(shareAction);
}
decorator.addExtraAction(
new DumbAwareActionButton("Import", "Import", AllIcons.Actions.Install) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
doImportAction(e.getDataContext());
updateCountLabel();
}
});
decorator.addExtraAction(
new DumbAwareActionButton("Export", "Export", AllIcons.Actions.Export) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
final List<BaseInjection> injections = getInjectionList(getSelectedInjections());
final VirtualFileWrapper wrapper =
FileChooserFactory.getInstance()
.createSaveFileDialog(
new FileSaverDescriptor("Export Selected Injections to File...", "", "xml"),
myProject)
.save(null, null);
if (wrapper == null) return;
final Configuration configuration = new Configuration();
configuration.setInjections(injections);
final Document document = new Document(configuration.getState());
try {
JDOMUtil.writeDocument(document, wrapper.getFile(), "\n");
} catch (IOException ex) {
final String msg = ex.getLocalizedMessage();
Messages.showErrorDialog(
myProject,
msg != null && msg.length() > 0 ? msg : ex.toString(),
"Export Failed");
}
}
@Override
public boolean isEnabled() {
return !getSelectedInjections().isEmpty();
}
});
}
@Override
@Nullable
public VirtualFileSystemEntry findRoot(
@NotNull String basePath, @NotNull NewVirtualFileSystem fs) {
String rootUrl = normalizeRootUrl(basePath, fs);
boolean isFakeRoot = basePath.isEmpty();
VirtualFileSystemEntry root;
myRootsLock.readLock().lock();
try {
root = isFakeRoot ? mySuperRoot : myRoots.get(rootUrl);
if (root != null) return root;
} finally {
myRootsLock.readLock().unlock();
}
myRootsLock.writeLock().lock();
try {
root = isFakeRoot ? mySuperRoot : myRoots.get(rootUrl);
if (root != null) return root;
int rootId = FSRecords.findRootRecord(rootUrl);
root = myRootsById.get(rootId);
if (root != null) return root;
if (isFakeRoot) {
// fake super-root
root = new FakeRoot(fs, rootId);
} else if (fs instanceof JarFileSystem) {
// optimization: for jar roots do not store base path in the myName field, use local FS
// file's getPath()
String parentPath = basePath.substring(0, basePath.indexOf(JarFileSystem.JAR_SEPARATOR));
VirtualFile parentLocalFile = LocalFileSystem.getInstance().findFileByPath(parentPath);
if (parentLocalFile == null) return null;
// check one more time since the findFileByPath could have created the root (by reentering
// the findRoot)
root = myRoots.get(rootUrl);
if (root != null) return root;
root = myRootsById.get(rootId);
if (root != null) return root;
root = new JarRoot(fs, rootId, parentLocalFile);
} else {
root = new FsRoot(fs, rootId, basePath);
}
if (isFakeRoot) {
mySuperRoot = root;
} else {
FileAttributes attributes = fs.getAttributes(root);
if (attributes == null || !attributes.isDirectory()) {
return null;
}
final boolean newRoot = writeAttributesToRecord(rootId, 0, root, fs, attributes);
if (!newRoot && attributes.lastModified != FSRecords.getTimestamp(rootId)) {
root.markDirtyRecursively();
}
myRoots.put(rootUrl, root);
myRootsById.put(rootId, root);
if (rootId != root.getId()) throw new AssertionError();
}
return root;
} finally {
myRootsLock.writeLock().unlock();
}
}