|
1
11
12 package org.eclipse.jface.internal.databinding.internal.viewers;
13
14 import java.util.ArrayList  ;
15 import java.util.Collection ;
16 import java.util.Collections ;
17 import java.util.HashSet ;
18 import java.util.Iterator ;
19 import java.util.List ;
20 import java.util.Set ;
21
22 import org.eclipse.jface.internal.databinding.provisional.observable.Diffs;
23 import org.eclipse.jface.internal.databinding.provisional.observable.list.IObservableList;
24 import org.eclipse.jface.internal.databinding.provisional.observable.list.ListDiffEntry;
25 import org.eclipse.jface.internal.databinding.provisional.observable.list.ObservableList;
26 import org.eclipse.jface.internal.databinding.provisional.observable.mapping.IMultiMapping;
27 import org.eclipse.jface.internal.databinding.provisional.observable.set.IObservableSet;
28 import org.eclipse.jface.internal.databinding.provisional.observable.set.ISetChangeListener;
29 import org.eclipse.jface.internal.databinding.provisional.observable.set.SetDiff;
30 import org.eclipse.jface.internal.databinding.provisional.viewers.IObservableCollectionWithLabels;
31 import org.eclipse.jface.viewers.IStructuredContentProvider;
32 import org.eclipse.jface.viewers.StructuredViewer;
33 import org.eclipse.jface.viewers.Viewer;
34
35
39 public abstract class StructuredViewerObservableCollectionWithLabels extends
40 ObservableList implements IObservableList, IObservableSet,
41 IObservableCollectionWithLabels {
42
43 private StructuredViewer structuredViewer;
44
45 private ContentProvider contentProvider = new ContentProvider();
46
47 private Object setChangeListeners;
48
49 private Set elementsAsSet = new HashSet ();
50
51 private class ContentProvider implements IStructuredContentProvider {
52
53 public Object [] getElements(Object inputElement) {
54 return StructuredViewerObservableCollectionWithLabels.this
55 .toArray();
56 }
57
58 public void dispose() {
59 }
60
61 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
62 }
63
64 }
65
66
69 public StructuredViewerObservableCollectionWithLabels(
70 StructuredViewer structuredViewer) {
71 super(new ArrayList (), Object .class);
72 this.structuredViewer = structuredViewer;
73 structuredViewer.setContentProvider(contentProvider);
78 structuredViewer.setInput(this);
79 }
80
81 public abstract void init(IMultiMapping labelMapping);
82
83 public abstract void updateElements(Object [] elements);
84
85 public void addSetChangeListener(ISetChangeListener listener) {
86 if (setChangeListeners == null) {
87 boolean hadListeners = hasListeners();
88 setChangeListeners = listener;
89 if (!hadListeners) {
90 firstListenerAdded();
91 }
92 return;
93 }
94
95 Collection listenerList;
96 if (setChangeListeners instanceof Collection ) {
97 listenerList = (Collection ) setChangeListeners;
98 } else {
99 ISetChangeListener l = (ISetChangeListener) setChangeListeners;
100
101 listenerList = new ArrayList ();
102 listenerList.add(l);
103 setChangeListeners = listenerList;
104 }
105
106 if (listenerList.size() > 16) {
107 HashSet listenerSet = new HashSet ();
108 listenerSet.addAll(listenerList);
109 setChangeListeners = listenerList;
110 }
111
112 listenerList.add(listener);
113 }
114
115 public void removeSetChangeListener(ISetChangeListener listener) {
116
117 if (setChangeListeners == listener) {
118 setChangeListeners = null;
119 if (!hasListeners()) {
120 lastListenerRemoved();
121 }
122 return;
123 }
124
125 if (setChangeListeners instanceof Collection ) {
126 Collection listenerList = (Collection ) setChangeListeners;
127 listenerList.remove(listener);
128 if (listenerList.size() == 0) {
129 setChangeListeners = null;
130 if (!hasListeners()) {
131 lastListenerRemoved();
132 }
133 }
134 }
135 }
136
137 protected boolean hasListeners() {
138 return super.hasListeners() || setChangeListeners != null;
139 }
140
141 protected void fireSetChange(SetDiff diff) {
142 if (setChangeListeners == null) {
143 return;
144 }
145
146 if (setChangeListeners instanceof ISetChangeListener) {
147 ((ISetChangeListener) setChangeListeners).handleSetChange(this,
148 diff);
149 return;
150 }
151
152 Collection changeListenerCollection = (Collection ) setChangeListeners;
153
154 ISetChangeListener[] listeners = (ISetChangeListener[]) (changeListenerCollection)
155 .toArray(new ISetChangeListener[changeListenerCollection.size()]);
156 for (int i = 0; i < listeners.length; i++) {
157 listeners[i].handleSetChange(this, diff);
158 }
159 }
160
161 public boolean add(Object o) {
162 boolean added = elementsAsSet.add(o);
163 if (added) {
164 wrappedList.add(o);
165 fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
166 wrappedList.size() - 1, true, o)));
167 fireSetChange(Diffs.createSetDiff(Collections.singleton(o),
168 Collections.EMPTY_SET));
169 addToViewer(o);
171 }
172 return added;
173 }
174
175 public boolean addAll(Collection c) {
176 Set adds = new HashSet ();
177 List listAdds = new ArrayList ();
178 Iterator it = c.iterator();
179 while (it.hasNext()) {
180 Object element = it.next();
181 if (elementsAsSet.add(element)) {
182 listAdds.add(Diffs.createListDiffEntry(wrappedList.size(),
183 true, element));
184 wrappedList.add(element);
185 adds.add(element);
186 }
187 }
188 if (adds.size() > 0) {
189 fireListChange(Diffs.createListDiff((ListDiffEntry[]) listAdds
190 .toArray(new ListDiffEntry[listAdds.size()])));
191 fireSetChange(Diffs.createSetDiff(adds, Collections.EMPTY_SET));
192 addToViewer(adds.toArray());
194 return true;
195 }
196 return false;
197 }
198
199 public boolean remove(Object o) {
200 boolean removed = elementsAsSet.remove(o);
201 if (removed) {
202 int indexOfElement = wrappedList.indexOf(o);
203 wrappedList.remove(indexOfElement);
204 removeFromViewer(o);
206 fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
207 indexOfElement, false, o)));
208 fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET,
209 Collections.singleton(o)));
210 }
211 return removed;
212 }
213
214 public boolean removeAll(Collection c) {
215 Set removes = new HashSet ();
216 List listRemoves = new ArrayList ();
217 Iterator it = c.iterator();
218 while (it.hasNext()) {
219 Object element = it.next();
220 if (elementsAsSet.remove(element)) {
221 int indexOfElement = wrappedList.indexOf(element);
222 wrappedList.remove(indexOfElement);
223 listRemoves.add(Diffs.createListDiffEntry(indexOfElement,
224 false, element));
225 removes.add(element);
226 }
227 }
228 if (removes.size() > 0) {
229 removeFromViewer(removes.toArray());
231 fireListChange(Diffs.createListDiff((ListDiffEntry[]) listRemoves
232 .toArray(new ListDiffEntry[listRemoves.size()])));
233 fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removes));
234 return true;
235 }
236 return false;
237 }
238
239 public boolean retainAll(Collection c) {
240 Set removes = new HashSet ();
241 List listRemoves = new ArrayList ();
242 Iterator it = wrappedList.iterator();
243 for (int index = 0; it.hasNext(); index++) {
244 Object element = it.next();
245 if (!c.contains(element)) {
246 it.remove();
247 elementsAsSet.remove(element);
248 removes.add(element);
249 listRemoves.add(Diffs
250 .createListDiffEntry(index, false, element));
251 }
252 }
253 if (removes.size() > 0) {
254 removeFromViewer(removes.toArray());
256 fireListChange(Diffs.createListDiff((ListDiffEntry[]) listRemoves
257 .toArray(new ListDiffEntry[listRemoves.size()])));
258 fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removes));
259 return true;
260 }
261 return false;
262 }
263
264 public void clear() {
265 Set removes = new HashSet (elementsAsSet);
266 List listRemoves = new ArrayList ();
267 Iterator it = wrappedList.iterator();
268 for (int index = 0; it.hasNext(); index++) {
269 Object element = it.next();
270 listRemoves.add(Diffs.createListDiffEntry(index, false, element));
271 }
272 wrappedList.clear();
273 elementsAsSet.clear();
274 structuredViewer.refresh();
276 fireListChange(Diffs.createListDiff((ListDiffEntry[]) listRemoves
277 .toArray(new ListDiffEntry[listRemoves.size()])));
278 fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removes));
279 }
280
281 public Object set(int index, Object element) {
282 Object oldObject = wrappedList.get(index);
283 elementsAsSet.remove(oldObject);
284 removeFromViewer(oldObject);
285 fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(index,
286 false, oldObject)));
287 fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, Collections
288 .singleton(oldObject)));
289 if (elementsAsSet.add(element)) {
290 wrappedList.add(index, element);
291 fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
292 index, true, element)));
293 fireSetChange(Diffs.createSetDiff(Collections.singleton(element),
294 Collections.EMPTY_SET));
295 addToViewer(index, element);
296 }
297 return oldObject;
298 }
299
300 public Object remove(int index) {
301 Object oldObject = wrappedList.remove(index);
302 elementsAsSet.remove(oldObject);
303 removeFromViewer(oldObject);
304 fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(index,
305 false, oldObject)));
306 fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, Collections
307 .singleton(oldObject)));
308 return oldObject;
309 }
310
311 public void add(int index, Object element) {
312 if (elementsAsSet.add(element)) {
313 wrappedList.add(index, element);
314 fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
315 index, true, element)));
316 fireSetChange(Diffs.createSetDiff(Collections.singleton(element),
317 Collections.EMPTY_SET));
318 addToViewer(index, element);
319 }
320 }
321
322 public boolean addAll(int index, Collection c) {
323 Set adds = new HashSet ();
324 List listAdds = new ArrayList ();
325 Iterator it = c.iterator();
326 while (it.hasNext()) {
327 Object element = it.next();
328 if (elementsAsSet.add(element)) {
329 listAdds.add(Diffs.createListDiffEntry(index, true, element));
330 wrappedList.add(index, element);
331 adds.add(element);
332 addToViewer(index, element);
333 index++;
334 }
335 }
336 if (adds.size() > 0) {
337 fireListChange(Diffs.createListDiff((ListDiffEntry[]) listAdds
338 .toArray(new ListDiffEntry[listAdds.size()])));
339 fireSetChange(Diffs.createSetDiff(adds, Collections.EMPTY_SET));
340 return true;
342 }
343 return false;
344 }
345
346 public void dispose() {
347 super.dispose();
348 wrappedList.clear();
349 structuredViewer = null;
350 contentProvider = null;
351 }
352
353 protected abstract void addToViewer(Object element);
354
355 protected abstract void addToViewer(Object [] elements);
356
357 protected abstract void addToViewer(int index, Object element);
358
359 protected abstract void removeFromViewer(Object element);
360
361 protected abstract void removeFromViewer(Object [] elements);
362
363
366 public StructuredViewer getViewer() {
367 return structuredViewer;
368 }
369
370 }
371 |
Popular Tags |
Java API By Example, From Geeks To Geeks.