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 v1.0

5 * which accompanies this distribution, and is available at

6 * http://www.eclipse.org/legal/epl-v10.html

7 *

8 * Contributors:

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

10 * Daniel Megert <daniel_megert@ch.ibm.com> - Added context menu to the Commit Editor's header text

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

12 *******************************************************************************/

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

15 import java.text.MessageFormat;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.egit.core.AdapterUtils;

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.commit.command.CheckoutHandler;

import org.eclipse.egit.ui.internal.commit.command.CherryPickHandler;

import org.eclipse.egit.ui.internal.commit.command.CreateBranchHandler;

import org.eclipse.egit.ui.internal.commit.command.CreateTagHandler;

import org.eclipse.egit.ui.internal.commit.command.RevertHandler;

import org.eclipse.egit.ui.internal.commit.command.ShowInHistoryHandler;

import org.eclipse.egit.ui.internal.commit.command.StashApplyHandler;

import org.eclipse.egit.ui.internal.commit.command.StashDropHandler;

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

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

import org.eclipse.ui.IPartService;

import org.eclipse.ui.ISharedImages;

import org.eclipse.ui.IWorkbenchPart;

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.views.contentoutline.IContentOutlinePage;

86 /**

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

88 */

89 public class CommitEditor extends SharedHeaderFormEditor implements

90 RefsChangedListener, IShowInSource, IShowInTargetList {

92 /**

93 * ID - editor id

94 */

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

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

99 /**

100 * Open commit in editor

101 *

102 * @param commit

103 * @return opened editor part

104 * @throws PartInitException

105 */

106 public static final IEditorPart open(RepositoryCommit commit)

107 throws PartInitException {

                return open(commit, true);

109 }

110

111 /**

112 * Open commit in editor

113 *

114 * @param commit

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

116 * @return opened editor part

117 * @throws PartInitException

118 * @since 2.1

119 */

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

121 throws PartInitException {

                CommitEditorInput input = new CommitEditorInput(commit);

                return IDE.openEditor(PlatformUI.getWorkbench()

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

125 }

126

127 /**

128 * Open commit in editor

129 *

130 * @param commit

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

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

133 * @since 2.1

134 */

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

136 try {

                        return open(commit, activateOnOpen);

138 } catch (PartInitException e) {

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

140 return null;

141 }

142 }

143

144 /**

145 * Open commit in editor

146 *

147 * @param commit

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

149 */

150 public static final IEditorPart openQuiet(RepositoryCommit commit) {

                return openQuiet(commit, true);

152 }

153

154 private IContentOutlinePage outlinePage;

155

156 private CommitEditorPage commitPage;

157

158 private DiffEditorPage diffPage;

159

160 private NotesEditorPage notePage;

161

162 private ListenerHandle refListenerHandle;

163

        private FocusTracker headerFocusTracker = new FocusTracker();

165

166 private IToolBarManager toolbar;

167

168 /** Ensures that the toolbar buttons in the header are properly updated. */

        private final IPartListener activationListener = new IPartListener() {

170

171 private boolean isActive;

172

173 @Override

174 public void partActivated(IWorkbenchPart part) {

                        if (part == CommitEditor.this) {

176 if (!isActive) {

177 isActive = true;

178 updateToolbar();

179 }

180 } else if (isActive) {

181 isActive = false;

182 updateToolbar();

183 }

184 }

185

186 @Override

187 public void partBroughtToTop(IWorkbenchPart part) {

188 // Nothing to do

189 }

190

191 @Override

192 public void partClosed(IWorkbenchPart part) {

193 // Nothing to do

194 }

195

196 @Override

197 public void partDeactivated(IWorkbenchPart part) {

198 // Nothing to do

199 }

200

201 @Override

202 public void partOpened(IWorkbenchPart part) {

203 // Nothing to do

204 }

205

206 };

207

208 private static class CommitEditorNestedSite extends MultiPageEditorSite {

209

210 public CommitEditorNestedSite(CommitEditor topLevelEditor,

211 IEditorPart nestedEditor) {

212 super(topLevelEditor, nestedEditor);

213 }

214

215 @Override

216 public IEditorActionBarContributor getActionBarContributor() {

217 IEditorActionBarContributor globalContributor = getMultiPageEditor()

                                        .getEditorSite().getActionBarContributor();

219 if (globalContributor instanceof CommitEditorActionBarContributor) {

220 return ((CommitEditorActionBarContributor) globalContributor)

221 .getTextEditorActionContributor();

222 }

223 return super.getActionBarContributor();

224 }

225

226 }

227

228 @Override

229 protected IEditorSite createSite(IEditorPart editor) {

                return new CommitEditorNestedSite(this, editor);

231 }

232

233 /**

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

235 */

236 @Override

237 protected void addPages() {

238 try {

                        if (getCommit().isStash()) {

                                commitPage = new StashEditorPage(this);

241 } else {

                                commitPage = new CommitEditorPage(this);

243 }

244 addPage(commitPage);

                        diffPage = new DiffEditorPage(this);

                        addPage(diffPage, getEditorInput());

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

                                notePage = new NotesEditorPage(this);

249 addPage(notePage);

250 }

251 } catch (PartInitException e) {

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

253 }

254 refListenerHandle = Repository.getGlobalListenerList()

                                .addRefsChangedListener(this);

256 }

