Attachment #183680 for bug #231081




import java.util.Collection;
import java.util.Iterator;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.IInputValidator;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;

import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.forms.events.ExpansionEvent;
import org.eclipse.ui.forms.events.IExpansionListener;
import org.eclipse.ui.forms.widgets.ExpandableComposite;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.ScrolledForm;
import org.eclipse.ui.internal.ide.IDEInternalPreferences;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.preferences.ViewSettingsDialog;
import org.eclipse.ui.views.markers.FilterConfigurationArea;
import org.eclipse.ui.views.markers.internal.MarkerMessages;


 * @since 3.3
 * 
 */
public class FiltersConfigurationDialog extends ViewerSettingsAndStatusDialog {

	private static final String SELECTED_FILTER_GROUP = "SELECTED_FILTER_GROUP"; //$NON-NLS-1$



	private MarkerContentGenerator generator;

	private int limitValue = -1;
	private boolean limitEnabled = false;
	private boolean andFilters = false;

	private Collection filterAreas;

	private Button removeButton;
	private Button renameButton;
	
	private Button cloneButton;

	private Button andButton;

	private Button orButton;

	private Label andOrLabel;
	private Text limitEditor;
	private Button limitBttn;

	/**
	 * Create a new instance of the receiver on builder.
	 * 
	 * @param parentShell
	 * @param generator
	 */
	public FiltersConfigurationDialog(Shell parentShell,
			MarkerContentGenerator generator) {

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.internal.views.markers.ViewerSettingsAndStatusDialog#
	 * configureShell(org.eclipse.swt.widgets.Shell)
	 */
	protected void configureShell(Shell newShell) {
		super.configureShell(newShell);
		newShell.setText(MarkerMessages.configureFiltersDialog_title);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.dialogs.Dialog#isResizable()
	 */
	protected boolean isResizable() {
		return true;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.internal.views.markers.ViewerSettingsAndStatusDialog#
	 * initializeDialog()
	 */
	protected void initializeDialog() {
		super.initializeDialog();
		validateState();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.internal.views.markers.ViewerSettingsAndStatusDialog#
	 * createDialogContentArea(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createDialogContentArea(Composite parent) {

		createViewCommonUI(parent).setLayoutData(
				new GridData(SWT.FILL, SWT.NONE, true, false));

		Group top = new Group(parent, SWT.NONE);
		top.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
		GridLayout layout = new GridLayout(3, false);
		top.setLayout(layout);
		top.setBackground(parent.getBackground());
		initializeDialogUnits(top);

		createFilterSelectionArea(top);
		createVerticalSeperator(top).setLayoutData(
				new GridData(SWT.NONE, SWT.FILL, false, true));
		createFilterAreas(top).setLayoutData(
				new GridData(SWT.FILL, SWT.FILL, true, true));
		final FormToolkit toolkit = new FormToolkit(top.getDisplay());
		parent.addDisposeListener(new DisposeListener() {

			public void widgetDisposed(DisposeEvent e) {
				toolkit.dispose();

			}
		});
		form = toolkit.createScrolledForm(top);
		form.setBackground(parent.getBackground());

		GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
		form.setLayoutData(data);
		form.getBody().setLayout(new GridLayout());

		filterAreas = generator.createFilterConfigurationFields();

		createFieldArea(toolkit, form, scopeArea, true);
		Iterator areas = filterAreas.iterator();

		while (areas.hasNext()) {
			createFieldArea(toolkit, form, (FilterConfigurationArea) areas
					.next(), true);
		}

		if (filterGroups.isEmpty())
			setFieldsEnabled(false);
		else
			loadDialogSettings();

		applyDialogFont(top);
		return top;
	}

	/**
	 * @param parent
	 *            parent
	 * @return {@link Control}
	 */
	private Control createViewCommonUI(Composite parent) {
		Group group = new Group(parent, SWT.NONE);
		group.setLayout(new GridLayout(1, true));
		createLimitArea(group);
		return group;
	}
			boolean expand) {
		final ExpandableComposite expandable = toolkit
				.createExpandableComposite(form.getBody(),
						ExpandableComposite.TWISTIE);
		expandable.setText(area.getTitle());
		expandable.setBackground(form.getBackground());
		expandable.setLayout(new GridLayout());
		expandable.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, area.grabExcessVerticalSpace()));
		expandable.addExpansionListener(new IExpansionListener() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.ui.forms.events.IExpansionListener#expansionStateChanged(org.eclipse.ui.forms.events.ExpansionEvent)
			 */
			public void expansionStateChanged(ExpansionEvent e) {
				expandable.getParent().layout(true);

			}

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.ui.forms.events.IExpansionListener#expansionStateChanging(org.eclipse.ui.forms.events.ExpansionEvent)
			 */
			public void expansionStateChanging(ExpansionEvent e) {

	/**
	 * Create element limit area.
	 * 
	 * @param parent
	 */
	private Control createLimitArea(Composite parent) {
		Composite composite = new Composite(parent, SWT.NONE);
		composite.setLayout(new GridLayout(2, false));
		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		limitBttn = new Button(composite, SWT.CHECK);
		limitBttn.setText(MarkerMessages.MarkerPreferences_VisibleItems);
		limitBttn.setLayoutData(new GridData());

		limitEditor = new Text(composite, SWT.BORDER);
		limitEditor.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		Listener listener = new Listener() {
			public void handleEvent(Event event) {
				switch (event.type) {
				case SWT.Selection:
					boolean limited = limitBttn.getSelection();
					setLimitEnabled(limited);
					limitEditor.setEditable(limited);
					limitEditor.setText(Integer.toString(getLimitValue()));
					break;
				case SWT.Modify:
					try {
						int limit = Integer.parseInt(event.text);
						if (limit > 0) {
							setLimitValue(limit);
						} else {
							limitEditor.setFocus();
						}
					} catch (Exception e) {
						limitEditor.setFocus();
					}
					break;
				}
				validateState();
			}
		};
		limitEditor.addListener(SWT.Modify, listener);
		limitBttn.addListener(SWT.Selection, listener);
		setLimitEnabled(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getBoolean(IDEInternalPreferences.USE_MARKER_LIMITS));
		setLimitValue(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getInt(IDEInternalPreferences.MARKER_LIMITS_VALUE));

		limitBttn.setSelection(isLimitEnabled());
		limitEditor.setText(Integer.toString(getLimitValue()));
		limitEditor.setEditable(isLimitEnabled());
		return composite;
	}

	/**
	 * Create the area for selecting the filters and enabling/disabling them.
	 * 
	 * @param main
	 * @return {@link Control}
	 */
	private Control createFilterSelectionArea(Composite main) {

		Composite filtersComposite = new Composite(main, SWT.NONE);
		filtersComposite.setLayout(new GridLayout(2, false));
		filtersComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,
				true));


		filtersList = CheckboxTableViewer.newCheckList(filtersComposite,
				SWT.BORDER);

		filtersList.setContentProvider(new IStructuredContentProvider() {
			/*
			 * (non-Javadoc)

			/*
			 * (non-Javadoc)
			 * 
			 * @see
			 * org.eclipse.jface.viewers.IStructuredContentProvider#getElements
			 * (java.lang.Object)
			 */
			public Object[] getElements(Object inputElement) {
				return filterGroups.toArray();

			/*
			 * (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) {

			/*
			 * (non-Javadoc)
			 * 
			 * @see
			 * org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object
			 * )
			 */
			public String getText(Object element) {
				return ((MarkerFieldFilterGroup) element).getName();

					/*
					 * (non-Javadoc)
					 * 
					 * @see org.eclipse.jface.viewers.ISelectionChangedListener#
					 * selectionChanged
					 * (org.eclipse.jface.viewers.SelectionChangedEvent)
					 */
					public void selectionChanged(SelectionChangedEvent event) {
						setSelectedFilter((MarkerFieldFilterGroup) ((IStructuredSelection) event

		addNew.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				addNewFilter(false);
			}
		});
		setButtonLayoutData(addNew);

		cloneButton = new Button(buttons, SWT.PUSH);
		cloneButton.setText(MarkerMessages.MarkerFilter_cloneFilterName);
		cloneButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {

			}
		});
		setButtonLayoutData(removeButton);

		renameButton = new Button(buttons, SWT.PUSH);
		renameButton.setText(MarkerMessages.MarkerFilter_renameName);
		renameButton.addSelectionListener(new SelectionAdapter() {

			}
		});
		setButtonLayoutData(renameButton);

		andOrLabel = new Label(filtersComposite, SWT.NONE);
		GridData labelData = new GridData();
		labelData.horizontalSpan = 2;
		andOrLabel.setLayoutData(labelData);
		andOrLabel.setText(MarkerMessages.AND_OR_Label);

		andButton = new Button(filtersComposite, SWT.RADIO);
		GridData data = new GridData(GridData.FILL_HORIZONTAL, SWT.NONE, true,
				false);

			/*
			 * (non-Javadoc)
			 * 
			 * @see
			 * org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse
			 * .swt.events.SelectionEvent)
			 */
			public void widgetSelected(SelectionEvent e) {
				andFilters = true;

			/*
			 * (non-Javadoc)
			 * 
			 * @see
			 * org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse
			 * .swt.events.SelectionEvent)
			 */
			public void widgetSelected(SelectionEvent e) {
				andFilters = false;

		});
		filtersList.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				updateAndOrEnblement();
				validateState();
			}
		});
		return filtersComposite;
	}

	/**
	 * 
	 * @param parent
	 * @return {@link Control}
	 */
	private Control createVerticalSeperator(Composite parent) {
		Label seprator = new Label(parent, SWT.SEPARATOR | SWT.VERTICAL);
		return seprator;
	}

	/**
	 * 
	 * @param parent
	 * @return {@link Control}
	 */
	private Control createFilterAreas(Composite parent) {
		final FormToolkit toolkit = new FormToolkit(parent.getDisplay());
		parent.addDisposeListener(new DisposeListener() {
			public void widgetDisposed(DisposeEvent e) {
				toolkit.dispose();
			}
		});
		form = toolkit.createScrolledForm(parent);
		form.setBackground(parent.getBackground());

		form.getBody().setLayout(new GridLayout());

		filterAreas = generator.createFilterConfigurationFields();

		createFieldArea(toolkit, form, scopeArea, true);
		Iterator areas = filterAreas.iterator();
		while (areas.hasNext()) {
			createFieldArea(toolkit, form,
					(FilterConfigurationArea) areas.next(), true);
		}
		return form;
	}

	/**
	 * Create a field area in the form for the FilterConfigurationArea
	 * 
	 * @param toolkit
	 * @param form
	 * @param area
	 * @param expand
	 *            <code>true</code> if the area should be expanded by default
	 */
	private void createFieldArea(final FormToolkit toolkit,
			final ScrolledForm form, final FilterConfigurationArea area,
			boolean expand) {
		final ExpandableComposite expandable = toolkit
				.createExpandableComposite(form.getBody(),
						ExpandableComposite.TWISTIE);
		expandable.setText(area.getTitle());
		expandable.setBackground(form.getBackground());
		expandable.setLayout(new GridLayout());
		expandable.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, area
				.grabExcessVerticalSpace()));
		expandable.addExpansionListener(new IExpansionListener() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see
			 * org.eclipse.ui.forms.events.IExpansionListener#expansionStateChanged
			 * (org.eclipse.ui.forms.events.ExpansionEvent)
			 */
			public void expansionStateChanged(ExpansionEvent e) {
				expandable.getParent().layout(true);

			}

			/*
			 * (non-Javadoc)
			 * 
			 * @see
			 * org.eclipse.ui.forms.events.IExpansionListener#expansionStateChanging
			 * (org.eclipse.ui.forms.events.ExpansionEvent)
			 */
			public void expansionStateChanging(ExpansionEvent e) {

			}
		});

		Composite sectionClient = toolkit.createComposite(expandable);
		sectionClient.setLayout(new GridLayout());
		sectionClient.setLayoutData(new GridData(SWT.FILL, SWT.NONE, true,
				false));
		sectionClient.setBackground(form.getBackground());
		area.createContents(sectionClient);
		expandable.setClient(sectionClient);
		expandable.setExpanded(expand);
	}

	/**
	 * Get a collection of names of the filters currently in the list
	 * 
	 * @return Collection
	 */
	private Collection getCurrentFilterNames() {
		Collection names = new ArrayList();
		Iterator filterIterator = filterGroups.iterator();
		while (filterIterator.hasNext()) {
			names.add(((MarkerFieldFilterGroup) filterIterator.next())
					.getName());
		}
		return names;
	}

	/**
	 * Opens Input Dialog for name,creates a new filterGroup, and adds it to the
	 * filterGroups
	 * 
	 * @param cloneSelected
	 *            true clones the selected filterGroup
	 * 
	 */
	private void addNewFilter(boolean cloneSelected) {
		String newName = getNewFilterName(getCurrentFilterNames(), null);
		if (newName != null) {
			createNewFilter(newName, cloneSelected);
		}
	}

	/**
	 * Opens Input Dialog for a new filter name
	 * 
	 * @param avoidNames
	 *            filter names to avoid
	 * @param initialName
	 *            initial name of the filter
	 * @return new filter name or null if canceled
	 * 
	 */
	private String getNewFilterName(final Collection avoidNames,
			String initialName) {
		InputDialog newDialog = new InputDialog(getShell(),
				MarkerMessages.MarkerFilterDialog_title,
				MarkerMessages.MarkerFilterDialog_message,


	/**
	 * Get IInputValidator for checking if the new name is valid
	 * 
	 * @param avoidNames
	 * @return IInputValidator
	 */
	private IInputValidator getNameValidator(final Collection avoidNames) {
		return new IInputValidator() {
			public String isValid(String value) {
				String newText = value.trim();
				if (newText.length() == 0)
					return MarkerMessages.MarkerFilterDialog_emptyMessage;
				if (avoidNames.contains(newText))

			}
		};
	}

	/**
	 * Get a collection of names of the filters currently in the list
	 * @return Collection
	 */
	private Collection getCurrentFilterNames() {
		Collection names = new ArrayList();
		Iterator filterIterator = filterGroups.iterator();
		while (filterIterator.hasNext()) {
			names.add(((MarkerFieldFilterGroup) filterIterator.next()).getName());
		}
		return names;
	}
	/**
	 * Create a new filterGroup, and adds it to the filterGroups
	 * 
	 * @param cloneSelected
	 *            true clones the selected filterGroup
	 * @param newName
	 *            name of new filterGroup
	 */
	private void createNewFilter(String newName, boolean cloneSelected) {
		MarkerFieldFilterGroup group = new MarkerFieldFilterGroup(null,
				generator);
		if (cloneSelected && selectedFilterGroup != null) {
			captureStateInto(group); // copy current values from UI
		}
		group.setName(newName);
		filterGroups.add(group);


	/**
	 * Renames the supplied MarkerFieldFilterGroup
	 * 
	 * @param filterGroup
	 */
	private void renameFilter(MarkerFieldFilterGroup filterGroup) {

			String initial = null;
			initial = filterGroup.getName();
			names.remove(initial);
			String newName = getNewFilterName(names, initial);
			if (newName != null) {
				filterGroup.setName(newName);
				filtersList.update(filterGroup, null);
			}
		}
	}

	/**
	 * Enable/disable 'and', 'or' buttons
	 */
	private void updateAndOrEnblement() {
		if (filtersList.getCheckedElements().length == 0) {
			andOrLabel.setEnabled(false);
			andButton.setEnabled(false);
			orButton.setEnabled(false);
		} else {
			andOrLabel.setEnabled(true);
			andButton.setEnabled(true);
			orButton.setEnabled(true);
		}
	}

	/**
	 * Return the dialog settings for the receiver.
	 * 

		return filterGroups;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.dialogs.Dialog#isResizable()
	 */
	protected boolean isResizable() {
		return true;
	}

	/**
	 * Load the dialog settings.
	 */

		return returnFilters;
	}

	private void validateState() {
		if (limitBttn == null || limitBttn.isDisposed()) {
			handleStatusUdpate(IStatus.INFO, null);
		} else {
			boolean limitLess = !limitBttn.getSelection();
			if (limitLess) {
				if (filtersList == null
						|| filtersList.getControl().isDisposed()) {
					handleStatusUdpate(IStatus.INFO, null);
				} else {
					boolean warnning = filtersList.getCheckedElements() == null
							|| filtersList.getCheckedElements().length == 0;
					if (warnning) {
						handleStatusUdpate(
								IStatus.WARNING,
								MarkerMessages.filtersDialogDeselectedFiltersMessage
										+ MarkerMessages.MarkerFilterDialog_YouHaveDisabledMarkerLimit);

					} else {
						handleStatusUdpate(
								IStatus.WARNING,
								MarkerMessages.MarkerFilterDialog_YouHaveDisabledMarkerLimit);
					}
				}
			} else {
				if (limitEditor == null || limitEditor.isDisposed()) {
					handleStatusUdpate(IStatus.INFO, null);
				} else {
					String value = limitEditor.getText().trim();
					boolean validLimit = value.length() != 0;
					if (validLimit) {
						try {
							int limit = Integer.parseInt(value);
							if (limit <= 0) {
								validLimit = false;
							}
						} catch (Exception e) {
							validLimit = false;
						}
					}
					if (filtersList == null
							|| filtersList.getControl().isDisposed()) {
						handleStatusUdpate(IStatus.INFO, null);
					} else {
						boolean warnning = filtersList.getCheckedElements().length == 0;
						if (validLimit) {
							if (warnning) {
								handleStatusUdpate(
										IStatus.WARNING,
										MarkerMessages.filtersDialogDeselectedFiltersMessage);
							} else {
								handleStatusUdpate(IStatus.INFO, null);
							}
						} else {
							handleStatusUdpate(IStatus.ERROR, null);
						}
					}
				}
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 

	 */
	protected void okPressed() {

		IDEWorkbenchPlugin
				.getDefault()
				.getPreferenceStore()
				.setValue(IDEInternalPreferences.MARKER_LIMITS_VALUE,
						getLimitValue());
		IDEWorkbenchPlugin
				.getDefault()
				.getPreferenceStore()
				.setValue(IDEInternalPreferences.USE_MARKER_LIMITS,
						isLimitEnabled());
		IDEWorkbenchPlugin.getDefault().savePluginPreferences();

		Iterator filterGroupIterator = filterGroups.iterator();
		while (filterGroupIterator.hasNext()) {

	/**
	 * 
	 * Updates the filterGroup with the values showing in the dialog's GUI.
	 * 
	 * @param filterGroup
	 * 
	 */
	private void captureStateInto(MarkerFieldFilterGroup filterGroup) {

			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.preferences.ViewSettingsDialog#performDefaults()
	 */
	protected void performDefaults() {
		setLimitEnabled(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getDefaultBoolean(IDEInternalPreferences.USE_MARKER_LIMITS));
		limitBttn.setSelection(isLimitEnabled());

		setLimitValue(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getDefaultInt(IDEInternalPreferences.MARKER_LIMITS_VALUE));
		limitEditor.setText(Integer.toString(getLimitValue()));

		filterGroups.clear();
		filterGroups.addAll(generator.getDeclaredFilters());
		filtersList.refresh();
		filtersList.setSelection(new StructuredSelection(
				filterGroups.size() > 1 ? filterGroups.iterator().next()
						: new Object[0]));
		andFilters = false;
		andButton.setSelection(andFilters);
		orButton.setSelection(!andFilters);
	}

	/**
	 * Return whether or not deselected elements should have been selected.
	 * 
	 * @return boolean
	 */
	private boolean shouldContinue() {
		if (filtersList.getCheckedElements().length == 0) {
			return MessageDialog.openQuestion(getShell(),
					MarkerMessages.filtersDialogDeselectedFiltersTitle,
					MarkerMessages.filtersDialogDeselectedFiltersMessage);
		}

		return true;
	}

	/**
	 * Remove the filters in selection.
	 * 
	 * @param selection

	}

	/**
	 * @return Returns the limitValue.
	 */
	private int getLimitValue() {
		return limitValue;
	}

	/**
	 * @param limitValue
	 *            The limitValue to set.
	 */
	private void setLimitValue(int limitValue) {
		this.limitValue = limitValue;
	}

	/**
	 * @return Returns true if limit is enabled.
	 */
	private boolean isLimitEnabled() {
		return limitEnabled;
	}

	/**
	 * @param limitEnabled
	 *            The limitEnabled to set.
	 */
	private void setLimitEnabled(boolean limitEnabled) {
		this.limitEnabled = limitEnabled;
	}

	/**
	 * Set the control and all of it's visibility state to visible.
	 * 
	 * @param visible

	 * @param markerFieldFilterGroup
	 */
	private void setSelectedFilter(MarkerFieldFilterGroup markerFieldFilterGroup) {
		if (selectedFilterGroup == markerFieldFilterGroup) {
			return;
		}
		removeButton

				.setEnabled(!(markerFieldFilterGroup == null || markerFieldFilterGroup
						.isSystem()));
		cloneButton.setEnabled(markerFieldFilterGroup != null);

		MarkerFieldFilterGroup old = selectedFilterGroup;
		selectedFilterGroup = markerFieldFilterGroup;
		if (old != null)




	 */
	boolean select(MarkerEntry entry) {
		try {
			return select(entry, getSelectedResources(), getEnabledFilters(), andFilters());
		} finally {
			entry.clearCache();
		}
	}
				if (andFilters) {
					while (filtersIterator.hasNext()) {
						MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) filtersIterator
								.next();
						if (!group.selectByScope(entry, resources)
								|| !group.selectByFilters(entry)) {
							return false;
						}
					}
					return true;
				}

	boolean select(MarkerEntry entry, IResource[] selResources,
			Collection enabledFilters, boolean andFilters) {
		if (enabledFilters.size() > 0) {
			Iterator filtersIterator = enabledFilters.iterator();
			if (andFilters) {
				while (filtersIterator.hasNext()) {
					MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) filtersIterator
							.next();
					if (!group.selectByScope(entry, selResources)
							|| !group.selectByFilters(entry)) {
						return false;
					}
				}
				return true;
			}

			while (filtersIterator.hasNext()) {
				MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) filtersIterator
						.next();
				if (group.selectByScope(entry, selResources)
						&& group.selectByFilters(entry)) {
					return true;
				}
			}
			return false;
		}
		return true;
	}

	/**

		if (monitor.isCanceled()) {
			return false;
		}
		IResource[] selected = getSelectedResources();
		Collection filters = getEnabledFilters();
		boolean andFilters = andFilters();
		Iterator iterator = resources.iterator();
		while (iterator.hasNext()) {
			IMarker[] markers = null;

			if (monitor.isCanceled()) {
				return false;
			}
			MarkerEntry entry = null;
			int lenght =  markers.length;
			for (int i = 0; i < lenght; i++) {
				entry = new MarkerEntry(markers[i]);
				if (select(entry, selected, filters, andFilters)) {
					result.add(entry);
				}
				entry.clearCache();
				if (i % 500 == 0) {
					if (monitor.isCanceled()) {
						return false;

Lines 95-100 Link Here

(-)src/org/eclipse/ui/internal/views/markers/MarkerFieldFilterGroup.java (-6 / +37 lines)
95	private static final String TAG_SCOPE = "scope"; //$NON-NLS-1$	95	private static final String TAG_SCOPE = "scope"; //$NON-NLS-1$
96	private static final String TAG_FIELD_FILTER_ENTRY = "fieldFilter"; //$NON-NLS-1$	96	private static final String TAG_FIELD_FILTER_ENTRY = "fieldFilter"; //$NON-NLS-1$
97	private static final String TAG_WORKING_SET = "workingSet"; //$NON-NLS-1$	97	private static final String TAG_WORKING_SET = "workingSet"; //$NON-NLS-1$
		98	private static final String TAG_LIMIT = "filterLimit"; //$NON-NLS-1$
98	// The identifier for user filters	99	// The identifier for user filters
99	private static String USER = "USER"; //$NON-NLS-1$	100	private static String USER = "USER"; //$NON-NLS-1$
100		101
Lines 106-111 Link Here
106	private boolean enabled = true;	107	private boolean enabled = true;
107	protected MarkerFieldFilter[] fieldFilters;	108	protected MarkerFieldFilter[] fieldFilters;
108	private int scope;	109	private int scope;
		110	private int limit;
		111
109	private String name;	112	private String name;
110	private String id;	113	private String id;
111		114
Lines 131-141 Link Here
131		134
132	if (configurationElement == null)	135	if (configurationElement == null)
133	return;	136	return;
134	String enablementString = configurationElement	137	String stringValue = configurationElement
135	.getAttribute(MarkerSupportRegistry.ENABLED);	138	.getAttribute(MarkerSupportRegistry.ENABLED);
136	if (MarkerSupportInternalUtilities.FALSE.equals(enablementString))	139	if (MarkerSupportInternalUtilities.FALSE.equals(stringValue)) {
137	enabled = false;	140	enabled = false;
138		141	}
		142	stringValue = configurationElement
		143	.getAttribute(MarkerSupportRegistry.FILTER_LIMIT);
		144	if (stringValue == null \|\| stringValue.length() == 0) {
		145	limit = -1;
		146	}
139	}	147	}
140		148
141	/**	149	/**
Lines 433-441 Link Here
433	*/	441	*/
434	void loadSettings(IMemento memento) {	442	void loadSettings(IMemento memento) {
435		443
436	String enabledString = memento.getString(TAG_ENABLED);	444	String stringValue = memento.getString(TAG_ENABLED);
437	if (enabledString != null && enabledString.length() > 0)	445	if (stringValue != null && stringValue.length() > 0){
438	enabled = Boolean.valueOf(enabledString).booleanValue();	446	enabled = Boolean.valueOf(stringValue).booleanValue();
		447	}
439	scope = memento.getInteger(TAG_SCOPE).intValue();	448	scope = memento.getInteger(TAG_SCOPE).intValue();
440		449
441	String workingSetName = memento.getString(TAG_WORKING_SET);	450	String workingSetName = memento.getString(TAG_WORKING_SET);
Lines 444-449 Link Here
444	setWorkingSet(PlatformUI.getWorkbench().getWorkingSetManager()	453	setWorkingSet(PlatformUI.getWorkbench().getWorkingSetManager()
445	.getWorkingSet(workingSetName));	454	.getWorkingSet(workingSetName));
446		455
		456	stringValue = memento.getString(TAG_LIMIT);
		457	if (stringValue != null && stringValue.length() > 0) {
		458	setLimit(Integer.parseInt(stringValue));
		459	}
		460
447	Map filterMap = new HashMap();	461	Map filterMap = new HashMap();
448	MarkerFieldFilter[] filters = getFieldFilters();	462	MarkerFieldFilter[] filters = getFieldFilters();
449	for (int i = 0; i < filters.length; i++) {	463	for (int i = 0; i < filters.length; i++) {
Lines 502-507 Link Here
502	*/	516	*/
503	protected boolean populateClone(MarkerFieldFilterGroup clone) {	517	protected boolean populateClone(MarkerFieldFilterGroup clone) {
504	clone.scope = this.scope;	518	clone.scope = this.scope;
		519	clone.limit = limit;
505	clone.workingSet = this.workingSet;	520	clone.workingSet = this.workingSet;
506	clone.enabled = this.enabled;	521	clone.enabled = this.enabled;
507	clone.fieldFilters = new MarkerFieldFilter[getFieldFilters().length];	522	clone.fieldFilters = new MarkerFieldFilter[getFieldFilters().length];
Lines 560-565 Link Here
560	void saveFilterSettings(IMemento memento) {	575	void saveFilterSettings(IMemento memento) {
561	memento.putString(TAG_ENABLED, String.valueOf(enabled));	576	memento.putString(TAG_ENABLED, String.valueOf(enabled));
562	memento.putString(TAG_SCOPE, String.valueOf(scope));	577	memento.putString(TAG_SCOPE, String.valueOf(scope));
		578	memento.putString(TAG_LIMIT, String.valueOf(limit));
563		579
564	if (workingSet != null) {	580	if (workingSet != null) {
565	memento.putString(TAG_WORKING_SET, workingSet.getName());	581	memento.putString(TAG_WORKING_SET, workingSet.getName());
Lines 661-666 Link Here
661	void setWorkingSet(IWorkingSet workingSet) {	677	void setWorkingSet(IWorkingSet workingSet) {
662	this.workingSet = workingSet;	678	this.workingSet = workingSet;
663	}	679	}
		680
		681	/**
		682	* @return Returns -1 for no limit else the limit.
		683	*/
		684	int getLimit() {
		685	return limit;
		686	}
		687
		688	/**
		689	* @param limit
		690	* The limit to set, -1 or 0 for no limit.
		691	*/
		692	void setLimit(int limit) {
		693	this.limit = limit;
		694	}
664		695
665	/**	696	/**
666	* Refresh the MarkerFieldFilterGroup .	697	* Refresh the MarkerFieldFilterGroup .

Lines 317-328 Link Here

(-)src/org/eclipse/ui/internal/views/markers/MarkerSupportInternalUtilities.java (-5 / +8 lines)
317	*/	317	*/
318	static int getMarkerLimit() {	318	static int getMarkerLimit() {
319		319
320	int value = IDEWorkbenchPlugin.getDefault().getPreferenceStore()	320	// If limits are enabled return it. Otherwise return -1
321	.getInt(IDEInternalPreferences.MARKER_LIMITS_VALUE);	321	if (IDEWorkbenchPlugin.getDefault().getPreferenceStore().getBoolean(
322	if (value <= 0) {	322	IDEInternalPreferences.USE_MARKER_LIMITS)) {
323	return -1;	323	return IDEWorkbenchPlugin.getDefault().getPreferenceStore().getInt(
		324	IDEInternalPreferences.MARKER_LIMITS_VALUE);
		325
324	}	326	}
325	return value;	327	return -1;
		328
326	}	329	}
327		330
328	/**	331	/**




import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.internal.ide.IDEInternalPreferences;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.views.markers.MarkerField;

/**

		super(view.getSite().getShell());
		this.extendedView = view;
		initialize(false);
		setLimitValue(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getInt(IDEInternalPreferences.MARKER_LIMITS_VALUE));
	}

	/*

	 * @see org.eclipse.jface.dialogs.Dialog#okPressed()
	 */
	protected void okPressed() {
		IDEWorkbenchPlugin
				.getDefault()
				.getPreferenceStore()
				.setValue(IDEInternalPreferences.MARKER_LIMITS_VALUE,
						getLimitValue());
		IDEWorkbenchPlugin.getDefault().savePluginPreferences();
		extendedView.setVisibleFields(getVisibleFields(), getNewWidths());
		super.okPressed();
	}

	 */
	protected void performDefaults() {
		initialize(true);
		setLimitValue(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getDefaultInt(IDEInternalPreferences.MARKER_LIMITS_VALUE));
		super.performDefaults();
	}





import java.util.Random;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.preferences.ViewSettingsDialog;
import org.eclipse.ui.views.markers.internal.MarkerMessages;

/**

 * @noextend This class is not intended to be subclassed by clients.
 * 
 */
abstract class ViewerColumnsDialog extends ViewerSettingsAndStatusDialog {

	/** The list contains columns that are currently visible in viewer */
	private List visible;

	/** The list contains columns that are note shown in viewer */
	private List nonVisible;

	/**
	 * The number of elements to show at Max. A zero value may indicate
	 * disablement of limit
	 */
	private int limitValue;

	/** The message area */
	private CLabel messageLabel;

	private TableViewer visibleViewer, nonVisibleViewer;

	private Button upButton, downButton;

	private Button toVisibleBtt, toNonVisibleBtt;

	private Text widthText;

	/**
	 * A listener to validate positive integer numbers only
	 */
	Listener postiveIntTextListener = new Listener() {

		private String intialValue;

		public void handleEvent(Event event) {

		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.views.markers.ViewerSettingsAndStatusDialog#createDialogContentArea(org.eclipse.swt.widgets.Composite)
	 * 
	 * @see
	 * org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets
	 * .Shell)
	 */
	protected void configureShell(Shell newShell) {
		super.configureShell(newShell);
		newShell.setText(JFaceResources
				.getString("ConfigureColumnsDialog_Title")); //$NON-NLS-1$
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.window.Window#getShellStyle()
	 */
	protected int getShellStyle() {
		return super.getShellStyle() | SWT.RESIZE;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets
	 * .Composite)
	 */
	protected Control createDialogArea(Composite parent) {

		Composite dialogArea = (Composite) super.createDialogArea(parent);

		dialogArea.setLayout(new GridLayout(1, true));

		initializeDialogUnits(dialogArea);

		createMessageArea(dialogArea);

		createLimitArea(dialogArea);

		createColumnsArea(dialogArea);

		applyDialogFont(dialogArea);

		initializeDlg();

		return dialogArea;
	}

	/**
	 * 
	 */
	protected Control createDialogContentArea(Composite dialogArea) {
		return createColumnsArea(dialogArea);
	}
	
	/**
	 * Create message area.
	 * 
	 * @param parent
	 */
	void createMessageArea(Composite parent) {
		messageLabel = new CLabel(parent, SWT.NONE);
		messageLabel.setImage(JFaceResources
				.getImage(Dialog.DLG_IMG_MESSAGE_INFO));
		messageLabel
				.setLayoutData(new GridData(SWT.FILL, SWT.NONE, true, false));
	}

	/**
	 * Create element limit area.
	 * 
	 * @param parent
	 */
	void createLimitArea(Composite parent) {
		Composite composite = new Group(parent, SWT.NONE);
		composite.setLayout(new GridLayout(2, false));
		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

		CLabel cLabel = new CLabel(composite, SWT.NONE);
		cLabel.setText(MarkerMessages.MarkerPreferences_VisibleItems);
		cLabel.setLayoutData(new GridData());

		limitEditor = new Text(composite, SWT.BORDER);
		limitEditor.setText(Integer.toString(getLimitValue()));
		limitEditor.setLayoutData(new GridData());
		limitEditor.addListener(SWT.FocusOut, postivIntTextListener);
		limitEditor.addListener(SWT.KeyDown, postivIntTextListener);
		limitEditor.addListener(SWT.Modify, new Listener() {
			public void handleEvent(Event event) {
				int limit = 0;
				try {
					limit = Integer.parseInt(limitEditor.getText().trim());
				} catch (Exception e) {
					return;// ignore this one
				}
				setLimitValue(limit);
			}
		});
		limitEditor.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
	}

	/**
	 * Create the controls to configure columns.
	 * 
	 * @param dialogArea
	 * @return {@link Control}
	 */
	Control createColumnsArea(Composite dialogArea) {
		Group columnArea = new Group(dialogArea, SWT.NONE);
		columnArea.setLayout(new GridLayout(4, false));
		GridData gData = new GridData(GridData.FILL_BOTH

		createVisibleTable(columnArea);
		createUpDownBtt(columnArea);
		createWidthArea(columnArea);
		return columnArea;
	}

	/**

	 * 
	 * @param parent
	 */
	Control createUpDownBtt(Composite parent) {
		Composite composite = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout(1, true);
		layout.horizontalSpacing = 0;

		});
		downButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		downButton.setEnabled(false);
		return composite;
	}

	/**
	 * Create the controls responsible to display/edit column widths.
	 * 
	 * @param parent
	 * @return {@link Control}
	 */
	Control createWidthArea(Composite parent) {
		Label widthLabel = new Label(parent, SWT.NONE);
		widthLabel.setText(JFaceResources
				.getString("ConfigureColumnsDialog_WidthOfSelectedColumn")); //$NON-NLS-1$

				| GridData.HORIZONTAL_ALIGN_CENTER);
		gridData.widthHint = convertWidthInCharsToPixels(5);
		widthText.setLayoutData(gridData);
		widthText.addListener(SWT.Modify, postiveIntTextListener);
		widthText.addListener(SWT.FocusOut, postivIntTextListener);
		widthText.addListener(SWT.Modify, new Listener() {
			public void handleEvent(Event event) {
				if (widthText.isEnabled()) {
					int width = 0;
					try {
						int width = Integer
								.parseInt(widthText.getText().trim());
						Object data = ((IStructuredSelection) visibleViewer
								.getSelection()).getFirstElement();
						if (data != null) {
							IColumnUpdater updater = getColumnUpdater();
							updater.setColumnWidth(data, width);
						}
					} catch (Exception e) {
						return;// ignore
					}
					Object data = ((IStructuredSelection) visibleViewer
							.getSelection()).getFirstElement();
					if (data != null) {
						IColumnUpdater updater = getColumnUpdater();
						updater.setColumnWidth(data, width);
					}
				}
			}
		});
		widthText.setText(MarkerSupportInternalUtilities.EMPTY_STRING);
		widthText.setEditable(false);
		return widthText;
	}

	/**

	 * Creates the table that lists out visible columns in the viewer
	 * 
	 * @param parent
	 * @return {@link Control}
	 */
	Control createVisibleTable(Composite parent) {
		final Table table = new Table(parent, SWT.BORDER | SWT.MULTI);
		GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
		data.widthHint = convertWidthInCharsToPixels(30);

			}
		});
		visibleViewer.setInput(this);
		return table;
	}

	/**
	 * Creates the table that lists out non-visible columns in the viewer
	 * 
	 * @param parent
	 * @return {@link Control}
	 */
	Control createInvisibleTable(Composite parent) {
		final Table table = new Table(parent, SWT.BORDER | SWT.MULTI);
		GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
		data.widthHint = convertWidthInCharsToPixels(30);

			}
		});
		nonVisibleViewer.setInput(this);
		return table;
	}

	/**

	 * vice-versa
	 * 
	 * @param parent
	 * @return {@link Control}
	 */
	Control createMoveButtons(Composite parent) {
		Composite bttArea = new Composite(parent, SWT.NONE);
		bttArea.setLayout(new GridLayout(1, true));
		bttArea.setLayoutData(new GridData(GridData.FILL_VERTICAL));

			}
		});
		toVisibleBtt.setEnabled(false);
		return bttArea;

	/**
	 * Display the error message and an appropriate icon.
	 * 
	 * @param messgage
	 * @param severity
	 */
	protected void handleStatusUdpate(int severity, String messgage) {
		Image image = null;
		switch (severity) {
		case IStatus.ERROR: {
			if (messgage == null) {
				messgage = getErrorMessage();
			}
			image = getErrorImage();
			break;
		}
		case IStatus.WARNING: {
			image = getWarningImage();
			break;
		}
		case IStatus.OK:
		case IStatus.INFO:
		default:
			image = getInfoImage();
		}
		messageLabel.setImage(image);
		if (messgage == null) {
			messgage = getDefaultMessage();
		}
		if (messgage == null) {
			messgage = MarkerSupportInternalUtilities.EMPTY_STRING;
		}
		messageLabel.setText(messgage);
	}

	/**
	 * Return the message to display when dialog is opened.
	 */
	protected String getDefaultMessage() {
		return MarkerMessages.MarkerPreferences_ZeroOrBlankValueCanBeUsedToDisableTheLimit;
	}

	/**
	 * @return Returns the error message to display for a wrong limit value.
	 */
	protected String getErrorMessage() {
		return JFaceResources.getString("IntegerFieldEditor.errorMessage"); //$NON-NLS-1$
	}

	/**
	 */
	protected Image getInfoImage() {
		return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_INFO);
	}

	/**
	 */
	protected Image getWarningImage() {
		return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_WARNING);
	}

	/**
	 */
	protected Image getErrorImage() {
		return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_ERROR);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.preferences.ViewSettingsDialog#performDefaults()
	 */
	protected void performDefaults() {
		refreshViewers();
		super.performDefaults();
	}

	/**
	 * 
	 * @param event
	 * @param intialvalue
	 * @return new value in String
	 */
	String handleIntegerFieldChange(Event event, String intialvalue) {
		String value = ((Text) event.widget).getText().trim();
		String value = text.getText().trim();
		switch (event.type) {
		case SWT.KeyDown:
		case SWT.Modify:
				if (!Character.isISOControl(event.character)) {
					handleStatusUdpate(IStatus.ERROR, getErrorMessage());
					event.doit = false;
					return intialvalue;
				}
			}
		case SWT.FocusOut:
			if (value.length() == 0) {
				handleStatusUdpate(IStatus.ERROR, null);
				text.setText(value);
				text.selectAll();
				handleStatusUdpate(IStatus.INFO, null);
			} else {
				try {
					int number = Integer.parseInt(value);
					if (number > 0) {
						handleStatusUdpate(IStatus.INFO, null);
					} else {
						value = intialvalue;
						((Text) event.widget).selectAll();
						handleStatusUdpate(IStatus.ERROR, getErrorMessage());
					}
				} catch (Exception e) {
					value = intialvalue;
					((Text) event.widget).selectAll();
					text.selectAll();
					handleStatusUdpate(IStatus.ERROR, getErrorMessage());
					event.doit = false;
				}
			}
		}

			updater.setColumnVisible(iterator.next(), visibility);
		}
	}
	
	protected void performDefaults() {
		refreshViewers();
		super.performDefaults();
	}

	/**
	 * Updates the UI based on values of the variable
	 */
	void refreshViewers() {
		if (limitEditor != null) {
			limitEditor.setText(Integer.toString(getLimitValue()));
		}
		if (nonVisibleViewer != null) {
			nonVisibleViewer.refresh();
		}

		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.dialogs.Dialog#isResizable()
	 */
	protected boolean isResizable() {
		return true;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.dialogs.Dialog#okPressed()
	 */
	protected void okPressed() {
		super.okPressed();
	}

	/**
	 * @return Returns the limitValue.
	 */
	public int getLimitValue() {
		return limitValue;
	}

	/**
	 * @param limitValue
	 *            The limitValue to set.
	 */
	void setLimitValue(int limitValue) {
		this.limitValue = limitValue;
	}

	/**
	 * @return List of visible columns
	 */




/*******************************************************************************
 * Copyright (c) 2010 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.internal.views.markers;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.preferences.ViewSettingsDialog;

/**
 * @since 3.7
 * @author Hitesh Soliwal
 * @noextend This class is not intended to be subclassed by clients.
 */
public abstract class ViewerSettingsAndStatusDialog extends ViewSettingsDialog {

	private Label imageLabel;
	/** The message area */
	private Text messageArea;
	private Composite msgParent;

	/**
	 * @param parentShell
	 */
	public ViewerSettingsAndStatusDialog(Shell parentShell) {
		super(parentShell);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets
	 * .Shell)
	 */
	protected void configureShell(Shell newShell) {
		super.configureShell(newShell);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.window.Window#getShellStyle()
	 */
	protected int getShellStyle() {
		return super.getShellStyle() | SWT.RESIZE;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.dialogs.Dialog#getInitialSize()
	 */
	protected Point getInitialSize() {
		Point size = super.getInitialSize();
		size.y += convertHeightInCharsToPixels(3);
		return size;
	}

	protected Control createDialogArea(Composite parent) {

		Composite dialogArea = (Composite) super.createDialogArea(parent);

		dialogArea.setLayout(new GridLayout(1, true));

		initializeDialogUnits(dialogArea);

		createMessageArea(dialogArea).setLayoutData(
				new GridData(SWT.FILL, SWT.NONE, true, false));

		createDialogContentArea(dialogArea).setLayoutData(
				new GridData(SWT.FILL, SWT.FILL, true, true));

		applyDialogFont(dialogArea);

		initializeDialog();

		return dialogArea;
	}

	/**
	 * @param dialogArea
	 */
	protected abstract Control createDialogContentArea(Composite dialogArea);

	/**
	 * 
	 */
	protected void initializeDialog() {
		handleStatusUdpate(IStatus.INFO, getDefaultMessage());
	}

	/**
	 * Create message area.
	 * 
	 * @param parent
	 */
	Control createMessageArea(Composite parent) {
		msgParent = new Composite(parent, SWT.BORDER);
		msgParent.setBackground(getMessageBackground());
		msgParent.setLayout(new GridLayout(2, false));

		imageLabel = new Label(msgParent, SWT.NONE);
		imageLabel.setBackground(msgParent.getBackground());
		imageLabel.setImage(JFaceResources
				.getImage(Dialog.DLG_IMG_MESSAGE_INFO));
		imageLabel
				.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));

		messageArea = new Text(msgParent, SWT.READ_ONLY | SWT.NONE | SWT.WRAP
				| SWT.MULTI | SWT.NO_FOCUS);
		messageArea.setEditable(false);
		messageArea.setBackground(msgParent.getBackground());
		messageArea
				.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
		return msgParent;
	}

	/**
	 * Display the message and an appropriate icon.
	 * 
	 * @param status
	 */
	protected void handleStatusUdpate(IStatus status) {
		handleStatusUdpate(status.getSeverity(), status.getMessage());
	}

	/**
	 * Display the message and an appropriate icon.
	 * 
	 * @param messgage
	 * @param severity
	 */
	protected void handleStatusUdpate(int severity, String messgage) {
		Image image = null;
		Button okBttn = getButton(OK);
		switch (severity) {
		case IStatus.ERROR: {
			if (messgage == null) {
				messgage = getErrorMessage();
			}
			image = getErrorImage();
			break;
		}
		case IStatus.WARNING: {
			image = getWarningImage();
			break;
		}
		case IStatus.OK:
		case IStatus.INFO:
		default:
			image = getInfoImage();
		}
		if (messgage == null) {
			messgage = getDefaultMessage();
		}
		if (messgage.equals(MarkerSupportInternalUtilities.EMPTY_STRING)) {
			handleMessageAreaVisibility(false);
			image = null;
		} else {
			handleMessageAreaVisibility(true);
		}
		if (okBttn != null) {
			okBttn.setEnabled(severity == IStatus.OK
					|| severity == IStatus.INFO || severity == IStatus.WARNING);
		}
		if (msgParent != null) {
			setMessageImage(image);
			setMessageText(messgage);
			msgParent.layout();
		}
	}

	/**
	 * @param image
	 */
	protected void setMessageImage(Image image) {
		if (imageLabel != null) {
			imageLabel.setImage(image);
		}
	}

	/**
	 * @param messgage
	 */
	protected void setMessageText(String messgage) {
		if (messageArea != null) {
			messageArea.setText(messgage);
		}
	}

	/**
	 * 
	 */
	protected Image getMessageImage() {
		if (imageLabel != null) {
			imageLabel.getImage();
		}
		return null;
	}

	/**
	 */
	protected String getMessageText() {
		if (messageArea != null) {
			return messageArea.getText();
		}
		return null;
	}

	/**
	 * 
	 * @param visible
	 */
	protected void handleMessageAreaVisibility(boolean visible) {
		if (msgParent == null || msgParent.isDisposed()) {
			return;
		}
		GridData data = (GridData) msgParent.getLayoutData();
		if (data.exclude == visible) {
			data.exclude = !visible;
			msgParent.setVisible(visible);
			msgParent.getParent().layout();
		}
	}

	/**
	 * Return the Color to display when dialog is opened.
	 */
	protected Color getMessageBackground() {
		return getShell().getDisplay()
				.getSystemColor(SWT.COLOR_LIST_BACKGROUND);
	}

	/**
	 * Return the message to display when dialog is opened.
	 */
	protected String getDefaultMessage() {
		return MarkerSupportInternalUtilities.EMPTY_STRING;
	}

	/**
	 * @return Returns the error message to display for a wrong limit value.
	 */
	protected String getErrorMessage() {
		return JFaceResources.getString("StringFieldEditor.errorMessage"); //$NON-NLS-1$
	}

	/**
	 */
	protected Image getInfoImage() {
		return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_INFO);
	}

	/**
	 */
	protected Image getWarningImage() {
		return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_WARNING);
	}

	/**
	 */
	protected Image getErrorImage() {
		return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_ERROR);
	}

	protected void performDefaults() {
		super.performDefaults();
	}

	protected boolean isResizable() {
		return true;
	}

	protected void okPressed() {
		super.okPressed();
	}

}

Lines 60-65 Link Here

(-)src/org/eclipse/ui/views/markers/internal/MarkerSupportRegistry.java (+6 lines)
60	private static final Object WARNING = "WARNING";//$NON-NLS-1$	60	private static final Object WARNING = "WARNING";//$NON-NLS-1$
61		61
62	private static final String MARKER_ID = "markerId"; //$NON-NLS-1$	62	private static final String MARKER_ID = "markerId"; //$NON-NLS-1$
		63
		64	/**
		65	* Filter enablement : A zero/negative integer implies that the limit is
		66	* disabled.
		67	*/
		68	public static final String FILTER_LIMIT = "filterLimit"; //$NON-NLS-1$
63		69
64	/**	70	/**
65	* The tag for the marker support extension	71	* The tag for the marker support extension

Lines 77-83 Link Here

(-)src/org/eclipse/ui/views/markers/internal/messages.properties (-2 / +2 lines)
77	filtersDialog_deselectAllTypes = Dese&lect All	77	filtersDialog_deselectAllTypes = Dese&lect All
78	filtersDialog_conflictingName = A filter already exists with the name {0}	78	filtersDialog_conflictingName = A filter already exists with the name {0}
79	filtersDialogDeselectedFiltersTitle = Confirm Show All	79	filtersDialogDeselectedFiltersTitle = Confirm Show All
80	filtersDialogDeselectedFiltersMessage = You have not checked any configurations. This will show all entries. Continue?	80	filtersDialogDeselectedFiltersMessage = You have not checked any configurations. This will show all entries.
81		81
82	filtersDialog_descriptionLabel = Te&xt:	82	filtersDialog_descriptionLabel = Te&xt:
83	filtersDialog_contains = contains	83	filtersDialog_contains = contains
Lines 203-209 Link Here
203	MarkerPreferences_VisibleColumnsTitle = &Show	203	MarkerPreferences_VisibleColumnsTitle = &Show
204	MarkerPreferences_HiddenColumnsTitle = &Hide	204	MarkerPreferences_HiddenColumnsTitle = &Hide
205	MarkerPreferences_AtLeastOneVisibleColumn = There must be at least one visible column.	205	MarkerPreferences_AtLeastOneVisibleColumn = There must be at least one visible column.
206	MarkerPreferences_ZeroOrBlankValueCanBeUsedToDisableTheLimit = Please enter a positive number (zero or blank can be used to disable the limit).	206	MarkerFilterDialog_YouHaveDisabledMarkerLimit= You have selected to disable limiting items per group.
207		207
208	ProblemFilterDialog_System_Filters_Title = System filte&rs:	208	ProblemFilterDialog_System_Filters_Title = System filte&rs:
209	ProblemFilterDialog_All_Problems = Enabled for all problems	209	ProblemFilterDialog_All_Problems = Enabled for all problems

Return to bug 231081

Lines 758-794 Link Here

(-)src/org/eclipse/ui/internal/views/markers/MarkerContentGenerator.java (-26 / +34 lines)
758	*/	758	*/
759	boolean select(MarkerEntry entry) {	759	boolean select(MarkerEntry entry) {
760	try {	760	try {
761	Collection enabledFilters = getEnabledFilters();	761	return select(entry, getSelectedResources(), getEnabledFilters(), andFilters());
762	IResource[] resources = getSelectedResources();	762	} finally {
763	boolean andFilters = andFilters();	763	entry.clearCache();
764	if (enabledFilters.size() > 0) {	764	}
765	Iterator filtersIterator = enabledFilters.iterator();	765	}
766	if (andFilters) {
767	while (filtersIterator.hasNext()) {
768	MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) filtersIterator
769	.next();
770	if (!group.selectByScope(entry, resources)
771	\|\| !group.selectByFilters(entry)) {
772	return false;
773	}
774	}
775	return true;
776	}
777		766
		767	boolean select(MarkerEntry entry, IResource[] selResources,
		768	Collection enabledFilters, boolean andFilters) {
		769	if (enabledFilters.size() > 0) {
		770	Iterator filtersIterator = enabledFilters.iterator();
		771	if (andFilters) {
778	while (filtersIterator.hasNext()) {	772	while (filtersIterator.hasNext()) {
779	MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) filtersIterator	773	MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) filtersIterator
780	.next();	774	.next();
781	if (group.selectByScope(entry, resources)	775	if (!group.selectByScope(entry, selResources)
782	&& group.selectByFilters(entry)) {	776	\|\| !group.selectByFilters(entry)) {
783	return true;	777	return false;
784	}	778	}
785	}	779	}
786	return false;	780	return true;
787	}	781	}
788	return true;	782
789	} finally {	783	while (filtersIterator.hasNext()) {
790	entry.clearCache();	784	MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) filtersIterator
		785	.next();
		786	if (group.selectByScope(entry, selResources)
		787	&& group.selectByFilters(entry)) {
		788	return true;
		789	}
		790	}
		791	return false;
791	}	792	}
		793	return true;
792	}	794	}
793		795
794	/**	796	/**
Lines 1049-1054 Link Here
1049	if (monitor.isCanceled()) {	1051	if (monitor.isCanceled()) {
1050	return false;	1052	return false;
1051	}	1053	}
		1054	IResource[] selected = getSelectedResources();
		1055	Collection filters = getEnabledFilters();
		1056	boolean andFilters = andFilters();
1052	Iterator iterator = resources.iterator();	1057	Iterator iterator = resources.iterator();
1053	while (iterator.hasNext()) {	1058	while (iterator.hasNext()) {
1054	IMarker[] markers = null;	1059	IMarker[] markers = null;
Lines 1068-1078 Link Here
1068	if (monitor.isCanceled()) {	1073	if (monitor.isCanceled()) {
1069	return false;	1074	return false;
1070	}	1075	}
1071	for (int i = 0; i < markers.length; i++) {	1076	MarkerEntry entry = null;
1072	MarkerEntry entry = new MarkerEntry(markers[i]);	1077	int lenght = markers.length;
1073	if (select(entry)) {	1078	for (int i = 0; i < lenght; i++) {
		1079	entry = new MarkerEntry(markers[i]);
		1080	if (select(entry, selected, filters, andFilters)) {
1074	result.add(entry);	1081	result.add(entry);
1075	}	1082	}
		1083	entry.clearCache();
1076	if (i % 500 == 0) {	1084	if (i % 500 == 0) {
1077	if (monitor.isCanceled()) {	1085	if (monitor.isCanceled()) {
1078	return false;	1086	return false;

Lines 22-29 Link Here

(-)src/org/eclipse/ui/internal/views/markers/MarkersViewColumnsDialog.java (-12 lines)
22	import org.eclipse.swt.widgets.Composite;	22	import org.eclipse.swt.widgets.Composite;
23	import org.eclipse.swt.widgets.Control;	23	import org.eclipse.swt.widgets.Control;
24	import org.eclipse.swt.widgets.Shell;	24	import org.eclipse.swt.widgets.Shell;
25	import org.eclipse.ui.internal.ide.IDEInternalPreferences;
26	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
27	import org.eclipse.ui.views.markers.MarkerField;	25	import org.eclipse.ui.views.markers.MarkerField;
28		26
29	/**	27	/**
Lines 48-55 Link Here
48	super(view.getSite().getShell());	46	super(view.getSite().getShell());
49	this.extendedView = view;	47	this.extendedView = view;
50	initialize(false);	48	initialize(false);
51	setLimitValue(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
52	.getInt(IDEInternalPreferences.MARKER_LIMITS_VALUE));
53	}	49	}
54		50
55	/*	51	/*
Lines 92-103 Link Here
92	* @see org.eclipse.jface.dialogs.Dialog#okPressed()	88	* @see org.eclipse.jface.dialogs.Dialog#okPressed()
93	*/	89	*/
94	protected void okPressed() {	90	protected void okPressed() {
95	IDEWorkbenchPlugin
96	.getDefault()
97	.getPreferenceStore()
98	.setValue(IDEInternalPreferences.MARKER_LIMITS_VALUE,
99	getLimitValue());
100	IDEWorkbenchPlugin.getDefault().savePluginPreferences();
101	extendedView.setVisibleFields(getVisibleFields(), getNewWidths());	91	extendedView.setVisibleFields(getVisibleFields(), getNewWidths());
102	super.okPressed();	92	super.okPressed();
103	}	93	}
Lines 133-140 Link Here
133	*/	123	*/
134	protected void performDefaults() {	124	protected void performDefaults() {
135	initialize(true);	125	initialize(true);
136	setLimitValue(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
137	.getDefaultInt(IDEInternalPreferences.MARKER_LIMITS_VALUE));
138	super.performDefaults();	126	super.performDefaults();
139	}	127	}
140		128

