Public Git Hosting - egit/eclipse.git/blob - org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/commit/DiffViewer.java

1 /*******************************************************************************

4 * are made available under the terms of the Eclipse Public License 2.0

5 * which accompanies this distribution, and is available at

6 * https://www.eclipse.org/legal/epl-2.0/

7 *

8 * SPDX-License-Identifier: EPL-2.0

9 *

10 * Contributors:

11 * Kevin Sawicki (GitHub Inc.) - initial API and implementation

12 * Tobias Pfeifer (SAP AG) - customizable font and color for the first header line - https://bugs.eclipse.org/397723

13 * Thomas Wolf <thomas.wolf@paranor.ch> - add hyperlinks, and use JFace syntax coloring

14 *******************************************************************************/

package org.eclipse.egit.ui.internal.commit;

import static org.eclipse.egit.ui.UIPreferences.THEME_DiffAddBackgroundColor;

import static org.eclipse.egit.ui.UIPreferences.THEME_DiffAddForegroundColor;

import static org.eclipse.egit.ui.UIPreferences.THEME_DiffHeadlineBackgroundColor;

import static org.eclipse.egit.ui.UIPreferences.THEME_DiffHeadlineFont;

import static org.eclipse.egit.ui.UIPreferences.THEME_DiffHeadlineForegroundColor;

import static org.eclipse.egit.ui.UIPreferences.THEME_DiffHunkBackgroundColor;

import static org.eclipse.egit.ui.UIPreferences.THEME_DiffHunkForegroundColor;

import static org.eclipse.egit.ui.UIPreferences.THEME_DiffRemoveBackgroundColor;

import static org.eclipse.egit.ui.UIPreferences.THEME_DiffRemoveForegroundColor;

27 import java.io.File;

28 import java.io.IOException;

29 import java.util.ArrayList;

30 import java.util.Arrays;

31 import java.util.HashMap;

32 import java.util.List;

33 import java.util.Map;

import java.util.function.Supplier;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.eclipse.compare.ITypedElement;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.Path;

import org.eclipse.egit.core.internal.util.ResourceUtil;

import org.eclipse.egit.ui.Activator;

import org.eclipse.egit.ui.internal.CompareUtils;

import org.eclipse.egit.ui.internal.EgitUiEditorUtils;

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.dialogs.HyperlinkSourceViewer;

import org.eclipse.egit.ui.internal.history.FileDiff;

import org.eclipse.egit.ui.internal.revision.GitCompareFileRevisionEditorInput;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.resource.ColorRegistry;

import org.eclipse.jface.resource.FontRegistry;

import org.eclipse.jface.resource.JFaceResources;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.Document;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.IRegion;

import org.eclipse.jface.text.ITextViewer;

import org.eclipse.jface.text.ITypedRegion;

import org.eclipse.jface.text.Region;

import org.eclipse.jface.text.TextAttribute;

import org.eclipse.jface.text.TextUtilities;

import org.eclipse.jface.text.hyperlink.AbstractHyperlinkDetector;

import org.eclipse.jface.text.hyperlink.IHyperlink;

import org.eclipse.jface.text.hyperlink.IHyperlinkDetector;

import org.eclipse.jface.text.hyperlink.IHyperlinkDetectorExtension2;

import org.eclipse.jface.text.presentation.IPresentationReconciler;

import org.eclipse.jface.text.presentation.PresentationReconciler;

import org.eclipse.jface.text.rules.DefaultDamagerRepairer;

import org.eclipse.jface.text.rules.IToken;

import org.eclipse.jface.text.rules.ITokenScanner;

import org.eclipse.jface.text.rules.Token;

import org.eclipse.jface.text.source.IOverviewRuler;

import org.eclipse.jface.text.source.ISourceViewer;

import org.eclipse.jface.text.source.IVerticalRuler;

import org.eclipse.jface.text.source.SourceViewerConfiguration;

