package org.eclipse.ui.views.navigator;

/*
 * (c) Copyright IBM Corp. 2000, 2001.
 * All Rights Reserved.
 */
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.help.*;
import org.eclipse.jface.action.*;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.widgets.*;
import org.eclipse.ui.*;
import org.eclipse.ui.actions.*;
import org.eclipse.ui.dialogs.*;
import org.eclipse.ui.help.*;
import org.eclipse.ui.views.internal.framelist.*;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.ui.part.*;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;

/**
 * Implements the Resource Navigator view.
 */
public class ResourceNavigator extends ViewPart implements ISetSelectionTarget {
	private TreeViewer viewer;
	private IDialogSettings settings;
	private IMemento memento;
	private NavigatorFrameSource frameSource;
	private FrameList frameList;
	
	private AddBookmarkAction addBookmarkAction;
	private BuildAction buildAction;
	private BuildAction rebuildAllAction;
	private CloseResourceAction closeResourceAction;
	private CopyResourceAction copyResourceAction;
	private DeleteResourceAction deleteResourceAction;
	private OpenFileAction openFileAction;
	private OpenResourceAction openResourceAction;
	private OpenSystemEditorAction openSystemEditorAction; 
	private PropertyDialogAction propertyDialogAction;
	private RefreshAction localRefreshAction;
	private SortViewAction sortByTypeAction;
	private SortViewAction sortByNameAction;
	private ResourceNavigatorRenameAction renameResourceAction;
	private ResourceNavigatorMoveAction moveResourceAction;
	private CopyProjectAction copyProjectAction;
	private MoveProjectAction moveProjectAction;
	private NewWizardAction newWizardAction;
	private BackAction backAction;
	private ForwardAction forwardAction;
	private GoIntoAction goIntoAction;
	private UpAction upAction;
	private GotoResourceAction gotoResourceAction;
	
	//The filter the resources are cleared up on
	private ResourcePatternFilter patternFilter = new ResourcePatternFilter();

	/** Property store constant for sort order. */
	private static final String STORE_SORT_TYPE = "ResourceViewer.STORE_SORT_TYPE";//$NON-NLS-1$

	/**
	 * No longer used but preserved to avoid an api change.
	 */
	public static final String NAVIGATOR_VIEW_HELP_ID = INavigatorHelpContextIds.RESOURCE_VIEW;

	/**
	 * Preference name constant for linking editor switching to navigator selection.
	 * 
	 * [Issue: We're cheating here, by referencing a preference which is actually defined
	 * on the Workbench's preference page.  The Navigator should eventually have its own
	 * preference page with this preference on it, instead of on the Workbench's.
	 * The value must be the same as IWorkbenchPreferenceConstants.LINK_NAVIGATOR_TO_EDITOR.]
	 */
	private static final String LINK_NAVIGATOR_TO_EDITOR = "LINK_NAVIGATOR_TO_EDITOR";//$NON-NLS-1$

	// Persistance tags.
	private static final String TAG_SORTER = "sorter";//$NON-NLS-1$
	private static final String TAG_FILTERS = "filters";//$NON-NLS-1$
	private static final String TAG_FILTER = "filter";//$NON-NLS-1$
	private static final String TAG_SELECTION = "selection";//$NON-NLS-1$
	private static final String TAG_EXPANDED = "expanded";//$NON-NLS-1$
	private static final String TAG_ELEMENT = "element";//$NON-NLS-1$
	private static final String TAG_PATH = "path";//$NON-NLS-1$
	private static final String TAG_VERTICAL_POSITION = "verticalPosition";//$NON-NLS-1$
	private static final String TAG_HORIZONTAL_POSITION = "horizontalPosition";//$NON-NLS-1$

	private static final String SELECT_FILTERS_LABEL = ResourceNavigatorMessages.getString("ResourceNavigator.filterText"); //$NON-NLS-1$
	private FilterSelectionAction filterAction;