Lines 19-25 Link Here

(-)src/org/eclipse/ui/internal/views/markers/ViewerColumnsDialog.java (-266 / +53 lines)
19	import java.util.Random;	19	import java.util.Random;
20		20
21	import org.eclipse.core.runtime.IStatus;	21	import org.eclipse.core.runtime.IStatus;
22	import org.eclipse.jface.dialogs.Dialog;
23	import org.eclipse.jface.resource.JFaceResources;	22	import org.eclipse.jface.resource.JFaceResources;
24	import org.eclipse.jface.viewers.ISelection;	23	import org.eclipse.jface.viewers.ISelection;
25	import org.eclipse.jface.viewers.ISelectionChangedListener;	24	import org.eclipse.jface.viewers.ISelectionChangedListener;
Lines 31-37 Link Here
31	import org.eclipse.jface.viewers.TableViewer;	30	import org.eclipse.jface.viewers.TableViewer;
32	import org.eclipse.jface.viewers.Viewer;	31	import org.eclipse.jface.viewers.Viewer;
33	import org.eclipse.swt.SWT;	32	import org.eclipse.swt.SWT;
34	import org.eclipse.swt.custom.CLabel;
35	import org.eclipse.swt.graphics.Image;	33	import org.eclipse.swt.graphics.Image;
36	import org.eclipse.swt.layout.FillLayout;	34	import org.eclipse.swt.layout.FillLayout;
37	import org.eclipse.swt.layout.GridData;	35	import org.eclipse.swt.layout.GridData;
Lines 48-54 Link Here
48	import org.eclipse.swt.widgets.Table;	46	import org.eclipse.swt.widgets.Table;
49	import org.eclipse.swt.widgets.TableColumn;	47	import org.eclipse.swt.widgets.TableColumn;
50	import org.eclipse.swt.widgets.Text;	48	import org.eclipse.swt.widgets.Text;
51	import org.eclipse.ui.preferences.ViewSettingsDialog;
52	import org.eclipse.ui.views.markers.internal.MarkerMessages;	49	import org.eclipse.ui.views.markers.internal.MarkerMessages;
53		50
54	/**	51	/**
Lines 64-70 Link Here
64	* @noextend This class is not intended to be subclassed by clients.	61	* @noextend This class is not intended to be subclassed by clients.
65	*	62	*
66	*/	63	*/
67	abstract class ViewerColumnsDialog extends ViewSettingsDialog {	64	abstract class ViewerColumnsDialog extends ViewerSettingsAndStatusDialog {
68		65
69	/** The list contains columns that are currently visible in viewer */	66	/** The list contains columns that are currently visible in viewer */
70	private List visible;	67	private List visible;
Lines 72-99 Link Here
72	/** The list contains columns that are note shown in viewer */	69	/** The list contains columns that are note shown in viewer */
73	private List nonVisible;	70	private List nonVisible;
74		71
75	/**
76	* The number of elements to show at Max. A zero value may indicate
77	* disablement of limit
78	*/
79	private int limitValue;
80
81	/** The message area */
82	private CLabel messageLabel;
83
84	private TableViewer visibleViewer, nonVisibleViewer;	72	private TableViewer visibleViewer, nonVisibleViewer;
85		73
86	private Button upButton, downButton;	74	private Button upButton, downButton;
87		75
88	private Button toVisibleBtt, toNonVisibleBtt;	76	private Button toVisibleBtt, toNonVisibleBtt;
89		77
90	private Text widthText, limitEditor;	78	private Text widthText;
91		79
92	/**	80	/**
93	* A listener to validate positive integer numbers only	81	* A listener to validate positive integer numbers only
94	*/	82	*/
95	Listener postivIntTextListener = new Listener() {	83	Listener postiveIntTextListener = new Listener() {
96
97	private String intialValue;	84	private String intialValue;
98		85
99	public void handleEvent(Event event) {	86	public void handleEvent(Event event) {
Lines 139-253 Link Here
139	}	126	}
140	}	127	}
141		128
142	/*	129	/* (non-Javadoc)
143	* (non-Javadoc)	130	* @see org.eclipse.ui.internal.views.markers.ViewerSettingsAndStatusDialog#createDialogContentArea(org.eclipse.swt.widgets.Composite)
144	*
145	* @see
146	* org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets
147	* .Shell)
148	*/
149	protected void configureShell(Shell newShell) {
150	super.configureShell(newShell);
151	newShell.setText(JFaceResources
152	.getString("ConfigureColumnsDialog_Title")); //$NON-NLS-1$
153	}
154
155	/*
156	* (non-Javadoc)
157	*
158	* @see org.eclipse.jface.window.Window#getShellStyle()
159	*/
160	protected int getShellStyle() {
161	return super.getShellStyle() \| SWT.RESIZE;
162	}
163
164	/*
165	* (non-Javadoc)
166	*
167	* @see
168	* org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets
169	* .Composite)
170	*/
171	protected Control createDialogArea(Composite parent) {
172
173	Composite dialogArea = (Composite) super.createDialogArea(parent);
174
175	dialogArea.setLayout(new GridLayout(1, true));
176
177	initializeDialogUnits(dialogArea);
178
179	createMessageArea(dialogArea);
180
181	createLimitArea(dialogArea);
182
183	createColumnsArea(dialogArea);
184
185	applyDialogFont(dialogArea);
186
187	initializeDlg();
188
189	return dialogArea;
190	}
191
192	/**
193	*
194	*/	131	*/
195	void initializeDlg() {	132	protected Control createDialogContentArea(Composite dialogArea) {
196	handleStatusUdpate(IStatus.INFO, getDefaultMessage());	133	return createColumnsArea(dialogArea);
197	}	134	}
198		135
199	/**
200	* Create message area.
201	*
202	* @param parent
203	*/
204	void createMessageArea(Composite parent) {
205	messageLabel = new CLabel(parent, SWT.NONE);
206	messageLabel.setImage(JFaceResources
207	.getImage(Dialog.DLG_IMG_MESSAGE_INFO));
208	messageLabel
209	.setLayoutData(new GridData(SWT.FILL, SWT.NONE, true, false));
210	}
211
212	/**
213	* Create element limit area.
214	*
215	* @param parent
216	*/
217	void createLimitArea(Composite parent) {
218	Composite composite = new Group(parent, SWT.NONE);
219	composite.setLayout(new GridLayout(2, false));
220	composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
221
222	CLabel cLabel = new CLabel(composite, SWT.NONE);
223	cLabel.setText(MarkerMessages.MarkerPreferences_VisibleItems);
224	cLabel.setLayoutData(new GridData());
225
226	limitEditor = new Text(composite, SWT.BORDER);
227	limitEditor.setText(Integer.toString(getLimitValue()));
228	limitEditor.setLayoutData(new GridData());
229	limitEditor.addListener(SWT.FocusOut, postivIntTextListener);
230	limitEditor.addListener(SWT.KeyDown, postivIntTextListener);
231	limitEditor.addListener(SWT.Modify, new Listener() {
232	public void handleEvent(Event event) {
233	int limit = 0;
234	try {
235	limit = Integer.parseInt(limitEditor.getText().trim());
236	} catch (Exception e) {
237	return;// ignore this one
238	}
239	setLimitValue(limit);
240	}
241	});
242	limitEditor.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
243	}
244
245	/**	136	/**
246	* Create the controls to configure columns.	137	* Create the controls to configure columns.
247	*	138	*
248	* @param dialogArea	139	* @param dialogArea
		140	* @return {@link Control}
249	*/	141	*/
250	void createColumnsArea(Composite dialogArea) {	142	Control createColumnsArea(Composite dialogArea) {
251	Group columnArea = new Group(dialogArea, SWT.NONE);	143	Group columnArea = new Group(dialogArea, SWT.NONE);
252	columnArea.setLayout(new GridLayout(4, false));	144	columnArea.setLayout(new GridLayout(4, false));
253	GridData gData = new GridData(GridData.FILL_BOTH	145	GridData gData = new GridData(GridData.FILL_BOTH
Lines 260-265 Link Here
260	createVisibleTable(columnArea);	152	createVisibleTable(columnArea);
261	createUpDownBtt(columnArea);	153	createUpDownBtt(columnArea);
262	createWidthArea(columnArea);	154	createWidthArea(columnArea);
		155	return columnArea;
263	}	156	}
264		157
265	/**	158	/**
Lines 267-273 Link Here
267	*	160	*
268	* @param parent	161	* @param parent
269	*/	162	*/
270	void createUpDownBtt(Composite parent) {	163	Control createUpDownBtt(Composite parent) {
271	Composite composite = new Composite(parent, SWT.NONE);	164	Composite composite = new Composite(parent, SWT.NONE);
272	GridLayout layout = new GridLayout(1, true);	165	GridLayout layout = new GridLayout(1, true);
273	layout.horizontalSpacing = 0;	166	layout.horizontalSpacing = 0;
Lines 297-310 Link Here
297	});	190	});
298	downButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));	191	downButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
299	downButton.setEnabled(false);	192	downButton.setEnabled(false);
		193	return composite;
