| /******************************************************************************* |
| * Copyright (c) 2001, 2004 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Jens Lukowski/Innoopract - initial renaming/restructuring |
| * |
| *******************************************************************************/ |
| package org.eclipse.wst.sse.ui.internal.editorviewer; |
| |
| |
| |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.DisposeEvent; |
| import org.eclipse.swt.events.DisposeListener; |
| import org.eclipse.swt.layout.FillLayout; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IEditorActionBarContributor; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorSite; |
| import org.eclipse.ui.IKeyBindingService; |
| import org.eclipse.ui.IPersistableElement; |
| import org.eclipse.ui.IViewSite; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPartSite; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.texteditor.IDocumentProvider; |
| import org.eclipse.ui.views.contentoutline.IContentOutlinePage; |
| import org.eclipse.wst.sse.core.IStructuredModel; |
| import org.eclipse.wst.sse.core.IndexedRegion; |
| import org.eclipse.wst.sse.core.text.IStructuredDocument; |
| import org.eclipse.wst.sse.ui.StructuredTextEditor; |
| import org.eclipse.wst.sse.ui.view.events.INodeSelectionListener; |
| import org.eclipse.wst.sse.ui.view.events.NodeSelectionChangedEvent; |
| import org.eclipse.wst.sse.ui.views.contentoutline.StructuredTextEditorContentOutlinePage; |
| import org.w3c.dom.Attr; |
| |
| |
| /** |
| * TODO remove in C5 or earlier |
| * |
| * @deprecated use the StructuredTextViewer directly if only using for |
| * read-only mode. otherwise, use the StructuredTextEditorViewer |
| * in com.ibm.etools.qev plugin (removing in C5 or earlier) |
| */ |
| public class StructuredTextEditorViewer extends Viewer { |
| |
| /** |
| * Sets the editor's highlighting text range to the text range indicated |
| * by the selected Nodes. |
| */ |
| protected class NodeRangeSelectionListener implements INodeSelectionListener { |
| public void nodeSelectionChanged(NodeSelectionChangedEvent event) { |
| if (!event.getSelectedNodes().isEmpty()) { |
| IndexedRegion startNode = (IndexedRegion) event.getSelectedNodes().get(0); |
| IndexedRegion endNode = (IndexedRegion) event.getSelectedNodes().get(event.getSelectedNodes().size() - 1); |
| |
| if (startNode instanceof Attr) |
| startNode = (IndexedRegion) ((Attr) startNode).getOwnerElement(); |
| if (endNode instanceof Attr) |
| endNode = (IndexedRegion) ((Attr) endNode).getOwnerElement(); |
| |
| int start = startNode.getStartOffset(); |
| int end = endNode.getEndOffset(); |
| |
| getTextEditor().resetHighlightRange(); |
| getTextEditor().setHighlightRange(start, end - start, true); |
| } else { |
| getTextEditor().resetHighlightRange(); |
| } |
| } |
| } |
| |
| /** |
| * Unhooks the editor when in follow mode and the target editing part is |
| * disposed. |
| */ |
| protected class UnhookOnDisposeListener implements DisposeListener { |
| public void widgetDisposed(DisposeEvent e) { |
| unhook(); |
| } |
| } |
| |
| public static class ViewEditorInput implements IEditorInput { |
| |
| private IStructuredModel fStructuredModel = null; |
| |
| public ViewEditorInput(IStructuredModel model) { |
| super(); |
| fStructuredModel = model; |
| } |
| |
| public boolean exists() { |
| return fStructuredModel != null; |
| } |
| |
| public Object getAdapter(Class arg0) { |
| return null; |
| } |
| |
| public ImageDescriptor getImageDescriptor() { |
| return null; |
| } |
| |
| public String getName() { |
| if (exists()) |
| return fStructuredModel.getId(); |
| return "org.eclipse.wst.sse.ui.internal-view"; //$NON-NLS-1$ |
| } |
| |
| public IPersistableElement getPersistable() { |
| return null; |
| } |
| |
| public IStructuredModel getStructuredModel() { |
| return fStructuredModel; |
| } |
| |
| public String getToolTipText() { |
| return getStructuredModel().getBaseLocation(); |
| } |
| |
| public void setStructuredModel(IStructuredModel structuredModel) { |
| fStructuredModel = structuredModel; |
| } |
| } |
| |
| public static class ViewerEditorSite implements IEditorSite { |
| |
| protected IWorkbenchPartSite fSite = null; |
| |
| public ViewerEditorSite(IWorkbenchPartSite site) { |
| fSite = site; |
| } |
| |
| public IEditorActionBarContributor getActionBarContributor() { |
| return null; |
| } |
| |
| /** |
| * @see org.eclipse.ui.IEditorSite#getActionBars() |
| */ |
| public IActionBars getActionBars() { |
| if (fSite instanceof IViewSite) |
| return ((IViewSite) fSite).getActionBars(); |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class) |
| */ |
| public Object getAdapter(Class adapter) { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| |
| public String getId() { |
| return fSite.getId(); |
| } |
| |
| public IKeyBindingService getKeyBindingService() { |
| return fSite.getKeyBindingService(); |
| } |
| |
| public IWorkbenchPage getPage() { |
| return fSite.getPage(); |
| } |
| |
| public String getPluginId() { |
| return fSite.getPluginId(); |
| } |
| |
| public String getRegisteredName() { |
| return fSite.getRegisteredName(); |
| } |
| |
| public ISelectionProvider getSelectionProvider() { |
| return fSite.getSelectionProvider(); |
| } |
| |
| public Shell getShell() { |
| return fSite.getShell(); |
| } |
| |
| public IWorkbenchWindow getWorkbenchWindow() { |
| return fSite.getWorkbenchWindow(); |
| } |
| |
| public void registerContextMenu(MenuManager menuManager, ISelectionProvider selectionProvider) { |
| fSite.registerContextMenu(menuManager, selectionProvider); |
| } |
| |
| public void registerContextMenu(String menuId, MenuManager menuManager, ISelectionProvider selectionProvider) { |
| fSite.registerContextMenu(menuId, menuManager, selectionProvider); |
| } |
| |
| public void setSelectionProvider(ISelectionProvider provider) { |
| } |
| |
| } |
| |
| protected Composite container = null; |
| protected IContentOutlinePage fContentOutlinePage = null; |
| |
| private String fDefaultContentTypeID = null; |
| |
| protected boolean fEditable = true; |
| protected INodeSelectionListener fHighlightRangeListener = null; |
| protected IEditorInput fInput = null; |
| protected int fStyle = SWT.NONE; |
| |
| protected StructuredTextEditor fTextEditor = null; |
| |
| private Composite parent = null; |
| |
| /** |
| * Method StructuredTextEditorViewer. |
| * |
| * @param parent |
| */ |
| public StructuredTextEditorViewer(Composite parent) { |
| this(parent, SWT.NONE); |
| } |
| |
| /** |
| * Method StructuredTextEditorViewer. |
| * |
| * @param parent |
| * @param style |
| */ |
| public StructuredTextEditorViewer(Composite parent, int style) { |
| super(); |
| this.parent = parent; |
| fTextEditor = createTextEditor(); |
| fStyle = style; |
| } |
| |
| /** |
| * Method StructuredTextEditorViewer. |
| * |
| * @param parent |
| * @param style |
| * @param editor |
| */ |
| public StructuredTextEditorViewer(Composite parent, int style, StructuredTextEditor editor) { |
| super(); |
| this.parent = parent; |
| fTextEditor = editor; |
| fStyle = style; |
| } |
| |
| protected StructuredTextEditor createTextEditor() { |
| StructuredTextEditor editor = new StructuredTextEditor(); |
| return editor; |
| } |
| |
| public void dispose() { |
| getTextEditor().dispose(); |
| } |
| |
| /** |
| * If possible, retrieves the IEditorPart's |
| * StructuredTextEditorContentOutlinePage and displays the text content |
| * indicated by its Selection |
| * |
| * @param editor |
| */ |
| public void followSelection(IEditorPart editor) { |
| setInput(editor.getEditorInput()); |
| hook(editor); |
| } |
| |
| public void followSelection2(IEditorPart editor) { |
| setInput(editor.getEditorInput()); |
| hook2(editor); |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.Viewer#getControl() |
| */ |
| public Control getControl() { |
| return container; |
| } |
| |
| public String getDefaultContentTypeID() { |
| return fDefaultContentTypeID; |
| } |
| |
| public IEditorInput getEditorInput() { |
| return fInput; |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.IInputProvider#getInput() |
| */ |
| public Object getInput() { |
| return getEditorInput(); |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.ISelectionProvider#getSelection() |
| */ |
| public ISelection getSelection() { |
| return getTextEditor().getTextViewer().getSelection(); |
| } |
| |
| /** |
| * Returns the textEditor. |
| * |
| * @return StructuredTextEditor |
| */ |
| public StructuredTextEditor getTextEditor() { |
| return fTextEditor; |
| } |
| |
| protected void hook(IEditorPart editor) { |
| if (fHighlightRangeListener == null) |
| fHighlightRangeListener = new NodeRangeSelectionListener(); |
| |
| fContentOutlinePage = ((IContentOutlinePage) editor.getAdapter(IContentOutlinePage.class)); |
| if (fContentOutlinePage != null && fContentOutlinePage instanceof StructuredTextEditorContentOutlinePage) { |
| ((StructuredTextEditorContentOutlinePage) fContentOutlinePage).getViewerSelectionManager().addNodeSelectionListener(fHighlightRangeListener); |
| |
| if (!fContentOutlinePage.getSelection().isEmpty() && fContentOutlinePage.getSelection() instanceof IStructuredSelection) { |
| getTextEditor().showHighlightRangeOnly(true); |
| Object[] nodes = ((IStructuredSelection) fContentOutlinePage.getSelection()).toArray(); |
| IndexedRegion startNode = (IndexedRegion) nodes[0]; |
| IndexedRegion endNode = (IndexedRegion) nodes[nodes.length - 1]; |
| |
| if (startNode instanceof Attr) |
| startNode = (IndexedRegion) ((Attr) startNode).getOwnerElement(); |
| if (endNode instanceof Attr) |
| endNode = (IndexedRegion) ((Attr) endNode).getOwnerElement(); |
| |
| int start = startNode.getStartOffset(); |
| int end = endNode.getEndOffset(); |
| getTextEditor().resetHighlightRange(); |
| getTextEditor().setHighlightRange(start, end - start, true); |
| } |
| } |
| } |
| |
| protected void hook2(IEditorPart editor) { |
| if (fHighlightRangeListener == null) |
| fHighlightRangeListener = new NodeRangeSelectionListener(); |
| |
| fContentOutlinePage = ((IContentOutlinePage) editor.getAdapter(IContentOutlinePage.class)); |
| if (fContentOutlinePage != null && fContentOutlinePage instanceof StructuredTextEditorContentOutlinePage) { |
| ((StructuredTextEditorContentOutlinePage) fContentOutlinePage).getViewerSelectionManager().addNodeSelectionListener(fHighlightRangeListener); |
| |
| if (!fContentOutlinePage.getSelection().isEmpty() && fContentOutlinePage.getSelection() instanceof IStructuredSelection) { |
| getTextEditor().showHighlightRangeOnly(true); |
| Object[] nodes = ((IStructuredSelection) fContentOutlinePage.getSelection()).toArray(); |
| IndexedRegion startNode = (IndexedRegion) nodes[0]; |
| IndexedRegion endNode = (IndexedRegion) nodes[nodes.length - 1]; |
| |
| if (startNode instanceof Attr) |
| startNode = (IndexedRegion) ((Attr) startNode).getOwnerElement(); |
| if (endNode instanceof Attr) |
| endNode = (IndexedRegion) ((Attr) endNode).getOwnerElement(); |
| |
| int start = startNode.getStartOffset(); |
| int end = endNode.getEndOffset(); |
| getTextEditor().resetHighlightRange(); |
| getTextEditor().setHighlightRange(start, end - start, true); |
| |
| IDocument document = getTextEditor().getDocumentProvider().getDocument(getEditorInput()); |
| if (document instanceof IStructuredDocument) { |
| ((IStructuredDocument) document).makeReadOnly(start, end - start); |
| refresh(); |
| } |
| |
| } |
| } |
| } |
| |
| /** |
| * Method init, for testing. |
| * |
| * @param site |
| */ |
| public void init(IWorkbenchPartSite site, IEditorInput input) { |
| try { |
| // setInput(input); |
| // getTextEditor().init(new ViewerEditorSite(site), |
| // getEditorInput()); |
| getTextEditor().init(new ViewerEditorSite(site), input); |
| } catch (PartInitException e) { |
| e.printStackTrace(); |
| } |
| container = new Composite(parent, fStyle); |
| FillLayout fill = new FillLayout(); |
| container.setLayout(fill); |
| |
| getTextEditor().createPartControl(container); |
| // part of the specific DnD support, even though it is itself an |
| // IEditorPart |
| // TODO: 5.1W3 - should update the StructuredTextEditor to handle this |
| // functionality itself |
| getTextEditor().setEditorPart(getTextEditor()); |
| getTextEditor().getTextViewer().getTextWidget().addDisposeListener(new UnhookOnDisposeListener()); |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.Viewer#refresh() |
| */ |
| public void refresh() { |
| getTextEditor().getTextViewer().refresh(); |
| } |
| |
| /** |
| * @param string |
| */ |
| public void setDefaultContentTypeID(String string) { |
| fDefaultContentTypeID = string; |
| } |
| |
| /** |
| * Sets the documentProvider. |
| * |
| * @param documentProvider |
| * The documentProvider to set |
| */ |
| public void setDocumentProvider(IDocumentProvider documentProvider) { |
| getTextEditor().initializeDocumentProvider(documentProvider); |
| } |
| |
| public void setEditable(boolean editable) { |
| fEditable = editable; |
| } |
| |
| /** |
| * Sets the viewer's input - expects a IStructuredModel or IEditorInput |
| * |
| * @see org.eclipse.jface.viewers.Viewer#setInput(Object) |
| */ |
| public void setInput(Object input) { |
| // getTextEditor().getTextViewer().getTextWidget().setEnabled(input != |
| // null); |
| unhook(); |
| if (input instanceof IStructuredModel) { |
| fInput = new ViewEditorInput((IStructuredModel) input); |
| getTextEditor().setInput(fInput); |
| updateEditor(); |
| } else if (input instanceof IEditorInput) { |
| // if (input instanceof IFileEditorInput) { |
| // setDocumentProvider(FileModelProvider.getInstance()); |
| // } |
| fInput = (IEditorInput) input; |
| getTextEditor().setInput(fInput); |
| updateEditor(); |
| } else |
| throw new UnsupportedOperationException("setInput: unsupported type"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.Viewer#setSelection(ISelection, boolean) |
| */ |
| public void setSelection(ISelection selection, boolean reveal) { |
| getTextEditor().getTextViewer().setSelection(selection, reveal); |
| } |
| |
| /** |
| * @deprecated - leave for users |
| * |
| * Show content from the beginning of the line on which the offset "start" |
| * is located for "length" number of characters. |
| */ |
| public void show(int start, int length) { |
| getTextEditor().showHighlightRangeOnly(true); |
| getTextEditor().resetHighlightRange(); |
| getTextEditor().setHighlightRange(start, length, true); |
| } |
| |
| /** |
| * @deprecated - leave for users |
| * |
| * Show all content. |
| */ |
| public void showAll() { |
| getTextEditor().resetHighlightRange(); |
| getTextEditor().showHighlightRangeOnly(false); |
| } |
| |
| /** |
| * cease showing just the current selection in the |
| * StructuredTextEditorContentOutlinePage |
| */ |
| public void stopFollowingSelection() { |
| unhook(); |
| } |
| |
| protected void unhook() { |
| if (fContentOutlinePage != null && fContentOutlinePage instanceof StructuredTextEditorContentOutlinePage) { |
| ((StructuredTextEditorContentOutlinePage) fContentOutlinePage).getViewerSelectionManager().removeNodeSelectionListener(fHighlightRangeListener); |
| if (getTextEditor().getTextViewer() != null) { |
| showAll(); |
| } |
| fContentOutlinePage = null; |
| } |
| } |
| |
| protected void updateEditor() { |
| if (getTextEditor().getTextViewer() != null && fInput != null) { |
| getTextEditor().getTextViewer().setEditable(fEditable); |
| } |
| } |
| |
| } |