	private IPartListener partListener = new IPartListener() {
		public void partActivated(IWorkbenchPart part) {
			if (part instanceof IEditorPart)
				editorActivated((IEditorPart) part);
		}
		public void partBroughtToTop(IWorkbenchPart part) {}
		public void partClosed(IWorkbenchPart part) {}
		public void partDeactivated(IWorkbenchPart part) {}
		public void partOpened(IWorkbenchPart part) {}
	};
/**
 * Creates a new ResourceNavigator.
 */
public ResourceNavigator() {
	IDialogSettings workbenchSettings = getPlugin().getDialogSettings();
	settings = workbenchSettings.getSection("ResourceNavigator");//$NON-NLS-1$
	if(settings == null)
		settings = workbenchSettings.addNewSection("ResourceNavigator");//$NON-NLS-1$
}
/**
 * Converts the given selection into a form usable by the viewer,
 * where the elements are resources.
 */
StructuredSelection convertSelection(ISelection selection) {
	ArrayList list = new ArrayList();
	if (selection instanceof IStructuredSelection) {
		IStructuredSelection ssel = (IStructuredSelection) selection;
		for (Iterator i = ssel.iterator(); i.hasNext();) {
			Object o = i.next();
			IResource resource = null;
			if (o instanceof IResource) {
				resource = (IResource) o;
			}
			else {
				if (o instanceof IAdaptable) {
					resource = (IResource) ((IAdaptable) o).getAdapter(IResource.class);
				}
			}
			if (resource != null) {
				list.add(resource);
			}
		}
	}
	return new StructuredSelection(list);
}
/* (non-Javadoc)
 * Method declared on IWorkbenchPart.
 */ 
public void createPartControl(Composite parent) {
	viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
//	initDrillDownAdapter(viewer);
	viewer.setUseHashlookup(true);
	viewer.setContentProvider(new WorkbenchContentProvider());
	viewer.setLabelProvider(new DecoratingLabelProvider(new WorkbenchLabelProvider(), null));
	viewer.addFilter(this.patternFilter);
	if(memento != null) restoreFilters();
	initResourceSorter();
	viewer.setInput(getInitialInput());
	initFrameList();
	initDragAndDrop();
	initRefreshKey();
	updateTitle();
	
	MenuManager menuMgr = new MenuManager("#PopupMenu");//$NON-NLS-1$
	menuMgr.setRemoveAllWhenShown(true);
	menuMgr.addMenuListener(new IMenuListener() {
		public void menuAboutToShow(IMenuManager manager) {
			ResourceNavigator.this.fillContextMenu(manager);
		}
	});
	Menu menu = menuMgr.createContextMenu(viewer.getTree());
	viewer.getTree().setMenu(menu);
	getSite().registerContextMenu(menuMgr, viewer);
	makeActions();

	viewer.addSelectionChangedListener(new ISelectionChangedListener() {
		public void selectionChanged(SelectionChangedEvent event) {
			handleSelectionChanged(event);
		}
	});
	viewer.addSelectionActivatedListener(new ISelectionActivatedListener() {
		public void selectionActivated(SelectionActivatedEvent event) {
			handleSelectionActivated(event);
		}
	});
	viewer.addDoubleClickListener(new IDoubleClickListener() {
		public void doubleClick(DoubleClickEvent event) {
			handleDoubleClick(event);
		}
	});
	viewer.getControl().addKeyListener(new KeyAdapter() {
		public void keyPressed(KeyEvent e) {
			handleKeyPressed(e);
		}
	});

	fillActionBars();
	
	getSite().setSelectionProvider(viewer);

	getSite().getPage().addPartListener(partListener);
	
	if(memento != null) restoreState(memento);
	memento = null;	
	// Set help for the view 
	WorkbenchHelp.setHelp(viewer.getControl(), new ViewContextComputer(this, INavigatorHelpContextIds.RESOURCE_VIEW));
}
/* (non-Javadoc)
 * Method declared on IWorkbenchPart.
 */ 
public void dispose() {
	getSite().getPage().removePartListener(partListener);
	super.dispose();
}
/**
 * An editor has been activated.  Set the selection in this navigator
 * to be the editor's input, if linking is enabled.
 */
void editorActivated(IEditorPart editor) {
	if (!isLinkingEnabled())
		return;

	IEditorInput input = editor.getEditorInput();
	if (input instanceof IFileEditorInput) {
		IFileEditorInput fileInput = (IFileEditorInput) input;
		IFile file = fileInput.getFile();
		ISelection newSelection = new StructuredSelection(file);
		if (!viewer.getSelection().equals(newSelection)) {
			viewer.setSelection(newSelection);
		}
	}
	
}
/**
 * Contributes actions to the local tool bar and local pulldown menu.
 */
void fillActionBars() {
	IActionBars actionBars = getViewSite().getActionBars();
	IToolBarManager toolBar = actionBars.getToolBarManager();
	toolBar.add(backAction);
	toolBar.add(forwardAction);
	toolBar.add(upAction);
	actionBars.updateActionBars();

	IMenuManager menu = actionBars.getMenuManager();
	MenuManager submenu = new MenuManager(ResourceNavigatorMessages.getString("ResourceNavigator.sort")); //$NON-NLS-1$
	menu.add(submenu);
	updateSortActions();
	submenu.add(sortByNameAction);
	submenu.add(sortByTypeAction);
	menu.add(filterAction);
}
/**
 * Called when the context menu is about to open.
 */
void fillContextMenu(IMenuManager menu) {
	IStructuredSelection selection = (IStructuredSelection) getResourceViewer().getSelection();

	updateActions(selection);
	
	fillFileMenu(menu, selection);
	menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
	menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS+"-end"));//$NON-NLS-1$
	menu.add(new Separator());

	if (propertyDialogAction.isApplicableForSelection())
	   menu.add(propertyDialogAction);	
}
/**
 * Add file / resource actions to the context sensitive menu.
 * @param menu the context sensitive menu
 * @param selection the current selection in the project explorer
 */
