bundles/org.eclipse.wst.xml.xpath.ui/src/org/eclipse/wst/xml/xpath/ui/internal/views/XPathView.java - sourceediting/webtools.sourceediting.xpath - Git at Google

 /*******************************************************************************
  * Copyright (c) 2008, 2010 Chase Technology Ltd - http://www.chasetechnology.co.uk
  * 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:
  *     Doug Satchwell (Chase Technology Ltd) - initial API and implementation
  *     David Carver (STAR) - bug 261588 - Add Edit Namespace support for XPath view
  *     David Carver (Intalio) - bug 246110 - Clean up XPath UI.
  *     David Carver (Intalio) - bug 271288 - Set ContextNode for XPath Evaluation
  *     Jesper Steen Moller - bug 313992 - XPath evaluation does not show atomics
  *******************************************************************************/
 package org.eclipse.wst.xml.xpath.ui.internal.views;

 import java.util.HashMap;
 import java.util.Map;

 import javax.xml.xpath.XPathExpressionException;

 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.ListenerList;
 import org.eclipse.core.runtime.SafeRunner;
 import org.eclipse.jface.action.IAction;
 import org.eclipse.jface.action.IMenuListener;
 import org.eclipse.jface.action.IMenuManager;
 import org.eclipse.jface.action.IToolBarManager;
 import org.eclipse.jface.action.MenuManager;
 import org.eclipse.jface.resource.JFaceColors;
 import org.eclipse.jface.util.SafeRunnable;
 import org.eclipse.jface.viewers.DoubleClickEvent;
 import org.eclipse.jface.viewers.IDoubleClickListener;
 import org.eclipse.jface.viewers.IPostSelectionProvider;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.ISelectionChangedListener;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.jface.viewers.SelectionChangedEvent;
 import org.eclipse.jface.viewers.StructuredSelection;
 import org.eclipse.jface.viewers.TreeViewer;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.CTabFolder;
 import org.eclipse.swt.custom.CTabItem;
 import org.eclipse.swt.events.ModifyEvent;
 import org.eclipse.swt.events.ModifyListener;
 import org.eclipse.swt.events.SelectionAdapter;
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Label;
 import org.eclipse.swt.widgets.Menu;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.swt.widgets.Text;
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IMemento;
 import org.eclipse.ui.IPartListener2;
 import org.eclipse.ui.ISelectionListener;
 import org.eclipse.ui.IViewSite;
 import org.eclipse.ui.IWorkbenchPart;
 import org.eclipse.ui.IWorkbenchPartReference;
 import org.eclipse.ui.PartInitException;
 import org.eclipse.ui.part.IShowInSource;
 import org.eclipse.ui.part.IShowInTarget;
 import org.eclipse.ui.part.IShowInTargetList;
 import org.eclipse.ui.part.ShowInContext;
 import org.eclipse.ui.part.ViewPart;
 import org.eclipse.ui.texteditor.ITextEditor;
 import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
 import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
 import org.eclipse.wst.xml.xpath.core.util.XSLTXPathHelper;
 import org.eclipse.wst.xml.xpath.ui.internal.Messages;
 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

 public class XPathView extends ViewPart {

 	private boolean isFiringSelection = false;
 	private IPartListener2 partListener2 = new XPathPartListener();
 	private ISelectionListener selectionListener = new ISelectionListener() {
 		public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 			if (part == getSite().getPage().getActiveEditor()) {
 				if (selection instanceof IStructuredSelection) {
 					currentSelection = (IStructuredSelection) selection;
 					if (!selection.isEmpty()
 							&& (currentSelection.getFirstElement() instanceof Node)) {
 						recalculateLocation((Node) currentSelection
 								.getFirstElement());
 						boolean isLinked = xpathViewActions
 								.isLinkedWithEditor(treeViewer);
 						if (isLinked) {
 							treeViewer.setSelection(currentSelection, true);
 						}
 					} else {
 						recalculateLocation(null);
 					}
 				}
 			}
 		}
 	};
 	private TreeViewer treeViewer;
 	private IEditorPart activeEditor;
 	private Text text;
 	// private JFaceNodeContentProviderXPath contentProvider;
 	private XPathComputer xpathComputer;
 	private Text locationText;
 	private XPathViewActions xpathViewActions = new XPathViewActions();
 	private IPostSelectionProvider selectionProvider = new SelectionProvider();
 	private String location = ""; //$NON-NLS-1$
 	private String message;
 	private boolean expressionValid = true;
 	private Integer currentSheet = Integer.valueOf(0);
 	private Map<Integer, String> sheetMap;
 	private IStructuredSelection currentSelection;
 	private Node contextNode = null;

 	public void createPartControl(Composite parent) {
 		Composite parentComp = new Composite(parent, SWT.NONE);
 		GridLayout gl = new GridLayout(1, false);
 		gl.horizontalSpacing = 0;
 		gl.verticalSpacing = 0;
 		gl.marginHeight = 0;
 		gl.marginWidth = 0;
 		parentComp.setLayout(gl);
 		GridData gd = new GridData(SWT.FILL, SWT.NONE, true, false, 2, 1);
 		parentComp.setLayoutData(gd);

 		Composite comp = new Composite(parentComp, SWT.NONE);
 		comp.setLayout(new GridLayout(1, false));
 		comp.setLayoutData(new GridData(SWT.FILL, SWT.NONE, true, false));

 		Label label = new Label(comp, SWT.NONE);
 		label.setText(Messages.XPathView_1);

 		this.text = new Text(comp, SWT.BORDER);

 		gd = new GridData(SWT.FILL, SWT.NONE, true, false);
 		text.setLayoutData(gd);
 		text.addModifyListener(new ModifyListener() {
 			public void modifyText(ModifyEvent e) {
 				recomputeXPath();
 			}
 		});

 		this.locationText = new Text(comp, SWT.READ_ONLY | SWT.FULL_SELECTION);
 		gd = new GridData(SWT.FILL, SWT.NONE, true, false);
 		locationText.setLayoutData(gd);

 		this.treeViewer = new TreeViewer(parentComp, SWT.NONE);
 		gd = new GridData(SWT.FILL, SWT.FILL, true, true);
 		gd.horizontalSpan = 2;
 		treeViewer.getControl().setLayoutData(gd);
 		treeViewer.setLabelProvider(new JFaceNodeLabelProviderXPath());
 		treeViewer.setContentProvider(new JFaceNodeContentProviderXPath());
 		treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {

 			public void selectionChanged(SelectionChangedEvent event) {
 				if (getSite().getPage().getActivePart() == XPathView.this) {
 					handleTreeSelection((IStructuredSelection) event
 							.getSelection(), false);
 				}
 			}
 		});
 		treeViewer.addDoubleClickListener(new IDoubleClickListener() {

 			public void doubleClick(DoubleClickEvent event) {
 				handleTreeSelection(
 						(IStructuredSelection) event.getSelection(), true);
 			}

 		});

 		final CTabFolder folder = new CTabFolder(parentComp, SWT.BOTTOM
 				| SWT.FLAT);
 		gd = new GridData(SWT.FILL, SWT.NONE, true, false);
 		gd.heightHint = 0;
 		folder.setLayoutData(gd);
 		folder.addSelectionListener(new SelectionAdapter() {
 			public void widgetSelected(SelectionEvent e) {
 				CTabItem item = (CTabItem) e.item;
 				sheetMap.put(currentSheet, text.getText());
 				pageChange(folder.indexOf(item));
 			}
 		});

 		for (int i = 0; i < 5; i++) {
 			CTabItem item = new CTabItem(folder, SWT.NONE, i);
 			// item.setControl(comp);
 			item.setText(Messages.XPathView_2 + (i + 1));
 		}
 		folder.setSelection(currentSheet);
 		pageChange(currentSheet);

 		this.xpathComputer = new XPathComputer(this);
 		createMenu();
 		createToolbar();
 		createContextMenu();

 		getSite().setSelectionProvider(selectionProvider);

 		initEditorListener();
 	}

 	private void handleTreeSelection(IStructuredSelection selection,
 			boolean reveal) {
 		if (activeEditor != null) {
 			isFiringSelection = true;
 			if (selection.getFirstElement() != null) {
 				Object element = selection.getFirstElement();
 				if (element instanceof IDOMNode) {
 					IDOMNode node = (IDOMNode) element;
 					ITextEditor textEditor = (ITextEditor) activeEditor
 							.getAdapter(ITextEditor.class);

 					if (textEditor != null) {
 						getSite().getWorkbenchWindow().getActivePage()
 								.bringToTop(textEditor);
 						if (reveal) {
 							textEditor
 									.selectAndReveal(node.getStartOffset(),
 											node.getEndOffset()
 													- node.getStartOffset());
 						} else {
 							textEditor.setHighlightRange(node.getStartOffset(),
 									0, true);
 						}
 					}
 				}
 			}
 			isFiringSelection = false;
 		}
 	}

 	private void createContextMenu() {
 		MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$
 		menuMgr.setRemoveAllWhenShown(true);
 		menuMgr.addMenuListener(new IMenuListener() {
 			public void menuAboutToShow(IMenuManager manager) {
 				xpathViewActions.fillContextMenu(manager);
 			}
 		});
 		Menu menu = menuMgr.createContextMenu(treeViewer.getControl());
 		treeViewer.getControl().setMenu(menu);
 		getSite().registerContextMenu(menuMgr, treeViewer);
 	}

 	private void pageChange(int index) {
 		currentSheet = index;
 		String exp = sheetMap.get(index);
 		if (exp != null) {
 			text.setText(exp);
 		} else {
 			text.setText("/"); //$NON-NLS-1$
 		}
 	}

 	private void createMenu() {
 		IMenuManager mgr = getViewSite().getActionBars().getMenuManager();
 		IAction[] items = xpathViewActions.createMenuContributions(treeViewer);
 		for (int i = 0; i < items.length; i++) {
 			IAction item = items[i];
 			mgr.add(item);
 		}
 	}

 	private void createToolbar() {
 		IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager();
 		IAction[] items = xpathViewActions
 				.createToolbarContributions(treeViewer);
 		for (int i = 0; i < items.length; i++) {
 			IAction item = items[i];
 			mgr.add(item);
 		}
 	}

 	private void recalculateLocation(Node selected) {
 		this.location = XSLTXPathHelper.calculateXPathToNode(selected);
 		contextNode = selected;
 		updateLocationText();
 		recomputeXPath();
 	}

 	private void recomputeXPath() {
 		if (activeEditor != null) {
 			boolean valid = expressionValid;
 			try {
 				if (contextNode != null) {
 					xpathComputer.setSelectedNode(contextNode);
 				}
 				xpathComputer.setText(text.getText());
 				xpathComputer.compute();
 				valid = true;
 			} catch (XPathExpressionException e) {
 				valid = false;
 				if (e.getCause() != null) {
 					message = e.getCause().getMessage();
 				} else {
 					message = "Invalid XPath expression"; //$NON-NLS-1$
 				}
 			}
 			if (expressionValid != valid) {
 				expressionValid = valid;
 				updateLocationText();
 			}
 		}
 	}

 	protected void xpathRecomputed(final NodeList nodeList, final IStatus error) {
 		if (getSite() == null) return;
 		Shell shell = getSite().getShell();
 		if (shell == null) return;
 		Display display = shell.getDisplay();
 		if (display == null) return;
 		display.asyncExec(new Runnable() {
 			public void run() {
 				Control refreshControl = treeViewer.getControl();
 				if ((refreshControl != null) && !refreshControl.isDisposed()) {
 					refreshControl.setRedraw(false);
 					treeViewer.setInput(nodeList);
 					treeViewer.setSelection(currentSelection, true);
 					refreshControl.setRedraw(true);
 				}
 				if (error.getSeverity() == IStatus.OK) {
 					expressionValid = true;
 					message = "";
 				} else {
 					expressionValid = false;
 					message = error.getMessage();
 				}
 				updateLocationText();
 			}
 		});
 	}

 	private void updateLocationText() {
 		if (expressionValid) {
 			locationText.setText(Messages.XPathView_0 + location);
 			locationText.setForeground(null);
 		} else {
 			locationText.setText(message);
 			locationText.setForeground(JFaceColors.getErrorText(locationText
 					.getDisplay()));
 		}
 	}

 	private void initEditorListener() {
 		getSite().getPage().addPartListener(partListener2);
 		getSite().getWorkbenchWindow().getSelectionService()
 				.addSelectionListener(selectionListener);
 		editorActivated(getSite().getPage().getActiveEditor());
 	}

 	public void setFocus() {
 		text.setFocus();
 	}

 	public void dispose() {
 		getSite().getPage().removePartListener(partListener2);
 		getSite().getWorkbenchWindow().getSelectionService()
 				.removeSelectionListener(selectionListener);
 		xpathComputer.dispose();
 		super.dispose();
 	}

 	private void editorActivated(IWorkbenchPart part) {
 		if ((part != activeEditor) && (part instanceof IEditorPart)) {
 			IEditorPart editor = (IEditorPart) part;
 			IStructuredModel model = getEditorModel(editor);
 			if (model != null) {
 				activeEditor = editor;
 				xpathComputer.setModel(model);
 				xpathComputer.setSelectedNode((Document) model
 						.getAdapter(Document.class));
 			}
 			recomputeXPath();
 		}
 	}

 	private void editorClosed(IWorkbenchPart part) {
 		if (part == activeEditor) {
 			treeViewer.setInput(null);
 			locationText.setText("");
 			activeEditor = null;
 		}
 	}

 	private IStructuredModel getEditorModel(IEditorPart editor) {
 		return (IStructuredModel) editor.getAdapter(IStructuredModel.class);
 	}

 	@SuppressWarnings("unchecked")
 	public Object getAdapter(Class key) {
 		Object adapter = null;
 		if (key.equals(IShowInTarget.class) && (treeViewer != null)) {
 			adapter = new IShowInTarget() {
 				public boolean show(ShowInContext context) {
 					treeViewer.setSelection(context.getSelection());
 					return treeViewer.getSelection().equals(
 							context.getSelection());
 				}
 			};
 		} else if (key.equals(IShowInSource.class) && (activeEditor != null)) {
 			adapter = new IShowInSource() {
 				public ShowInContext getShowInContext() {
 					return new ShowInContext(activeEditor.getEditorInput(),
 							activeEditor.getEditorSite().getSelectionProvider()
 									.getSelection());
 				}
 			};
 		} else if (key.equals(IShowInTargetList.class)
 				&& (activeEditor != null)) {
 			adapter = activeEditor.getAdapter(key);
 		}
 		if (adapter == null) {
 			adapter = super.getAdapter(key);
 		}
 		return adapter;
 	}

 	public void saveState(IMemento memento) {
 		sheetMap.put(currentSheet, text.getText());
 		memento.putInteger("CurrentSheet", currentSheet); //$NON-NLS-1$
 		for (Map.Entry<Integer, String> entry : sheetMap.entrySet()) {
 			IMemento child = memento.createChild("Sheet"); //$NON-NLS-1$
 			child.putInteger("Index", entry.getKey()); //$NON-NLS-1$
 			child.putString("XPath", entry.getValue()); //$NON-NLS-1$
 		}
 		boolean link = xpathViewActions.isLinkWithEditor();
 		memento.putBoolean("LinkWithEditor", link);
 		super.saveState(memento);
 	}

 	@Override
 	public void init(IViewSite site, IMemento memento) throws PartInitException {
 		sheetMap = new HashMap<Integer, String>();
 		if (memento != null) {
 			IMemento[] sheets = memento.getChildren("Sheet"); //$NON-NLS-1$
 			if (sheets != null) {
 				currentSheet = memento.getInteger("CurrentSheet"); //$NON-NLS-1$
 				for (IMemento sheet : sheets) {
 					sheetMap
 							.put(
 									sheet.getInteger("Index"), sheet.getString("XPath")); //$NON-NLS-1$ //$NON-NLS-2$
 				}
 			}
 			Boolean linkWithEditor = memento.getBoolean("LinkWithEditor");
 			boolean link = false;
 			if (linkWithEditor != null) {
 				link = linkWithEditor.booleanValue();
 			}
 			xpathViewActions.setLinkWithEditor(link);
 		}
 		if (currentSheet == null) {
 			currentSheet = 0;
 		}
 		super.init(site, memento);
 	}

 	private class XPathPartListener implements IPartListener2 {
 		public void partActivated(IWorkbenchPartReference partRef) {
 			editorActivated(partRef.getPart(false));
 		}

 		public void partBroughtToTop(IWorkbenchPartReference partRef) {
 		}

 		public void partInputChanged(IWorkbenchPartReference partRef) {
 		}

 		public void partOpened(IWorkbenchPartReference partRef) {
 		}

 		public void partVisible(IWorkbenchPartReference partRef) {
 		}

 		public void partClosed(IWorkbenchPartReference partRef) {
 			editorClosed(partRef.getPart(false));
 		}

 		public void partDeactivated(IWorkbenchPartReference partRef) {
 		}

 		public void partHidden(IWorkbenchPartReference partRef) {
 		}
 	}

 	private class SelectionProvider implements IPostSelectionProvider {
 		private class PostSelectionChangedListener implements
 				ISelectionChangedListener {
 			public void selectionChanged(SelectionChangedEvent event) {
 				if (!isFiringSelection()) {
 					fireSelectionChanged(event, postListeners);
 				}
 			}
 		}

 		private class SelectionChangedListener implements
 				ISelectionChangedListener {
 			public void selectionChanged(SelectionChangedEvent event) {
 				if (!isFiringSelection()) {
 					fireSelectionChanged(event, listeners);
 				}
 			}
 		}

 		private ListenerList listeners = new ListenerList();
 		private ListenerList postListeners = new ListenerList();
 		private ISelectionChangedListener postSelectionChangedListener = new PostSelectionChangedListener();
 		private ISelectionChangedListener selectionChangedListener = new SelectionChangedListener();

 		public void addPostSelectionChangedListener(
 				ISelectionChangedListener listener) {
 			postListeners.add(listener);
 		}

 		public void addSelectionChangedListener(
 				ISelectionChangedListener listener) {
 			listeners.add(listener);
 		}

 		public void fireSelectionChanged(final SelectionChangedEvent event,
 				ListenerList listenerList) {
 			isFiringSelection = true;
 			Object[] listeners = listenerList.getListeners();
 			for (int i = 0; i < listeners.length; ++i) {
 				final ISelectionChangedListener l = (ISelectionChangedListener) listeners[i];
 				SafeRunner.run(new SafeRunnable() {
 					public void run() {
 						l.selectionChanged(event);
 					}
 				});
 			}
 			isFiringSelection = false;
 		}

 		public ISelection getSelection() {
 			if (treeViewer != null) {
 				return treeViewer.getSelection();
 			}
 			return StructuredSelection.EMPTY;
 		}

 		public boolean isFiringSelection() {
 			return isFiringSelection;
 		}

 		public void removePostSelectionChangedListener(
 				ISelectionChangedListener listener) {
 			postListeners.remove(listener);
 		}

 		public void removeSelectionChangedListener(
 				ISelectionChangedListener listener) {
 			listeners.remove(listener);
 		}

 		public void setSelection(ISelection selection) {
 			if (!isFiringSelection) {
 				treeViewer.setSelection(selection);
 			}
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2008, 2010 Chase Technology Ltd - http://www.chasetechnology.co.uk
	* 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:
	* Doug Satchwell (Chase Technology Ltd) - initial API and implementation
	* David Carver (STAR) - bug 261588 - Add Edit Namespace support for XPath view
	* David Carver (Intalio) - bug 246110 - Clean up XPath UI.
	* David Carver (Intalio) - bug 271288 - Set ContextNode for XPath Evaluation
	* Jesper Steen Moller - bug 313992 - XPath evaluation does not show atomics
	*******************************************************************************/
	package org.eclipse.wst.xml.xpath.ui.internal.views;

	import java.util.HashMap;
	import java.util.Map;

	import javax.xml.xpath.XPathExpressionException;

	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.ListenerList;
	import org.eclipse.core.runtime.SafeRunner;
	import org.eclipse.jface.action.IAction;
	import org.eclipse.jface.action.IMenuListener;
	import org.eclipse.jface.action.IMenuManager;
	import org.eclipse.jface.action.IToolBarManager;
	import org.eclipse.jface.action.MenuManager;
	import org.eclipse.jface.resource.JFaceColors;
	import org.eclipse.jface.util.SafeRunnable;
	import org.eclipse.jface.viewers.DoubleClickEvent;
	import org.eclipse.jface.viewers.IDoubleClickListener;
	import org.eclipse.jface.viewers.IPostSelectionProvider;
	import org.eclipse.jface.viewers.ISelection;
	import org.eclipse.jface.viewers.ISelectionChangedListener;
	import org.eclipse.jface.viewers.IStructuredSelection;
	import org.eclipse.jface.viewers.SelectionChangedEvent;
	import org.eclipse.jface.viewers.StructuredSelection;
	import org.eclipse.jface.viewers.TreeViewer;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.custom.CTabFolder;
	import org.eclipse.swt.custom.CTabItem;
	import org.eclipse.swt.events.ModifyEvent;
	import org.eclipse.swt.events.ModifyListener;
	import org.eclipse.swt.events.SelectionAdapter;
	import org.eclipse.swt.events.SelectionEvent;
	import org.eclipse.swt.layout.GridData;
	import org.eclipse.swt.layout.GridLayout;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Label;
	import org.eclipse.swt.widgets.Menu;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.swt.widgets.Text;
	import org.eclipse.ui.IEditorPart;
	import org.eclipse.ui.IMemento;
	import org.eclipse.ui.IPartListener2;
	import org.eclipse.ui.ISelectionListener;
	import org.eclipse.ui.IViewSite;
	import org.eclipse.ui.IWorkbenchPart;
	import org.eclipse.ui.IWorkbenchPartReference;
	import org.eclipse.ui.PartInitException;
	import org.eclipse.ui.part.IShowInSource;
	import org.eclipse.ui.part.IShowInTarget;
	import org.eclipse.ui.part.IShowInTargetList;
	import org.eclipse.ui.part.ShowInContext;
	import org.eclipse.ui.part.ViewPart;
	import org.eclipse.ui.texteditor.ITextEditor;
	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
	import org.eclipse.wst.xml.xpath.core.util.XSLTXPathHelper;
	import org.eclipse.wst.xml.xpath.ui.internal.Messages;
	import org.w3c.dom.Document;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;

	public class XPathView extends ViewPart {

	private boolean isFiringSelection = false;
	private IPartListener2 partListener2 = new XPathPartListener();
	private ISelectionListener selectionListener = new ISelectionListener() {
	public void selectionChanged(IWorkbenchPart part, ISelection selection) {
	if (part == getSite().getPage().getActiveEditor()) {
	if (selection instanceof IStructuredSelection) {
	currentSelection = (IStructuredSelection) selection;
	if (!selection.isEmpty()
	&& (currentSelection.getFirstElement() instanceof Node)) {
	recalculateLocation((Node) currentSelection
	.getFirstElement());
	boolean isLinked = xpathViewActions
	.isLinkedWithEditor(treeViewer);
	if (isLinked) {
	treeViewer.setSelection(currentSelection, true);
	}
	} else {
	recalculateLocation(null);
	}
	}
	}
	}
	};
	private TreeViewer treeViewer;
	private IEditorPart activeEditor;
	private Text text;
	// private JFaceNodeContentProviderXPath contentProvider;
	private XPathComputer xpathComputer;
	private Text locationText;
	private XPathViewActions xpathViewActions = new XPathViewActions();
	private IPostSelectionProvider selectionProvider = new SelectionProvider();
	private String location = ""; //$NON-NLS-1$
	private String message;
	private boolean expressionValid = true;
	private Integer currentSheet = Integer.valueOf(0);
	private Map<Integer, String> sheetMap;
	private IStructuredSelection currentSelection;
	private Node contextNode = null;

	public void createPartControl(Composite parent) {
	Composite parentComp = new Composite(parent, SWT.NONE);
	GridLayout gl = new GridLayout(1, false);
	gl.horizontalSpacing = 0;
	gl.verticalSpacing = 0;
	gl.marginHeight = 0;
	gl.marginWidth = 0;
	parentComp.setLayout(gl);
	GridData gd = new GridData(SWT.FILL, SWT.NONE, true, false, 2, 1);
	parentComp.setLayoutData(gd);

	Composite comp = new Composite(parentComp, SWT.NONE);
	comp.setLayout(new GridLayout(1, false));
	comp.setLayoutData(new GridData(SWT.FILL, SWT.NONE, true, false));

	Label label = new Label(comp, SWT.NONE);
	label.setText(Messages.XPathView_1);

	this.text = new Text(comp, SWT.BORDER);

	gd = new GridData(SWT.FILL, SWT.NONE, true, false);
	text.setLayoutData(gd);
	text.addModifyListener(new ModifyListener() {
	public void modifyText(ModifyEvent e) {
	recomputeXPath();
	}
	});

	this.locationText = new Text(comp, SWT.READ_ONLY \| SWT.FULL_SELECTION);
	gd = new GridData(SWT.FILL, SWT.NONE, true, false);
	locationText.setLayoutData(gd);

	this.treeViewer = new TreeViewer(parentComp, SWT.NONE);
	gd = new GridData(SWT.FILL, SWT.FILL, true, true);
	gd.horizontalSpan = 2;
	treeViewer.getControl().setLayoutData(gd);
	treeViewer.setLabelProvider(new JFaceNodeLabelProviderXPath());
	treeViewer.setContentProvider(new JFaceNodeContentProviderXPath());
	treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {

	public void selectionChanged(SelectionChangedEvent event) {
	if (getSite().getPage().getActivePart() == XPathView.this) {
	handleTreeSelection((IStructuredSelection) event
	.getSelection(), false);
	}
	}
	});
	treeViewer.addDoubleClickListener(new IDoubleClickListener() {

	public void doubleClick(DoubleClickEvent event) {
	handleTreeSelection(
	(IStructuredSelection) event.getSelection(), true);
	}

	});

	final CTabFolder folder = new CTabFolder(parentComp, SWT.BOTTOM
	\| SWT.FLAT);
	gd = new GridData(SWT.FILL, SWT.NONE, true, false);
	gd.heightHint = 0;
	folder.setLayoutData(gd);
	folder.addSelectionListener(new SelectionAdapter() {
	public void widgetSelected(SelectionEvent e) {
	CTabItem item = (CTabItem) e.item;
	sheetMap.put(currentSheet, text.getText());
	pageChange(folder.indexOf(item));
	}
	});

	for (int i = 0; i < 5; i++) {
	CTabItem item = new CTabItem(folder, SWT.NONE, i);
	// item.setControl(comp);
	item.setText(Messages.XPathView_2 + (i + 1));
	}
	folder.setSelection(currentSheet);
	pageChange(currentSheet);

	this.xpathComputer = new XPathComputer(this);
	createMenu();
	createToolbar();
	createContextMenu();

	getSite().setSelectionProvider(selectionProvider);

	initEditorListener();
	}

	private void handleTreeSelection(IStructuredSelection selection,
	boolean reveal) {
	if (activeEditor != null) {
	isFiringSelection = true;
	if (selection.getFirstElement() != null) {
	Object element = selection.getFirstElement();
	if (element instanceof IDOMNode) {
	IDOMNode node = (IDOMNode) element;
	ITextEditor textEditor = (ITextEditor) activeEditor
	.getAdapter(ITextEditor.class);

	if (textEditor != null) {
	getSite().getWorkbenchWindow().getActivePage()
	.bringToTop(textEditor);
	if (reveal) {
	textEditor
	.selectAndReveal(node.getStartOffset(),
	node.getEndOffset()
	- node.getStartOffset());
	} else {
	textEditor.setHighlightRange(node.getStartOffset(),
	0, true);
	}
	}
	}
	}
	isFiringSelection = false;
	}
	}

	private void createContextMenu() {
	MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$
	menuMgr.setRemoveAllWhenShown(true);
	menuMgr.addMenuListener(new IMenuListener() {
	public void menuAboutToShow(IMenuManager manager) {
	xpathViewActions.fillContextMenu(manager);
	}
	});
	Menu menu = menuMgr.createContextMenu(treeViewer.getControl());
	treeViewer.getControl().setMenu(menu);
	getSite().registerContextMenu(menuMgr, treeViewer);
	}

	private void pageChange(int index) {
	currentSheet = index;
	String exp = sheetMap.get(index);
	if (exp != null) {
	text.setText(exp);
	} else {
	text.setText("/"); //$NON-NLS-1$
	}
	}

	private void createMenu() {
	IMenuManager mgr = getViewSite().getActionBars().getMenuManager();
	IAction[] items = xpathViewActions.createMenuContributions(treeViewer);
	for (int i = 0; i < items.length; i++) {
	IAction item = items[i];
	mgr.add(item);
	}
	}

	private void createToolbar() {
	IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager();
	IAction[] items = xpathViewActions
	.createToolbarContributions(treeViewer);
	for (int i = 0; i < items.length; i++) {
	IAction item = items[i];
	mgr.add(item);
	}
	}

	private void recalculateLocation(Node selected) {
	this.location = XSLTXPathHelper.calculateXPathToNode(selected);
	contextNode = selected;
	updateLocationText();
	recomputeXPath();
	}

	private void recomputeXPath() {
	if (activeEditor != null) {
	boolean valid = expressionValid;
	try {
	if (contextNode != null) {
	xpathComputer.setSelectedNode(contextNode);
	}
	xpathComputer.setText(text.getText());
	xpathComputer.compute();
	valid = true;
	} catch (XPathExpressionException e) {
	valid = false;
	if (e.getCause() != null) {
	message = e.getCause().getMessage();
	} else {
	message = "Invalid XPath expression"; //$NON-NLS-1$
	}
	}
	if (expressionValid != valid) {
	expressionValid = valid;
	updateLocationText();
	}
	}
	}

	protected void xpathRecomputed(final NodeList nodeList, final IStatus error) {
	if (getSite() == null) return;
	Shell shell = getSite().getShell();
	if (shell == null) return;
	Display display = shell.getDisplay();
	if (display == null) return;
	display.asyncExec(new Runnable() {
	public void run() {
	Control refreshControl = treeViewer.getControl();
	if ((refreshControl != null) && !refreshControl.isDisposed()) {
	refreshControl.setRedraw(false);
	treeViewer.setInput(nodeList);
	treeViewer.setSelection(currentSelection, true);
	refreshControl.setRedraw(true);
	}
	if (error.getSeverity() == IStatus.OK) {
	expressionValid = true;
	message = "";
	} else {
	expressionValid = false;
	message = error.getMessage();
	}
	updateLocationText();
	}
	});
	}

	private void updateLocationText() {
	if (expressionValid) {
	locationText.setText(Messages.XPathView_0 + location);
	locationText.setForeground(null);
	} else {
	locationText.setText(message);
	locationText.setForeground(JFaceColors.getErrorText(locationText
	.getDisplay()));
	}
	}

	private void initEditorListener() {
	getSite().getPage().addPartListener(partListener2);
	getSite().getWorkbenchWindow().getSelectionService()
	.addSelectionListener(selectionListener);
	editorActivated(getSite().getPage().getActiveEditor());
	}

	public void setFocus() {
	text.setFocus();
	}

	public void dispose() {
	getSite().getPage().removePartListener(partListener2);
	getSite().getWorkbenchWindow().getSelectionService()
	.removeSelectionListener(selectionListener);
	xpathComputer.dispose();
	super.dispose();
	}

	private void editorActivated(IWorkbenchPart part) {
	if ((part != activeEditor) && (part instanceof IEditorPart)) {
	IEditorPart editor = (IEditorPart) part;
	IStructuredModel model = getEditorModel(editor);
	if (model != null) {
	activeEditor = editor;
	xpathComputer.setModel(model);
	xpathComputer.setSelectedNode((Document) model
	.getAdapter(Document.class));
	}
	recomputeXPath();
	}
	}

	private void editorClosed(IWorkbenchPart part) {
	if (part == activeEditor) {
	treeViewer.setInput(null);
	locationText.setText("");
	activeEditor = null;
	}
	}

	private IStructuredModel getEditorModel(IEditorPart editor) {
	return (IStructuredModel) editor.getAdapter(IStructuredModel.class);
	}

	@SuppressWarnings("unchecked")
	public Object getAdapter(Class key) {
	Object adapter = null;
	if (key.equals(IShowInTarget.class) && (treeViewer != null)) {
	adapter = new IShowInTarget() {
	public boolean show(ShowInContext context) {
	treeViewer.setSelection(context.getSelection());
	return treeViewer.getSelection().equals(
	context.getSelection());
	}
	};
	} else if (key.equals(IShowInSource.class) && (activeEditor != null)) {
	adapter = new IShowInSource() {
	public ShowInContext getShowInContext() {
	return new ShowInContext(activeEditor.getEditorInput(),
	activeEditor.getEditorSite().getSelectionProvider()
	.getSelection());
	}
	};
	} else if (key.equals(IShowInTargetList.class)
	&& (activeEditor != null)) {
	adapter = activeEditor.getAdapter(key);
	}
	if (adapter == null) {
	adapter = super.getAdapter(key);
	}
	return adapter;
	}

	public void saveState(IMemento memento) {
	sheetMap.put(currentSheet, text.getText());
	memento.putInteger("CurrentSheet", currentSheet); //$NON-NLS-1$
	for (Map.Entry<Integer, String> entry : sheetMap.entrySet()) {
	IMemento child = memento.createChild("Sheet"); //$NON-NLS-1$
	child.putInteger("Index", entry.getKey()); //$NON-NLS-1$
	child.putString("XPath", entry.getValue()); //$NON-NLS-1$
	}
	boolean link = xpathViewActions.isLinkWithEditor();
	memento.putBoolean("LinkWithEditor", link);
	super.saveState(memento);
	}

	@Override
	public void init(IViewSite site, IMemento memento) throws PartInitException {
	sheetMap = new HashMap<Integer, String>();
	if (memento != null) {
	IMemento[] sheets = memento.getChildren("Sheet"); //$NON-NLS-1$
	if (sheets != null) {
	currentSheet = memento.getInteger("CurrentSheet"); //$NON-NLS-1$
	for (IMemento sheet : sheets) {
	sheetMap
	.put(
	sheet.getInteger("Index"), sheet.getString("XPath")); //$NON-NLS-1$ //$NON-NLS-2$
	}
	}
	Boolean linkWithEditor = memento.getBoolean("LinkWithEditor");
	boolean link = false;
	if (linkWithEditor != null) {
	link = linkWithEditor.booleanValue();
	}
	xpathViewActions.setLinkWithEditor(link);
	}
	if (currentSheet == null) {
	currentSheet = 0;
	}
	super.init(site, memento);
	}

	private class XPathPartListener implements IPartListener2 {
	public void partActivated(IWorkbenchPartReference partRef) {
	editorActivated(partRef.getPart(false));
	}

	public void partBroughtToTop(IWorkbenchPartReference partRef) {
	}

	public void partInputChanged(IWorkbenchPartReference partRef) {
	}

	public void partOpened(IWorkbenchPartReference partRef) {
	}

	public void partVisible(IWorkbenchPartReference partRef) {
	}

	public void partClosed(IWorkbenchPartReference partRef) {
	editorClosed(partRef.getPart(false));
	}

	public void partDeactivated(IWorkbenchPartReference partRef) {
	}

	public void partHidden(IWorkbenchPartReference partRef) {
	}
	}

	private class SelectionProvider implements IPostSelectionProvider {
	private class PostSelectionChangedListener implements
	ISelectionChangedListener {
	public void selectionChanged(SelectionChangedEvent event) {
	if (!isFiringSelection()) {
	fireSelectionChanged(event, postListeners);
	}
	}
	}

	private class SelectionChangedListener implements
	ISelectionChangedListener {
	public void selectionChanged(SelectionChangedEvent event) {
	if (!isFiringSelection()) {
	fireSelectionChanged(event, listeners);
	}
	}
	}

	private ListenerList listeners = new ListenerList();
	private ListenerList postListeners = new ListenerList();
	private ISelectionChangedListener postSelectionChangedListener = new PostSelectionChangedListener();
	private ISelectionChangedListener selectionChangedListener = new SelectionChangedListener();

	public void addPostSelectionChangedListener(
	ISelectionChangedListener listener) {
	postListeners.add(listener);
	}

	public void addSelectionChangedListener(
	ISelectionChangedListener listener) {
	listeners.add(listener);
	}

	public void fireSelectionChanged(final SelectionChangedEvent event,
	ListenerList listenerList) {
	isFiringSelection = true;
	Object[] listeners = listenerList.getListeners();
	for (int i = 0; i < listeners.length; ++i) {
	final ISelectionChangedListener l = (ISelectionChangedListener) listeners[i];
	SafeRunner.run(new SafeRunnable() {
	public void run() {
	l.selectionChanged(event);
	}
	});
	}
	isFiringSelection = false;
	}

	public ISelection getSelection() {
	if (treeViewer != null) {
	return treeViewer.getSelection();
	}
	return StructuredSelection.EMPTY;
	}

	public boolean isFiringSelection() {
	return isFiringSelection;
	}

	public void removePostSelectionChangedListener(
	ISelectionChangedListener listener) {
	postListeners.remove(listener);
	}

	public void removeSelectionChangedListener(
	ISelectionChangedListener listener) {
	listeners.remove(listener);
	}

	public void setSelection(ISelection selection) {
	if (!isFiringSelection) {
	treeViewer.setSelection(selection);
	}
	}
	}
	}