import org.eclipse.jface.util.IPropertyChangeListener;

import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.jgit.annotations.NonNull;

import org.eclipse.jgit.diff.DiffEntry;

import org.eclipse.jgit.diff.DiffEntry.ChangeType;

import org.eclipse.jgit.lib.ObjectId;

import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.revwalk.RevCommit;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Layout;

import org.eclipse.team.core.history.IFileRevision;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.themes.IThemeManager;

101

102 /**

103 * Source viewer to display one or more file differences using standard editor

104 * colors and fonts preferences. Should be used together with a

105 * {@link DiffDocument} to get proper coloring and hyperlink support.

106 */

107 public class DiffViewer extends HyperlinkSourceViewer {

108

        private final Map<String, IToken> tokens = new HashMap<>();

110

        private final Map<String, Color> backgroundColors = new HashMap<>();

112

        private IPropertyChangeListener themeListener = new IPropertyChangeListener() {

114

115 @Override

116 public void propertyChange(PropertyChangeEvent event) {

117 String property = event.getProperty();

                        if (IThemeManager.CHANGE_CURRENT_THEME.equals(property)

                                        || THEME_DiffAddBackgroundColor.equals(property)

                                        || THEME_DiffAddForegroundColor.equals(property)

                                        || THEME_DiffHunkBackgroundColor.equals(property)

                                        || THEME_DiffHunkForegroundColor.equals(property)

                                        || THEME_DiffHeadlineBackgroundColor.equals(property)

                                        || THEME_DiffHeadlineForegroundColor.equals(property)

                                        || THEME_DiffHeadlineFont.equals(property)

                                        || THEME_DiffRemoveBackgroundColor.equals(property)

                                        || THEME_DiffRemoveForegroundColor.equals(property)) {

128 refreshDiffStyles();

129 invalidateTextPresentation();

130 }

131 }

132 };

133

134 /**

135 * A configuration to use with a {@link DiffViewer}, setting up the syntax

136 * coloring for a diff and adding the {@link IHyperlinkDetector} for the

137 * links.

138 */

139 public static class Configuration

140 extends HyperlinkSourceViewer.Configuration {

141

142 /**

143 * Creates a new {@link Configuration} connected to the given

144 * {@link IPreferenceStore}.

145 *

146 * @param preferenceStore

147 * to connect to

148 */

149 public Configuration(IPreferenceStore preferenceStore) {

150 super(preferenceStore);

151 }

152

153 @Override

154 public int getHyperlinkStateMask(ISourceViewer sourceViewer) {

155 return SWT.NONE;

156 }

157

158 @Override

159 protected IHyperlinkDetector[] internalGetHyperlinkDetectors(

160 ISourceViewer sourceViewer) {

                        Assert.isTrue(sourceViewer instanceof DiffViewer);

                        IHyperlinkDetector[] result = { new HyperlinkDetector() };

163 return result;

164 }

165

166 @Override

                public String[] getConfiguredContentTypes(ISourceViewer sourceViewer) {

                        Assert.isTrue(sourceViewer instanceof DiffViewer);

169 DiffViewer viewer = (DiffViewer) sourceViewer;

                        return viewer.tokens.keySet()

                                        .toArray(new String[viewer.tokens.size()]);

172 }

173

174 @Override

175 public IPresentationReconciler getPresentationReconciler(

176 ISourceViewer sourceViewer) {

                        Assert.isTrue(sourceViewer instanceof DiffViewer);

178 DiffViewer viewer = (DiffViewer) sourceViewer;

179 PresentationReconciler reconciler = new PresentationReconciler();

180 reconciler.setDocumentPartitioning(

181 getConfiguredDocumentPartitioning(viewer));

                        for (String contentType : viewer.tokens.keySet()) {

183 DefaultDamagerRepairer damagerRepairer = new DefaultDamagerRepairer(

184 new SingleTokenScanner(

                                                                () -> viewer.tokens.get(contentType)));

                                reconciler.setDamager(damagerRepairer, contentType);

                                reconciler.setRepairer(damagerRepairer, contentType);

188 }

189 return reconciler;

190 }

191 }

192

193 /**

194 * Creates a new {@link DiffViewer}.

195 *

196 * @param parent

197 * to contain the viewer

198 * @param ruler

199 * for the viewer (left side)

200 * @param styles

201 * for the viewer

202 */

        public DiffViewer(Composite parent, IVerticalRuler ruler, int styles) {

                this(parent, ruler, null, false, styles);

205 }

206

207 /**

208 * Creates a new {@link DiffViewer}.

209 *

210 * @param parent

211 * to contain the viewer

212 * @param ruler

213 * for the viewer (left side)

214 * @param overviewRuler

215 * ruler for overview annotations

216 * @param showsAnnotationOverview

217 * whether to show overview annotations

218 * @param styles

219 * for the viewer

220 */

        public DiffViewer(Composite parent, IVerticalRuler ruler,

222 IOverviewRuler overviewRuler, boolean showsAnnotationOverview,

223 int styles) {

                super(parent, ruler, overviewRuler, showsAnnotationOverview, styles);

                getTextWidget().setAlwaysShowScrollBars(false);

226 setEditable(false);

                setDocument(new Document());

228 initListeners();

229 getTextWidget()

                                .setFont(JFaceResources.getFont(JFaceResources.TEXT_FONT));

231 refreshDiffStyles();

232 }

233

234 @Override

235 protected void handleDispose() {

                PlatformUI.getWorkbench().getThemeManager()

237 .removePropertyChangeListener(themeListener);

238 super.handleDispose();

239 }

240

241 @Override

242 public void configure(SourceViewerConfiguration config) {

                Assert.isTrue(config instanceof Configuration);

                super.configure(config);

245 }

246

247 @Override

248 protected Layout createLayout() {

249 return new FixedRulerLayout(GAP_SIZE_1);

250 }

251

252 private class FixedRulerLayout extends RulerLayout {

253

                public FixedRulerLayout(int gap) {

255 super(gap);

256 }

257

258 @Override

                protected void layout(Composite composite, boolean flushCache) {

260 Rectangle bounds = composite.getBounds();

                        if (bounds.width == 0 || bounds.height == 0) {

262 // The overview ruler is laid out wrongly in the DiffEditorPage:

263 // it ends up with a negative y-coordinate. This seems to be

264 // caused by layout attempts while the page is not visible,

265 // which cache that bogus negative offset in RulerLayout, which

266 // will re-use it even when the viewer is laid out again when

267 // the page is visible. So don't layout if the containing

268 // composite has no extent.

269 return;

270 }

                        super.layout(composite, flushCache);

272 }

273 }

274

275 private void refreshDiffStyles() {

                ColorRegistry col = PlatformUI.getWorkbench().getThemeManager()

                                .getCurrentTheme().getColorRegistry();

                FontRegistry reg = PlatformUI.getWorkbench().getThemeManager()

                                .getCurrentTheme().getFontRegistry();

280 // We do the foreground via syntax coloring and the background via a

281 // line background listener. If we did the background also via the

282 // TextAttributes, this would take precedence over the line background

283 // resulting in strange display if the current line is highlighted:

284 // that highlighting would appear only beyond the end of the actual

285 // text content (i.e., beyond the end-of-line), while actual text

286 // would still get the background from the attribute.

                tokens.put(IDocument.DEFAULT_CONTENT_TYPE, new Token(null));

                tokens.put(DiffDocument.HEADLINE_CONTENT_TYPE,

                                new Token(new TextAttribute(

                                                col.get(THEME_DiffHeadlineForegroundColor), null,

                                                SWT.NORMAL, reg.get(THEME_DiffHeadlineFont))));

                tokens.put(DiffDocument.HUNK_CONTENT_TYPE, new Token(

                                new TextAttribute(col.get(THEME_DiffHunkForegroundColor))));

                tokens.put(DiffDocument.ADDED_CONTENT_TYPE, new Token(

                                new TextAttribute(col.get(THEME_DiffAddForegroundColor))));

                tokens.put(DiffDocument.REMOVED_CONTENT_TYPE, new Token(

                                new TextAttribute(col.get(THEME_DiffRemoveForegroundColor))));

                backgroundColors.put(DiffDocument.HEADLINE_CONTENT_TYPE,

299 col.get(THEME_DiffHeadlineBackgroundColor));

                backgroundColors.put(DiffDocument.HUNK_CONTENT_TYPE,

301 col.get(THEME_DiffHunkBackgroundColor));

                backgroundColors.put(DiffDocument.ADDED_CONTENT_TYPE,

303 col.get(THEME_DiffAddBackgroundColor));

                backgroundColors.put(DiffDocument.REMOVED_CONTENT_TYPE,

305 col.get(THEME_DiffRemoveBackgroundColor));

306 }

307

308 private void initListeners() {

                PlatformUI.getWorkbench().getThemeManager()

                                .addPropertyChangeListener(this.themeListener);

                getTextWidget().addLineBackgroundListener((event) -> {

312 IDocument document = getDocument();

313 if (document instanceof DiffDocument) {

314 try {

315 // We are in SWT land here: we get widget offsets.

316 int modelOffset = widgetOffset2ModelOffset(

317 event.lineOffset);

318 ITypedRegion partition = ((DiffDocument) document)

319 .getPartition(modelOffset);

                                        if (partition != null) {

                                                Color color = backgroundColors.get(partition.getType());

                                                if (color != null) {

323 event.lineBackground = color;

324 }

325 }

326 } catch (BadLocationException e) {

327 // Ignore

328 }

329 }

330 });

331 }

332

333 @Override

334 protected void handleJFacePreferencesChange(PropertyChangeEvent event) {

                if (JFaceResources.TEXT_FONT.equals(event.getProperty())) {

                        setFont(JFaceResources.getFont(JFaceResources.TEXT_FONT));

337 } else {

                        super.handleJFacePreferencesChange(event);

339 }

340 }

341

342 private static class SingleTokenScanner implements ITokenScanner {

343

344 private final Supplier<IToken> token;

345

346 private int currentOffset;

347

348 private int end;

349

350 private int tokenStart;

351

                public SingleTokenScanner(Supplier<IToken> supplier) {

353 this.token = supplier;

354 }

355

356 @Override

                public void setRange(IDocument document, int offset, int length) {

358 currentOffset = offset;

359 end = offset + length;

360 tokenStart = -1;

361 }

362

363 @Override

364 public IToken nextToken() {

365 tokenStart = currentOffset;

366 if (currentOffset < end) {

367 currentOffset = end;

368 return token.get();

369 }

370 return Token.EOF;

371 }

372

373 @Override

374 public int getTokenOffset() {

375 return tokenStart;

376 }

377

378 @Override

379 public int getTokenLength() {

380 return currentOffset - tokenStart;

381 }

382

383 }

384

385 private static class HyperlinkDetector extends AbstractHyperlinkDetector

386 implements IHyperlinkDetectorExtension2 {

387

388 private final Pattern HUNK_LINE_PATTERN = Pattern

                                .compile("@@ ([-+]?(\\d+),\\d+) ([-+]?(\\d+),\\d+) @@"); //$NON-NLS-1$

390

391 @Override

                public IHyperlink[] detectHyperlinks(ITextViewer textViewer,

393 IRegion region, boolean canShowMultipleHyperlinks) {

394 IDocument document = textViewer.getDocument();

395 if (!(document instanceof DiffDocument)

                                        || document.getLength() == 0) {

397 return null;

398 }

399 DiffDocument diffDocument = (DiffDocument) document;

                        DiffRegion[] regions = diffDocument.getRegions();

                        FileDiffRegion[] fileRegions = diffDocument.getFileRegions();

                        if (regions == null || regions.length == 0 || fileRegions == null

                                        || fileRegions.length == 0) {

404 return null;

405 }

                        int start = region.getOffset();

                        int end = region.getOffset() + region.getLength();

                        DiffRegion key = new DiffRegion(start, 0);

                        int i = Arrays.binarySearch(regions, key, (a, b) -> {

                                if (a.getOffset() > b.getOffset() + b.getLength()) {

411 return 1;

412 }

                                if (a.getOffset() + a.getLength() < b.getOffset()) {

414 return -1;

415 }

416 return 0;

417 });

                        List<IHyperlink> links = new ArrayList<>();

419 FileDiffRegion fileRange = null;

                        for (; i >= 0 && i < regions.length; i++) {

421 DiffRegion range = regions[i];

                                if (range.getOffset() >= end) {

423 break;

424 }

                                if (range.getOffset() + range.getLength() <= start) {

426 continue;

427 }

428 // Range overlaps region

                                switch (range.getType()) {

430 case HEADLINE:

                                        fileRange = findFileRange(diffDocument, fileRange,

432 range.getOffset());

                                        if (fileRange != null) {

                                                DiffEntry.ChangeType change = fileRange.getDiff()

435 .getChange();

436 switch (change) {

437 case ADD:

438 case DELETE:

439 break;

440 default:

                                                        if (getString(document, range.getOffset(),

                                                                        range.getLength()).startsWith("diff")) { //$NON-NLS-1$

443 // "diff" is at the beginning

444 IRegion linkRegion = new Region(

                                                                                range.getOffset(), 4);

                                                                if (TextUtilities.overlaps(region,

447 linkRegion)) {

                                                                        links.add(new CompareLink(linkRegion,

449 fileRange, -1));

450 }

451 }

452 break;

453 }

454 }

455 break;

456 case HEADER:

                                        fileRange = findFileRange(diffDocument, fileRange,

458 range.getOffset());

                                        if (fileRange != null) {

                                                String line = getString(document, range.getOffset(),

461 range.getLength());

                                                createHeaderLinks((DiffDocument) document, region,

                                                                fileRange, range, line, DiffEntry.Side.OLD,

464 links);

                                                createHeaderLinks((DiffDocument) document, region,

                                                                fileRange, range, line, DiffEntry.Side.NEW,

467 links);

468 }

469 break;

470 case HUNK:

                                        fileRange = findFileRange(diffDocument, fileRange,

472 range.getOffset());

                                        if (fileRange != null) {

                                                String line = getString(document, range.getOffset(),

475 range.getLength());

                                                Matcher m = HUNK_LINE_PATTERN.matcher(line);

                                                if (m.find()) {

                                                        int lineOffset = getContextLines(document, range,

                                                                        i + 1 < regions.length ? regions[i + 1]

480 : null);

                                                        createHunkLinks(region, fileRange, range, m,

482 lineOffset, links);

483 }

484 }

485 break;

486 default:

487 break;

488 }

489 }

                        if (links.isEmpty()) {

491 return null;

492 }

                        return links.toArray(new IHyperlink[links.size()]);

494 }

495

                private String getString(IDocument document, int offset, int length) {

497 try {

                                return document.get(offset, length);

499 } catch (BadLocationException e) {

500 return ""; //$NON-NLS-1$

501 }

502 }

503

                private int getContextLines(IDocument document, DiffRegion hunk,

505 DiffRegion next) {

                        if (next != null) {

507 try {

                                        switch (next.getType()) {

509 case CONTEXT:

                                                int nofLines = document.getNumberOfLines(

                                                                next.getOffset(), next.getLength());

512 return nofLines - 1;

513 case ADD:

514 case REMOVE:

515 int hunkLine = document

                                                                .getLineOfOffset(hunk.getOffset());

517 int diffLine = document

                                                                .getLineOfOffset(next.getOffset());

                                                return diffLine - hunkLine - 1;

520 default:

521 break;

522 }

523 } catch (BadLocationException e) {

524 // Ignore

525 }

526 }

527 return 0;

528 }

529

530 private FileDiffRegion findFileRange(DiffDocument document,

531 FileDiffRegion candidate, int offset) {

                        if (candidate != null && TextUtilities.overlaps(candidate,

                                        new Region(offset, 0))) {

534 return candidate;

535 }

                        return document.findFileRegion(offset);

537 }

538

                private void createHeaderLinks(DiffDocument document, IRegion region,

540 FileDiffRegion fileRange, DiffRegion range, String line,

                                @NonNull DiffEntry.Side side, List<IHyperlink> links) {

                        Pattern p = document.getPathPattern(side);

                        if (p == null) {

544 return;

545 }

                        DiffEntry.ChangeType change = fileRange.getDiff().getChange();

547 switch (side) {

548 case OLD:

                                if (change == DiffEntry.ChangeType.ADD) {

550 return;

551 }

552 break;

553 default:

                                if (change == DiffEntry.ChangeType.DELETE) {

555 return;

556 }

557 break;

558

559 }

                        Matcher m = p.matcher(line);

                        if (m.find()) {

                                IRegion linkRegion = new Region(range.getOffset() + m.start(),

                                                m.end() - m.start());

                                if (TextUtilities.overlaps(region, linkRegion)) {

                                        if (side == DiffEntry.Side.NEW) {

                                                File file = new Path(fileRange.getRepository()

                                                                .getWorkTree().getAbsolutePath()).append(

                                                                                fileRange.getDiff().getNewPath())

569 .toFile();

                                                if (file.exists()) {

                                                        links.add(new FileLink(linkRegion, file, -1));

572 }

573 }

                                        links.add(new OpenLink(linkRegion, fileRange, side, -1));

575 }

576 }

577 }

578

                private void createHunkLinks(IRegion region, FileDiffRegion fileRange,

580 DiffRegion range, Matcher m, int lineOffset,

581 List<IHyperlink> links) {

                        DiffEntry.ChangeType change = fileRange.getDiff().getChange();

                        if (change != DiffEntry.ChangeType.ADD) {

                                IRegion linkRegion = new Region(range.getOffset() + m.start(1),

                                                m.end(1) - m.start(1));

                                if (TextUtilities.overlaps(linkRegion, region)) {

                                        int lineNo = Integer.parseInt(m.group(2)) - 1 + lineOffset;

                                        if (change != DiffEntry.ChangeType.DELETE) {

589 links.add(

                                                                new CompareLink(linkRegion, fileRange, lineNo));

591 }

                                        links.add(new OpenLink(linkRegion, fileRange,

593 DiffEntry.Side.OLD, lineNo));

594 }

595 }

                        if (change != DiffEntry.ChangeType.DELETE) {

                                IRegion linkRegion = new Region(range.getOffset() + m.start(3),

                                                m.end(3) - m.start(3));

                                if (TextUtilities.overlaps(linkRegion, region)) {

                                        int lineNo = Integer.parseInt(m.group(4)) - 1 + lineOffset;

                                        if (change != DiffEntry.ChangeType.ADD) {

602 links.add(

                                                                new CompareLink(linkRegion, fileRange, lineNo));

604 }

                                        File file = new Path(fileRange.getRepository().getWorkTree()

606 .getAbsolutePath())

                                                                        .append(fileRange.getDiff().getNewPath())

608 .toFile();

                                        if (file.exists()) {

                                                links.add(new FileLink(linkRegion, file, lineNo));

611 }

                                        links.add(new OpenLink(linkRegion, fileRange,

613 DiffEntry.Side.NEW, lineNo));

614 }

615 }

616 }

617

618 @Override

619 public int getStateMask() {

620 return -1;

621 }

622 }

623

624 private static abstract class RevealLink implements IHyperlink {

625

626 private final IRegion region;

627

628 protected final int lineNo;

629

                protected RevealLink(IRegion region, int lineNo) {

631 this.region = region;

632 this.lineNo = lineNo;

633 }

634

635 @Override

636 public IRegion getHyperlinkRegion() {

637 return region;

638 }

639

640 @Override

641 public String getTypeLabel() {

642 return null;

643 }

644

645 }

646

647 private static class FileLink extends RevealLink {

648

649 private final File file;

650

                public FileLink(IRegion region, File file, int lineNo) {

652 super(region, lineNo);

653 this.file = file;

654 }

655

656 @Override

657 public String getHyperlinkText() {

658 return UIText.DiffViewer_OpenWorkingTreeLinkLabel;

659 }

660

661 @Override

662 public void open() {

663 openFileInEditor(file, lineNo);

664 }

665

666 }

667

668 private static class CompareLink extends RevealLink {

669

670 protected final Repository repository;

671

672 protected final FileDiff fileDiff;

673

                public CompareLink(IRegion region, FileDiffRegion fileRange,

675 int lineNo) {

676 super(region, lineNo);

                        this.repository = fileRange.getRepository();

                        this.fileDiff = fileRange.getDiff();

679 }

680

681 @Override

682 public String getHyperlinkText() {

683 return UIText.DiffViewer_OpenComparisonLinkLabel;

684 }

685

686 @Override

687 public void open() {

688 // No way to selectAndReveal a line or a diff node in a

689 // CompareEditor?

690 showTwoWayFileDiff(repository, fileDiff);

691 }

692

693 }

694

695 private static class OpenLink extends CompareLink {

696

697 private final DiffEntry.Side side;

698

                public OpenLink(IRegion region, FileDiffRegion fileRange,

700 DiffEntry.Side side, int lineNo) {

                        super(region, fileRange, lineNo);

702 this.side = side;

703 }

704

705 @Override

706 public String getHyperlinkText() {

707 switch (side) {

708 case OLD:

709 return UIText.DiffViewer_OpenPreviousLinkLabel;

710 default:

711 return UIText.DiffViewer_OpenInEditorLinkLabel;

712 }

713 }

714

715 @Override

716 public void open() {

                        openInEditor(repository, fileDiff, side, lineNo);

718 }

719

720 }

721

722 /**

723 * Opens the file, if it exists, in an editor.

724 *

725 * @param file

726 * to open

727 * @param lineNoToReveal

728 * if >= 0, select and reveals the given line

729 */

        public static void openFileInEditor(File file, int lineNoToReveal) {

                if (!file.exists()) {

732 Activator.showError(

                                        NLS.bind(UIText.DiffViewer_FileDoesNotExist,

734 file.getPath()),

735 null);

736 return;

737 }

738 IWorkbenchPage page = PlatformUI.getWorkbench()

                                .getActiveWorkbenchWindow().getActivePage();

                IEditorPart editor = EgitUiEditorUtils.openEditor(file, page);

                EgitUiEditorUtils.revealLine(editor, lineNoToReveal);

742 }

743

744 /**

745 * Opens either the new or the old version of a {@link FileDiff} in an

746 * editor.

747 *

748 * @param repository

749 * the {@link FileDiff} belongs to

750 * @param d

751 * the {@link FileDiff}

752 * @param side

753 * to show

754 * @param lineNoToReveal

755 * if >= 0, select and reveals the given line

756 */

        public static void openInEditor(Repository repository, FileDiff d,

758 DiffEntry.Side side, int lineNoToReveal) {

                ObjectId[] blobs = d.getBlobs();

760 switch (side) {

761 case OLD:

                        openInEditor(repository, d.getOldPath(), d.getCommit().getParent(0),

763 blobs[0], lineNoToReveal);

764 break;

765 default:

                        openInEditor(repository, d.getNewPath(), d.getCommit(),

                                        blobs[blobs.length - 1], lineNoToReveal);

768 break;

769 }

770 }

771

        private static void openInEditor(Repository repository, String path,

773 RevCommit commit, ObjectId blob, int reveal) {

774 try {

                        IFileRevision rev = CompareUtils.getFileRevision(path, commit,

776 repository, blob);

                        if (rev == null) {

778 String message = NLS.bind(

779 UIText.DiffViewer_notContainedInCommit, path,

780 commit.getName());

                                Activator.showError(message, null);

782 return;

783 }

784 IWorkbenchWindow window = PlatformUI.getWorkbench()

785 .getActiveWorkbenchWindow();

786 IWorkbenchPage page = window.getActivePage();

                        IEditorPart editor = EgitUiEditorUtils.openEditor(page, rev,

788 new NullProgressMonitor());

                        EgitUiEditorUtils.revealLine(editor, reveal);

                } catch (IOException | CoreException e) {

                        Activator.handleError(UIText.GitHistoryPage_openFailed, e, true);

792 }

793 }

794

795 /**

796 * Shows a two-way diff between the old and new versions of a

797 * {@link FileDiff} in a compare editor.

798 *

799 * @param repository

800 * the {@link FileDiff} belongs to

801 * @param d

802 * the {@link FileDiff} to show

803 */

        public static void showTwoWayFileDiff(Repository repository, FileDiff d) {

805 String np = d.getNewPath();

806 String op = d.getOldPath();

807 RevCommit c = d.getCommit();

                ObjectId[] blobs = d.getBlobs();

809

810 // extract commits

811 final RevCommit oldCommit;

812 final ObjectId oldObjectId;

                if (!d.getChange().equals(ChangeType.ADD)) {

                        oldCommit = c.getParent(0);

815 oldObjectId = blobs[0];

816 } else {

817 // Initial import

818 oldCommit = null;

819 oldObjectId = null;

820 }

821

822 final RevCommit newCommit;

823 final ObjectId newObjectId;

                if (d.getChange().equals(ChangeType.DELETE)) {

825 newCommit = null;

826 newObjectId = null;

827 } else {

828 newCommit = c;

                        newObjectId = blobs[blobs.length - 1];

830 }

831 IWorkbenchWindow window = PlatformUI.getWorkbench()

832 .getActiveWorkbenchWindow();

833 IWorkbenchPage page = window.getActivePage();

                if (oldCommit != null && newCommit != null && repository != null) {

835 IFile file = np != null

                                        ? ResourceUtil.getFileForLocation(repository, np, false)

837 : null;

838 try {

                                if (file != null) {

                                        CompareUtils.compare(file, repository, np, op,

                                                        newCommit.getName(), oldCommit.getName(), false,

842 page);

843 } else {

                                        CompareUtils.compareBetween(repository, np, op,

                                                        newCommit.getName(), oldCommit.getName(),

846 page);

847 }

848 } catch (IOException e) {

                                Activator.handleError(UIText.GitHistoryPage_openFailed, e,

850 true);

851 }

852 return;

853 }

854

855 // still happens on initial commits

                final ITypedElement oldSide = createTypedElement(repository, op,

857 oldCommit, oldObjectId);

                final ITypedElement newSide = createTypedElement(repository, np,

859 newCommit, newObjectId);

860 CompareUtils.openInCompare(page,

                                new GitCompareFileRevisionEditorInput(newSide, oldSide, null));

862 }

863

864 private static ITypedElement createTypedElement(Repository repository,

                        String path, final RevCommit commit, final ObjectId objectId) {

                if (null != commit) {

                        return CompareUtils.getFileRevisionTypedElement(path, commit,

868 repository, objectId);

869 } else {

                        return new GitCompareFileRevisionEditorInput.EmptyTypedElement(""); //$NON-NLS-1$

871 }

872 }

873

874 }