void fillFileMenu(IMenuManager menu, IStructuredSelection selection) {
	boolean anyResourceSelected = !selection.isEmpty() && SelectionUtil.allResourcesAreOfType(selection, IResource.PROJECT | IResource.FOLDER | IResource.FILE);
	boolean onlyFilesSelected = !selection.isEmpty() && SelectionUtil.allResourcesAreOfType(selection, IResource.FILE);
	boolean onlyFoldersOrFilesSelected = !selection.isEmpty() && SelectionUtil.allResourcesAreOfType(selection, IResource.FOLDER | IResource.FILE);
	boolean onlyProjectsSelected = !selection.isEmpty() && SelectionUtil.allResourcesAreOfType(selection, IResource.PROJECT);

	MenuManager newMenu = new MenuManager(ResourceNavigatorMessages.getString("ResourceNavigator.new")); //$NON-NLS-1$
	menu.add(newMenu);
	new NewWizardMenu(newMenu, getSite().getWorkbenchWindow(), false);
	
	if (selection.size() == 1 && SelectionUtil.allResourcesAreOfType(selection, IResource.PROJECT | IResource.FOLDER)) {
		menu.add(goIntoAction);
	}
	MenuManager gotoMenu = new MenuManager(ResourceNavigatorMessages.getString("ResourceNavigator.goto")); //$NON-NLS-1$
	menu.add(gotoMenu);
	gotoMenu.add(backAction);
	gotoMenu.add(forwardAction);
	gotoMenu.add(upAction);
	gotoMenu.add(gotoResourceAction);
		
	if (onlyFilesSelected)
		menu.add(openFileAction);

	if (anyResourceSelected) {
		fillOpenWithMenu(menu, selection);
		fillOpenToMenu(menu, selection);
	}
	menu.add(new Separator());
	
	if (onlyFoldersOrFilesSelected) {
		menu.add(copyResourceAction);
		menu.add(moveResourceAction);
	} else if (onlyProjectsSelected) {
		menu.add(copyProjectAction);
		menu.add(moveProjectAction);
	}
	if (anyResourceSelected) {
		menu.add(renameResourceAction);
		menu.add(deleteResourceAction);
	}
	if (onlyFilesSelected)
		menu.add(addBookmarkAction);

	menu.add(new Separator());
	if (onlyProjectsSelected) {
		menu.add(openResourceAction);
		menu.add(closeResourceAction);
		// Allow manual incremental build only if auto build is off.
		if (!ResourcesPlugin.getWorkspace().isAutoBuilding())
			menu.add(buildAction);
		menu.add(rebuildAllAction);
	}
	menu.add(localRefreshAction);
		
}
/**
 * Add "open to" actions to the context sensitive menu.
 * @param menu the context sensitive menu
 * @param selection the current selection in the project explorer
 */
