in org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/staging/StagingView.java [769:1418]
public void createPartControl(final Composite parent) {
GridLayoutFactory.fillDefaults().applyTo(parent);
titleNode = null;
titleLabelProvider = new DecoratingLabelProvider(
new RepositoryTreeNodeLabelProvider(),
PlatformUI.getWorkbench().getDecoratorManager());
titleLabelProvider.addListener(e -> {
if (titleNode != null && form != null && !form.isDisposed()) {
updateTitle(false);
}
});
toolkit = new FormToolkit(parent.getDisplay());
parent.addDisposeListener(new DisposeListener() {
@Override
public void widgetDisposed(DisposeEvent e) {
if (commitMessageComponent.isAmending()
|| userEnteredCommitMessage())
saveCommitMessageComponentState();
else
deleteCommitMessageComponentState();
resources.dispose();
toolkit.dispose();
}
});
form = toolkit.createForm(parent);
parent.addControlListener(new ControlListener() {
private int[] defaultWeights = { 1, 1 };
@Override
public void controlResized(ControlEvent e) {
org.eclipse.swt.graphics.Rectangle b = parent.getBounds();
int oldOrientation = mainSashForm.getOrientation();
if ((oldOrientation == SWT.HORIZONTAL)
&& (b.height > b.width)) {
mainSashForm.setOrientation(SWT.VERTICAL);
mainSashForm.setWeights(defaultWeights);
} else if ((oldOrientation == SWT.VERTICAL)
&& (b.height <= b.width)) {
mainSashForm.setOrientation(SWT.HORIZONTAL);
mainSashForm.setWeights(defaultWeights);
}
}
@Override
public void controlMoved(ControlEvent e) {
// ignore
}
});
form.setImage(getImage(UIIcons.REPOSITORY));
form.setText(UIText.StagingView_NoSelectionTitle);
GridDataFactory.fillDefaults().grab(true, true).applyTo(form);
toolkit.decorateFormHeading(form);
GridLayoutFactory.swtDefaults().applyTo(form.getBody());
mainSashForm = new SashForm(form.getBody(), getMainSashFormOrientation());
saveSashFormOrientationOnDisposal(mainSashForm, MAIN_SASH_FORM_ORIENTATION_VERTICAL);
saveSashFormWeightsOnDisposal(mainSashForm,
HORIZONTAL_SASH_FORM_WEIGHT);
toolkit.adapt(mainSashForm, true, true);
GridDataFactory.fillDefaults().grab(true, true)
.applyTo(mainSashForm);
stagingSashForm = new SashForm(mainSashForm,
getStagingFormOrientation());
saveSashFormWeightsOnDisposal(stagingSashForm,
STAGING_SASH_FORM_WEIGHT);
toolkit.adapt(stagingSashForm, true, true);
GridDataFactory.fillDefaults().grab(true, true)
.applyTo(stagingSashForm);
unstageAction = new Action(UIText.StagingView_UnstageItemMenuLabel,
UIIcons.UNSTAGE) {
@Override
public void run() {
unstage(stagedViewer.getStructuredSelection().toList());
}
};
unstageAction.setToolTipText(UIText.StagingView_UnstageItemTooltip);
stageAction = new Action(UIText.StagingView_StageItemMenuLabel,
UIIcons.ELCL16_ADD) {
@Override
public void run() {
stage(unstagedViewer.getStructuredSelection().toList());
}
};
stageAction.setToolTipText(UIText.StagingView_StageItemTooltip);
unstageAction.setEnabled(false);
stageAction.setEnabled(false);
unstageAllAction = new Action(
UIText.StagingView_UnstageAllItemMenuLabel,
UIIcons.UNSTAGE_ALL) {
@Override
public void run() {
unstage(Arrays.asList(
getContentProvider(stagedViewer).getStagingEntries()));
}
};
unstageAllAction
.setToolTipText(UIText.StagingView_UnstageAllItemTooltip);
stageAllAction = new Action(UIText.StagingView_StageAllItemMenuLabel,
UIIcons.ELCL16_ADD_ALL) {
@Override
public void run() {
stage(Arrays.asList(getContentProvider(unstagedViewer)
.getStagingEntries()));
}
};
stageAllAction.setToolTipText(UIText.StagingView_StageAllItemTooltip);
unstageAllAction.setEnabled(false);
stageAllAction.setEnabled(false);
createPresentationActions();
unstagedSection = toolkit.createSection(stagingSashForm,
ExpandableComposite.SHORT_TITLE_BAR);
unstagedSection.clientVerticalSpacing = 0;
unstagedSection.setLayoutData(
GridDataFactory.fillDefaults().grab(true, true).create());
createUnstagedToolBarComposite();
Composite unstagedComposite = toolkit.createComposite(unstagedSection);
toolkit.paintBordersFor(unstagedComposite);
unstagedSection.setClient(unstagedComposite);
GridLayoutFactory.fillDefaults().applyTo(unstagedComposite);
unstagedViewer = createViewer(unstagedComposite, true,
selection -> unstage(selection.toList()), stageAction);
unstagedViewer.addSelectionChangedListener(event -> {
boolean hasSelection = !event.getSelection().isEmpty();
if (hasSelection != stageAction.isEnabled()) {
stageAction.setEnabled(hasSelection);
unstagedToolBarManager.update(true);
}
workaroundMissingSwtRefresh(unstagedViewer);
});
Composite rebaseAndCommitComposite = toolkit.createComposite(mainSashForm);
rebaseAndCommitComposite.setLayout(GridLayoutFactory.fillDefaults().create());
rebaseSection = toolkit.createSection(rebaseAndCommitComposite,
ExpandableComposite.SHORT_TITLE_BAR);
rebaseSection.clientVerticalSpacing = 0;
rebaseSection.setText(UIText.StagingView_RebaseLabel);
Composite rebaseComposite = toolkit.createComposite(rebaseSection);
toolkit.paintBordersFor(rebaseComposite);
rebaseSection.setClient(rebaseComposite);
rebaseSection.setLayoutData(GridDataFactory.fillDefaults().create());
rebaseComposite.setLayout(GridLayoutFactory.fillDefaults()
.numColumns(3).equalWidth(true).create());
GridDataFactory buttonGridData = GridDataFactory.fillDefaults().align(
SWT.FILL, SWT.CENTER);
this.rebaseAbortButton = toolkit.createButton(rebaseComposite,
UIText.StagingView_RebaseAbort, SWT.PUSH);
rebaseAbortButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
rebaseAbort();
}
});
rebaseAbortButton.setImage(getImage(UIIcons.REBASE_ABORT));
buttonGridData.applyTo(rebaseAbortButton);
this.rebaseSkipButton = toolkit.createButton(rebaseComposite,
UIText.StagingView_RebaseSkip, SWT.PUSH);
rebaseSkipButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
rebaseSkip();
}
});
rebaseSkipButton.setImage(getImage(UIIcons.REBASE_SKIP));
buttonGridData.applyTo(rebaseSkipButton);
this.rebaseContinueButton = toolkit.createButton(rebaseComposite,
UIText.StagingView_RebaseContinue, SWT.PUSH);
rebaseContinueButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
rebaseContinue();
}
});
rebaseContinueButton.setImage(getImage(UIIcons.REBASE_CONTINUE));
buttonGridData.applyTo(rebaseContinueButton);
showControl(rebaseSection, false);
commitMessageSection = toolkit.createSection(rebaseAndCommitComposite,
ExpandableComposite.SHORT_TITLE_BAR);
commitMessageSection.clientVerticalSpacing = 0;
commitMessageSection.setText(UIText.StagingView_CommitMessage);
commitMessageSection.setLayoutData(GridDataFactory.fillDefaults()
.grab(true, true).create());
Composite commitMessageToolbarComposite = toolkit
.createComposite(commitMessageSection);
commitMessageToolbarComposite.setBackground(null);
commitMessageToolbarComposite.setLayout(createRowLayoutWithoutMargin());
commitMessageSection.setTextClient(commitMessageToolbarComposite);
ToolBarManager commitMessageToolBarManager = new ToolBarManager(
SWT.FLAT | SWT.HORIZONTAL);
previewAction = new Action(UIText.StagingView_Preview_Commit_Message,
IAction.AS_CHECK_BOX) {
@Override
public void run() {
if (isChecked()) {
previewLayout.topControl = commitMessagePreview;
commitMessageSection.setText(
UIText.StagingView_CommitMessagePreview);
previewer
.setText(commitMessageComponent.getRepository(),
commitMessageComponent.getCommitMessage());
} else {
previewLayout.topControl = commitMessageText;
commitMessageSection
.setText(UIText.StagingView_CommitMessage);
}
previewLayout.topControl.getParent().layout(true, true);
commitMessageSection.redraw();
if (!isChecked()) {
commitMessageText.setFocus();
}
}
};
previewAction.setImageDescriptor(UIIcons.ELCL16_PREVIEW);
commitMessageToolBarManager.add(previewAction);
commitMessageToolBarManager.add(new Separator());
amendPreviousCommitAction = new Action(
UIText.StagingView_Ammend_Previous_Commit, IAction.AS_CHECK_BOX) {
@Override
public void run() {
commitMessageComponent.setAmendingButtonSelection(isChecked());
updateMessage();
updateCommitButtons();
}
};
amendPreviousCommitAction.setImageDescriptor(UIIcons.AMEND_COMMIT);
commitMessageToolBarManager.add(amendPreviousCommitAction);
signedOffByAction = new Action(UIText.StagingView_Add_Signed_Off_By,
IAction.AS_CHECK_BOX) {
@Override
public void run() {
commitMessageComponent.setSignedOffButtonSelection(isChecked());
}
};
signedOffByAction.setImageDescriptor(UIIcons.SIGNED_OFF);
commitMessageToolBarManager.add(signedOffByAction);
signCommitAction = new Action(UIText.StagingView_Sign_Commit,
IAction.AS_CHECK_BOX) {
@Override
public void run() {
commitMessageComponent
.setSignCommitButtonSelection(isChecked());
}
};
signCommitAction.setImageDescriptor(UIIcons.SIGN_COMMIT);
commitMessageToolBarManager.add(signCommitAction);
boolean canSign = GpgSetup.getDefault() != null;
signCommitAction.setEnabled(canSign);
if (!canSign) {
signCommitAction
.setToolTipText(UIText.StagingView_Sign_Not_Available);
}
addChangeIdAction = new Action(UIText.StagingView_Add_Change_ID,
IAction.AS_CHECK_BOX) {
@Override
public void run() {
commitMessageComponent.setChangeIdButtonSelection(isChecked());
}
};
addChangeIdAction.setImageDescriptor(UIIcons.GERRIT);
commitMessageToolBarManager.add(addChangeIdAction);
commitMessageToolBarManager
.createControl(commitMessageToolbarComposite);
Composite commitMessageComposite = toolkit
.createComposite(commitMessageSection);
commitMessageSection.setClient(commitMessageComposite);
GridLayoutFactory.fillDefaults().numColumns(1)
.applyTo(commitMessageComposite);
warningLabel = new ToggleableLabel(commitMessageComposite,
SWT.NONE);
GridDataFactory.fillDefaults().grab(true, false).exclude(true)
.applyTo(warningLabel);
Composite commitMessageTextComposite = toolkit
.createComposite(commitMessageComposite);
toolkit.paintBordersFor(commitMessageTextComposite);
GridDataFactory.fillDefaults().grab(true, true)
.applyTo(commitMessageTextComposite);
previewLayout = new StackLayout();
previewLayout.marginHeight = 2;
previewLayout.marginWidth = 2;
commitMessageTextComposite.setLayout(previewLayout);
final CommitProposalProcessor commitProposalProcessor = new CommitProposalProcessor() {
@Override
protected Collection<String> computeFileNameProposals() {
return getStagedFileNames();
}
@Override
protected Collection<String> computeMessageProposals() {
return CommitMessageHistory.getCommitHistory();
}
};
commitMessageText = new CommitMessageArea(commitMessageTextComposite,
EMPTY_STRING, SWT.NONE) {
@Override
protected CommitProposalProcessor getCommitProposalProcessor() {
return commitProposalProcessor;
}
@Override
protected IHandlerService getHandlerService() {
return getSite().getService(IHandlerService.class);
}
};
commitMessageText.setData(FormToolkit.KEY_DRAW_BORDER,
FormToolkit.TEXT_BORDER);
GridDataFactory.fillDefaults().grab(true, true)
.applyTo(commitMessageText);
UIUtils.addBulbDecorator(
commitMessageText.getTextWidget(),
UIText.CommitDialog_ContentAssist);
commitMessagePreview = new Composite(commitMessageTextComposite,
SWT.NONE);
commitMessagePreview.setLayout(new FillLayout());
commitMessagePreview.setData(FormToolkit.KEY_DRAW_BORDER,
FormToolkit.TEXT_BORDER);
previewer = new CommitMessagePreviewer();
previewer.createControl(commitMessagePreview);
previewLayout.topControl = commitMessageText;
Composite composite = toolkit.createComposite(commitMessageComposite);
toolkit.paintBordersFor(composite);
GridDataFactory.fillDefaults().grab(true, false).applyTo(composite);
GridLayoutFactory.swtDefaults().margins(1, 2).numColumns(3)
.spacing(1, LayoutConstants.getSpacing().y).applyTo(composite);
createPersonLabel(composite, UIIcons.ELCL16_AUTHOR,
UIText.StagingView_Author);
authorText = toolkit.createText(composite, null);
authorText.setData(FormToolkit.KEY_DRAW_BORDER,
FormToolkit.TEXT_BORDER);
authorText.setLayoutData(GridDataFactory.fillDefaults().indent(5, 0)
.grab(true, false).align(SWT.FILL, SWT.CENTER).create());
createPersonLabel(composite, UIIcons.ELCL16_COMMITTER,
UIText.StagingView_Committer);
committerText = toolkit.createText(composite, null);
committerText.setData(FormToolkit.KEY_DRAW_BORDER,
FormToolkit.TEXT_BORDER);
committerText.setLayoutData(GridDataFactory.fillDefaults().indent(5, 0)
.grab(true, false).align(SWT.FILL, SWT.CENTER).create());
Composite buttonsContainer = toolkit.createComposite(composite);
GridDataFactory.fillDefaults().grab(true, false).span(3, 1)
.indent(0, 3).applyTo(buttonsContainer);
GridLayoutFactory.fillDefaults().numColumns(2)
.applyTo(buttonsContainer);
ignoreErrors = toolkit.createButton(buttonsContainer,
UIText.StagingView_IgnoreErrors, SWT.CHECK);
ignoreErrors.setSelection(false);
ignoreErrors.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
updateMessage();
updateCommitButtons();
}
});
getPreferenceStore()
.addPropertyChangeListener(new IPropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent event) {
if (isDisposed()) {
getPreferenceStore()
.removePropertyChangeListener(this);
return;
}
asyncExec(() -> {
updateIgnoreErrorsButtonVisibility();
updateMessage();
updateCommitButtons();
});
}
});
GridDataFactory.fillDefaults().align(SWT.BEGINNING, SWT.BEGINNING)
.grab(true, true).applyTo(ignoreErrors);
updateIgnoreErrorsButtonVisibility();
Label filler = toolkit.createLabel(buttonsContainer, ""); //$NON-NLS-1$
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL)
.grab(true, true).applyTo(filler);
Composite commitButtonsContainer = toolkit
.createComposite(buttonsContainer);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.applyTo(commitButtonsContainer);
GridLayoutFactory.fillDefaults().numColumns(2)
.applyTo(commitButtonsContainer);
this.commitAndPushButton = toolkit.createButton(commitButtonsContainer,
UIText.StagingView_CommitAndPushWithEllipsis, SWT.PUSH);
commitAndPushButton.setImage(getImage(UIIcons.PUSH));
commitAndPushButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
if (canPushHeadOnly()) {
pushHead(currentRepository);
} else {
commit(true);
}
}
private void pushHead(Repository repository) {
if (repository == null) {
return;
}
PushMode mode = getPushMode();
if (mode == null) {
return;
}
try {
Wizard wizard = mode.getWizard(repository, null);
if (wizard != null) {
PushWizardDialog dialog = new PushWizardDialog(
commitAndPushButton.getShell(), wizard);
dialog.open();
}
} catch (IOException e) {
Activator.handleError(e.getMessage(), e, true);
}
}
});
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.applyTo(commitAndPushButton);
this.commitButton = toolkit.createButton(commitButtonsContainer,
UIText.StagingView_Commit, SWT.PUSH);
commitButton.setImage(getImage(UIIcons.COMMIT));
commitButton.setText(UIText.StagingView_Commit);
commitButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
commit(false);
}
});
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.applyTo(commitButton);
stagedSection = toolkit.createSection(stagingSashForm,
ExpandableComposite.SHORT_TITLE_BAR);
stagedSection.clientVerticalSpacing = 0;
createStagedToolBarComposite();
Composite stagedComposite = toolkit.createComposite(stagedSection);
toolkit.paintBordersFor(stagedComposite);
stagedSection.setClient(stagedComposite);
GridLayoutFactory.fillDefaults().applyTo(stagedComposite);
stagedViewer = createViewer(stagedComposite, false,
selection -> stage(selection.toList()), unstageAction);
stagedViewer.getLabelProvider().addListener(event -> {
if (event.getSource() instanceof ProblemLabelDecorator
&& !isDisposed()) {
// Update UI when problem markers on staged items change
updateMessage();
updateCommitButtons();
}
});
stagedViewer.addSelectionChangedListener(event -> {
boolean hasSelection = !event.getSelection().isEmpty();
if (hasSelection != unstageAction.isEnabled()) {
unstageAction.setEnabled(hasSelection);
stagedToolBarManager.update(true);
}
workaroundMissingSwtRefresh(stagedViewer);
});
selectionChangedListener = new ISelectionListener() {
@Override
public void selectionChanged(IWorkbenchPart part,
ISelection selection) {
if (part == StagingView.this) {
return;
}
if (part instanceof IEditorPart) {
IEditorInput input = ((IEditorPart) part).getEditorInput();
Repository repository = Adapters.adapt(input,
Repository.class);
if (repository != null) {
reactOnSelection(new StructuredSelection(repository));
}
} else {
reactOnSelection(selection);
}
}
};
initPresentation();
partListener = new PartListener();
IPreferenceStore preferenceStore = getPreferenceStore();
if (preferenceStore.contains(UIPreferences.STAGING_VIEW_SYNC_SELECTION))
reactOnSelection = preferenceStore.getBoolean(
UIPreferences.STAGING_VIEW_SYNC_SELECTION);
else
preferenceStore.setDefault(UIPreferences.STAGING_VIEW_SYNC_SELECTION, true);
preferenceStore.addPropertyChangeListener(uiPrefsListener);
InstanceScope.INSTANCE
.getNode(org.eclipse.egit.core.Activator.PLUGIN_ID)
.addPreferenceChangeListener(prefListener);
updateSectionText();
stagedSection.setToolTipText(UIText.StagingView_StagedChangesTooltip);
unstagedSection
.setToolTipText(UIText.StagingView_UnstagedChangesTooltip);
updateToolbar();
enableCommitWidgets(false);
refreshAction.setEnabled(false);
createPopupMenu(unstagedViewer);
createPopupMenu(stagedViewer);
final ICommitMessageComponentNotifications listener = new ICommitMessageComponentNotifications() {
@Override
public void updateSignedOffToggleSelection(boolean selection) {
signedOffByAction.setChecked(selection);
}
@Override
public void updateChangeIdToggleSelection(boolean selection) {
addChangeIdAction.setChecked(selection);
updateCommitButtons();
}
@Override
public void updateSignCommitToggleSelection(boolean selection) {
signCommitAction.setChecked(selection);
}
@Override
public void statusUpdated() {
updateMessage();
}
};
commitMessageComponent = new CommitMessageComponent(listener);
commitMessageComponent.attachControls(commitMessageText, authorText,
committerText);
// allow to commit with ctrl-enter
commitMessageText.getTextWidget().addVerifyKeyListener(new VerifyKeyListener() {
@Override
public void verifyKey(VerifyEvent event) {
if (UIUtils.isSubmitKeyEvent(event)) {
event.doit = false;
commit(false);
}
}
});
commitMessageText.getTextWidget().addFocusListener(new FocusListener() {
@Override
public void focusGained(FocusEvent e) {
// Ctrl+Enter shortcut only works when the focus is on the commit message text
String commitButtonTooltip = MessageFormat.format(
UIText.StagingView_CommitToolTip,
UIUtils.SUBMIT_KEY_STROKE.format());
commitButton.setToolTipText(commitButtonTooltip);
}
@Override
public void focusLost(FocusEvent e) {
commitButton.setToolTipText(null);
}
});
IWorkbenchPartSite site = getSite();
// Use current selection to populate staging view
UIUtils.notifySelectionChangedWithCurrentSelection(
selectionChangedListener, site);
// react on selection changes
ISelectionService srv = site.getService(ISelectionService.class);
srv.addPostSelectionListener(selectionChangedListener);
site.getService(IPartService.class).addPartListener(partListener);
site.setSelectionProvider(new RepositorySelectionProvider(
new MultiViewerSelectionProvider(unstagedViewer, stagedViewer),
() -> realRepository));
ViewerFilter filter = new ViewerFilter() {
@Override
public boolean select(Viewer viewer, Object parentElement,
Object element) {
StagingViewContentProvider contentProvider = getContentProvider((TreeViewer) viewer);
if (element instanceof StagingEntry)
return contentProvider.isInFilter((StagingEntry) element);
else if (element instanceof StagingFolderEntry)
return contentProvider
.hasVisibleChildren((StagingFolderEntry) element);
return true;
}
};
unstagedViewer.addFilter(filter);
stagedViewer.addFilter(filter);
restoreSashFormWeights();
IWorkbenchSiteProgressService service = getSite()
.getService(IWorkbenchSiteProgressService.class);
if (service != null && reactOnSelection)
// If we are linked, each time IndexDiffUpdateJob starts, indicate
// that the view is busy (e.g. reload() will trigger this job in
// background!).
service.showBusyForFamily(org.eclipse.egit.core.JobFamilies.INDEX_DIFF_CACHE_UPDATE);
}