![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: DefaultReferenceServiceFactory$6
DefaultReferenceServiceFactory$6
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| getSelectionViewer(EObject, EReference, Collection) |
|
|
|
|
|
||||||||||||||||||||
| {...} |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2019 EclipseSource Muenchen GmbH 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: * Eugen - initial API and implementation
13: * Christian W. Damus - bugs 529542, 547787
14: * Lucas Koehler - refactored common bazaar functionality out
15: ******************************************************************************/
16: package org.eclipse.emf.ecp.ui.view.swt;
17:
18: import static org.osgi.service.component.annotations.ReferenceCardinality.MULTIPLE;
19: import static org.osgi.service.component.annotations.ReferencePolicy.DYNAMIC;
20:
21: import java.util.Collection;
22: import java.util.List;
23: import java.util.Set;
24:
25: import org.eclipse.emf.ecore.EObject;
26: import org.eclipse.emf.ecore.EReference;
27: import org.eclipse.emf.ecp.edit.spi.ReferenceService;
28: import org.eclipse.emf.ecp.spi.common.ui.composites.SelectionComposite;
29: import org.eclipse.emf.ecp.ui.view.swt.reference.AttachmentStrategy;
30: import org.eclipse.emf.ecp.ui.view.swt.reference.CreateNewModelElementStrategy;
31: import org.eclipse.emf.ecp.ui.view.swt.reference.EObjectSelectionStrategy;
32: import org.eclipse.emf.ecp.ui.view.swt.reference.OpenInNewContextStrategy;
33: import org.eclipse.emf.ecp.ui.view.swt.reference.ReferenceStrategy;
34: import org.eclipse.emf.ecp.ui.view.swt.reference.ReferenceStrategyUtil;
35: import org.eclipse.emf.ecp.ui.view.swt.reference.SelectionCompositeStrategy;
36: import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
37: import org.eclipse.emfforms.bazaar.Bazaar;
38: import org.eclipse.emfforms.bazaar.BazaarContext;
39: import org.eclipse.emfforms.common.Optional;
40: import org.eclipse.emfforms.spi.bazaar.BazaarUtil;
41: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewContext;
42: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewServiceFactory;
43: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewServicePolicy;
44: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewServiceScope;
45: import org.eclipse.jface.viewers.StructuredViewer;
46: import org.osgi.service.component.ComponentContext;
47: import org.osgi.service.component.annotations.Activate;
48: import org.osgi.service.component.annotations.Component;
49: import org.osgi.service.component.annotations.Deactivate;
50: import org.osgi.service.component.annotations.Reference;
51:
52: /**
53: * The Factory for creating the {@link DefaultReferenceService}.
54: *
55: * @author Eugen Neufeld
56: * @since 1.8
57: *
58: */
59: @Component
60: public class DefaultReferenceServiceFactory implements EMFFormsViewServiceFactory<ReferenceService> {
61:
62: private ComponentContext context;
63:
64: private final Bazaar<EObjectSelectionStrategy> eobjectSelectionStrategyBazaar = BazaarUtil.createBazaar(
65: EObjectSelectionStrategy.NULL);
66: private final Bazaar<CreateNewModelElementStrategy> createNewModelElementStrategyBazaar = BazaarUtil.createBazaar(
67: CreateNewModelElementStrategy.DEFAULT);
68: private final Bazaar<AttachmentStrategy> attachmentStrategyBazaar = BazaarUtil
69: .createBazaar(AttachmentStrategy.DEFAULT);
70: private final Bazaar<ReferenceStrategy> referenceStrategyBazaar = BazaarUtil
71: .createBazaar(ReferenceStrategy.DEFAULT);
72: private final Bazaar<OpenInNewContextStrategy> openInNewContextStrategyBazaar = BazaarUtil.createBazaar(
73: OpenInNewContextStrategy.DEFAULT);
74: private final Bazaar<SelectionCompositeStrategy> selectionCompositeStrategyBazaar = BazaarUtil.createBazaar(
75: SelectionCompositeStrategy.DEFAULT);
76:
77: /**
78: * Initializes me.
79: */
80: public DefaultReferenceServiceFactory() {
81: super();
82: }
83:
84: @Override
85: public EMFFormsViewServicePolicy getPolicy() {
86: return EMFFormsViewServicePolicy.LAZY;
87: }
88:
89: @Override
90: public EMFFormsViewServiceScope getScope() {
91: return EMFFormsViewServiceScope.LOCAL;
92: }
93:
94: @Override
95: public double getPriority() {
96: return 1;
97: }
98:
99: @Override
100: public Class<ReferenceService> getType() {
101: return ReferenceService.class;
102: }
103:
104: /**
105: * Add an attachment strategy provider.
106: *
107: * @param provider the provider to add
108: */
109: @Reference(cardinality = MULTIPLE, policy = DYNAMIC)
110: void addAttachmentStrategyProvider(AttachmentStrategy.Provider provider) {
111: attachmentStrategyBazaar.addVendor(provider);
112: }
113:
114: /**
115: * Remove an attachment strategy provider.
116: *
117: * @param provider the provider to remove
118: */
119: void removeAttachmentStrategyProvider(AttachmentStrategy.Provider provider) {
120: attachmentStrategyBazaar.removeVendor(provider);
121: }
122:
123: /**
124: * Add a create new model element strategy provider.
125: *
126: * @param provider the provider to add
127: */
128: @Reference(cardinality = MULTIPLE, policy = DYNAMIC)
129: void addCreateNewModelElementStrategyProvider(CreateNewModelElementStrategy.Provider provider) {
130: createNewModelElementStrategyBazaar.addVendor(provider);
131: }
132:
133: /**
134: * Remove a create new model element strategy provider.
135: *
136: * @param provider the provider to remove
137: */
138: void removeCreateNewModelElementStrategyProvider(CreateNewModelElementStrategy.Provider provider) {
139: createNewModelElementStrategyBazaar.removeVendor(provider);
140: }
141:
142: /**
143: * Add an open strategy provider.
144: *
145: * @param provider the provider to add
146: */
147: @Reference(cardinality = MULTIPLE, policy = DYNAMIC)
148: void addOpenInNewContextStrategyProvider(OpenInNewContextStrategy.Provider provider) {
149: openInNewContextStrategyBazaar.addVendor(provider);
150: }
151:
152: /**
153: * Remove an open strategy provider.
154: *
155: * @param provider the provider to remove
156: */
157: void removeOpenInNewContextStrategyProvider(OpenInNewContextStrategy.Provider provider) {
158: openInNewContextStrategyBazaar.removeVendor(provider);
159: }
160:
161: /**
162: * Add an {@code EObject} selection strategy provider.
163: *
164: * @param provider the provider to add
165: */
166: @Reference(cardinality = MULTIPLE, policy = DYNAMIC)
167: void addEObjectSelectionStrategyProvider(EObjectSelectionStrategy.Provider provider) {
168: eobjectSelectionStrategyBazaar.addVendor(provider);
169: }
170:
171: /**
172: * Remove an {@code EObject} selection strategy provider.
173: *
174: * @param provider the provider to remove
175: */
176: void removeEObjectSelectionStrategyProvider(EObjectSelectionStrategy.Provider provider) {
177: eobjectSelectionStrategyBazaar.removeVendor(provider);
178: }
179:
180: /**
181: * Add a reference strategy provider.
182: *
183: * @param provider the provider to add
184: */
185: @Reference(cardinality = MULTIPLE, policy = DYNAMIC)
186: void addReferenceStrategyProvider(ReferenceStrategy.Provider provider) {
187: referenceStrategyBazaar.addVendor(provider);
188: }
189:
190: /**
191: * Remove a reference strategy provider.
192: *
193: * @param provider the provider to remove
194: */
195: void removeReferenceStrategyProvider(ReferenceStrategy.Provider provider) {
196: referenceStrategyBazaar.removeVendor(provider);
197: }
198:
199: /**
200: * Add a selection composite strategy provider.
201: *
202: * @param provider the provider to add
203: */
204: @Reference(cardinality = MULTIPLE, policy = DYNAMIC)
205: void addReferenceTableColumnStrategyProvider(SelectionCompositeStrategy.Provider provider) {
206: selectionCompositeStrategyBazaar.addVendor(provider);
207: }
208:
209: /**
210: * Remove a selection composite strategy provider.
211: *
212: * @param provider the provider to remove
213: */
214: void removeReferenceTableColumnStrategyProvider(SelectionCompositeStrategy.Provider provider) {
215: selectionCompositeStrategyBazaar.removeVendor(provider);
216: }
217:
218: /**
219: * Activates me.
220: *
221: * @param context my component context
222: *
223: * @since 1.16
224: */
225: @Activate
226: void activate(ComponentContext context) {
227: this.context = context;
228: }
229:
230: /**
231: * Deactivates me.
232: *
233: * @since 1.16
234: */
235: @Deactivate
236: void deactivate() {
237: context = null;
238: }
239:
240: @Override
241: public ReferenceService createService(EMFFormsViewContext emfFormsViewContext) {
242: if (emfFormsViewContext instanceof ViewModelContext) {
243: final DefaultReferenceService drs = new DefaultReferenceService();
244:
245: // Inject customizations
246: drs.setAttachmentStrategy(createDynamicAttachmentStrategy());
247: drs.setCreateNewModelElementStrategy(createDynamicCreateNewModelElementStrategy());
248: drs.setEObjectSelectionStrategy(createDynamicEObjectSelectionStrategy());
249: drs.setOpenStrategy(createDynamicOpenInNewContextStrategy());
250: drs.setReferenceStrategy(createDynamicReferenceStrategy());
251: drs.setSelectionCompositeStrategyy(createDynamicSelectionCompositeStrategy());
252:
253: drs.instantiate((ViewModelContext) emfFormsViewContext);
254:
255: return drs;
256: }
257: throw new IllegalStateException("The provided context is not a ViewModelContext."); //$NON-NLS-1$
258: }
259:
260: private AttachmentStrategy createDynamicAttachmentStrategy() {
261: return new AttachmentStrategy() {
262:
263: @Override
264: public boolean addElementToModel(EObject owner, EReference reference, EObject object) {
265: final AttachmentStrategy delegate = attachmentStrategyBazaar.createProduct(
266: ReferenceStrategyUtil.createBazaarContext(context, owner, reference));
267: if (delegate == null) {
268: return false;
269: }
270: return delegate.addElementToModel(owner, reference, object);
271: }
272: };
273: }
274:
275: private CreateNewModelElementStrategy createDynamicCreateNewModelElementStrategy() {
276: return new CreateNewModelElementStrategy() {
277:
278: @Override
279: public Optional<EObject> createNewModelElement(EObject owner, EReference reference) {
280: final CreateNewModelElementStrategy delegate = createNewModelElementStrategyBazaar
281: .createProduct(ReferenceStrategyUtil.createBazaarContext(context, owner, reference));
282: if (delegate == null) {
283: return Optional.empty();
284: }
285: return delegate.createNewModelElement(owner, reference);
286: }
287: };
288: }
289:
290: private ReferenceStrategy createDynamicReferenceStrategy() {
291: return new ReferenceStrategy() {
292:
293: @Override
294: public boolean addElementsToReference(EObject owner, EReference reference, Set<? extends EObject> objects) {
295: final ReferenceStrategy delegate = referenceStrategyBazaar.createProduct(
296: ReferenceStrategyUtil.createBazaarContext(context, owner, reference));
297: if (delegate == null) {
298: return false;
299: }
300: return delegate.addElementsToReference(owner, reference, objects);
301: }
302: };
303: }
304:
305: private EObjectSelectionStrategy createDynamicEObjectSelectionStrategy() {
306: return new EObjectSelectionStrategy() {
307:
308: @Override
309: public Collection<EObject> collectExistingObjects(EObject owner, EReference reference,
310: Collection<EObject> existingObjects) {
311:
312: Collection<EObject> result = existingObjects;
313:
314: final List<EObjectSelectionStrategy> delegates = eobjectSelectionStrategyBazaar.createProducts(
315: ReferenceStrategyUtil.createBazaarContext(context, owner, reference));
316: for (final EObjectSelectionStrategy next : delegates) {
317: result = next.collectExistingObjects(owner, reference, result);
318: }
319:
320: return result;
321: }
322: };
323: }
324:
325: private OpenInNewContextStrategy createDynamicOpenInNewContextStrategy() {
326: return new OpenInNewContextStrategy() {
327:
328: @Override
329: public boolean openInNewContext(EObject owner, EReference reference, EObject object) {
330: final OpenInNewContextStrategy delegate = openInNewContextStrategyBazaar.createProduct(
331: ReferenceStrategyUtil.createBazaarContext(context, owner, reference));
332: if (delegate == null) {
333: return false;
334: }
335: return delegate.openInNewContext(owner, reference, object);
336: }
337: };
338: }
339:
340: private SelectionCompositeStrategy createDynamicSelectionCompositeStrategy() {
341: return new SelectionCompositeStrategy() {
342:
343: @Override
344: public SelectionComposite<? extends StructuredViewer> getSelectionViewer(EObject owner,
345: EReference reference, Collection<? extends EObject> extent) {
346:
347: final BazaarContext bctx = ReferenceStrategyUtil.bazaarContextBuilder(context, owner, reference)
348: .put(EXTENT, extent)
349: .build();
350:
351: final SelectionCompositeStrategy delegate = selectionCompositeStrategyBazaar.createProduct(bctx);
352:• if (delegate == null) {
353: return null; // Shouldn't happen
354: }
355: return delegate.getSelectionViewer(owner, reference, extent);
356: }
357: };
358: }
359:
360: }