Examples with ToolBarManager org.eclipse.jface.action.ToolBarManager used on opensource projects

Example 71 with ToolBarManager

use of org.eclipse.jface.action.ToolBarManager in project linuxtools by eclipse.

the class MetadataPage method createFormContent.

@Override
protected void createFormContent(IManagedForm managedForm) {
    // setting up the form page
    super.createFormContent(managedForm);
    GridLayout layout = new GridLayout();
    toolkit = managedForm.getToolkit();
    ScrolledForm form = managedForm.getForm();
    form.setText(Messages.MetadataPage_formHeaderText);
    form.setImage(Activator.getImageDescriptor(HEADER_ICON).createImage());
    ToolBarManager toolbarManager = (ToolBarManager) form.getToolBarManager();
    toolkit.decorateFormHeading(form.getForm());
    // add the menuContribution from MANIFEST.MF to the form
    IMenuService menuService = getSite().getService(IMenuService.class);
    menuService.populateContributionManager(toolbarManager, MENU_URI);
    toolbarManager.update(true);
    layout = new GridLayout();
    layout.marginWidth = 6;
    layout.marginHeight = 12;
    form.getBody().setLayout(layout);
    // --------------------------------- REVISION SECTION START ----------
    // Section and its client area to manage updating revision info
    Section revSection = toolkit.createSection(form.getBody(), Section.DESCRIPTION | ExpandableComposite.TITLE_BAR);
    layout = new GridLayout();
    GridData data = new GridData();
    data.verticalAlignment = GridData.FILL;
    data.horizontalAlignment = GridData.FILL;
    data.grabExcessHorizontalSpace = true;
    revSection.setText(Messages.MetadataPage_sectionTitleRevision);
    revSection.setDescription(Messages.MetadataPage_sectionInstructionRevision);
    revSection.setLayoutData(data);
    // the client area containing the editing fields
    Composite sectionClient = toolkit.createComposite(revSection);
    layout = new GridLayout(2, false);
    layout.marginWidth = 1;
    layout.marginHeight = 7;
    sectionClient.setLayout(layout);
    Text revisionTxt = createTextFieldWithLabel(sectionClient, Messages.MetadataPage_labelRevision);
    String prefRevisionTxt = eclipsePreferences.get(CreaterepoPreferenceConstants.PREF_REVISION, ICreaterepoConstants.EMPTY_STRING);
    if (!prefRevisionTxt.isEmpty()) {
        revisionTxt.setText(prefRevisionTxt);
    }
    revisionTxt.addSelectionListener(SelectionListener.widgetDefaultSelectedAdapter(e -> {
        String revisionText = revisionTxt.getText().trim();
        savePreferences(CreaterepoPreferenceConstants.PREF_REVISION, revisionText);
    }));
    revSection.setClient(sectionClient);
    // ---------- REVISION SECTION END
    // --------------------------------- TAGS SECTION START ----------
    // Section and its client area to manage tags
    Section tagSection = toolkit.createSection(form.getBody(), Section.DESCRIPTION | ExpandableComposite.TITLE_BAR);
    layout = new GridLayout();
    tagSection.setText(Messages.MetadataPage_sectionTitleTags);
    tagSection.setDescription(Messages.MetadataPage_sectionInstructionTags);
    tagSection.setLayoutData(expandComposite());
    // the client area containing the tags
    Composite sectionClientTags = toolkit.createComposite(tagSection);
    layout = new GridLayout(2, false);
    layout.marginWidth = 1;
    layout.marginHeight = 7;
    sectionClientTags.setLayout(layout);
    tagTxt = createTextFieldWithLabel(sectionClientTags, Messages.MetadataPage_labelTags);
    tagTxt.addSelectionListener(new AddTagButtonListener());
    tagsTreeViewer = new TreeViewer(sectionClientTags, SWT.BORDER | SWT.SINGLE | SWT.HORIZONTAL | SWT.VERTICAL | SWT.LEFT_TO_RIGHT | SWT.SMOOTH);
    tagsTreeViewer.setContentProvider(new CreaterepoTreeContentProvider());
    tagsTreeViewer.setLabelProvider(new CreaterepoTreeLabelProvider());
    CreaterepoCategoryModel model = new CreaterepoCategoryModel(project);
    tagsTreeViewer.setInput(model);
    // change the tag text field on change (make editing tag easier)
    tagsTreeViewer.addSelectionChangedListener(event -> {
        if (tagsTree.getSelectionCount() == 1) {
            TreeItem treeItem = tagsTree.getSelection()[0];
            if (!(treeItem.getData() instanceof CreaterepoTreeCategory)) {
                String tag = (String) treeItem.getData();
                tagTxt.setText(tag);
            } else {
                tagTxt.setText(ICreaterepoConstants.EMPTY_STRING);
            }
        }
    });
    // expand or shrink a category
    tagsTreeViewer.addDoubleClickListener(event -> {
        IStructuredSelection selection = (IStructuredSelection) tagsTreeViewer.getSelection();
        if (selection.getFirstElement() instanceof CreaterepoTreeCategory) {
            CreaterepoTreeCategory category = (CreaterepoTreeCategory) selection.getFirstElement();
            tagsTreeViewer.setExpandedState(category, !tagsTreeViewer.getExpandedState(category));
        }
    });
    tagsTree = tagsTreeViewer.getTree();
    tagsTree.setLayoutData(expandComposite());
    // everything to do with the buttons
    Composite buttonList = toolkit.createComposite(sectionClientTags);
    layout = new GridLayout();
    data = new GridData(SWT.BEGINNING, SWT.FILL, false, true);
    layout.marginWidth = 0;
    layout.marginHeight = 0;
    buttonList.setLayout(layout);
    buttonList.setLayoutData(data);
    createPushButton(buttonList, Messages.MetadataPage_buttonAddTag, toolkit).addSelectionListener(new AddTagButtonListener());
    createPushButton(buttonList, Messages.MetadataPage_buttonEditTag, toolkit).addSelectionListener(new EditTagButtonListener());
    createPushButton(buttonList, Messages.MetadataPage_buttonRemoveTag, toolkit).addSelectionListener(new RemoveTagButtonListener());
    tagSection.setClient(sectionClientTags);
    // ---------- TAGS SECTION END
    refreshTree();
    managedForm.refresh();
}