300	}	194	}
301		195
302	/**	196	/**
303	* Create the controls responsible to display/edit column widths.	197	* Create the controls responsible to display/edit column widths.
304	*	198	*
305	* @param parent	199	* @param parent
		200	* @return {@link Control}
306	*/	201	*/
307	void createWidthArea(Composite parent) {	202	Control createWidthArea(Composite parent) {
308	Label widthLabel = new Label(parent, SWT.NONE);	203	Label widthLabel = new Label(parent, SWT.NONE);
309	widthLabel.setText(JFaceResources	204	widthLabel.setText(JFaceResources
310	.getString("ConfigureColumnsDialog_WidthOfSelectedColumn")); //$NON-NLS-1$	205	.getString("ConfigureColumnsDialog_WidthOfSelectedColumn")); //$NON-NLS-1$
Lines 319-346 Link Here
319	\| GridData.HORIZONTAL_ALIGN_CENTER);	214	\| GridData.HORIZONTAL_ALIGN_CENTER);
320	gridData.widthHint = convertWidthInCharsToPixels(5);	215	gridData.widthHint = convertWidthInCharsToPixels(5);
321	widthText.setLayoutData(gridData);	216	widthText.setLayoutData(gridData);
322	widthText.addListener(SWT.KeyDown, postivIntTextListener);	217	widthText.addListener(SWT.Modify, postiveIntTextListener);
323	widthText.addListener(SWT.FocusOut, postivIntTextListener);
324	widthText.addListener(SWT.Modify, new Listener() {	218	widthText.addListener(SWT.Modify, new Listener() {
325	public void handleEvent(Event event) {	219	public void handleEvent(Event event) {
326	if (widthText.isEnabled()) {	220	if (widthText.isEnabled()) {
327	int width = 0;
328	try {	221	try {
329	width = Integer.parseInt(widthText.getText().trim());	222	int width = Integer
		223	.parseInt(widthText.getText().trim());
		224	Object data = ((IStructuredSelection) visibleViewer
		225	.getSelection()).getFirstElement();
		226	if (data != null) {
		227	IColumnUpdater updater = getColumnUpdater();
		228	updater.setColumnWidth(data, width);
		229	}
330	} catch (Exception e) {	230	} catch (Exception e) {
331	return;// ignore this one	231	return;// ignore
332	}
333	Object data = ((IStructuredSelection) visibleViewer
334	.getSelection()).getFirstElement();
335	if (data != null) {
336	IColumnUpdater updater = getColumnUpdater();
337	updater.setColumnWidth(data, width);
338	}	232	}
339	}	233	}
340	}	234	}
341	});	235	});
342	widthText.setText(MarkerSupportInternalUtilities.EMPTY_STRING);	236	widthText.setText(MarkerSupportInternalUtilities.EMPTY_STRING);
343	widthText.setEditable(false);	237	widthText.setEditable(false);
		238	return widthText;
344	}	239	}
345		240
346	/**	241	/**
Lines 359-366 Link Here
359	* Creates the table that lists out visible columns in the viewer	254	* Creates the table that lists out visible columns in the viewer
360	*	255	*
361	* @param parent	256	* @param parent
		257	* @return {@link Control}
362	*/	258	*/
363	void createVisibleTable(Composite parent) {	259	Control createVisibleTable(Composite parent) {
364	final Table table = new Table(parent, SWT.BORDER \| SWT.MULTI);	260	final Table table = new Table(parent, SWT.BORDER \| SWT.MULTI);
365	GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);	261	GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
366	data.widthHint = convertWidthInCharsToPixels(30);	262	data.widthHint = convertWidthInCharsToPixels(30);
Lines 396-409 Link Here
396	}	292	}
397	});	293	});
398	visibleViewer.setInput(this);	294	visibleViewer.setInput(this);
		295	return table;
