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
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
|
/*******************************************************************************
* Copyright (c) 2000, 2004 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.team.internal.ui.synchronize;
import java.util.*;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.team.core.synchronize.*;
import org.eclipse.team.ui.synchronize.ISynchronizeModelElement;
import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
/**
* This class is reponsible for creating and maintaining a presentation model of
* {@link SynchronizeModelElement} elements that can be shown in a viewer. The model
* is based on the synchronization information contained in the provided {@link SyncInfoSet}.
* <p>
* label updates (property propagation to parent nodes)
* sync change listener (changes, additions, removals, reset)
* batching busy updates
* </p>
*
* @see HierarchicalModelProvider
* @see CompressedFoldersModelProvider
* @since 3.0
*/
public abstract class SynchronizeModelProvider extends AbstractSynchronizeModelProvider implements ISyncInfoSetChangeListener {
protected Map resourceMap = Collections.synchronizedMap(new HashMap());
protected static final boolean DEBUG = false;
public SynchronizeModelProvider(ISynchronizePageConfiguration configuration, SyncInfoSet set) {
super(configuration, set);
}
public SynchronizeModelProvider(AbstractSynchronizeModelProvider parentProvider, ISynchronizeModelElement modelRoot, ISynchronizePageConfiguration configuration, SyncInfoSet set) {
super(parentProvider, modelRoot, configuration, set);
associateRoot(modelRoot);
}
private void associateRoot(ISynchronizeModelElement modelRoot) {
// associate the root resource with the provider's root element
resourceMap.put(ResourcesPlugin.getWorkspace().getRoot(), modelRoot);
}
/**
* The provider can try and return a mapping for the provided object. Providers often use mappings
* to store the source of a logical element they have created. For example, when displaying resource
* based logical elements, a provider will cache the resource -> element mapping for quick retrieval
* of the element when resource based changes are made.
*
* @param object the object to query for a mapping
* @return an object created by this provider that would be shown in a viewer, or <code>null</code>
* if the provided object is not mapped by this provider.
*/
public Object getMapping(Object object) {
return resourceMap.get(object);
}
/**
* Dispose of the builder
*/
public void dispose() {
resourceMap.clear();
super.dispose();
}
/**
* Returns the sorter for this model provider.
*
* @return the sorter for this model provider.
*/
public abstract ViewerSorter getViewerSorter();
/**
* Return the model object (i.e. an instance of <code>SyncInfoModelElement</code>
* or one of its subclasses) for the given IResource.
* @param resource
* the resource
* @return the <code>SyncInfoModelElement</code> for the given resource
*/
protected ISynchronizeModelElement getModelObject(IResource resource) {
return (ISynchronizeModelElement) resourceMap.get(resource);
}
/* (non-Javadoc)
* @see org.eclipse.team.internal.ui.synchronize.AbstractSynchronizeModelProvider#getModelObjects(org.eclipse.core.resources.IResource)
*/
protected ISynchronizeModelElement[] getModelObjects(IResource resource) {
ISynchronizeModelElement element = getModelObject(resource);
if (element == null) {
return new ISynchronizeModelElement[0];
}
return new ISynchronizeModelElement[] { element };
}
protected void associateDiffNode(ISynchronizeModelElement node) {
IResource resource = node.getResource();
if(resource != null) {
resourceMap.put(resource, node);
}
}
protected void unassociateDiffNode(IResource resource) {
resourceMap.remove(resource);
}
/**
* Helper method to remove a resource from the viewer. If the resource
* is not mapped to a model element, this is a no-op.
* @param resource the resource to remove
*/
protected void removeFromViewer(IResource resource) {
ISynchronizeModelElement element = getModelObject(resource);
if(element != null) {
removeFromViewer(element);
}
}
/* (non-Javadoc)
* @see org.eclipse.team.internal.ui.synchronize.AbstractSynchronizeModelProvider#clearModelObjects(org.eclipse.team.ui.synchronize.ISynchronizeModelElement)
*/
protected void clearModelObjects(ISynchronizeModelElement node) {
super.clearModelObjects(node);
if (node == getModelRoot()) {
// If we are clearing everything under the root
// than just purge the resource map
resourceMap.clear();
// Reassociate the root node to allow the children to be readded
associateRoot(getModelRoot());
} else {
IResource resource = node.getResource();
if (resource != null) {
unassociateDiffNode(resource);
}
}
}
/* (non-Javadoc)
* @see org.eclipse.team.internal.ui.synchronize.AbstractSynchronizeModelProvider#addToViewer(org.eclipse.team.ui.synchronize.ISynchronizeModelElement)
*/
protected void addToViewer(ISynchronizeModelElement node) {
associateDiffNode(node);
super.addToViewer(node);
}
/* (non-Javadoc)
* @see org.eclipse.team.internal.ui.synchronize.AbstractSynchronizeModelProvider#hasViewerState()
*/
protected boolean hasViewerState() {
return ! resourceMap.isEmpty();
}
public ISynchronizeModelElement[] getClosestExistingParents(IResource resource) {
ISynchronizeModelElement element = getModelObject(resource);
if(element == null) {
do {
resource = resource.getParent();
element = getModelObject(resource);
} while(element == null && resource != null);
}
if (element == null) {
return new ISynchronizeModelElement[0];
}
return new ISynchronizeModelElement[] { element };
}
/* (non-Javadoc)
* @see org.eclipse.team.internal.ui.synchronize.AbstractSynchronizeModelProvider#handleChanges(org.eclipse.team.core.synchronize.ISyncInfoTreeChangeEvent)
*/
protected final void handleChanges(ISyncInfoTreeChangeEvent event, IProgressMonitor monitor) {
super.handleChanges(event, monitor);
}
/* (non-Javadoc)
* @see org.eclipse.team.internal.ui.synchronize.AbstractSynchronizeModelProvider#handleResourceChanges(org.eclipse.team.core.synchronize.ISyncInfoTreeChangeEvent)
*/
protected void handleResourceChanges(ISyncInfoTreeChangeEvent event) {
// Refresh the viewer for each changed resource
SyncInfo[] infos = event.getChangedResources();
for (int i = 0; i < infos.length; i++) {
SyncInfo info = infos[i];
IResource local = info.getLocal();
ISynchronizeModelElement diffNode = getModelObject(local);
if (diffNode != null) {
handleChange(diffNode, info);
}
}
}
/**
* The sync state for the existing diff node has changed and the new state
* is provided by the given sync info.
* @param diffNode the changed diff node
* @param info the new sync state
*/
protected void handleChange(ISynchronizeModelElement diffNode, SyncInfo info) {
IResource local = info.getLocal();
if(diffNode instanceof SyncInfoModelElement) {
((SyncInfoModelElement)diffNode).update(info);
propogateConflictState(diffNode, false);
queueForLabelUpdate(diffNode);
} else {
removeFromViewer(local);
addResource(info);
ISynchronizeModelElement node = getModelObject(info.getLocal());
buildModelObjects(node);
}
}
/**
* Add the give sync infos to the provider, creating
* any intermediate nodes a required.
* @param infos the added infos
*/
protected void addResources(SyncInfo[] added) {
for (int i = 0; i < added.length; i++) {
SyncInfo info = added[i];
addResource(info);
}
}
/**
* Add the give sync info to the provider, creating
* any intermediate nodes a required and adding any children as well
* @param info the added infos
*/
protected abstract void addResource(SyncInfo info);
/**
* Create the model object for the given sync info as a child of the given parent node.
* @param parent the parent
* @param info the info to be used for the new node
* @return the created node
*/
protected abstract ISynchronizeModelElement createModelObject(ISynchronizeModelElement parent, SyncInfo info);
}
|
