Skip to contentPackage: DefaultUIProvider$1
DefaultUIProvider$1
Coverage
1: /********************************************************************************
2: * Copyright (c) 2011 Eike Stepper (Berlin, Germany) and others.
3: *
4: * All rights reserved. This program and the accompanying materials
5: * are made available under the terms of the Eclipse Public License 2.0
6: * which accompanies this distribution, and is available at
7: * https://www.eclipse.org/legal/epl-2.0/
8: *
9: * SPDX-License-Identifier: EPL-2.0
10: *
11: * Contributors:
12: * Eike Stepper - initial API and implementation
13: ********************************************************************************/
14: package org.eclipse.emf.ecp.spi.ui;
15:
16: import java.io.IOException;
17: import java.text.MessageFormat;
18: import java.util.ArrayList;
19: import java.util.Arrays;
20: import java.util.Collection;
21: import java.util.Collections;
22: import java.util.Comparator;
23: import java.util.List;
24: import java.util.Map;
25: import java.util.Map.Entry;
26: import java.util.Set;
27:
28: import org.eclipse.core.runtime.Platform;
29: import org.eclipse.emf.ecore.EClass;
30: import org.eclipse.emf.ecore.EClassifier;
31: import org.eclipse.emf.ecore.EObject;
32: import org.eclipse.emf.ecore.EPackage;
33: import org.eclipse.emf.ecore.EReference;
34: import org.eclipse.emf.ecore.resource.Resource;
35: import org.eclipse.emf.ecore.util.EcoreUtil;
36: import org.eclipse.emf.ecore.xmi.XMLResource;
37: import org.eclipse.emf.ecp.common.spi.ChildrenDescriptorCollector;
38: import org.eclipse.emf.ecp.core.ECPProject;
39: import org.eclipse.emf.ecp.core.ECPRepository;
40: import org.eclipse.emf.ecp.core.util.ECPCheckoutSource;
41: import org.eclipse.emf.ecp.core.util.ECPContainer;
42: import org.eclipse.emf.ecp.core.util.ECPProperties;
43: import org.eclipse.emf.ecp.core.util.ECPUtil;
44: import org.eclipse.emf.ecp.internal.core.util.Disposable;
45: import org.eclipse.emf.ecp.internal.core.util.Element;
46: import org.eclipse.emf.ecp.internal.ui.Activator;
47: import org.eclipse.emf.ecp.internal.ui.Messages;
48: import org.eclipse.emf.ecp.internal.ui.composites.PropertiesComposite;
49: import org.eclipse.emf.ecp.spi.core.InternalProvider;
50: import org.eclipse.emf.ecp.spi.ui.util.ECPHandlerHelper;
51: import org.eclipse.emf.edit.command.AddCommand;
52: import org.eclipse.emf.edit.command.CommandParameter;
53: import org.eclipse.emf.edit.domain.EditingDomain;
54: import org.eclipse.emf.edit.provider.ItemProviderAdapter;
55: import org.eclipse.emf.edit.ui.action.CreateChildAction;
56: import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;
57: import org.eclipse.jface.action.Action;
58: import org.eclipse.jface.action.IContributionItem;
59: import org.eclipse.jface.action.IMenuListener;
60: import org.eclipse.jface.action.IMenuManager;
61: import org.eclipse.jface.action.MenuManager;
62: import org.eclipse.jface.resource.ImageDescriptor;
63: import org.eclipse.jface.viewers.StructuredSelection;
64: import org.eclipse.swt.graphics.Image;
65: import org.eclipse.swt.widgets.Composite;
66: import org.eclipse.swt.widgets.Control;
67: import org.eclipse.swt.widgets.Text;
68:
69: /**
70: * @author Eike Stepper
71: * @author Eugen Neufeld
72: * @since 1.1
73: */
74: public class DefaultUIProvider extends Element implements UIProvider {
75:
76: private static final String PROJECT_OPEN_ICON = "icons/project_open.gif"; //$NON-NLS-1$
77: private static final String PROJECT_CLOSED_ICON = "icons/project_closed.gif"; //$NON-NLS-1$
78: private static final String REPOSITORY_ICON = "icons/repository.gif"; //$NON-NLS-1$
79: private static final String UNKNOWN_PACKAGE_ICON = "icons/EPackageUnknown.gif"; //$NON-NLS-1$
80: private static final String EPACKAGE_ICON = "icons/EPackage.gif"; //$NON-NLS-1$
81:
82: private final Disposable disposable = new Disposable(this) {
83: @Override
84: protected void doDispose() {
85: DefaultUIProvider.this.doDispose();
86: }
87: };
88:
89: private String label;
90:
91: private String description;
92:
93: /**
94: * Constructor of a {@link DefaultUIProvider}.
95: *
96: * @param name the name for this {@link UIProvider}
97: */
98: public DefaultUIProvider(String name) {
99: super(name);
100: label = name;
101: description = ""; //$NON-NLS-1$
102: }
103:
104: /** {@inheritDoc} **/
105: @Override
106: public String getType() {
107: return TYPE;
108: }
109:
110: /** {@inheritDoc} **/
111: @Override
112: public InternalProvider getProvider() {
113: return (InternalProvider) ECPUtil.getECPProviderRegistry().getProvider(getName());
114: }
115:
116: /** {@inheritDoc} **/
117: @Override
118: public final String getLabel() {
119: return label;
120: }
121:
122: /** {@inheritDoc} **/
123: @Override
124: public final void setLabel(String label) {
125: this.label = label;
126: }
127:
128: /** {@inheritDoc} **/
129: @Override
130: public final String getDescription() {
131: return description;
132: }
133:
134: /** {@inheritDoc} **/
135: @Override
136: public final void setDescription(String description) {
137: this.description = description;
138: }
139:
140: /** {@inheritDoc} **/
141: @Override
142: public <T> T getAdapter(Object adaptable, Class<T> adapterType) {
143: return null;
144: }
145:
146: /**
147: * Returns an object which is an instance of the given class associated with this object. Returns <code>null</code>
148: * if
149: * no such object can be found.
150: * <p>
151: * This implementation of the method declared by <code>IAdaptable</code> passes the request along to the platform's
152: * adapter manager; roughly <code>Platform.getAdapterManager().getAdapter(this, adapter)</code>. Subclasses may
153: * override this method (however, if they do so, they should invoke the method on their superclass to ensure that
154: * the Platform's adapter manager is consulted).
155: * </p>
156: *
157: * @param adapterType
158: * the class to adapt to
159: * @return the adapted object or <code>null</code>
160: * @see org.eclipse.core.runtime.IAdaptable#getAdapter(Class)
161: */
162: @Override
163: public Object getAdapter(@SuppressWarnings("rawtypes") Class adapterType) {
164: return Platform.getAdapterManager().getAdapter(this, adapterType);
165: }
166:
167: /** {@inheritDoc} **/
168: @Override
169: public final boolean isDisposed() {
170: return disposable.isDisposed();
171: }
172:
173: /** {@inheritDoc} **/
174: @Override
175: public final void dispose() {
176: disposable.dispose();
177: }
178:
179: /** {@inheritDoc} **/
180: @Override
181: public final void addDisposeListener(DisposeListener listener) {
182: disposable.addDisposeListener(listener);
183: }
184:
185: /** {@inheritDoc} **/
186: @Override
187: public final void removeDisposeListener(DisposeListener listener) {
188: disposable.removeDisposeListener(listener);
189: }
190:
191: /**
192: * Subclasses can override.
193: */
194: protected void doDispose() {
195: // Subclasses can override.
196: }
197:
198: /** {@inheritDoc} **/
199: @Override
200: public String getText(Object element) {
201: if (element instanceof Resource) {
202: final Resource resource = (Resource) element;
203: return resource.getURI().lastSegment();
204: }
205:
206: return UIProvider.EMF_LABEL_PROVIDER.getText(element);
207: }
208:
209: /** {@inheritDoc} **/
210: @Override
211: public Image getImage(Object element) {
212: if (element instanceof ECPProject) {
213: final ECPProject project = (ECPProject) element;
214: return project.isOpen() ? Activator.getImage(PROJECT_OPEN_ICON) : Activator.getImage(PROJECT_CLOSED_ICON);
215: }
216:
217: if (element instanceof ECPRepository) {
218: return Activator.getImage(REPOSITORY_ICON);
219: }
220:
221: return UIProvider.EMF_LABEL_PROVIDER.getImage(element);
222: }
223:
224: /** {@inheritDoc} **/
225: // TODO is this the right place for this implementation?
226: @Override
227: public void fillContextMenu(IMenuManager manager, ECPContainer context, Object[] elements) {
228: if (elements.length == 1) {
229: final Object element = elements[0];
230: if (context instanceof ECPProject) {
231: fillContextMenuForProject(manager, (ECPProject) context, element);
232: }
233: }
234: }
235:
236: private void fillContextMenuForProject(IMenuManager manager, final ECPProject project, Object element) {
237: if (element instanceof Resource) {
238: // TODO: does it make sense to show "all" registered EPackages in context menu of a resource?
239: // ZH: Do nothing for now. Instead, we show an "Add new Model Element..." in context menu,
240: // when element is a resource
241: // final Resource resource = (Resource) element;
242: // populateNewRoot(resource, manager);
243: } else if (element instanceof EObject) {
244: final EditingDomain domain = project.getEditingDomain();
245: final ChildrenDescriptorCollector childrenDescriptorCollector = new ChildrenDescriptorCollector();
246: final Collection<?> descriptors = childrenDescriptorCollector.getDescriptors((EObject) element);
247: if (descriptors != null) {
248: fillContextMenuWithDescriptors(manager, descriptors, domain, element, project);
249: }
250: } else if (element instanceof ItemProviderAdapter
251: && ((ItemProviderAdapter) element).getTarget() instanceof EObject) {
252: final EditingDomain domain = project.getEditingDomain();
253: final ItemProviderAdapter adapter = (ItemProviderAdapter) element;
254: element = adapter.getTarget();
255: final Collection<?> descriptors = adapter.getNewChildDescriptors(element, domain, null);
256: fillContextMenuWithDescriptors(manager, descriptors, domain, element, project);
257: }
258: }
259:
260: /**
261: * @param descriptors
262: */
263: private void fillContextMenuWithDescriptors(IMenuManager manager, Collection<?> descriptors,
264: final EditingDomain domain, Object object, final ECPProject project) {
265: if (!EObject.class.isInstance(object)) {
266: return;
267: }
268: final EObject eObject = (EObject) object;
269: for (final Object descriptor : descriptors) {
270: if (!CommandParameter.class.isInstance(descriptor)) {
271: continue;
272: }
273: final CommandParameter cp = (CommandParameter) descriptor;
274: if (cp.getEReference() == null) {
275: continue;
276: }
277: if (!cp.getEReference().isMany() && eObject.eIsSet(cp.getEStructuralFeature())) {
278: continue;
279: } else if (cp.getEReference().isMany() && cp.getEReference().getUpperBound() != -1
280: && cp.getEReference().getUpperBound() <= ((List<?>) eObject.eGet(cp.getEReference())).size()) {
281: continue;
282: }
283: // TODO: Temporal hack to remove all other elements of the view model for 1.1.M1
284: // final EObject objectToCreate = cp.getEValue();
285: // if (objectToCreate.eClass().getEPackage().getNsURI().equals("http://org/eclipse/emf/ecp/view/model")) {
286: // if (!objectToCreate.eClass().getName().equals("Control")) {
287: // continue;
288: // }
289: // }
290: // if
291: // (objectToCreate.eClass().getEPackage().getNsURI().equals("http://org/eclipse/emf/ecp/view/rule/model")) {
292: // continue;
293: // }
294:
295: // TODO needed?
296: // if (!cp.getEReference().isMany() || !cp.getEReference().isContainment()) {
297: // continue;
298: // }
299: manager.add(new CreateChildAction(domain, new StructuredSelection(eObject), descriptor) {
300: @Override
301: public void run() {
302: super.run();
303:
304: final EReference reference = ((CommandParameter) descriptor).getEReference();
305: if (!reference.isContainment()) {
306: domain.getCommandStack().execute(
307: AddCommand.create(domain, eObject.eContainer(), null, cp.getEValue()));
308: }
309: // try {
310: // TODO what is correct
311: domain.getCommandStack().execute(AddCommand.create(domain, eObject, reference, cp.getEValue()));
312: // object.eResource().save(null);
313: ECPHandlerHelper.openModelElement(cp.getEValue(), project);
314: // } catch (IOException ex) {
315: // Activator.log(ex);
316: // }
317: }
318: });
319: }
320: }
321:
322: /** {@inheritDoc} **/
323: @Override
324: public Control createAddRepositoryUI(Composite parent, ECPProperties repositoryProperties, Text repositoryNameText,
325: Text repositoryLabelText, Text repositoryDescriptionText) {
326: return new PropertiesComposite(parent, true, repositoryProperties);
327: }
328:
329: /** {@inheritDoc} **/
330: @Override
331: public Control createCheckoutUI(Composite parent, ECPCheckoutSource checkoutSource,
332: ECPProperties projectProperties) {
333: return new PropertiesComposite(parent, true, projectProperties);
334: }
335:
336: /** {@inheritDoc} **/
337: @Override
338: public Control createNewProjectUI(Composite parent, CompositeStateObserver observer,
339: ECPProperties projectProperties) {
340: return null;
341: }
342:
343: protected boolean populateNewRoot(Resource resource, IMenuManager manager) {
344: boolean populated = false;
345: final EPackage.Registry packageRegistry = EPackage.Registry.INSTANCE;
346: for (final Map.Entry<String, Object> entry : getSortedRegistryEntries(packageRegistry)) {
347: final IContributionItem item = populateSubMenu(resource, entry.getKey(), entry.getValue(), packageRegistry);
348: if (item != null) {
349: manager.add(item);
350: populated = true;
351: }
352: }
353:
354: return populated;
355: }
356:
357: private static IContributionItem populateSubMenu(final Resource resource, String nsURI, Object value,
358: final EPackage.Registry packageRegistry) {
359: if (value instanceof EPackage) {
360: final EPackage ePackage = (EPackage) value;
361:
362: final ImageDescriptor imageDescriptor = Activator.getImageDescriptor(EPACKAGE_ICON);
363: final MenuManager submenuManager = new MenuManager(nsURI, imageDescriptor, nsURI);
364: populateSubMenu(resource, ePackage, submenuManager);
365: return submenuManager;
366: }
367:
368: final ImageDescriptor imageDescriptor = Activator.getImageDescriptor(UNKNOWN_PACKAGE_ICON);
369: final MenuManager submenuManager = new MenuManager(nsURI, imageDescriptor, nsURI);
370: submenuManager.setRemoveAllWhenShown(true);
371: submenuManager.add(new Action(Messages.DefaultUIProvider_Calculating) {
372: });
373:
374: submenuManager.addMenuListener(new IMenuListener() {
375: @Override
376: public void menuAboutToShow(IMenuManager manager) {
377: final String nsURI = submenuManager.getMenuText();
378: final EPackage ePackage = packageRegistry.getEPackage(nsURI);
379:
380: if (ePackage != null) {
381: populateSubMenu(resource, ePackage, submenuManager);
382: } else {
383: Activator.log(MessageFormat.format(Messages.DefaultUIProvider_CantFindInPackageRegistry, nsURI));
384: }
385: }
386: });
387:
388: return submenuManager;
389: }
390:
391: private static void populateSubMenu(final Resource resource, EPackage ePackage, final MenuManager submenuManager) {
392: final List<EObject> objects = new ArrayList<EObject>();
393: for (final EClassifier eClassifier : ePackage.getEClassifiers()) {
394: if (eClassifier instanceof EClass) {
395: final EClass eClass = (EClass) eClassifier;
396: if (!eClass.isAbstract() && !eClass.isInterface()) {
397: objects.add(EcoreUtil.create(eClass));
398: }
399: }
400: }
401:
402: if (!objects.isEmpty()) {
403: Collections.sort(objects, new Comparator<EObject>() {
404: @Override
405: public int compare(EObject o1, EObject o2) {
406: return o1.eClass().getName().compareTo(o2.eClass().getName());
407: }
408: });
409:
410: for (final EObject object : objects) {
411: final String text = object.eClass().getName();
412: final Image image = UIProvider.EMF_LABEL_PROVIDER.getImage(object);
413: final ImageDescriptor imageDescriptor = ExtendedImageRegistry.getInstance().getImageDescriptor(image);
414:
415: final Action action = new Action(text, imageDescriptor) {
416: @Override
417: public void run() {
418: resource.getContents().add(object);
419:
420: try {
421: resource.save(Collections.singletonMap(XMLResource.OPTION_ENCODING, "UTF-8")); //$NON-NLS-1$
422: } catch (final IOException ex) {
423: Activator.log(ex);
424: }
425: }
426: };
427:
428: submenuManager.add(action);
429: }
430: }
431: }
432:
433: private static Map.Entry<String, Object>[] getSortedRegistryEntries(EPackage.Registry packageRegistry) {
434: final Set<Map.Entry<String, Object>> entries = packageRegistry.entrySet();
435: @SuppressWarnings("unchecked")
436: final Map.Entry<String, Object>[] array = entries.toArray(new Entry[entries.size()]);
437: Arrays.sort(array, new Comparator<Map.Entry<String, Object>>() {
438: @Override
439: public int compare(Map.Entry<String, Object> o1, Map.Entry<String, Object> o2) {
440: return o1.getKey().compareTo(o2.getKey());
441: }
442: });
443:
444: return array;
445: }
446: }
![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
