/*******************************************************************************
* Copyright (c) 2000, 2011 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 org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.resources.IFolder;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.ILabelDecorator;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.part.IShowInTargetList;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.corext.util.Messages;
import org.eclipse.jdt.ui.JavaElementComparator;
import org.eclipse.jdt.ui.JavaElementLabels;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.ui.PreferenceConstants;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.actions.MultiActionGroup;
import org.eclipse.jdt.internal.ui.actions.SelectAllAction;
import org.eclipse.jdt.internal.ui.filters.NonJavaElementFilter;
import org.eclipse.jdt.internal.ui.packageview.PackageExplorerPart;
import org.eclipse.jdt.internal.ui.viewsupport.DecoratingJavaLabelProvider;
import org.eclipse.jdt.internal.ui.viewsupport.JavaUILabelProvider;
import org.eclipse.jdt.internal.ui.viewsupport.LibraryFilter;
import org.eclipse.jdt.internal.ui.viewsupport.ProblemTableViewer;
import org.eclipse.jdt.internal.ui.viewsupport.ProblemTreeViewer;
import org.eclipse.jdt.internal.ui.viewsupport.StatusBarUpdater;
public class PackagesView extends JavaBrowsingPart{
private static final String TAG_VIEW_STATE= ".viewState"; //$NON-NLS-1$
private static final int LIST_VIEW_STATE= 0;
private static final int TREE_VIEW_STATE= 1;
private static class StatusBarUpdater4LogicalPackage extends StatusBarUpdater {
private StatusBarUpdater4LogicalPackage(IStatusLineManager statusLineManager) {
super(statusLineManager);
}
@Override
protected String formatMessage(ISelection sel) {
if (sel instanceof IStructuredSelection) {
IStructuredSelection selection= (IStructuredSelection)sel;
int nElements= selection.size();
Object elem= selection.getFirstElement();
if (nElements == 1 && (elem instanceof LogicalPackage))
return formatLogicalPackageMessage((LogicalPackage) elem);
}
return super.formatMessage(sel);
}
private String formatLogicalPackageMessage(LogicalPackage logicalPackage) {
IPackageFragment[] fragments= logicalPackage.getFragments();
StringBuffer buf= new StringBuffer(logicalPackage.getElementName());
buf.append(JavaElementLabels.CONCAT_STRING);
String message= ""; //$NON-NLS-1$
boolean firstTime= true;
for (int i= 0; i < fragments.length; i++) {
IPackageFragment fragment= fragments[i];
IJavaElement element= fragment.getParent();
if (element instanceof IPackageFragmentRoot) {
IPackageFragmentRoot root= (IPackageFragmentRoot) element;
String label= JavaElementLabels.getElementLabel(root, JavaElementLabels.DEFAULT_QUALIFIED | JavaElementLabels.ROOT_QUALIFIED);
if (firstTime) {
buf.append(label);
firstTime= false;
}
else
message= Messages.format(JavaBrowsingMessages.StatusBar_concat, new String[] {message, label});
}
}
buf.append(message);
return buf.toString();
}
}
private SelectAllAction fSelectAllAction;
private int fCurrViewState;
private PackageViewerWrapper fWrappedViewer;
private MultiActionGroup fSwitchActionGroup;
private boolean fLastInputWasProject;
/**
* Adds filters the viewer of this part.
*/
@Override
protected void addFilters() {
super.addFilters();
getViewer().addFilter(createNonJavaElementFilter());
getViewer().addFilter(new LibraryFilter());
}
/**
* Creates new NonJavaElementFilter and overrides method select to allow for
* LogicalPackages.
* @return NonJavaElementFilter
*/
protected NonJavaElementFilter createNonJavaElementFilter() {
return new NonJavaElementFilter(){
@Override
public boolean select(Viewer viewer, Object parent, Object element){
return ((element instanceof IJavaElement) || (element instanceof LogicalPackage) || (element instanceof IFolder));
}
};
}
@Override
public void init(IViewSite site, IMemento memento) throws PartInitException {
super.init(site, memento);
//this must be created before all actions and filters
fWrappedViewer= new PackageViewerWrapper();
restoreLayoutState(memento);
}
private void restoreLayoutState(IMemento memento) {
if (memento == null) {
//read state from the preference store
IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
fCurrViewState= store.getInt(this.getViewSite().getId() + TAG_VIEW_STATE);
} else {
//restore from memento
Integer integer= memento.getInteger(this.getViewSite().getId() + TAG_VIEW_STATE);
if ((integer == null) || !isValidState(integer.intValue())) {
fCurrViewState= LIST_VIEW_STATE;
} else fCurrViewState= integer.intValue();
}
}
private boolean isValidState(int state) {
return (state==LIST_VIEW_STATE) || (state==TREE_VIEW_STATE);
}
/*
* @see org.eclipse.ui.IViewPart#saveState(org.eclipse.ui.IMemento)
*/
@Override
public void saveState(IMemento memento) {
super.saveState(memento);
memento.putInteger(this.getViewSite().getId()+TAG_VIEW_STATE,fCurrViewState);
}
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#createViewer(org.eclipse.swt.widgets.Composite)
*/
@Override
protected StructuredViewer createViewer(Composite parent) {
//Creates the viewer of this part dependent on the current layout.
StructuredViewer viewer;
if(isInListState())
viewer= createTableViewer(parent);
else
viewer= createTreeViewer(parent);
fWrappedViewer.setViewer(viewer);
return fWrappedViewer;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#getAdapter(java.lang.Class)
*/
@Override
public Object getAdapter(Class key) {
if (key == IShowInTargetList.class) {
return new IShowInTargetList() {
public String[] getShowInTargetIds() {
return new String[] { JavaUI.ID_PACKAGES, JavaPlugin.ID_RES_NAV };
}
};
}
return super.getAdapter(key);
}
protected boolean isInListState() {
return fCurrViewState== LIST_VIEW_STATE;
}
private ProblemTableViewer createTableViewer(Composite parent) {
return new PackagesViewTableViewer(parent, SWT.MULTI);
}
private ProblemTreeViewer createTreeViewer(Composite parent) {
return new PackagesViewTreeViewer(parent, SWT.MULTI);
}
/**
* Overrides the createContentProvider from JavaBrowsingPart
* Creates the content provider of this part.
*/
@Override
protected IContentProvider createContentProvider() {
if(isInListState())
return new PackagesViewFlatContentProvider(fWrappedViewer.getViewer());
else return new PackagesViewHierarchicalContentProvider(fWrappedViewer.getViewer());
}
@Override
protected JavaUILabelProvider createLabelProvider() {
if(isInListState())
return createListLabelProvider();
else return createTreeLabelProvider();
}
private JavaUILabelProvider createTreeLabelProvider() {
return new PackagesViewLabelProvider(PackagesViewLabelProvider.HIERARCHICAL_VIEW_STATE);
}
private JavaUILabelProvider createListLabelProvider() {
return new PackagesViewLabelProvider(PackagesViewLabelProvider.FLAT_VIEW_STATE);
}
/**
* Returns the context ID for the Help system
*
* @return the string used as ID for the Help context
*/
@Override
protected String getHelpContextId() {
return IJavaHelpContextIds.PACKAGES_BROWSING_VIEW;
}
@Override
protected String getLinkToEditorKey() {
return PreferenceConstants.LINK_BROWSING_PACKAGES_TO_EDITOR;
}
/**
* Answers if the given <code>element</code> is a valid
* input for this part.
*
* @param element the object to test
* @return <true> if the given element is a valid input
*/
@Override
protected boolean isValidInput(Object element) {
if (element instanceof IJavaProject || (element instanceof IPackageFragmentRoot && ((IJavaElement)element).getElementName() != IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH))
try {
IJavaProject jProject= ((IJavaElement)element).getJavaProject();
if (jProject != null)
return jProject.getProject().hasNature(JavaCore.NATURE_ID);
} catch (CoreException ex) {
return false;
}
return false;
}
/**
* Answers if the given <code>element</code> is a valid
* element for this part.
*
* @param element the object to test
* @return <true> if the given element is a valid element
*/
@Override
protected boolean isValidElement(Object element) {
if (element instanceof IPackageFragment) {
IJavaElement parent= ((IPackageFragment)element).getParent();
if (parent != null)
return super.isValidElement(parent) || super.isValidElement(parent.getJavaProject());
}
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#findElementToSelect(org.eclipse.jdt.core.IJavaElement)
*/
@Override
protected IJavaElement findElementToSelect(IJavaElement je) {
if (je == null)
return null;
switch (je.getElementType()) {
case IJavaElement.PACKAGE_FRAGMENT:
return je;
case IJavaElement.COMPILATION_UNIT:
return ((ICompilationUnit)je).getParent();
case IJavaElement.CLASS_FILE:
return ((IClassFile)je).getParent();
case IJavaElement.TYPE:
return ((IType)je).getPackageFragment();
default:
return findElementToSelect(je.getParent());
}
}
/*
* @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#setInput(java.lang.Object)
*/
@Override
protected void setInput(Object input) {
setViewerWrapperInput(input);
super.updateTitle();
}
private void setViewerWrapperInput(Object input) {
fWrappedViewer.setViewerInput(input);
}
/**
* @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#fillActionBars(org.eclipse.ui.IActionBars)
*/
@Override
protected void fillActionBars(IActionBars actionBars) {
super.fillActionBars(actionBars);
fSwitchActionGroup.fillActionBars(actionBars);
}
private void setUpViewer(StructuredViewer viewer){
Assert.isTrue(viewer != null);
JavaUILabelProvider labelProvider= createLabelProvider();
viewer.setLabelProvider(createDecoratingLabelProvider(labelProvider));
viewer.setComparator(createJavaElementComparator());
viewer.setUseHashlookup(true);
createContextMenu();
//disapears when control disposed
addKeyListener();
//this methods only adds listeners to the viewer,
//these listenters disapear when the viewer is disposed
hookViewerListeners();
// Set content provider
viewer.setContentProvider(createContentProvider());
//Disposed when viewer's Control is disposed
initDragAndDrop();
}
//alter sorter to include LogicalPackages
@Override
protected JavaElementComparator createJavaElementComparator() {
return new JavaElementComparator(){
@Override
public int category(Object element) {
if (element instanceof LogicalPackage) {
LogicalPackage cp= (LogicalPackage) element;
return super.category(cp.getFragments()[0]);
} else return super.category(element);
}
@Override
public int compare(Viewer viewer, Object e1, Object e2){
if (e1 instanceof LogicalPackage) {
LogicalPackage cp= (LogicalPackage) e1;
e1= cp.getFragments()[0];
}
if (e2 instanceof LogicalPackage) {
LogicalPackage cp= (LogicalPackage) e2;
e2= cp.getFragments()[0];
}
return super.compare(viewer, e1, e2);
}
};
}
@Override
protected StatusBarUpdater createStatusBarUpdater(IStatusLineManager slManager) {
return new StatusBarUpdater4LogicalPackage(slManager);
}
protected void setSiteSelectionProvider(){
getSite().setSelectionProvider(fWrappedViewer);
}
@Override
void adjustInputAndSetSelection(Object o) {
if (!(o instanceof LogicalPackage)) {
super.adjustInputAndSetSelection(o);
return;
}
LogicalPackage lp= (LogicalPackage)o;
if (!lp.getJavaProject().equals(getInput()))
setInput(lp.getJavaProject());
setSelection(new StructuredSelection(lp), true);
}
//do the same thing as the JavaBrowsingPart but with wrapper
@Override
protected void createActions() {
super.createActions();
createSelectAllAction();
//create the switch action group
fSwitchActionGroup= createSwitchActionGroup();
}
private MultiActionGroup createSwitchActionGroup(){
LayoutAction switchToFlatViewAction= new LayoutAction(JavaBrowsingMessages.PackagesView_flatLayoutAction_label,LIST_VIEW_STATE);
LayoutAction switchToHierarchicalViewAction= new LayoutAction(JavaBrowsingMessages.PackagesView_HierarchicalLayoutAction_label, TREE_VIEW_STATE);
JavaPluginImages.setLocalImageDescriptors(switchToFlatViewAction, "flatLayout.gif"); //$NON-NLS-1$
JavaPluginImages.setLocalImageDescriptors(switchToHierarchicalViewAction, "hierarchicalLayout.gif"); //$NON-NLS-1$
return new LayoutActionGroup(new IAction[]{switchToFlatViewAction,switchToHierarchicalViewAction}, fCurrViewState);
}
private static class LayoutActionGroup extends MultiActionGroup {
LayoutActionGroup(IAction[] actions, int index) {
super(actions, index);
}
@Override
public void fillActionBars(IActionBars actionBars) {
//create new layout group
IMenuManager manager= actionBars.getMenuManager();
final IContributionItem groupMarker= new GroupMarker("layout"); //$NON-NLS-1$
manager.add(groupMarker);
IMenuManager newManager= new MenuManager(JavaBrowsingMessages.PackagesView_LayoutActionGroup_layout_label);
manager.appendToGroup("layout", newManager); //$NON-NLS-1$
super.addActions(newManager);
}
}
/**
* Switches between flat and hierarchical state.
*/
private class LayoutAction extends Action {
private int fState;
public LayoutAction(String text, int state) {
super(text, IAction.AS_RADIO_BUTTON);
fState= state;
if (state == PackagesView.LIST_VIEW_STATE)
PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IJavaHelpContextIds.LAYOUT_FLAT_ACTION);
else
PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IJavaHelpContextIds.LAYOUT_HIERARCHICAL_ACTION);
}
/*
* @see org.eclipse.jface.action.IAction#run()
*/
@Override
public void run() {
switchViewer(fState);
}
}
private void switchViewer(int state) {
//Indicate which viewer is to be used
if (fCurrViewState == state)
return;
else {
fCurrViewState= state;
IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
store.setValue(getViewSite().getId() + TAG_VIEW_STATE, state);
}
//get the information from the existing viewer
StructuredViewer viewer= fWrappedViewer.getViewer();
Object object= viewer.getInput();
ISelection selection= viewer.getSelection();
// create and set up the new viewer
Control control= createViewer(fWrappedViewer.getControl().getParent()).getControl();
setUpViewer(fWrappedViewer);
createSelectAllAction();
// add the selection information from old viewer
fWrappedViewer.setViewerInput(object);
fWrappedViewer.getControl().setFocus();
fWrappedViewer.setSelection(selection, true);
// dispose old viewer
viewer.getContentProvider().dispose();
viewer.getControl().dispose();
// layout the new viewer
if (control != null && !control.isDisposed()) {
control.setVisible(true);
control.getParent().layout(true);
}
}
private void createSelectAllAction() {
IActionBars actionBars= getViewSite().getActionBars();
if (isInListState()) {
fSelectAllAction= new SelectAllAction((TableViewer)fWrappedViewer.getViewer());
actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), fSelectAllAction);
} else {
actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), null);
fSelectAllAction= null;
}
actionBars.updateActionBars();
}
@Override
protected IJavaElement findInputForJavaElement(IJavaElement je) {
// null check has to take place here as well (not only in
// findInputForJavaElement(IJavaElement, boolean) since we
// are accessing the Java element
if (je == null)
return null;
if(je.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT || je.getElementType() == IJavaElement.JAVA_PROJECT)
return findInputForJavaElement(je, true);
else
return findInputForJavaElement(je, false);
}
protected IJavaElement findInputForJavaElement(IJavaElement je, boolean canChangeInputType) {
if (je == null || !je.exists())
return null;
if (isValidInput(je)) {
//don't update if input must be project (i.e. project is used as source folder)
if (canChangeInputType)
fLastInputWasProject= je.getElementType() == IJavaElement.JAVA_PROJECT;
return je;
} else if (fLastInputWasProject) {
IPackageFragmentRoot packageFragmentRoot= (IPackageFragmentRoot)je.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
if (!packageFragmentRoot.isExternal())
return je.getJavaProject();
}
return findInputForJavaElement(je.getParent(), canChangeInputType);
}
/**
* Override the getText and getImage methods for the DecoratingLabelProvider
* to handel the decoration of logical packages.
*
* @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#createDecoratingLabelProvider(JavaUILabelProvider)
*/
@Override
protected DecoratingJavaLabelProvider createDecoratingLabelProvider(JavaUILabelProvider provider) {
return new DecoratingJavaLabelProvider(provider, false, isInListState()) {
@Override
public String getText(Object element){
if (element instanceof LogicalPackage) {
LogicalPackage el= (LogicalPackage) element;
return super.getText(el.getFragments()[0]);
} else return super.getText(element);
}
@Override
public Image getImage(Object element) {
if(element instanceof LogicalPackage){
LogicalPackage el= (LogicalPackage) element;
ILabelDecorator decorator= getLabelDecorator();
IPackageFragment[] fragments= el.getFragments();
Image image= super.getImage(el);
for (int i= 0; i < fragments.length; i++) {
IPackageFragment fragment= fragments[i];
Image decoratedImage= decorator.decorateImage(image, fragment);
if(decoratedImage != null)
image= decoratedImage;
}
return image;
} else return super.getImage(element);
}
};
}
/*
* @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#isInputResetBy(java.lang.Object, java.lang.Object, org.eclipse.ui.IWorkbenchPart)
* @since 3.7
*/
@Override
boolean isInputResetBy(Object newInput, Object input, IWorkbenchPart part) {
return (!(part instanceof ProjectsView || part instanceof PackageExplorerPart)) && super.isInputResetBy(newInput, input, part);
}
}
