| /******************************************************************************* |
| * Copyright (c) 2005-2007 Orangevolt (www.orangevolt.com) |
| * 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: |
| * Orangevolt (www.orangevolt.com) - XSLT support |
| * Jesper Steen Moller - refactored Orangevolt XSLT support into WST |
| * |
| *******************************************************************************/ |
| package org.eclipse.wst.xml.xpath.ui.views; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.WeakHashMap; |
| |
| import javax.xml.namespace.NamespaceContext; |
| import javax.xml.xpath.XPath; |
| import javax.xml.xpath.XPathConstants; |
| import javax.xml.xpath.XPathExpression; |
| import javax.xml.xpath.XPathExpressionException; |
| import javax.xml.xpath.XPathFactory; |
| |
| import org.eclipse.jface.action.Action; |
| 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.action.Separator; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.text.BadLocationException; |
| import org.eclipse.jface.viewers.ComboViewer; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.CTabFolder; |
| import org.eclipse.swt.custom.CTabItem; |
| import org.eclipse.swt.custom.StyleRange; |
| import org.eclipse.swt.custom.StyledText; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.events.KeyListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Group; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IMemento; |
| import org.eclipse.ui.IPathEditorInput; |
| import org.eclipse.ui.IViewSite; |
| import org.eclipse.ui.IWorkbenchActionConstants; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.part.ViewPart; |
| import org.eclipse.wst.sse.ui.internal.provisional.extensions.ISourceEditingTextTools; |
| import org.eclipse.wst.xml.core.internal.contentmodel.util.NamespaceInfo; |
| import org.eclipse.wst.xml.core.internal.contentmodel.util.NamespaceTable; |
| import org.eclipse.wst.xml.core.internal.document.DocumentImpl; |
| import org.eclipse.wst.xml.core.internal.document.ElementImpl; |
| import org.eclipse.wst.xml.ui.internal.provisional.IDOMSourceEditingTextTools; |
| import org.eclipse.wst.xml.xpath.ui.internal.Messages; |
| import org.eclipse.wst.xml.xpath.ui.internal.XPathUIPlugin; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.CDATASection; |
| import org.w3c.dom.Comment; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.DocumentFragment; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.ProcessingInstruction; |
| |
| /** |
| * |
| */ |
| public class XPathNavigator extends ViewPart { |
| class XPathAction extends Action { |
| public void run() { |
| String expr = xpath.getText().trim(); |
| if (expr.length() == 0) { |
| xpath.setFocus(); |
| return; |
| } |
| |
| if (documents.getSelection().isEmpty()) { |
| MessageDialog.openInformation(getSite().getShell(), |
| Messages.XPathNavigator_XPath_Navigator, |
| Messages.XPathNavigator_Select_source_first); |
| documents.getCombo().setFocus(); |
| return; |
| } |
| |
| Element contextElement = getQueryContext(); |
| if (contextElement == null) { |
| return; |
| } |
| |
| try { |
| text.setText(""); //$NON-NLS-1$ |
| viewer.setInput(null); |
| |
| XPath newXPath = XPathFactory.newInstance().newXPath(); |
| |
| final List<NamespaceInfo> namespaces = createNamespaceInfo(getSelectedDocument()); |
| if (namespaces != null) { |
| |
| newXPath.setNamespaceContext(new NamespaceContext() { |
| |
| public String getNamespaceURI(String prefix) { |
| for (NamespaceInfo ni : namespaces) { |
| if (prefix.equals(ni.prefix)) { |
| return ni.uri; |
| } |
| } |
| return null; |
| } |
| |
| public String getPrefix(String uri) { |
| // Should be same as getPrefixes(uri).get(0) |
| for (NamespaceInfo ni : namespaces) { |
| if (uri.equals(ni.uri)) { |
| return ni.prefix; |
| } |
| } |
| return null; |
| } |
| |
| public Iterator<String> getPrefixes(String uri) { |
| List<String> prefixes = new LinkedList<String>(); |
| for (NamespaceInfo ni : namespaces) { |
| if (uri.equals(ni.uri)) { |
| prefixes.add(ni.prefix); |
| } |
| } |
| return prefixes.iterator(); |
| } |
| }); |
| } |
| XPathExpression xpExp = newXPath.compile(expr); |
| |
| NodeList nl = null; |
| String stringResult = null; |
| |
| // IMHO, this is really poor API design in javax.xpath. |
| // We prefer the nodeset, but if there's a string instead, we |
| // want that. It shouldn't be that hard! |
| try { |
| nl = (NodeList) xpExp.evaluate(contextElement, |
| XPathConstants.NODESET); |
| } catch (XPathExpressionException xee) { |
| stringResult = xpExp.evaluate(contextElement); // Implicit |
| // XPathConstants.STRING |
| } |
| Document document = (Document) contextElement |
| .getOwnerDocument().cloneNode(false); |
| Element root = document.createElement("xpath-result"); //$NON-NLS-1$ |
| document.appendChild(root); |
| |
| boolean odd = false; |
| |
| StringBuffer sb = new StringBuffer(); |
| |
| if (nl != null) { |
| for (int i = 0; i < nl.getLength(); ++i) { |
| Node node = nl.item(i); |
| |
| root.appendChild(document.importNode(node, true)); |
| switch (node.getNodeType()) { |
| case org.w3c.dom.Node.ATTRIBUTE_NODE: { |
| Attr attr = (Attr) node; |
| sb |
| .append("#attribute :: ").append(attr.getName()).append("=\"").append(attr.getValue()).append('"'); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| break; |
| } |
| case org.w3c.dom.Node.CDATA_SECTION_NODE: { |
| CDATASection cdata = (CDATASection) node; |
| sb.append("#cdata :: ").append(cdata.toString()); //$NON-NLS-1$ |
| break; |
| } |
| case org.w3c.dom.Node.COMMENT_NODE: { |
| Comment comment = (Comment) node; |
| sb |
| .append("#comment :: ").append(comment.toString()); //$NON-NLS-1$ |
| |
| break; |
| } |
| case org.w3c.dom.Node.DOCUMENT_FRAGMENT_NODE: { |
| DocumentFragment fragment = (DocumentFragment) node; |
| sb |
| .append("#fragment :: ").append(fragment.toString()); //$NON-NLS-1$ |
| break; |
| } |
| case org.w3c.dom.Node.DOCUMENT_NODE: { |
| Document doc = (Document) node; |
| sb.append("#document :: "); //$NON-NLS-1$ |
| sb.append(((DocumentImpl) doc).getSource()); |
| break; |
| } |
| case org.w3c.dom.Node.ELEMENT_NODE: { |
| Element element = (Element) node; |
| sb.append("#element :: "); //$NON-NLS-1$ |
| sb.append(((ElementImpl) element).getSource()); |
| break; |
| } |
| case org.w3c.dom.Node.PROCESSING_INSTRUCTION_NODE: { |
| ProcessingInstruction pi = (ProcessingInstruction) node; |
| |
| sb.append("#pi :: ").append(pi.toString()); //$NON-NLS-1$ |
| |
| break; |
| } |
| case org.w3c.dom.Node.TEXT_NODE: { |
| org.w3c.dom.Text text = (org.w3c.dom.Text) node; |
| sb.append("#text :: ").append(text.getNodeValue()); //$NON-NLS-1$ |
| |
| break; |
| } |
| default: { |
| sb |
| .append("#unknown :: ").append(node.getNodeType()).append(node.toString()); //$NON-NLS-1$ |
| } |
| } |
| |
| sb.append("\r\n"); //$NON-NLS-1$ |
| |
| text.append(sb.toString()); |
| |
| StyleRange sr = new StyleRange(); |
| sr.foreground = Display.getDefault().getSystemColor( |
| odd ? SWT.COLOR_BLACK : SWT.COLOR_DARK_BLUE); |
| sr.start = text.getText().length() - sb.length(); |
| sr.length = sb.length(); |
| text.setStyleRange(sr); |
| |
| odd = !odd; |
| sb.setLength(0); |
| } |
| } else if (stringResult != null) { |
| text.setText(stringResult); |
| resultTabs.setSelection(1); |
| } else { |
| text.setText(""); //$NON-NLS-1$ |
| } |
| |
| text.setCaretOffset(0); |
| |
| viewer.setInput(document.getDocumentElement()); |
| viewer.refresh(); |
| viewer.expandToLevel(3); |
| |
| // scroll top element into visible area |
| if (viewer.getTree().getItems().length > 0) { |
| viewer.getTree().showItem(viewer.getTree().getItems()[0]); |
| } |
| } catch (XPathExpressionException pex) { |
| MessageDialog.openError(getSite().getShell(), |
| Messages.XPathNavigator_XPath_Navigator, |
| Messages.XPathNavigator_XPath_Eval_Failed |
| + pex.getCause().getMessage()); |
| XPathUIPlugin.log(pex); |
| } catch (Exception ex) { |
| MessageDialog.openError(getSite().getShell(), |
| Messages.XPathNavigator_XPath_Navigator, |
| Messages.XPathNavigator_XPath_Eval_Failed |
| + ex.getMessage()); |
| XPathUIPlugin.log(ex); |
| } |
| } |
| } |
| |
| class RefreshAction extends Action { |
| public void run() { |
| update(); |
| } |
| } |
| |
| class ShowInSourceAction extends Action { |
| public void run() { |
| // try |
| // { |
| // NodeImpl nodeImpl = |
| // (NodeImpl)((IStructuredSelection)viewer.getSelection()).getFirstElement(); |
| // |
| // int start = nodeImpl.getStartOffset(); |
| // int end = nodeImpl.getEndOffset(); |
| // IStructuredSelection selection = |
| // (IStructuredSelection)documents.getSelection(); |
| // IEditorReference editorReference = |
| // (IEditorReference)selection.getFirstElement(); |
| // XMLMultiPageEditorPart structuredTextEditor = |
| // (XMLMultiPageEditorPart)editorReference.getEditor( true); |
| // structuredTextEditor.selectAndReveal( start, end-start); |
| // } |
| // catch( Exception ex) |
| // { |
| // MessageDialog.openError( getSite().getShell(), |
| // XPathUIMessages.XPathNavigator_XPath_Navigator, |
| // XPathUIMessages.XPathNavigator_XPath_Show_In_Source_Failed + |
| // ex.getMessage()); |
| // XPathViewPlugin.getDefault().log( "XPath Navigator : Show in source failed.", ex); //$NON-NLS-1$ |
| // } |
| } |
| } |
| |
| private TreeViewer viewer; |
| private StyledText text; |
| private CTabFolder resultTabs; |
| |
| private XPathAction query; |
| |
| private RefreshAction refresh; |
| |
| private ShowInSourceAction showInSource; |
| |
| private Text xpath; |
| |
| private ComboViewer documents; |
| |
| private Button queryByContext, queryByDocument, namespaceButton; |
| |
| protected IMemento memento; |
| |
| protected WeakHashMap<Document, List<NamespaceInfo>> namespaceInfo = new WeakHashMap<Document, List<NamespaceInfo>>(); |
| |
| /** |
| * This is a callback that will allow us to create the viewer and initialize |
| * it. |
| */ |
| public void createPartControl(Composite parent) { |
| Composite comp = new Composite(parent, SWT.NONE); |
| |
| GridLayout gridLayout = new GridLayout(); |
| gridLayout.verticalSpacing = 0; |
| gridLayout.marginHeight = 0; |
| gridLayout.marginTop = 5; |
| gridLayout.marginWidth = 0; |
| comp.setLayout(gridLayout); |
| |
| Label label = new Label(comp, SWT.NONE); |
| label.setText(Messages.XPathNavigator_XML_Source_Document); |
| GridData data = new GridData(); |
| data.horizontalAlignment = GridData.FILL; |
| data.horizontalIndent = gridLayout.horizontalSpacing / 2; |
| label.setLayoutData(data); |
| |
| documents = new ComboViewer(comp, SWT.READ_ONLY); |
| data = new GridData(); |
| data.horizontalAlignment = GridData.FILL; |
| data.grabExcessHorizontalSpace = true; |
| data.horizontalAlignment = GridData.FILL; |
| data.verticalIndent = gridLayout.marginTop; |
| data.verticalAlignment = GridData.VERTICAL_ALIGN_BEGINNING; |
| documents.getCombo().setLayoutData(data); |
| documents.setUseHashlookup(true); |
| documents.setContentProvider(new XMLEditorsContentProvider()); |
| documents.setLabelProvider(new EditorReferenceLabelProvider()); |
| documents.setInput(Boolean.TRUE); |
| |
| Group queryGroup = new Group(comp, SWT.SHADOW_NONE); |
| queryGroup.setText(Messages.XPathNavigator_Context); |
| data = new GridData(); |
| data.horizontalAlignment = GridData.FILL; |
| data.grabExcessHorizontalSpace = true; |
| data.verticalIndent = gridLayout.marginTop; |
| data.verticalAlignment = GridData.VERTICAL_ALIGN_BEGINNING; |
| queryGroup.setLayoutData(data); |
| GridLayout _gridLayout = new GridLayout(); |
| _gridLayout.numColumns = 3; |
| queryGroup.setLayout(_gridLayout); |
| |
| queryByContext = new Button(queryGroup, SWT.RADIO); |
| queryByContext.setText(Messages.XPathNavigator_Selection); |
| |
| queryByDocument = new Button(queryGroup, SWT.RADIO); |
| queryByDocument.setText(Messages.XPathNavigator_Document); |
| queryByDocument.setSelection(true); |
| |
| namespaceButton = new Button(queryGroup, SWT.PUSH); |
| namespaceButton.setText(Messages.XPathNavigator_Namespaces); |
| namespaceButton.setToolTipText(Messages.XPathNavigator_Namespaces_Tip); |
| namespaceButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| Document selectedDocument = getSelectedDocument(); |
| |
| if (selectedDocument != null) { |
| List<NamespaceInfo> info = createNamespaceInfo(selectedDocument); |
| |
| IStructuredSelection selection = (IStructuredSelection) documents |
| .getSelection(); |
| IEditorReference editorReference = (IEditorReference) selection |
| .getFirstElement(); |
| IPathEditorInput editorInput = (IPathEditorInput) editorReference |
| .getEditor(true).getEditorInput(); |
| |
| EditNamespacePrefixDialog dlg = new EditNamespacePrefixDialog( |
| XPathNavigator.this.getSite().getShell(), |
| editorInput.getPath()); |
| dlg.setNamespaceInfoList(info); |
| if (SWT.OK == dlg.open()) { |
| // Apply changes |
| } |
| } |
| } |
| }); |
| |
| label = new Label(comp, SWT.NONE); |
| label.setText(Messages.XPathNavigator_Expression); |
| data = new GridData(); |
| data.horizontalAlignment = GridData.FILL; |
| data.horizontalIndent = gridLayout.horizontalSpacing; |
| data.grabExcessHorizontalSpace = true; |
| data.horizontalIndent = gridLayout.horizontalSpacing / 2; |
| label.setLayoutData(data); |
| |
| xpath = new Text(comp, SWT.BORDER); |
| data = new GridData(); |
| data.horizontalAlignment = GridData.FILL; |
| data.grabExcessHorizontalSpace = true; |
| data.verticalIndent = gridLayout.marginTop; |
| data.verticalAlignment = GridData.VERTICAL_ALIGN_BEGINNING; |
| xpath.setLayoutData(data); |
| xpath.addKeyListener(new KeyListener() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.swt.events.KeyListener#keyReleased(org.eclipse.swt |
| * .events.KeyEvent) |
| */ |
| public void keyReleased(KeyEvent e) { |
| if (e.keyCode == '\r') { |
| query.run(); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.swt.events.KeyListener#keyPressed(org.eclipse.swt |
| * .events.KeyEvent) |
| */ |
| public void keyPressed(KeyEvent e) { |
| } |
| }); |
| |
| resultTabs = new CTabFolder(comp, SWT.BOTTOM); |
| data = new GridData(); |
| data.verticalIndent = gridLayout.marginTop; |
| data.verticalAlignment = GridData.VERTICAL_ALIGN_BEGINNING; |
| data.horizontalAlignment = GridData.FILL; |
| data.verticalAlignment = GridData.FILL; |
| data.grabExcessHorizontalSpace = true; |
| data.grabExcessVerticalSpace = true; |
| resultTabs.setLayoutData(data); |
| |
| viewer = new TreeViewer(resultTabs, SWT.H_SCROLL | SWT.V_SCROLL); |
| viewer.setLabelProvider(new DOMNodeLabelProvider()); |
| viewer.setContentProvider(new DOMTreeContentProvider()); |
| viewer.addFilter(new DOMViewerFilter()); |
| viewer.addSelectionChangedListener(new ISelectionChangedListener() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged |
| * (org.eclipse.jface.viewers.SelectionChangedEvent) |
| */ |
| public void selectionChanged(SelectionChangedEvent event) { |
| showInSource.setEnabled(!event.getSelection().isEmpty()); |
| } |
| }); |
| CTabItem item = new CTabItem(resultTabs, SWT.NULL); |
| item.setText(Messages.XPathNavigator_DOM_Tree); |
| item.setControl(viewer.getControl()); |
| |
| resultTabs.setSelection(item); |
| |
| text = new StyledText(resultTabs, SWT.MULTI | SWT.H_SCROLL |
| | SWT.V_SCROLL); |
| Color white = text.getBackground(); |
| text.setEditable(false); |
| text.setBackground(white); |
| item = new CTabItem(resultTabs, SWT.NULL); |
| item.setText(Messages.XPathNavigator_Text); |
| item.setControl(text); |
| |
| makeActions(); |
| hookContextMenu(); |
| contributeToActionBars(); |
| |
| if (memento != null) { |
| restoreState(); |
| memento = null; |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.part.ViewPart#init(org.eclipse.ui.IViewSite, |
| * org.eclipse.ui.IMemento) |
| */ |
| public void init(IViewSite site, IMemento memento) throws PartInitException { |
| super.init(site, memento); |
| this.memento = memento; |
| } |
| |
| public static final String MEMENTO_XPATHNAVIGATOR_SECTION = "xpath-navigator-view"; //$NON-NLS-1$ |
| |
| public static final String MEMENTO_QUERYCONTEXT_KEY = "query-context"; //$NON-NLS-1$ |
| public static final String MEMENTO_QUERYCONTEXT_DOCUMENT = "document"; //$NON-NLS-1$ |
| public static final String MEMENTO_QUERYCONTEXT_SELECTION = "selection"; //$NON-NLS-1$ |
| |
| public static final String MEMENTO_XPATHQUERY_KEY = "xpath-query"; //$NON-NLS-1$ |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.part.ViewPart#saveState(org.eclipse.ui.IMemento) |
| */ |
| public void saveState(IMemento memento) { |
| IMemento settings = memento.createChild(MEMENTO_XPATHNAVIGATOR_SECTION); |
| // System.out.println( "queryByDocument.getSelection()=" + |
| // queryByDocument.getSelection()); |
| settings.putString(MEMENTO_QUERYCONTEXT_KEY, queryByDocument |
| .getSelection() ? MEMENTO_QUERYCONTEXT_DOCUMENT |
| : MEMENTO_QUERYCONTEXT_SELECTION); |
| settings.putString(MEMENTO_XPATHQUERY_KEY, xpath.getText()); |
| super.saveState(memento); |
| } |
| |
| /** |
| * |
| */ |
| protected void restoreState() { |
| IMemento settings = memento.getChild(MEMENTO_XPATHNAVIGATOR_SECTION); |
| if (settings != null) { |
| String queryContext = settings.getString(MEMENTO_QUERYCONTEXT_KEY); |
| if (MEMENTO_QUERYCONTEXT_DOCUMENT.equals(queryContext)) { |
| queryByDocument.setSelection(true); |
| queryByContext.setSelection(false); |
| } else { |
| queryByDocument.setSelection(false); |
| queryByContext.setSelection(true); |
| } |
| |
| xpath.setText(settings.getString(MEMENTO_XPATHQUERY_KEY)); |
| } |
| } |
| |
| private void hookContextMenu() { |
| MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$ |
| menuMgr.setRemoveAllWhenShown(true); |
| menuMgr.addMenuListener(new IMenuListener() { |
| public void menuAboutToShow(IMenuManager manager) { |
| XPathNavigator.this.fillContextMenu(manager); |
| } |
| }); |
| Menu menu = menuMgr.createContextMenu(viewer.getControl()); |
| viewer.getControl().setMenu(menu); |
| getSite().registerContextMenu(menuMgr, viewer); |
| } |
| |
| private void contributeToActionBars() { |
| IActionBars bars = getViewSite().getActionBars(); |
| fillLocalPullDown(bars.getMenuManager()); |
| fillLocalToolBar(bars.getToolBarManager()); |
| } |
| |
| private void fillLocalPullDown(IMenuManager manager) { |
| manager.add(query); |
| manager.add(refresh); |
| } |
| |
| private void fillContextMenu(IMenuManager manager) { |
| manager.add(query); |
| manager.add(refresh); |
| manager.add(new Separator()); |
| manager.add(showInSource); |
| manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); |
| } |
| |
| private void fillLocalToolBar(IToolBarManager manager) { |
| manager.add(query); |
| manager.add(refresh); |
| } |
| |
| private void makeActions() { |
| query = new XPathAction(); |
| query.setText(Messages.XPathNavigator_Run_XPath_Query); |
| query.setToolTipText(Messages.XPathNavigator_Run_on_selected); |
| query.setImageDescriptor(XPathUIPlugin.getDefault().getImageRegistry() |
| .getDescriptor("run")); //$NON-NLS-1$ |
| |
| refresh = new RefreshAction(); |
| refresh.setText(Messages.XPathNavigator_Refresh_Source_Docs); |
| refresh.setToolTipText(Messages.XPathNavigator_Refresh_Source_Docs_Tip); |
| refresh.setImageDescriptor(XPathUIPlugin.getDefault() |
| .getImageRegistry().getDescriptor("refresh")); //$NON-NLS-1$ |
| |
| showInSource = new ShowInSourceAction(); |
| showInSource.setText(Messages.XPathNavigator_Show_In_Source); |
| showInSource.setToolTipText(Messages.XPathNavigator_Show_In_Source_Tip); |
| } |
| |
| protected Document getSelectedDocument() { |
| IStructuredSelection selection = (IStructuredSelection) documents |
| .getSelection(); |
| IEditorReference editorReference = (IEditorReference) selection |
| .getFirstElement(); |
| |
| return (Document) editorReference.getEditor(true).getAdapter( |
| Document.class); |
| } |
| |
| protected Element getQueryContext() { |
| IStructuredSelection selection = (IStructuredSelection) documents |
| .getSelection(); |
| IEditorReference editorReference = (IEditorReference) selection |
| .getFirstElement(); |
| |
| IEditorPart structuredTextEditor = editorReference.getEditor(true); |
| |
| if (queryByContext.getSelection()) { |
| ISourceEditingTextTools sett = (ISourceEditingTextTools) structuredTextEditor |
| .getAdapter(ISourceEditingTextTools.class); |
| if (sett instanceof IDOMSourceEditingTextTools) { |
| IDOMSourceEditingTextTools idsett = (IDOMSourceEditingTextTools) sett; |
| Node n = null; |
| try { |
| n = idsett.getNode(idsett.getCaretOffset()); |
| } catch (BadLocationException e) { |
| MessageDialog.openInformation(getSite().getShell(), |
| Messages.XPathNavigator_XPath_Navigator, |
| Messages.XPathNavigator_Node_could_not_be_selected); |
| } |
| |
| // Go upwards to an element |
| while ((n != null) |
| && !((n instanceof Element) || (n instanceof Document))) { |
| n = n.getParentNode(); |
| } |
| |
| if (n instanceof Document) { |
| n = ((Document) n).getDocumentElement(); |
| } |
| |
| if (n == null) { |
| MessageDialog.openInformation(getSite().getShell(), |
| Messages.XPathNavigator_XPath_Navigator, |
| Messages.XPathNavigator_Nothing_selected); |
| structuredTextEditor.setFocus(); |
| return null; |
| } |
| return (Element) n; |
| } |
| } |
| return ((Document) structuredTextEditor.getAdapter(Document.class)) |
| .getDocumentElement(); |
| } |
| |
| /** |
| * Passing the focus request to the viewer's control. |
| */ |
| public void setFocus() { |
| xpath.setFocus(); |
| } |
| |
| public void update() { |
| ISelection selection = documents.getSelection(); |
| |
| // dummy call to force refresh viewer |
| documents.setInput(documents.getInput() == Boolean.FALSE ? Boolean.TRUE |
| : Boolean.FALSE); |
| |
| documents.setSelection(selection); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private List<NamespaceInfo> createNamespaceInfo(Document document) { |
| List<NamespaceInfo> info = namespaceInfo.get(document); |
| if (info == null) { |
| info = new ArrayList<NamespaceInfo>(); |
| NamespaceTable namespaceTable = new NamespaceTable(document); |
| namespaceTable.visitElement(document.getDocumentElement()); |
| Collection<?> namespaces = namespaceTable |
| .getNamespaceInfoCollection(); |
| info.addAll((Collection<NamespaceInfo>) namespaces); |
| namespaceInfo.put(document, info); |
| } |
| return info; |
| } |
| |
| static class XMLEditorsContentProvider implements |
| IStructuredContentProvider { |
| public Object[] getElements(Object inputElement) { |
| ArrayList<IEditorReference> editorReferences = new ArrayList<IEditorReference>(); |
| |
| IWorkbenchWindow[] windows = PlatformUI.getWorkbench() |
| .getWorkbenchWindows(); |
| |
| for (int i = 0; i < windows.length; i++) { |
| IWorkbenchWindow window = windows[i]; |
| |
| IWorkbenchPage[] pages = window.getPages(); |
| for (int j = 0; j < pages.length; j++) { |
| IWorkbenchPage page = pages[j]; |
| IEditorReference[] editors = page.getEditorReferences(); |
| |
| editorReferences.addAll(Arrays.asList(editors)); |
| } |
| } |
| ArrayList<IEditorReference> aClone = new ArrayList<IEditorReference>(); |
| aClone.addAll(editorReferences); |
| |
| for (IEditorReference ref : aClone) { |
| if (!(ref.getEditor(false) instanceof IEditorPart)) { |
| editorReferences.remove(ref); |
| } |
| } |
| |
| return editorReferences.toArray(); |
| } |
| |
| public void dispose() { |
| } |
| |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| // System.out.println( "inputChanged"); |
| } |
| } |
| |
| static class EditorReferenceLabelProvider extends LabelProvider { |
| /** |
| * A string used to indicate that an editor is dirty |
| */ |
| public static char DIRTY_INDICATOR = '*'; |
| |
| /** |
| * @see ILabelProvider#getImage(Object) |
| */ |
| public Image getImage(Object element) { |
| if (element instanceof IEditorReference) { |
| return ((IEditorReference) element).getTitleImage(); |
| } |
| return super.getImage(element); |
| } |
| |
| /** |
| * @see ILabelProvider#getText(Object) |
| */ |
| public String getText(Object element) { |
| if (element instanceof IEditorReference) { |
| IEditorReference reference = ((IEditorReference) element); |
| StringBuffer buffer = new StringBuffer(); |
| if (reference.isDirty()) { |
| buffer.append(DIRTY_INDICATOR); |
| } |
| buffer.append(reference.getTitle()); |
| return buffer.toString(); |
| } |
| return super.getText(element); |
| } |
| } |
| } |