Public Git Hosting - egit/eclipse.git/blob - org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/commit/CommitEditor.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 * Daniel Megert <daniel_megert@ch.ibm.com> - Added context menu to the Commit Editor's header text

13 * Tomasz Zarna <Tomasz.Zarna@pl.ibm.com> - Add "Revert" action to Commit Editor

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

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

17 import java.text.MessageFormat;

import java.util.concurrent.atomic.AtomicBoolean;

import org.eclipse.core.runtime.Adapters;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.egit.core.RepositoryCache;

import org.eclipse.egit.core.internal.IRepositoryCommit;

import org.eclipse.egit.ui.Activator;

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

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

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

import org.eclipse.egit.ui.internal.actions.ActionCommands;

import org.eclipse.egit.ui.internal.components.EditorVisibilityTracker;

import org.eclipse.egit.ui.internal.properties.CommitPropertySource;

import org.eclipse.egit.ui.internal.properties.GitPropertySheetPage;

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.ContributionManager;

import org.eclipse.jface.action.ControlContribution;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.action.IContributionItem;

import org.eclipse.jface.action.IToolBarManager;

import org.eclipse.jface.action.ToolBarManager;

import org.eclipse.jface.dialogs.IPageChangedListener;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.jface.resource.JFaceResources;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jgit.api.StashListCommand;

import org.eclipse.jgit.events.ListenerHandle;

import org.eclipse.jgit.events.RefsChangedEvent;

import org.eclipse.jgit.events.RefsChangedListener;

import org.eclipse.jgit.lib.ObjectId;

import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.revwalk.RevCommit;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.ui.IEditorActionBarContributor;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.IPartService;

import org.eclipse.ui.ISharedImages;

import org.eclipse.ui.ISources;

import org.eclipse.ui.IWorkbenchPartReference;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.forms.IFormColors;

import org.eclipse.ui.forms.IManagedForm;

import org.eclipse.ui.forms.editor.IFormPage;

import org.eclipse.ui.forms.editor.SharedHeaderFormEditor;

import org.eclipse.ui.forms.events.HyperlinkAdapter;

import org.eclipse.ui.forms.events.HyperlinkEvent;

import org.eclipse.ui.forms.widgets.FormToolkit;

import org.eclipse.ui.forms.widgets.ImageHyperlink;

import org.eclipse.ui.forms.widgets.ScrolledForm;

import org.eclipse.ui.ide.IDE;

import org.eclipse.ui.menus.IMenuService;

import org.eclipse.ui.part.IShowInSource;

import org.eclipse.ui.part.IShowInTargetList;

import org.eclipse.ui.part.MultiPageEditorSite;

import org.eclipse.ui.part.ShowInContext;

import org.eclipse.ui.progress.UIJob;

import org.eclipse.ui.services.IEvaluationService;

import org.eclipse.ui.views.contentoutline.IContentOutlinePage;

import org.eclipse.ui.views.properties.IPropertySheetPage;

import org.eclipse.ui.views.properties.IPropertySource;

import org.eclipse.ui.views.properties.PropertySheetPage;

92 /**

93 * Editor class to view a commit in a form editor.

94 */

95 public class CommitEditor extends SharedHeaderFormEditor implements

