| /******************************************************************************* |
| * Copyright (c) 2005, 2006 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.ltk.internal.ui.refactoring.history; |
| |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.Job; |
| |
| import org.eclipse.core.resources.IProject; |
| |
| import org.eclipse.ltk.core.refactoring.RefactoringCore; |
| import org.eclipse.ltk.core.refactoring.RefactoringDescriptor; |
| import org.eclipse.ltk.core.refactoring.RefactoringDescriptorProxy; |
| import org.eclipse.ltk.core.refactoring.history.RefactoringHistory; |
| |
| import org.eclipse.ltk.internal.ui.refactoring.Messages; |
| import org.eclipse.ltk.internal.ui.refactoring.RefactoringUIMessages; |
| |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.BusyIndicator; |
| import org.eclipse.swt.custom.CLabel; |
| import org.eclipse.swt.custom.ViewForm; |
| import org.eclipse.swt.events.MouseAdapter; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.swt.widgets.TreeItem; |
| import org.eclipse.swt.widgets.Widget; |
| |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.viewers.AbstractTreeViewer; |
| import org.eclipse.jface.viewers.CheckStateChangedEvent; |
| import org.eclipse.jface.viewers.CheckboxTreeViewer; |
| import org.eclipse.jface.viewers.ICheckStateListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.ITreeViewerListener; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TreeExpansionEvent; |
| import org.eclipse.jface.viewers.TreeViewer; |
| |
| import org.eclipse.ui.progress.UIJob; |
| |
| import org.eclipse.compare.CompareViewerPane; |
| import org.eclipse.compare.Splitter; |
| |
| import org.eclipse.ltk.ui.refactoring.history.IRefactoringHistoryControl; |
| import org.eclipse.ltk.ui.refactoring.history.RefactoringHistoryContentProvider; |
| import org.eclipse.ltk.ui.refactoring.history.RefactoringHistoryControlConfiguration; |
| import org.eclipse.ltk.ui.refactoring.history.RefactoringHistoryLabelProvider; |
| |
| /** |
| * Control which is capable of displaying refactoring histories. |
| * |
| * @since 3.2 |
| */ |
| public class RefactoringHistoryControl extends Composite implements IRefactoringHistoryControl { |
| |
| /** Checkbox tree viewer for the refactoring history */ |
| protected final class RefactoringHistoryTreeViewer extends CheckboxTreeViewer { |
| |
| /** |
| * Creates a new refactoring history tree viewer. |
| * |
| * @param parent |
| * the parent control |
| * @param style |
| * the style |
| */ |
| public RefactoringHistoryTreeViewer(final Composite parent, final int style) { |
| super(parent, style); |
| addCheckStateListener(new ICheckStateListener() { |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final void checkStateChanged(final CheckStateChangedEvent event) { |
| reconcileCheckState(event.getElement(), event.getChecked()); |
| handleCheckStateChanged(); |
| } |
| }); |
| addTreeListener(new ITreeViewerListener() { |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final void treeCollapsed(final TreeExpansionEvent event) { |
| // Do nothing |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final void treeExpanded(final TreeExpansionEvent event) { |
| BusyIndicator.showWhile(getDisplay(), new Runnable() { |
| |
| public final void run() { |
| final Object element= event.getElement(); |
| if (getGrayed(element)) { |
| final RefactoringHistory history= RefactoringHistoryControl.this.getInput(); |
| if (history != null) |
| reconcileCheckState(history); |
| } else if (getChecked(element)) { |
| setSubTreeGrayed(element, false); |
| setSubtreeChecked(element, true); |
| } |
| } |
| }); |
| } |
| }); |
| } |
| |
| /** |
| * Returns the children of the specified element. |
| * |
| * @param element |
| * the element |
| * @return the children of the element |
| */ |
| private Object[] getChildren(final Object element) { |
| return ((RefactoringHistoryContentProvider) getContentProvider()).getChildren(element); |
| } |
| |
| /** |
| * Reconciles the checkstate of the specified element and dependencies. |
| * |
| * @param element |
| * the changed element |
| */ |
| private void reconcileCheckState(final Object element) { |
| final Object[] children= getChildren(element); |
| for (int index= 0; index < children.length; index++) { |
| reconcileCheckState(children[index]); |
| } |
| int checkCount= 0; |
| final Collection collection= getCoveredDescriptors(element); |
| for (final Iterator iterator= collection.iterator(); iterator.hasNext();) { |
| final RefactoringDescriptorProxy proxy= (RefactoringDescriptorProxy) iterator.next(); |
| if (fCheckedDescriptors.contains(proxy)) |
| checkCount++; |
| } |
| setElementChecked(element, checkCount > 0); |
| setElementGrayed(element, checkCount != 0 && checkCount != collection.size()); |
| } |
| |
| /** |
| * Reconciles the checkstate of the specified element and dependencies. |
| * |
| * @param element |
| * the changed element |
| * @param checked |
| * <code>true</code> if the element is checked, |
| * <code>false</code> otherwise |
| */ |
| private void reconcileCheckState(final Object element, final boolean checked) { |
| if (element instanceof RefactoringHistoryEntry) { |
| final RefactoringHistoryEntry entry= (RefactoringHistoryEntry) element; |
| final RefactoringDescriptorProxy proxy= entry.getDescriptor(); |
| if (checked) |
| fCheckedDescriptors.add(proxy); |
| else |
| fCheckedDescriptors.remove(proxy); |
| } else if (element instanceof RefactoringHistoryNode) { |
| final Collection collection= getCoveredDescriptors(element); |
| if (checked) |
| fCheckedDescriptors.addAll(collection); |
| else |
| fCheckedDescriptors.removeAll(collection); |
| } |
| RefactoringHistoryControl.this.reconcileCheckState(); |
| } |
| |
| /** |
| * Determines whether the specified element is checked. |
| * |
| * @param element |
| * the element |
| * @param checked |
| * <code>true</code> to render it checked, |
| * <code>false</code> otherwise |
| */ |
| private void setElementChecked(final Object element, final boolean checked) { |
| final Widget widget= RefactoringHistoryTreeViewer.this.findItem(element); |
| if (widget instanceof TreeItem) { |
| final TreeItem item= (TreeItem) widget; |
| item.setChecked(checked); |
| } |
| } |
| |
| /** |
| * Determines whether the specified element is grayed. |
| * |
| * @param element |
| * the element |
| * @param grayed |
| * <code>true</code> to render it grayed, |
| * <code>false</code> otherwise |
| */ |
| private void setElementGrayed(final Object element, final boolean grayed) { |
| final Widget widget= RefactoringHistoryTreeViewer.this.findItem(element); |
| if (widget instanceof TreeItem) { |
| final TreeItem item= (TreeItem) widget; |
| item.setGrayed(grayed); |
| } |
| } |
| |
| /** |
| * Determines whether the subtree of the specified element is rendered |
| * grayed. |
| * |
| * @param element |
| * the element specifying the subtree |
| * @param grayed |
| * <code>true</code> to render the subtree grayed, |
| * <code>false</code> otherwise |
| */ |
| private void setSubTreeGrayed(final Object element, final boolean grayed) { |
| setElementGrayed(element, grayed); |
| final Object[] children= getChildren(element); |
| for (int index= 0; index < children.length; index++) { |
| setSubTreeGrayed(children[index], grayed); |
| } |
| } |
| } |
| |
| /** |
| * The checked refactoring descriptors (element type: |
| * <code>RefactoringDescriptorProxy</code>) |
| */ |
| private final Set fCheckedDescriptors= new HashSet(); |
| |
| /** The comment field */ |
| private Text fCommentField= null; |
| |
| /** The refactoring history control configuration to use */ |
| protected final RefactoringHistoryControlConfiguration fControlConfiguration; |
| |
| /** The history pane */ |
| protected CompareViewerPane fHistoryPane= null; |
| |
| /** The history viewer */ |
| protected TreeViewer fHistoryViewer= null; |
| |
| /** |
| * The selected refactoring descriptors (element type: |
| * <code>RefactoringDescriptorProxy</code>) |
| */ |
| private final Set fSelectedDescriptors= new HashSet(); |
| |
| /** The selection label, or <code>null</code> */ |
| private Label fSelectionLabel= null; |
| |
| /** The splitter control */ |
| private Splitter fSplitterControl= null; |
| |
| /** |
| * Creates a new refactoring history control. |
| * |
| * @param parent |
| * the parent control |
| * @param configuration |
| * the refactoring history control configuration to use |
| */ |
| public RefactoringHistoryControl(final Composite parent, final RefactoringHistoryControlConfiguration configuration) { |
| super(parent, SWT.NONE); |
| Assert.isNotNull(configuration); |
| fControlConfiguration= configuration; |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final void addCheckStateListener(final ICheckStateListener listener) { |
| Assert.isNotNull(listener); |
| if (fHistoryViewer instanceof RefactoringHistoryTreeViewer) { |
| final RefactoringHistoryTreeViewer viewer= (RefactoringHistoryTreeViewer) fHistoryViewer; |
| viewer.addCheckStateListener(listener); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final void addSelectionChangedListener(final ISelectionChangedListener listener) { |
| Assert.isNotNull(listener); |
| if (fHistoryViewer != null) |
| fHistoryViewer.addSelectionChangedListener(listener); |
| } |
| |
| /** |
| * Creates the button bar at the bottom of the component. |
| * |
| * @param parent |
| * the parent composite |
| */ |
| protected void createBottomButtonBar(final Composite parent) { |
| // Do nothing |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void createControl() { |
| RefactoringCore.getHistoryService().connect(); |
| GridLayout layout= new GridLayout(getContainerColumns(), false); |
| layout.marginHeight= 0; |
| layout.marginWidth= 0; |
| layout.horizontalSpacing= 0; |
| layout.verticalSpacing= 0; |
| setLayout(layout); |
| setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL)); |
| fSplitterControl= new Splitter(this, SWT.VERTICAL); |
| fSplitterControl.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL)); |
| createRightButtonBar(this); |
| final Composite leftPane= new Composite(fSplitterControl, SWT.NONE); |
| layout= new GridLayout(); |
| layout.marginWidth= 0; |
| layout.marginHeight= 2; |
| layout.verticalSpacing= 2; |
| leftPane.setLayout(layout); |
| fHistoryPane= new CompareViewerPane(leftPane, SWT.BORDER | SWT.FLAT); |
| final CLabel label= new CLabel(fHistoryPane, SWT.NONE) { |
| |
| public final Point computeSize(final int wHint, final int hHint, final boolean changed) { |
| return super.computeSize(wHint, Math.max(24, hHint), changed); |
| } |
| }; |
| fHistoryPane.setTopLeft(label); |
| |
| fHistoryPane.setText(getHistoryPaneText()); |
| fHistoryPane.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL)); |
| fHistoryViewer= createHistoryViewer(fHistoryPane); |
| if (!fControlConfiguration.isTimeDisplayed()) |
| fHistoryViewer.setAutoExpandLevel(AbstractTreeViewer.ALL_LEVELS); |
| fHistoryViewer.getControl().setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL)); |
| fHistoryViewer.setUseHashlookup(true); |
| fHistoryViewer.setContentProvider(getContentProvider()); |
| fHistoryViewer.setLabelProvider(getLabelProvider()); |
| fHistoryViewer.addSelectionChangedListener(new ISelectionChangedListener() { |
| |
| public final void selectionChanged(final SelectionChangedEvent event) { |
| final ISelection selection= event.getSelection(); |
| if (selection instanceof IStructuredSelection) |
| handleSelectionChanged((IStructuredSelection) selection); |
| } |
| }); |
| fHistoryPane.setContent(fHistoryViewer.getControl()); |
| createToolBar(fHistoryPane); |
| createDetailPane(fSplitterControl); |
| final MouseAdapter listener= new MouseAdapter() { |
| |
| public void mouseDoubleClick(final MouseEvent event) { |
| final Control content= fHistoryPane.getContent(); |
| if (content != null && content.getBounds().contains(event.x, event.y)) |
| return; |
| final Control control= fHistoryPane.getParent().getParent(); |
| if (control instanceof Splitter) |
| ((Splitter) control).setMaximizedControl(fHistoryPane.getParent()); |
| } |
| }; |
| addMouseListener(listener); |
| fHistoryPane.getTopLeft().addMouseListener(listener); |
| fSplitterControl.setWeights(new int[] { 65, 35}); |
| createBottomButtonBar(this); |
| Dialog.applyDialogFont(this); |
| } |
| |
| /** |
| * Creates the detail label of the control |
| * |
| * @param parent |
| * the parent composite |
| */ |
| protected void createDetailLabel(final Composite parent) { |
| Assert.isNotNull(parent); |
| final Label label= new Label(parent, SWT.HORIZONTAL | SWT.LEFT | SWT.WRAP); |
| label.setText(RefactoringUIMessages.RefactoringHistoryControl_comment_viewer_label); |
| final GridData data= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING); |
| data.horizontalSpan= 1; |
| label.setLayoutData(data); |
| } |
| |
| /** |
| * Creates the detail pane of the control. |
| * |
| * @param parent |
| * the parent composite |
| * @return the detail pane |
| */ |
| protected Composite createDetailPane(final Composite parent) { |
| Assert.isNotNull(parent); |
| final Composite composite= new Composite(parent, SWT.NONE); |
| final GridLayout layout= new GridLayout(getDetailColumns(), true); |
| layout.horizontalSpacing= 0; |
| layout.marginHeight= 0; |
| layout.marginWidth= 0; |
| composite.setLayout(layout); |
| createDetailLabel(composite); |
| createSelectionLabel(composite); |
| fCommentField= new Text(composite, SWT.BORDER | SWT.FLAT | SWT.MULTI | SWT.READ_ONLY | SWT.H_SCROLL | SWT.V_SCROLL); |
| fCommentField.setText(fControlConfiguration.getCommentCaption()); |
| final GridData data= new GridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL); |
| data.horizontalSpan= getDetailColumns(); |
| fCommentField.setLayoutData(data); |
| return composite; |
| } |
| |
| /** |
| * Creates the history viewer of the control. |
| * |
| * @param parent |
| * the parent composite |
| * @return the history viewer |
| */ |
| protected TreeViewer createHistoryViewer(final Composite parent) { |
| Assert.isNotNull(parent); |
| if (fControlConfiguration.isCheckableViewer()) |
| return new RefactoringHistoryTreeViewer(parent, SWT.H_SCROLL | SWT.V_SCROLL); |
| else |
| return new TreeViewer(parent, SWT.H_SCROLL | SWT.V_SCROLL); |
| } |
| |
| /** |
| * Creates the button bar at the right of the component. |
| * |
| * @param parent |
| * the parent composite |
| */ |
| protected void createRightButtonBar(final Composite parent) { |
| // Do nothing |
| } |
| |
| /** |
| * Creates the selection label of the control |
| * |
| * @param parent |
| * the parent composite |
| */ |
| protected void createSelectionLabel(final Composite parent) { |
| Assert.isNotNull(parent); |
| fSelectionLabel= new Label(parent, SWT.HORIZONTAL | SWT.RIGHT | SWT.WRAP); |
| final GridData data= new GridData(GridData.HORIZONTAL_ALIGN_END); |
| data.horizontalSpan= 1; |
| fSelectionLabel.setLayoutData(data); |
| } |
| |
| /** |
| * Creates the toolbar of the control. |
| * |
| * @param parent |
| * the parent control |
| */ |
| protected void createToolBar(final ViewForm parent) { |
| // Do nothing |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final void dispose() { |
| RefactoringCore.getHistoryService().disconnect(); |
| super.dispose(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final RefactoringDescriptorProxy[] getCheckedDescriptors() { |
| if (fHistoryViewer instanceof RefactoringHistoryTreeViewer) |
| return (RefactoringDescriptorProxy[]) fCheckedDescriptors.toArray(new RefactoringDescriptorProxy[fCheckedDescriptors.size()]); |
| return getSelectedDescriptors(); |
| } |
| |
| /** |
| * Returns the number of columns to use for the container layout. |
| * |
| * @return the number of columns |
| */ |
| protected int getContainerColumns() { |
| return 2; |
| } |
| |
| /** |
| * Returns the content provider to use. |
| * |
| * @return the content provider |
| */ |
| protected RefactoringHistoryContentProvider getContentProvider() { |
| return fControlConfiguration.getContentProvider(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final Control getControl() { |
| return this; |
| } |
| |
| /** |
| * Returns the refactoring descriptors covered by the specified node. |
| * |
| * @param element |
| * the refactoring history element |
| * @return the collection of covered descriptors |
| */ |
| private Collection getCoveredDescriptors(final Object element) { |
| Assert.isNotNull(element); |
| final Set set= new HashSet(); |
| getCoveredDescriptors(element, set); |
| return set; |
| } |
| |
| /** |
| * Computes the refactoring descriptors covered by the specified node. |
| * |
| * @param element |
| * the refactoring history element |
| * @param set |
| * the set of refactoring descriptor proxies |
| */ |
| private void getCoveredDescriptors(final Object element, final Set set) { |
| Assert.isNotNull(element); |
| Assert.isNotNull(set); |
| final RefactoringHistoryContentProvider provider= (RefactoringHistoryContentProvider) fHistoryViewer.getContentProvider(); |
| if (provider != null) { |
| if (element instanceof RefactoringHistoryEntry) { |
| final RefactoringHistoryEntry entry= (RefactoringHistoryEntry) element; |
| final RefactoringDescriptorProxy proxy= entry.getDescriptor(); |
| set.add(proxy); |
| } else { |
| final Object[] children= provider.getChildren(element); |
| for (int index= 0; index < children.length; index++) { |
| final Object child= children[index]; |
| if (child instanceof RefactoringHistoryNode) |
| getCoveredDescriptors(child, set); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns the number of columns to use for the detail pane layout. |
| * |
| * @return the number of columns |
| */ |
| protected int getDetailColumns() { |
| return 2; |
| } |
| |
| /** |
| * Returns the text to be displayed in the history pane. |
| * |
| * @return the text in the history pane |
| */ |
| private String getHistoryPaneText() { |
| String text= null; |
| final IProject project= fControlConfiguration.getProject(); |
| if (project != null) |
| text= Messages.format(fControlConfiguration.getProjectPattern(), project.getName()); |
| else |
| text= fControlConfiguration.getWorkspaceCaption(); |
| return text; |
| } |
| |
| /** |
| * Returns the input of the refactoring history control. |
| * |
| * @return the input, or <code>null</code> |
| */ |
| public final RefactoringHistory getInput() { |
| return (RefactoringHistory) fHistoryViewer.getInput(); |
| } |
| |
| /** |
| * Returns the label provider to use. |
| * |
| * @return the label provider |
| */ |
| protected RefactoringHistoryLabelProvider getLabelProvider() { |
| return fControlConfiguration.getLabelProvider(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final RefactoringDescriptorProxy[] getSelectedDescriptors() { |
| return (RefactoringDescriptorProxy[]) fSelectedDescriptors.toArray(new RefactoringDescriptorProxy[fSelectedDescriptors.size()]); |
| } |
| |
| /** |
| * Handles the check state changed event. |
| */ |
| protected void handleCheckStateChanged() { |
| if (fSelectionLabel != null) { |
| final RefactoringHistory history= getInput(); |
| if (history != null) { |
| final int total= history.getDescriptors().length; |
| final int checked= fCheckedDescriptors.size(); |
| if (total > 0 && fControlConfiguration.isCheckableViewer()) |
| fSelectionLabel.setText(Messages.format(RefactoringUIMessages.RefactoringHistoryControl_selection_pattern, new String[] { String.valueOf(checked), String.valueOf(total)})); |
| else |
| fSelectionLabel.setText(RefactoringUIMessages.RefactoringHistoryControl_no_selection); |
| } |
| } |
| } |
| |
| /** |
| * Handles the selection changed event. |
| * |
| * @param selection |
| * the new selection |
| */ |
| protected void handleSelectionChanged(final IStructuredSelection selection) { |
| Assert.isNotNull(selection); |
| fSelectedDescriptors.clear(); |
| final Object[] elements= selection.toArray(); |
| for (int index= 0; index < elements.length; index++) { |
| final Object element= elements[index]; |
| if (element instanceof RefactoringHistoryEntry) { |
| final RefactoringHistoryEntry entry= (RefactoringHistoryEntry) element; |
| final RefactoringDescriptorProxy proxy= entry.getDescriptor(); |
| fSelectedDescriptors.add(proxy); |
| } else if (element instanceof RefactoringHistoryNode) { |
| final RefactoringHistoryNode node= (RefactoringHistoryNode) element; |
| fSelectedDescriptors.addAll(getCoveredDescriptors(node)); |
| } |
| } |
| if (elements.length == 1 && elements[0] instanceof RefactoringHistoryEntry) { |
| final RefactoringHistoryEntry entry= (RefactoringHistoryEntry) elements[0]; |
| final RefactoringDescriptorProxy proxy= entry.getDescriptor(); |
| final Job job= new UIJob(RefactoringUIMessages.RefactoringHistoryControl_resolving_information) { |
| |
| public final IStatus runInUIThread(final IProgressMonitor monitor) { |
| final RefactoringDescriptor descriptor= proxy.requestDescriptor(monitor); |
| if (descriptor != null) { |
| String comment= descriptor.getComment(); |
| if ("".equals(comment)) //$NON-NLS-1$ |
| comment= RefactoringUIMessages.RefactoringHistoryControl_no_comment; |
| fCommentField.setText(comment); |
| } |
| return Status.OK_STATUS; |
| } |
| }; |
| job.setSystem(true); |
| job.schedule(); |
| } |
| fCommentField.setText(fControlConfiguration.getCommentCaption()); |
| } |
| |
| /** |
| * Reconciles the check state of the control. |
| */ |
| public void reconcileCheckState() { |
| final RefactoringHistory history= getInput(); |
| if (history != null && fHistoryViewer instanceof RefactoringHistoryTreeViewer) |
| ((RefactoringHistoryTreeViewer) fHistoryViewer).reconcileCheckState(history); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final void removeCheckStateListener(final ICheckStateListener listener) { |
| Assert.isNotNull(listener); |
| Assert.isNotNull(listener); |
| if (fHistoryViewer instanceof RefactoringHistoryTreeViewer) { |
| final RefactoringHistoryTreeViewer viewer= (RefactoringHistoryTreeViewer) fHistoryViewer; |
| viewer.removeCheckStateListener(listener); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final void removeSelectionChangedListener(final ISelectionChangedListener listener) { |
| Assert.isNotNull(listener); |
| if (fHistoryViewer != null) |
| fHistoryViewer.removeSelectionChangedListener(listener); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final void setCheckedDescriptors(final RefactoringDescriptorProxy[] descriptors) { |
| Assert.isNotNull(descriptors); |
| if (fHistoryViewer instanceof RefactoringHistoryTreeViewer) { |
| fCheckedDescriptors.clear(); |
| fCheckedDescriptors.addAll(Arrays.asList(descriptors)); |
| final RefactoringHistoryTreeViewer viewer= (RefactoringHistoryTreeViewer) fHistoryViewer; |
| final RefactoringHistoryNode[] nodes= new RefactoringHistoryNode[descriptors.length]; |
| for (int index= 0; index < descriptors.length; index++) |
| nodes[index]= new RefactoringHistoryEntry(null, descriptors[index]); |
| final RefactoringHistory history= RefactoringHistoryControl.this.getInput(); |
| if (history != null) |
| viewer.reconcileCheckState(history); |
| handleCheckStateChanged(); |
| } else |
| setSelectedDescriptors(descriptors); |
| } |
| |
| /** |
| * Sets the expanded state of the viewer. |
| */ |
| protected void setExpandedState() { |
| final RefactoringHistoryContentProvider provider= (RefactoringHistoryContentProvider) fHistoryViewer.getContentProvider(); |
| if (provider != null) { |
| handleCheckStateChanged(); |
| final Object[] roots= provider.getRootElements(); |
| if (roots != null) { |
| for (int index= 0; index < roots.length; index++) { |
| if (!(roots[index] instanceof RefactoringHistoryEntry)) { |
| fHistoryViewer.setExpandedState(roots[index], true); |
| return; |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void setInput(final RefactoringHistory history) { |
| fHistoryViewer.setInput(history); |
| fSelectedDescriptors.clear(); |
| fCheckedDescriptors.clear(); |
| if (history != null) { |
| final RefactoringHistoryContentProvider provider= (RefactoringHistoryContentProvider) fHistoryViewer.getContentProvider(); |
| if (provider != null) { |
| provider.inputChanged(fHistoryViewer, null, history); |
| setExpandedState(); |
| } |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public final void setSelectedDescriptors(final RefactoringDescriptorProxy[] descriptors) { |
| Assert.isNotNull(descriptors); |
| if (fHistoryViewer != null) { |
| fSelectedDescriptors.clear(); |
| fSelectedDescriptors.addAll(Arrays.asList(descriptors)); |
| final RefactoringHistoryNode[] nodes= new RefactoringHistoryNode[descriptors.length]; |
| for (int index= 0; index < descriptors.length; index++) |
| nodes[index]= new RefactoringHistoryEntry(null, descriptors[index]); |
| fHistoryViewer.setSelection(new StructuredSelection(nodes)); |
| } |
| } |
| } |