void fillOpenToMenu(IMenuManager menu, IStructuredSelection selection) 
{
	// If one file is selected get it.
	// Otherwise, do not show the "open with" menu.
	if (selection.size() != 1)
		return;
	IAdaptable element = (IAdaptable) selection.getFirstElement();
	if (!(element instanceof IContainer))
		return;

	// Create a menu flyout.
	MenuManager submenu = new MenuManager(ResourceNavigatorMessages.getString("ResourceNavigator.openPerspective")); //$NON-NLS-1$
	submenu.add(new OpenPerspectiveMenu(getSite().getWorkbenchWindow(), element));
	menu.add(submenu);

}
/**
 * Add "open with" actions to the context sensitive menu.
 * @param menu the context sensitive menu
 * @param selection the current selection in the project explorer
 */
void fillOpenWithMenu(IMenuManager menu, IStructuredSelection selection) {

	// If one file is selected get it.
	// Otherwise, do not show the "open with" menu.
	if (selection.size() != 1)
		return;

	Object element = selection.getFirstElement();
	if (!(element instanceof IFile))
		return;

	// Create a menu flyout.
	MenuManager submenu = new MenuManager(ResourceNavigatorMessages.getString("ResourceNavigator.openWith")); //$NON-NLS-1$
	submenu.add(new OpenWithMenu(getSite().getPage(), (IFile) element));
		
	// Add the submenu.
	menu.add(submenu);
}
/** 
 * Returns the initial input for the viewer.
 * Tries to convert the input to a resource, either directly or via IAdaptable.
 * If the resource is a container, it uses that.
 * If the resource is a file, it uses its parent folder.
 * If a resource could not be obtained, it uses the workspace root.
 */
IContainer getInitialInput() {
	IAdaptable input = getSite().getPage().getInput();
	IResource resource = null;
	if (input instanceof IResource) {
		resource = (IResource) input;
	}
	else {
		resource = (IResource) input.getAdapter(IResource.class);
	}
	if (resource != null) {
		switch (resource.getType()) {
			case IResource.FILE:
				return resource.getParent();
			case IResource.FOLDER:
			case IResource.PROJECT:
			case IResource.ROOT:
				return (IContainer) resource;
			default:
				// Unknown resource type.  Fall through.
				break;
		}
	}
	return ResourcesPlugin.getWorkspace().getRoot();
}
/**
 * Returns the pattern filter for this view.
 *
 * @return the pattern filter
 */
ResourcePatternFilter getPatternFilter() {
	return this.patternFilter;
}
/**
 * Returns the navigator's plugin.
 */
AbstractUIPlugin getPlugin() {
	return (AbstractUIPlugin) Platform.getPlugin(PlatformUI.PLUGIN_ID);
}
/**
 * Returns the current sorter.
 */
ResourceSorter getResourceSorter() {
	return (ResourceSorter) getResourceViewer().getSorter();
}
/**
 * Returns the tree viewer which shows the resource hierarchy.
 */
TreeViewer getResourceViewer() {
	return viewer;
}
/**
 * Returns the shell to use for opening dialogs.
 * Used in this class, and in the actions.
 */
Shell getShell() {
	return getViewSite().getShell();
}
/**
 * Returns the message to show in the status line.
 *
 * @param selection the current selection
 * @return the status line message
 */
String getStatusLineMessage(IStructuredSelection selection) {
	if (selection.size() == 1) {
		Object o = selection.getFirstElement();
		if (o instanceof IResource) {
			return ((IResource) o).getFullPath().makeRelative().toString();
		}
		else {
			return ResourceNavigatorMessages.getString("ResourceNavigator.oneItemSelected"); //$NON-NLS-1$
		}
	}
	if (selection.size() > 1) {
		return ResourceNavigatorMessages.format("ResourceNavigator.statusLine",new Object[] {new Integer(selection.size())}); //$NON-NLS-1$
	}
	return "";//$NON-NLS-1$
}
/**
 * Returns the tool tip text for the given element.
 */
