001: /*******************************************************************************
002: * Copyright (c) 2000, 2007 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.internal.ui.browsing;
011:
012: import java.util.List;
013:
014: import org.eclipse.core.runtime.Assert;
015: import org.eclipse.core.runtime.ListenerList;
016:
017: import org.eclipse.swt.events.HelpListener;
018: import org.eclipse.swt.widgets.Control;
019: import org.eclipse.swt.widgets.Item;
020: import org.eclipse.swt.widgets.Widget;
021:
022: import org.eclipse.jface.viewers.IBaseLabelProvider;
023: import org.eclipse.jface.viewers.IContentProvider;
024: import org.eclipse.jface.viewers.IDoubleClickListener;
025: import org.eclipse.jface.viewers.IOpenListener;
026: import org.eclipse.jface.viewers.ISelection;
027: import org.eclipse.jface.viewers.ISelectionChangedListener;
028: import org.eclipse.jface.viewers.IStructuredSelection;
029: import org.eclipse.jface.viewers.StructuredSelection;
030: import org.eclipse.jface.viewers.StructuredViewer;
031: import org.eclipse.jface.viewers.ViewerComparator;
032: import org.eclipse.jface.viewers.ViewerFilter;
033: import org.eclipse.jface.viewers.ViewerSorter;
034:
035: import org.eclipse.jdt.core.IPackageFragment;
036:
037: /**
038: * Wrapper who transfers listeners and filters and to which clients
039: * can refer.
040: *
041: * @deprecated needs to be replaced by a manager who handles transfer of listeners and filters
042: */
043: class PackageViewerWrapper extends StructuredViewer {
044:
045: private StructuredViewer fViewer;
046: private ListenerList fListenerList;
047: private ListenerList fSelectionChangedListenerList;
048: private ListenerList fPostSelectionChangedListenerList;
049:
050: public PackageViewerWrapper() {
051: fListenerList = new ListenerList(ListenerList.IDENTITY);
052: fPostSelectionChangedListenerList = new ListenerList(
053: ListenerList.IDENTITY);
054: fSelectionChangedListenerList = new ListenerList(
055: ListenerList.IDENTITY);
056: }
057:
058: public void setViewer(StructuredViewer viewer) {
059: Assert.isNotNull(viewer);
060:
061: StructuredViewer oldViewer = fViewer;
062: fViewer = viewer;
063:
064: if (fViewer.getContentProvider() != null)
065: super .setContentProvider(fViewer.getContentProvider());
066: transferFilters(oldViewer);
067: transferListeners();
068: }
069:
070: StructuredViewer getViewer() {
071: return fViewer;
072: }
073:
074: private void transferFilters(StructuredViewer oldViewer) {
075: //set filters
076: if (oldViewer != null) {
077: ViewerFilter[] filters = oldViewer.getFilters();
078: for (int i = 0; i < filters.length; i++) {
079: ViewerFilter filter = filters[i];
080: fViewer.addFilter(filter);
081: }
082: }
083: }
084:
085: private void transferListeners() {
086:
087: Object[] listeners = fPostSelectionChangedListenerList
088: .getListeners();
089: for (int i = 0; i < listeners.length; i++) {
090: Object object = listeners[i];
091: ISelectionChangedListener listener = (ISelectionChangedListener) object;
092: fViewer.addPostSelectionChangedListener(listener);
093: }
094:
095: listeners = fSelectionChangedListenerList.getListeners();
096: for (int i = 0; i < listeners.length; i++) {
097: Object object = listeners[i];
098: ISelectionChangedListener listener = (ISelectionChangedListener) object;
099: fViewer.addSelectionChangedListener(listener);
100: }
101:
102: // Add all other listeners
103: listeners = fListenerList.getListeners();
104: for (int i = 0; i < listeners.length; i++) {
105: Object object = listeners[i];
106:
107: if (object instanceof IOpenListener) {
108: IOpenListener listener = (IOpenListener) object;
109: addOpenListener(listener);
110: } else if (object instanceof HelpListener) {
111: HelpListener listener = (HelpListener) object;
112: addHelpListener(listener);
113: } else if (object instanceof IDoubleClickListener) {
114: IDoubleClickListener listener = (IDoubleClickListener) object;
115: addDoubleClickListener(listener);
116: }
117: }
118: }
119:
120: public void setSelection(ISelection selection, boolean reveal) {
121: if (selection instanceof IStructuredSelection) {
122: IStructuredSelection sel = (IStructuredSelection) selection;
123:
124: //try and give the two a common super class
125: IContentProvider provider = getContentProvider();
126: if (provider instanceof LogicalPackagesProvider) {
127: LogicalPackagesProvider fprovider = (LogicalPackagesProvider) provider;
128:
129: Object object = sel.getFirstElement();
130: if (object instanceof IPackageFragment) {
131: IPackageFragment pkgFragment = (IPackageFragment) object;
132: LogicalPackage logicalPkg = fprovider
133: .findLogicalPackage(pkgFragment);
134: if (logicalPkg != null)
135: object = logicalPkg;
136: else
137: object = pkgFragment;
138: }
139: if (object != null)
140: fViewer.setSelection(
141: new StructuredSelection(object), reveal);
142: else
143: fViewer.setSelection(StructuredSelection.EMPTY,
144: reveal);
145: }
146: } else
147: fViewer.setSelection(selection, reveal);
148: }
149:
150: public void addPostSelectionChangedListener(
151: ISelectionChangedListener listener) {
152: fPostSelectionChangedListenerList.add(listener);
153: fViewer.addPostSelectionChangedListener(listener);
154: }
155:
156: public void addSelectionChangedListener(
157: ISelectionChangedListener listener) {
158: fSelectionChangedListenerList.add(listener);
159: fViewer.addSelectionChangedListener(listener);
160: }
161:
162: public void addDoubleClickListener(IDoubleClickListener listener) {
163: fViewer.addDoubleClickListener(listener);
164: fListenerList.add(listener);
165: }
166:
167: public void addOpenListener(IOpenListener listener) {
168: fViewer.addOpenListener(listener);
169: fListenerList.add(listener);
170: }
171:
172: public void addHelpListener(HelpListener listener) {
173: fViewer.addHelpListener(listener);
174: fListenerList.add(listener);
175: }
176:
177: public void removeSelectionChangedListener(
178: ISelectionChangedListener listener) {
179: fViewer.removeSelectionChangedListener(listener);
180: fSelectionChangedListenerList.remove(listener);
181: }
182:
183: public void removePostSelectionChangedListener(
184: ISelectionChangedListener listener) {
185: fViewer.removePostSelectionChangedListener(listener);
186: fPostSelectionChangedListenerList.remove(listener);
187: }
188:
189: public void removeHelpListener(HelpListener listener) {
190: fListenerList.remove(listener);
191: fViewer.removeHelpListener(listener);
192: }
193:
194: public void removeDoubleClickListener(IDoubleClickListener listener) {
195: fViewer.removeDoubleClickListener(listener);
196: fListenerList.remove(listener);
197: }
198:
199: public void removeOpenListener(IOpenListener listener) {
200: fViewer.removeOpenListener(listener);
201: fListenerList.remove(listener);
202: }
203:
204: // --------- simply delegate to wrapped viewer ---------
205: public Control getControl() {
206: return fViewer.getControl();
207: }
208:
209: public void addFilter(ViewerFilter filter) {
210: fViewer.addFilter(filter);
211: }
212:
213: public void setFilters(ViewerFilter[] filters) {
214: fViewer.setFilters(filters);
215: }
216:
217: public void refresh() {
218: fViewer.refresh();
219: }
220:
221: public void removeFilter(ViewerFilter filter) {
222: fViewer.removeFilter(filter);
223: }
224:
225: public ISelection getSelection() {
226: return fViewer.getSelection();
227: }
228:
229: public void refresh(boolean updateLabels) {
230: fViewer.refresh(updateLabels);
231: }
232:
233: public void refresh(Object element, boolean updateLabels) {
234: fViewer.refresh(element, updateLabels);
235: }
236:
237: public void refresh(Object element) {
238: fViewer.refresh(element);
239: }
240:
241: public void resetFilters() {
242: fViewer.resetFilters();
243: }
244:
245: public void reveal(Object element) {
246: fViewer.reveal(element);
247: }
248:
249: public void setContentProvider(IContentProvider contentProvider) {
250: fViewer.setContentProvider(contentProvider);
251: }
252:
253: public void setSorter(ViewerSorter sorter) {
254: fViewer.setSorter(sorter);
255: }
256:
257: public void setComparator(ViewerComparator comparator) {
258: fViewer.setComparator(comparator);
259: }
260:
261: public void setUseHashlookup(boolean enable) {
262: fViewer.setUseHashlookup(enable);
263: }
264:
265: public Widget testFindItem(Object element) {
266: return fViewer.testFindItem(element);
267: }
268:
269: public void update(Object element, String[] properties) {
270: fViewer.update(element, properties);
271: }
272:
273: public void update(Object[] elements, String[] properties) {
274: fViewer.update(elements, properties);
275: }
276:
277: public IContentProvider getContentProvider() {
278: return fViewer.getContentProvider();
279: }
280:
281: public Object getInput() {
282: return fViewer.getInput();
283: }
284:
285: public IBaseLabelProvider getLabelProvider() {
286: return fViewer.getLabelProvider();
287: }
288:
289: public void setLabelProvider(IBaseLabelProvider labelProvider) {
290: fViewer.setLabelProvider(labelProvider);
291: }
292:
293: public Object getData(String key) {
294: return fViewer.getData(key);
295: }
296:
297: public Item scrollDown(int x, int y) {
298: return fViewer.scrollDown(x, y);
299: }
300:
301: public Item scrollUp(int x, int y) {
302: return fViewer.scrollUp(x, y);
303: }
304:
305: public void setData(String key, Object value) {
306: fViewer.setData(key, value);
307: }
308:
309: public void setSelection(ISelection selection) {
310: fViewer.setSelection(selection);
311: }
312:
313: public boolean equals(Object obj) {
314: return fViewer.equals(obj);
315: }
316:
317: public int hashCode() {
318: return fViewer.hashCode();
319: }
320:
321: public String toString() {
322: return fViewer.toString();
323: }
324:
325: public void setViewerInput(Object input) {
326: fViewer.setInput(input);
327: }
328:
329: // need to provide implementation for abstract methods
330: protected Widget doFindInputItem(Object element) {
331: return ((IPackagesViewViewer) fViewer).doFindInputItem(element);
332: }
333:
334: protected Widget doFindItem(Object element) {
335: return ((IPackagesViewViewer) fViewer).doFindItem(element);
336: }
337:
338: protected void doUpdateItem(Widget item, Object element,
339: boolean fullMap) {
340: ((IPackagesViewViewer) fViewer).doUpdateItem(item, element,
341: fullMap);
342: }
343:
344: protected List getSelectionFromWidget() {
345: return ((IPackagesViewViewer) fViewer).getSelectionFromWidget();
346: }
347:
348: protected void internalRefresh(Object element) {
349: ((IPackagesViewViewer) fViewer).internalRefresh(element);
350: }
351:
352: protected void setSelectionToWidget(List l, boolean reveal) {
353: ((IPackagesViewViewer) fViewer).setSelectionToWidget(l, reveal);
354: }
355:
356: }
|