| /******************************************************************************* |
| * 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.ui.internal.tabletree.XMLMultiPageEditorPart; |
| import org.eclipse.wst.xml.xpath.ui.XPathUIMessages; |
| import org.eclipse.wst.xml.xpath.ui.XPathViewPlugin; |
| 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(), XPathUIMessages.XPathNavigator_XPath_Navigator, XPathUIMessages.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(), XPathUIMessages.XPathNavigator_XPath_Navigator, XPathUIMessages.XPathNavigator_XPath_Eval_Failed + pex.getCause().getMessage()); |
| XPathViewPlugin.getDefault().log( "XPath Navigator : XPath Expression evaluation failed.", pex); //$NON-NLS-1$ |
| } |
| catch( Exception ex) |
| { |
| MessageDialog.openError( getSite().getShell(), XPathUIMessages.XPathNavigator_XPath_Navigator, XPathUIMessages.XPathNavigator_XPath_Eval_Failed + ex.getMessage()); |
| XPathViewPlugin.getDefault().log( "XPath Navigator : XPath Expression evaluation failed.", ex); //$NON-NLS-1$ |
| } |
| } |
| } |
| |
| 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(XPathUIMessages.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( XPathUIMessages.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( XPathUIMessages.XPathNavigator_Selection); |
| |
| queryByDocument = new Button( queryGroup, SWT.RADIO); |
| queryByDocument.setText( XPathUIMessages.XPathNavigator_Document); |
| queryByDocument.setSelection( true); |
| |
| namespaceButton = new Button( queryGroup, SWT.PUSH); |
| namespaceButton.setText(XPathUIMessages.XPathNavigator_Namespaces); |
| namespaceButton.setToolTipText(XPathUIMessages.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(XPathUIMessages.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 ( XPathUIMessages.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 ( XPathUIMessages.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(XPathUIMessages.XPathNavigator_Run_XPath_Query); |
| query.setToolTipText(XPathUIMessages.XPathNavigator_Run_on_selected); |
| query.setImageDescriptor(XPathViewPlugin.getDefault().getImageRegistry().getDescriptor("run")); //$NON-NLS-1$ |
| |
| refresh = new RefreshAction(); |
| refresh.setText(XPathUIMessages.XPathNavigator_Refresh_Source_Docs); |
| refresh.setToolTipText(XPathUIMessages.XPathNavigator_Refresh_Source_Docs_Tip); |
| refresh.setImageDescriptor( XPathViewPlugin.getDefault().getImageRegistry().getDescriptor( "refresh")); //$NON-NLS-1$ |
| |
| showInSource = new ShowInSourceAction(); |
| showInSource.setText(XPathUIMessages.XPathNavigator_Show_In_Source); |
| showInSource.setToolTipText(XPathUIMessages.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(), XPathUIMessages.XPathNavigator_XPath_Navigator, XPathUIMessages.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(), XPathUIMessages.XPathNavigator_XPath_Navigator, XPathUIMessages.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") //$NON-NLS-1$ |
| 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); |
| } |
| } |
| } |
