| /******************************************************************************* |
| * Copyright (c) 2011, 2016 GitHub Inc. 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: |
| * Kevin Sawicki (GitHub Inc.) - initial API and implementation |
| * Thomas Wolf <thomas.wolf@paranor.ch> - turn it into a real text editor |
| *******************************************************************************/ |
| package org.eclipse.egit.ui.internal.commit; |
| |
| import static java.util.Arrays.asList; |
| import static org.eclipse.egit.ui.UIPreferences.THEME_DiffAddBackgroundColor; |
| import static org.eclipse.egit.ui.UIPreferences.THEME_DiffRemoveBackgroundColor; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.SubMonitor; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.egit.core.AdapterUtils; |
| import org.eclipse.egit.ui.Activator; |
| import org.eclipse.egit.ui.UIUtils; |
| import org.eclipse.egit.ui.internal.UIText; |
| import org.eclipse.egit.ui.internal.commit.DiffRegionFormatter.DiffRegion; |
| import org.eclipse.egit.ui.internal.commit.DiffRegionFormatter.FileDiffRegion; |
| import org.eclipse.egit.ui.internal.history.FileDiff; |
| import org.eclipse.egit.ui.internal.repository.RepositoriesView; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.ActionContributionItem; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.IContributionItem; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.operation.IRunnableContext; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.preference.PreferenceStore; |
| import org.eclipse.jface.resource.ColorRegistry; |
| import org.eclipse.jface.resource.StringConverter; |
| import org.eclipse.jface.text.Document; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.Position; |
| import org.eclipse.jface.text.reconciler.IReconciler; |
| import org.eclipse.jface.text.source.Annotation; |
| import org.eclipse.jface.text.source.AnnotationModel; |
| import org.eclipse.jface.text.source.IAnnotationModel; |
| import org.eclipse.jface.text.source.IAnnotationModelExtension; |
| import org.eclipse.jface.text.source.ISourceViewer; |
| import org.eclipse.jface.text.source.IVerticalRuler; |
| import org.eclipse.jface.text.source.IVerticalRulerColumn; |
| import org.eclipse.jface.text.source.projection.ProjectionAnnotation; |
| import org.eclipse.jface.text.source.projection.ProjectionSupport; |
| import org.eclipse.jface.text.source.projection.ProjectionViewer; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jgit.lib.Repository; |
| import org.eclipse.jgit.revwalk.RevCommit; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.team.ui.history.IHistoryView; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.editors.text.EditorsUI; |
| import org.eclipse.ui.editors.text.TextEditor; |
| import org.eclipse.ui.forms.IManagedForm; |
| import org.eclipse.ui.forms.editor.FormEditor; |
| import org.eclipse.ui.forms.editor.IFormPage; |
| import org.eclipse.ui.ide.IDE; |
| import org.eclipse.ui.part.IShowInSource; |
| import org.eclipse.ui.part.IShowInTargetList; |
| import org.eclipse.ui.part.ShowInContext; |
| import org.eclipse.ui.progress.UIJob; |
| import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants; |
| import org.eclipse.ui.texteditor.AbstractDocumentProvider; |
| import org.eclipse.ui.texteditor.ChainedPreferenceStore; |
| import org.eclipse.ui.texteditor.IDocumentProvider; |
| import org.eclipse.ui.texteditor.ITextEditorActionConstants; |
| import org.eclipse.ui.themes.IThemeManager; |
| import org.eclipse.ui.views.contentoutline.IContentOutlinePage; |
| |
| /** |
| * A {@link TextEditor} wrapped as an {@link IFormPage} and specialized to |
| * showing a unified diff of a whole commit. The editor has an associated |
| * {@link DiffEditorOutlinePage}. |
| */ |
| public class DiffEditorPage extends TextEditor |
| implements IFormPage, IShowInSource, IShowInTargetList { |
| |
| private static final String ADD_ANNOTATION_TYPE = "org.eclipse.egit.ui.commitEditor.diffAdded"; //$NON-NLS-1$ |
| |
| private static final String REMOVE_ANNOTATION_TYPE = "org.eclipse.egit.ui.commitEditor.diffRemoved"; //$NON-NLS-1$ |
| |
| private FormEditor formEditor; |
| |
| private String title; |
| |
| private String pageId; |
| |
| private int pageIndex = -1; |
| |
| private Control textControl; |
| |
| private DiffEditorOutlinePage outlinePage; |
| |
| private Annotation[] currentFoldingAnnotations; |
| |
| private Annotation[] currentOverviewAnnotations; |
| |
| /** An {@link IPreferenceStore} for the annotation colors.*/ |
| private ThemePreferenceStore overviewStore; |
| |
| private FileDiffRegion currentFileDiffRange; |
| |
| private OldNewLogicalLineNumberRulerColumn lineNumberColumn; |
| |
| private boolean plainLineNumbers = false; |
| |
| /** |
| * Creates a new {@link DiffEditorPage} with the given id and title, which |
| * is shown on the page's tab. |
| * |
| * @param editor |
| * containing this page |
| * @param id |
| * of the page |
| * @param title |
| * of the page |
| */ |
| public DiffEditorPage(FormEditor editor, String id, String title) { |
| pageId = id; |
| this.title = title; |
| setPartName(title); |
| initialize(editor); |
| } |
| |
| /** |
| * Creates a new {@link DiffEditorPage} with default id and title. |
| * |
| * @param editor |
| * containing the page |
| */ |
| public DiffEditorPage(FormEditor editor) { |
| this(editor, "diffPage", UIText.DiffEditorPage_Title); //$NON-NLS-1$ |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public Object getAdapter(Class adapter) { |
| // TODO Switch to generified signature once EGit's base dependency is |
| // Eclipse 4.6 |
| if (IContentOutlinePage.class.equals(adapter)) { |
| if (outlinePage == null) { |
| outlinePage = createOutlinePage(); |
| outlinePage.setInput( |
| getDocumentProvider().getDocument(getEditorInput())); |
| if (currentFileDiffRange != null) { |
| outlinePage.setSelection( |
| new StructuredSelection(currentFileDiffRange)); |
| } |
| } |
| return outlinePage; |
| } |
| return super.getAdapter(adapter); |
| } |
| |
| private DiffEditorOutlinePage createOutlinePage() { |
| DiffEditorOutlinePage page = new DiffEditorOutlinePage(); |
| page.addSelectionChangedListener( |
| event -> doSetSelection(event.getSelection())); |
| page.addOpenListener(event -> { |
| FormEditor editor = getEditor(); |
| editor.getSite().getPage().activate(editor); |
| editor.setActivePage(getId()); |
| doSetSelection(event.getSelection()); |
| }); |
| return page; |
| } |
| |
| @Override |
| public void dispose() { |
| // Nested editors are responsible for disposing their outline pages |
| // themselves. |
| if (outlinePage != null) { |
| outlinePage.dispose(); |
| outlinePage = null; |
| } |
| if (overviewStore != null) { |
| overviewStore.dispose(); |
| overviewStore = null; |
| } |
| super.dispose(); |
| } |
| |
| // TextEditor specifics: |
| |
| @Override |
| protected ISourceViewer createSourceViewer(Composite parent, |
| IVerticalRuler ruler, int styles) { |
| DiffViewer viewer = new DiffViewer(parent, ruler, getOverviewRuler(), |
| isOverviewRulerVisible(), styles); |
| getSourceViewerDecorationSupport(viewer); |
| ProjectionSupport projector = new ProjectionSupport(viewer, |
| getAnnotationAccess(), getSharedColors()); |
| projector.install(); |
| viewer.getTextWidget().addCaretListener(event -> { |
| if (outlinePage != null) { |
| FileDiffRegion region = getFileDiffRange(event.caretOffset); |
| if (region != null && !region.equals(currentFileDiffRange)) { |
| currentFileDiffRange = region; |
| outlinePage.setSelection(new StructuredSelection(region)); |
| } else { |
| currentFileDiffRange = region; |
| } |
| } |
| }); |
| return viewer; |
| } |
| |
| @Override |
| protected IVerticalRulerColumn createLineNumberRulerColumn() { |
| lineNumberColumn = new OldNewLogicalLineNumberRulerColumn( |
| plainLineNumbers); |
| initializeLineNumberRulerColumn(lineNumberColumn); |
| return lineNumberColumn; |
| } |
| |
| @Override |
| protected void initializeEditor() { |
| super.initializeEditor(); |
| overviewStore = new ThemePreferenceStore(); |
| setPreferenceStore(new ChainedPreferenceStore(new IPreferenceStore[] { |
| overviewStore, EditorsUI.getPreferenceStore() })); |
| setDocumentProvider(new DiffDocumentProvider()); |
| setSourceViewerConfiguration( |
| new DiffViewer.Configuration(getPreferenceStore()) { |
| @Override |
| public IReconciler getReconciler( |
| ISourceViewer sourceViewer) { |
| // Switch off spell-checking |
| return null; |
| } |
| }); |
| } |
| |
| @Override |
| protected void doSetInput(IEditorInput input) throws CoreException { |
| super.doSetInput(input); |
| if (input instanceof DiffEditorInput) { |
| setFolding(); |
| FileDiffRegion region = getFileDiffRange(0); |
| currentFileDiffRange = region; |
| setOverviewAnnotations(); |
| } else if (input instanceof CommitEditorInput) { |
| formatDiff(); |
| currentFileDiffRange = null; |
| } |
| if (outlinePage != null) { |
| outlinePage.setInput(getDocumentProvider().getDocument(input)); |
| if (currentFileDiffRange != null) { |
| outlinePage.setSelection( |
| new StructuredSelection(currentFileDiffRange)); |
| } |
| } |
| } |
| |
| @Override |
| protected void doSetSelection(ISelection selection) { |
| if (!selection.isEmpty() && selection instanceof StructuredSelection) { |
| Object selected = ((StructuredSelection) selection) |
| .getFirstElement(); |
| if (selected instanceof FileDiffRegion) { |
| FileDiffRegion newRange = (FileDiffRegion) selected; |
| if (!newRange.equals(currentFileDiffRange)) { |
| currentFileDiffRange = newRange; |
| selectAndReveal(newRange.getOffset(), 0); |
| } |
| return; |
| } |
| } |
| super.doSetSelection(selection); |
| } |
| |
| @Override |
| protected void editorContextMenuAboutToShow(IMenuManager menu) { |
| super.editorContextMenuAboutToShow(menu); |
| addAction(menu, ITextEditorActionConstants.GROUP_COPY, |
| ITextEditorActionConstants.SELECT_ALL); |
| // TextEditor always adds these, even if the document is not editable. |
| menu.remove(ITextEditorActionConstants.SHIFT_RIGHT); |
| menu.remove(ITextEditorActionConstants.SHIFT_LEFT); |
| } |
| |
| @Override |
| protected void rulerContextMenuAboutToShow(IMenuManager menu) { |
| super.rulerContextMenuAboutToShow(menu); |
| // AbstractDecoratedTextEditor's menu presumes a |
| // LineNumberChangeRulerColumn, which we don't have. |
| IContributionItem showLineNumbers = menu |
| .find(ITextEditorActionConstants.LINENUMBERS_TOGGLE); |
| boolean isShowingLineNumbers = EditorsUI.getPreferenceStore() |
| .getBoolean( |
| AbstractDecoratedTextEditorPreferenceConstants.EDITOR_LINE_NUMBER_RULER); |
| if (showLineNumbers instanceof ActionContributionItem) { |
| ((ActionContributionItem) showLineNumbers).getAction() |
| .setChecked(isShowingLineNumbers); |
| } |
| if (isShowingLineNumbers) { |
| // Add an action to toggle between physical and logical line numbers |
| boolean plain = lineNumberColumn.isPlain(); |
| IAction togglePlain = new Action( |
| UIText.DiffEditorPage_ToggleLineNumbers, |
| IAction.AS_CHECK_BOX) { |
| |
| @Override |
| public void run() { |
| plainLineNumbers = !plain; |
| lineNumberColumn.setPlain(!plain); |
| } |
| }; |
| togglePlain.setChecked(!plain); |
| menu.appendToGroup(ITextEditorActionConstants.GROUP_RULERS, |
| togglePlain); |
| } |
| } |
| |
| // FormPage specifics: |
| |
| @Override |
| public void initialize(FormEditor editor) { |
| formEditor = editor; |
| } |
| |
| @Override |
| public FormEditor getEditor() { |
| return formEditor; |
| } |
| |
| @Override |
| public IManagedForm getManagedForm() { |
| return null; |
| } |
| |
| @Override |
| public void setActive(boolean active) { |
| if (active) { |
| setFocus(); |
| } |
| } |
| |
| @Override |
| public boolean isActive() { |
| return this.equals(formEditor.getActivePageInstance()); |
| } |
| |
| @Override |
| public boolean canLeaveThePage() { |
| return true; |
| } |
| |
| @Override |
| public Control getPartControl() { |
| return textControl; |
| } |
| |
| @Override |
| public String getId() { |
| return pageId; |
| } |
| |
| @Override |
| public int getIndex() { |
| return pageIndex; |
| } |
| |
| @Override |
| public void setIndex(int index) { |
| pageIndex = index; |
| } |
| |
| @Override |
| public boolean isEditor() { |
| return true; |
| } |
| |
| @Override |
| public boolean selectReveal(Object object) { |
| if (object instanceof IMarker) { |
| IDE.gotoMarker(this, (IMarker) object); |
| return true; |
| } else if (object instanceof ISelection) { |
| doSetSelection((ISelection) object); |
| return true; |
| } |
| return false; |
| } |
| |
| // WorkbenchPart specifics: |
| |
| @Override |
| public String getTitle() { |
| return title; |
| } |
| |
| @Override |
| public void createPartControl(Composite parent) { |
| super.createPartControl(parent); |
| Control[] children = parent.getChildren(); |
| textControl = children[children.length - 1]; |
| } |
| |
| // "Show In..." specifics: |
| |
| @Override |
| public ShowInContext getShowInContext() { |
| RepositoryCommit commit = AdapterUtils.adapt(getEditorInput(), |
| RepositoryCommit.class); |
| if (commit != null) { |
| return new ShowInContext(getEditorInput(), |
| new StructuredSelection(commit)); |
| } |
| return null; |
| } |
| |
| @Override |
| public String[] getShowInTargetIds() { |
| return new String[] { IHistoryView.VIEW_ID, RepositoriesView.VIEW_ID }; |
| } |
| |
| // Diff specifics: |
| |
| private void setFolding() { |
| ProjectionViewer viewer = (ProjectionViewer) getSourceViewer(); |
| if (viewer == null) { |
| return; |
| } |
| IDocument document = viewer.getDocument(); |
| if (document instanceof DiffDocument) { |
| FileDiffRegion[] regions = ((DiffDocument) document) |
| .getFileRegions(); |
| if (regions == null || regions.length <= 1) { |
| viewer.disableProjection(); |
| return; |
| } |
| viewer.enableProjection(); |
| Map<Annotation, Position> newAnnotations = new HashMap<>(); |
| for (FileDiffRegion region : regions) { |
| newAnnotations.put(new ProjectionAnnotation(), |
| new Position(region.getOffset(), region.getLength())); |
| } |
| viewer.getProjectionAnnotationModel().modifyAnnotations( |
| currentFoldingAnnotations, newAnnotations, null); |
| currentFoldingAnnotations = newAnnotations.keySet() |
| .toArray(new Annotation[newAnnotations.size()]); |
| } else { |
| viewer.disableProjection(); |
| currentFoldingAnnotations = null; |
| } |
| } |
| |
| private void setOverviewAnnotations() { |
| IDocumentProvider documentProvider = getDocumentProvider(); |
| IDocument document = documentProvider.getDocument(getEditorInput()); |
| if (!(document instanceof DiffDocument)) { |
| return; |
| } |
| IAnnotationModel annotationModel = documentProvider |
| .getAnnotationModel(getEditorInput()); |
| if (annotationModel == null) { |
| return; |
| } |
| DiffRegion[] diffs = ((DiffDocument) document).getRegions(); |
| if (diffs == null || diffs.length == 0) { |
| return; |
| } |
| Map<Annotation, Position> newAnnotations = new HashMap<>(); |
| for (DiffRegion region : diffs) { |
| if (DiffRegion.Type.ADD.equals(region.getType())) { |
| newAnnotations.put( |
| new Annotation(ADD_ANNOTATION_TYPE, true, null), |
| new Position(region.getOffset(), region.getLength())); |
| } else if (DiffRegion.Type.REMOVE.equals(region.getType())) { |
| newAnnotations.put( |
| new Annotation(REMOVE_ANNOTATION_TYPE, true, null), |
| new Position(region.getOffset(), region.getLength())); |
| } |
| } |
| if (annotationModel instanceof IAnnotationModelExtension) { |
| ((IAnnotationModelExtension) annotationModel).replaceAnnotations( |
| currentOverviewAnnotations, newAnnotations); |
| } else { |
| if (currentOverviewAnnotations != null) { |
| for (Annotation existing : currentOverviewAnnotations) { |
| annotationModel.removeAnnotation(existing); |
| } |
| } |
| for (Map.Entry<Annotation, Position> entry : newAnnotations |
| .entrySet()) { |
| annotationModel.addAnnotation(entry.getKey(), entry.getValue()); |
| } |
| } |
| currentOverviewAnnotations = newAnnotations.keySet() |
| .toArray(new Annotation[newAnnotations.size()]); |
| } |
| |
| private FileDiffRegion getFileDiffRange(int widgetOffset) { |
| DiffViewer viewer = (DiffViewer) getSourceViewer(); |
| if (viewer != null) { |
| int offset = viewer.widgetOffset2ModelOffset(widgetOffset); |
| IDocument document = getDocumentProvider() |
| .getDocument(getEditorInput()); |
| if (document instanceof DiffDocument) { |
| return ((DiffDocument) document).findFileRegion(offset); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Gets the full unified diff of a {@link RepositoryCommit}. |
| * |
| * @param commit |
| * to get the diff |
| * @return the diff as a sorted (by file path) array of {@link FileDiff}s |
| */ |
| protected FileDiff[] getDiffs(RepositoryCommit commit) { |
| List<FileDiff> diffResult = new ArrayList<>(); |
| |
| diffResult.addAll(asList(commit.getDiffs())); |
| |
| if (commit.getRevCommit().getParentCount() > 2) { |
| RevCommit untrackedCommit = commit.getRevCommit() |
| .getParent(StashEditorPage.PARENT_COMMIT_UNTRACKED); |
| diffResult |
| .addAll(asList(new RepositoryCommit(commit.getRepository(), |
| untrackedCommit).getDiffs())); |
| } |
| FileDiff[] result = diffResult.toArray(new FileDiff[diffResult.size()]); |
| Arrays.sort(result, FileDiff.PATH_COMPARATOR); |
| return result; |
| } |
| |
| /** |
| * Asynchronously gets the diff of the commit set on our |
| * {@link CommitEditorInput}, formats it into a {@link DiffDocument}, and |
| * then re-sets this editors's input to a {@link DiffEditorInput} which will |
| * cause this document to be shown. |
| */ |
| private void formatDiff() { |
| RepositoryCommit commit = AdapterUtils.adapt(getEditor(), |
| RepositoryCommit.class); |
| if (commit == null) { |
| return; |
| } |
| if (!commit.isStash() && commit.getRevCommit().getParentCount() > 1) { |
| setInput(new DiffEditorInput(commit, null)); |
| return; |
| } |
| |
| Job job = new Job(UIText.DiffEditorPage_TaskGeneratingDiff) { |
| |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| FileDiff diffs[] = getDiffs(commit); |
| DiffDocument document = new DiffDocument(); |
| try (DiffRegionFormatter formatter = new DiffRegionFormatter( |
| document)) { |
| SubMonitor progress = SubMonitor.convert(monitor, |
| diffs.length); |
| Repository repository = commit.getRepository(); |
| for (FileDiff diff : diffs) { |
| if (progress.isCanceled()) { |
| break; |
| } |
| progress.subTask(diff.getPath()); |
| try { |
| formatter.write(repository, diff); |
| } catch (IOException ignore) { |
| // Ignored |
| } |
| progress.worked(1); |
| } |
| document.connect(formatter); |
| } |
| new UIJob(UIText.DiffEditorPage_TaskUpdatingViewer) { |
| |
| @Override |
| public IStatus runInUIThread(IProgressMonitor uiMonitor) { |
| if (UIUtils.isUsable(getPartControl())) { |
| setInput(new DiffEditorInput(commit, document)); |
| } |
| return Status.OK_STATUS; |
| } |
| }.schedule(); |
| return Status.OK_STATUS; |
| } |
| }; |
| job.schedule(); |
| } |
| |
| /** |
| * An editor input that gives access to the document created by the diff |
| * formatter. |
| */ |
| private static class DiffEditorInput extends CommitEditorInput { |
| |
| private IDocument document; |
| |
| public DiffEditorInput(RepositoryCommit commit, IDocument diff) { |
| super(commit); |
| document = diff; |
| } |
| |
| public IDocument getDocument() { |
| return document; |
| } |
| |
| @Override |
| public String getName() { |
| return UIText.DiffEditorPage_Title; |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| return super.equals(obj) && (obj instanceof DiffEditorInput) |
| && Objects.equals(document, |
| ((DiffEditorInput) obj).document); |
| } |
| |
| @Override |
| public int hashCode() { |
| return super.hashCode() ^ Objects.hashCode(document); |
| } |
| } |
| |
| /** |
| * A document provider that knows about {@link DiffEditorInput}. |
| */ |
| private static class DiffDocumentProvider extends AbstractDocumentProvider { |
| |
| @Override |
| public IStatus getStatus(Object element) { |
| if (element instanceof CommitEditorInput) { |
| RepositoryCommit commit = ((CommitEditorInput) element) |
| .getCommit(); |
| if (commit != null && !commit.isStash() |
| && commit.getRevCommit() != null |
| && commit.getRevCommit().getParentCount() > 1) { |
| return Activator.createErrorStatus( |
| UIText.DiffEditorPage_WarningNoDiffForMerge); |
| } |
| } |
| return Status.OK_STATUS; |
| } |
| |
| @Override |
| protected IDocument createDocument(Object element) |
| throws CoreException { |
| if (element instanceof DiffEditorInput) { |
| IDocument document = ((DiffEditorInput) element).getDocument(); |
| if (document != null) { |
| return document; |
| } |
| } |
| return new Document(); |
| } |
| |
| @Override |
| protected IAnnotationModel createAnnotationModel(Object element) |
| throws CoreException { |
| return new AnnotationModel(); |
| } |
| |
| @Override |
| protected void doSaveDocument(IProgressMonitor monitor, Object element, |
| IDocument document, boolean overwrite) throws CoreException { |
| // Cannot save |
| } |
| |
| @Override |
| protected IRunnableContext getOperationRunner( |
| IProgressMonitor monitor) { |
| return null; |
| } |
| |
| } |
| |
| /** |
| * An ephemeral {@link PreferenceStore} that sets the annotation colors |
| * based on the theme-dependent colors defined for the line backgrounds in a |
| * unified diff. This ensures that the annotation colors are always |
| * consistent with the line backgrounds. Plus the user doesn't have to |
| * configure several related colors, and the annotations update when the |
| * theme changes. |
| */ |
| private static class ThemePreferenceStore extends PreferenceStore { |
| |
| // The colors defined in plugin.xml for these annotations are not taken |
| // into account. We always use auto-computed colors based on the current |
| // settings for the line background colors. |
| |
| private static final String ADD_ANNOTATION_COLOR_PREFERENCE = "org.eclipse.egit.ui.commitEditor.diffAddedColor"; //$NON-NLS-1$ |
| |
| private static final String REMOVE_ANNOTATION_COLOR_PREFERENCE = "org.eclipse.egit.ui.commitEditor.diffRemovedColor"; //$NON-NLS-1$ |
| |
| private final IPropertyChangeListener listener = event -> { |
| String property = event.getProperty(); |
| if (IThemeManager.CHANGE_CURRENT_THEME.equals(property)) { |
| setColorRegistry(); |
| initColors(); |
| } else if (THEME_DiffAddBackgroundColor.equals(property) |
| || THEME_DiffRemoveBackgroundColor.equals(property)) { |
| initColors(); |
| } |
| }; |
| |
| private ColorRegistry currentColors; |
| |
| public ThemePreferenceStore() { |
| super(); |
| setColorRegistry(); |
| initColors(); |
| PlatformUI.getWorkbench().getThemeManager() |
| .addPropertyChangeListener(listener); |
| } |
| |
| private void setColorRegistry() { |
| if (currentColors != null) { |
| currentColors.removeListener(listener); |
| } |
| currentColors = PlatformUI.getWorkbench().getThemeManager() |
| .getCurrentTheme().getColorRegistry(); |
| currentColors.addListener(listener); |
| } |
| |
| private void initColors() { |
| // The overview ruler tones down colors. Since our background colors |
| // usually are already rather pale, let's saturate them more and |
| // brighten them, otherwise the annotations will be barely visible. |
| RGB rgb = adjust(currentColors.getRGB(THEME_DiffAddBackgroundColor), |
| 4.0); |
| setValue(ADD_ANNOTATION_COLOR_PREFERENCE, |
| StringConverter.asString(rgb)); |
| rgb = adjust(currentColors.getRGB(THEME_DiffRemoveBackgroundColor), |
| 4.0); |
| setValue(REMOVE_ANNOTATION_COLOR_PREFERENCE, |
| StringConverter.asString(rgb)); |
| } |
| |
| /** |
| * Increases the saturation (simple multiplier), and brightens dark |
| * colors. |
| * |
| * @param rgb |
| * to modify |
| * @param saturation |
| * multiplier |
| * @return A new {@link RGB} for the new saturated and possibly |
| * brightened color |
| */ |
| private RGB adjust(RGB rgb, double saturation) { |
| float[] hsb = rgb.getHSB(); |
| // We also brighten the color because otherwise the color |
| // manipulations in OverviewRuler result in a fill color barely |
| // discernible from a dark background. |
| return new RGB(hsb[0], (float) Math.min(hsb[1] * saturation, 1.0), |
| hsb[2] < 0.5 ? hsb[2] * 2 : hsb[2]); |
| } |
| |
| public void dispose() { |
| PlatformUI.getWorkbench().getThemeManager() |
| .removePropertyChangeListener(listener); |
| if (currentColors != null) { |
| currentColors.removeListener(listener); |
| currentColors = null; |
| } |
| } |
| } |
| } |
