/*******************************************************************************
* Copyright (c) 2000, 2008 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.jdt.internal.ui.browsing;
import java.util.List;
import org.eclipse.swt.dnd.DragSourceListener;
import org.eclipse.swt.dnd.DropTargetListener;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.HelpListener;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.jface.viewers.IBaseLabelProvider;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.IElementComparer;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.jdt.core.IPackageFragment;
/**
* Wrapper who transfers listeners and filters and to which clients
* can refer.
*
* @deprecated needs to be replaced by a manager who handles transfer of listeners and filters
*/
class PackageViewerWrapper extends StructuredViewer {
private StructuredViewer fViewer;
private ListenerList fListenerList;
private ListenerList fSelectionChangedListenerList;
private ListenerList fPostSelectionChangedListenerList;
public PackageViewerWrapper() {
fListenerList= new ListenerList(ListenerList.IDENTITY);
fPostSelectionChangedListenerList= new ListenerList(ListenerList.IDENTITY);
fSelectionChangedListenerList= new ListenerList(ListenerList.IDENTITY);
}
public void setViewer(StructuredViewer viewer) {
Assert.isNotNull(viewer);
StructuredViewer oldViewer= fViewer;
fViewer= viewer;
if (fViewer.getContentProvider() != null)
super.setContentProvider(fViewer.getContentProvider());
transferFilters(oldViewer);
transferListeners();
}
StructuredViewer getViewer(){
return fViewer;
}
private void transferFilters(StructuredViewer oldViewer) {
//set filters
if (oldViewer != null) {
ViewerFilter[] filters= oldViewer.getFilters();
for (int i= 0; i < filters.length; i++) {
ViewerFilter filter= filters[i];
fViewer.addFilter(filter);
}
}
}
private void transferListeners() {
Object[] listeners= fPostSelectionChangedListenerList.getListeners();
for (int i= 0; i < listeners.length; i++) {
Object object= listeners[i];
ISelectionChangedListener listener= (ISelectionChangedListener)object;
fViewer.addPostSelectionChangedListener(listener);
}
listeners= fSelectionChangedListenerList.getListeners();
for (int i= 0; i < listeners.length; i++) {
Object object= listeners[i];
ISelectionChangedListener listener= (ISelectionChangedListener)object;
fViewer.addSelectionChangedListener(listener);
}
// Add all other listeners
listeners= fListenerList.getListeners();
for (int i= 0; i < listeners.length; i++) {
Object object= listeners[i];
if (object instanceof IOpenListener) {
IOpenListener listener= (IOpenListener) object;
addOpenListener(listener);
} else if (object instanceof HelpListener) {
HelpListener listener= (HelpListener) object;
addHelpListener(listener);
} else if (object instanceof IDoubleClickListener) {
IDoubleClickListener listener= (IDoubleClickListener) object;
addDoubleClickListener(listener);
}
}
}
public void setSelection(ISelection selection, boolean reveal) {
if (selection instanceof IStructuredSelection) {
IStructuredSelection sel= (IStructuredSelection) selection;
//try and give the two a common super class
IContentProvider provider= getContentProvider();
if (provider instanceof LogicalPackagesProvider) {
LogicalPackagesProvider fprovider= (LogicalPackagesProvider) provider;
Object object= sel.getFirstElement();
if (object instanceof IPackageFragment) {
IPackageFragment pkgFragment= (IPackageFragment)object;
LogicalPackage logicalPkg= fprovider.findLogicalPackage(pkgFragment);
if (logicalPkg != null)
object= logicalPkg;
else
object= pkgFragment;
}
if (object != null)
fViewer.setSelection(new StructuredSelection(object), reveal);
else
fViewer.setSelection(StructuredSelection.EMPTY, reveal);
}
} else
fViewer.setSelection(selection, reveal);
}
public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
fPostSelectionChangedListenerList.add(listener);
fViewer.addPostSelectionChangedListener(listener);
}
public void addSelectionChangedListener(ISelectionChangedListener listener) {
fSelectionChangedListenerList.add(listener);
fViewer.addSelectionChangedListener(listener);
}
public void addDoubleClickListener(IDoubleClickListener listener) {
fViewer.addDoubleClickListener(listener);
fListenerList.add(listener);
}
public void addOpenListener(IOpenListener listener) {
fViewer.addOpenListener(listener);
fListenerList.add(listener);
}
public void addHelpListener(HelpListener listener) {
fViewer.addHelpListener(listener);
fListenerList.add(listener);
}
public void removeSelectionChangedListener(ISelectionChangedListener listener) {
fViewer.removeSelectionChangedListener(listener);
fSelectionChangedListenerList.remove(listener);
}
public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
fViewer.removePostSelectionChangedListener(listener);
fPostSelectionChangedListenerList.remove(listener);
}
public void removeHelpListener(HelpListener listener) {
fListenerList.remove(listener);
fViewer.removeHelpListener(listener);
}
public void removeDoubleClickListener(IDoubleClickListener listener) {
fViewer.removeDoubleClickListener(listener);
fListenerList.remove(listener);
}
public void removeOpenListener(IOpenListener listener) {
fViewer.removeOpenListener(listener);
fListenerList.remove(listener);
}
// --------- simply delegate to wrapped viewer ---------
public Control getControl() {
return fViewer.getControl();
}
public void addFilter(ViewerFilter filter) {
fViewer.addFilter(filter);
}
public void setFilters(ViewerFilter[] filters) {
fViewer.setFilters(filters);
}
public ViewerFilter[] getFilters() {
return fViewer.getFilters();
}
public void refresh() {
fViewer.refresh();
}
public void removeFilter(ViewerFilter filter) {
fViewer.removeFilter(filter);
}
public ISelection getSelection() {
return fViewer.getSelection();
}
public void refresh(boolean updateLabels) {
fViewer.refresh(updateLabels);
}
public void refresh(Object element, boolean updateLabels) {
fViewer.refresh(element, updateLabels);
}
public void refresh(Object element) {
fViewer.refresh(element);
}
public void resetFilters() {
fViewer.resetFilters();
}
public void reveal(Object element) {
fViewer.reveal(element);
}
public void setContentProvider(IContentProvider contentProvider) {
fViewer.setContentProvider(contentProvider);
}
public void setSorter(ViewerSorter sorter) {
fViewer.setSorter(sorter);
}
public void setComparator(ViewerComparator comparator) {
fViewer.setComparator(comparator);
}
public void setUseHashlookup(boolean enable) {
fViewer.setUseHashlookup(enable);
}
public Widget testFindItem(Object element) {
return fViewer.testFindItem(element);
}
public void update(Object element, String[] properties) {
fViewer.update(element, properties);
}
public void update(Object[] elements, String[] properties) {
fViewer.update(elements, properties);
}
public IContentProvider getContentProvider() {
return fViewer.getContentProvider();
}
public Object getInput() {
return fViewer.getInput();
}
public IBaseLabelProvider getLabelProvider() {
return fViewer.getLabelProvider();
}
public void setLabelProvider(IBaseLabelProvider labelProvider) {
fViewer.setLabelProvider(labelProvider);
}
public Object getData(String key) {
return fViewer.getData(key);
}
public Item scrollDown(int x, int y) {
return fViewer.scrollDown(x, y);
}
public Item scrollUp(int x, int y) {
return fViewer.scrollUp(x, y);
}
public void setData(String key, Object value) {
fViewer.setData(key, value);
}
public void setSelection(ISelection selection) {
fViewer.setSelection(selection);
}
public boolean equals(Object obj) {
return fViewer.equals(obj);
}
public int hashCode() {
return fViewer.hashCode();
}
public String toString() {
return fViewer.toString();
}
public void setViewerInput(Object input){
fViewer.setInput(input);
}
// need to provide implementation for abstract methods
protected Widget doFindInputItem(Object element) {
return ((IPackagesViewViewer) fViewer).doFindInputItem(element);
}
protected Widget doFindItem(Object element) {
return ((IPackagesViewViewer)fViewer).doFindItem(element);
}
protected void doUpdateItem(Widget item, Object element, boolean fullMap) {
((IPackagesViewViewer)fViewer).doUpdateItem(item, element, fullMap);
}
protected List getSelectionFromWidget() {
return ((IPackagesViewViewer)fViewer).getSelectionFromWidget();
}
protected void internalRefresh(Object element) {
((IPackagesViewViewer)fViewer).internalRefresh(element);
}
protected void setSelectionToWidget(List l, boolean reveal) {
((IPackagesViewViewer) fViewer).setSelectionToWidget(l, reveal);
}
public ViewerComparator getComparator() {
return fViewer.getComparator();
}
public IElementComparer getComparer() {
return fViewer.getComparer();
}
public ViewerSorter getSorter() {
return fViewer.getSorter();
}
public void setComparer(IElementComparer comparer) {
fViewer.setComparer(comparer);
}
public void addDragSupport(int operations, Transfer[] transferTypes, DragSourceListener listener) {
fViewer.addDragSupport(operations, transferTypes, listener);
}
public void addDropSupport(int operations, Transfer[] transferTypes, DropTargetListener listener) {
fViewer.addDropSupport(operations, transferTypes, listener);
}
public Widget[] testFindItems(Object element) {
return fViewer.testFindItems(element);
}
}