String getToolTipText(Object element) {
	if (element instanceof IResource) {
		IPath path = ((IResource) element).getFullPath();
		if (path.isRoot()) {
			return ResourceNavigatorMessages.getString("ResourceManager.toolTip"); //$NON-NLS-1$
		}
		else {
			return path.makeRelative().toString();
		}
	}
	else {
		return ((ILabelProvider) getResourceViewer().getLabelProvider()).getText(element);
	}
}
/**
 * Handles double clicks in viewer.
 * Opens editor if file double-clicked.
 */
void handleDoubleClick(DoubleClickEvent event) {
	IStructuredSelection s = (IStructuredSelection)event.getSelection();
	Object element = s.getFirstElement();
//	if (element instanceof IFile) {
//		runOpenFileAction(s);
//	}
//	else {
	if (!(element instanceof IFile)) {
		// 1GBZIA0: ITPUI:WIN2000 - Double-clicking in navigator should expand/collapse containers
		if (viewer.isExpandable(element)) {
			viewer.setExpandedState(element, !viewer.getExpandedState(element));
		}
	}
}

/**
 * Handles selection activated events in viewer.
 * Opens editor if file double-clicked.
 */
void handleSelectionActivated(SelectionActivatedEvent event) {
	IStructuredSelection s = (IStructuredSelection)event.getSelection();
	Object element = s.getFirstElement();
	if (element instanceof IFile)
		runOpenFileAction(s);
}
/**
 */
void runOpenFileAction(IStructuredSelection s) {
	openFileAction.selectionChanged(s);
	openFileAction.run();
}
/**
 * Handles key events in viewer.
 */
void handleKeyPressed(KeyEvent event) {
	if (event.character == SWT.DEL && event.stateMask == 0 && deleteResourceAction.isEnabled()) {
		deleteResourceAction.run();
	}
}
/**
 * Handles selection changed in viewer.
 * Updates global actions.
 * Links to editor (if option enabled)
 */
void handleSelectionChanged(SelectionChangedEvent event) {
	IStructuredSelection sel = (IStructuredSelection) event.getSelection();
	updateStatusLine(sel);
	goIntoAction.update();
	updateGlobalActions(sel);
	linkToEditor(sel);
}
/* (non-Javadoc)
 * Method declared on IViewPart.
 */
public void init(IViewSite site,IMemento memento) throws PartInitException {
	super.init(site,memento);
	this.memento = memento;
}
/**
 * Adds drag and drop support to the navigator.
 */
void initDragAndDrop() {
	int ops = DND.DROP_COPY | DND.DROP_MOVE;
	Transfer[] transfers = new Transfer[] {ResourceTransfer.getInstance(),
	    FileTransfer.getInstance(), PluginTransfer.getInstance()};
	viewer.addDragSupport(ops, transfers, new NavigatorDragAdapter((ISelectionProvider)viewer));
	viewer.addDropSupport(ops, transfers, new NavigatorDropAdapter(viewer));
}
/**
 * Initializes a drill down adapter on the viewer.
 */ 
void initDrillDownAdapter(TreeViewer viewer) {
	DrillDownAdapter drillDownAdapter = new DrillDownAdapter(viewer) {
		// need to update title whenever input changes;
		// updateNavigationButtons is called whenever any of the drill down buttons are used
		protected void updateNavigationButtons() {
			super.updateNavigationButtons();
			updateTitle();
		}
	};
	drillDownAdapter.addNavigationActions(getViewSite().getActionBars().getToolBarManager());
}
void initFrameList() {
	frameSource = new NavigatorFrameSource(this);
	frameList = new FrameList(frameSource);
	frameSource.connectTo(frameList);	
}
/**
 * Create the KeyListener for doing the refresh on the viewer.
 */
private void initRefreshKey() {

	getResourceViewer().getControl().addKeyListener(new KeyAdapter() {
		// Listen on key released instead of pressed just in case some
		// menu bar item sets up an accelerator on F5.
		public void keyReleased(KeyEvent event) {
			if (event.keyCode == SWT.F5) {
				localRefreshAction.selectionChanged(StructuredSelection.EMPTY);
				localRefreshAction.run();
				localRefreshAction.selectionChanged(
					(IStructuredSelection) getResourceViewer().getSelection());
			}
		}
	});
}
/**
 * Init the current sorter.
 */