Example 72 with ToolBarManager

use of org.eclipse.jface.action.ToolBarManager in project knime-core by knime.

the class KNIMEApplicationActionBarAdvisor method fillCoolBar.

/**
 * {@inheritDoc}
 */
@Override
protected void fillCoolBar(final ICoolBarManager coolBar) {
    // create a toolbar and add it to the coolbar :)
    IToolBarManager toolbar = new ToolBarManager(SWT.FLAT | SWT.RIGHT);
    Stream.of(coolBar.getItems()).forEach(item -> toolbar.remove(item));
    coolBar.add(new ToolBarContributionItem(toolbar, "main"));
    // add tools to the toolbar
    toolbar.add(m_newWizardDropdownAction);
    toolbar.add(m_saveAction);
    toolbar.add(m_saveAsAction);
    toolbar.add(m_saveAllAction);
}

Example 73 with ToolBarManager

use of org.eclipse.jface.action.ToolBarManager in project egit by eclipse.

the class StagingView method createPartControl.

@Override
public void createPartControl(final Composite parent) {
    GridLayoutFactory.fillDefaults().applyTo(parent);
    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(), SWT.HORIZONTAL);
    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((IStructuredSelection) stagedViewer.getSelection());
        }
    };
    unstageAction.setToolTipText(UIText.StagingView_UnstageItemTooltip);
    stageAction = new Action(UIText.StagingView_StageItemMenuLabel, UIIcons.ELCL16_ADD) {

        @Override
        public void run() {
            stage((IStructuredSelection) unstagedViewer.getSelection());
        }
    };
    stageAction.setToolTipText(UIText.StagingView_StageItemTooltip);
    unstageAction.setEnabled(false);
    stageAction.setEnabled(false);
    unstageAllAction = new Action(UIText.StagingView_UnstageAllItemMenuLabel, UIIcons.UNSTAGE_ALL) {

        @Override
        public void run() {
            stagedViewer.getTree().selectAll();
            unstage((IStructuredSelection) stagedViewer.getSelection());
        }
    };
    unstageAllAction.setToolTipText(UIText.StagingView_UnstageAllItemTooltip);
    stageAllAction = new Action(UIText.StagingView_StageAllItemMenuLabel, UIIcons.ELCL16_ADD_ALL) {

        @Override
        public void run() {
            unstagedViewer.getTree().selectAll();
            stage((IStructuredSelection) unstagedViewer.getSelection());
        }
    };
    stageAllAction.setToolTipText(UIText.StagingView_StageAllItemTooltip);
    unstageAllAction.setEnabled(false);
    stageAllAction.setEnabled(false);
    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), stageAction);
    unstagedViewer.addSelectionChangedListener(event -> {
        boolean hasSelection = !event.getSelection().isEmpty();
        if (hasSelection != stageAction.isEnabled()) {
            stageAction.setEnabled(hasSelection);
            unstagedToolBarManager.update(true);
        }
    });
    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);
    amendPreviousCommitAction = new Action(UIText.StagingView_Ammend_Previous_Commit, IAction.AS_CHECK_BOX) {

        @Override
        public void run() {
            commitMessageComponent.setAmendingButtonSelection(isChecked());
            updateMessage();
        }
    };
    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);
    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 ToggleableWarningLabel(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);
    GridLayoutFactory.fillDefaults().numColumns(1).extendedMargins(2, 2, 2, 2).applyTo(commitMessageTextComposite);
    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 CommonUtils.getService(getSite(), 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);
    Composite composite = toolkit.createComposite(commitMessageComposite);
    toolkit.paintBordersFor(composite);
    GridDataFactory.fillDefaults().grab(true, false).applyTo(composite);
    GridLayoutFactory.swtDefaults().numColumns(2).applyTo(composite);
    toolkit.createLabel(composite, UIText.StagingView_Author).setForeground(toolkit.getColors().getColor(IFormColors.TB_TOGGLE));
    authorText = toolkit.createText(composite, null);
    authorText.setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER);
    authorText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());
    toolkit.createLabel(composite, UIText.StagingView_Committer).setForeground(toolkit.getColors().getColor(IFormColors.TB_TOGGLE));
    committerText = toolkit.createText(composite, null);
    committerText.setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER);
    committerText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());
    Composite buttonsContainer = toolkit.createComposite(composite);
    GridDataFactory.fillDefaults().grab(true, false).span(2, 1).indent(0, 8).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();
    // $NON-NLS-1$
    Label filler = toolkit.createLabel(buttonsContainer, "");
    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).equalWidth(true).applyTo(commitButtonsContainer);
    this.commitAndPushButton = toolkit.createButton(commitButtonsContainer, UIText.StagingView_CommitAndPush, SWT.PUSH);
    commitAndPushButton.setImage(getImage(UIIcons.PUSH));
    commitAndPushButton.addSelectionListener(new SelectionAdapter() {

        @Override
        public void widgetSelected(SelectionEvent e) {
            commit(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), unstageAction);
    stagedViewer.getLabelProvider().addListener(event -> {
        updateMessage();
        updateCommitButtons();
    });
    stagedViewer.addSelectionChangedListener(event -> {
        boolean hasSelection = !event.getSelection().isEmpty();
        if (hasSelection != unstageAction.isEnabled()) {
            unstageAction.setEnabled(hasSelection);
            stagedToolBarManager.update(true);
        }
    });
    selectionChangedListener = new ISelectionListener() {

        @Override
        public void selectionChanged(IWorkbenchPart part, ISelection selection) {
            if (part == getSite().getPart()) {
                return;
            }
            // don't accept text selection, only structural one
            if (selection instanceof StructuredSelection) {
                reactOnSelection((StructuredSelection) selection);
            }
        }
    };
    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.getPluginId()).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);
            commitAndPushButton.setImage(getImage(selection ? UIIcons.GERRIT : UIIcons.PUSH));
        }

        @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);
        }
    });
    // react on selection changes
    IWorkbenchPartSite site = getSite();
    ISelectionService srv = CommonUtils.getService(site, ISelectionService.class);
    srv.addPostSelectionListener(selectionChangedListener);
    CommonUtils.getService(site, IPartService.class).addPartListener(partListener);
    // Use current selection to populate staging view
    UIUtils.notifySelectionChangedWithCurrentSelection(selectionChangedListener, site);
    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();
    reactOnInitialSelection();
    IWorkbenchSiteProgressService service = CommonUtils.getService(getSite(), 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);
}