399	}	296	}
400		297
401	/**	298	/**
402	* Creates the table that lists out non-visible columns in the viewer	299	* Creates the table that lists out non-visible columns in the viewer
403	*	300	*
404	* @param parent	301	* @param parent
		302	* @return {@link Control}
405	*/	303	*/
406	void createInvisibleTable(Composite parent) {	304	Control createInvisibleTable(Composite parent) {
407	final Table table = new Table(parent, SWT.BORDER \| SWT.MULTI);	305	final Table table = new Table(parent, SWT.BORDER \| SWT.MULTI);
408	GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);	306	GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
409	data.widthHint = convertWidthInCharsToPixels(30);	307	data.widthHint = convertWidthInCharsToPixels(30);
Lines 439-444 Link Here
439	}	337	}
440	});	338	});
441	nonVisibleViewer.setInput(this);	339	nonVisibleViewer.setInput(this);
		340	return table;
442	}	341	}
443		342
444	/**	343	/**
Lines 446-453 Link Here
446	* vice-versa	345	* vice-versa
447	*	346	*
448	* @param parent	347	* @param parent
		348	* @return {@link Control}
449	*/	349	*/
450	void createMoveButtons(Composite parent) {	350	Control createMoveButtons(Composite parent) {
451	Composite bttArea = new Composite(parent, SWT.NONE);	351	Composite bttArea = new Composite(parent, SWT.NONE);
452	bttArea.setLayout(new GridLayout(1, true));	352	bttArea.setLayout(new GridLayout(1, true));
453	bttArea.setLayoutData(new GridData(GridData.FILL_VERTICAL));	353	bttArea.setLayoutData(new GridData(GridData.FILL_VERTICAL));
Lines 476-594 Link Here
476	}	376	}
477	});	377	});
478	toVisibleBtt.setEnabled(false);	378	toVisibleBtt.setEnabled(false);
479	}	379	return bttArea;
480
481	/**
482	* Display the error message and an appropriate icon.
483	*
484	* @param messgage
485	* @param severity
486	*/
487	protected void handleStatusUdpate(int severity, String messgage) {
488	Image image = null;
489	switch (severity) {
490	case IStatus.ERROR: {
491	if (messgage == null) {
492	messgage = getErrorMessage();
493	}
494	image = getErrorImage();
495	break;
496	}
497	case IStatus.WARNING: {
498	image = getWarningImage();
499	break;
500	}
501	case IStatus.OK:
502	case IStatus.INFO:
503	default:
504	image = getInfoImage();
505	}
506	messageLabel.setImage(image);
507	if (messgage == null) {
508	messgage = getDefaultMessage();
509	}
510	if (messgage == null) {
511	messgage = MarkerSupportInternalUtilities.EMPTY_STRING;
512	}
513	messageLabel.setText(messgage);
514	}
515
516	/**
517	* Return the message to display when dialog is opened.
518	*/
519	protected String getDefaultMessage() {
520	return MarkerMessages.MarkerPreferences_ZeroOrBlankValueCanBeUsedToDisableTheLimit;
521	}
522
523	/**
524	* @return Returns the error message to display for a wrong limit value.
525	*/
526	protected String getErrorMessage() {
527	return JFaceResources.getString("IntegerFieldEditor.errorMessage"); //$NON-NLS-1$
528	}
529
530	/**
531	*/
532	protected Image getInfoImage() {
533	return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_INFO);
534	}
535
536	/**
537	*/
538	protected Image getWarningImage() {
539	return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_WARNING);
540	}
541
542	/**
543	*/
544	protected Image getErrorImage() {
545	return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_ERROR);
546	}
547
548	/*
549	* (non-Javadoc)
550	*
551	* @see org.eclipse.ui.preferences.ViewSettingsDialog#performDefaults()
552	*/
553	protected void performDefaults() {
554	refreshViewers();
555	super.performDefaults();
556	}	380	}
557		381
558	/**	382	/**
559	*	383	*
560	* @param event	384	* @param event
561	* @param intialvalue	385	* @param intialvalue
562	* @return new integer value	386	* @return new value in String
563	*/	387	*/
564	String handleIntegerFieldChange(Event event, String intialvalue) {	388	String handleIntegerFieldChange(Event event, String intialvalue) {
565	Text text = (Text) event.widget;	389	String value = ((Text) event.widget).getText().trim();
566	String value = text.getText().trim();
567	switch (event.type) {	390	switch (event.type) {
568	case SWT.KeyDown:	391	case SWT.KeyDown:
569	if (!Character.isDigit(event.character)) {	392	case SWT.Modify:
570	if (!Character.isISOControl(event.character)) {
571	handleStatusUdpate(IStatus.ERROR, getErrorMessage());
572	event.doit = false;
573	return intialvalue;
574	}
575	}
576	case SWT.FocusOut:	393	case SWT.FocusOut:
577	if (value.length() == 0) {	394	if (value.length() == 0) {
578	value = Integer.toString(0);	395	handleStatusUdpate(IStatus.ERROR, null);
579	text.setText(value);
580	text.selectAll();
581	handleStatusUdpate(IStatus.INFO, null);
582	} else {	396	} else {
583	try {	397	try {
584	Integer.parseInt(value);	398	int number = Integer.parseInt(value);
585	handleStatusUdpate(IStatus.INFO, null);	399	if (number > 0) {
		400	handleStatusUdpate(IStatus.INFO, null);
		401	} else {
		402	value = intialvalue;
		403	((Text) event.widget).selectAll();
		404	handleStatusUdpate(IStatus.ERROR, getErrorMessage());
		405	}
586	} catch (Exception e) {	406	} catch (Exception e) {
587	value = intialvalue;	407	value = intialvalue;
588	text.setText(value);	408	((Text) event.widget).selectAll();
589	text.selectAll();
590	handleStatusUdpate(IStatus.ERROR, getErrorMessage());	409	handleStatusUdpate(IStatus.ERROR, getErrorMessage());
591	event.doit = false;
592	}	410	}
593	}	411	}
594	}	412	}
Lines 785-798 Link Here
785	updater.setColumnVisible(iterator.next(), visibility);	603	updater.setColumnVisible(iterator.next(), visibility);
786	}	604	}
787	}	605	}
		606
		607	protected void performDefaults() {
		608	refreshViewers();
		609	super.performDefaults();
		610	}
