Java tutorial
/***************************************************************************** * Copyright (c) 2004, 2011 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 ****************************************************************************/ package org.eclipse.wst.xml.ui.internal.tabletree; import java.util.Iterator; import org.eclipse.jface.action.IMenuListener; import org.eclipse.jface.action.IMenuManager; import org.eclipse.jface.action.MenuManager; import org.eclipse.jface.action.Separator; import org.eclipse.jface.text.IDocument; import org.eclipse.jface.text.ITextSelection; import org.eclipse.jface.util.LocalSelectionTransfer; import org.eclipse.jface.util.SafeRunnable; import org.eclipse.jface.viewers.CellEditor; import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent; import org.eclipse.jface.viewers.ColumnViewerEditorActivationListener; import org.eclipse.jface.viewers.ColumnViewerEditorDeactivationEvent; import org.eclipse.jface.viewers.ICellEditorListener; import org.eclipse.jface.viewers.ICellModifier; import org.eclipse.jface.viewers.IPostSelectionProvider; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.ISelectionChangedListener; import org.eclipse.jface.viewers.ISelectionProvider; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.StructuredSelection; import org.eclipse.jface.viewers.TextCellEditor; import org.eclipse.jface.viewers.TreeViewer; import org.eclipse.swt.SWT; import org.eclipse.swt.accessibility.ACC; import org.eclipse.swt.accessibility.AccessibleAdapter; import org.eclipse.swt.accessibility.AccessibleEvent; import org.eclipse.swt.dnd.DND; import org.eclipse.swt.dnd.DragSource; import org.eclipse.swt.dnd.DragSourceEvent; import org.eclipse.swt.dnd.DragSourceListener; import org.eclipse.swt.dnd.DropTarget; import org.eclipse.swt.dnd.DropTargetEvent; import org.eclipse.swt.dnd.DropTargetListener; import org.eclipse.swt.dnd.Transfer; import org.eclipse.swt.events.ControlAdapter; import org.eclipse.swt.events.ControlEvent; import org.eclipse.swt.events.DisposeEvent; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Item; import org.eclipse.swt.widgets.Menu; import org.eclipse.swt.widgets.TableItem; import org.eclipse.swt.widgets.TreeColumn; import org.eclipse.swt.widgets.TreeItem; import org.eclipse.ui.views.properties.IPropertyDescriptor; import org.eclipse.wst.sse.core.StructuredModelManager; import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel; import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion; import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion; import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument; import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel; import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode; import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext; import org.eclipse.wst.xml.ui.internal.actions.NodeAction; import org.eclipse.wst.xml.ui.internal.contentoutline.XMLNodeActionManager; import org.eclipse.wst.xml.ui.internal.dnd.DragNodeCommand; import org.w3c.dom.Document; import org.w3c.dom.NamedNodeMap; import org.w3c.dom.Node; public class XMLTableTreeViewer extends TreeViewer implements IDesignViewer { class NodeActionMenuListener implements IMenuListener { public void menuAboutToShow(IMenuManager menuManager) { // used to disable NodeSelection listening while running // NodeAction XMLNodeActionManager nodeActionManager = new XMLNodeActionManager( ((IDOMDocument) getInput()).getModel(), XMLTableTreeViewer.this) { public void beginNodeAction(NodeAction action) { super.beginNodeAction(action); } public void endNodeAction(NodeAction action) { super.endNodeAction(action); } }; nodeActionManager.fillContextMenu(menuManager, getSelection()); } } private class SelectionProvider implements IPostSelectionProvider { public void addPostSelectionChangedListener(ISelectionChangedListener listener) { XMLTableTreeViewer.this.addPostSelectionChangedListener(listener); } public void removePostSelectionChangedListener(ISelectionChangedListener listener) { XMLTableTreeViewer.this.removePostSelectionChangedListener(listener); } public void addSelectionChangedListener(ISelectionChangedListener listener) { XMLTableTreeViewer.this.addSelectionChangedListener(listener); } public ISelection getSelection() { return XMLTableTreeViewer.this.getSelection(); } public void removeSelectionChangedListener(ISelectionChangedListener listener) { XMLTableTreeViewer.this.removeSelectionChangedListener(listener); } public void setSelection(ISelection selection) { boolean selectionSet = false; if (!selection.isEmpty() && selection instanceof IStructuredSelection) { IStructuredSelection structuredSelection = (IStructuredSelection) selection; if (selection instanceof ITextSelection) { ITextSelection textSelection = (ITextSelection) selection; if (structuredSelection.size() == 1) { if (structuredSelection.getFirstElement() instanceof IDOMNode) { IDOMNode domNode = (IDOMNode) structuredSelection.getFirstElement(); IStructuredDocumentRegion startStructuredDocumentRegion = domNode .getStartStructuredDocumentRegion(); if (startStructuredDocumentRegion != null) { ITextRegion matchingRegion = startStructuredDocumentRegion .getRegionAtCharacterOffset(textSelection.getOffset()); int allowedIterations = 40; while (matchingRegion != null && !matchingRegion.getType().equals(DOMRegionContext.XML_TAG_ATTRIBUTE_NAME) && allowedIterations > 0) { matchingRegion = startStructuredDocumentRegion.getRegionAtCharacterOffset( startStructuredDocumentRegion.getStartOffset(matchingRegion) - 1); allowedIterations--; } if (matchingRegion != null && matchingRegion.getType() .equals(DOMRegionContext.XML_TAG_ATTRIBUTE_NAME)) { String attrName = startStructuredDocumentRegion.getText(matchingRegion); NamedNodeMap attributes = domNode.getAttributes(); if (attributes != null && attrName.length() > 0) { Node attr = attributes.getNamedItem(attrName); if (attr != null) { selectionSet = true; XMLTableTreeViewer.this.setSelection(new StructuredSelection(attr)); } } } } } } } } if (!selectionSet) { XMLTableTreeViewer.this.setSelection(selection); } } } private PaintListener fContentPaintListener = new PaintListener() { public void paintControl(PaintEvent e) { GC gc = e.gc; if (getTree().getItemCount() == 0) { gc.setForeground(getTree().getDisplay().getSystemColor(SWT.COLOR_LIST_FOREGROUND)); gc.setBackground(getTree().getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND)); gc.drawString(XMLEditorMessages.XMLTreeExtension_3, 10, 10); gc.drawString(XMLEditorMessages.XMLTreeExtension_4, 10, 10 + gc.getFontMetrics().getHeight()); } } }; private ISelectionProvider fSelectionProvider = new SelectionProvider(); // node: 40%, content: 60% static final double[] WEIGHTS = { .4, .6 }; private ControlAdapter fResizeAdapter = new ControlAdapter() { public void controlResized(ControlEvent e) { sizeColumns(getTree().getSize().x, WEIGHTS); } private void sizeColumns(int width, double[] weights) { TreeColumn[] columns = getTree().getColumns(); int size = columns.length; for (int i = 0; i < size; i++) { columns[i].setWidth((int) (weights[i] * width)); } } }; public XMLTableTreeViewer(Composite parent) { super(parent, SWT.FULL_SELECTION | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); TreeColumn column = new TreeColumn(this.getTree(), SWT.LEFT); column.setText(XMLEditorMessages.XMLTableTreeViewer_1); column = new TreeColumn(this.getTree(), SWT.LEFT); column.setText(XMLEditorMessages.XMLTableTreeViewer_2); this.getTree().setHeaderVisible(true); this.getTree().setLinesVisible(true); getTree().addControlListener(fResizeAdapter); getTree().getAccessible().addAccessibleListener(new AccessibleAdapter() { public void getDescription(AccessibleEvent e) { if (e.childID == ACC.CHILDID_SELF && getTree().getItemCount() == 0) { e.result = XMLEditorMessages.XMLTreeExtension_3 + "\n" + XMLEditorMessages.XMLTreeExtension_4; } } }); // set up providers propertyDescriptorFactory = new XMLTableTreePropertyDescriptorFactory(); XMLTableTreeContentProvider provider = new XMLTableTreeContentProvider(); setContentProvider(provider); setLabelProvider(provider); setColumnProperties(new String[] { STRUCTURE_PROPERTY, VALUE_PROPERTY }); setCellEditors(new CellEditor[] { null, new TextCellEditor(this.getTree()) }); setCellModifier(new XMLCMCellModifier()); createContextMenu(); DragSource dragSource = new DragSource(getControl(), DND.DROP_COPY | DND.DROP_MOVE); dragSource.addDragListener(createDragSourceListener()); dragSource.setTransfer(new Transfer[] { LocalSelectionTransfer.getTransfer() }); DropTarget dropTarget = new DropTarget(getControl(), DND.DROP_COPY | DND.DROP_MOVE); dropTarget.addDropListener(createDropTargetListener()); dropTarget.setTransfer(new Transfer[] { LocalSelectionTransfer.getTransfer() }); this.getTree().addPaintListener(fContentPaintListener); } /** * This creates a context menu for the viewer and adds a listener as well * registering the menu for extension. */ protected void createContextMenu() { MenuManager contextMenu = new MenuManager("#PopUp"); //$NON-NLS-1$ contextMenu.add(new Separator("additions")); //$NON-NLS-1$ contextMenu.setRemoveAllWhenShown(true); contextMenu.addMenuListener(new NodeActionMenuListener()); Menu menu = contextMenu.createContextMenu(getControl()); getControl().setMenu(menu); } private DragSourceListener createDragSourceListener() { return new DragSourceListener() { public void dragFinished(DragSourceEvent event) { LocalSelectionTransfer.getTransfer().setSelection(null); } public void dragSetData(DragSourceEvent event) { } public void dragStart(DragSourceEvent event) { LocalSelectionTransfer.getTransfer().setSelection(getSelection()); } }; } private DropTargetListener createDropTargetListener() { return new DropTargetListener() { public void dragEnter(DropTargetEvent event) { } public void dragLeave(DropTargetEvent event) { } public void dragOperationChanged(DropTargetEvent event) { } public void drop(DropTargetEvent event) { if (event.operations != DND.DROP_NONE && LocalSelectionTransfer.getTransfer().getSelection() instanceof IStructuredSelection) { dragOver(event); IStructuredSelection selection = (IStructuredSelection) LocalSelectionTransfer.getTransfer() .getSelection(); if (selection != null && !selection.isEmpty() && event.item != null && event.item.getData() != null) { /* * the command uses these numbers instead of the * feedback constants (even though it converts in * the other direction as well) */ float feedbackFloat = getHeightInItem(event); final DragNodeCommand command = new DragNodeCommand(event.item.getData(), feedbackFloat, event.operations, event.detail, selection.toList(), XMLTableTreeViewer.this); if (command != null && command.canExecute()) { SafeRunnable.run(new SafeRunnable() { public void run() throws Exception { command.execute(); } }); } } } } public void dropAccept(DropTargetEvent event) { } public void dragOver(DropTargetEvent event) { event.feedback = DND.FEEDBACK_SELECT; float feedbackFloat = getHeightInItem(event); if (feedbackFloat > 0.75) { event.feedback = DND.FEEDBACK_INSERT_AFTER; } else if (feedbackFloat < 0.25) { event.feedback = DND.FEEDBACK_INSERT_BEFORE; } event.feedback |= DND.FEEDBACK_EXPAND | DND.FEEDBACK_SCROLL; if (getLocalNodeSelection(event) == null) { event.detail = DND.DROP_NONE; } } private IStructuredSelection getLocalNodeSelection(DropTargetEvent event) { IStructuredSelection selection = (IStructuredSelection) LocalSelectionTransfer.getTransfer() .getSelection(); if (selection != null && !selection.isEmpty()) { for (Iterator i = selection.iterator(); i.hasNext();) { Object node = i.next(); if (node instanceof Node) { return selection; } } } return null; } private float getHeightInItem(DropTargetEvent event) { if (event.item == null) return .5f; if (event.item instanceof TreeItem) { TreeItem treeItem = (TreeItem) event.item; Control control = treeItem.getParent(); Point point = control.toControl(new Point(event.x, event.y)); Rectangle bounds = treeItem.getBounds(); return (float) (point.y - bounds.y) / (float) bounds.height; } else if (event.item instanceof TableItem) { TableItem tableItem = (TableItem) event.item; Control control = tableItem.getParent(); Point point = control.toControl(new Point(event.x, event.y)); Rectangle bounds = tableItem.getBounds(0); return (float) (point.y - bounds.y) / (float) bounds.height; } else { return 0.0F; } } }; } protected void doRefresh(Object o, boolean fromDelayed) { super.refresh(o); } public ISelectionProvider getSelectionProvider() { return fSelectionProvider; } public String getTitle() { return XMLEditorMessages.XMLTableTreeViewer_0; } protected void handleDispose(DisposeEvent event) { super.handleDispose(event); this.getTree().removePaintListener(fContentPaintListener); getTree().removeControlListener(fResizeAdapter); setDocument(null); } public void setDocument(IDocument document) { /* * let the text editor to be the one that manages the model's lifetime */ IStructuredModel model = null; try { model = StructuredModelManager.getModelManager().getExistingModelForRead(document); if ((model != null) && (model instanceof IDOMModel)) { Document domDoc = null; domDoc = ((IDOMModel) model).getDocument(); setInput(domDoc); } } finally { if (model != null) { model.releaseFromRead(); } } } protected TreeContentHelper treeContentHelper = new TreeContentHelper(); protected XMLTableTreePropertyDescriptorFactory propertyDescriptorFactory; private final static String STRUCTURE_PROPERTY = XMLEditorMessages.XMLTreeExtension_0; private final static String VALUE_PROPERTY = XMLEditorMessages.XMLTreeExtension_1; private class CellListener extends ColumnViewerEditorActivationListener implements ICellEditorListener { private Node node; private CellEditor editor; private String originalValue; CellListener(Node data, CellEditor editor) { this.node = data; this.editor = editor; originalValue = treeContentHelper.getNodeValue(node); ((IDOMNode) node).getModel().aboutToChangeModel(); } public void applyEditorValue() { editor.removeListener(this); } public void cancelEditor() { final Object value = editor.getValue(); if (value != null && !value.equals(originalValue)) { treeContentHelper.setNodeValue(node, originalValue); } editor.removeListener(this); } public void editorValueChanged(boolean oldValidState, boolean newValidState) { if (newValidState) { treeContentHelper.setNodeValue(node, editor.getValue().toString(), getControl().getShell()); } } public void beforeEditorActivated(ColumnViewerEditorActivationEvent event) { } public void afterEditorActivated(ColumnViewerEditorActivationEvent event) { } public void beforeEditorDeactivated(ColumnViewerEditorDeactivationEvent event) { } public void afterEditorDeactivated(ColumnViewerEditorDeactivationEvent event) { ((IDOMNode) node).getModel().changedModel(); getColumnViewerEditor().removeEditorActivationListener(this); } } public class XMLCMCellModifier implements ICellModifier, TreeExtension.ICellEditorProvider { public boolean canModify(Object element, String property) { boolean result = false; if (element instanceof Node) { Node node = (Node) element; if (property == VALUE_PROPERTY) { result = treeContentHelper.isEditable(node); if (result) { /* Set up the cell editor based on the element */ CellEditor[] editors = getCellEditors(); if (editors.length > 0) { if (editors[1] != null) editors[1].dispose(); editors[1] = getCellEditor(element, 1); if (editors[1] instanceof TextCellEditor) { final CellListener listener = new CellListener(node, editors[1]); getColumnViewerEditor().addEditorActivationListener(listener); editors[1].addListener(listener); } } } } } return result; } public Object getValue(Object object, String property) { String result = null; if (object instanceof Node) { result = treeContentHelper.getNodeValue((Node) object); } return (result != null) ? result : ""; //$NON-NLS-1$ } public void modify(Object element, String property, Object value) { Item item = (Item) element; String oldValue = treeContentHelper.getNodeValue((Node) item.getData()); String newValue = value.toString(); if ((newValue != null) && !newValue.equals(oldValue)) { treeContentHelper.setNodeValue((Node) item.getData(), value.toString(), getControl().getShell()); } } public CellEditor getCellEditor(Object o, int col) { IPropertyDescriptor pd = propertyDescriptorFactory.createPropertyDescriptor(o); return pd != null ? pd.createPropertyEditor(XMLTableTreeViewer.this.getTree()) : null; } } }