| /******************************************************************************* |
| * Copyright (c) 2000, 2006 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.ui.views.markers.internal; |
| |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.viewers.CheckboxTableViewer; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.events.TraverseEvent; |
| import org.eclipse.swt.events.TraverseListener; |
| import org.eclipse.swt.layout.FormAttachment; |
| import org.eclipse.swt.layout.FormData; |
| import org.eclipse.swt.layout.FormLayout; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Text; |
| |
| /** |
| * DialogProblemFilter is the dialog class for problem filters. |
| * |
| * @since 3.2 |
| * |
| */ |
| public class DialogProblemFilter extends DialogMarkerFilter { |
| |
| private DescriptionGroup descriptionGroup; |
| |
| private SeverityGroup severityGroup; |
| |
| private Composite userFilterComposite; |
| |
| private Label systemSettingsLabel; |
| |
| private CheckboxTableViewer definedList; |
| |
| private class DescriptionGroup { |
| private Label descriptionLabel; |
| |
| private Combo combo; |
| |
| private Text description; |
| |
| private String contains = MarkerMessages.filtersDialog_contains; |
| |
| private String doesNotContain = MarkerMessages.filtersDialog_doesNotContain; |
| |
| /** |
| * Create a descriptor group. |
| * |
| * @param parent |
| */ |
| public DescriptionGroup(Composite parent) { |
| |
| Composite descriptionComposite = new Composite(parent, SWT.NONE); |
| descriptionComposite.setLayout(new GridLayout(2, false)); |
| descriptionComposite.setLayoutData(new GridData( |
| GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL)); |
| |
| descriptionLabel = new Label(descriptionComposite, SWT.NONE); |
| descriptionLabel.setFont(parent.getFont()); |
| descriptionLabel |
| .setText(MarkerMessages.filtersDialog_descriptionLabel); |
| |
| combo = new Combo(descriptionComposite, SWT.READ_ONLY); |
| combo.setFont(parent.getFont()); |
| combo.add(contains); |
| combo.add(doesNotContain); |
| combo.addSelectionListener(new SelectionAdapter() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent) |
| */ |
| public void widgetSelected(SelectionEvent e) { |
| updateForSelection(); |
| } |
| }); |
| // Prevent Esc and Return from closing the dialog when the combo is |
| // active. |
| combo.addTraverseListener(new TraverseListener() { |
| public void keyTraversed(TraverseEvent e) { |
| if (e.detail == SWT.TRAVERSE_ESCAPE |
| || e.detail == SWT.TRAVERSE_RETURN) { |
| e.doit = false; |
| } |
| } |
| }); |
| |
| description = new Text(descriptionComposite, SWT.SINGLE |
| | SWT.BORDER); |
| description.setFont(parent.getFont()); |
| GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| data.horizontalSpan = 2; |
| |
| description.setLayoutData(data); |
| description.addModifyListener(new ModifyListener() { |
| public void modifyText(ModifyEvent e) { |
| DialogProblemFilter.this.markDirty(); |
| } |
| }); |
| } |
| |
| /** |
| * Get the contains value. |
| * |
| * @return boolean |
| */ |
| public boolean getContains() { |
| return combo.getSelectionIndex() == combo.indexOf(contains); |
| } |
| |
| /** |
| * Return whether or not the contains value is of use. |
| * |
| * @param value |
| */ |
| public void setContains(boolean value) { |
| if (value) { |
| combo.select(combo.indexOf(contains)); |
| } else { |
| combo.select(combo.indexOf(doesNotContain)); |
| } |
| } |
| |
| /** |
| * Set the description field. |
| * |
| * @param text |
| */ |
| public void setDescription(String text) { |
| if (text == null) { |
| description.setText(""); //$NON-NLS-1$ |
| } else { |
| description.setText(text); |
| } |
| } |
| |
| /** |
| * Return the text for the description. |
| * |
| * @return String |
| */ |
| public String getDescription() { |
| return description.getText(); |
| } |
| |
| /** |
| * Update the enablement state based on whether or not the receiver is |
| * enabled. |
| * |
| * @param enabled |
| */ |
| public void updateEnablement(boolean enabled) { |
| descriptionLabel.setEnabled(enabled); |
| combo.setEnabled(enabled); |
| description.setEnabled(enabled); |
| } |
| } |
| |
| private class SeverityGroup { |
| private Button enablementButton; |
| |
| private Button errorButton; |
| |
| private Button warningButton; |
| |
| private Button infoButton; |
| |
| /** |
| * Create a group for severity. |
| * |
| * @param parent |
| */ |
| public SeverityGroup(Composite parent) { |
| |
| Composite severityComposite = new Composite(parent, SWT.NONE); |
| severityComposite.setLayout(new GridLayout(4, false)); |
| severityComposite.setLayoutData(new GridData( |
| GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL)); |
| |
| SelectionListener listener = new SelectionAdapter() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent) |
| */ |
| public void widgetSelected(SelectionEvent e) { |
| updateEnablement(true); |
| DialogProblemFilter.this.markDirty(); |
| } |
| }; |
| |
| enablementButton = new Button(severityComposite, SWT.CHECK); |
| GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| enablementButton.setLayoutData(data); |
| enablementButton.setFont(parent.getFont()); |
| enablementButton |
| .setText(MarkerMessages.filtersDialog_severityLabel); |
| enablementButton.addSelectionListener(listener); |
| |
| errorButton = new Button(severityComposite, SWT.CHECK); |
| errorButton.setFont(parent.getFont()); |
| errorButton.setText(MarkerMessages.filtersDialog_severityError); |
| errorButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| errorButton.addSelectionListener(new SelectionAdapter() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent) |
| */ |
| public void widgetSelected(SelectionEvent e) { |
| updateForSelection(); |
| } |
| }); |
| |
| warningButton = new Button(severityComposite, SWT.CHECK); |
| warningButton.setFont(parent.getFont()); |
| warningButton.setText(MarkerMessages.filtersDialog_severityWarning); |
| warningButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| warningButton.addSelectionListener(new SelectionAdapter() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent) |
| */ |
| public void widgetSelected(SelectionEvent e) { |
| updateForSelection(); |
| } |
| }); |
| |
| infoButton = new Button(severityComposite, SWT.CHECK); |
| infoButton.setFont(parent.getFont()); |
| infoButton.setText(MarkerMessages.filtersDialog_severityInfo); |
| infoButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| infoButton.addSelectionListener(new SelectionAdapter() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent) |
| */ |
| public void widgetSelected(SelectionEvent e) { |
| updateForSelection(); |
| } |
| }); |
| } |
| |
| /** |
| * Return whether or not sort by severity is selected. |
| * |
| * @return boolean |
| */ |
| public boolean isSeveritySelected() { |
| return enablementButton.getSelection(); |
| } |
| |
| /** |
| * Set whether or not the enabled button is selected. |
| * |
| * @param enabled |
| */ |
| public void setEnabled(boolean enabled) { |
| enablementButton.setSelection(enabled); |
| } |
| |
| /** |
| * Return whether or not the error button is selected. |
| * |
| * @return boolean |
| */ |
| public boolean isErrorSelected() { |
| return errorButton.getSelection(); |
| } |
| |
| /** |
| * Set whether or not the error button is selected. |
| * |
| * @param selected |
| */ |
| public void setErrorSelected(boolean selected) { |
| errorButton.setSelection(selected); |
| } |
| |
| /** |
| * Return whether or not the warning button is selected. |
| * |
| * @return boolean |
| */ |
| public boolean isWarningSelected() { |
| return warningButton.getSelection(); |
| } |
| |
| /** |
| * Set whether or not the warning button is selected. |
| * |
| * @param selected |
| */ |
| public void setWarningSelected(boolean selected) { |
| warningButton.setSelection(selected); |
| } |
| |
| /** |
| * Return whether or not the info button is selected. |
| * |
| * @return boolean |
| */ |
| public boolean isInfoSelected() { |
| return infoButton.getSelection(); |
| } |
| |
| /** |
| * Set whether or not the erinforor button is selected. |
| * |
| * @param selected |
| */ |
| public void setInfoSelected(boolean selected) { |
| infoButton.setSelection(selected); |
| } |
| |
| /** |
| * Update enablement based on the enabled flag. |
| * |
| * @param enabled |
| */ |
| public void updateEnablement(boolean enabled) { |
| |
| boolean showingSeverity = isSeveritySelected(); |
| enablementButton.setEnabled(enabled); |
| errorButton.setEnabled(showingSeverity && enabled); |
| warningButton.setEnabled(showingSeverity && enabled); |
| infoButton.setEnabled(showingSeverity && enabled); |
| |
| } |
| } |
| |
| /** |
| * Create a new instance of the receiver. |
| * |
| * @param parentShell |
| * @param filters |
| */ |
| public DialogProblemFilter(Shell parentShell, ProblemFilter[] filters) { |
| super(parentShell, filters); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter#createAttributesArea(org.eclipse.swt.widgets.Composite) |
| */ |
| protected void createAttributesArea(Composite parent) { |
| Composite composite = new Composite(parent, SWT.NONE); |
| composite.setFont(parent.getFont()); |
| composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| GridLayout layout = new GridLayout(); |
| composite.setLayout(layout); |
| |
| descriptionGroup = new DescriptionGroup(composite); |
| severityGroup = new SeverityGroup(composite); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter#updateFilterFromUI(org.eclipse.ui.views.markers.internal.MarkerFilter) |
| */ |
| protected void updateFilterFromUI(MarkerFilter filter) { |
| super.updateFilterFromUI(filter); |
| |
| ProblemFilter problemFilter = (ProblemFilter) filter; |
| problemFilter.setContains(descriptionGroup.getContains()); |
| problemFilter.setDescription(descriptionGroup.getDescription().trim()); |
| |
| problemFilter.setSelectBySeverity(severityGroup.isSeveritySelected()); |
| int severity = 0; |
| if (severityGroup.isErrorSelected()) { |
| severity = severity | ProblemFilter.SEVERITY_ERROR; |
| } |
| if (severityGroup.isWarningSelected()) { |
| severity = severity | ProblemFilter.SEVERITY_WARNING; |
| } |
| if (severityGroup.isInfoSelected()) { |
| severity = severity | ProblemFilter.SEVERITY_INFO; |
| } |
| problemFilter.setSeverity(severity); |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter#updateUIWithFilter(org.eclipse.ui.views.markers.internal.MarkerFilter) |
| */ |
| protected void updateUIWithFilter(MarkerFilter filter) { |
| |
| ProblemFilter problemFilter = (ProblemFilter) filter; |
| descriptionGroup.setContains(problemFilter.getContains()); |
| descriptionGroup.setDescription(problemFilter.getDescription()); |
| |
| severityGroup.setEnabled(problemFilter.getSelectBySeverity()); |
| int severity = problemFilter.getSeverity(); |
| |
| severityGroup |
| .setErrorSelected((severity & ProblemFilter.SEVERITY_ERROR) > 0); |
| severityGroup |
| .setWarningSelected((severity & ProblemFilter.SEVERITY_WARNING) > 0); |
| severityGroup |
| .setInfoSelected((severity & ProblemFilter.SEVERITY_INFO) > 0); |
| |
| super.updateUIWithFilter(filter); |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter#updateEnabledState(boolean) |
| */ |
| protected void updateEnabledState(boolean enabled) { |
| super.updateEnabledState(enabled); |
| descriptionGroup.updateEnablement(enabled); |
| severityGroup.updateEnablement(enabled); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.views.markerview.FiltersDialog#resetPressed() |
| */ |
| protected void resetPressed() { |
| descriptionGroup.setContains(ProblemFilter.DEFAULT_CONTAINS); |
| descriptionGroup.setDescription(ProblemFilter.DEFAULT_DESCRIPTION); |
| |
| severityGroup.setEnabled(ProblemFilter.DEFAULT_SELECT_BY_SEVERITY); |
| severityGroup |
| .setErrorSelected((ProblemFilter.DEFAULT_SEVERITY & ProblemFilter.SEVERITY_ERROR) > 0); |
| severityGroup |
| .setWarningSelected((ProblemFilter.DEFAULT_SEVERITY & ProblemFilter.SEVERITY_WARNING) > 0); |
| severityGroup |
| .setInfoSelected((ProblemFilter.DEFAULT_SEVERITY & ProblemFilter.SEVERITY_INFO) > 0); |
| |
| super.resetPressed(); |
| } |
| |
| protected MarkerFilter newFilter(String newName) { |
| return new ProblemFilter(newName); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter#createFiltersArea(org.eclipse.swt.widgets.Composite) |
| */ |
| void createFiltersArea(Composite dialogArea) { |
| |
| if (MarkerSupportRegistry.getInstance().getRegisteredFilters().size() == 0) { |
| super.createFiltersArea(dialogArea); |
| return; |
| } |
| |
| Composite mainComposite = new Composite(dialogArea, SWT.NONE); |
| mainComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, |
| true)); |
| |
| mainComposite.setLayout(new FormLayout()); |
| |
| Composite topComposite = new Composite(mainComposite, SWT.NONE); |
| FormData topData = new FormData(); |
| topData.top = new FormAttachment(0); |
| topData.left = new FormAttachment(0); |
| topData.right = new FormAttachment(100); |
| topData.bottom = new FormAttachment(50); |
| |
| topComposite.setLayoutData(topData); |
| topComposite.setLayout(new GridLayout()); |
| |
| createUserFiltersArea(topComposite); |
| |
| Composite bottomComposite = new Composite(mainComposite, SWT.NONE); |
| FormData bottomData = new FormData(); |
| bottomData.top = new FormAttachment(50); |
| bottomData.left = new FormAttachment(0); |
| bottomData.right = new FormAttachment(100); |
| bottomData.bottom = new FormAttachment(100); |
| |
| bottomComposite.setLayoutData(bottomData); |
| bottomComposite.setLayout(new GridLayout()); |
| |
| createRegisteredFilters(bottomComposite); |
| createFilterSelectButtons(bottomComposite); |
| |
| } |
| |
| /** |
| * Create a composite for the registered filters. |
| * |
| * @param bottomComposite |
| */ |
| private void createRegisteredFilters(Composite bottomComposite) { |
| |
| Composite listArea = new Composite(bottomComposite, SWT.NONE); |
| listArea.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true)); |
| listArea.setLayout(new GridLayout()); |
| |
| Label title = new Label(listArea, SWT.NONE); |
| title.setText(MarkerMessages.ProblemFilterDialog_System_Filters_Title); |
| definedList = CheckboxTableViewer.newCheckList(listArea, SWT.BORDER); |
| definedList.setContentProvider(new IStructuredContentProvider() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) |
| */ |
| public Object[] getElements(Object inputElement) { |
| return MarkerSupportRegistry.getInstance() |
| .getRegisteredFilters().toArray(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.IContentProvider#dispose() |
| */ |
| public void dispose() { |
| // Do nothing |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, |
| * java.lang.Object, java.lang.Object) |
| */ |
| public void inputChanged(Viewer viewer, Object oldInput, |
| Object newInput) { |
| // Do nothing |
| } |
| }); |
| |
| definedList.setLabelProvider(new LabelProvider() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object) |
| */ |
| public String getText(Object element) { |
| return ((MarkerFilter) element).getName(); |
| } |
| }); |
| |
| definedList |
| .addSelectionChangedListener(new ISelectionChangedListener() { |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent) |
| */ |
| public void selectionChanged(SelectionChangedEvent event) { |
| |
| ISelection selection = event.getSelection(); |
| if (selection instanceof IStructuredSelection) { |
| Object selected = ((IStructuredSelection) selection) |
| .getFirstElement(); |
| if (selected == null) { |
| systemSettingsLabel.setText(Util.EMPTY_STRING); |
| } else { |
| systemSettingsLabel |
| .setText(getSystemFilterString((ProblemFilter) selected)); |
| } |
| } else { |
| systemSettingsLabel.setText(Util.EMPTY_STRING); |
| } |
| showSystemLabel(true); |
| |
| } |
| }); |
| |
| Iterator definedFilters = MarkerSupportRegistry.getInstance() |
| .getRegisteredFilters().iterator(); |
| definedList.setInput(this); |
| while (definedFilters.hasNext()) { |
| MarkerFilter next = (MarkerFilter) definedFilters.next(); |
| definedList.setChecked(next, next.isEnabled()); |
| } |
| |
| definedList.getControl().setLayoutData( |
| new GridData(SWT.FILL, SWT.FILL, true, true)); |
| |
| } |
| |
| /** |
| * Return the string with the details of filter. |
| * |
| * @param filter |
| * @return String |
| */ |
| protected String getSystemFilterString(ProblemFilter filter) { |
| StringBuffer filterBuffer = new StringBuffer(); |
| |
| String scopeString = getScopeString(filter); |
| if (scopeString != null) { |
| filterBuffer.append(scopeString); |
| } |
| |
| String descriptionString = getDescriptionString(filter); |
| if (descriptionString != null) { |
| filterBuffer.append(Util.TWO_LINE_FEED); |
| filterBuffer.append(descriptionString); |
| } |
| |
| String severityString = getSeverityString(filter); |
| if (severityString != null) { |
| filterBuffer.append(Util.TWO_LINE_FEED); |
| filterBuffer.append(severityString); |
| } |
| |
| String typesString = getProblemTypesString(filter); |
| filterBuffer.append(Util.TWO_LINE_FEED); |
| filterBuffer.append(typesString); |
| |
| return filterBuffer.toString(); |
| } |
| |
| /** |
| * Get the problem types String for filter. |
| * |
| * @param filter |
| * @return String |
| */ |
| private String getProblemTypesString(ProblemFilter filter) { |
| List types = filter.getSelectedTypes(); |
| if (types.size() == getRootEntries(filter).length) { |
| return MarkerMessages.ProblemFilterDialog_All_Problems; |
| } |
| StringBuffer typesBuffer = new StringBuffer(); |
| Iterator typesIterator = types.iterator(); |
| typesBuffer.append(MarkerMessages.ProblemFilterDialog_Selected_Types); |
| |
| while (typesIterator.hasNext()) { |
| typesBuffer.append(Util.LINE_FEED_AND_TAB); |
| typesBuffer.append(((MarkerType) typesIterator.next()).getLabel()); |
| |
| } |
| return typesBuffer.toString(); |
| } |
| |
| /** |
| * Return the string for severity if there is one. Otherwise return |
| * <code>null</code>. |
| * |
| * @param filter |
| * @return String |
| */ |
| private String getSeverityString(ProblemFilter filter) { |
| if (filter.getSelectBySeverity()) { |
| switch (filter.getSeverity()) { |
| case ProblemFilter.SEVERITY_INFO: |
| return MarkerMessages.ProblemFilterDialog_Info_Severity; |
| case ProblemFilter.SEVERITY_WARNING: |
| return MarkerMessages.ProblemFilterDialog_Warning_Severity; |
| case ProblemFilter.SEVERITY_ERROR: |
| return MarkerMessages.ProblemFilterDialog_Error_Severity; |
| default: |
| return null; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Return the string for the description if there is one. If not return |
| * <code>null</code>. |
| * |
| * @param filter |
| * @return String or <code>null</code>. |
| */ |
| private String getDescriptionString(ProblemFilter filter) { |
| if (filter.getDescription().length() == 0) { |
| return null; |
| } |
| if (filter.getContains()) { |
| return NLS.bind( |
| MarkerMessages.ProblemFilterDialog_Contains_Description, |
| filter.getDescription()); |
| } |
| return NLS |
| .bind( |
| MarkerMessages.ProblemFilterDialog_Does_Not_Contain_Description, |
| filter.getDescription()); |
| |
| } |
| |
| /** |
| * Return the string that describes the scope. |
| * |
| * @param filter |
| * @return String or <code>null</code> if the severity does not match. |
| */ |
| private String getScopeString(ProblemFilter filter) { |
| |
| switch (filter.onResource) { |
| case MarkerFilter.ON_ANY: |
| return MarkerMessages.ProblemFilterDialog_any; |
| case MarkerFilter.ON_ANY_IN_SAME_CONTAINER: |
| return MarkerMessages.ProblemFilterDialog_sameContainer; |
| case MarkerFilter.ON_SELECTED_AND_CHILDREN: |
| return MarkerMessages.ProblemFilterDialog_selectedAndChildren; |
| case MarkerFilter.ON_SELECTED_ONLY: |
| return MarkerMessages.ProblemFilterDialog_selected; |
| case MarkerFilter.ON_WORKING_SET: |
| return NLS.bind(MarkerMessages.ProblemFilterDialog_workingSet, |
| filter.getWorkingSet()); |
| |
| default: |
| return null; |
| |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter#setSelectedFilter(org.eclipse.jface.viewers.SelectionChangedEvent) |
| */ |
| protected void setSelectedFilter(SelectionChangedEvent event) { |
| showSystemLabel(false); |
| super.setSelectedFilter(event); |
| } |
| |
| /** |
| * Show or hide the system label. |
| * |
| * @param systemLabelShowing |
| */ |
| protected void showSystemLabel(boolean systemLabelShowing) { |
| |
| systemSettingsLabel.setVisible(systemLabelShowing); |
| userFilterComposite.setVisible(!systemLabelShowing); |
| userFilterComposite.getParent().layout(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter#createSelectedFilterArea(org.eclipse.swt.widgets.Composite) |
| */ |
| Composite createSelectedFilterArea(Composite composite) { |
| |
| Composite wrapper = new Composite(composite, SWT.NONE); |
| FormLayout wrapperLayout = new FormLayout(); |
| wrapperLayout.marginHeight = 0; |
| wrapperLayout.marginWidth = 0; |
| wrapper.setLayout(wrapperLayout); |
| |
| systemSettingsLabel = createSystemSettingsLabel(wrapper); |
| systemSettingsLabel.setVisible(false); |
| |
| FormData systemData = new FormData(); |
| systemData.top = new FormAttachment(0, IDialogConstants.VERTICAL_MARGIN); |
| systemData.left = new FormAttachment(0, |
| IDialogConstants.HORIZONTAL_MARGIN); |
| systemData.right = new FormAttachment(100, -1 |
| * IDialogConstants.HORIZONTAL_MARGIN); |
| systemData.bottom = new FormAttachment(100, -1 |
| * IDialogConstants.VERTICAL_MARGIN); |
| |
| systemSettingsLabel.setLayoutData(systemData); |
| |
| userFilterComposite = super.createSelectedFilterArea(wrapper); |
| |
| FormData userData = new FormData(); |
| userData.top = new FormAttachment(0); |
| userData.left = new FormAttachment(0); |
| userData.right = new FormAttachment(100); |
| userData.bottom = new FormAttachment(100); |
| |
| userFilterComposite.setLayoutData(userData); |
| |
| return wrapper; |
| } |
| |
| /** |
| * Create the label for system filters. |
| * |
| * @param wrapper |
| * @return Label |
| */ |
| private Label createSystemSettingsLabel(Composite wrapper) { |
| |
| return new Label(wrapper, SWT.NONE); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter#buttonPressed(int) |
| */ |
| protected void buttonPressed(int buttonId) { |
| if (definedList != null) { |
| if (buttonId == SELECT_ALL_FILTERS_ID) { |
| definedList.setAllChecked(true); |
| } else if (buttonId == DESELECT_ALL_FILTERS_ID) { |
| definedList.setAllChecked(false); |
| } |
| } |
| |
| super.buttonPressed(buttonId); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter#okPressed() |
| */ |
| protected void okPressed() { |
| |
| Iterator registered = MarkerSupportRegistry.getInstance() |
| .getRegisteredFilters().iterator(); |
| while (registered.hasNext()) { |
| ProblemFilter next = (ProblemFilter) registered.next(); |
| next.setEnabled(definedList.getChecked(next)); |
| |
| } |
| super.okPressed(); |
| } |
| } |