788		611
789	/**	612	/**
790	* Updates the UI based on values of the variable	613	* Updates the UI based on values of the variable
791	*/	614	*/
792	void refreshViewers() {	615	void refreshViewers() {
793	if (limitEditor != null) {
794	limitEditor.setText(Integer.toString(getLimitValue()));
795	}
796	if (nonVisibleViewer != null) {	616	if (nonVisibleViewer != null) {
797	nonVisibleViewer.refresh();	617	nonVisibleViewer.refresh();
798	}	618	}
Lines 801-839 Link Here
801	}	621	}
802	}	622	}
803		623
804	/*
805	* (non-Javadoc)
806	*
807	* @see org.eclipse.jface.dialogs.Dialog#isResizable()
808	*/
809	protected boolean isResizable() {
810	return true;
811	}
812
813	/*
814	* (non-Javadoc)
815	*
816	* @see org.eclipse.jface.dialogs.Dialog#okPressed()
817	*/
818	protected void okPressed() {
819	super.okPressed();
820	}
821
822	/**
823	* @return Returns the limitValue.
824	*/
825	public int getLimitValue() {
826	return limitValue;
827	}
828
829	/**
830	* @param limitValue
831	* The limitValue to set.
832	*/
833	void setLimitValue(int limitValue) {
834	this.limitValue = limitValue;
835	}
836
837	/**	624	/**
838	* @return List of visible columns	625	* @return List of visible columns
839	*/	626	*/

