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