1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/*******************************************************************************
* Copyright (c) 2000, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.team.ui.operations;
import java.lang.reflect.InvocationTargetException;
import org.eclipse.core.resources.mapping.*;
import org.eclipse.core.runtime.*;
import org.eclipse.jface.window.Window;
import org.eclipse.team.core.mapping.*;
import org.eclipse.team.core.mapping.provider.ScopeGenerator;
import org.eclipse.team.internal.ui.TeamUIMessages;
import org.eclipse.team.internal.ui.dialogs.AdditionalMappingsDialog;
import org.eclipse.ui.IWorkbenchPart;
/**
* Here's a summary of the input determination scheme
* <ol>
* <li>Obtain selected mappings
* <li>Project mappings onto resources using the appropriate
* context(s) in order to obtain a set of ResourceTraverals
* <li>Determine what model providers are interested in the targeted resources
* <li>From those model providers, obtain the set of affected resource mappings
* <li>If the original set is the same as the new set, we are done.
* <li>if the set differs from the original selection, rerun the mapping process
* for any new mappings
* <ul>
* <li>Only need to query model providers for mappings for new resources
* <li>If new mappings are obtained,
* ask model provider to compress the mappings?
* <li>keep repeating until no new mappings or resources are added
* </ul>
* <li>Use model provider relationships to result?
* <li>Display the original set and the new set with an explanation
* <ul>
* <li>The original set and final set may involve mappings from
* multiple providers.
* <li>The number of providers can be reduced by assuming that
* extending models can display the elements of extended models.
* Then we are only left with conflicting models.
* <li>Could use a content provider approach a.k.a. Common Navigator
* or component based approach
* </ul>
* </ol>
*
* <p>
* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
* part of a work in progress. There is a guarantee neither that this API will
* work nor that it will remain the same. Please do not use this API without
* consulting with the Platform/Team team.
* </p>
*
* @since 3.2
*/
public abstract class ResourceMappingOperation extends ModelProviderOperation {
private static final ScopeGenerator DEFAULT_SCOPE_BUILDER = new ScopeGenerator();
private final ResourceMapping[] selectedMappings;
private final ResourceMappingContext context;
private IResourceMappingScope scope;
/**
* Create a resource mapping based operation
* @param part the workspace part from which the operation was launched
* @param input the input to the operation (which must have already been built by
* invoking <code>buildInput</code>.
*/
protected ResourceMappingOperation(IWorkbenchPart part, ResourceMapping[] selectedMappings, ResourceMappingContext context) {
super(part);
this.selectedMappings = selectedMappings;
this.context = context;
}
public void run(IProgressMonitor monitor) throws InvocationTargetException,
InterruptedException {
buildScope(monitor);
execute(monitor);
}
/**
* Adjust the input of the operation according to the selected
* resource mappings and the set of interested participants
* @param monitor a progress monitor
*/
protected void buildScope(IProgressMonitor monitor) throws InvocationTargetException {
try {
scope = getScopeBuilder().prepareScope(getJobName(), selectedMappings, context, monitor);
IResourceMappingScope inputScope = new ScopeGenerator().asInputScope(scope);
if (scope.hasAdditionalMappings()) {
// There are additional mappings so we may need to prompt
ModelProvider[] inputModelProviders = inputScope.getModelProviders();
if (scope.hasAdditonalResources()) {
// We definitely need to prompt to indicate that additional resources
promptForInputChange(monitor);
} else if (inputModelProviders.length == 1) {
// We may need to prompt depending on the nature of the additional mappings
// We need to prompt if the additional mappings are from the same model as
// the input or if they are from a model that has no relationship to the input model
String modelProviderId = inputModelProviders[0].getDescriptor().getId();
ResourceMapping[] mappings = scope.getMappings();
boolean prompt = false;
for (int i = 0; i < mappings.length; i++) {
ResourceMapping mapping = mappings[i];
if (inputScope.getTraversals(mapping) == null) {
// This mapping was not in the input
String id = mapping.getModelProviderId();
if (id.equals(modelProviderId)) {
prompt = true;
break;
} else if (isIndependantModel(modelProviderId, id)) {
prompt = true;
break;
}
}
}
if (prompt)
promptForInputChange(monitor);
} else {
// The input had mixed mappings so just prompt with the additional mappings
// TODO: Perhaps we could do better (bug 119921)
promptForInputChange(monitor);
}
}
} catch (CoreException e) {
throw new InvocationTargetException(e);
}
}
private boolean isIndependantModel(String modelProviderId, String id) {
IModelProviderDescriptor desc1 = ModelProvider.getModelProviderDescriptor(modelProviderId);
IModelProviderDescriptor desc2 = ModelProvider.getModelProviderDescriptor(id);
return !(isExtension(desc1, desc2) || isExtension(desc2, desc1));
}
/*
* Return whether the desc1 model extends the desc2 model
*/
private boolean isExtension(IModelProviderDescriptor desc1, IModelProviderDescriptor desc2) {
String[] ids = desc1.getExtendedModels();
// First check direct extension
for (int i = 0; i < ids.length; i++) {
String id = ids[i];
if (id.equals(desc2.getId())) {
return true;
}
}
// Now check for indirect extension
for (int i = 0; i < ids.length; i++) {
String id = ids[i];
IModelProviderDescriptor desc3 = ModelProvider.getModelProviderDescriptor(id);
if (isExtension(desc3, desc2)) {
return true;
}
}
return false;
}
/**
* Return the scope builder used to build the scope of this
* operation from the input mappings. This method can be
* overridden by subclasses.
* @return the scope builder used to build the scope of this
* operation from the input mappings.
*/
protected ScopeGenerator getScopeBuilder() {
return DEFAULT_SCOPE_BUILDER;
}
/**
* Prompt the user to inform them that additional resource mappings
* have been included in the operations.
* @param monitor a progress monitor
* @throws OperationCanceledException if the user choose to cancel
*/
protected void promptForInputChange(IProgressMonitor monitor) {
showAllMappings();
}
private void showAllMappings() {
final boolean[] canceled = new boolean[] { false };
getShell().getDisplay().syncExec(new Runnable() {
public void run() {
AdditionalMappingsDialog dialog = new AdditionalMappingsDialog(getShell(), TeamUIMessages.ResourceMappingOperation_0, getScope(), getContext());
int result = dialog.open();
canceled[0] = result != Window.OK;
}
});
if (canceled[0]) {
throw new OperationCanceledException();
}
}
/**
* Return the synchronization context for the operation or <code>null</code>
* if the operation doesn't have one or if it has not yet been created.
* By default, the method always returns <code>null</code>. Subclasses may override.
* @return the synchronization context for the operation or <code>null</code>
*/
protected ISynchronizationContext getContext() {
return null;
}
protected abstract void execute(IProgressMonitor monitor) throws InvocationTargetException,
InterruptedException;
public IResourceMappingScope getScope() {
return scope;
}
}
|