void initResourceSorter() {
	int sortType = ResourceSorter.NAME;
	try {
		int sortInt = 0;
		if(memento != null) {
			String sortStr = memento.getString(TAG_SORTER);
			if(sortStr != null)
				sortInt = new Integer(sortStr).intValue();
		} else {
			sortInt = settings.getInt(STORE_SORT_TYPE);
		}
		if (sortInt == ResourceSorter.NAME || sortInt == ResourceSorter.TYPE)
			sortType = sortInt;
	} catch (NumberFormatException e) {}
	setResourceSorter(new ResourceSorter(sortType));
}
/**
 * Returns whether the preference to link navigator selection to active editor is enabled.
 */
boolean isLinkingEnabled() {
	IPreferenceStore store = getPlugin().getPreferenceStore(); 
	return store.getBoolean(LINK_NAVIGATOR_TO_EDITOR);
}
/**
 * Links to editor (if option enabled)
 */
boolean linkToEditor(IStructuredSelection selection) {
	if (!isLinkingEnabled())
		return false;

	Object obj = selection.getFirstElement();
	if (obj instanceof IFile && selection.size() == 1) {
		IFile file = (IFile) obj;
		IWorkbenchPage page = getSite().getPage();
		IEditorPart editorArray[] = page.getEditors();
		for (int i = 0; i < editorArray.length; ++i) {
			IEditorPart editor = editorArray[i];
			IEditorInput input = editor.getEditorInput();
			if (input instanceof IFileEditorInput && file.equals(((IFileEditorInput)input).getFile())) {
				page.bringToTop(editor);
				return true;
			}
		}
	}
	return false;
}
/**
 *	Create self's action objects
 */
