public RefreshAllExternalProjectsAction() {
getTemplatePresentation()
.setText(ExternalSystemBundle.message("action.refresh.all.projects.text", "external"));
getTemplatePresentation()
.setDescription(
ExternalSystemBundle.message("action.refresh.all.projects.description", "external"));
}
@Override
public boolean configureTask(
RunConfiguration runConfiguration, ExternalSystemBeforeRunTask task) {
ExternalSystemEditTaskDialog dialog =
new ExternalSystemEditTaskDialog(myProject, task.getTaskExecutionSettings(), mySystemId);
dialog.setTitle(
ExternalSystemBundle.message("tasks.select.task.title", mySystemId.getReadableName()));
if (!dialog.showAndGet()) {
return false;
}
return true;
}
@Override
public void update(AnActionEvent e) {
final Project project = e.getProject();
if (project == null) {
e.getPresentation().setEnabled(false);
return;
}
final List<ProjectSystemId> systemIds = getSystemIds(e);
if (systemIds.isEmpty()) {
e.getPresentation().setEnabled(false);
return;
}
final String name =
StringUtil.join(
systemIds,
new Function<ProjectSystemId, String>() {
@Override
public String fun(ProjectSystemId projectSystemId) {
return projectSystemId.getReadableName();
}
},
",");
e.getPresentation()
.setText(ExternalSystemBundle.message("action.refresh.all.projects.text", name));
e.getPresentation()
.setDescription(
ExternalSystemBundle.message("action.refresh.all.projects.description", name));
ExternalSystemProcessingManager processingManager =
ServiceManager.getService(ExternalSystemProcessingManager.class);
e.getPresentation()
.setEnabled(
!processingManager.hasTaskOfTypeInProgress(
ExternalSystemTaskType.RESOLVE_PROJECT, project));
}
@Override
public String getDescription(ExternalSystemBeforeRunTask task) {
final String externalProjectPath = task.getTaskExecutionSettings().getExternalProjectPath();
if (task.getTaskExecutionSettings().getTaskNames().isEmpty()) {
return ExternalSystemBundle.message("tasks.before.run.empty", mySystemId.getReadableName());
}
String desc = StringUtil.join(task.getTaskExecutionSettings().getTaskNames(), " ");
for (Module module : ModuleManager.getInstance(myProject).getModules()) {
if (!mySystemId
.toString()
.equals(module.getOptionValue(ExternalSystemConstants.EXTERNAL_SYSTEM_ID_KEY))) continue;
if (StringUtil.equals(
externalProjectPath,
module.getOptionValue(ExternalSystemConstants.LINKED_PROJECT_PATH_KEY))) {
desc = module.getName() + ": " + desc;
break;
}
}
return ExternalSystemBundle.message("tasks.before.run", mySystemId.getReadableName(), desc);
}
public ExternalSystemTasksPanel(
@NotNull Project project,
@NotNull ProjectSystemId externalSystemId,
@NotNull NotificationGroup notificationGroup) {
super(true);
myExternalSystemId = externalSystemId;
myNotificationGroup = notificationGroup;
myProject = project;
ExternalSystemManager<?, ?, ?, ?, ?> manager =
ExternalSystemApiUtil.getManager(externalSystemId);
assert manager != null;
AbstractExternalSystemLocalSettings settings = manager.getLocalSettingsProvider().fun(project);
ExternalSystemRecentTaskListModel recentTasksModel =
new ExternalSystemRecentTaskListModel(externalSystemId, project);
recentTasksModel.setTasks(settings.getRecentTasks());
myRecentTasksList =
new ExternalSystemRecentTasksList(recentTasksModel, externalSystemId, project) {
@Override
protected void processMouseEvent(MouseEvent e) {
if (e.getClickCount() > 0) {
mySelectedTaskProvider = myRecentTasksList;
myAllTasksTree.getSelectionModel().clearSelection();
}
super.processMouseEvent(e);
}
};
myAllTasksModel = new ExternalSystemTasksTreeModel(externalSystemId);
myAllTasksTree =
new ExternalSystemTasksTree(
myAllTasksModel, settings.getExpandStates(), project, externalSystemId) {
@Override
protected void processMouseEvent(MouseEvent e) {
if (e.getClickCount() > 0) {
mySelectedTaskProvider = myAllTasksTree;
myRecentTasksList.getSelectionModel().clearSelection();
}
super.processMouseEvent(e);
}
};
final String actionIdToUseForDoubleClick =
DefaultRunExecutor.getRunExecutorInstance().getContextActionId();
myAllTasksTree.addMouseListener(
new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
if (e.getClickCount() >= 2 && !e.isPopupTrigger()) {
ExternalSystemUiUtil.executeAction(actionIdToUseForDoubleClick, e);
}
}
});
ExternalSystemUiUtil.apply(settings, myAllTasksModel);
CustomizationUtil.installPopupHandler(
myAllTasksTree, TREE_ACTIONS_GROUP_ID, TREE_CONTEXT_MENU_PLACE);
ActionManager actionManager = ActionManager.getInstance();
ActionGroup group = (ActionGroup) actionManager.getAction(TOOL_WINDOW_TOOLBAR_ACTIONS_GROUP_ID);
ActionToolbar toolbar = actionManager.createActionToolbar(TOOL_WINDOW_PLACE, group, true);
toolbar.setTargetComponent(this);
setToolbar(toolbar.getComponent());
JPanel content = new JPanel(new GridBagLayout());
content.setOpaque(true);
content.setBackground(UIUtil.getListBackground());
JComponent recentTasksWithTitle =
wrap(myRecentTasksList, ExternalSystemBundle.message("tasks.recent.title"));
content.add(recentTasksWithTitle, ExternalSystemUiUtil.getFillLineConstraints(0));
JBScrollPane scrollPane = new JBScrollPane(myAllTasksTree);
scrollPane.setBorder(null);
JComponent allTasksWithTitle =
wrap(scrollPane, ExternalSystemBundle.message("tasks.all.title"));
content.add(
allTasksWithTitle, ExternalSystemUiUtil.getFillLineConstraints(0).weighty(1).fillCell());
setContent(content);
}
/**
* Asks current builder to ensure that target external project is defined.
*
* @param wizardContext current wizard context
* @throws ConfigurationException if gradle project is not defined and can't be constructed
*/
@SuppressWarnings("unchecked")
public void ensureProjectIsDefined(@NotNull WizardContext wizardContext)
throws ConfigurationException {
final String externalSystemName = myExternalSystemId.getReadableName();
File projectFile = getProjectFile();
if (projectFile == null) {
throw new ConfigurationException(ExternalSystemBundle.message("error.project.undefined"));
}
projectFile = getExternalProjectConfigToUse(projectFile);
final Ref<ConfigurationException> error = new Ref<ConfigurationException>();
final ExternalProjectRefreshCallback callback =
new ExternalProjectRefreshCallback() {
@Override
public void onSuccess(@Nullable DataNode<ProjectData> externalProject) {
myExternalProjectNode = externalProject;
}
@Override
public void onFailure(@NotNull String errorMessage, @Nullable String errorDetails) {
if (!StringUtil.isEmpty(errorDetails)) {
LOG.warn(errorDetails);
}
error.set(
new ConfigurationException(
ExternalSystemBundle.message("error.resolve.with.reason", errorMessage),
ExternalSystemBundle.message("error.resolve.generic")));
}
};
final Project project = getProject(wizardContext);
final File finalProjectFile = projectFile;
final String externalProjectPath = FileUtil.toCanonicalPath(finalProjectFile.getAbsolutePath());
final Ref<ConfigurationException> exRef = new Ref<ConfigurationException>();
executeAndRestoreDefaultProjectSettings(
project,
new Runnable() {
@Override
public void run() {
try {
ExternalSystemUtil.refreshProject(
project,
myExternalSystemId,
externalProjectPath,
callback,
true,
ProgressExecutionMode.MODAL_SYNC);
} catch (IllegalArgumentException e) {
exRef.set(
new ConfigurationException(
e.getMessage(),
ExternalSystemBundle.message(
"error.cannot.parse.project", externalSystemName)));
}
}
});
ConfigurationException ex = exRef.get();
if (ex != null) {
throw ex;
}
if (myExternalProjectNode == null) {
ConfigurationException exception = error.get();
if (exception != null) {
throw exception;
}
} else {
applyProjectSettings(wizardContext);
}
}
@Override
public String getDescription() {
return ExternalSystemBundle.message(
"module.type.description", myExternalSystemId.getReadableName());
}
@Override
public String getPresentableName() {
return ExternalSystemBundle.message("module.type.title", myExternalSystemId.getReadableName());
}
@Override
public String getName() {
return ExternalSystemBundle.message("tasks.before.run.empty", mySystemId.getReadableName());
}
public KeymapGroup createGroup(Condition<AnAction> condition, final Project project) {
KeymapGroup result =
KeymapGroupFactory.getInstance()
.createGroup(
ExternalSystemBundle.message("external.system.keymap.group"),
ExternalSystemIcons.TaskGroup);
if (project == null) return result;
MultiMap<ProjectSystemId, String> projectToActionsMapping = MultiMap.create();
for (ExternalSystemManager<?, ?, ?, ?, ?> manager : ExternalSystemApiUtil.getAllManagers()) {
projectToActionsMapping.putValues(manager.getSystemId(), ContainerUtil.<String>emptyList());
}
ActionManager actionManager = ActionManager.getInstance();
if (actionManager != null) {
for (String eachId : actionManager.getActionIds(getActionPrefix(project, null))) {
AnAction eachAction = actionManager.getAction(eachId);
if (!(eachAction instanceof MyExternalSystemAction)) continue;
if (condition != null && !condition.value(actionManager.getActionOrStub(eachId))) continue;
MyExternalSystemAction taskAction = (MyExternalSystemAction) eachAction;
projectToActionsMapping.putValue(taskAction.getSystemId(), eachId);
}
}
Map<ProjectSystemId, KeymapGroup> keymapGroupMap = ContainerUtil.newHashMap();
for (ProjectSystemId systemId : projectToActionsMapping.keySet()) {
if (!keymapGroupMap.containsKey(systemId)) {
final Icon projectIcon = ExternalSystemUiUtil.getUiAware(systemId).getProjectIcon();
KeymapGroup group =
KeymapGroupFactory.getInstance().createGroup(systemId.getReadableName(), projectIcon);
result.addGroup(group);
keymapGroupMap.put(systemId, group);
}
}
for (Map.Entry<ProjectSystemId, Collection<String>> each : projectToActionsMapping.entrySet()) {
Collection<String> tasks = each.getValue();
final ProjectSystemId systemId = each.getKey();
final KeymapGroup systemGroup = keymapGroupMap.get(systemId);
for (String actionId : tasks) {
systemGroup.addActionId(actionId);
}
if (systemGroup instanceof Group) {
Icon icon =
SystemInfoRt.isMac ? AllIcons.ToolbarDecorator.Mac.Add : AllIcons.ToolbarDecorator.Add;
((Group) systemGroup)
.addHyperlink(
new Hyperlink(icon, "Choose a task to assign a shortcut") {
@Override
public void onClick(MouseEvent e) {
SelectExternalTaskDialog dialog =
new SelectExternalTaskDialog(systemId, project);
if (dialog.showAndGet() && dialog.getResult() != null) {
TaskData taskData = dialog.getResult().second;
String ownerModuleName = dialog.getResult().first;
ExternalSystemTaskAction externalSystemAction =
(ExternalSystemTaskAction)
getOrRegisterAction(project, ownerModuleName, taskData);
ApplicationManager.getApplication()
.getMessageBus()
.syncPublisher(KeymapListener.CHANGE_TOPIC)
.processCurrentKeymapChanged();
Settings allSettings =
Settings.KEY.getData(
DataManager.getInstance().getDataContext(e.getComponent()));
KeymapPanel keymapPanel =
allSettings != null ? allSettings.find(KeymapPanel.class) : null;
if (keymapPanel != null) {
// clear actions filter
keymapPanel.showOption("");
keymapPanel.selectAction(externalSystemAction.myId);
}
}
}
});
}
}
for (ActionsProvider extension : ActionsProvider.EP_NAME.getExtensions()) {
KeymapGroup group = extension.createGroup(condition, project);
if (group != null) {
result.addGroup(group);
}
}
return result;
}