Example 74 with ToolBarManager

use of org.eclipse.jface.action.ToolBarManager in project egit by eclipse.

the class StagingView method createUnstagedToolBarComposite.

private void createUnstagedToolBarComposite() {
    Composite unstagedToolbarComposite = toolkit.createComposite(unstagedSection);
    unstagedToolbarComposite.setBackground(null);
    unstagedToolbarComposite.setLayout(createRowLayoutWithoutMargin());
    unstagedSection.setTextClient(unstagedToolbarComposite);
    unstagedExpandAllAction = new Action(UIText.UIUtils_ExpandAll, IAction.AS_PUSH_BUTTON) {

        @Override
        public void run() {
            unstagedViewer.expandAll();
            enableAutoExpand(unstagedViewer);
        }
    };
    unstagedExpandAllAction.setImageDescriptor(UIIcons.EXPAND_ALL);
    unstagedExpandAllAction.setId(EXPAND_ALL_ITEM_TOOLBAR_ID);
    unstagedCollapseAllAction = new Action(UIText.UIUtils_CollapseAll, IAction.AS_PUSH_BUTTON) {

        @Override
        public void run() {
            unstagedViewer.collapseAll();
            disableAutoExpand(unstagedViewer);
        }
    };
    unstagedCollapseAllAction.setImageDescriptor(UIIcons.COLLAPSEALL);
    unstagedCollapseAllAction.setId(COLLAPSE_ALL_ITEM_TOOLBAR_ID);
    sortAction = new Action(UIText.StagingView_UnstagedSort, IAction.AS_CHECK_BOX) {

        @Override
        public void run() {
            StagingEntryComparator comparator = (StagingEntryComparator) unstagedViewer.getComparator();
            comparator.setAlphabeticSort(!isChecked());
            comparator = (StagingEntryComparator) stagedViewer.getComparator();
            comparator.setAlphabeticSort(!isChecked());
            unstagedViewer.refresh();
            stagedViewer.refresh();
        }
    };
    sortAction.setImageDescriptor(UIIcons.STATE_SORT);
    sortAction.setId(SORT_ITEM_TOOLBAR_ID);
    sortAction.setChecked(getSortCheckState());
    unstagedToolBarManager = new ToolBarManager(SWT.FLAT | SWT.HORIZONTAL);
    unstagedToolBarManager.add(stageAction);
    unstagedToolBarManager.add(stageAllAction);
    unstagedToolBarManager.add(sortAction);
    unstagedToolBarManager.add(unstagedExpandAllAction);
    unstagedToolBarManager.add(unstagedCollapseAllAction);
    unstagedToolBarManager.update(true);
    unstagedToolBarManager.createControl(unstagedToolbarComposite);
}