void makeActions() {
	Shell shell = getShell();
	openResourceAction = new OpenResourceAction(shell);
	openFileAction = new OpenFileAction(getSite().getPage());
	openSystemEditorAction = new OpenSystemEditorAction(getSite().getPage());
	closeResourceAction = new CloseResourceAction(shell);
	localRefreshAction = new RefreshAction(shell);
	buildAction = new BuildAction(shell, IncrementalProjectBuilder.INCREMENTAL_BUILD);
	rebuildAllAction = new BuildAction(shell, IncrementalProjectBuilder.FULL_BUILD);
	moveResourceAction = new ResourceNavigatorMoveAction(shell,this.viewer);
	copyResourceAction = new CopyResourceAction(shell);
	moveProjectAction = new MoveProjectAction(shell);
	copyProjectAction = new CopyProjectAction(shell);	
	renameResourceAction = new ResourceNavigatorRenameAction(shell,this.viewer);
	deleteResourceAction = new DeleteResourceAction(shell);
	sortByNameAction = new SortViewAction(this, false);
	sortByTypeAction = new SortViewAction(this, true);
	filterAction = new FilterSelectionAction(shell, this, SELECT_FILTERS_LABEL);
	addBookmarkAction = new AddBookmarkAction(shell);
	propertyDialogAction = new PropertyDialogAction(getShell(), getResourceViewer());
	newWizardAction = new NewWizardAction();
	goIntoAction = new GoIntoAction(frameList);
	backAction = new BackAction(frameList);
	forwardAction = new ForwardAction(frameList);
	upAction = new UpAction(frameList);
	gotoResourceAction = new GotoResourceAction(this, ResourceNavigatorMessages.getString("ResourceNavigator.resourceText")); //$NON-NLS-1$

	IActionBars actionBars = getViewSite().getActionBars();
	actionBars.setGlobalActionHandler(IWorkbenchActionConstants.DELETE, deleteResourceAction);
	actionBars.setGlobalActionHandler(IWorkbenchActionConstants.BOOKMARK, addBookmarkAction);
}
public void restoreFilters() {
	IMemento filtersMem = memento.getChild(TAG_FILTERS);
	if(filtersMem != null) {	
		IMemento children[] = filtersMem.getChildren(TAG_FILTER);
		String filters[] = new String[children.length];
		for (int i = 0; i < children.length; i++) {
			filters[i] = children[i].getString(TAG_ELEMENT);
		}
		getPatternFilter().setPatterns(filters);
	} else {
		getPatternFilter().setPatterns(new String[0]);
	}
}
void restoreState(IMemento memento) {
	IContainer container  = ResourcesPlugin.getWorkspace().getRoot();
	IMemento childMem = memento.getChild(TAG_EXPANDED);
	if(childMem != null) {
		ArrayList elements = new ArrayList();
		IMemento[] elementMem = childMem.getChildren(TAG_ELEMENT);
		for (int i = 0; i < elementMem.length; i++){
			Object element = container.findMember(elementMem[i].getString(TAG_PATH));
			elements.add(element);
		}
		viewer.setExpandedElements(elements.toArray());
	}
	childMem = memento.getChild(TAG_SELECTION);
	if(childMem != null) {
		ArrayList list = new ArrayList();
		IMemento[] elementMem = childMem.getChildren(TAG_ELEMENT);
		for (int i = 0; i < elementMem.length; i++){
			Object element = container.findMember(elementMem[i].getString(TAG_PATH));
			list.add(element);
		}
		viewer.setSelection(new StructuredSelection(list));
	}

	Tree tree = viewer.getTree();
	//save vertical position
	ScrollBar bar = tree.getVerticalBar();
	if (bar != null) {
		try {
			String posStr = memento.getString(TAG_VERTICAL_POSITION);
			int position;
			position = new Integer(posStr).intValue();
			bar.setSelection(position);
		} catch (NumberFormatException e){}
	}
	bar = tree.getHorizontalBar();
	if (bar != null) {
		try {
			String posStr = memento.getString(TAG_HORIZONTAL_POSITION);
			int position;
			position = new Integer(posStr).intValue();
			bar.setSelection(position);
		} catch (NumberFormatException e){}
	}
}
public void saveState(IMemento memento) {
	if(viewer == null) {
		if(this.memento != null) //Keep the old state;
			memento.putMemento(this.memento);
		return;
	}

	//save sorter
	memento.putInteger(TAG_SORTER,getResourceSorter().getCriteria());
	//save filters
	String filters[] = getPatternFilter().getPatterns();
	if(filters.length > 0) {
		IMemento filtersMem = memento.createChild(TAG_FILTERS);
		for (int i = 0; i < filters.length; i++){
			IMemento child = filtersMem.createChild(TAG_FILTER);
			child.putString(TAG_ELEMENT,filters[i]);
		}
	}
	//save expanded elements
	Tree tree = viewer.getTree();
 	Object expandedElements[] = viewer.getExpandedElements();
 	if(expandedElements.length > 0) {
	 	IMemento expandedMem = memento.createChild(TAG_EXPANDED);
 		for (int i = 0; i < expandedElements.length; i++) {
	 		IMemento elementMem = expandedMem.createChild(TAG_ELEMENT);
 			elementMem.putString(TAG_PATH,((IResource)expandedElements[i]).getFullPath().toString());
 		}
 	}

 	//save selection
 	Object elements[] = ((IStructuredSelection)viewer.getSelection()).toArray();
 	if(elements.length > 0) {
 		IMemento selectionMem = memento.createChild(TAG_SELECTION);
 		for (int i = 0; i < elements.length; i++) {
	 		IMemento elementMem = selectionMem.createChild(TAG_ELEMENT);
 			elementMem.putString(TAG_PATH,((IResource)elements[i]).getFullPath().toString());
 		}
 	}

 	//save vertical position
	ScrollBar bar = tree.getVerticalBar();
	int position = bar != null ? bar.getSelection():0;
	memento.putString(TAG_VERTICAL_POSITION,String.valueOf(position));
	//save horizontal position
	bar = tree.getHorizontalBar();
	position = bar != null ? bar.getSelection():0;
	memento.putString(TAG_HORIZONTAL_POSITION,String.valueOf(position));
}
/**
 *	Reveal and select the passed element selection in self's visual component
 */
public void selectReveal(ISelection selection) {
	StructuredSelection ssel = convertSelection(selection);
	if (!ssel.isEmpty()) {
		getResourceViewer().setSelection(ssel, true);
	}
}
/**
 * @see IWorkbenchPart#setFocus()
 */ 
public void setFocus() {
	getResourceViewer().getTree().setFocus();
}
/**
 * Note: For experimental use only.
 * Sets the decorator for the navigator.
 *
 * @param decorator a label decorator or <code>null</code> for no decorations.
 */
