![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: TreeViewerSWTBuilder$3
TreeViewerSWTBuilder$3
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| dispose() |
|
|
|
|
|
||||||||||||||||||||
| getLabelDecorator(TreeViewer) |
|
|
|
|
|
||||||||||||||||||||
| {...} |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2015 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: * Johannes Faltermeier - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emfforms.spi.swt.treemasterdetail;
15:
16: import java.util.Collection;
17:
18: import org.eclipse.emf.ecore.EObject;
19: import org.eclipse.emf.ecore.resource.Resource;
20: import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
21: import org.eclipse.emf.edit.domain.EditingDomain;
22: import org.eclipse.emfforms.common.Optional;
23: import org.eclipse.emfforms.internal.swt.treemasterdetail.BaseLabelProviderWrapper;
24: import org.eclipse.emfforms.internal.swt.treemasterdetail.DefaultTreeViewerCustomization;
25: import org.eclipse.emfforms.spi.swt.treemasterdetail.actions.MasterDetailAction;
26: import org.eclipse.emfforms.spi.swt.treemasterdetail.util.CreateElementCallback;
27: import org.eclipse.emfforms.spi.swt.treemasterdetail.util.RootObject;
28: import org.eclipse.jface.layout.GridDataFactory;
29: import org.eclipse.jface.viewers.DecoratingLabelProvider;
30: import org.eclipse.jface.viewers.IBaseLabelProvider;
31: import org.eclipse.jface.viewers.IContentProvider;
32: import org.eclipse.jface.viewers.ILabelDecorator;
33: import org.eclipse.jface.viewers.ILabelProvider;
34: import org.eclipse.jface.viewers.StructuredSelection;
35: import org.eclipse.jface.viewers.TreeViewer;
36: import org.eclipse.jface.viewers.ViewerFilter;
37: import org.eclipse.swt.widgets.Composite;
38:
39: /**
40: * The TreeViewerSWTBuilder is initialized with a default behavior. It offers methods to customize certain
41: * aspects of a {@link org.eclipse.jface.viewers.TreeViewer TreeViewer}.
42: *
43: * @author Johannes Faltermeier
44: * @since 1.8
45: *
46: */
47: public class TreeViewerSWTBuilder {
48:
49: private final EditingDomain editingDomain;
50: private final Composite composite;
51: private final Object input;
52: private final DefaultTreeViewerCustomization behaviour;
53:
54: /**
55: * Default constructor.
56: *
57: * @param composite the parent composite
58: * @param input the input object
59: */
60: /* package */ TreeViewerSWTBuilder(Composite composite, Object input) {
61: this.composite = composite;
62: this.input = input;
63: editingDomain = getEditingDomain(input);
64: behaviour = new DefaultTreeViewerCustomization();
65: }
66:
67: /**
68: * Use this method to set a custom {@link org.eclipse.jface.viewers.IContentProvider IContentProvider} on the tree
69: * viewer. The default implementation will use
70: * an {@link org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider AdapterFactoryContentProvider}.
71: *
72: * @param contentProvider the desired behavior
73: * @return self
74: */
75: public TreeViewerSWTBuilder customizeContentProvider(ContentProviderProvider contentProvider) {
76: behaviour.setContentProvider(contentProvider);
77: return this;
78: }
79:
80: /**
81: * Use this method to set a custom {@link org.eclipse.jface.viewers.IContentProvider IContentProvider} on the tree
82: * viewer. If the content provider requires more dispose code than calling {@link IContentProvider#dispose()} use
83: * {@link #customizeContentProvider(ContentProviderProvider)} instead. The default implementation will use
84: * an {@link org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider AdapterFactoryContentProvider}.
85: *
86: * @param contentProvider the content provider to add
87: * @return self
88: */
89: public TreeViewerSWTBuilder customizeContentProvider(final IContentProvider contentProvider) {
90: behaviour.setContentProvider(new ContentProviderProvider() {
91:
92: @Override
93: public void dispose() {
94: contentProvider.dispose();
95: }
96:
97: @Override
98: public IContentProvider getContentProvider() {
99: return contentProvider;
100: }
101: });
102: return this;
103: }
104:
105: /**
106: * Use this method to add a customized drag and drop behaviour to the tree or to remove drag and drop functionality.
107: * The default implementation supports {@link org.eclipse.swt.dnd.DND#DROP_COPY DND#DROP_COPY},
108: * {@link org.eclipse.swt.dnd.DND#DROP_MOVE DND#DROP_MOVE} and {@link org.eclipse.swt.dnd.DND#DROP_LINK
109: * DND#DROP_LINK} based
110: * on EMF Edit.
111: *
112: * @param dnd the desired behavior
113: * @return self
114: */
115: public TreeViewerSWTBuilder customizeDragAndDrop(DNDProvider dnd) {
116: behaviour.setDragAndDrop(dnd);
117: return this;
118: }
119:
120: /**
121: * Use this method a add a custom {@link org.eclipse.jface.viewers.IBaseLabelProvider IBaseLabelProvider} to the
122: * tree. The default implementation uses an
123: * {@link org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider AdapterFactoryLabelProvider}.
124: *
125: * @param provider the desired behavior
126: * @return self
127: */
128: public TreeViewerSWTBuilder customizeLabelProvider(LabelProviderProvider provider) {
129: behaviour.setLabelProvider(provider);
130: return this;
131: }
132:
133: /**
134: * Use this method a add a custom {@link org.eclipse.jface.viewers.IBaseLabelProvider IBaseLabelProvider} to the
135: * tree. If the label provider requires more dispose code than a call to {@link IBaseLabelProvider#dispose()} use
136: * {@link #customizeLabelProvider(LabelProviderProvider)} instead. The default implementation uses an
137: * {@link org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider AdapterFactoryLabelProvider}.
138: *
139: * @param provider the label provider to add
140: * @return self
141: */
142: public TreeViewerSWTBuilder customizeLabelProvider(final IBaseLabelProvider provider) {
143: behaviour.setLabelProvider(new LabelProviderProvider() {
144:
145: @Override
146: public void dispose() {
147: provider.dispose();
148: }
149:
150: @Override
151: public IBaseLabelProvider getLabelProvider() {
152: return provider;
153: }
154: });
155: return this;
156: }
157:
158: /**
159: * Use this method to add a {@link ILabelDecorator} for decorating the labels of the label provider. The default
160: * implementation does not use a decorator.
161: *
162: * @param provider the {@link LabelDecoratorProvider} which will be used to create the decorator
163: * @return self
164: * @since 1.9
165: */
166: public TreeViewerSWTBuilder customizeLabelDecorator(LabelDecoratorProvider provider) {
167: behaviour.setLabelDecorator(provider);
168: return this;
169: }
170:
171: /**
172: * Use this method to add a {@link ILabelDecorator} for decorating the labels of the label provider. The default
173: * implementation does not use a decorator.
174: *
175: * @param decorator the decorator instance to be used
176: * @return self
177: * @since 1.9
178: */
179: public TreeViewerSWTBuilder customizeLabelDecorator(final ILabelDecorator decorator) {
180: behaviour.setLabelDecorator(new LabelDecoratorProvider() {
181: @Override
182: public Optional<ILabelDecorator> getLabelDecorator(TreeViewer viewer) {
183: return Optional.of(decorator);
184: }
185:
186: @Override
187: public void dispose() {
188: /* no op */
189: }
190: });
191: return this;
192: }
193:
194: /**
195: * Use this method to customize the {@link org.eclipse.swt.widgets.Menu Menu} which is shown when an element in the
196: * tree is right-clicked. The
197: * default implementation will offer menu entries to create new elements based on EMF Edit and to delete elements.
198: *
199: * @param menu the desired behavior
200: * @return self
201: */
202: public TreeViewerSWTBuilder customizeMenu(MenuProvider menu) {
203: behaviour.setMenu(menu);
204: return this;
205: }
206:
207: /**
208: * Use this method to customize the {@link org.eclipse.swt.widgets.Menu Menu} which is shown when an element in the
209: * tree is right-clicked. Use this method to add additional menu entries.
210: *
211: * @param rightClickActions the additional right click actions which will be shown in the context menu
212: * @return self
213: * @since 1.8
214: */
215: public TreeViewerSWTBuilder customizeMenuItems(Collection<MasterDetailAction> rightClickActions) {
216: behaviour.customizeMenu(rightClickActions);
217: return this;
218: }
219:
220: /**
221: * Use this method to customize the {@link org.eclipse.swt.widgets.Menu Menu} which is shown when an element in the
222: * tree is right-clicked. Use this method to influence the way new children are created.
223: *
224: * @param createElementCallback a callback which gets notified when a new child is created. this allows to veto the
225: * creation or to change the object to be added
226: * @return self
227: * @since 1.8
228: */
229: public TreeViewerSWTBuilder customizeCildCreation(CreateElementCallback createElementCallback) {
230: behaviour.customizeMenu(createElementCallback);
231: return this;
232: }
233:
234: /**
235: * Use this method to customize the {@link org.eclipse.swt.widgets.Menu Menu} which is shown when an element in the
236: * tree is right-clicked. Use this method to change the way elements are deleted.
237: *
238: * @param deleteActionBuilder the delete action which will be added to the context menu
239: * @return self
240: * @since 1.8
241: */
242: public TreeViewerSWTBuilder customizeDelete(DeleteActionBuilder deleteActionBuilder) {
243: behaviour.customizeMenu(deleteActionBuilder);
244: return this;
245: }
246:
247: /**
248: * Use this method to customize which element should be selected after the initial rendering. The default bahviour
249: * is to select the root node, if it is displayed in the tree.
250: *
251: * @param selection the desired behavior
252: * @return self
253: */
254: public TreeViewerSWTBuilder customizeInitialSelection(InitialSelectionProvider selection) {
255: behaviour.setInitialSelection(selection);
256: return this;
257: }
258:
259: /**
260: * Use this method to create the {@link org.eclipse.jface.viewers.TreeViewer TreeViewer} which is part of the tree
261: * master detail. The default
262: * implementation creates a regular {@link org.eclipse.jface.viewers.TreeViewer TreeViewer} with an
263: * {@link org.eclipse.jface.viewers.TreeViewer#setAutoExpandLevel(int) expand
264: * level} of 3.
265: *
266: * @param tree the desired behavior
267: * @return self
268: */
269: public TreeViewerSWTBuilder customizeTree(TreeViewerBuilder tree) {
270: behaviour.setTree(tree);
271: return this;
272: }
273:
274: /**
275: * Use this method to add {@link org.eclipse.jface.viewers.ViewerFilter ViewerFilters} on the tree. The default
276: * implementation does not add
277: * filters.
278: *
279: * @param filters the filters to add
280: * @return self
281: */
282: public TreeViewerSWTBuilder customizeViewerFilters(final ViewerFilter[] filters) {
283: behaviour.setViewerFilters(new ViewerFilterProvider() {
284: @Override
285: public ViewerFilter[] getViewerFilters() {
286: return filters;
287: }
288: });
289: return this;
290: }
291:
292: /**
293: * Call this method after all desired customizations have been passed to the builder. The will create a new
294: * {@link TreeMasterDetailComposite} with the desired customizations.
295: *
296: * @return the {@link TreeMasterDetailComposite}
297: */
298: public TreeViewer create() {
299: return create(behaviour, composite, editingDomain, input);
300: }
301:
302: /**
303: * @param input the input
304: * @return the {@link EditingDomain}
305: */
306: static EditingDomain getEditingDomain(Object input) {
307: if (input instanceof Resource) {
308: return AdapterFactoryEditingDomain.getEditingDomainFor(((Resource) input).getContents().get(0));
309: } else if (input instanceof RootObject) {
310: return AdapterFactoryEditingDomain.getEditingDomainFor(RootObject.class.cast(input).getRoot());
311: } else {
312: return AdapterFactoryEditingDomain.getEditingDomainFor(input);
313: }
314: }
315:
316: /**
317: * Creates a {@link TreeViewer}.
318: *
319: * @param behaviour the {@link TreeViewerCustomization}
320: * @param composite the parent {@link Composite}
321: * @param editingDomain the {@link EditingDomain}
322: * @param input the input
323: * @return the viewer
324: */
325: static TreeViewer create(TreeViewerCustomization behaviour, Composite composite, EditingDomain editingDomain,
326: Object input) {
327: final TreeViewer treeViewer = behaviour.createTree(composite);
328: GridDataFactory.fillDefaults().grab(true, true).applyTo(treeViewer.getControl());
329: if (behaviour.hasDND()) {
330: treeViewer.addDragSupport(behaviour.getDragOperations(), behaviour.getDragTransferTypes(),
331: behaviour.getDragListener(treeViewer));
332: treeViewer.addDropSupport(behaviour.getDropOperations(), behaviour.getDropTransferTypes(),
333: behaviour.getDropListener(editingDomain, treeViewer));
334: }
335: treeViewer.setContentProvider(behaviour.getContentProvider());
336: IBaseLabelProvider labelProvider = behaviour.getLabelProvider();
337: final Optional<ILabelDecorator> labelDecorator = behaviour.getLabelDecorator(treeViewer);
338: if (labelDecorator.isPresent()) {
339: ILabelProvider labelProviderForDecorator;
340: if (ILabelProvider.class.isInstance(labelProvider)) {
341: labelProviderForDecorator = ILabelProvider.class.cast(labelProvider);
342: } else {
343: labelProviderForDecorator = new BaseLabelProviderWrapper(labelProvider);
344: }
345: labelProvider = new DecoratingLabelProvider(labelProviderForDecorator,
346: labelDecorator.get());
347: }
348: treeViewer.setLabelProvider(labelProvider);
349: treeViewer.setFilters(behaviour.getViewerFilters());
350: treeViewer.getControl().setMenu(behaviour.getMenu(treeViewer, editingDomain));
351: treeViewer.setInput(input);
352: final EObject initialSelection = behaviour.getInitialSelection(input);
353: if (initialSelection != null) {
354: treeViewer.setSelection(new StructuredSelection(initialSelection), true);
355: }
356: return treeViewer;
357: }
358:
359: }