Java tutorial
/******************************************************************************* * Copyright (c) 2013, 2016 SAP AG 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: * Tobias Pfeifer (SAP AG) - initial implementation * Tobias Baumann (tobbaumann@gmail.com) - Bug 473950 * Thomas Wolf <thomas.wolf@paranor.ch> - Bug 477248, 460595 *******************************************************************************/ package org.eclipse.egit.ui.internal.rebase; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.List; import org.eclipse.core.commands.ExecutionException; import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener; import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent; import org.eclipse.core.runtime.preferences.InstanceScope; import org.eclipse.egit.core.AdapterUtils; import org.eclipse.egit.core.RepositoryUtil; import org.eclipse.egit.core.internal.rebase.RebaseInteractivePlan; import org.eclipse.egit.core.internal.rebase.RebaseInteractivePlan.ElementAction; import org.eclipse.egit.core.internal.rebase.RebaseInteractivePlan.ElementType; import org.eclipse.egit.core.internal.rebase.RebaseInteractivePlan.PlanElement; import org.eclipse.egit.core.project.RepositoryMapping; import org.eclipse.egit.ui.Activator; import org.eclipse.egit.ui.UIPreferences; import org.eclipse.egit.ui.UIUtils; import org.eclipse.egit.ui.internal.CommonUtils; import org.eclipse.egit.ui.internal.PreferenceBasedDateFormatter; import org.eclipse.egit.ui.internal.UIIcons; import org.eclipse.egit.ui.internal.UIText; import org.eclipse.egit.ui.internal.actions.BooleanPrefAction; import org.eclipse.egit.ui.internal.commands.shared.AbortRebaseCommand; import org.eclipse.egit.ui.internal.commands.shared.AbstractRebaseCommandHandler; import org.eclipse.egit.ui.internal.commands.shared.ContinueRebaseCommand; import org.eclipse.egit.ui.internal.commands.shared.ProcessStepsRebaseCommand; import org.eclipse.egit.ui.internal.commands.shared.SkipRebaseCommand; import org.eclipse.egit.ui.internal.commit.CommitEditor; import org.eclipse.egit.ui.internal.commit.RepositoryCommit; import org.eclipse.egit.ui.internal.repository.RepositoriesView; import org.eclipse.egit.ui.internal.repository.tree.RepositoryTreeNode; import org.eclipse.jface.action.Action; import org.eclipse.jface.action.IAction; 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.bindings.keys.SWTKeySupport; import org.eclipse.jface.layout.GridDataFactory; import org.eclipse.jface.layout.GridLayoutFactory; import org.eclipse.jface.layout.TreeColumnLayout; import org.eclipse.jface.preference.IPersistentPreferenceStore; import org.eclipse.jface.resource.JFaceResources; import org.eclipse.jface.resource.LocalResourceManager; import org.eclipse.jface.util.IPropertyChangeListener; import org.eclipse.jface.util.LocalSelectionTransfer; import org.eclipse.jface.util.PropertyChangeEvent; import org.eclipse.jface.viewers.ColumnLabelProvider; import org.eclipse.jface.viewers.ColumnPixelData; import org.eclipse.jface.viewers.ColumnViewerToolTipSupport; import org.eclipse.jface.viewers.ColumnWeightData; import org.eclipse.jface.viewers.DoubleClickEvent; import org.eclipse.jface.viewers.IDoubleClickListener; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.ISelectionChangedListener; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.jface.viewers.StructuredSelection; import org.eclipse.jface.viewers.TreeViewer; import org.eclipse.jface.viewers.TreeViewerColumn; import org.eclipse.jface.window.ToolTip; import org.eclipse.jgit.lib.AbbreviatedObjectId; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.RepositoryState; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.revwalk.RevWalk; import org.eclipse.jgit.util.GitDateFormatter; import org.eclipse.jgit.util.GitDateFormatter.Format; import org.eclipse.swt.SWT; import org.eclipse.swt.dnd.DND; import org.eclipse.swt.dnd.Transfer; import org.eclipse.swt.events.DisposeEvent; import org.eclipse.swt.events.DisposeListener; import org.eclipse.swt.events.KeyAdapter; import org.eclipse.swt.events.KeyEvent; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Menu; import org.eclipse.swt.widgets.ToolBar; import org.eclipse.swt.widgets.ToolItem; import org.eclipse.swt.widgets.Tree; import org.eclipse.swt.widgets.TreeItem; import org.eclipse.ui.IActionBars; import org.eclipse.ui.IEditorInput; import org.eclipse.ui.IEditorPart; import org.eclipse.ui.IFileEditorInput; import org.eclipse.ui.ISelectionListener; import org.eclipse.ui.ISelectionService; import org.eclipse.ui.IViewSite; import org.eclipse.ui.IWorkbenchPart; import org.eclipse.ui.IWorkbenchPartSite; import org.eclipse.ui.PartInitException; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.forms.widgets.Form; import org.eclipse.ui.forms.widgets.FormToolkit; import org.eclipse.ui.part.ViewPart; /** * View visualizing git interactive rebase */ public class RebaseInteractiveView extends ViewPart implements RebaseInteractivePlan.RebaseInteractivePlanChangeListener { /** * interactive rebase view id */ public static final String VIEW_ID = "org.eclipse.egit.ui.InteractiveRebaseView"; //$NON-NLS-1$ TreeViewer planTreeViewer; private Composite headComposite; private PlanLayout planLayout; private RebaseInteractivePlan currentPlan; private Repository currentRepository; private RebaseInteractiveStepActionToolBarProvider actionToolBarProvider; private ToolItem startItem; private ToolItem abortItem; private ToolItem skipItem; private ToolItem continueItem; private ToolItem refreshItem; private boolean listenOnRepositoryViewSelection = true; private ISelectionListener selectionChangedListener; private boolean dndEnabled = false; private Form form; private LocalResourceManager resources = new LocalResourceManager(JFaceResources.getResources()); private GitDateFormatter dateFormatter = getNewDateFormatter(); /** these columns are dynamically resized to fit their contents */ private TreeViewerColumn[] dynamicColumns; private List<PlanContextMenuAction> contextMenuItems; private RebasePlanIndexer planIndexer; private IPreferenceChangeListener prefListener; private IPropertyChangeListener uiPrefsListener; private InitialSelection initialSelection; @Override public void init(IViewSite site) throws PartInitException { super.init(site); setPartName(UIText.InteractiveRebaseView_this_partName); initInitialSelection(site); } private void initInitialSelection(IViewSite site) { this.initialSelection = new InitialSelection( site.getWorkbenchWindow().getSelectionService().getSelection()); if (!isViewInputDerivableFromSelection(initialSelection.selection)) { this.initialSelection.activeEditor = site.getPage().getActiveEditor(); } } private static boolean isViewInputDerivableFromSelection(Object o) { return o instanceof StructuredSelection && ((StructuredSelection) o).size() == 1; } /** * Set the view input if the passed object can be used to determine the * current repository * * @param o */ public void setInput(Object o) { if (o == null) return; if (isViewInputDerivableFromSelection(o)) { o = ((StructuredSelection) o).getFirstElement(); } Repository repo = null; if (o instanceof RepositoryTreeNode<?>) { repo = ((RepositoryTreeNode) o).getRepository(); } else if (o instanceof Repository) { repo = (Repository) o; } else { IResource resource = AdapterUtils.adaptToAnyResource(o); if (resource != null) { RepositoryMapping mapping = RepositoryMapping.getMapping(resource); if (mapping == null) { return; } repo = mapping.getRepository(); } } if (repo == null) { repo = AdapterUtils.adapt(o, Repository.class); } currentRepository = repo; showRepository(repo); } /** * @return {@link RebaseInteractiveView#currentPlan} */ public RebaseInteractivePlan getCurrentPlan() { return currentPlan; } @Override public void dispose() { removeListeners(); resources.dispose(); super.dispose(); } private void removeListeners() { ISelectionService srv = CommonUtils.getService(getSite(), ISelectionService.class); srv.removePostSelectionListener(RepositoriesView.VIEW_ID, selectionChangedListener); if (currentPlan != null) currentPlan.removeRebaseInteractivePlanChangeListener(this); if (planIndexer != null) planIndexer.dispose(); InstanceScope.INSTANCE.getNode(org.eclipse.egit.core.Activator.getPluginId()) .removePreferenceChangeListener(prefListener); Activator.getDefault().getPreferenceStore().removePropertyChangeListener(uiPrefsListener); } @Override public void createPartControl(Composite parent) { GridLayoutFactory.fillDefaults().applyTo(parent); final FormToolkit toolkit = new FormToolkit(parent.getDisplay()); parent.addDisposeListener(new DisposeListener() { @Override public void widgetDisposed(DisposeEvent e) { toolkit.dispose(); } }); form = createForm(parent, toolkit); createCommandToolBar(form, toolkit); planTreeViewer = createPlanTreeViewer(form.getBody(), toolkit); planLayout = new PlanLayout(); planTreeViewer.getTree().getParent().setLayout(planLayout); createColumns(planLayout); createStepActionToolBar(toolkit); createPopupMenu(planTreeViewer); setupListeners(); createLocalDragandDrop(); planTreeViewer.addDoubleClickListener(new IDoubleClickListener() { @Override public void doubleClick(DoubleClickEvent event) { PlanElement element = (PlanElement) ((IStructuredSelection) event.getSelection()).getFirstElement(); if (element == null) return; RepositoryCommit commit = loadCommit(element.getCommit()); if (commit != null) CommitEditor.openQuiet(commit); } private RepositoryCommit loadCommit(AbbreviatedObjectId abbreviatedObjectId) { if (abbreviatedObjectId != null) { try (RevWalk walk = new RevWalk(RebaseInteractiveView.this.currentRepository)) { Collection<ObjectId> resolved = walk.getObjectReader().resolve(abbreviatedObjectId); if (resolved.size() == 1) { RevCommit commit = walk.parseCommit(resolved.iterator().next()); return new RepositoryCommit(RebaseInteractiveView.this.currentRepository, commit); } } catch (IOException e) { return null; } } return null; } }); prefListener = new IPreferenceChangeListener() { @Override public void preferenceChange(PreferenceChangeEvent event) { if (!RepositoryUtil.PREFS_DIRECTORIES_REL.equals(event.getKey())) { return; } final Repository repo = currentRepository; if (repo == null) return; if (Activator.getDefault().getRepositoryUtil().contains(repo)) return; // Unselect repository as it has been removed Display.getDefault().asyncExec(new Runnable() { @Override public void run() { currentRepository = null; showRepository(null); } }); } }; InstanceScope.INSTANCE.getNode(org.eclipse.egit.core.Activator.getPluginId()) .addPreferenceChangeListener(prefListener); uiPrefsListener = new IPropertyChangeListener() { @Override public void propertyChange(PropertyChangeEvent event) { String property = event.getProperty(); if (UIPreferences.DATE_FORMAT.equals(property) || UIPreferences.DATE_FORMAT_CHOICE.equals(property) || UIPreferences.RESOURCEHISTORY_SHOW_RELATIVE_DATE.equals(property)) { refresh(); } } }; Activator.getDefault().getPreferenceStore().addPropertyChangeListener(uiPrefsListener); IActionBars actionBars = getViewSite().getActionBars(); IToolBarManager toolbar = actionBars.getToolBarManager(); listenOnRepositoryViewSelection = RebaseInteractivePreferences.isReactOnSelection(); // link with selection Action linkSelectionAction = new BooleanPrefAction( (IPersistentPreferenceStore) Activator.getDefault().getPreferenceStore(), UIPreferences.REBASE_INTERACTIVE_SYNC_SELECTION, UIText.InteractiveRebaseView_LinkSelection) { @Override public void apply(boolean value) { listenOnRepositoryViewSelection = value; } }; linkSelectionAction.setImageDescriptor(UIIcons.ELCL16_SYNCED); toolbar.add(linkSelectionAction); reactOnInitalSelection(); } private void createCommandToolBar(Form theForm, FormToolkit toolkit) { headComposite = new Composite(theForm.getHead(), SWT.NONE); theForm.setHeadClient(headComposite); GridLayoutFactory.fillDefaults().numColumns(2).equalWidth(false).margins(0, 0).applyTo(headComposite); ToolBar toolBar = new ToolBar(headComposite, SWT.FLAT); GridDataFactory.fillDefaults().grab(false, false).applyTo(toolBar); toolkit.adapt(toolBar); toolkit.paintBordersFor(toolBar); toolBar.setBackground(null); startItem = new ToolItem(toolBar, SWT.NONE); startItem.setImage(UIIcons.getImage(resources, UIIcons.REBASE_PROCESS_STEPS)); startItem.addSelectionListener(new RebaseCommandItemSelectionListener(new ProcessStepsRebaseCommand())); startItem.setEnabled(false); startItem.setText(UIText.InteractiveRebaseView_startItem_text); continueItem = new ToolItem(toolBar, SWT.NONE); continueItem.setImage(UIIcons.getImage(resources, UIIcons.REBASE_CONTINUE)); continueItem.addSelectionListener(new RebaseCommandItemSelectionListener(new ContinueRebaseCommand())); continueItem.setEnabled(false); continueItem.setText(UIText.InteractiveRebaseView_continueItem_text); skipItem = new ToolItem(toolBar, SWT.NONE); skipItem.setImage(UIIcons.getImage(resources, UIIcons.REBASE_SKIP)); skipItem.addSelectionListener(new RebaseCommandItemSelectionListener(new SkipRebaseCommand())); skipItem.setText(UIText.InteractiveRebaseView_skipItem_text); skipItem.setEnabled(false); abortItem = new ToolItem(toolBar, SWT.NONE); abortItem.setImage(UIIcons.getImage(resources, UIIcons.REBASE_ABORT)); abortItem.addSelectionListener(new RebaseCommandItemSelectionListener(new AbortRebaseCommand())); abortItem.setText(UIText.InteractiveRebaseView_abortItem_text); abortItem.setEnabled(false); createSeparator(toolBar); refreshItem = new ToolItem(toolBar, SWT.NONE); refreshItem.setImage(UIIcons.getImage(resources, UIIcons.ELCL16_REFRESH)); refreshItem.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { refresh(); } }); refreshItem.setText(UIText.InteractiveRebaseView_refreshItem_text); toolBar.pack(); } private static ToolItem createSeparator(ToolBar toolBar) { return new ToolItem(toolBar, SWT.SEPARATOR); } private TreeViewer createPlanTreeViewer(Composite parent, FormToolkit toolkit) { Composite rebasePlanTableComposite = toolkit.createComposite(parent); toolkit.paintBordersFor(rebasePlanTableComposite); GridDataFactory.fillDefaults().grab(true, true).applyTo(rebasePlanTableComposite); GridLayoutFactory.fillDefaults().extendedMargins(2, 2, 2, 2).applyTo(rebasePlanTableComposite); final Tree planTree = toolkit.createTree(rebasePlanTableComposite, SWT.FULL_SELECTION | SWT.MULTI); planTree.setHeaderVisible(true); planTree.setLinesVisible(false); TreeViewer viewer = new TreeViewer(planTree); viewer.addSelectionChangedListener(new PlanViewerSelectionChangedListener()); GridDataFactory.fillDefaults().grab(true, true).applyTo(viewer.getControl()); viewer.getTree().setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TREE_BORDER); viewer.setContentProvider(RebaseInteractivePlanContentProvider.INSTANCE); return viewer; } private Form createForm(Composite parent, final FormToolkit toolkit) { Form newForm = toolkit.createForm(parent); Image repoImage = UIIcons.REPOSITORY.createImage(); UIUtils.hookDisposal(newForm, repoImage); newForm.setImage(repoImage); newForm.setText(UIText.RebaseInteractiveView_NoSelection); GridDataFactory.fillDefaults().grab(true, true).applyTo(newForm); toolkit.decorateFormHeading(newForm); GridLayoutFactory.swtDefaults().applyTo(newForm.getBody()); return newForm; } private void setupListeners() { setupRepositoryViewSelectionChangeListener(); refreshUI(); } private void setupRepositoryViewSelectionChangeListener() { selectionChangedListener = new ISelectionListener() { @Override public void selectionChanged(IWorkbenchPart part, ISelection selection) { if (!listenOnRepositoryViewSelection || part == getSite().getPart()) return; // this may happen if we switch between editors if (part instanceof IEditorPart) { IEditorInput input = ((IEditorPart) part).getEditorInput(); if (input instanceof IFileEditorInput) setInput(new StructuredSelection(((IFileEditorInput) input).getFile())); } else setInput(selection); } }; ISelectionService srv = CommonUtils.getService(getSite(), ISelectionService.class); srv.addPostSelectionListener(selectionChangedListener); } private void reactOnInitalSelection() { selectionChangedListener.selectionChanged(initialSelection.activeEditor, initialSelection.selection); this.initialSelection = null; } private static final class InitialSelection { ISelection selection; IEditorPart activeEditor; InitialSelection(ISelection selection) { this.selection = selection; } } private class RebaseCommandItemSelectionListener extends SelectionAdapter { private final AbstractRebaseCommandHandler command; public RebaseCommandItemSelectionListener(AbstractRebaseCommandHandler command) { super(); this.command = command; } @Override public void widgetSelected(SelectionEvent sEvent) { try { Repository repository = currentPlan.getRepository(); if (repository != null) { command.execute(repository); } } catch (ExecutionException e) { Activator.showError(e.getMessage(), e); } } } private class PlanViewerSelectionChangedListener implements ISelectionChangedListener { @Override public void selectionChanged(SelectionChangedEvent event) { if (event == null) return; ISelection selection = event.getSelection(); actionToolBarProvider.mapActionItemsToSelection(selection); } } private void createLocalDragandDrop() { planTreeViewer.addDragSupport(DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK, new Transfer[] { LocalSelectionTransfer.getTransfer() }, new RebaseInteractiveDragSourceListener(this)); planTreeViewer.addDropSupport(DND.DROP_MOVE, new Transfer[] { LocalSelectionTransfer.getTransfer() }, new RebaseInteractiveDropTargetListener(this, planTreeViewer)); } private void createStepActionToolBar(final FormToolkit toolkit) { actionToolBarProvider = new RebaseInteractiveStepActionToolBarProvider(headComposite, SWT.FLAT | SWT.WRAP, this); ToolBar bar = actionToolBarProvider.getTheToolbar(); GridDataFactory.fillDefaults().grab(true, false).align(SWT.END, SWT.CENTER).applyTo(bar); toolkit.adapt(bar); toolkit.paintBordersFor(bar); bar.setBackground(null); bar.pack(); } private static RebaseInteractivePlan.ElementType getType(Object element) { if (element instanceof PlanElement) { PlanElement planLine = (PlanElement) element; return planLine.getElementType(); } else return null; } private static class HighlightingColumnLabelProvider extends ColumnLabelProvider { @Override public Font getFont(Object element) { ElementType t = RebaseInteractiveView.getType(element); if (t != null && t == ElementType.DONE_CURRENT) return UIUtils.getBoldFont(JFaceResources.DIALOG_FONT); return super.getFont(element); } } private void createColumns(TreeColumnLayout layout) { String[] headings = { UIText.RebaseInteractiveView_HeadingStatus, UIText.RebaseInteractiveView_HeadingStep, UIText.RebaseInteractiveView_HeadingAction, UIText.RebaseInteractiveView_HeadingCommitId, UIText.RebaseInteractiveView_HeadingMessage, UIText.RebaseInteractiveView_HeadingAuthor, UIText.RebaseInteractiveView_HeadingAuthorDate, UIText.RebaseInteractiveView_HeadingCommitter, UIText.RebaseInteractiveView_HeadingCommitDate }; ColumnViewerToolTipSupport.enableFor(planTreeViewer, ToolTip.NO_RECREATE); TreeViewerColumn infoColumn = createColumn(headings[0]); layout.setColumnData(infoColumn.getColumn(), new ColumnPixelData(70)); infoColumn.setLabelProvider(new HighlightingColumnLabelProvider() { @Override public Image getImage(Object element) { ElementType t = getType(element); if (t != null) { switch (t) { case DONE_CURRENT: return UIIcons.getImage(resources, UIIcons.CURRENT_STEP); case DONE: return UIIcons.getImage(resources, UIIcons.DONE_STEP); default: // fall through } } return null; } @Override public String getToolTipText(Object element) { ElementType t = getType(element); if (t != null) { switch (t) { case DONE: return UIText.RebaseInteractiveView_StatusDone; case DONE_CURRENT: return UIText.RebaseInteractiveView_StatusCurrent; case TODO: return UIText.RebaseInteractiveView_StatusTodo; default: // fall through } } return ""; //$NON-NLS-1$ } @Override public String getText(Object element) { return ""; //$NON-NLS-1$ } }); TreeViewerColumn stepColumn = createColumn(headings[1]); layout.setColumnData(stepColumn.getColumn(), new ColumnPixelData(55)); stepColumn.setLabelProvider(new HighlightingColumnLabelProvider() { @Override public String getText(Object element) { if (element instanceof PlanElement) { PlanElement planLine = (PlanElement) element; return (planIndexer.indexOf(planLine) + 1) + "."; //$NON-NLS-1$ } return super.getText(element); } }); stepColumn.getColumn().addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { Tree tree = planTreeViewer.getTree(); boolean orderReversed = tree.getSortDirection() == SWT.DOWN; RebaseInteractivePreferences.setOrderReversed(!orderReversed); int newDirection = (orderReversed ? SWT.UP : SWT.DOWN); tree.setSortDirection(newDirection); TreeItem topmostVisibleItem = tree.getTopItem(); refreshUI(); if (topmostVisibleItem != null) tree.showItem(topmostVisibleItem); } }); int direction = (RebaseInteractivePreferences.isOrderReversed() ? SWT.DOWN : SWT.UP); Tree planTree = planTreeViewer.getTree(); planTree.setSortColumn(stepColumn.getColumn()); planTree.setSortDirection(direction); TreeViewerColumn actionColumn = createColumn(headings[2]); layout.setColumnData(actionColumn.getColumn(), new ColumnPixelData(90)); actionColumn.setLabelProvider(new HighlightingColumnLabelProvider() { @Override public Image getImage(Object element) { ElementAction a = getAction(element); if (a != null) { switch (a) { case EDIT: return UIIcons.getImage(resources, UIIcons.EDITCONFIG); case FIXUP: if (RebaseInteractivePreferences.isOrderReversed()) return UIIcons.getImage(resources, UIIcons.FIXUP_DOWN); else return UIIcons.getImage(resources, UIIcons.FIXUP_UP); case PICK: return UIIcons.getImage(resources, UIIcons.CHERRY_PICK); case REWORD: return UIIcons.getImage(resources, UIIcons.REWORD); case SKIP: return UIIcons.getImage(resources, UIIcons.REBASE_SKIP); case SQUASH: if (RebaseInteractivePreferences.isOrderReversed()) return UIIcons.getImage(resources, UIIcons.SQUASH_DOWN); else return UIIcons.getImage(resources, UIIcons.SQUASH_UP); default: // fall through } } return super.getImage(element); } @Override public String getText(Object element) { ElementAction a = getAction(element); return (a != null) ? a.name() : super.getText(element); } private ElementAction getAction(Object element) { if (element instanceof PlanElement) { PlanElement planLine = (PlanElement) element; return planLine.getPlanElementAction(); } else return null; } }); TreeViewerColumn commitIDColumn = createColumn(headings[3]); int minWidth; GC gc = new GC(planTreeViewer.getControl().getDisplay()); try { gc.setFont(planTreeViewer.getControl().getFont()); minWidth = Math.max(gc.stringExtent("0000000").x, //$NON-NLS-1$ gc.stringExtent(headings[3]).x) + 10; } finally { gc.dispose(); } layout.setColumnData(commitIDColumn.getColumn(), new ColumnPixelData(minWidth)); commitIDColumn.setLabelProvider(new HighlightingColumnLabelProvider() { @Override public String getText(Object element) { if (element instanceof PlanElement) { PlanElement planLine = (PlanElement) element; return planLine.getCommit().name(); } return super.getText(element); } }); TreeViewerColumn commitMessageColumn = createColumn(headings[4]); layout.setColumnData(commitMessageColumn.getColumn(), new ColumnWeightData(200, 200)); commitMessageColumn.setLabelProvider(new HighlightingColumnLabelProvider() { @Override public String getText(Object element) { if (element instanceof PlanElement) { PlanElement planLine = (PlanElement) element; return planLine.getShortMessage(); } return super.getText(element); } }); TreeViewerColumn authorColumn = createColumn(headings[5]); layout.setColumnData(authorColumn.getColumn(), new ColumnWeightData(120, 120)); authorColumn.setLabelProvider(new HighlightingColumnLabelProvider() { @Override public String getText(Object element) { if (element instanceof PlanElement) { PlanElement planLine = (PlanElement) element; return planLine.getAuthor(); } return super.getText(element); } }); TreeViewerColumn authoredDateColumn = createColumn(headings[6]); layout.setColumnData(authoredDateColumn.getColumn(), new ColumnWeightData(80, 80)); authoredDateColumn.setLabelProvider(new HighlightingColumnLabelProvider() { @Override public String getText(Object element) { if (element instanceof PlanElement) { PlanElement planLine = (PlanElement) element; return planLine.getAuthoredDate(dateFormatter); } return super.getText(element); } }); TreeViewerColumn committerColumn = createColumn(headings[7]); layout.setColumnData(committerColumn.getColumn(), new ColumnWeightData(120, 120)); committerColumn.setLabelProvider(new HighlightingColumnLabelProvider() { @Override public String getText(Object element) { if (element instanceof PlanElement) { PlanElement planLine = (PlanElement) element; return planLine.getCommitter(); } return super.getText(element); } }); TreeViewerColumn commitDateColumn = createColumn(headings[8]); layout.setColumnData(commitDateColumn.getColumn(), new ColumnWeightData(80, 80)); commitDateColumn.setLabelProvider(new HighlightingColumnLabelProvider() { @Override public String getText(Object element) { if (element instanceof PlanElement) { PlanElement planLine = (PlanElement) element; return planLine.getCommittedDate(dateFormatter); } return super.getText(element); } }); dynamicColumns = new TreeViewerColumn[] { commitMessageColumn, authorColumn, authoredDateColumn, committerColumn, commitDateColumn }; } private TreeViewerColumn createColumn(String text) { TreeViewerColumn column = new TreeViewerColumn(planTreeViewer, SWT.NONE); column.getColumn().setText(text); column.getColumn().setMoveable(false); return column; } private void asyncExec(Runnable runnable) { PlatformUI.getWorkbench().getDisplay().asyncExec(runnable); } private static String getRepositoryName(Repository repository) { String repoName = Activator.getDefault().getRepositoryUtil().getRepositoryName(repository); RepositoryState state = repository.getRepositoryState(); if (state != RepositoryState.SAFE) return repoName + '|' + state.getDescription(); else return repoName; } private void showRepository(final Repository repository) { if (form.isDisposed()) return; if (currentPlan != null) currentPlan.removeRebaseInteractivePlanChangeListener(this); if (planIndexer != null) planIndexer.dispose(); if (isValidRepo(repository)) { currentPlan = RebaseInteractivePlan.getPlan(repository); planIndexer = new RebasePlanIndexer(currentPlan); currentPlan.addRebaseInteractivePlanChangeListener(this); form.setText(getRepositoryName(repository)); } else { currentPlan = null; planIndexer = null; form.setText(UIText.RebaseInteractiveView_NoSelection); } refresh(); } private boolean isValidRepo(final Repository repository) { return repository != null && !repository.isBare() && repository.getWorkTree().exists(); } void refresh() { if (!isReady()) return; asyncExec(new Runnable() { @Override public void run() { Tree t = planTreeViewer.getTree(); if (t.isDisposed()) return; t.setRedraw(false); try { planTreeViewer.setInput(currentPlan); refreshUI(); } finally { t.setRedraw(true); } } }); } private boolean isReady() { IWorkbenchPartSite site = this.getSite(); if (site == null) return false; return !site.getShell().isDisposed(); } private void refreshUI() { dateFormatter = getNewDateFormatter(); if (planTreeViewer != null) { planTreeViewer.refresh(true); // make column widths match the contents for (TreeViewerColumn col : dynamicColumns) { col.getColumn().pack(); } // Re-distribute the space again, now that we know the true minimum // widths. First dynamic column is the commit message; give that one // a somewhat larger minimum width. int minimumWidth = 200; for (TreeViewerColumn col : dynamicColumns) { int width = col.getColumn().getWidth(); // Use width as weight planLayout.setColumnData(col.getColumn(), new ColumnWeightData(width, minimumWidth)); minimumWidth = 80; } planLayout.layout(planTreeViewer.getTree().getParent(), true); } startItem.setEnabled(false); continueItem.setEnabled(false); skipItem.setEnabled(false); abortItem.setEnabled(false); dndEnabled = false; actionToolBarProvider.getTheToolbar().setEnabled(false); if (currentPlan == null || !currentPlan.isRebasingInteractive()) { if (currentRepository == null) form.setText(UIText.RebaseInteractiveView_NoSelection); else form.setText(getRepositoryName(currentRepository)); return; } actionToolBarProvider.mapActionItemsToSelection(planTreeViewer.getSelection()); if (!currentPlan.hasRebaseBeenStartedYet()) { if (!planTreeViewer.getSelection().isEmpty()) actionToolBarProvider.getTheToolbar().setEnabled(true); startItem.setEnabled(true); abortItem.setEnabled(true); dndEnabled = true; } else { continueItem.setEnabled(true); skipItem.setEnabled(true); abortItem.setEnabled(true); } if (RebaseInteractivePreferences.isOrderReversed()) { Tree tree = planTreeViewer.getTree(); int itemCount = tree.getItemCount(); if (itemCount > 0) { TreeItem bottomItem = tree.getItem(itemCount - 1); tree.showItem(bottomItem); } } } private void createPopupMenu(final TreeViewer planViewer) { createContextMenuItems(planViewer); MenuManager manager = new MenuManager(); manager.addMenuListener(new IMenuListener() { @Override public void menuAboutToShow(IMenuManager menuManager) { boolean selectionNotEmpty = !planViewer.getSelection().isEmpty(); boolean rebaseNotStarted = !currentPlan.hasRebaseBeenStartedYet(); boolean menuEnabled = selectionNotEmpty && rebaseNotStarted; for (PlanContextMenuAction item : contextMenuItems) item.setEnabled(menuEnabled); } }); for (PlanContextMenuAction item : contextMenuItems) manager.add(item); Menu menu = manager.createContextMenu(planViewer.getControl()); planViewer.getControl().setMenu(menu); planViewer.getControl().addKeyListener(new ContextMenuKeyListener()); } private void createContextMenuItems(final TreeViewer planViewer) { contextMenuItems = new ArrayList<>(); contextMenuItems.add(new PlanContextMenuAction(UIText.RebaseInteractiveStepActionToolBarProvider_PickText, UIIcons.CHERRY_PICK, RebaseInteractivePlan.ElementAction.PICK, planViewer, actionToolBarProvider)); contextMenuItems.add(new PlanContextMenuAction(UIText.RebaseInteractiveStepActionToolBarProvider_SkipText, UIIcons.REBASE_SKIP, RebaseInteractivePlan.ElementAction.SKIP, planViewer, actionToolBarProvider)); contextMenuItems.add(new PlanContextMenuAction(UIText.RebaseInteractiveStepActionToolBarProvider_EditText, UIIcons.EDITCONFIG, RebaseInteractivePlan.ElementAction.EDIT, planViewer, actionToolBarProvider)); contextMenuItems.add(new PlanContextMenuAction(UIText.RebaseInteractiveStepActionToolBarProvider_SquashText, UIIcons.SQUASH_UP, RebaseInteractivePlan.ElementAction.SQUASH, planViewer, actionToolBarProvider)); contextMenuItems.add(new PlanContextMenuAction(UIText.RebaseInteractiveStepActionToolBarProvider_FixupText, UIIcons.FIXUP_UP, RebaseInteractivePlan.ElementAction.FIXUP, planViewer, actionToolBarProvider)); contextMenuItems.add(new PlanContextMenuAction(UIText.RebaseInteractiveStepActionToolBarProvider_RewordText, UIIcons.REWORD, RebaseInteractivePlan.ElementAction.REWORD, planViewer, actionToolBarProvider)); } private class ContextMenuKeyListener extends KeyAdapter { @Override public void keyPressed(KeyEvent e) { int key = SWTKeySupport.convertEventToUnmodifiedAccelerator(e); for (IAction item : contextMenuItems) { if (key == item.getAccelerator()) { e.doit = false; item.run(); return; } } int[] moveAccelerators = actionToolBarProvider.getMoveAccelerators(); if (key == moveAccelerators[0]) { actionToolBarProvider.moveUp(); e.doit = false; } else if (key == moveAccelerators[1]) { actionToolBarProvider.moveDown(); e.doit = false; } else if ((e.stateMask & SWT.MODIFIER_MASK) == 0) { switch (key) { case SWT.ARROW_DOWN: case SWT.ARROW_UP: case SWT.PAGE_DOWN: case SWT.PAGE_UP: case SWT.HOME: case SWT.END: break; default: e.doit = false; break; } } } } private static GitDateFormatter getNewDateFormatter() { boolean useRelativeDates = Activator.getDefault().getPreferenceStore() .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_RELATIVE_DATE); if (useRelativeDates) return new GitDateFormatter(Format.RELATIVE); else return PreferenceBasedDateFormatter.create(); } @Override public void setFocus() { planTreeViewer.getControl().setFocus(); } boolean isDragAndDropEnabled() { return dndEnabled; } @Override public void planWasUpdatedFromRepository(final RebaseInteractivePlan plan) { refresh(); } @Override public void planElementTypeChanged(RebaseInteractivePlan rebaseInteractivePlan, PlanElement element, ElementAction oldType, ElementAction newType) { planTreeViewer.refresh(element, true); } @Override public void planElementsOrderChanged(RebaseInteractivePlan rebaseInteractivePlan, PlanElement element, int oldIndex, int newIndex) { planTreeViewer.refresh(true); } private static class PlanLayout extends TreeColumnLayout { @Override protected void layout(Composite composite, boolean flushCache) { // Just to get access to this in the enclosing class. super.layout(composite, flushCache); } } }