Java tutorial
/******************************************************************************* * Copyright (c) 2000, 2009 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.compare.structuremergeviewer; import java.util.Iterator; import java.util.ResourceBundle; import org.eclipse.compare.*; import org.eclipse.compare.internal.Utilities; import org.eclipse.compare.internal.patch.DiffViewerComparator; import org.eclipse.jface.action.*; import org.eclipse.jface.util.IPropertyChangeListener; import org.eclipse.jface.util.PropertyChangeEvent; import org.eclipse.jface.viewers.*; import org.eclipse.swt.SWT; import org.eclipse.swt.events.DisposeEvent; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.widgets.*; /** * A tree viewer that works on objects implementing * the <code>IDiffContainer</code> and <code>IDiffElement</code> interfaces. * <p> * This class may be instantiated; it is not intended to be subclassed outside * this package. * </p> * * @see IDiffContainer * @see IDiffElement * @noextend This class is not intended to be subclassed by clients. */ public class DiffTreeViewer extends TreeViewer { class DiffViewerContentProvider implements ITreeContentProvider { public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { // empty implementation } public boolean isDeleted(Object element) { return false; } public void dispose() { inputChanged(DiffTreeViewer.this, getInput(), null); } public Object getParent(Object element) { if (element instanceof IDiffElement) return ((IDiffElement) element).getParent(); return null; } public final boolean hasChildren(Object element) { if (element instanceof IDiffContainer) return ((IDiffContainer) element).hasChildren(); return false; } public final Object[] getChildren(Object element) { if (element instanceof IDiffContainer) return ((IDiffContainer) element).getChildren(); return new Object[0]; } public Object[] getElements(Object element) { return getChildren(element); } } /* * Takes care of swapping left and right if fLeftIsLocal * is true. */ class DiffViewerLabelProvider extends LabelProvider { public String getText(Object element) { if (element instanceof IDiffElement) return ((IDiffElement) element).getName(); return Utilities.getString(fBundle, "defaultLabel"); //$NON-NLS-1$ } public Image getImage(Object element) { if (element instanceof IDiffElement) { IDiffElement input = (IDiffElement) element; int kind = input.getKind(); if (fLeftIsLocal) { switch (kind & Differencer.DIRECTION_MASK) { case Differencer.LEFT: kind = (kind & ~Differencer.LEFT) | Differencer.RIGHT; break; case Differencer.RIGHT: kind = (kind & ~Differencer.RIGHT) | Differencer.LEFT; break; } } return fCompareConfiguration.getImage(input.getImage(), kind); } return null; } } static class FilterSame extends ViewerFilter { public boolean select(Viewer viewer, Object parentElement, Object element) { if (element instanceof IDiffElement) return (((IDiffElement) element).getKind() & Differencer.PSEUDO_CONFLICT) == 0; return true; } public boolean isFilterProperty(Object element, Object property) { return false; } } private ResourceBundle fBundle; private CompareConfiguration fCompareConfiguration; /* package */ boolean fLeftIsLocal; private IPropertyChangeListener fPropertyChangeListener; private Action fCopyLeftToRightAction; private Action fCopyRightToLeftAction; private Action fEmptyMenuAction; private Action fExpandAllAction; /** * Creates a new viewer for the given SWT tree control with the specified configuration. * * @param tree the tree control * @param configuration the configuration for this viewer */ public DiffTreeViewer(Tree tree, CompareConfiguration configuration) { super(tree); initialize(configuration == null ? new CompareConfiguration() : configuration); } /** * Creates a new viewer under the given SWT parent and with the specified configuration. * * @param parent the SWT control under which to create the viewer * @param configuration the configuration for this viewer */ public DiffTreeViewer(Composite parent, CompareConfiguration configuration) { super(new Tree(parent, SWT.MULTI)); initialize(configuration == null ? new CompareConfiguration() : configuration); } private void initialize(CompareConfiguration configuration) { Control tree = getControl(); INavigatable nav = new INavigatable() { public boolean selectChange(int flag) { if (flag == INavigatable.FIRST_CHANGE) { setSelection(StructuredSelection.EMPTY); flag = INavigatable.NEXT_CHANGE; } else if (flag == INavigatable.LAST_CHANGE) { setSelection(StructuredSelection.EMPTY); flag = INavigatable.PREVIOUS_CHANGE; } // Fix for http://dev.eclipse.org/bugs/show_bug.cgi?id=20106 return internalNavigate(flag == INavigatable.NEXT_CHANGE, true); } public Object getInput() { return DiffTreeViewer.this.getInput(); } public boolean openSelectedChange() { return internalOpen(); } public boolean hasChange(int changeFlag) { return getNextItem(changeFlag == INavigatable.NEXT_CHANGE, false) != null; } }; tree.setData(INavigatable.NAVIGATOR_PROPERTY, nav); fLeftIsLocal = Utilities.getBoolean(configuration, "LEFT_IS_LOCAL", false); //$NON-NLS-1$ tree.setData(CompareUI.COMPARE_VIEWER_TITLE, getTitle()); Composite parent = tree.getParent(); fBundle = ResourceBundle.getBundle("org.eclipse.compare.structuremergeviewer.DiffTreeViewerResources"); //$NON-NLS-1$ // register for notification with the CompareConfiguration fCompareConfiguration = configuration; if (fCompareConfiguration != null) { fPropertyChangeListener = new IPropertyChangeListener() { public void propertyChange(PropertyChangeEvent event) { DiffTreeViewer.this.propertyChange(event); } }; fCompareConfiguration.addPropertyChangeListener(fPropertyChangeListener); } setContentProvider(new DiffViewerContentProvider()); setLabelProvider(new DiffViewerLabelProvider()); addSelectionChangedListener(new ISelectionChangedListener() { public void selectionChanged(SelectionChangedEvent se) { updateActions(); } }); setComparator(new DiffViewerComparator()); ToolBarManager tbm = CompareViewerPane.getToolBarManager(parent); if (tbm != null) { tbm.removeAll(); tbm.add(new Separator("merge")); //$NON-NLS-1$ tbm.add(new Separator("modes")); //$NON-NLS-1$ tbm.add(new Separator("navigation")); //$NON-NLS-1$ createToolItems(tbm); updateActions(); tbm.update(true); } MenuManager mm = new MenuManager(); mm.setRemoveAllWhenShown(true); mm.addMenuListener(new IMenuListener() { public void menuAboutToShow(IMenuManager mm2) { fillContextMenu(mm2); if (mm2.isEmpty()) { if (fEmptyMenuAction == null) { fEmptyMenuAction = new Action(Utilities.getString(fBundle, "emptyMenuItem")) { //$NON-NLS-1$ // left empty }; fEmptyMenuAction.setEnabled(false); } mm2.add(fEmptyMenuAction); } } }); tree.setMenu(mm.createContextMenu(tree)); } /** * Returns the viewer's name. * * @return the viewer's name */ public String getTitle() { String title = Utilities.getString(fBundle, "title", null); //$NON-NLS-1$ if (title == null) title = Utilities.getString("DiffTreeViewer.title"); //$NON-NLS-1$ return title; } /** * Returns the resource bundle. * * @return the viewer's resource bundle */ protected ResourceBundle getBundle() { return fBundle; } /** * Returns the compare configuration of this viewer. * * @return the compare configuration of this viewer */ public CompareConfiguration getCompareConfiguration() { return fCompareConfiguration; } /** * Called on the viewer disposal. * Unregisters from the compare configuration. * Clients may extend if they have to do additional cleanup. * @param event dispose event that triggered call to this method */ protected void handleDispose(DisposeEvent event) { if (fCompareConfiguration != null) { if (fPropertyChangeListener != null) fCompareConfiguration.removePropertyChangeListener(fPropertyChangeListener); fCompareConfiguration = null; } fPropertyChangeListener = null; super.handleDispose(event); } /** * Tracks property changes of the configuration object. * Clients may extend to track their own property changes. * @param event property change event that triggered call to this method */ protected void propertyChange(PropertyChangeEvent event) { // empty default implementation } protected void inputChanged(Object in, Object oldInput) { super.inputChanged(in, oldInput); if (in != oldInput) { initialSelection(); updateActions(); } } /** * This hook method is called from within <code>inputChanged</code> * after a new input has been set but before any controls are updated. * This default implementation calls <code>navigate(true)</code> * to select and expand the first leaf node. * Clients can override this method and are free to decide whether * they want to call the inherited method. * * @since 2.0 */ protected void initialSelection() { navigate(true); } /** * Overridden to avoid expanding <code>DiffNode</code>s that shouldn't expand. * @param node the node to expand * @param level non-negative level, or <code>ALL_LEVELS</code> to collapse all levels of the tree */ protected void internalExpandToLevel(Widget node, int level) { Object data = node.getData(); if (dontExpand(data)) return; super.internalExpandToLevel(node, level); } /** * This hook method is called from within <code>internalExpandToLevel</code> * to control whether a given model node should be expanded or not. * This default implementation checks whether the object is a <code>DiffNode</code> and * calls <code>dontExpand()</code> on it. * Clients can override this method and are free to decide whether * they want to call the inherited method. * * @param o the model object to be expanded * @return <code>false</code> if a node should be expanded, <code>true</code> to prevent expanding * @since 2.0 */ protected boolean dontExpand(Object o) { return o instanceof DiffNode && ((DiffNode) o).dontExpand(); } //---- merge action support /** * This factory method is called after the viewer's controls have been created. * It installs four actions in the given <code>ToolBarManager</code>. Two actions * allow for copying one side of a <code>DiffNode</code> to the other side. * Two other actions are for navigating from one node to the next (previous). * <p> * Clients can override this method and are free to decide whether they want to call * the inherited method. * * @param toolbarManager the toolbar manager for which to add the actions */ protected void createToolItems(ToolBarManager toolbarManager) { // fCopyLeftToRightAction= new Action() { // public void run() { // copySelected(true); // } // }; // Utilities.initAction(fCopyLeftToRightAction, fBundle, "action.TakeLeft."); // toolbarManager.appendToGroup("merge", fCopyLeftToRightAction); // fCopyRightToLeftAction= new Action() { // public void run() { // copySelected(false); // } // }; // Utilities.initAction(fCopyRightToLeftAction, fBundle, "action.TakeRight."); // toolbarManager.appendToGroup("merge", fCopyRightToLeftAction); // fNextAction= new Action() { // public void run() { // navigate(true); // } // }; // Utilities.initAction(fNextAction, fBundle, "action.NextDiff."); //$NON-NLS-1$ // toolbarManager.appendToGroup("navigation", fNextAction); //$NON-NLS-1$ // fPreviousAction= new Action() { // public void run() { // navigate(false); // } // }; // Utilities.initAction(fPreviousAction, fBundle, "action.PrevDiff."); //$NON-NLS-1$ // toolbarManager.appendToGroup("navigation", fPreviousAction); //$NON-NLS-1$ } /** * This method is called to add actions to the viewer's context menu. * It installs actions for expanding tree nodes, copying one side of a <code>DiffNode</code> to the other side. * Clients can override this method and are free to decide whether they want to call * the inherited method. * * @param manager the menu manager for which to add the actions */ protected void fillContextMenu(IMenuManager manager) { if (fExpandAllAction == null) { fExpandAllAction = new Action() { public void run() { expandSelection(); } }; Utilities.initAction(fExpandAllAction, fBundle, "action.ExpandAll."); //$NON-NLS-1$ } boolean enable = false; ISelection selection = getSelection(); if (selection instanceof IStructuredSelection) { Iterator elements = ((IStructuredSelection) selection).iterator(); while (elements.hasNext()) { Object element = elements.next(); if (element instanceof IDiffContainer) { if (((IDiffContainer) element).hasChildren()) { enable = true; break; } } } } fExpandAllAction.setEnabled(enable); manager.add(fExpandAllAction); if (fCopyLeftToRightAction != null) manager.add(fCopyLeftToRightAction); if (fCopyRightToLeftAction != null) manager.add(fCopyRightToLeftAction); } /** * Expands to infinity all items in the selection. * * @since 2.0 */ protected void expandSelection() { ISelection selection = getSelection(); if (selection instanceof IStructuredSelection) { Iterator elements = ((IStructuredSelection) selection).iterator(); while (elements.hasNext()) { Object next = elements.next(); expandToLevel(next, ALL_LEVELS); } } } /** * Copies one side of all <code>DiffNode</code>s in the current selection to the other side. * Called from the (internal) actions for copying the sides of a <code>DiffNode</code>. * Clients may override. * * @param leftToRight if <code>true</code> the left side is copied to the right side. * If <code>false</code> the right side is copied to the left side */ protected void copySelected(boolean leftToRight) { ISelection selection = getSelection(); if (selection instanceof IStructuredSelection) { Iterator e = ((IStructuredSelection) selection).iterator(); while (e.hasNext()) { Object element = e.next(); if (element instanceof ICompareInput) copyOne((ICompareInput) element, leftToRight); } } } /** * Called to copy one side of the given node to the other. * This default implementation delegates the call to <code>ICompareInput.copy(...)</code>. * Clients may override. * @param node the node to copy * @param leftToRight if <code>true</code> the left side is copied to the right side. * If <code>false</code> the right side is copied to the left side */ protected void copyOne(ICompareInput node, boolean leftToRight) { node.copy(leftToRight); // update node's image update(new Object[] { node }, null); } /** * Selects the next (or previous) node of the current selection. * If there is no current selection the first (last) node in the tree is selected. * Wraps around at end or beginning. * Clients may override. * * @param next if <code>true</code> the next node is selected, otherwise the previous node */ protected void navigate(boolean next) { // Fix for http://dev.eclipse.org/bugs/show_bug.cgi?id=20106 internalNavigate(next, false); } //---- private /** * Selects the next (or previous) node of the current selection. * If there is no current selection the first (last) node in the tree is selected. * Wraps around at end or beginning. * Clients may override. * * @param next if <code>true</code> the next node is selected, otherwise the previous node * @param fireOpen if <code>true</code> an open event is fired. * @return <code>true</code> if at end (or beginning) */ private boolean internalNavigate(boolean next, boolean fireOpen) { Control c = getControl(); if (!(c instanceof Tree) || c.isDisposed()) return false; TreeItem item = getNextItem(next, true); if (item != null) { internalSetSelection(item, fireOpen); } return item == null; } private TreeItem getNextItem(boolean next, boolean expand) { Control c = getControl(); if (!(c instanceof Tree) || c.isDisposed()) return null; Tree tree = (Tree) c; TreeItem item = null; TreeItem children[] = tree.getSelection(); if (children != null && children.length > 0) item = children[0]; if (item == null) { children = tree.getItems(); if (children != null && children.length > 0) { item = children[0]; if (item != null && item.getItemCount() <= 0) { return item; } } } while (true) { item = findNextPrev(item, next, expand); if (item == null) break; if (item.getItemCount() <= 0) break; } return item; } private TreeItem findNextPrev(TreeItem item, boolean next, boolean expand) { if (item == null) return null; TreeItem children[] = null; if (!next) { TreeItem parent = item.getParentItem(); if (parent != null) children = parent.getItems(); else children = item.getParent().getItems(); if (children != null && children.length > 0) { // goto previous child int index = 0; for (; index < children.length; index++) if (children[index] == item) break; if (index > 0) { item = children[index - 1]; while (true) { createChildren(item); int n = item.getItemCount(); if (n <= 0) break; if (expand) item.setExpanded(true); item = item.getItems()[n - 1]; } // previous return item; } } // go up item = parent; } else { if (expand) item.setExpanded(true); createChildren(item); if (item.getItemCount() > 0) { // has children: go down children = item.getItems(); return children[0]; } while (item != null) { children = null; TreeItem parent = item.getParentItem(); if (parent != null) children = parent.getItems(); else children = item.getParent().getItems(); if (children != null && children.length > 0) { // goto next child int index = 0; for (; index < children.length; index++) if (children[index] == item) break; if (index < children.length - 1) { // next return children[index + 1]; } } // go up item = parent; } } return item; } private void internalSetSelection(TreeItem ti, boolean fireOpen) { if (ti != null) { Object data = ti.getData(); if (data != null) { // Fix for http://dev.eclipse.org/bugs/show_bug.cgi?id=20106 ISelection selection = new StructuredSelection(data); setSelection(selection, true); ISelection currentSelection = getSelection(); if (fireOpen && currentSelection != null && selection.equals(currentSelection)) { fireOpen(new OpenEvent(this, selection)); } } } } private final boolean isEditable(Object element, boolean left) { if (element instanceof ICompareInput) { ICompareInput diff = (ICompareInput) element; Object side = left ? diff.getLeft() : diff.getRight(); if (side == null && diff instanceof IDiffElement) { IDiffContainer container = ((IDiffElement) diff).getParent(); if (container instanceof ICompareInput) { ICompareInput parent = (ICompareInput) container; side = left ? parent.getLeft() : parent.getRight(); } } if (side instanceof IEditableContent) return ((IEditableContent) side).isEditable(); } return false; } private void updateActions() { int leftToRight = 0; int rightToLeft = 0; ISelection selection = getSelection(); if (selection instanceof IStructuredSelection) { IStructuredSelection ss = (IStructuredSelection) selection; Iterator e = ss.iterator(); while (e.hasNext()) { Object element = e.next(); if (element instanceof ICompareInput) { if (isEditable(element, false)) leftToRight++; if (isEditable(element, true)) rightToLeft++; if (leftToRight > 0 && rightToLeft > 0) break; } } if (fExpandAllAction != null) fExpandAllAction.setEnabled(selection.isEmpty()); } if (fCopyLeftToRightAction != null) fCopyLeftToRightAction.setEnabled(leftToRight > 0); if (fCopyRightToLeftAction != null) fCopyRightToLeftAction.setEnabled(rightToLeft > 0); } /* * Fix for http://dev.eclipse.org/bugs/show_bug.cgi?id=20106 */ private boolean internalOpen() { ISelection selection = getSelection(); if (selection != null && !selection.isEmpty()) { fireOpen(new OpenEvent(this, selection)); return true; } return false; } }