257

258 private IContributionItem createActionContributionItem(String commandId,

259 String title, ImageDescriptor icon) {

                IAction action = new Action(title, icon) {

261

262 @Override

263 public void run() {

264 CommonUtils.runCommand(commandId,

                                                new StructuredSelection(getCommit()));

266 }

267 };

268 return new ActionContributionItem(action);

269 }

270

271 /**

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

273 */

274 @Override

275 protected void createHeaderContents(IManagedForm headerForm) {

                headerForm.addPart(new FocusManagerFormPart(headerFocusTracker) {

277

278 @Override

279 public void setDefaultFocus() {

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

281 }

282 });

283 RepositoryCommit commit = getCommit();

284 ScrolledForm form = headerForm.getForm();

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

286 String title = getFormattedHeaderTitle(commitName);

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

288 Control textControl = text.getControl();

                if (textControl != null) {

290 headerFocusTracker.addToFocusTracking(textControl);

291 }

292 form.setToolTipText(commitName);

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

294

295 toolbar = form.getToolBarManager();

296

297 ControlContribution repositoryLabelControl = new ControlContribution(

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

299 @Override

300 protected Control createControl(Composite parent) {

                                FormToolkit toolkit = getHeaderForm().getToolkit();

                                String label = getCommit().getRepositoryName();

303

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

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

306 // focusable control inside another focusable control (the

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

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

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

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

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

312 // the first line of a FormHeading.

313 headerFocusTracker.addToFocusTracking(link);

314 link.setText(label);

                                link.setFont(JFaceResources.getBannerFont());

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

317 IFormColors.TITLE));

                                link.setToolTipText(UIText.CommitEditor_showGitRepo);

                                link.addHyperlinkListener(new HyperlinkAdapter() {

320 @Override

321 public void linkActivated(HyperlinkEvent event) {

322 RepositoriesView view;

323 try {

                                                        view = (RepositoriesView) PlatformUI.getWorkbench()

                                                                        .getActiveWorkbenchWindow().getActivePage()

                                                                        .showView(RepositoriesView.VIEW_ID);

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

328 } catch (PartInitException e) {

329 Activator.handleError(

330 UIText.CommitEditor_couldNotShowRepository,

331 e, false);

332 }

333 }

334 });

335

336 return link;

337 }

338 };

339 toolbar.add(repositoryLabelControl);

                CommonUtils.getService(getSite(), IPartService.class)

341 .addPartListener(activationListener);

                if (commit.isStash()) {

                        toolbar.add(createActionContributionItem(StashApplyHandler.ID,

344 UIText.CommitEditor_toolbarApplyStash,

345 UIIcons.STASH_APPLY));

                        toolbar.add(createActionContributionItem(StashDropHandler.ID,

347 UIText.CommitEditor_toolbarDeleteStash,

                                        PlatformUI.getWorkbench().getSharedImages()

349 .getImageDescriptor(

350 ISharedImages.IMG_TOOL_DELETE)));

351 } else {

                        toolbar.add(createActionContributionItem(CreateTagHandler.ID,

353 UIText.CommitEditor_toolbarCreateTag, UIIcons.TAG));

                        toolbar.add(createActionContributionItem(CreateBranchHandler.ID,

355 UIText.CommitEditor_toolbarCreateBranch, UIIcons.BRANCH));

                        toolbar.add(createActionContributionItem(CheckoutHandler.ID,

357 UIText.CommitEditor_toolbarCheckOut, UIIcons.CHECKOUT));

                        toolbar.add(createActionContributionItem(CherryPickHandler.ID,

359 UIText.CommitEditor_toolbarCherryPick,

360 UIIcons.CHERRY_PICK));

                        toolbar.add(createActionContributionItem(RevertHandler.ID,

362 UIText.CommitEditor_toolbarRevert, UIIcons.REVERT));

                        toolbar.add(createActionContributionItem(ShowInHistoryHandler.ID,

364 UIText.CommitEditor_toolbarShowInHistory, UIIcons.HISTORY));

365 }

