|
1
|
/*******************************************************************************
|
|
2
|
* Copyright (c) 2006, 2010 IBM Corporation and others.
|
|
3
|
* All rights reserved. This program and the accompanying materials
|
|
4
|
* are made available under the terms of the Eclipse Public License v1.0
|
|
5
|
* which accompanies this distribution, and is available at
|
|
6
|
* http://www.eclipse.org/legal/epl-v10.html
|
|
7
|
*
|
|
8
|
* Contributors:
|
|
9
|
* IBM Corporation - initial API and implementation
|
|
10
|
*******************************************************************************/
|
|
11
|
|
|
12
|
package org.eclipse.ui.internal.navigator;
|
|
13
|
|
|
14
|
import java.util.Arrays;
|
|
15
|
import java.util.Iterator;
|
|
16
|
import java.util.LinkedHashSet;
|
|
17
|
import java.util.Set;
|
|
18
|
|
|
19
|
import org.eclipse.core.runtime.SafeRunner;
|
|
20
|
import org.eclipse.jface.viewers.TreePath;
|
|
21
|
import org.eclipse.osgi.util.NLS;
|
|
22
|
|
|
23
|
import org.eclipse.ui.internal.navigator.extensions.NavigatorContentDescriptor;
|
|
24
|
import org.eclipse.ui.internal.navigator.extensions.NavigatorContentExtension;
|
|
25
|
import org.eclipse.ui.navigator.INavigatorContentDescriptor;
|
|
26
|
import org.eclipse.ui.navigator.INavigatorPipelineService;
|
|
27
|
import org.eclipse.ui.navigator.IPipelinedTreeContentProvider;
|
|
28
|
import org.eclipse.ui.navigator.PipelinedShapeModification;
|
|
29
|
import org.eclipse.ui.navigator.PipelinedViewerUpdate;
|
|
30
|
|
|
31
|
/**
|
|
32
|
* @since 3.2
|
|
33
|
*
|
|
34
|
*/
|
|
35
|
public class NavigatorPipelineService implements INavigatorPipelineService {
|
|
36
|
|
|
37
|
private NavigatorContentService contentService;
|
|
38
|
|
|
39
|
/**
|
|
40
|
* Create a pipeline assistant for the given content service.
|
|
41
|
*
|
|
42
|
* @param aContentService
|
|
43
|
* The content service that will drive this pipeline assistant.
|
|
44
|
*/
|
|
45
|
public NavigatorPipelineService(NavigatorContentService aContentService) {
|
|
46
|
contentService = aContentService;
|
|
47
|
}
|
|
48
|
|
|
49
|
public PipelinedShapeModification interceptAdd(
|
|
50
|
PipelinedShapeModification anAddModification) {
|
|
51
|
|
|
52
|
ContributorTrackingSet trackedSet =(ContributorTrackingSet) anAddModification.getChildren();
|
|
53
|
|
|
54
|
Set contentDescriptors = contentService.findDescriptorsByTriggerPoint(anAddModification.getParent(), !NavigatorContentService.CONSIDER_OVERRIDES);
|
|
55
|
|
|
56
|
|
|
57
|
for (Iterator descriptorsItr = contentDescriptors.iterator(); descriptorsItr.hasNext();) {
|
|
58
|
INavigatorContentDescriptor descriptor = (INavigatorContentDescriptor) descriptorsItr.next();
|
|
59
|
pipelineInterceptAdd(anAddModification, trackedSet, descriptor);
|
|
60
|
}
|
|
61
|
return anAddModification;
|
|
62
|
}
|
|
63
|
|
|
64
|
private void pipelineInterceptAdd(final PipelinedShapeModification anAddModification,
|
|
65
|
final ContributorTrackingSet trackedSet, final INavigatorContentDescriptor descriptor) {
|
|
66
|
if (descriptor.hasOverridingExtensions()) {
|
|
67
|
Set overridingDescriptors = descriptor.getOverriddingExtensions();
|
|
68
|
for (Iterator overridingDescriptorsItr = overridingDescriptors.iterator(); overridingDescriptorsItr
|
|
69
|
.hasNext();) {
|
|
70
|
INavigatorContentDescriptor overridingDescriptor = (INavigatorContentDescriptor) overridingDescriptorsItr
|
|
71
|
.next();
|
|
72
|
if (contentService.isVisible(overridingDescriptor.getId())
|
|
73
|
&& contentService.isActive(overridingDescriptor.getId())) {
|
|
74
|
trackedSet.setContributor((NavigatorContentDescriptor) overridingDescriptor,
|
|
75
|
(NavigatorContentDescriptor) descriptor);
|
|
76
|
final NavigatorContentExtension extension = contentService
|
|
77
|
.getExtension(overridingDescriptor);
|
|
78
|
if (extension.internalGetContentProvider().isPipelined()) {
|
|
79
|
SafeRunner.run(new NavigatorSafeRunnable() {
|
|
80
|
public void run() throws Exception {
|
|
81
|
((IPipelinedTreeContentProvider) extension
|
|
82
|
.internalGetContentProvider())
|
|
83
|
.interceptAdd(anAddModification);
|
|
84
|
}
|
|
85
|
|
|
86
|
public void handleException(Throwable e) {
|
|
87
|
NavigatorPlugin.logError(0, NLS.bind(
|
|
88
|
CommonNavigatorMessages.Exception_Invoking_Extension,
|
|
89
|
new Object[] { extension.getDescriptor().getId(), null }),
|
|
90
|
e);
|
|
91
|
}
|
|
92
|
});
|
|
93
|
}
|
|
94
|
trackedSet.setContributor(null, null);
|
|
95
|
pipelineInterceptAdd(anAddModification, trackedSet, overridingDescriptor);
|
|
96
|
}
|
|
97
|
}
|
|
98
|
}
|
|
99
|
}
|
|
100
|
|
|
101
|
public PipelinedShapeModification interceptRemove(
|
|
102
|
PipelinedShapeModification aRemoveModification) {
|
|
103
|
|
|
104
|
ContributorTrackingSet trackedSet =(ContributorTrackingSet) aRemoveModification.getChildren();
|
|
105
|
|
|
106
|
Set interestedExtensions = new LinkedHashSet();
|
|
107
|
for (Iterator iter = trackedSet.iterator(); iter.hasNext();) {
|
|
108
|
Object element = (Object) iter.next();
|
|
109
|
if(element instanceof TreePath) {
|
|
110
|
interestedExtensions.addAll(contentService.findOverrideableContentExtensionsForPossibleChild(((TreePath)element).getLastSegment()));
|
|
111
|
} else {
|
|
112
|
interestedExtensions = contentService.findOverrideableContentExtensionsForPossibleChild(element);
|
|
113
|
|
|
114
|
}
|
|
115
|
}
|
|
116
|
for (Iterator overridingExtensionsIter = interestedExtensions.iterator(); overridingExtensionsIter.hasNext();)
|
|
117
|
pipelineInterceptRemove(aRemoveModification, trackedSet, (NavigatorContentExtension) overridingExtensionsIter.next());
|
|
118
|
return aRemoveModification;
|
|
119
|
}
|
|
120
|
|
|
121
|
private void pipelineInterceptRemove(final PipelinedShapeModification aRemoveModification,
|
|
122
|
final ContributorTrackingSet trackedSet,
|
|
123
|
final NavigatorContentExtension overrideableExtension) {
|
|
124
|
|
|
125
|
final Set overridingExtensions = new LinkedHashSet();
|
|
126
|
overridingExtensions.addAll(Arrays.asList(overrideableExtension
|
|
127
|
.getOverridingExtensions()));
|
|
128
|
|
|
129
|
for (Iterator extensionsItr = overridingExtensions.iterator(); extensionsItr
|
|
130
|
.hasNext();) {
|
|
131
|
final NavigatorContentExtension overridingExtension = (NavigatorContentExtension) extensionsItr
|
|
132
|
.next();
|
|
133
|
trackedSet.setContributor((NavigatorContentDescriptor) overridingExtension
|
|
134
|
.getDescriptor(), null);
|
|
135
|
if (overridingExtension.internalGetContentProvider().isPipelined()) {
|
|
136
|
SafeRunner.run(new NavigatorSafeRunnable() {
|
|
137
|
public void run() throws Exception {
|
|
138
|
((IPipelinedTreeContentProvider) overridingExtension
|
|
139
|
.internalGetContentProvider()).interceptRemove(aRemoveModification);
|
|
140
|
}
|
|
141
|
|
|
142
|
public void handleException(Throwable e) {
|
|
143
|
NavigatorPlugin.logError(0, NLS.bind(
|
|
144
|
CommonNavigatorMessages.Exception_Invoking_Extension, new Object[] {
|
|
145
|
overridingExtension.getDescriptor().getId(), null }), e);
|
|
146
|
}
|
|
147
|
});
|
|
148
|
}
|
|
149
|
trackedSet.setContributor(null, null);
|
|
150
|
if (overridingExtension.getDescriptor().hasOverridingExtensions())
|
|
151
|
pipelineInterceptRemove(aRemoveModification, trackedSet, overridingExtension);
|
|
152
|
}
|
|
153
|
|
|
154
|
}
|
|
155
|
|
|
156
|
public boolean interceptRefresh(
|
|
157
|
PipelinedViewerUpdate aRefreshSynchronization) {
|
|
158
|
|
|
159
|
boolean pipelined = false;
|
|
160
|
Object refreshable = null;
|
|
161
|
Set overrideableExtensions = new LinkedHashSet();
|
|
162
|
for (Iterator iter = aRefreshSynchronization.getRefreshTargets().iterator(); iter.hasNext();) {
|
|
163
|
refreshable = iter.next();
|
|
164
|
overrideableExtensions.addAll(contentService.findOverrideableContentExtensionsForPossibleChild(refreshable));
|
|
165
|
}
|
|
166
|
for (Iterator overrideableExtensionItr = overrideableExtensions.iterator(); overrideableExtensionItr.hasNext();) {
|
|
167
|
pipelined |= pipelineInterceptRefresh((NavigatorContentExtension) overrideableExtensionItr.next(), aRefreshSynchronization, refreshable);
|
|
168
|
}
|
|
169
|
|
|
170
|
return pipelined;
|
|
171
|
|
|
172
|
}
|
|
173
|
|
|
174
|
private boolean pipelineInterceptRefresh(final NavigatorContentExtension overrideableExtension,
|
|
175
|
final PipelinedViewerUpdate aRefreshSynchronization, final Object refreshable) {
|
|
176
|
|
|
177
|
final boolean[] intercepted = new boolean[1];
|
|
178
|
|
|
179
|
final NavigatorContentExtension[] overridingExtensions = overrideableExtension
|
|
180
|
.getOverridingExtensions();
|
|
181
|
for (int i = 0; i < overridingExtensions.length; i++) {
|
|
182
|
final NavigatorContentExtension nceLocal = overridingExtensions[i];
|
|
183
|
if (nceLocal.internalGetContentProvider().isPipelined()) {
|
|
184
|
SafeRunner.run(new NavigatorSafeRunnable() {
|
|
185
|
public void run() throws Exception {
|
|
186
|
intercepted[0] |= ((IPipelinedTreeContentProvider) nceLocal
|
|
187
|
.internalGetContentProvider())
|
|
188
|
.interceptRefresh(aRefreshSynchronization);
|
|
189
|
|
|
190
|
if (nceLocal.getDescriptor().hasOverridingExtensions())
|
|
191
|
intercepted[0] |= pipelineInterceptRefresh(nceLocal,
|
|
192
|
aRefreshSynchronization, refreshable);
|
|
193
|
}
|
|
194
|
|
|
195
|
public void handleException(Throwable e) {
|
|
196
|
NavigatorPlugin.logError(0, NLS.bind(
|
|
197
|
CommonNavigatorMessages.Exception_Invoking_Extension, new Object[] {
|
|
198
|
nceLocal.getDescriptor().getId(), refreshable }), e);
|
|
199
|
}
|
|
200
|
});
|
|
201
|
}
|
|
202
|
}
|
|
203
|
|
|
204
|
return intercepted[0];
|
|
205
|
}
|
|
206
|
|
|
207
|
public boolean interceptUpdate(
|
|
208
|
PipelinedViewerUpdate anUpdateSynchronization) {
|
|
209
|
|
|
210
|
boolean pipelined = false;
|
|
211
|
Object refreshable = null;
|
|
212
|
|
|
213
|
Set overrideableExtensions = new LinkedHashSet();
|
|
214
|
for (Iterator iter = anUpdateSynchronization.getRefreshTargets().iterator(); iter.hasNext();) {
|
|
215
|
refreshable = iter.next();
|
|
216
|
overrideableExtensions.addAll(contentService.findOverrideableContentExtensionsForPossibleChild(refreshable));
|
|
217
|
}
|
|
218
|
for (Iterator overrideableExtensionItr = overrideableExtensions.iterator(); overrideableExtensionItr.hasNext();) {
|
|
219
|
pipelined |= pipelineInterceptUpdate((NavigatorContentExtension) overrideableExtensionItr.next(), anUpdateSynchronization, refreshable);
|
|
220
|
}
|
|
221
|
|
|
222
|
return pipelined;
|
|
223
|
|
|
224
|
}
|
|
225
|
|
|
226
|
private boolean pipelineInterceptUpdate(final NavigatorContentExtension overrideableExtension,
|
|
227
|
final PipelinedViewerUpdate anUpdateSynchronization, final Object refreshable) {
|
|
228
|
|
|
229
|
final boolean[] intercepted = new boolean[1];
|
|
230
|
final NavigatorContentExtension[] overridingExtensions = overrideableExtension
|
|
231
|
.getOverridingExtensions();
|
|
232
|
for (int i = 0; i < overridingExtensions.length; i++) {
|
|
233
|
if (overridingExtensions[i].internalGetContentProvider().isPipelined()) {
|
|
234
|
final NavigatorContentExtension nceLocal = overridingExtensions[i];
|
|
235
|
SafeRunner.run(new NavigatorSafeRunnable() {
|
|
236
|
public void run() throws Exception {
|
|
237
|
intercepted[0] |= ((IPipelinedTreeContentProvider) nceLocal
|
|
238
|
.internalGetContentProvider())
|
|
239
|
.interceptUpdate(anUpdateSynchronization);
|
|
240
|
|
|
241
|
if (nceLocal.getDescriptor().hasOverridingExtensions())
|
|
242
|
intercepted[0] |= pipelineInterceptUpdate(nceLocal,
|
|
243
|
anUpdateSynchronization, refreshable);
|
|
244
|
}
|
|
245
|
|
|
246
|
public void handleException(Throwable e) {
|
|
247
|
NavigatorPlugin.logError(0, NLS.bind(
|
|
248
|
CommonNavigatorMessages.Exception_Invoking_Extension, new Object[] {
|
|
249
|
nceLocal.getDescriptor().getId(), refreshable }), e);
|
|
250
|
}
|
|
251
|
});
|
|
252
|
|
|
253
|
}
|
|
254
|
}
|
|
255
|
|
|
256
|
return intercepted[0];
|
|
257
|
}
|
|
258
|
|
|
259
|
}
|