public void setLabelDecorator(ILabelDecorator decorator) {
	DecoratingLabelProvider provider = (DecoratingLabelProvider) getResourceViewer().getLabelProvider();
	provider.setLabelDecorator(decorator);
}
/**
 * Set the current sorter.
 */
void setResourceSorter(ResourceSorter sorter) {
	TreeViewer viewer = getResourceViewer();
	viewer.getControl().setRedraw(false);
	viewer.setSorter(sorter);
	viewer.getControl().setRedraw(true);
	settings.put(STORE_SORT_TYPE,sorter.getCriteria());
	updateSortActions();
}
/**
 * Updates all actions with the given selection.
 * Necessary when popping up a menu, because some of the enablement criteria
 * may have changed, even if the selection in the viewer hasn't.
 * E.g. A project was opened or closed.
 */
void updateActions(IStructuredSelection selection) {
	buildAction.selectionChanged(selection);
	rebuildAllAction.selectionChanged(selection);
	closeResourceAction.selectionChanged(selection);
	copyResourceAction.selectionChanged(selection);
	localRefreshAction.selectionChanged(selection);
	moveResourceAction.selectionChanged(selection);
	openResourceAction.selectionChanged(selection);
	openFileAction.selectionChanged(selection);
	openSystemEditorAction.selectionChanged(selection);
	propertyDialogAction.selectionChanged(selection);
	renameResourceAction.selectionChanged(selection);
	sortByTypeAction.selectionChanged(selection);
	sortByNameAction.selectionChanged(selection);
	copyProjectAction.selectionChanged(selection);
	moveProjectAction.selectionChanged(selection);
	updateGlobalActions(selection);
}
/**
 * Updates the global actions with the given selection.
 * Be sure to invoke after actions objects have updated, since can* methods delegate to action objects.
 */
void updateGlobalActions(IStructuredSelection selection) {
	deleteResourceAction.selectionChanged(selection);
	addBookmarkAction.selectionChanged(selection);

	// Ensure Copy global action targets correct action,
	// either copyProjectAction or copyResourceAction,
	// depending on selection.
	copyProjectAction.selectionChanged(selection);
	copyResourceAction.selectionChanged(selection);
	IActionBars actionBars = getViewSite().getActionBars();
	if (copyProjectAction.isEnabled())
		actionBars.setGlobalActionHandler(IWorkbenchActionConstants.COPY, copyProjectAction);
	else
		actionBars.setGlobalActionHandler(IWorkbenchActionConstants.COPY, copyResourceAction);
	actionBars.updateActionBars();
	renameResourceAction.selectionChanged(selection);
}
/**
 * Updates the checked state of the sort actions.
 */
void updateSortActions() {
	int criteria = getResourceSorter().getCriteria();
	if (sortByNameAction != null && sortByTypeAction != null) {
		sortByNameAction.setChecked(criteria == ResourceSorter.NAME);
		sortByTypeAction.setChecked(criteria == ResourceSorter.TYPE);
	}
}
/**
 * Updates the message shown in the status line.
 *
 * @param selection the current selection
 */
void updateStatusLine(IStructuredSelection selection) {
	String msg = getStatusLineMessage(selection);
	getViewSite().getActionBars().getStatusLineManager().setMessage(msg);
}
/**
 * Updates the title text and title tool tip.
 * Called whenever the input of the viewer changes.
 */ 
void updateTitle() {
	Object input = getResourceViewer().getInput();
	String viewName = getConfigurationElement().getAttribute("name");//$NON-NLS-1$
	IWorkspace workspace = ResourcesPlugin.getWorkspace();
	if (input == null || input.equals(workspace) || input.equals(workspace.getRoot())) {
		setTitle(viewName);
		setTitleToolTip("");//$NON-NLS-1$
	}
	else {
		ILabelProvider labelProvider = (ILabelProvider) getResourceViewer().getLabelProvider();
		setTitle(ResourceNavigatorMessages.format("ResourceNavigator.title", new Object[] {viewName, labelProvider.getText(input)})); //$NON-NLS-1$
		setTitleToolTip(getToolTipText(input));
	}
}
}