![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: DefaultTreeViewerCustomization$DefaultLabelDecoratorProvider
DefaultTreeViewerCustomization$DefaultLabelDecoratorProvider
| 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.internal.swt.treemasterdetail;
15:
16: import java.util.Collection;
17:
18: import org.eclipse.emf.common.notify.AdapterFactory;
19: import org.eclipse.emf.ecore.EObject;
20: import org.eclipse.emf.ecp.view.model.common.edit.provider.CustomReflectiveItemProviderAdapterFactory;
21: import org.eclipse.emf.edit.domain.EditingDomain;
22: import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
23: import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
24: import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
25: import org.eclipse.emfforms.common.Optional;
26: import org.eclipse.emfforms.internal.swt.treemasterdetail.defaultprovider.DefaultDNDProvider;
27: import org.eclipse.emfforms.internal.swt.treemasterdetail.defaultprovider.DefaultMenuProvider;
28: import org.eclipse.emfforms.internal.swt.treemasterdetail.defaultprovider.DefaultTreeViewerBuilder;
29: import org.eclipse.emfforms.internal.swt.treemasterdetail.defaultprovider.DefaultViewerFilterProvider;
30: import org.eclipse.emfforms.spi.swt.treemasterdetail.ContentProviderProvider;
31: import org.eclipse.emfforms.spi.swt.treemasterdetail.DNDProvider;
32: import org.eclipse.emfforms.spi.swt.treemasterdetail.DeleteActionBuilder;
33: import org.eclipse.emfforms.spi.swt.treemasterdetail.InitialSelectionProvider;
34: import org.eclipse.emfforms.spi.swt.treemasterdetail.LabelDecoratorProvider;
35: import org.eclipse.emfforms.spi.swt.treemasterdetail.LabelProviderProvider;
36: import org.eclipse.emfforms.spi.swt.treemasterdetail.MenuProvider;
37: import org.eclipse.emfforms.spi.swt.treemasterdetail.TreeViewerBuilder;
38: import org.eclipse.emfforms.spi.swt.treemasterdetail.TreeViewerCustomization;
39: import org.eclipse.emfforms.spi.swt.treemasterdetail.ViewerFilterProvider;
40: import org.eclipse.emfforms.spi.swt.treemasterdetail.actions.MasterDetailAction;
41: import org.eclipse.emfforms.spi.swt.treemasterdetail.util.CreateElementCallback;
42: import org.eclipse.emfforms.spi.swt.treemasterdetail.util.RootObject;
43: import org.eclipse.jface.viewers.IBaseLabelProvider;
44: import org.eclipse.jface.viewers.IContentProvider;
45: import org.eclipse.jface.viewers.ILabelDecorator;
46: import org.eclipse.jface.viewers.TreeViewer;
47: import org.eclipse.jface.viewers.ViewerFilter;
48: import org.eclipse.swt.dnd.DragSourceListener;
49: import org.eclipse.swt.dnd.DropTargetListener;
50: import org.eclipse.swt.dnd.Transfer;
51: import org.eclipse.swt.widgets.Composite;
52: import org.eclipse.swt.widgets.Menu;
53:
54: /**
55: * Default implementation of the {@link TreeViewerCustomization}.
56: *
57: * @author Johannes Faltermeier
58: *
59: */
60: public class DefaultTreeViewerCustomization implements TreeViewerCustomization {
61:
62: private ViewerFilterProvider filters;
63: private TreeViewerBuilder tree;
64: private InitialSelectionProvider selection;
65: private MenuProvider menu;
66: private LabelProviderProvider labelProvider;
67: private LabelDecoratorProvider decorator;
68: private DNDProvider dnd;
69: private ContentProviderProvider contentProvider;
70: private ComposedAdapterFactory adapterFactory;
71: private AdapterFactoryContentProvider adapterFactoryContentProvider;
72: private boolean readOnly;
73:
74: /**
75: * Default constructor.
76: */
77: public DefaultTreeViewerCustomization() {
78: filters = new DefaultViewerFilterProvider();
79: tree = new DefaultTreeViewerBuilder();
80: selection = new DefaultTreeMasterDetailSelectionProvider();
81: menu = new DefaultMenuProvider();
82: labelProvider = new DefaultLabelProviderProvider();
83: dnd = new DefaultDNDProvider();
84: contentProvider = new DefaultContentProviderProvider();
85: decorator = new DefaultLabelDecoratorProvider();
86: }
87:
88: /**
89: * Gives access to the composed adapter factory.
90: *
91: * @return the adapter factory
92: */
93: protected ComposedAdapterFactory getComposedAdapterFactory() {
94: if (adapterFactory == null) {
95: adapterFactory = new ComposedAdapterFactory(new AdapterFactory[] {
96: new CustomReflectiveItemProviderAdapterFactory(),
97: new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE) });
98: }
99: return adapterFactory;
100: }
101:
102: /**
103: * Returns the {@link AdapterFactoryContentProvider}.
104: *
105: * @return the content provider
106: */
107: protected AdapterFactoryContentProvider getAdapterFactoryContentProvider() {
108: if (adapterFactoryContentProvider == null) {
109: final ComposedAdapterFactory adapterFactory = getComposedAdapterFactory();
110: adapterFactoryContentProvider = new AdapterFactoryContentProvider(
111: adapterFactory) {
112:
113: @Override
114: public Object[] getElements(Object object) {
115: if (RootObject.class.isInstance(object)) {
116: return new Object[] { RootObject.class.cast(object).getRoot() };
117: }
118: return super.getElements(object);
119: }
120:
121: @Override
122: public boolean hasChildren(Object object) {
123: return getChildren(object).length > 0;
124: }
125: };
126: }
127: return adapterFactoryContentProvider;
128: }
129:
130: @Override
131: public TreeViewer createTree(Composite parent) {
132: return tree.createTree(parent);
133: }
134:
135: @Override
136: public boolean hasDND() {
137: if (readOnly) {
138: return false;
139: }
140: return dnd.hasDND();
141: }
142:
143: @Override
144: public int getDragOperations() {
145: return dnd.getDragOperations();
146: }
147:
148: @Override
149: public Transfer[] getDragTransferTypes() {
150: return dnd.getDragTransferTypes();
151: }
152:
153: @Override
154: public DragSourceListener getDragListener(TreeViewer treeViewer) {
155: return dnd.getDragListener(treeViewer);
156: }
157:
158: @Override
159: public int getDropOperations() {
160: return dnd.getDropOperations();
161: }
162:
163: @Override
164: public Transfer[] getDropTransferTypes() {
165: return dnd.getDropTransferTypes();
166: }
167:
168: @Override
169: public DropTargetListener getDropListener(EditingDomain editingDomain, TreeViewer treeViewer) {
170: return dnd.getDropListener(editingDomain, treeViewer);
171: }
172:
173: @Override
174: public IContentProvider getContentProvider() {
175: return contentProvider.getContentProvider();
176: }
177:
178: @Override
179: public IBaseLabelProvider getLabelProvider() {
180: return labelProvider.getLabelProvider();
181: }
182:
183: @Override
184: public Optional<ILabelDecorator> getLabelDecorator(TreeViewer viewer) {
185: return decorator.getLabelDecorator(viewer);
186: }
187:
188: @Override
189: public ViewerFilter[] getViewerFilters() {
190: return filters.getViewerFilters();
191: }
192:
193: @Override
194: public EObject getInitialSelection(Object input) {
195: return selection.getInitialSelection(input);
196: }
197:
198: @Override
199: public Menu getMenu(TreeViewer treeViewer, EditingDomain editingDomain) {
200: if (readOnly) {
201: return null;
202: }
203: return menu.getMenu(treeViewer, editingDomain);
204: }
205:
206: @Override
207: public void dispose() {
208: decorator.dispose();
209: contentProvider.dispose();
210: labelProvider.dispose();
211: if (adapterFactoryContentProvider != null) {
212: adapterFactoryContentProvider.dispose();
213: }
214: if (adapterFactory != null) {
215: adapterFactory.dispose();
216: }
217: }
218:
219: /**
220: * Sets the content provider provider.
221: *
222: * @param contentProvider the content provider
223: */
224: public void setContentProvider(ContentProviderProvider contentProvider) {
225: this.contentProvider = contentProvider;
226: }
227:
228: /**
229: * Sets the d&d support.
230: *
231: * @param dnd the dnd
232: */
233: public void setDragAndDrop(DNDProvider dnd) {
234: this.dnd = dnd;
235: }
236:
237: /**
238: * Sets the label provider provider.
239: *
240: * @param labelProvider the provider
241: */
242: public void setLabelProvider(LabelProviderProvider labelProvider) {
243: this.labelProvider = labelProvider;
244: }
245:
246: /**
247: * Sets the label decorator provider.
248: *
249: * @param decorator the provider
250: */
251: public void setLabelDecorator(LabelDecoratorProvider decorator) {
252: this.decorator = decorator;
253: }
254:
255: /**
256: * Sets the menu provider.
257: *
258: * @param menu the provider
259: */
260: public void setMenu(MenuProvider menu) {
261: this.menu = menu;
262: }
263:
264: /**
265: * Sets the right click actions of the menu.
266: *
267: * @param rightClickActions the actions
268: */
269: public void customizeMenu(Collection<MasterDetailAction> rightClickActions) {
270: if (!DefaultMenuProvider.class.isInstance(menu)) {
271: menu = new DefaultMenuProvider();
272: }
273: final DefaultMenuProvider defaultMenuProvider = DefaultMenuProvider.class.cast(menu);
274: defaultMenuProvider.setRightClickAction(rightClickActions);
275: }
276:
277: /**
278: * Sets the {@link CreateElementCallback}.
279: *
280: * @param createElementCallback the callback
281: */
282: public void customizeMenu(CreateElementCallback createElementCallback) {
283: if (!DefaultMenuProvider.class.isInstance(menu)) {
284: menu = new DefaultMenuProvider();
285: }
286: final DefaultMenuProvider defaultMenuProvider = DefaultMenuProvider.class.cast(menu);
287: defaultMenuProvider.setCreateElementCallback(createElementCallback);
288: }
289:
290: /**
291: * Sets the delete action.
292: *
293: * @param deleteActionBuilder the builder
294: */
295: public void customizeMenu(DeleteActionBuilder deleteActionBuilder) {
296: if (!DefaultMenuProvider.class.isInstance(menu)) {
297: menu = new DefaultMenuProvider();
298: }
299: final DefaultMenuProvider defaultMenuProvider = DefaultMenuProvider.class.cast(menu);
300: defaultMenuProvider.setDeleteAction(deleteActionBuilder);
301: }
302:
303: /**
304: * Sets the initial selection provider.
305: *
306: * @param selection the provider
307: */
308: public void setInitialSelection(InitialSelectionProvider selection) {
309: this.selection = selection;
310: }
311:
312: /**
313: * Sets the tree builder.
314: *
315: * @param tree the tree builder
316: */
317: public void setTree(TreeViewerBuilder tree) {
318: this.tree = tree;
319: }
320:
321: /**
322: * Sets the viewer filter provider.
323: *
324: * @param filters the provider
325: */
326: public void setViewerFilters(ViewerFilterProvider filters) {
327: this.filters = filters;
328: }
329:
330: @Override
331: public boolean isReadOnly() {
332: return readOnly;
333: }
334:
335: /**
336: * Allows to set the tree as read-only. Default is false. Setting the tree as read-only has two consequences:
337: * <ol>
338: * <li>The tree's context menu is disabled
339: * <li>Drag and drop is disabled</li>
340: * </ol>
341: *
342: * @param readOnly <code>true</code> to set as read-only
343: */
344: public void setReadOnly(boolean readOnly) {
345: this.readOnly = readOnly;
346: }
347:
348: /**
349: * Provides no decorator.
350: *
351: * @author Johannes Faltermeier
352: *
353: */
354: private static final class DefaultLabelDecoratorProvider implements LabelDecoratorProvider {
355: @Override
356: public Optional<ILabelDecorator> getLabelDecorator(TreeViewer viewer) {
357: return Optional.empty();
358: }
359:
360: @Override
361: public void dispose() {
362: /* no op */
363:
364: }
365: }
366:
367: /**
368: * Default {@link ContentProviderProvider}.
369: *
370: * @author jfaltermeier
371: *
372: */
373: private final class DefaultContentProviderProvider implements ContentProviderProvider {
374: @Override
375: public IContentProvider getContentProvider() {
376: return getAdapterFactoryContentProvider();
377: }
378:
379: @Override
380: public void dispose() {
381: /* disposed by build behaviour */
382: }
383: }
384:
385: /**
386: * Default {@link LabelProviderProvider}.
387: *
388: * @author jfaltermeier
389: *
390: */
391: private final class DefaultLabelProviderProvider implements LabelProviderProvider {
392: private AdapterFactoryLabelProvider provider;
393:
394: @Override
395: public IBaseLabelProvider getLabelProvider() {
396: final ComposedAdapterFactory adapterFactory = getComposedAdapterFactory();
397: provider = new AdapterFactoryLabelProvider(adapterFactory);
398: return provider;
399: }
400:
401: @Override
402: public void dispose() {
403: /* adapter factory will be disposed by build behaviour */
404: provider.dispose();
405: }
406: }
407:
408: /**
409: * Default {@link InitialSelectionProvider}.
410: *
411: * @author jfaltermeier
412: *
413: */
414: private final class DefaultTreeMasterDetailSelectionProvider implements InitialSelectionProvider {
415: @Override
416: public EObject getInitialSelection(Object input) {
417: final AdapterFactoryContentProvider contentProvider = getAdapterFactoryContentProvider();
418: if (input instanceof EObject) {
419: return (EObject) input;
420: }
421: for (final Object child : contentProvider.getChildren(input)) {
422: final EObject childSelector = getInitialSelection(child);
423: if (childSelector != null) {
424: return childSelector;
425: }
426: }
427: return null;
428: }
429: }
430:
431: }