Added Link Here

(-)src/org/eclipse/ui/internal/views/markers/ViewerSettingsAndStatusDialog.java (+300 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
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	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.views.markers;
13
14	import org.eclipse.core.runtime.IStatus;
15	import org.eclipse.jface.dialogs.Dialog;
16	import org.eclipse.jface.resource.JFaceResources;
17	import org.eclipse.swt.SWT;
18	import org.eclipse.swt.graphics.Color;
19	import org.eclipse.swt.graphics.Image;
20	import org.eclipse.swt.graphics.Point;
21	import org.eclipse.swt.layout.GridData;
22	import org.eclipse.swt.layout.GridLayout;
23	import org.eclipse.swt.widgets.Button;
24	import org.eclipse.swt.widgets.Composite;
25	import org.eclipse.swt.widgets.Control;
26	import org.eclipse.swt.widgets.Label;
27	import org.eclipse.swt.widgets.Shell;
28	import org.eclipse.swt.widgets.Text;
29	import org.eclipse.ui.preferences.ViewSettingsDialog;
30
31	/**
32	* @since 3.7
33	* @author Hitesh Soliwal
34	* @noextend This class is not intended to be subclassed by clients.
35	*/
36	public abstract class ViewerSettingsAndStatusDialog extends ViewSettingsDialog {
37
38	private Label imageLabel;
39	/** The message area */
40	private Text messageArea;
41	private Composite msgParent;
42
43	/**
44	* @param parentShell
45	*/
46	public ViewerSettingsAndStatusDialog(Shell parentShell) {
47	super(parentShell);
48	}
49
50	/*
51	* (non-Javadoc)
52	*
53	* @see
54	* org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets
55	* .Shell)
56	*/
57	protected void configureShell(Shell newShell) {
58	super.configureShell(newShell);
59	}
60
61	/*
62	* (non-Javadoc)
63	*
64	* @see org.eclipse.jface.window.Window#getShellStyle()
65	*/
66	protected int getShellStyle() {
67	return super.getShellStyle() \| SWT.RESIZE;
68	}
69
70	/*
71	* (non-Javadoc)
72	*
73	* @see org.eclipse.jface.dialogs.Dialog#getInitialSize()
74	*/
75	protected Point getInitialSize() {
76	Point size = super.getInitialSize();
77	size.y += convertHeightInCharsToPixels(3);
78	return size;
79	}
80
81	protected Control createDialogArea(Composite parent) {
82
83	Composite dialogArea = (Composite) super.createDialogArea(parent);
84
85	dialogArea.setLayout(new GridLayout(1, true));
86
87	initializeDialogUnits(dialogArea);
88
89	createMessageArea(dialogArea).setLayoutData(
90	new GridData(SWT.FILL, SWT.NONE, true, false));
91
92	createDialogContentArea(dialogArea).setLayoutData(
93	new GridData(SWT.FILL, SWT.FILL, true, true));
94
95	applyDialogFont(dialogArea);
96
97	initializeDialog();
98
99	return dialogArea;
100	}
101
102	/**
103	* @param dialogArea
104	*/
105	protected abstract Control createDialogContentArea(Composite dialogArea);
106
107	/**
108	*
109	*/
110	protected void initializeDialog() {
111	handleStatusUdpate(IStatus.INFO, getDefaultMessage());
112	}
113
114	/**
115	* Create message area.
116	*
117	* @param parent
118	*/
119	Control createMessageArea(Composite parent) {
120	msgParent = new Composite(parent, SWT.BORDER);
121	msgParent.setBackground(getMessageBackground());
122	msgParent.setLayout(new GridLayout(2, false));
123
124	imageLabel = new Label(msgParent, SWT.NONE);
125	imageLabel.setBackground(msgParent.getBackground());
126	imageLabel.setImage(JFaceResources
127	.getImage(Dialog.DLG_IMG_MESSAGE_INFO));
128	imageLabel
129	.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
130
131	messageArea = new Text(msgParent, SWT.READ_ONLY \| SWT.NONE \| SWT.WRAP
132	\| SWT.MULTI \| SWT.NO_FOCUS);
133	messageArea.setEditable(false);
134	messageArea.setBackground(msgParent.getBackground());
135	messageArea
136	.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
137	return msgParent;
138	}
139
140	/**
141	* Display the message and an appropriate icon.
142	*
143	* @param status
144	*/
145	protected void handleStatusUdpate(IStatus status) {
146	handleStatusUdpate(status.getSeverity(), status.getMessage());
147	}
148
149	/**
150	* Display the message and an appropriate icon.
151	*
152	* @param messgage
153	* @param severity
154	*/
155	protected void handleStatusUdpate(int severity, String messgage) {
156	Image image = null;
157	Button okBttn = getButton(OK);
158	switch (severity) {
159	case IStatus.ERROR: {
160	if (messgage == null) {
161	messgage = getErrorMessage();
162	}
163	image = getErrorImage();
164	break;
165	}
166	case IStatus.WARNING: {
167	image = getWarningImage();
168	break;
169	}
170	case IStatus.OK:
171	case IStatus.INFO:
172	default:
173	image = getInfoImage();
174	}
175	if (messgage == null) {
176	messgage = getDefaultMessage();
177	}
178	if (messgage.equals(MarkerSupportInternalUtilities.EMPTY_STRING)) {
179	handleMessageAreaVisibility(false);
180	image = null;
181	} else {
182	handleMessageAreaVisibility(true);
183	}
184	if (okBttn != null) {
185	okBttn.setEnabled(severity == IStatus.OK
186	\|\| severity == IStatus.INFO \|\| severity == IStatus.WARNING);
187	}
188	if (msgParent != null) {
189	setMessageImage(image);
190	setMessageText(messgage);
191	msgParent.layout();
192	}
193	}
194
195	/**
196	* @param image
197	*/
198	protected void setMessageImage(Image image) {
199	if (imageLabel != null) {
200	imageLabel.setImage(image);
201	}
202	}
203
204	/**
205	* @param messgage
206	*/
207	protected void setMessageText(String messgage) {
208	if (messageArea != null) {
209	messageArea.setText(messgage);
210	}
211	}
212
213	/**
214	*
215	*/
216	protected Image getMessageImage() {
217	if (imageLabel != null) {
218	imageLabel.getImage();
219	}
220	return null;
221	}
222
223	/**
224	*/
225	protected String getMessageText() {
226	if (messageArea != null) {
227	return messageArea.getText();
228	}
229	return null;
230	}
231
232	/**
233	*
234	* @param visible
235	*/
236	protected void handleMessageAreaVisibility(boolean visible) {
237	if (msgParent == null \|\| msgParent.isDisposed()) {
238	return;
239	}
240	GridData data = (GridData) msgParent.getLayoutData();
241	if (data.exclude == visible) {
242	data.exclude = !visible;
243	msgParent.setVisible(visible);
244	msgParent.getParent().layout();
245	}
246	}
247
248	/**
249	* Return the Color to display when dialog is opened.
250	*/
251	protected Color getMessageBackground() {
252	return getShell().getDisplay()
253	.getSystemColor(SWT.COLOR_LIST_BACKGROUND);
254	}
255
256	/**
257	* Return the message to display when dialog is opened.
258	*/
259	protected String getDefaultMessage() {
260	return MarkerSupportInternalUtilities.EMPTY_STRING;
261	}
262
263	/**
264	* @return Returns the error message to display for a wrong limit value.
265	*/
266	protected String getErrorMessage() {
267	return JFaceResources.getString("StringFieldEditor.errorMessage"); //$NON-NLS-1$
268	}
269
270	/**
271	*/
272	protected Image getInfoImage() {
273	return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_INFO);
274	}
275
276	/**
277	*/
278	protected Image getWarningImage() {
279	return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_WARNING);
280	}
281
282	/**
283	*/
284	protected Image getErrorImage() {
285	return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_ERROR);
286	}
287
288	protected void performDefaults() {
289	super.performDefaults();
290	}
291
292	protected boolean isResizable() {
293	return true;
294	}
295
296	protected void okPressed() {
297	super.okPressed();
298	}
299
300	}