366 addContributions(toolbar);

                toolbar.update(true);

                getSite().setSelectionProvider(new ISelectionProvider() {

369

370 @Override

371 public void setSelection(ISelection selection) {

372 // Ignored

373 }

374

375 @Override

376 public void removeSelectionChangedListener(

377 ISelectionChangedListener listener) {

378 // Ignored

379 }

380

381 @Override

382 public ISelection getSelection() {

                                return new StructuredSelection(getCommit());

384 }

385

386 @Override

387 public void addSelectionChangedListener(

388 ISelectionChangedListener listener) {

389 // Ignored

390 }

391 });

392 if (toolbar instanceof ToolBarManager) {

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

                        if (control != null) {

395 headerFocusTracker.addToFocusTracking(control);

396 }

397 }

398 }

399

400 private void updateToolbar() {

                if (toolbar != null) {

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

403 // the enablement.

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

405 item.isEnabled();

406 }

                        toolbar.update(true);

408 }

409 }

410

411 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$

416 Integer.valueOf(stashIndex));

417 return MessageFormat.format(

418 UIText.CommitEditor_TitleHeaderStashedCommit,

419 stashName);

420 } else {

                        return MessageFormat.format(UIText.CommitEditor_TitleHeaderCommit,

422 commitName);

423 }

424 }

425

        private int getStashIndex(Repository repo, ObjectId id) {

427 int index = 0;

428 try {

                        for (RevCommit commit : Git.wrap(repo).stashList().call())

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

431 return index;

432 else

433 index++;

434 throw new IllegalStateException(

435 UIText.CommitEditor_couldNotFindStashCommit);

436 } catch (Exception e) {

437 String message = MessageFormat.format(

                                        UIText.CommitEditor_couldNotGetStashIndex, id.name());

                        Activator.logError(message, e);

440 index = -1;

441 }

442 return index;

443 }

444

445 private void addContributions(IToolBarManager toolBarManager) {

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

447 if (menuService != null

448 && toolBarManager instanceof ContributionManager) {

449 ContributionManager contributionManager = (ContributionManager) toolBarManager;

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

451 menuService.populateContributionManager(contributionManager,

452 toolbarUri);

453 }

454 }

455

456 private RepositoryCommit getCommit() {

                return (RepositoryCommit) getAdapter(RepositoryCommit.class);

458 }

459

460 /**

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

462 */

463 @Override

464 public Object getAdapter(Class adapter) {

                if (RepositoryCommit.class == adapter) {

                        return AdapterUtils.adapt(getEditorInput(), RepositoryCommit.class);

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

468 return getOutlinePage();

469 }

                return super.getAdapter(adapter);

471 }

472

473 /**

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

475 * org.eclipse.ui.IEditorInput)

476 */

477 @Override

        public void init(IEditorSite site, IEditorInput input)

479 throws PartInitException {

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

481 throw new PartInitException(

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

                super.init(site, input);

                setPartName(input.getName());

                setTitleToolTip(input.getToolTipText());

486 }

487

488 @Override

489 public void dispose() {

                CommonUtils.getService(getSite(), IPartService.class)

491 .removePartListener(activationListener);

492 refListenerHandle.remove();

493 headerFocusTracker.dispose();

494 super.dispose();

495 }

496

497 /**

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

499 */

500 @Override

501 public void doSave(IProgressMonitor monitor) {

502 // Save not supported

503 }

504

505 /**

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

507 */

508 @Override

509 public void doSaveAs() {

510 // Save as not supported

511 }

512

513 /**

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

515 */

516 @Override

517 public boolean isSaveAsAllowed() {

518 return false;

519 }

520

521 @Override

522 public void onRefsChanged(RefsChangedEvent event) {

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

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

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

526

527 @Override

528 public IStatus runInUIThread(IProgressMonitor monitor) {

                                        if (!getContainer().isDisposed())

530 commitPage.refresh();

531 return Status.OK_STATUS;

532 }

533 };

534 job.schedule();

535 }

536 }

537

538 private IContentOutlinePage getOutlinePage() {

                if (outlinePage == null) {

                        outlinePage = new MultiPageEditorContentOutlinePage(this);

541 }

542 return outlinePage;

543 }

544

545 @Override

546 public ShowInContext getShowInContext() {

547 IFormPage currentPage = getActivePageInstance();

                IShowInSource showInSource = AdapterUtils.adapt(currentPage,

549 IShowInSource.class);

                if (showInSource != null) {

551 return showInSource.getShowInContext();

552 }

553 return null;

554 }

555

556 @Override

557 public String[] getShowInTargetIds() {

558 IFormPage currentPage = getActivePageInstance();

                IShowInTargetList targetList = AdapterUtils.adapt(currentPage,

560 IShowInTargetList.class);

                if (targetList != null) {

562 return targetList.getShowInTargetIds();

563 }

564 return null;

565 }

566 }