package org.eclipse.gmf.tooling.runtime.part;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.common.util.WrappedException;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.FeatureMap;
import org.eclipse.emf.edit.provider.IWrapperItemProvider;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint;
import org.eclipse.gmf.runtime.diagram.core.services.ViewService;
import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil;
import org.eclipse.gmf.runtime.emf.core.GMFEditingDomainFactory;
import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter;
import org.eclipse.gmf.runtime.notation.Node;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.gmf.tooling.runtime.GMFToolingRuntimePlugin;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.model.WorkbenchLabelProvider;
/**
* @since 3.2
*/
public class DefaultElementChooserDialog extends Dialog {
public interface Context {
public AdapterFactory getAdapterFactory();
public PreferencesHint getPreferenceHint();
public String[] getFileExtesions();
public String getDialogTitle();
public ITreeContentProvider getTreeContentProvider();
public boolean allowMultiSelection();
}
private final Context myContext;
private TreeViewer myTreeViewer;
private List<URI> mySelectedModelElementURIs;
private View myView;
private TransactionalEditingDomain myEditingDomain = GMFEditingDomainFactory.INSTANCE.createEditingDomain();
public DefaultElementChooserDialog(Shell parentShell, View view, Context context) {
super(parentShell);
myContext = context;
setShellStyle(getShellStyle() | SWT.RESIZE);
myView = view;
}
public URI getSelectedModelElementURI() {
return getSelectedModelElementURIs().size() > 0 ? getSelectedModelElementURIs().get(0) : null;
}
public List<URI> getSelectedModelElementURIs() {
if (mySelectedModelElementURIs == null) {
mySelectedModelElementURIs = new LinkedList<URI>();
}
return mySelectedModelElementURIs;
}
public int open() {
int result = super.open();
for (Resource resource : myEditingDomain.getResourceSet().getResources()) {
resource.unload();
}
myEditingDomain.dispose();
return result;
}
protected Control createDialogArea(Composite parent) {
Composite composite = (Composite) super.createDialogArea(parent);
getShell().setText(myContext.getDialogTitle());
createModelBrowser(composite);
return composite;
}
protected Control createButtonBar(Composite parent) {
Control buttonBar = super.createButtonBar(parent);
setOkButtonEnabled(false);
return buttonBar;
}
private void createModelBrowser(Composite composite) {
myTreeViewer = new TreeViewer(composite, myContext.allowMultiSelection() ? SWT.MULTI : SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
GridData layoutData = new GridData(GridData.FILL_BOTH);
layoutData.heightHint = 300;
layoutData.widthHint = 300;
myTreeViewer.getTree().setLayoutData(layoutData);
myTreeViewer.setContentProvider(new ModelElementsTreeContentProvider(myContext.getTreeContentProvider(), myContext.getAdapterFactory()));
myTreeViewer.setLabelProvider(new ModelElementsTreeLabelProvider(myContext.getAdapterFactory()));
myTreeViewer.setInput(ResourcesPlugin.getWorkspace().getRoot());
myTreeViewer.addFilter(new ModelFilesFilter());
myTreeViewer.addSelectionChangedListener(new OkButtonEnabler(myContext.getPreferenceHint()));
}
private void setOkButtonEnabled(boolean enabled) {
getButton(IDialogConstants.OK_ID).setEnabled(enabled);
}
private boolean isValidModelFile(IFile file) {
String fileExtension = file.getFullPath().getFileExtension();
for (int i = 0; i < myContext.getFileExtesions().length; i++) {
String currentExtension = myContext.getFileExtesions()[i];
if (currentExtension != null && currentExtension.equals(fileExtension)) {
return true;
}
}
return false; //$NON-NLS-1$
}
private class ModelElementsTreeContentProvider implements ITreeContentProvider {
private final ITreeContentProvider myWorkbenchContentProvider;
private final AdapterFactoryContentProvider myAdapterFactoryContentProvier;
private ModelElementsTreeContentProvider(ITreeContentProvider iTreeContentProvider, AdapterFactory adapterFactory) {
myWorkbenchContentProvider = iTreeContentProvider;
myAdapterFactoryContentProvier = new AdapterFactoryContentProvider(adapterFactory);
}
public Object[] getChildren(Object parentElement) {
Object[] result = myWorkbenchContentProvider.getChildren(parentElement);
if (result != null && result.length > 0) {
return result;
}
if (parentElement instanceof IFile) {
IFile modelFile = (IFile) parentElement;
IPath resourcePath = modelFile.getFullPath();
ResourceSet resourceSet = myEditingDomain.getResourceSet();
try {
Resource modelResource = resourceSet.getResource(URI.createPlatformResourceURI(resourcePath.toString(), true), true);
return myAdapterFactoryContentProvier.getChildren(modelResource);
} catch (WrappedException e) {
GMFToolingRuntimePlugin.getInstance().getLog().log(new Status(IStatus.ERROR, GMFToolingRuntimePlugin.ID, //
"Unable to load resource: " + resourcePath.toString(), e)); //$NON-NLS-1$
}
return Collections.EMPTY_LIST.toArray();
}
return myAdapterFactoryContentProvier.getChildren(parentElement);
}
public Object getParent(Object element) {
Object parent = myWorkbenchContentProvider.getParent(element);
if (parent != null) {
return parent;
}
if (element instanceof EObject) {
EObject eObject = (EObject) element;
if (eObject.eContainer() == null && eObject.eResource().getURI().isFile()) {
String path = eObject.eResource().getURI().path();
return ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(new Path(path));
}
return myAdapterFactoryContentProvier.getParent(eObject);
}
return null;
}
public boolean hasChildren(Object element) {
if (element instanceof IFile) {
return isValidModelFile((IFile) element);
}
return myWorkbenchContentProvider.hasChildren(element) || myAdapterFactoryContentProvier.hasChildren(element);
}
public Object[] getElements(Object inputElement) {
Object[] elements = myWorkbenchContentProvider.getElements(inputElement);
return elements;
}
public void dispose() {
myWorkbenchContentProvider.dispose();
myAdapterFactoryContentProvier.dispose();
}
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
myWorkbenchContentProvider.inputChanged(viewer, oldInput, newInput);
myAdapterFactoryContentProvier.inputChanged(viewer, oldInput, newInput);
}
}
private class ModelElementsTreeLabelProvider implements ILabelProvider {
private final WorkbenchLabelProvider myWorkbenchLabelProvider;
private final AdapterFactoryLabelProvider myAdapterFactoryLabelProvider;
private ModelElementsTreeLabelProvider(AdapterFactory adapterFactory) {
myWorkbenchLabelProvider = new WorkbenchLabelProvider();
myAdapterFactoryLabelProvider = new AdapterFactoryLabelProvider(adapterFactory);
}
public Image getImage(Object element) {
Image result = myWorkbenchLabelProvider.getImage(element);
return result != null ? result : myAdapterFactoryLabelProvider.getImage(element);
}
public String getText(Object element) {
String result = myWorkbenchLabelProvider.getText(element);
return result != null && result.length() > 0 ? result : myAdapterFactoryLabelProvider.getText(element);
}
public void addListener(ILabelProviderListener listener) {
myWorkbenchLabelProvider.addListener(listener);
myAdapterFactoryLabelProvider.addListener(listener);
}
public void dispose() {
myWorkbenchLabelProvider.dispose();
myAdapterFactoryLabelProvider.dispose();
}
public boolean isLabelProperty(Object element, String property) {
return myWorkbenchLabelProvider.isLabelProperty(element, property) || myAdapterFactoryLabelProvider.isLabelProperty(element, property);
}
public void removeListener(ILabelProviderListener listener) {
myWorkbenchLabelProvider.removeListener(listener);
myAdapterFactoryLabelProvider.removeListener(listener);
}
}
private class ModelFilesFilter extends ViewerFilter {
public boolean select(Viewer viewer, Object parentElement, Object element) {
if (element instanceof IContainer) {
return true;
}
if (element instanceof IFile) {
IFile file = (IFile) element;
return isValidModelFile(file);
}
return true;
}
}
private class OkButtonEnabler implements ISelectionChangedListener {
private final PreferencesHint myPreferenceHint;
private OkButtonEnabler(PreferencesHint preferenceHint) {
myPreferenceHint = preferenceHint;
}
public void selectionChanged(SelectionChangedEvent event) {
if (event.getSelection() instanceof IStructuredSelection) {
IStructuredSelection selection = (IStructuredSelection) event.getSelection();
getSelectedModelElementURIs().clear();
boolean isAllOk = true;
for (Object selectedElement : selection.toList()) {
URI elementURI = getElementURI(selectedElement);
if (elementURI != null) {
getSelectedModelElementURIs().add(elementURI);
} else {
getSelectedModelElementURIs().clear();
isAllOk = false;
break;
}
}
setOkButtonEnabled(isAllOk);
}
}
private URI getElementURI(Object selectedElement) {
URI result = null;
if (selectedElement instanceof IWrapperItemProvider) {
selectedElement = ((IWrapperItemProvider) selectedElement).getValue();
}
if (selectedElement instanceof FeatureMap.Entry) {
selectedElement = ((FeatureMap.Entry) selectedElement).getValue();
}
if (selectedElement instanceof EObject) {
EObject selectedModelElement = (EObject) selectedElement;
if (ViewService.getInstance().provides(Node.class, new EObjectAdapter(selectedModelElement), myView, null, ViewUtil.APPEND, true, myPreferenceHint)) {
result = EcoreUtil.getURI(selectedModelElement);
}
}
return result;
}
}
}