Lines 206-212 Link Here

(-)src/org/eclipse/ui/views/markers/internal/MarkerMessages.java (-3 / +2 lines)
206	public static String MarkerFilterDialog_title;	206	public static String MarkerFilterDialog_title;
207	public static String MarkerFilterDialog_message;	207	public static String MarkerFilterDialog_message;
208	public static String MarkerFilterDialog_emptyMessage;	208	public static String MarkerFilterDialog_emptyMessage;
209		209	public static String MarkerFilterDialog_YouHaveDisabledMarkerLimit;
210	public static String MarkerFilterDialog_errorTitle;	210	public static String MarkerFilterDialog_errorTitle;
211	public static String MarkerFilterDialog_failedFilterMessage;	211	public static String MarkerFilterDialog_failedFilterMessage;
212		212
Lines 219-226 Link Here
219	public static String MarkerPreferences_VisibleColumnsTitle;	219	public static String MarkerPreferences_VisibleColumnsTitle;
220	public static String MarkerPreferences_HiddenColumnsTitle;	220	public static String MarkerPreferences_HiddenColumnsTitle;
221	public static String MarkerPreferences_AtLeastOneVisibleColumn;	221	public static String MarkerPreferences_AtLeastOneVisibleColumn;
222	public static String MarkerPreferences_ZeroOrBlankValueCanBeUsedToDisableTheLimit;	222
223
224	public static String ProblemFilterDialog_System_Filters_Title;	223	public static String ProblemFilterDialog_System_Filters_Title;
225	public static String ProblemFilterDialog_All_Problems;	224	public static String ProblemFilterDialog_All_Problems;
226	public static String ProblemFilterDialog_Selected_Types;	225	public static String ProblemFilterDialog_Selected_Types;