96 RefsChangedListener, IShowInSource, IShowInTargetList {

98 /**

99 * ID - editor id

100 */

        public static final String ID = "org.eclipse.egit.ui.commitEditor"; //$NON-NLS-1$

102

        private static final String TOOLBAR_HEADER_ID = ID + ".header.toolbar"; //$NON-NLS-1$

104

105 /**

106 * Open commit in editor

107 *

108 * @param commit

109 * @return opened editor part

110 * @throws PartInitException

111 */

112 public static final IEditorPart open(RepositoryCommit commit)

113 throws PartInitException {

                return open(commit, true);

115 }

116

117 /**

118 * Open commit in editor

119 *

120 * @param commit

121 * @param activateOnOpen <code>true</code> if the newly opened editor should be activated

122 * @return opened editor part

123 * @throws PartInitException

124 * @since 2.1

125 */

        public static final IEditorPart open(RepositoryCommit commit, boolean activateOnOpen)

127 throws PartInitException {

                CommitEditorInput input = new CommitEditorInput(commit);

                return IDE.openEditor(PlatformUI.getWorkbench()

                                .getActiveWorkbenchWindow().getActivePage(), input, ID, activateOnOpen);

131 }

132

133 /**

134 * Open commit in editor

135 *

136 * @param commit

137 * @param activateOnOpen <code>true</code> if the newly opened editor should be activated

138 * @return opened editor part or null if opening fails

139 * @since 2.1

140 */

        public static final IEditorPart openQuiet(RepositoryCommit commit, boolean activateOnOpen) {

142 try {

                        return open(commit, activateOnOpen);

144 } catch (PartInitException e) {

                        Activator.logError(e.getMessage(), e);

146 return null;

147 }

148 }

149

150 /**

151 * Open commit in editor

152 *

153 * @param commit

154 * @return opened editor part or null if opening fails

155 */

156 public static final IEditorPart openQuiet(RepositoryCommit commit) {

                return openQuiet(commit, true);

158 }

159

        private final AtomicBoolean runRefresh = new AtomicBoolean();

161

162 private IContentOutlinePage outlinePage;

163

164 private CommitEditorPage commitPage;

165

166 private DiffEditorPage diffPage;

167

168 private NotesEditorPage notePage;

169

170 private ListenerHandle refListenerHandle;

171

        private FocusTracker headerFocusTracker = new FocusTracker();

173

174 private IToolBarManager toolbar;

175

176 private IPageChangedListener pageListener;

177

178 /**

179 * Ensures that the toolbar buttons in the header are properly updated, and

180 * that the editor refreshes on {@link RefsChangedEvent}s only when visible.

181 * Created and installed in {@link #createHeaderContents(IManagedForm)},

182 * which occurs before {@link #addPages()} where we start listening for

183 * {@link RefsChangedEvent}s.

184 */

185 private EditorVisibilityTracker visibilityListener;

186

187 private static class CommitEditorNestedSite extends MultiPageEditorSite {

188

189 public CommitEditorNestedSite(CommitEditor topLevelEditor,

190 IEditorPart nestedEditor) {

191 super(topLevelEditor, nestedEditor);

192 }

193

194 @Override

195 public IEditorActionBarContributor getActionBarContributor() {

196 IEditorActionBarContributor globalContributor = getMultiPageEditor()

                                        .getEditorSite().getActionBarContributor();

198 if (globalContributor instanceof CommitEditorActionBarContributor) {

199 return ((CommitEditorActionBarContributor) globalContributor)

200 .getTextEditorActionContributor();

201 }

202 return super.getActionBarContributor();

203 }

204

205 }

206

207 @Override

208 protected IEditorSite createSite(IEditorPart editor) {

                return new CommitEditorNestedSite(this, editor);

210 }

211

212 /**

213 * @see org.eclipse.ui.forms.editor.FormEditor#addPages()

214 */

215 @Override

216 protected void addPages() {

217 try {

                        if (getCommit().isStash()) {

                                commitPage = new StashEditorPage(this);

220 } else {

                                commitPage = new CommitEditorPage(this);

222 }

223 addPage(commitPage);

224 RepositoryCommit commit = getCommit();

                        if (commit != null) {

                                diffPage = new DiffEditorPage(this);

                                addPage(diffPage, new DiffEditorInput(commit));

                                if (commit.getNotes().length > 0) {

                                        notePage = new NotesEditorPage(this);

230 addPage(notePage);

231 }

232 }

233 } catch (PartInitException e) {

                        Activator.error("Error adding page", e); //$NON-NLS-1$

235 }

                refListenerHandle = RepositoryCache.INSTANCE.getGlobalListenerList()

                                .addRefsChangedListener(this);

238

239 pageListener = event -> {

240 IEvaluationService service = PlatformUI.getWorkbench()

                                        .getService(IEvaluationService.class);

                        if (service != null) {

243 // Update enablement of "Save As..."

                                service.requestEvaluation(ISources.ACTIVE_PART_NAME);

245 }

                        if (event.getSelectedPage() == commitPage) {

247 refreshCommitPage();

248 }

249 };

250 addPageChangedListener(pageListener);

251 }

252

253 private IContributionItem createActionContributionItem(String commandId,

254 String title, ImageDescriptor icon) {

                IAction action = new Action(title, icon) {

256

257 @Override

258 public void run() {

259 CommonUtils.runCommand(commandId,

                                                new StructuredSelection(getCommit()));

261 }

262 };

263 return new ActionContributionItem(action);

264 }

265

266 /**

267 * @see org.eclipse.ui.forms.editor.SharedHeaderFormEditor#createHeaderContents(org.eclipse.ui.forms.IManagedForm)

268 */

269 @Override

270 protected void createHeaderContents(IManagedForm headerForm) {

                headerForm.addPart(new FocusManagerFormPart(headerFocusTracker) {

272

273 @Override

274 public void setDefaultFocus() {

                                headerForm.getForm().getForm().setFocus();

276 }

277 });

278 RepositoryCommit commit = getCommit();

279 ScrolledForm form = headerForm.getForm();

                String commitName = commit.getRevCommit().name();

281 String title = getFormattedHeaderTitle(commitName);

                HeaderText text = new HeaderText(form.getForm(), title, commitName);

283 Control textControl = text.getControl();

                if (textControl != null) {

285 headerFocusTracker.addToFocusTracking(textControl);

286 }

287 form.setToolTipText(commitName);

                getToolkit().decorateFormHeading(form.getForm());

289

290 toolbar = form.getToolBarManager();

291

292 ControlContribution repositoryLabelControl = new ControlContribution(

293 "repositoryLabel") { //$NON-NLS-1$

294 @Override

295 protected Control createControl(Composite parent) {

                                FormToolkit toolkit = getHeaderForm().getToolkit();

                                String label = getCommit().getRepositoryName();

298

                                ImageHyperlink link = new ImageHyperlink(parent, SWT.NONE);

300 // Focus tracking on this link doesn't really work. It's a

301 // focusable control inside another focusable control (the

302 // toolbar). When focus leaves this control through tabbing

303 // or deactivating the editor, the toolbar gets the focus (and

304 // possibly loses it right away again). Thus the focus tracker

305 // will always see the toolbar as the last focused control.

306 // Unfortunately there is no other way to get some text onto

307 // the first line of a FormHeading.

308 headerFocusTracker.addToFocusTracking(link);

309 link.setText(label);

                                link.setFont(JFaceResources.getBannerFont());

                                link.setForeground(toolkit.getColors().getColor(

312 IFormColors.TITLE));

                                link.setToolTipText(UIText.CommitEditor_showGitRepo);

                                link.addHyperlinkListener(new HyperlinkAdapter() {

315 @Override

316 public void linkActivated(HyperlinkEvent event) {

317 RepositoriesView view;

318 try {

                                                        view = (RepositoriesView) PlatformUI.getWorkbench()

                                                                        .getActiveWorkbenchWindow().getActivePage()

                                                                        .showView(RepositoriesView.VIEW_ID);

                                                        view.showRepository(getCommit().getRepository());

323 } catch (PartInitException e) {

324 Activator.handleError(

325 UIText.CommitEditor_couldNotShowRepository,

326 e, false);

327 }

328 }

329 });

330

331 return link;

332 }

333 };

334 toolbar.add(repositoryLabelControl);

                visibilityListener = new EditorVisibilityTracker(this) {

336

337 private boolean isActive;

338

339 @Override

340 public void partActivated(IWorkbenchPartReference partRef) {

                                if (isMe(partRef)) {

342 if (!isActive) {

343 isActive = true;

344 updateToolbar();

345 }

346 } else if (isActive) {

347 isActive = false;

348 updateToolbar();

349 }

350 }

351 };

352

                getSite().getService(IPartService.class)

354 .addPartListener(visibilityListener);

                if (commit.isStash()) {

                        toolbar.add(createActionContributionItem(ActionCommands.STASH_APPLY,

357 UIText.CommitEditor_toolbarApplyStash,

358 UIIcons.STASH_APPLY));

                        toolbar.add(createActionContributionItem(ActionCommands.STASH_DROP,

360 UIText.CommitEditor_toolbarDeleteStash,

                                        PlatformUI.getWorkbench().getSharedImages()

362 .getImageDescriptor(

363 ISharedImages.IMG_TOOL_DELETE)));

364 } else {

                        toolbar.add(createActionContributionItem(ActionCommands.TAG_ACTION,

366 UIText.CommitEditor_toolbarCreateTag, UIIcons.CREATE_TAG));

367 toolbar.add(

368 createActionContributionItem(ActionCommands.BRANCH_CREATE,

369 UIText.CommitEditor_toolbarCreateBranch,

370 UIIcons.CREATE_BRANCH));

                        toolbar.add(createActionContributionItem(ActionCommands.CHECK_OUT,

372 UIText.CommitEditor_toolbarCheckOut, UIIcons.CHECKOUT));

                        toolbar.add(createActionContributionItem(ActionCommands.CHERRY_PICK,

374 UIText.CommitEditor_toolbarCherryPick,

375 UIIcons.CHERRY_PICK));

                        toolbar.add(createActionContributionItem(ActionCommands.REVERT,

377 UIText.CommitEditor_toolbarRevert, UIIcons.REVERT));

                        toolbar.add(createActionContributionItem(

379 ActionCommands.SHOW_IN_HISTORY,

380 UIText.CommitEditor_toolbarShowInHistory, UIIcons.HISTORY));

381 }

382 addContributions(toolbar);

                toolbar.update(true);

                getSite().setSelectionProvider(new ISelectionProvider() {

385

386 @Override

387 public void setSelection(ISelection selection) {

388 // Ignored

389 }

390

391 @Override

392 public void removeSelectionChangedListener(

393 ISelectionChangedListener listener) {

394 // Ignored

395 }

396

397 @Override

398 public ISelection getSelection() {

                                return new StructuredSelection(getCommit());

400 }

401

402 @Override

403 public void addSelectionChangedListener(

404 ISelectionChangedListener listener) {

405 // Ignored

406 }

407 });

408 if (toolbar instanceof ToolBarManager) {

                        Control control = ((ToolBarManager) toolbar).getControl();

                        if (control != null) {

411 headerFocusTracker.addToFocusTracking(control);

412 }

413 }

414 }

415

416 private void updateToolbar() {

                if (toolbar != null) {

418 // isEnabled() on a CommandContributionItem actually re-evaluates

419 // the enablement.

                        for (IContributionItem item : toolbar.getItems()) {

421 item.isEnabled();

422 }

                        toolbar.update(true);

424 }

425 }

426

427 private String getFormattedHeaderTitle(String commitName) {

                if (getCommit().isStash()) {

                        int stashIndex = getStashIndex(getCommit().getRepository(),

                                        getCommit().getRevCommit().getId());

                        String stashName = MessageFormat.format("stash@'{'{0}'}'", //$NON-NLS-1$

432 Integer.valueOf(stashIndex));

433 return MessageFormat.format(

434 UIText.CommitEditor_TitleHeaderStashedCommit,

435 stashName);

436 } else {

                        return MessageFormat.format(UIText.CommitEditor_TitleHeaderCommit,

438 commitName);

439 }

440 }

441

        private int getStashIndex(Repository repo, ObjectId id) {

443 int index = 0;

444 try {

                        for (RevCommit commit : new StashListCommand(repo).call()) {

                                if (commit.getId().equals(id)) {

447 return index;

448 }

449 index++;

450 }

451 throw new IllegalStateException(

452 UIText.CommitEditor_couldNotFindStashCommit);

453 } catch (Exception e) {

454 String message = MessageFormat.format(

                                        UIText.CommitEditor_couldNotGetStashIndex, id.name());

                        Activator.logError(message, e);

457 index = -1;

458 }

459 return index;

460 }

461

462 private void addContributions(IToolBarManager toolBarManager) {

                IMenuService menuService = getSite().getService(IMenuService.class);

464 if (menuService != null

465 && toolBarManager instanceof ContributionManager) {

466 ContributionManager contributionManager = (ContributionManager) toolBarManager;

                        String toolbarUri = "toolbar:" + TOOLBAR_HEADER_ID; //$NON-NLS-1$

468 menuService.populateContributionManager(contributionManager,

469 toolbarUri);

470 }

471 }

472

473 private RepositoryCommit getCommit() {

                return getAdapter(RepositoryCommit.class);

475 }

476

477 /**

478 * @see org.eclipse.ui.part.MultiPageEditorPart#getAdapter(java.lang.Class)

479 */

480 @Override

        public <T> T getAdapter(Class<T> adapter) {

                if (RepositoryCommit.class == adapter) {

                        return Adapters.adapt(getEditorInput(), adapter);

                } else if (IContentOutlinePage.class == adapter) {

                        return adapter.cast(getOutlinePage());

                } else if (IPropertySheetPage.class == adapter) {

487 PropertySheetPage page = new GitPropertySheetPage();

488 page.setPropertySourceProvider(object -> {

489 if (object instanceof IPropertySource) {

490 return (IPropertySource) object;

491 }

492 if (object instanceof IRepositoryCommit) {

493 return new CommitPropertySource(

                                                        ((IRepositoryCommit) object).getRevCommit(), page);

495 }

496 return null;

497 });

                        return adapter.cast(page);

499 }

                return super.getAdapter(adapter);

501 }

502

503 /**

504 * @see org.eclipse.ui.forms.editor.FormEditor#init(org.eclipse.ui.IEditorSite,

505 * org.eclipse.ui.IEditorInput)

506 */

507 @Override

        public void init(IEditorSite site, IEditorInput input)

509 throws PartInitException {

                if (Adapters.adapt(input, RepositoryCommit.class) == null)

511 throw new PartInitException(

512 "Input could not be adapted to commit object"); //$NON-NLS-1$

                super.init(site, input);

                setPartName(input.getName());

                setTitleToolTip(input.getToolTipText());

516 }

517

518 @Override

519 public void dispose() {

520 refListenerHandle.remove();

                if (pageListener != null) {

522 removePageChangedListener(pageListener);

523 pageListener = null;

524 }

                if (visibilityListener != null) {

                        getSite().getService(IPartService.class)

527 .removePartListener(visibilityListener);

528 visibilityListener = null;

529 }

530 headerFocusTracker.dispose();

531 super.dispose();

532 }

533

534 /**

535 * @see org.eclipse.ui.part.EditorPart#doSave(org.eclipse.core.runtime.IProgressMonitor)

536 */

537 @Override

538 public void doSave(IProgressMonitor monitor) {

539 // Save not supported

540 }

541

542 /**

543 * @see org.eclipse.ui.part.EditorPart#doSaveAs()

544 */

545 @Override

546 public void doSaveAs() {

547 IEditorPart editor = getActiveEditor();

                if (editor != null && editor.isSaveAsAllowed()) {

549 editor.doSaveAs();

550 }

551 }

552

553 /**

554 * @see org.eclipse.ui.part.EditorPart#isSaveAsAllowed()

555 */

556 @Override

557 public boolean isSaveAsAllowed() {

558 IEditorPart editor = getActiveEditor();

                return editor != null && editor.isSaveAsAllowed();

560 }

561

562 @Override

563 public void onRefsChanged(RefsChangedEvent event) {

                if (getCommit().getRepository().getDirectory()

                                .equals(event.getRepository().getDirectory())) {

566 visibilityListener.runWhenVisible(() -> {

                                runRefresh.set(true);

                                if (getActivePageInstance() == commitPage) {

569 refreshCommitPage();

570 }

571 // Otherwise the pageListener will run the refresh when the

572 // commitPage becomes active

573 });

574 }

575 }

576

577 private void refreshCommitPage() {

                if (!runRefresh.getAndSet(false) || getContainer().isDisposed()) {

579 return;

580 }

                UIJob job = new UIJob("Refreshing editor") { //$NON-NLS-1$

582

583 @Override

584 public IStatus runInUIThread(IProgressMonitor monitor) {

585 try {

                                        if (!getContainer().isDisposed()) {

587 commitPage.refresh();

588 }

589 } finally {

                                        if (monitor != null) {

591 monitor.done();

592 }

593 }

594 return Status.OK_STATUS;

595 }

596 };

597 job.schedule();

598 }

599

600 private IContentOutlinePage getOutlinePage() {

                if (outlinePage == null) {

                        outlinePage = new MultiPageEditorContentOutlinePage(this);

603 }

604 return outlinePage;

605 }

606

607 @Override

608 public ShowInContext getShowInContext() {

609 IFormPage currentPage = getActivePageInstance();

                IShowInSource showInSource = Adapters.adapt(currentPage,

611 IShowInSource.class);

                if (showInSource != null) {

613 return showInSource.getShowInContext();

614 }

615 return null;

616 }

617

618 @Override

619 public String[] getShowInTargetIds() {

620 IFormPage currentPage = getActivePageInstance();

                IShowInTargetList targetList = Adapters.adapt(currentPage,

622 IShowInTargetList.class);

                if (targetList != null) {

624 return targetList.getShowInTargetIds();

625 }

626 return null;

627 }

628

629 @Override

630 public void setFocus() {

631 // super class sets focus to form header

632 IFormPage currentPage = getActivePageInstance();

                if (currentPage != null) {

634 currentPage.setFocus();

635 }

636 }

637 }