/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.ivyde.internal.eclipse.cpcontainer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.apache.ivy.core.module.descriptor.ModuleDescriptor;
import org.apache.ivyde.eclipse.IvyDEException;
import org.apache.ivyde.eclipse.cp.IvyClasspathContainerConfiguration;
import org.apache.ivyde.eclipse.cp.IvyClasspathContainerHelper;
import org.apache.ivyde.eclipse.cp.SettingsSetup;
import org.apache.ivyde.internal.eclipse.IvyMarkerManager;
import org.apache.ivyde.internal.eclipse.IvyPlugin;
import org.apache.ivyde.internal.eclipse.ui.AdvancedSetupTab;
import org.apache.ivyde.internal.eclipse.ui.ClasspathSetupTab;
import org.apache.ivyde.internal.eclipse.ui.ConfTableViewer;
import org.apache.ivyde.internal.eclipse.ui.IvyFilePathText;
import org.apache.ivyde.internal.eclipse.ui.MappingSetupTab;
import org.apache.ivyde.internal.eclipse.ui.SettingsSetupTab;
import org.apache.ivyde.internal.eclipse.ui.ConfTableViewer.ConfTableListener;
import org.apache.ivyde.internal.eclipse.ui.IvyFilePathText.IvyXmlPathListener;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.ui.wizards.IClasspathContainerPage;
import org.eclipse.jdt.ui.wizards.IClasspathContainerPageExtension;
import org.eclipse.jdt.ui.wizards.NewElementWizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.TabFolder;
import org.eclipse.swt.widgets.TabItem;
/**
* Editor of the classpath container configuration at the project level.
*/
public class IvydeContainerPage extends NewElementWizardPage implements IClasspathContainerPage,
IClasspathContainerPageExtension {
private IJavaProject project;
private IvyFilePathText ivyFilePathText;
private ConfTableViewer confTableViewer;
private IvyClasspathContainerConfiguration conf;
private IClasspathEntry entry;
private TabFolder tabs;
private boolean exported = false;
private String oldIvyFile = null;
private List oldConfs = null;
private IvyClasspathContainerState state;
private SettingsSetupTab settingsSetupTab;
private ClasspathSetupTab classpathSetupTab;
private MappingSetupTab mappingSetupTab;
private AdvancedSetupTab advancedSetupTab;
/**
* Constructor
*/
public IvydeContainerPage() {
super("IvyDE Container");
}
public IJavaProject getProject() {
return project;
}
void checkCompleted() {
String error = null;
if (ivyFilePathText.getIvyFilePath().length() == 0) {
error = "Choose an ivy file";
} else if (project != null) {
error = checkConf();
}
setErrorMessage(error);
setPageComplete(error == null);
}
/**
* Check that the chosen configuration doesn't already exist within the current project
* <p>
* The uniqueness is for xmlivyPath + conf
*
* @return
*/
private String checkConf() {
String error = null;
String ivyFilePath = ivyFilePathText.getIvyFilePath();
List selectedConfigurations = confTableViewer.getSelectedConfigurations();
List/* <IvyClasspathContainer> */containers = IvyClasspathContainerHelper
.getContainers(project);
if (containers == null) {
return null;
}
Iterator/* <IvyClasspathContainer> */itContainers = containers.iterator();
while (error == null && itContainers.hasNext()) {
IvyClasspathContainerImpl ivycp = (IvyClasspathContainerImpl) itContainers.next();
IvyClasspathContainerConfiguration cpc = ivycp.getConf();
// first check that this is not the one we are editing
if (oldIvyFile != null && cpc.getIvyXmlPath().equals(oldIvyFile) && oldConfs != null
&& oldConfs.size() == cpc.getConfs().size()
&& oldConfs.containsAll(cpc.getConfs())) {
continue;
}
if (cpc.getIvyXmlPath().equals(ivyFilePath)) {
if (selectedConfigurations.isEmpty() || selectedConfigurations.contains("*")
|| cpc.getConfs().isEmpty() || cpc.getConfs().contains("*")) {
error = "A container already exists for the selected conf of "
+ "the module descriptor";
} else {
ArrayList list = new ArrayList(cpc.getConfs());
list.retainAll(selectedConfigurations);
if (!list.isEmpty()) {
error = "A container already exists for the selected conf of "
+ "the module descriptor";
}
}
}
}
return error;
}
void checkIvyXmlPath() {
ModuleDescriptor md;
try {
md = state.getModuleDescriptor();
ivyFilePathText.setIvyXmlError(null);
} catch (IvyDEException e) {
md = null;
ivyFilePathText.setIvyXmlError(e);
}
confTableViewer.setModuleDescriptor(md);
checkCompleted();
}
public boolean finish() {
List confs = confTableViewer.getSelectedConfigurations();
if (confs.isEmpty()) {
confs = Collections.singletonList("*");
}
conf.setConfs(confs);
if (settingsSetupTab.isProjectSpecific()) {
conf.setSettingsProjectSpecific(true);
conf.setIvySettingsSetup(settingsSetupTab.getSettingsEditor().getIvySettingsSetup());
} else {
conf.setSettingsProjectSpecific(false);
}
if (classpathSetupTab.isProjectSpecific()) {
conf.setClassthProjectSpecific(true);
conf.setClasspathSetup(classpathSetupTab.getClasspathSetupEditor().getClasspathSetup());
} else {
conf.setClassthProjectSpecific(false);
}
if (mappingSetupTab.isProjectSpecific()) {
conf.setMappingProjectSpecific(true);
conf.setMappingSetup(mappingSetupTab.getMappingSetupEditor().getMappingSetup());
} else {
conf.setMappingProjectSpecific(false);
}
if (advancedSetupTab.isProjectSpecific()) {
conf.setAdvancedProjectSpecific(true);
conf.setAdvancedSetup(advancedSetupTab.getAdvancedSetupEditor().getAdvancedSetup());
} else {
conf.setAdvancedProjectSpecific(false);
}
IPath path = IvyClasspathContainerConfAdapter.getPath(conf);
IClasspathAttribute[] atts = conf.getAttributes();
entry = JavaCore.newContainerEntry(path, null, atts, exported);
if (project != null) {
try {
IvyClasspathContainerImpl ivycp = new IvyClasspathContainerImpl(project, path,
new IClasspathEntry[0], atts);
JavaCore.setClasspathContainer(path, new IJavaProject[] {project},
new IClasspathContainer[] {ivycp}, null);
ivycp.launchResolve(false, null);
} catch (JavaModelException e) {
IvyPlugin.log(e);
}
}
if (conf.getJavaProject() != null && oldIvyFile != null
&& !oldIvyFile.equals(conf.getIvyXmlPath())) {
// changing the ivy.xml, remove old marker on the old file, if any
IvyMarkerManager ivyMarkerManager = IvyPlugin.getDefault().getIvyMarkerManager();
ivyMarkerManager.removeMarkers(conf.getJavaProject().getProject(), oldIvyFile);
}
return true;
}
public IClasspathEntry getSelection() {
return entry;
}
public void setSelection(IClasspathEntry entry) {
if (entry == null) {
conf = new IvyClasspathContainerConfiguration(project, "ivy.xml", true);
} else {
conf = new IvyClasspathContainerConfiguration(project, entry.getPath(), true,
entry.getExtraAttributes());
exported = entry.isExported();
}
state = new IvyClasspathContainerState(conf);
oldIvyFile = conf.getIvyXmlPath();
oldConfs = conf.getConfs();
}
public void setSelection(IFile ivyfile) {
conf = new IvyClasspathContainerConfiguration(project, ivyfile.getProjectRelativePath()
.toString(), true);
// if there is an ivysettings.xml file at the root of the project, configure the container
// to use it
if (project != null) {
IResource settings = project.getProject().findMember(new Path("ivysettings.xml"));
if (settings != null) {
conf.setSettingsProjectSpecific(true);
SettingsSetup setup = new SettingsSetup();
setup.setIvySettingsPath("ivysettings.xml");
conf.setIvySettingsSetup(setup);
}
}
state = new IvyClasspathContainerState(conf);
}
public void createControl(Composite parent) {
setTitle("IvyDE Managed Libraries");
setDescription("Choose ivy file and its configurations.");
tabs = new TabFolder(parent, SWT.BORDER);
tabs.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));
TabItem mainTab = new TabItem(tabs, SWT.NONE);
mainTab.setText("Main");
mainTab.setControl(createMainTab(tabs));
IProject p = project == null ? null : project.getProject();
settingsSetupTab = new SettingsSetupTab(tabs, p) {
protected void settingsUpdated() {
try {
conf.setSettingsProjectSpecific(isProjectSpecific());
conf.setIvySettingsSetup(getSettingsEditor().getIvySettingsSetup());
state.setIvySettingsLastModified(-1);
state.getIvy();
getSettingsEditor().setSettingsError(null);
checkIvyXmlPath();
} catch (IvyDEException e) {
getSettingsEditor().setSettingsError(e);
}
}
};
classpathSetupTab = new ClasspathSetupTab(tabs, p);
mappingSetupTab = new MappingSetupTab(tabs, p);
advancedSetupTab = new AdvancedSetupTab(tabs, p);
tabs.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
ivyFilePathText.updateErrorMarker();
settingsSetupTab.getSettingsEditor().updateErrorMarker();
}
});
setControl(tabs);
loadFromConf();
checkCompleted();
tabs.setFocus();
}
private Control createMainTab(Composite parent) {
Composite composite = new Composite(parent, SWT.NONE);
composite.setLayout(new GridLayout());
composite.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));
// CheckStyle:MagicNumber| OFF
Composite configComposite = new Composite(composite, SWT.NONE);
configComposite.setLayout(new GridLayout(2, false));
configComposite.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));
ivyFilePathText = new IvyFilePathText(configComposite, SWT.NONE, project == null ? null
: project.getProject());
ivyFilePathText.addListener(new IvyXmlPathListener() {
public void ivyXmlPathUpdated(String path) {
conf.setIvyXmlPath(path);
checkIvyXmlPath();
}
});
ivyFilePathText.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false, 2,
1));
// Label for ivy configurations field
Label confLabel = new Label(configComposite, SWT.NONE);
confLabel.setText("Configurations");
// table for configuration selection
confTableViewer = new ConfTableViewer(configComposite, SWT.NONE);
confTableViewer.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));
confTableViewer.addListener(new ConfTableListener() {
public void confTableUpdated(List confs) {
checkCompleted();
}
});
// refresh
Button refreshConf = new Button(configComposite, SWT.NONE);
refreshConf.setLayoutData(new GridData(GridData.END, GridData.CENTER, true, false, 2, 1));
refreshConf.setText("Reload the list of configurations");
refreshConf.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent ev) {
ModuleDescriptor md;
try {
md = state.getModuleDescriptor();
} catch (IvyDEException e) {
md = null;
e.show(IStatus.ERROR, "Ivy configuration error",
"The configurations of the ivy.xml could not be retrieved: ");
}
confTableViewer.setModuleDescriptor(md);
}
});
return composite;
}
private void loadFromConf() {
ivyFilePathText.init(conf.getIvyXmlPath());
settingsSetupTab.init(conf.isSettingsProjectSpecific(), conf.getIvySettingsSetup());
confTableViewer.init(conf.getConfs()); // *after* settingsSetupTab.init()!
classpathSetupTab.init(conf.isClassthProjectSpecific(), conf.getClasspathSetup());
mappingSetupTab.init(conf.isMappingProjectSpecific(), conf.getMappingSetup());
// project == null <==> container in a launch config: always resolve before launch
advancedSetupTab.init(conf.isAdvancedProjectSpecific(), conf.getAdvancedSetup(),
project == null);
settingsSetupTab.projectSpecificChanged();
classpathSetupTab.projectSpecificChanged();
mappingSetupTab.projectSpecificChanged();
advancedSetupTab.projectSpecificChanged();
}
public void initialize(IJavaProject p, IClasspathEntry[] currentEntries) {
this.project = p;
}
}