Example 75 with ToolBarManager

use of org.eclipse.jface.action.ToolBarManager in project egit by eclipse.

the class FindToolbar method createToolbar.

private void createToolbar() {
    errorBackgroundColor = new Color(getDisplay(), new RGB(255, 150, 150));
    ResourceManager resourceManager = Activator.getDefault().getResourceManager();
    allIcon = UIIcons.getImage(resourceManager, UIIcons.SEARCH_COMMIT);
    commitIdIcon = UIIcons.getImage(resourceManager, UIIcons.ELCL16_ID);
    commentsIcon = UIIcons.getImage(resourceManager, UIIcons.ELCL16_COMMENTS);
    authorIcon = UIIcons.getImage(resourceManager, UIIcons.ELCL16_AUTHOR);
    committerIcon = UIIcons.getImage(resourceManager, UIIcons.ELCL16_COMMITTER);
    branchesIcon = UIIcons.getImage(resourceManager, UIIcons.BRANCHES);
    GridLayout findLayout = new GridLayout();
    findLayout.marginHeight = 0;
    findLayout.marginBottom = 1;
    findLayout.marginWidth = 0;
    findLayout.numColumns = 5;
    setLayout(findLayout);
    setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
    patternField = new Text(this, SWT.SEARCH | SWT.ICON_CANCEL | SWT.ICON_SEARCH);
    GridData findTextData = new GridData(SWT.FILL, SWT.LEFT, true, false);
    findTextData.minimumWidth = 150;
    patternField.setLayoutData(findTextData);
    patternField.setMessage(UIText.HistoryPage_findbar_find_msg);
    patternField.setTextLimit(100);
    // Do _not_ set the font to JFaceResources.getDialogFont() here. It'll
    // scale if changed, but the Text field may not adjust.
    ToolBarManager manager = new ToolBarManager(SWT.HORIZONTAL);
    findNextAction = new Action() {

        @Override
        public void run() {
            findNext();
        }
    };
    findNextAction.setImageDescriptor(UIIcons.ELCL16_NEXT);
    findNextAction.setText(UIText.HistoryPage_findbar_next);
    findNextAction.setToolTipText(UIText.FindToolbar_NextTooltip);
    findNextAction.setEnabled(false);
    manager.add(findNextAction);
    findPreviousAction = new Action() {

        @Override
        public void run() {
            findPrevious();
        }
    };
    findPreviousAction.setImageDescriptor(UIIcons.ELCL16_PREVIOUS);
    findPreviousAction.setText(UIText.HistoryPage_findbar_previous);
    findPreviousAction.setToolTipText(UIText.FindToolbar_PreviousTooltip);
    findPreviousAction.setEnabled(false);
    manager.add(findPreviousAction);
    final ToolBar toolBar = manager.createControl(this);
    prefsDropDown = new ToolItem(toolBar, SWT.DROP_DOWN);
    prefsMenu = new Menu(getShell(), SWT.POP_UP);
    caseItem = new MenuItem(prefsMenu, SWT.CHECK);
    caseItem.setText(UIText.HistoryPage_findbar_ignorecase);
    new MenuItem(prefsMenu, SWT.SEPARATOR);
    allItem = createFindInMenuItem();
    allItem.setText(UIText.HistoryPage_findbar_all);
    allItem.setImage(allIcon);
    commentsItem = createFindInMenuItem();
    commentsItem.setText(UIText.HistoryPage_findbar_comments);
    commentsItem.setImage(commentsIcon);
    authorItem = createFindInMenuItem();
    authorItem.setText(UIText.HistoryPage_findbar_author);
    authorItem.setImage(authorIcon);
    commitIdItem = createFindInMenuItem();
    commitIdItem.setText(UIText.HistoryPage_findbar_commit);
    commitIdItem.setImage(commitIdIcon);
    committerItem = createFindInMenuItem();
    committerItem.setText(UIText.HistoryPage_findbar_committer);
    committerItem.setImage(committerIcon);
    referenceItem = createFindInMenuItem();
    referenceItem.setText(UIText.HistoryPage_findbar_reference);
    referenceItem.setImage(branchesIcon);
    prefsDropDown.addListener(SWT.Selection, new Listener() {

        @Override
        public void handleEvent(Event event) {
            if (event.detail == SWT.ARROW) {
                // Arrow clicked, show drop down menu
                Rectangle itemBounds = prefsDropDown.getBounds();
                Point point = toolBar.toDisplay(itemBounds.x, itemBounds.y + itemBounds.height);
                prefsMenu.setLocation(point);
                prefsMenu.setVisible(true);
            } else {
                // Button clicked, cycle to next option
                if (allItem.getSelection())
                    selectFindInItem(commentsItem);
                else if (commentsItem.getSelection())
                    selectFindInItem(authorItem);
                else if (authorItem.getSelection())
                    selectFindInItem(commitIdItem);
                else if (commitIdItem.getSelection())
                    selectFindInItem(committerItem);
                else if (committerItem.getSelection())
                    selectFindInItem(referenceItem);
                else if (referenceItem.getSelection())
                    selectFindInItem(allItem);
            }
        }
    });
    patternModifyListener = new ModifyListener() {

        @Override
        public void modifyText(ModifyEvent e) {
            if (getSearchPattern().equals(lastSearchPattern)) {
                // Don't bother if it's still the same.
                return;
            }
            final FindToolbarJob finder = createFinder();
            finder.setUser(false);
            finder.schedule(200);
        }
    };
    patternField.addModifyListener(patternModifyListener);
    patternField.addSelectionListener(new SelectionAdapter() {

        @Override
        public void widgetDefaultSelected(SelectionEvent e) {
            if (e.detail != SWT.ICON_CANCEL && !getSearchPattern().isEmpty()) {
                // ENTER or the search icon clicked
                final FindToolbarJob finder = createFinder();
                finder.setUser(false);
                finder.schedule();
            }
        }
    });
    patternField.addKeyListener(new KeyAdapter() {

        @Override
        public void keyPressed(KeyEvent e) {
            if (e.keyCode == SWT.ARROW_DOWN) {
                findNext();
            } else if (e.keyCode == SWT.ARROW_UP) {
                findPrevious();
            }
        }
    });
    caseItem.addSelectionListener(new SelectionAdapter() {

        @Override
        public void widgetSelected(SelectionEvent e) {
            store.setValue(UIPreferences.FINDTOOLBAR_IGNORE_CASE, caseItem.getSelection());
            if (store.needsSaving()) {
                try {
                    store.save();
                } catch (IOException e1) {
                    Activator.handleError(e1.getMessage(), e1, false);
                }
            }
            clear();
        }
    });
    caseItem.setSelection(store.getBoolean(UIPreferences.FINDTOOLBAR_IGNORE_CASE));
    int selectedPrefsItem = store.getInt(UIPreferences.FINDTOOLBAR_FIND_IN);
    if (selectedPrefsItem == PREFS_FINDIN_ALL)
        selectFindInItem(allItem);
    else if (selectedPrefsItem == PREFS_FINDIN_COMMENTS)
        selectFindInItem(commentsItem);
    else if (selectedPrefsItem == PREFS_FINDIN_AUTHOR)
        selectFindInItem(authorItem);
    else if (selectedPrefsItem == PREFS_FINDIN_COMMITID)
        selectFindInItem(commitIdItem);
    else if (selectedPrefsItem == PREFS_FINDIN_COMMITTER)
        selectFindInItem(committerItem);
    else if (selectedPrefsItem == PREFS_FINDIN_REFERENCE)
        selectFindInItem(referenceItem);
    registerDisposal();
}