Attachment #183471 for bug #231081




               mnemonic="%command.configureColumns.mnemonic"
               style="push">
         </command>
         <command
               commandId="org.eclipse.ui.window.preferences"
               label="%command.preferences.label"
               mnemonic="%command.preferences.mnemonic"
               style="push">
            <parameter
                  name="preferencePageId"
                  value="org.eclipse.ui.ide.markers">
            </parameter>
         </command>
      </menuContribution>
      <menuContribution
            locationURI="menu:org.eclipse.ui.views.TaskList">

               mnemonic="%command.configureColumns.mnemonic"
               style="push">
         </command>
         <command
               commandId="org.eclipse.ui.window.preferences"
               label="%command.preferences.label"
               mnemonic="%command.preferences.mnemonic"
               style="push">
            <parameter
                  name="preferencePageId"
                  value="org.eclipse.ui.ide.markers">
            </parameter>
         </command>
      </menuContribution>
      <menuContribution
            locationURI="menu:org.eclipse.ui.views.BookmarkView">

               mnemonic="%command.configureColumns.mnemonic"
               style="push">
         </command>
         <command
               commandId="org.eclipse.ui.window.preferences"
               label="%command.preferences.label"
               mnemonic="%command.preferences.mnemonic"
               style="push">
            <parameter
                  name="preferencePageId"
                  value="org.eclipse.ui.ide.markers">
            </parameter>
         </command>
      </menuContribution>
      <menuContribution
            locationURI="menu:org.eclipse.ui.views.AllMarkersView">

               mnemonic="%command.configureColumns.mnemonic"
               style="push">
         </command>
         <command
               commandId="org.eclipse.ui.window.preferences"
               label="%command.preferences.label"
               mnemonic="%command.preferences.mnemonic"
               style="push">
            <parameter
                  name="preferencePageId"
                  value="org.eclipse.ui.ide.markers">
            </parameter>
         </command>
      </menuContribution>
   </extension>
   <extension

            </iterate>
         </enabledWhen>
      </handler>
      <handler
            class="org.eclipse.ui.internal.views.markers.MarkerPreferencesHandler"
            commandId="org.eclipse.ui.window.preferences">
         <activeWhen>
            <with
                  variable="activePart">
               <instanceof
                     value="org.eclipse.ui.views.markers.MarkerSupportView">
               </instanceof>
            </with>
         </activeWhen>
      </handler>
   </extension>
   <extension
         point="org.eclipse.core.expressions.propertyTesters">

Lines 12-18 Link Here

(-)src/org/eclipse/ui/internal/views/markers/ConfigureColumnsHandler.java (-2 / +1 lines)
12		12
13	import org.eclipse.core.commands.ExecutionEvent;	13	import org.eclipse.core.commands.ExecutionEvent;
14	import org.eclipse.core.commands.IHandler;	14	import org.eclipse.core.commands.IHandler;
15	import org.eclipse.jface.util.ConfigureColumns;
16	import org.eclipse.ui.views.markers.MarkerViewHandler;	15	import org.eclipse.ui.views.markers.MarkerViewHandler;
17		16
18	/**	17	/**
Lines 33-39 Link Here
33	ExtendedMarkersView view = getView(event);	32	ExtendedMarkersView view = getView(event);
34	if (view == null)	33	if (view == null)
35	return this;	34	return this;
36	ConfigureColumns.forTree(view.getViewer().getTree(), view.getSite());	35	new MarkersViewSettingDialog(view).open();
37	return this;	36	return this;
38	}	37	}
39		38

Lines 117-127 Link Here

(-)src/org/eclipse/ui/internal/views/markers/ExtendedMarkersView.java (-32 / +54 lines)
117	*/	117	*/
118	public final Object MARKERSVIEW_UPDATE_JOB_FAMILY = new Object();	118	public final Object MARKERSVIEW_UPDATE_JOB_FAMILY = new Object();
119		119
		120	static final String MARKER_FIELD = "MARKER_FIELD"; //$NON-NLS-1$
		121
120	private static int instanceCount = 1;	122	private static int instanceCount = 1;
121	private static final String TAG_GENERATOR = "markerContentGenerator"; //$NON-NLS-1$	123	private static final String TAG_GENERATOR = "markerContentGenerator"; //$NON-NLS-1$
122		124
123	private static final String MARKER_FIELD = "MARKER_FIELD"; //$NON-NLS-1$
124
125	private static final String TAG_EXPANDED = "expanded"; //$NON-NLS-1$	125	private static final String TAG_EXPANDED = "expanded"; //$NON-NLS-1$
126		126
127	private static final String TAG_CATEGORY = "category"; //$NON-NLS-1$	127	private static final String TAG_CATEGORY = "category"; //$NON-NLS-1$
Lines 240-246 Link Here
240	/\| SWT.VIRTUAL /\| SWT.V_SCROLL \| SWT.MULTI \| SWT.FULL_SELECTION));	240	/\| SWT.VIRTUAL /\| SWT.V_SCROLL \| SWT.MULTI \| SWT.FULL_SELECTION));
241	viewer.getTree().setLinesVisible(true);	241	viewer.getTree().setLinesVisible(true);
242	viewer.setUseHashlookup(true);	242	viewer.setUseHashlookup(true);
243	createColumns(new TreeColumn[0]);	243	createColumns(new TreeColumn[0], new int[0]);
244	viewer.setContentProvider(getContentProvider());	244	viewer.setContentProvider(getContentProvider());
245	}	245	}
246		246
Lines 249-270 Link Here
249	*	249	*
250	* @param currentColumns	250	* @param currentColumns
251	* the columns to refresh	251	* the columns to refresh
		252	* @param widths
252	*/	253	*/
253	private void createColumns(TreeColumn[] currentColumns) {	254	private void createColumns(TreeColumn[] currentColumns, int[] widths) {
254		255
255	Tree tree = viewer.getTree();	256	Tree tree = viewer.getTree();
256	TableLayout layout = new TableLayout();	257	TableLayout layout = new TableLayout();
257		258
258	MarkerField[] fields = generator.getVisibleFields();	259	MarkerField[] fields = generator.getVisibleFields();
259		260
260	IMemento columnWidths = null;
261	if (memento != null)
262	columnWidths = memento.getChild(TAG_COLUMN_WIDTHS);
263
264	for (int i = 0; i < fields.length; i++) {	261	for (int i = 0; i < fields.length; i++) {
265	MarkerField markerField = fields[i];	262	MarkerField markerField = fields[i];
266		263	TreeViewerColumn column = null;
267	TreeViewerColumn column;
268	if (i < currentColumns.length)	264	if (i < currentColumns.length)
269	column = new TreeViewerColumn(viewer, currentColumns[i]);	265	column = new TreeViewerColumn(viewer, currentColumns[i]);
270	else {	266	else {
Lines 289-315 Link Here
289	if (builder.getPrimarySortField().equals(markerField))	285	if (builder.getPrimarySortField().equals(markerField))
290	updateDirectionIndicator(column.getColumn(), markerField);	286	updateDirectionIndicator(column.getColumn(), markerField);
291		287
292	int columnWidth = -1;	288	IMemento columnWidths = null;
293		289	if (memento != null){
294	if (i == 0) {	290	columnWidths = memento.getChild(TAG_COLUMN_WIDTHS);
295	// Compute and store a font metric
296	GC gc = new GC(tree);
297	gc.setFont(tree.getFont());
298	FontMetrics fontMetrics = gc.getFontMetrics();
299	gc.dispose();
300	columnWidth = Math.max(markerField.getDefaultColumnWidth(tree),
301	fontMetrics.getAverageCharWidth() * 5);
302	}	291	}
303		292	int columnWidth = -1;
304	if (columnWidths != null) {	293	if(i < widths.length){
305	Integer value = columnWidths.getInteger(getFieldId(column	294	columnWidth = widths[i];
306	.getColumn()));	295	if (columnWidths != null) {
307		296	//save it
308	// Make sure we get a useful value	297	columnWidths.putInteger(markerField.getConfigurationElement().getAttribute(
309	if (value != null && value.intValue() > 0)	298	MarkerSupportInternalUtilities.ATTRIBUTE_ID), columnWidth);
310	columnWidth = value.intValue();	299	}
		300	}else{
		301	columnWidth = getFieldWidth(markerField, columnWidth);
311	}	302	}
312
313	// Take trim into account if we are using the default value, but not	303	// Take trim into account if we are using the default value, but not
314	// if it is restored.	304	// if it is restored.
315	if (columnWidth < 0)	305	if (columnWidth < 0)
Lines 324-330 Link Here
324	if (currentColumns.length > fields.length) {	314	if (currentColumns.length > fields.length) {
325	for (int i = fields.length; i < currentColumns.length; i++) {	315	for (int i = fields.length; i < currentColumns.length; i++) {
326	currentColumns[i].dispose();	316	currentColumns[i].dispose();
327
328	}	317	}
329	}	318	}
330		319
Lines 334-339 Link Here
334	tree.layout(true);	323	tree.layout(true);
335		324
336	}	325	}
		326
		327	int getFieldWidth(MarkerField markerField, int columnWidth) {
		328	Tree tree = getViewer().getTree();
		329
		330	if (columnWidth < 0 && memento != null) {
		331	IMemento columnWidths = memento.getChild(TAG_COLUMN_WIDTHS);
		332	if (columnWidths != null) {
		333	Integer value = columnWidths.getInteger(markerField
		334	.getConfigurationElement().getAttribute(
		335	MarkerSupportInternalUtilities.ATTRIBUTE_ID));
		336	// Make sure we get a useful value
		337	if (value != null && value.intValue() > 0)
		338	columnWidth = value.intValue();
		339	}
		340	}
		341	if (columnWidth <= 0) {
		342	// Compute and store a font metric
		343	GC gc = new GC(tree);
		344	gc.setFont(tree.getFont());
		345	FontMetrics fontMetrics = gc.getFontMetrics();
		346	gc.dispose();
		347	columnWidth = Math.max(markerField.getDefaultColumnWidth(tree),
		348	fontMetrics.getAverageCharWidth() * 5);
		349	}
		350	TreeColumn[] columns = tree.getColumns();
		351	for (int i = 0; i < columns.length; i++) {
		352	if (MARKER_FIELD.equals(columns[i].getData(MARKER_FIELD))) {
		353	columnWidth = Math.max(columnWidth, columns[i].getWidth());
		354	return columnWidth;
		355	}
		356	}
		357	return columnWidth;
		358	}
337		359
338	/*	360	/*
339	* (non-Javadoc)	361	* (non-Javadoc)
Lines 1460-1470 Link Here
1460	/**	1482	/**
1461	* @param visible	1483	* @param visible
1462	*/	1484	*/
1463	void setVisibleFields(Collection visible) {	1485	void setVisibleFields(Collection visible,int[] widths) {
1464	generator.setVisibleFields(visible);	1486	generator.setVisibleFields(visible);
1465	//viewer.setSelection(new StructuredSelection());	1487	//viewer.setSelection(new StructuredSelection());
1466	//viewer.removeAndClearAll();	1488	//viewer.removeAndClearAll();
1467	createColumns(viewer.getTree().getColumns());	1489	createColumns(viewer.getTree().getColumns(), widths);
1468	scheduleUpdate(0L);	1490	scheduleUpdate(0L);
1469	}	1491	}
1470		1492




/*******************************************************************************
 * Copyright (c) 2008, 2009 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 java.util.ArrayList;
import java.util.List;

import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.preference.IntegerFieldEditor;
import org.eclipse.jface.resource.JFaceColors;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.ListViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
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.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
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.MarkerField;
import org.eclipse.ui.views.markers.internal.MarkerMessages;

/**
 * MarkerPreferencesDialog is the dialog for showing marker preferences.
 * 
 * @since 3.4
 * 
 */
public class MarkerPreferencesDialog extends ViewSettingsDialog {

	private IntegerFieldEditor limitEditor;

	private Button enablementButton;

	private Composite editArea;

	private Label messageLabel;

	private ExtendedMarkersView extendedView;

	private ArrayList visible;

	private ArrayList hidden;

	private ListViewer visibleViewer;

	private ListViewer nonVisibleViewer;

	/**
	 * Create a new instance of the receiver.
	 * 
	 * @param view -
	 *            the view this is being launched from
	 */
	public MarkerPreferencesDialog(ExtendedMarkersView view) {
		super(view.getSite().getShell());
		this.extendedView = view;

		Object[] visibleFields = view.getVisibleFields();
		Object[] hiddenFields = view.getHiddenFields();

		visible = new ArrayList();
		hidden = new ArrayList();

		for (int i = 0; i < visibleFields.length; i++) {
			visible.add(visibleFields[i]);
		}

		for (int i = 0; i < hiddenFields.length; i++) {
			hidden.add(hiddenFields[i]);
		}
	}

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

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

		boolean checked = IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getBoolean(IDEInternalPreferences.USE_MARKER_LIMITS);
		enablementButton = new Button(dialogArea, SWT.CHECK);
		enablementButton.setText(MarkerMessages.MarkerPreferences_MarkerLimits);
		enablementButton.setSelection(checked);

		editArea = new Composite(dialogArea, SWT.NONE);
		editArea.setLayout(new GridLayout());
		GridData editData = new GridData(GridData.FILL_BOTH
				| GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL);
		editData.horizontalIndent = 10;
		editArea.setLayoutData(editData);

		limitEditor = new IntegerFieldEditor(
				"limit", MarkerMessages.MarkerPreferences_VisibleItems, editArea) { //$NON-NLS-1$
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.jface.preference.IntegerFieldEditor#checkState()
			 */
			protected boolean checkState() {
				boolean state = super.checkState();
				setValid(state, getErrorMessage());
				return state;
			}
		};
		limitEditor.setPreferenceStore(IDEWorkbenchPlugin.getDefault()
				.getPreferenceStore());
		limitEditor
				.setPreferenceName(IDEInternalPreferences.MARKER_LIMITS_VALUE);
		limitEditor.load();

		GridData checkedData = new GridData(SWT.FILL, SWT.NONE, true, false);
		checkedData.horizontalSpan = limitEditor.getNumberOfControls();
		enablementButton.setLayoutData(checkedData);

		enablementButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				setLimitEditorEnablement(editArea, enablementButton
						.getSelection());
			}
		});

		setLimitEditorEnablement(editArea, checked);

		messageLabel = new Label(dialogArea, SWT.NONE);

		messageLabel.setBackground(JFaceColors.getErrorBackground(dialogArea
				.getDisplay()));
		messageLabel.setForeground(JFaceColors.getErrorText(dialogArea
				.getDisplay()));
		messageLabel
				.setLayoutData(new GridData(SWT.FILL, SWT.NONE, true, false));

		createColumnsArea(dialogArea);

		applyDialogFont(dialogArea);
		return dialogArea;
	}

	/**
	 * Create an area for the selected columns
	 * 
	 * @param dialogArea
	 */
	private void createColumnsArea(Composite dialogArea) {

		initializeDialogUnits(dialogArea);
		Group columnsComposite = new Group(dialogArea, SWT.NONE);
		columnsComposite.setText(MarkerMessages.MarkerPreferences_ColumnGroupTitle);
		FormLayout layout = new FormLayout();
		columnsComposite.setLayout(layout);

		columnsComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,
				true));
		Label visibleItemsLabel = new Label(columnsComposite, SWT.NONE);
		visibleItemsLabel.setText(MarkerMessages.MarkerPreferences_VisibleColumnsTitle);
		FormData visibleLabelData = new FormData();
		visibleLabelData.right = new FormAttachment(45, 0);
		visibleLabelData.left = new FormAttachment(
				IDialogConstants.BUTTON_MARGIN);
		visibleLabelData.top = new FormAttachment(0);
		visibleItemsLabel.setLayoutData(visibleLabelData);

		int rightMargin = IDialogConstants.BUTTON_MARGIN * -1;

		Label nonVisibleLabel = new Label(columnsComposite, SWT.NONE);
		nonVisibleLabel.setText(MarkerMessages.MarkerPreferences_HiddenColumnsTitle);
		FormData nonVisibleLabelData = new FormData();
		nonVisibleLabelData.right = new FormAttachment(100);
		nonVisibleLabelData.left = new FormAttachment(55, 0);
		nonVisibleLabelData.top = new FormAttachment(0);
		nonVisibleLabel.setLayoutData(nonVisibleLabelData);

		visibleViewer = new ListViewer(columnsComposite,
				SWT.BORDER);

		FormData visibleViewerData = new FormData();
		visibleViewerData.right = new FormAttachment(visibleItemsLabel, 0,
				SWT.RIGHT);
		visibleViewerData.left = new FormAttachment(visibleItemsLabel, 0,
				SWT.LEFT);
		visibleViewerData.top = new FormAttachment(visibleItemsLabel,
				IDialogConstants.BUTTON_MARGIN);
		visibleViewerData.bottom = new FormAttachment(100, rightMargin);
		visibleViewerData.height = convertHeightInCharsToPixels(15);
		visibleViewerData.width = convertWidthInCharsToPixels(25);

		visibleViewer.getControl().setLayoutData(visibleViewerData);

		visibleViewer.setContentProvider(new IStructuredContentProvider() {

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

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
			 */
			public void dispose() {
			}

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

		});

		visibleViewer.setLabelProvider(markerFieldLabelProvider());

		visibleViewer.setInput(this);

		nonVisibleViewer = new ListViewer(columnsComposite,
				SWT.BORDER);

		nonVisibleViewer.setLabelProvider(markerFieldLabelProvider());

		nonVisibleViewer.setContentProvider(new IStructuredContentProvider() {

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

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
			 */
			public void dispose() {
			}

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

		});
		nonVisibleViewer.setInput(this);

		FormData nonVisibleViewerData = new FormData();
		nonVisibleViewerData.right = new FormAttachment(nonVisibleLabel, 0,
				SWT.RIGHT);
		nonVisibleViewerData.left = new FormAttachment(nonVisibleLabel, 0,
				SWT.LEFT);
		nonVisibleViewerData.top = new FormAttachment(nonVisibleLabel,
				IDialogConstants.BUTTON_MARGIN);
		nonVisibleViewerData.bottom = new FormAttachment(100, rightMargin);
		nonVisibleViewerData.height = convertHeightInCharsToPixels(15);
		nonVisibleViewerData.width = convertWidthInCharsToPixels(25);

		nonVisibleViewer.getControl().setLayoutData(nonVisibleViewerData);

		Button toNonVisibleButton = new Button(columnsComposite, SWT.PUSH);
		toNonVisibleButton
				.setText(getDefaultOrientation() == SWT.RIGHT_TO_LEFT ? MarkerMessages.MarkerPreferences_MoveLeft
						: MarkerMessages.MarkerPreferences_MoveRight);

		FormData toNonVisibleButtonData = new FormData();

		toNonVisibleButtonData.top = new FormAttachment(visibleViewer
				.getControl(), IDialogConstants.BUTTON_BAR_HEIGHT, SWT.TOP);
		toNonVisibleButtonData.left = new FormAttachment(visibleViewer
				.getControl(), IDialogConstants.BUTTON_MARGIN);
		toNonVisibleButtonData.right = new FormAttachment(nonVisibleViewer
				.getControl(), rightMargin);
		toNonVisibleButton.setLayoutData(toNonVisibleButtonData);

		toNonVisibleButton.addSelectionListener(new SelectionAdapter() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
			 */
			public void widgetSelected(SelectionEvent e) {
				List selection = ((IStructuredSelection) visibleViewer
						.getSelection()).toList();
				hidden.addAll(selection);
				visible.removeAll(selection);
				visibleViewer.refresh();
				nonVisibleViewer.refresh();
				setValid(
						visible.size() > 0,
						MarkerMessages.MarkerPreferences_AtLeastOneVisibleColumn);
			}
		});

		Button toVisibleButton = new Button(columnsComposite, SWT.PUSH);
		toVisibleButton
				.setText(getDefaultOrientation() == SWT.RIGHT_TO_LEFT ? MarkerMessages.MarkerPreferences_MoveRight
						: MarkerMessages.MarkerPreferences_MoveLeft);

		FormData toVisibleButtonData = new FormData();

		toVisibleButtonData.top = new FormAttachment(toNonVisibleButton,
				IDialogConstants.BUTTON_MARGIN);
		toVisibleButtonData.left = new FormAttachment(visibleViewer
				.getControl(), IDialogConstants.BUTTON_MARGIN);
		toVisibleButtonData.right = new FormAttachment(nonVisibleViewer
				.getControl(), rightMargin);
		toVisibleButton.setLayoutData(toVisibleButtonData);

		toVisibleButton.addSelectionListener(new SelectionAdapter() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
			 */
			public void widgetSelected(SelectionEvent e) {
				List selection = ((IStructuredSelection) nonVisibleViewer
						.getSelection()).toList();
				hidden.removeAll(selection);
				visible.addAll(selection);
				visibleViewer.refresh();
				nonVisibleViewer.refresh();
				setValid(
						visible.size() > 0,
						MarkerMessages.MarkerPreferences_AtLeastOneVisibleColumn);
			}
		});

	}

	/**
	 * Return a label provider for fields.
	 * @return LabelProvider
	 */
	private LabelProvider markerFieldLabelProvider() {
		return new LabelProvider() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
			 */
			public String getText(Object element) {
				return ((MarkerField) element).getName();
			}
		};
	}

	/**
	 * Set the enabled state of the OK button by state.
	 * 
	 * @param state
	 */
	protected void setValid(boolean state, String errorMessage) {
		Button okButton = getButton(IDialogConstants.OK_ID);

		if (okButton == null)
			return;

		if (state)
			messageLabel.setText(MarkerSupportInternalUtilities.EMPTY_STRING);
		else
			messageLabel.setText(errorMessage);

		okButton.setEnabled(state);

	}

	/**
	 * Enable the limitEditor based on checked.
	 * 
	 * @param control
	 *            The parent of the editor
	 * @param checked
	 */
	private void setLimitEditorEnablement(Composite control, boolean checked) {
		limitEditor.setEnabled(checked, control);
	}

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

		limitEditor.store();
		IDEWorkbenchPlugin.getDefault().getPreferenceStore().setValue(
				IDEInternalPreferences.USE_MARKER_LIMITS,
				enablementButton.getSelection());
		IDEWorkbenchPlugin.getDefault().savePluginPreferences();

		extendedView.setVisibleFields(visible);

		super.okPressed();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.preferences.ViewSettingsDialog#performDefaults()
	 */
	protected void performDefaults() {
		super.performDefaults();
		limitEditor.loadDefault();
		boolean checked = IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getDefaultBoolean(IDEInternalPreferences.USE_MARKER_LIMITS);
		enablementButton.setSelection(checked);
		setLimitEditorEnablement(editArea, checked);

		Object[] visibleFields=extendedView.getBuilder().getGenerator().getInitialVisible();
		Object[] allFields=extendedView.getBuilder().getGenerator().getAllFields();
		visible.clear();
		hidden.clear();
		for (int i = 0; i < allFields.length; i++) {
			hidden.add(allFields[i]);
		}
		for (int i = 0; i < visibleFields.length; i++) {
			hidden.remove(visibleFields[i]);
			visible.add(visibleFields[i]);
		}
		visibleViewer.refresh();
		nonVisibleViewer.refresh();
	}

}




/*******************************************************************************
 * Copyright (c) 2005, 2008 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.commands.ExecutionEvent;
import org.eclipse.core.commands.IHandler;
import org.eclipse.ui.views.markers.MarkerViewHandler;

/**
 * MarkerPreferencesHandler is the handler for opening the marker preferences dialog.
 * @since 3.4
 *
 */
public class MarkerPreferencesHandler extends MarkerViewHandler implements
		IHandler {

	/* (non-Javadoc)
	 * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
	 */
	public Object execute(ExecutionEvent event) {
		
		ExtendedMarkersView view = getView(event);
		if(view == null)
			return this;
		
		new MarkerPreferencesDialog(view).open();
		return this;
	}

}




	 */
	static int getMarkerLimit() {

		int value = IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getInt(IDEInternalPreferences.MARKER_LIMITS_VALUE);
		if (value <= 0) {
			return -1;
					IDEInternalPreferences.MARKER_LIMITS_VALUE);

		}
		return value;

	}

	/**




import org.eclipse.ui.views.markers.internal.MarkerMessages;

/**
 * The Markers object contains the MarkerEntry(s) collected and updated by the
 * system, also maintains the categories that markers are grouped into.
 * 
 * @since 3.6
 * 
 */

	static final MarkerCategory[] EMPTY_CATEGORY_ARRAY = new MarkerCategory[0];
	static final MarkerEntry[] EMPTY_ENTRY_ARRAY = new MarkerEntry[0];

	// the marker entries
	private MarkerEntry[] markerEntryArray = EMPTY_ENTRY_ARRAY;
	// the categories
	private MarkerCategory[] categories = EMPTY_CATEGORY_ARRAY;

	
	private CachedMarkerBuilder builder;

	private boolean inChange = false;

	// markerToEntryMap is a lazily created map from the markers to thier
	// corresponding entry
	private Map markerToEntryMap = null;
	private Integer[] markerCounts;


	Markers(CachedMarkerBuilder builder) {
		this.builder = builder;
		inChange = false;
	}

	/**
	 * Update with newly collected markers
	 * 
	 * @param markerEntries
	 *            the new marker entries
	 * @param sortAndGroup
	 *            true sort and group them
	 * @param monitor
	 */
	synchronized boolean updateWithNewMarkers(Collection markerEntries,
			boolean sortAndGroup, IProgressMonitor monitor) {
		boolean initialVal = inChange;
		try {
			inChange = true;
			if (markerToEntryMap != null) {
				markerToEntryMap.clear();
				markerToEntryMap = null;

			}
			return true;
		} finally {
			inChange = initialVal;
		}
	}


	 * @param monitor
	 */
	synchronized boolean sortAndMakeCategories(IProgressMonitor monitor) {
		boolean initialVal = inChange;
		try {
			inChange = true;
			// Sort by Category first
			if (builder.isShowingHierarchy()) {
				MarkerCategory[] markerCategories = groupIntoCategories(


			return sortMarkerEntries(monitor);
		} finally {
			inChange = initialVal;
		}
	}


		if (monitor.isCanceled()) {
			return false;
		}
		boolean initialVal = inChange;
		try {
			inChange = true;
			if (builder.isShowingHierarchy()) {
				Comparator comparator = builder.getComparator()
						.getFieldsComparator();

				}
				int avaialble = markerEntryArray.length - 1;
				int effLimit = getShowingLimit(avaialble);
				MarkerSortUtil.sortStartingKElement(markerEntryArray,
						builder.getComparator(), effLimit, monitor);
			}
			if (monitor.isCanceled()) {
				return false;

			monitor.worked(50);
			return true;
		} finally {
			inChange = initialVal;
		}
	}

	/**
	 * get marker limit to show, if any.
	 * 
	 * @param avaliable
	 */
	private int getShowingLimit(int avaliable) {
		int limit = MarkerSupportInternalUtilities.getMarkerLimit();
		int effLimit = limit;
		if (avaliable < effLimit || limit <= 0) {
			effLimit = avaliable;
		}
		return effLimit;

	 */
	MarkerCategory[] groupIntoCategories(IProgressMonitor monitor,
			MarkerEntry[] newMarkers) {
		Map boundaryInfoMap = groupMarkerEntries(newMarkers,
				builder.getCategoryGroup(), newMarkers.length - 1, monitor);
		Iterator iterator = boundaryInfoMap.keySet().iterator();
		int start = 0;
		MarkerCategory[] markerCategories = new MarkerCategory[boundaryInfoMap

			Object key = iterator.next();
			end = ((Integer) boundaryInfoMap.get(key)).intValue();
			markerCategories[i++] = new MarkerCategory(this, start, end,
					builder.getCategoryGroup().getMarkerField()
							.getValue(newMarkers[start]));
			start = end + 1;
		}
		return markerCategories;

	 * @return {@link Map}
	 * 
	 */
	private Map groupMarkerEntries(MarkerEntry[] entries, MarkerGroup group,
			int k, IProgressMonitor monitor) {
		TreeMap map = new TreeMap(group.getEntriesComparator());
		for (int i = 0; i <= k; i++) {
			IMarker marker = entries[i].getMarker();
			if (marker == null) {
				continue;// skip stale markers
			}
			if (monitor.isCanceled()) {
				map.clear();
				return map;
			}
			try {
				MarkerGroupingEntry groupingEntry = group.findGroupValue(
						marker.getType(), marker);
				List list = (List) map.get(groupingEntry);
				if (list == null) {
					list = new ArrayList();

		Iterator keys = map.keySet().iterator();
		int i = 0;
		while (keys.hasNext()) {
			if (monitor.isCanceled()) {
				map.clear();
				return map;
			}

	 */
	Integer[] getMarkerCounts() {
		if (markerCounts == null) {
			markerCounts = getMarkerCounts(markerEntryArray);

		}
		return markerCounts;
	}

	/**
	 * Returns an array of marker counts for the given MarkerEntry array , where
	 * getMarkerCounts()[severity] is the number of markers in the list with the
	 * given severity.
	 * 
	 * @return an array of {@link Integer} where index indicates
	 *         [errors,warnings,infos,others]

	 * @return MarkerSupportItem[]
	 */
	public MarkerSupportItem[] getElements() {
		if (builder.isShowingHierarchy()) {
			return categories;
		}
		return markerEntryArray;

	CachedMarkerBuilder getBuilder() {
		return builder;
	}

	/**
	 * Use clone where thread safety is concerned. The method is non-blocking.
	 * The method is non-blocking.
	 */
	Markers getClone() {
		Markers markers = new Markers(builder);

		return inChange;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#hashCode()
	 */
	public int hashCode() {

		return result;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object obj) {




/*******************************************************************************
 * Copyright (c) 2008, 2009 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 java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.swt.SWT;
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;
import org.eclipse.ui.views.markers.internal.MarkerMessages;

/**
 * MarkersViewSettingDialog is the dialog for showing marker preferences.
 * 
 * 
 * @since 3.7
 * @author Hitesh Soliwal
 * 
 */
public class MarkersViewSettingDialog extends ViewerColumnsDialog {

	private ExtendedMarkersView extendedView;

	/**
	 * Create a new instance of the receiver.
	 * 
	 * @param view
	 *            - the view this is being launched from
	 */
	public MarkersViewSettingDialog(ExtendedMarkersView view) {
		super(view.getSite().getShell());
		this.extendedView = view;
		initialize(convert(extendedView.getBuilder().getGenerator()
				.getVisibleFields()), convert(extendedView.getBuilder()
				.getGenerator().getAllFields()), false);
		setLimitValue(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getInt(IDEInternalPreferences.MARKER_LIMITS_VALUE));
	}

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

	/*
	 * (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) {
		Control control = super.createDialogArea(parent);
		return control;
	}

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

	/**
	 */
	private int[] getNewWidths() {
		List visible = getVisible();
		int[] widths = new int[visible.size()];
		int i = 0;
		Iterator iterator = visible.iterator();
		while (iterator.hasNext()) {
			widths[i++] = ((FieldEntry) iterator.next()).width;
		}
		return widths;

	}

	private Collection getVisibleFields() {
		List visible = getVisible();
		List list = new ArrayList(visible.size());
		Iterator iterator = visible.iterator();
		while (iterator.hasNext()) {
			list.add(((FieldEntry) iterator.next()).field);
		}
		return list;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.preferences.ViewSettingsDialog#performDefaults()
	 */
	protected void performDefaults() {
		initialize(convert(extendedView.getBuilder().getGenerator()
				.getInitialVisible()), convert(extendedView.getBuilder()
				.getGenerator().getAllFields()), true);
		setLimitValue(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
				.getDefaultInt(IDEInternalPreferences.MARKER_LIMITS_VALUE));
		super.performDefaults();
	}

	/**
	 * @param visibleFields
	 * @param allFields
	 */
	void initialize(FieldEntry[] visibleFields, FieldEntry[] allFields,
			boolean defaultWidths) {
		List visible = getVisible();
		List nonVisible = getNonVisible();
		visible.clear();
		nonVisible.clear();
		for (int i = 0; i < allFields.length; i++) {
			nonVisible.add(allFields[i]);
		}
		for (int i = 0; i < visibleFields.length; i++) {
			nonVisible.remove(visibleFields[i]);
			visible.add(visibleFields[i]);
			visibleFields[i].visible = true;
			if (defaultWidths) {
				visibleFields[i].width = extendedView.getFieldWidth(
						visibleFields[i].field, 0);
			} else {
				// from a persistent store
				visibleFields[i].width = extendedView.getFieldWidth(
						visibleFields[i].field, -1);
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ui.internal.views.markers.ViewerColumnsDialog#getLabelProvider
	 * ()
	 */
	protected ITableLabelProvider getLabelProvider() {
		return new TableLabelProvider() {
			public String getText(Object element) {
				return ((FieldEntry) element).field.getName();
			}
		};
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.internal.views.markers.ViewerColumnsDialog#
	 * getColumnInfoProvider()
	 */
	protected IColumnInfoProvider getColumnInfoProvider() {

		return new IColumnInfoProvider() {
			public int getColumnIndex(Object columnObj) {
				return getVisible().indexOf(columnObj);
			}

			public int getColumnWidth(Object columnObj) {
				FieldEntry field = (FieldEntry) columnObj;
				return extendedView.getFieldWidth(field.field, field.width);
			}

			public boolean isColumnVisible(Object columnObj) {
				return ((FieldEntry) columnObj).visible;
			}

			public boolean isColumnMovable(Object columnObj) {
				return true;
			}

			public boolean isColumnResizable(Object columnObj) {
				return true;
			}
		};
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ui.internal.views.markers.ViewerColumnsDialog#getColumnUpdater
	 * ()
	 */
	protected IColumnUpdater getColumnUpdater() {

		return new IColumnUpdater() {
			public void setColumnVisible(Object columnObj, boolean visible) {
				((FieldEntry) columnObj).visible = visible;
			}

			public void setColumnMovable(Object columnObj, boolean movable) {
				// not implemented
			}

			public void setColumnIndex(Object columnObj, int index) {
				// ignore
			}

			public void setColumnResizable(Object columnObj, boolean resizable) {
				// ignore
			}

			public void setColumnWidth(Object columnObj, int newWidth) {
				((FieldEntry) columnObj).width = newWidth;
			}
		};
	}

	private static FieldEntry[] convert(Object[] fields) {
		FieldEntry[] entries = new FieldEntry[fields.length];
		for (int i = 0; i < entries.length; i++) {
			entries[i] = new FieldEntry((MarkerField) fields[i], -1);
		}
		return entries;
	}

	static class FieldEntry {
		final MarkerField field;
		int width;
		boolean visible;

		FieldEntry(MarkerField field, int width) {
			this.field = field;
			this.width = width;
			visible = false;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see java.lang.Object#toString()
		 */
		public String toString() {
			// TODO Auto-generated method stub
			return super.toString();
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see java.lang.Object#hashCode()
		 */
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + ((field == null) ? 0 : field.hashCode());
			return result;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see java.lang.Object#equals(java.lang.Object)
		 */
		public boolean equals(Object obj) {
			if (this == obj) {
				return true;
			}
			if (obj == null) {
				return false;
			}
			if (!(obj instanceof FieldEntry)) {
				return false;
			}
			FieldEntry other = (FieldEntry) obj;
			if (field == null) {
				if (other.field != null) {
					return false;
				}
			} else if (!field.equals(other.field)) {
				return false;
			}
			return true;
		}
	}
}




/*******************************************************************************
 * 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 java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
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.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
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.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.Display;
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.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;

/**
 * This was introduced as a fix to Bug , as an effort to combine the columns and
 * preference dialogs into one. It should be noted that the class can be re-used
 * or turned into a tool for column viewers in general, but with some
 * modifications. See example attached at the end of this class
 * 
 * @since 3.7
 * 
 * @author Hitesh Soliwal
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * 
 */
abstract class ViewerColumnsDialog extends ViewSettingsDialog {

	/** 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, limitEditor;

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

		private String intialValue;

		public void handleEvent(Event event) {
			intialValue = intialValue != null ? intialValue : Integer
					.toString(0);
			intialValue = handleIntegerFieldChange(event, intialValue);
		}
	};

	/**
	 * Create a new instance of the receiver.
	 * 
	 * @param parentShell
	 */
	ViewerColumnsDialog(Shell parentShell) {
		super(parentShell);
	}

	/**
	 * Initialize visible /non-visible columns.
	 * 
	 * @param columnObjs
	 */
	void setColumnsObjs(Object[] columnObjs) {
		IColumnInfoProvider columnInfo = doGetColumnInfoProvider();
		IColumnUpdater updater = doGetColumnUpdater();
		List visible = getVisible();
		List nonVisible = getNonVisible();
		visible.clear();
		nonVisible.clear();
		Object data = null;
		for (int i = 0; i < columnObjs.length; i++) {
			data = columnObjs[i];
			if (columnInfo.isColumnVisible(data)) {
				updater.setColumnVisible(data, true);
				updater.setColumnIndex(data, visible.size());
				visible.add(data);
			} else {
				updater.setColumnVisible(data, false);
				updater.setColumnIndex(data, nonVisible.size());
				nonVisible.add(data);
			}
		}
	}

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

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

	/**
	 * 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
	 */
	void createColumnsArea(Composite dialogArea) {
		Group columnArea = new Group(dialogArea, SWT.NONE);
		columnArea.setLayout(new GridLayout(4, false));
		GridData gData = new GridData(GridData.FILL_BOTH
				| GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL);
		columnArea.setLayoutData(gData);
		columnArea.setText(MarkerMessages.MarkerPreferences_ColumnGroupTitle);

		createInvisibleTable(columnArea);
		createMoveButtons(columnArea);
		createVisibleTable(columnArea);
		createUpDownBtt(columnArea);
		createWidthArea(columnArea);
	}

	/**
	 * The Up and Down button to change column ordering.
	 * 
	 * @param parent
	 */
	void createUpDownBtt(Composite parent) {
		Composite composite = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout(1, true);
		layout.horizontalSpacing = 0;
		layout.marginRight = -1;
		layout.marginLeft = -1;
		layout.marginWidth = 0;
		composite.setLayout(layout);
		composite.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL
				| GridData.VERTICAL_ALIGN_END));
		upButton = new Button(composite, SWT.PUSH);
		upButton.setText(JFaceResources.getString("ConfigureColumnsDialog_up")); //$NON-NLS-1$
		upButton.addListener(SWT.Selection, new Listener() {
			public void handleEvent(Event event) {
				handleUpButton(event);
			}
		});
		upButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		upButton.setEnabled(false);

		downButton = new Button(composite, SWT.PUSH);
		downButton.setText(JFaceResources
				.getString("ConfigureColumnsDialog_down")); //$NON-NLS-1$
		downButton.addListener(SWT.Selection, new Listener() {
			public void handleEvent(Event event) {
				handleDownButton(event);
			}
		});
		downButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		downButton.setEnabled(false);
	}

	/**
	 * Create the controls responsible to display/edit column widths.
	 * 
	 * @param parent
	 */
	void createWidthArea(Composite parent) {
		Label widthLabel = new Label(parent, SWT.NONE);
		widthLabel.setText(JFaceResources
				.getString("ConfigureColumnsDialog_WidthOfSelectedColumn")); //$NON-NLS-1$
		GridData gridData = new GridData(GridData.FILL_HORIZONTAL
				| GridData.HORIZONTAL_ALIGN_END);
		gridData.horizontalSpan = 3;
		widthLabel.setLayoutData(gridData);

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

	/**
	 * Adapter to {@link IStructuredContentProvider}
	 */
	abstract class ContentProviderAdapter implements IStructuredContentProvider {

		public void dispose() {
		}

		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		}
	}

	/**
	 * Creates the table that lists out visible columns in the viewer
	 * 
	 * @param parent
	 */
	void 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);
		data.heightHint = table.getItemHeight() * 15;
		table.setLayoutData(data);
		table.setHeaderVisible(true);

		final TableColumn column = new TableColumn(table, SWT.NONE);
		column.setText(MarkerMessages.MarkerPreferences_VisibleColumnsTitle);
		Listener columnResize = new Listener() {
			public void handleEvent(Event event) {
				column.setWidth(table.getClientArea().width);
			}
		};
		table.addListener(SWT.Resize, columnResize);

		visibleViewer = new TableViewer(table);
		visibleViewer.setLabelProvider(doGetLabelProvider());
		visibleViewer.setContentProvider(new ContentProviderAdapter() {
			public Object[] getElements(Object inputElement) {
				return getVisible().toArray();
			}
		});
		visibleViewer
				.addSelectionChangedListener(new ISelectionChangedListener() {
					public void selectionChanged(SelectionChangedEvent event) {
						handleVisibleSelection(event.getSelection());
					}
				});
		table.addListener(SWT.MouseDoubleClick, new Listener() {
			public void handleEvent(Event event) {
				handleToNonVisibleButton(event);
			}
		});
		visibleViewer.setInput(this);
	}

	/**
	 * Creates the table that lists out non-visible columns in the viewer
	 * 
	 * @param parent
	 */
	void 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);
		data.heightHint = table.getItemHeight() * 15;
		table.setLayoutData(data);
		table.setHeaderVisible(true);

		final TableColumn column = new TableColumn(table, SWT.NONE);
		column.setText(MarkerMessages.MarkerPreferences_HiddenColumnsTitle);
		Listener columnResize = new Listener() {
			public void handleEvent(Event event) {
				column.setWidth(table.getClientArea().width);
			}
		};
		table.addListener(SWT.Resize, columnResize);

		nonVisibleViewer = new TableViewer(table);
		nonVisibleViewer.setLabelProvider(doGetLabelProvider());
		nonVisibleViewer.setContentProvider(new ContentProviderAdapter() {
			public Object[] getElements(Object inputElement) {
				return getNonVisible().toArray();
			}
		});
		nonVisibleViewer
				.addSelectionChangedListener(new ISelectionChangedListener() {
					public void selectionChanged(SelectionChangedEvent event) {
						handleNonVisibleSelection(event.getSelection());
					}
				});
		table.addListener(SWT.MouseDoubleClick, new Listener() {
			public void handleEvent(Event event) {
				handleToVisibleButton(event);
			}
		});
		nonVisibleViewer.setInput(this);
	}

	/**
	 * Creates buttons for moving columns from non-visible to visible and
	 * vice-versa
	 * 
	 * @param parent
	 */
	void createMoveButtons(Composite parent) {
		Composite bttArea = new Composite(parent, SWT.NONE);
		bttArea.setLayout(new GridLayout(1, true));
		bttArea.setLayoutData(new GridData(GridData.FILL_VERTICAL));

		toNonVisibleBtt = new Button(bttArea, SWT.PUSH);
		toNonVisibleBtt
				.setText(getDefaultOrientation() == SWT.RIGHT_TO_LEFT ? MarkerMessages.MarkerPreferences_MoveRight
						: MarkerMessages.MarkerPreferences_MoveLeft);
		toNonVisibleBtt.setLayoutData(new GridData());

		toNonVisibleBtt.addListener(SWT.Selection, new Listener() {
			public void handleEvent(Event event) {
				handleToNonVisibleButton(event);
			}
		});
		toNonVisibleBtt.setEnabled(false);

		toVisibleBtt = new Button(bttArea, SWT.PUSH);
		toVisibleBtt
				.setText(getDefaultOrientation() == SWT.RIGHT_TO_LEFT ? MarkerMessages.MarkerPreferences_MoveLeft
						: MarkerMessages.MarkerPreferences_MoveRight);
		toVisibleBtt.setLayoutData(new GridData());
		toVisibleBtt.addListener(SWT.Selection, new Listener() {
			public void handleEvent(Event event) {
				handleToVisibleButton(event);
			}
		});
		toVisibleBtt.setEnabled(false);
	}

	/**
	 * 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 integer value
	 */
	String handleIntegerFieldChange(Event event, String intialvalue) {
		Text text = (Text) event.widget;
		String value = text.getText().trim();
		switch (event.type) {
		case SWT.KeyDown:
			if (!Character.isDigit(event.character)) {
				if (!Character.isISOControl(event.character)) {
					handleStatusUdpate(IStatus.ERROR, getErrorMessage());
					event.doit = false;
					return intialvalue;
				}
			}
		case SWT.FocusOut:
			if (value.length() == 0) {
				value = Integer.toString(0);
				text.setText(value);
				text.selectAll();
				handleStatusUdpate(IStatus.INFO, null);
			} else {
				try {
					Integer.parseInt(value);
					handleStatusUdpate(IStatus.INFO, null);
				} catch (Exception e) {
					value = intialvalue;
					text.setText(value);
					text.selectAll();
					handleStatusUdpate(IStatus.ERROR, getErrorMessage());
					event.doit = false;
				}
			}
		}
		return value;
	}

	/**
	 * Handles a selection change in the viewer that lists out the non-visible
	 * columns
	 * 
	 * @param selection
	 */
	void handleNonVisibleSelection(ISelection selection) {
		Object[] nvKeys = ((IStructuredSelection) selection).toArray();
		toVisibleBtt.setEnabled(nvKeys.length > 0);
	}

	/**
	 * Handles a selection change in the viewer that lists out the visible
	 * columns. Takes care of various enablements.
	 * 
	 * @param selection
	 */
	void handleVisibleSelection(ISelection selection) {
		List selVCols = ((IStructuredSelection) selection).toList();
		List allVCols = getVisible();
		toNonVisibleBtt.setEnabled(selVCols.size() > 0
				&& allVCols.size() > selVCols.size());

		IColumnInfoProvider infoProvider = doGetColumnInfoProvider();
		boolean moveDown = !selVCols.isEmpty(), moveUp = !selVCols.isEmpty();
		Iterator iterator = selVCols.iterator();
		while (iterator.hasNext()) {
			Object columnObj = iterator.next();
			if (!infoProvider.isColumnMovable(columnObj)) {
				moveUp = false;
				moveDown = false;
				break;
			}
			int i = allVCols.indexOf(columnObj);
			if (i == 0) {
				moveUp = false;
				if (!moveDown) {
					break;
				}
			}
			if (i == (allVCols.size() - 1)) {
				moveDown = false;
				if (!moveUp) {
					break;
				}
			}
		}
		upButton.setEnabled(moveUp);
		downButton.setEnabled(moveDown);

		boolean edit = selVCols.size() == 1 ? infoProvider
				.isColumnResizable(selVCols.get(0)) : false;
		if (edit) {
			widthText.setText(Integer.toString(infoProvider
					.getColumnWidth(selVCols.get(0))));
		} else {
			widthText.setText(Integer.toString(0));
		}
		widthText.setEditable(edit);
	}

	/**
	 * Applies to visible columns, and handles the changes in the order of
	 * columns
	 * 
	 * @param e
	 *            event from the button click
	 */
	void handleDownButton(Event e) {
		IStructuredSelection selection = (IStructuredSelection) visibleViewer
				.getSelection();
		Object[] selVCols = selection.toArray();
		List allVCols = getVisible();
		IColumnUpdater updater = doGetColumnUpdater();
		for (int i = selVCols.length - 1; i >= 0; i--) {
			Object colObj = selVCols[i];
			int index = allVCols.indexOf(colObj);
			updater.setColumnIndex(colObj, index + 1);
			allVCols.remove(index);
			allVCols.add(index + 1, colObj);
		}
		visibleViewer.refresh();
		handleVisibleSelection(selection);
	}

	/**
	 * Applies to visible columns, and handles the changes in the order of
	 * columns
	 * 
	 * @param e
	 *            event from the button click
	 */
	void handleUpButton(Event e) {
		IStructuredSelection selection = (IStructuredSelection) visibleViewer
				.getSelection();
		Object[] selVCols = selection.toArray();
		List allVCols = getVisible();
		IColumnUpdater updater = doGetColumnUpdater();
		for (int i = 0; i < selVCols.length; i++) {
			Object colObj = selVCols[i];
			int index = allVCols.indexOf(colObj);
			updater.setColumnIndex(colObj, index - 1);
			allVCols.remove(index);
			allVCols.add(index - 1, colObj);
		}
		visibleViewer.refresh();
		handleVisibleSelection(selection);
	}

	/**
	 * Moves selected columns from non-visible to visible state
	 * 
	 * @param e
	 *            event from the button click
	 */
	void handleToVisibleButton(Event e) {
		IStructuredSelection selection = (IStructuredSelection) nonVisibleViewer
				.getSelection();
		List selVCols = selection.toList();
		List nonVisible = getNonVisible();
		nonVisible.removeAll(selVCols);

		List list = getVisible();
		list.addAll(selVCols);

		updateVisibility(selVCols, true);
		updateIndices(getVisible());
		updateIndices(getNonVisible());

		visibleViewer.refresh();
		visibleViewer.setSelection(selection);
		nonVisibleViewer.refresh();
		handleVisibleSelection(selection);
		handleNonVisibleSelection(nonVisibleViewer.getSelection());
	}

	/**
	 * Moves selected columns from visible to non-visible state
	 * 
	 * @param e
	 *            event from the button click
	 */
	protected void handleToNonVisibleButton(Event e) {
		if (getVisible().size() <= 1) {
			handleStatusUdpate(IStatus.INFO,
					MarkerMessages.MarkerPreferences_AtLeastOneVisibleColumn);
			return;
		}
		IStructuredSelection selection = (IStructuredSelection) visibleViewer
				.getSelection();
		List selVCols = selection.toList();
		getVisible().removeAll(selVCols);
		getNonVisible().addAll(selVCols);

		updateVisibility(selVCols, false);
		updateIndices(getVisible());
		updateIndices(getNonVisible());

		nonVisibleViewer.refresh();
		nonVisibleViewer.setSelection(selection);
		visibleViewer.refresh();
		handleVisibleSelection(visibleViewer.getSelection());
		handleNonVisibleSelection(nonVisibleViewer.getSelection());
		handleStatusUdpate(IStatus.INFO, getDefaultMessage());
	}

	void updateIndices(List list) {
		ListIterator iterator = list.listIterator();
		IColumnUpdater updater = doGetColumnUpdater();
		while (iterator.hasNext()) {
			updater.setColumnIndex(iterator.next(), iterator.previousIndex());
		}
	}

	void updateVisibility(List list, boolean visibility) {
		IColumnUpdater updater = doGetColumnUpdater();
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			updater.setColumnVisible(iterator.next(), visibility);
		}
	}

	/**
	 * Updates the UI based on values of the variable
	 */
	void refreshViewers() {
		if (limitEditor != null) {
			limitEditor.setText(Integer.toString(getLimitValue()));
		}
		if (nonVisibleViewer != null) {
			nonVisibleViewer.refresh();
		}
		if (visibleViewer != null) {
			visibleViewer.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
	 */
	public List getVisible() {
		if (visible == null) {
			visible = new ArrayList();
		}
		return visible;
	}

	/**
	 * @return List of non-visible columns
	 */
	public List getNonVisible() {
		if (nonVisible == null) {
			nonVisible = new ArrayList();
		}
		return nonVisible;
	}

	/**
	 * An adapter class to {@link ITableLabelProvider}
	 * 
	 */
	class TableLabelProvider extends LabelProvider implements
			ITableLabelProvider {
		public Image getColumnImage(Object element, int columnIndex) {
			return null;
		}

		public String getColumnText(Object element, int columnIndex) {
			return getText(element);
		}
	}

	/**
	 * Internal helper to @see {@link ViewerColumnsDialog#getLabelProvider()}
	 */
	ITableLabelProvider doGetLabelProvider() {
		return getLabelProvider();
	}

	/**
	 * The tables-columns need to be displayed appropriately. The supplied
	 * column objects are adapted to text and image as dictacted by this
	 * {@link ITableLabelProvider}
	 */
	protected abstract ITableLabelProvider getLabelProvider();

	/**
	 * Internal helper to @see
	 * {@link ViewerColumnsDialog#getColumnInfoProvider()}
	 */
	IColumnInfoProvider doGetColumnInfoProvider() {
		return getColumnInfoProvider();
	}

	/**
	 * To configure the columns we need further information. The supplied column
	 * objects are adapted for its properties via {@link IColumnInfoProvider}
	 */
	protected abstract IColumnInfoProvider getColumnInfoProvider();

	/**
	 * Internal helper to @see {@link ViewerColumnsDialog#getColumnUpdater()}
	 */
	IColumnUpdater doGetColumnUpdater() {
		return getColumnUpdater();
	}

	/**
	 * To configure properties/order of the columns is achieved via
	 * {@link IColumnUpdater}
	 */
	protected abstract IColumnUpdater getColumnUpdater();

	/**
	 * Update various aspects of a columns from a viewer such
	 * {@link TableViewer}
	 */
	public interface IColumnInfoProvider {

		/**
		 * Get corresponding index for the column
		 * 
		 * @param columnObj
		 */
		public int getColumnIndex(Object columnObj);

		/**
		 * Get the width of the column
		 * 
		 * @param columnObj
		 */
		public int getColumnWidth(Object columnObj);

		/**
		 * Returns true if the column represented by parameters is showing in
		 * the viewer
		 * 
		 * @param columnObj
		 */
		public boolean isColumnVisible(Object columnObj);

		/**
		 * Returns true if the column represented by parameters is configured as
		 * movable
		 * 
		 * @param columnObj
		 */
		public boolean isColumnMovable(Object columnObj);

		/**
		 * Returns true if the column represented by parameters is configured as
		 * resizable
		 * 
		 * @param columnObj
		 */
		public boolean isColumnResizable(Object columnObj);

	}

	/**
	 * Update various aspects of a columns from a viewer such
	 * {@link TableViewer}
	 */
	public interface IColumnUpdater {

		/**
		 * Set the column represented by parameters as visible
		 * 
		 * @param columnObj
		 * @param visible
		 */
		public void setColumnVisible(Object columnObj, boolean visible);

		/**
		 * Dummy method - more a result of symmetry
		 * 
		 * @param columnObj
		 * @param movable
		 */
		public void setColumnMovable(Object columnObj, boolean movable);

		/**
		 * Call back to notify change in the index of the column represented by
		 * columnObj
		 * 
		 * @param columnObj
		 * @param index
		 */
		public void setColumnIndex(Object columnObj, int index);

		/**
		 * Dummy method - more a result of symmetry
		 * 
		 * @param columnObj
		 * @param resizable
		 */
		public void setColumnResizable(Object columnObj, boolean resizable);

		/**
		 * Call back to notify change in the width of the column represented by
		 * columnObj
		 * 
		 * @param columnObj
		 * @param newWidth
		 */
		public void setColumnWidth(Object columnObj, int newWidth);

	}

	// //////////////////////////////////////////////////////////////////////////////////
	/**
	 * Ignore the class below as it is simply meant to test the above. I intend
	 * to retain this for a while.
	 */
	static class TestData {

		final Object key;

		final int keyIndex;

		int newIndex, width;

		boolean visibility, movable, resizable;

		TestData(Object key, int currIndex) {
			this.key = key;
			this.keyIndex = currIndex;
		}

		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + ((key == null) ? 0 : key.hashCode());
			result = prime * result + keyIndex;
			return result;
		}

		public boolean equals(Object obj) {
			if (this == obj) {
				return true;
			}
			if (obj == null) {
				return false;
			}
			if (!(obj instanceof TestData)) {
				return false;
			}
			TestData other = (TestData) obj;
			if (key == null) {
				if (other.key != null) {
					return false;
				}
			} else if (!key.equals(other.key)) {
				return false;
			}
			if (keyIndex != other.keyIndex) {
				return false;
			}
			return true;
		}

		public String toString() {
			return key.toString();
		}

		private static ViewerColumnsDialog getColumnsDialog(Shell shell,
				final TestData[] colums) {
			ViewerColumnsDialog dialog = new ViewerColumnsDialog(shell) {

				protected IColumnInfoProvider getColumnInfoProvider() {
					return getInfoProvider(colums);
				}

				protected ITableLabelProvider getLabelProvider() {
					return new TableLabelProvider();
				}

				protected IColumnUpdater getColumnUpdater() {
					return getUpdater(colums);
				}
			};
			dialog.setColumnsObjs(colums);
			return dialog;
		}

		private static IColumnUpdater getUpdater(final TestData[] data) {
			return new IColumnUpdater() {

				public void setColumnWidth(Object columnObj, int newWidth) {
					((TestData) columnObj).width = newWidth;
				}

				public void setColumnVisible(Object columnObj, boolean visible) {
					((TestData) columnObj).visibility = visible;
				}

				public void setColumnResizable(Object columnObj,
						boolean resizable) {

				}

				public void setColumnMovable(Object columnObj, boolean movable) {
					((TestData) columnObj).movable = movable;

				}

				public void setColumnIndex(Object columnObj, int index) {
					((TestData) columnObj).newIndex = index;
				}
			};
		}

		private static IColumnInfoProvider getInfoProvider(
				final TestData[] colData) {
			return new IColumnInfoProvider() {

				public boolean isColumnVisible(Object columnObj) {
					return ((TestData) columnObj).visibility;
				}

				public boolean isColumnResizable(Object columnObj) {
					return ((TestData) columnObj).resizable;
				}

				public boolean isColumnMovable(Object columnObj) {
					return ((TestData) columnObj).movable;
				}

				public int getColumnWidth(Object columnObj) {
					return ((TestData) columnObj).width;
				}

				public int getColumnIndex(Object columnObj) {
					return ((TestData) columnObj).newIndex;
				}
			};
		}

		private static TestData[] genData(int count) {
			String[] cols = new String[count];
			for (int i = 0; i < cols.length; i++) {
				cols[i] = new String("Column-" + (i + 1)); //$NON-NLS-1$
			}
			Random random = new Random();

			boolean[] visibility = new boolean[cols.length];
			Arrays.fill(visibility, true);
			int ranInt = random.nextInt() % cols.length;
			for (int i = 0; i < ranInt; i++) {
				visibility[random.nextInt(ranInt)] = false;
			}

			boolean[] resizable = new boolean[cols.length];
			Arrays.fill(resizable, true);
			ranInt = random.nextInt() % cols.length;
			for (int i = 0; i < ranInt; i++) {
				resizable[random.nextInt(ranInt)] = false;
			}

			boolean[] movable = new boolean[cols.length];
			Arrays.fill(movable, true);
			ranInt = random.nextInt() % cols.length;
			for (int i = 0; i < ranInt; i++) {
				movable[random.nextInt(ranInt)] = false;
			}

			int[] widths = new int[cols.length];
			Arrays.fill(widths, 100);
			return TestData.generateColumnsData(cols, visibility, resizable,
					movable, widths);
		}

		public static TestData[] generateColumnsData(Object[] keys,
				boolean[] visibility, boolean[] resizable, boolean[] movable,
				int[] widths) {
			TestData[] colData = new TestData[keys.length];
			int m = 0, n = 0;
			for (int i = 0; i < colData.length; i++) {
				TestData data = new TestData(keys[i], i);
				data.visibility = visibility[i];
				data.resizable = resizable[i];
				data.movable = movable[i];
				data.width = widths[i];
				if (data.visibility) {
					data.newIndex = m++;
				} else {
					data.newIndex = n++;
				}
				colData[i] = data;
			}
			return colData;
		}

		/**
		 * Demo
		 * 
		 * @param args
		 */
		public static void main(String[] args) {
			Display display = new Display();
			final Shell shell = new Shell(display);
			shell.setLayout(new FillLayout());
			ViewerColumnsDialog dialog = getColumnsDialog(shell, genData(100));
			dialog.open();
			shell.dispose();
			while (!shell.isDisposed()) {
				if (!display.readAndDispatch()) {
					display.sleep();
				}
			}
			display.dispose();

		}

	}

	// //////////////////////////////////////////////////////////////////////////////////
}

Lines 255-261 Link Here

(-)src/org/eclipse/ui/views/markers/MarkerField.java (-1 / +1 lines)
255	*/	255	*/
256	public void update(ViewerCell cell) {	256	public void update(ViewerCell cell) {
257	cell.setText(getValue((MarkerItem) cell.getElement()));	257	cell.setText(getValue((MarkerItem) cell.getElement()));
258		258	cell.setImage(null);
259	}	259	}
260		260
261	}	261	}

Lines 219-224 Link Here

(-)src/org/eclipse/ui/views/markers/internal/MarkerMessages.java (+1 lines)
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
223	public static String ProblemFilterDialog_System_Filters_Title;	224	public static String ProblemFilterDialog_System_Filters_Title;
224	public static String ProblemFilterDialog_All_Problems;	225	public static String ProblemFilterDialog_All_Problems;




MarkerPreferences_DialogTitle = Preferences
MarkerPreferences_MarkerLimits = Use marker &limits
MarkerPreferences_VisibleItems = Limit visible &items per group to:
MarkerPreferences_MoveLeft = &<<
MarkerPreferences_MoveRight = &>>
MarkerPreferences_ColumnGroupTitle = Hide/Show Columns
MarkerPreferences_VisibleColumnsTitle = &Show
MarkerPreferences_HiddenColumnsTitle = &Hide
MarkerPreferences_AtLeastOneVisibleColumn = There must be at least one visible column.
MarkerPreferences_ZeroOrBlankValueCanBeUsedToDisableTheLimit = Please enter a positive number (zero or blank can be used to disable the limit).

ProblemFilterDialog_System_Filters_Title = System filte&rs:
ProblemFilterDialog_All_Problems = Enabled for all problems

Return to bug 231081

Lines 1850-1865 Link Here

(-)plugin.xml (-52 lines)
1850	mnemonic="%command.configureColumns.mnemonic"	1850	mnemonic="%command.configureColumns.mnemonic"
1851	style="push">	1851	style="push">
1852	</command>	1852	</command>
1853	<command
1854	commandId="org.eclipse.ui.window.preferences"
1855	label="%command.preferences.label"
1856	mnemonic="%command.preferences.mnemonic"
1857	style="push">
1858	<parameter
1859	name="preferencePageId"
1860	value="org.eclipse.ui.ide.markers">
1861	</parameter>
1862	</command>
1863	</menuContribution>	1853	</menuContribution>
1864	<menuContribution	1854	<menuContribution
1865	locationURI="menu:org.eclipse.ui.views.TaskList">	1855	locationURI="menu:org.eclipse.ui.views.TaskList">
Lines 1913-1928 Link Here
1913	mnemonic="%command.configureColumns.mnemonic"	1903	mnemonic="%command.configureColumns.mnemonic"
1914	style="push">	1904	style="push">
1915	</command>	1905	</command>
1916	<command
1917	commandId="org.eclipse.ui.window.preferences"
1918	label="%command.preferences.label"
1919	mnemonic="%command.preferences.mnemonic"
1920	style="push">
1921	<parameter
1922	name="preferencePageId"
1923	value="org.eclipse.ui.ide.markers">
1924	</parameter>
1925	</command>
1926	</menuContribution>	1906	</menuContribution>
1927	<menuContribution	1907	<menuContribution
1928	locationURI="menu:org.eclipse.ui.views.BookmarkView">	1908	locationURI="menu:org.eclipse.ui.views.BookmarkView">
Lines 1986-2001 Link Here
1986	mnemonic="%command.configureColumns.mnemonic"	1966	mnemonic="%command.configureColumns.mnemonic"
1987	style="push">	1967	style="push">
1988	</command>	1968	</command>
1989	<command
1990	commandId="org.eclipse.ui.window.preferences"
1991	label="%command.preferences.label"
1992	mnemonic="%command.preferences.mnemonic"
1993	style="push">
1994	<parameter
1995	name="preferencePageId"
1996	value="org.eclipse.ui.ide.markers">
1997	</parameter>
1998	</command>
1999	</menuContribution>	1969	</menuContribution>
2000	<menuContribution	1970	<menuContribution
2001	locationURI="menu:org.eclipse.ui.views.AllMarkersView">	1971	locationURI="menu:org.eclipse.ui.views.AllMarkersView">
Lines 2049-2064 Link Here
2049	mnemonic="%command.configureColumns.mnemonic"	2019	mnemonic="%command.configureColumns.mnemonic"
2050	style="push">	2020	style="push">
2051	</command>	2021	</command>
2052	<command
2053	commandId="org.eclipse.ui.window.preferences"
2054	label="%command.preferences.label"
2055	mnemonic="%command.preferences.mnemonic"
2056	style="push">
2057	<parameter
2058	name="preferencePageId"
2059	value="org.eclipse.ui.ide.markers">
2060	</parameter>
2061	</command>
2062	</menuContribution>	2022	</menuContribution>
2063	</extension>	2023	</extension>
2064	<extension	2024	<extension
Lines 2240-2257 Link Here
2240	</iterate>	2200	</iterate>
2241	</enabledWhen>	2201	</enabledWhen>
2242	</handler>	2202	</handler>
2243	<handler
2244	class="org.eclipse.ui.internal.views.markers.MarkerPreferencesHandler"
2245	commandId="org.eclipse.ui.window.preferences">
2246	<activeWhen>
2247	<with
2248	variable="activePart">
2249	<instanceof
2250	value="org.eclipse.ui.views.markers.MarkerSupportView">
2251	</instanceof>
2252	</with>
2253	</activeWhen>
2254	</handler>
2255	</extension>	2203	</extension>
2256	<extension	2204	<extension
2257	point="org.eclipse.core.expressions.propertyTesters">	2205	point="org.eclipse.core.expressions.propertyTesters">

Removed Link Here

(-)src/org/eclipse/ui/internal/views/markers/MarkerPreferencesDialog.java (-483 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008, 2009 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 java.util.ArrayList;
15	import java.util.List;
16
17	import org.eclipse.jface.dialogs.IDialogConstants;
18	import org.eclipse.jface.preference.IntegerFieldEditor;
19	import org.eclipse.jface.resource.JFaceColors;
20	import org.eclipse.jface.viewers.IStructuredContentProvider;
21	import org.eclipse.jface.viewers.IStructuredSelection;
22	import org.eclipse.jface.viewers.LabelProvider;
23	import org.eclipse.jface.viewers.ListViewer;
24	import org.eclipse.jface.viewers.Viewer;
25	import org.eclipse.swt.SWT;
26	import org.eclipse.swt.events.SelectionAdapter;
27	import org.eclipse.swt.events.SelectionEvent;
28	import org.eclipse.swt.layout.FormAttachment;
29	import org.eclipse.swt.layout.FormData;
30	import org.eclipse.swt.layout.FormLayout;
31	import org.eclipse.swt.layout.GridData;
32	import org.eclipse.swt.layout.GridLayout;
33	import org.eclipse.swt.widgets.Button;
34	import org.eclipse.swt.widgets.Composite;
35	import org.eclipse.swt.widgets.Control;
36	import org.eclipse.swt.widgets.Group;
37	import org.eclipse.swt.widgets.Label;
38	import org.eclipse.swt.widgets.Shell;
39	import org.eclipse.ui.internal.ide.IDEInternalPreferences;
40	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
41	import org.eclipse.ui.preferences.ViewSettingsDialog;
42	import org.eclipse.ui.views.markers.MarkerField;
43	import org.eclipse.ui.views.markers.internal.MarkerMessages;
44
45	/**
46	* MarkerPreferencesDialog is the dialog for showing marker preferences.
47	*
48	* @since 3.4
49	*
50	*/
51	public class MarkerPreferencesDialog extends ViewSettingsDialog {
52
53	private IntegerFieldEditor limitEditor;
54
55	private Button enablementButton;
56
57	private Composite editArea;
58
59	private Label messageLabel;
60
61	private ExtendedMarkersView extendedView;
62
63	private ArrayList visible;
64
65	private ArrayList hidden;
66
67	private ListViewer visibleViewer;
68
69	private ListViewer nonVisibleViewer;
70
71	/**
72	* Create a new instance of the receiver.
73	*
74	* @param view -
75	* the view this is being launched from
76	*/
77	public MarkerPreferencesDialog(ExtendedMarkersView view) {
78	super(view.getSite().getShell());
79	this.extendedView = view;
80
81	Object[] visibleFields = view.getVisibleFields();
82	Object[] hiddenFields = view.getHiddenFields();
83
84	visible = new ArrayList();
85	hidden = new ArrayList();
86
87	for (int i = 0; i < visibleFields.length; i++) {
88	visible.add(visibleFields[i]);
89	}
90
91	for (int i = 0; i < hiddenFields.length; i++) {
92	hidden.add(hiddenFields[i]);
93	}
94	}
95
96	/*
97	* (non-Javadoc)
98	*
99	* @see org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets.Shell)
100	*/
101	protected void configureShell(Shell newShell) {
102	super.configureShell(newShell);
103	newShell.setText(MarkerMessages.MarkerPreferences_DialogTitle);
104	}
105
106	/*
107	* (non-Javadoc)
108	*
109	* @see org.eclipse.jface.window.Window#getShellStyle()
110	*/
111	protected int getShellStyle() {
112	return super.getShellStyle() \| SWT.RESIZE;
113	}
114
115	/*
116	* (non-Javadoc)
117	*
118	* @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
119	*/
120	protected Control createDialogArea(Composite parent) {
121
122	Composite dialogArea = (Composite) super.createDialogArea(parent);
123
124	boolean checked = IDEWorkbenchPlugin.getDefault().getPreferenceStore()
125	.getBoolean(IDEInternalPreferences.USE_MARKER_LIMITS);
126	enablementButton = new Button(dialogArea, SWT.CHECK);
127	enablementButton.setText(MarkerMessages.MarkerPreferences_MarkerLimits);
128	enablementButton.setSelection(checked);
129
130	editArea = new Composite(dialogArea, SWT.NONE);
131	editArea.setLayout(new GridLayout());
132	GridData editData = new GridData(GridData.FILL_BOTH
133	\| GridData.GRAB_HORIZONTAL \| GridData.GRAB_VERTICAL);
134	editData.horizontalIndent = 10;
135	editArea.setLayoutData(editData);
136
137	limitEditor = new IntegerFieldEditor(
138	"limit", MarkerMessages.MarkerPreferences_VisibleItems, editArea) { //$NON-NLS-1$
139	/*
140	* (non-Javadoc)
141	*
142	* @see org.eclipse.jface.preference.IntegerFieldEditor#checkState()
143	*/
144	protected boolean checkState() {
145	boolean state = super.checkState();
146	setValid(state, getErrorMessage());
147	return state;
148	}
149	};
150	limitEditor.setPreferenceStore(IDEWorkbenchPlugin.getDefault()
151	.getPreferenceStore());
152	limitEditor
153	.setPreferenceName(IDEInternalPreferences.MARKER_LIMITS_VALUE);
154	limitEditor.load();
155
156	GridData checkedData = new GridData(SWT.FILL, SWT.NONE, true, false);
157	checkedData.horizontalSpan = limitEditor.getNumberOfControls();
158	enablementButton.setLayoutData(checkedData);
159
160	enablementButton.addSelectionListener(new SelectionAdapter() {
161	public void widgetSelected(SelectionEvent e) {
162	setLimitEditorEnablement(editArea, enablementButton
163	.getSelection());
164	}
165	});
166
167	setLimitEditorEnablement(editArea, checked);
168
169	messageLabel = new Label(dialogArea, SWT.NONE);
170
171	messageLabel.setBackground(JFaceColors.getErrorBackground(dialogArea
172	.getDisplay()));
173	messageLabel.setForeground(JFaceColors.getErrorText(dialogArea
174	.getDisplay()));
175	messageLabel
176	.setLayoutData(new GridData(SWT.FILL, SWT.NONE, true, false));
177
178	createColumnsArea(dialogArea);
179
180	applyDialogFont(dialogArea);
181	return dialogArea;
182	}
183
184	/**
185	* Create an area for the selected columns
186	*
187	* @param dialogArea
188	*/
189	private void createColumnsArea(Composite dialogArea) {
190
191	initializeDialogUnits(dialogArea);
192	Group columnsComposite = new Group(dialogArea, SWT.NONE);
193	columnsComposite.setText(MarkerMessages.MarkerPreferences_ColumnGroupTitle);
194	FormLayout layout = new FormLayout();
195	columnsComposite.setLayout(layout);
196
197	columnsComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,
198	true));
199	Label visibleItemsLabel = new Label(columnsComposite, SWT.NONE);
200	visibleItemsLabel.setText(MarkerMessages.MarkerPreferences_VisibleColumnsTitle);
201	FormData visibleLabelData = new FormData();
202	visibleLabelData.right = new FormAttachment(45, 0);
203	visibleLabelData.left = new FormAttachment(
204	IDialogConstants.BUTTON_MARGIN);
205	visibleLabelData.top = new FormAttachment(0);
206	visibleItemsLabel.setLayoutData(visibleLabelData);
207
208	int rightMargin = IDialogConstants.BUTTON_MARGIN * -1;
209
210	Label nonVisibleLabel = new Label(columnsComposite, SWT.NONE);
211	nonVisibleLabel.setText(MarkerMessages.MarkerPreferences_HiddenColumnsTitle);
212	FormData nonVisibleLabelData = new FormData();
213	nonVisibleLabelData.right = new FormAttachment(100);
214	nonVisibleLabelData.left = new FormAttachment(55, 0);
215	nonVisibleLabelData.top = new FormAttachment(0);
216	nonVisibleLabel.setLayoutData(nonVisibleLabelData);
217
218	visibleViewer = new ListViewer(columnsComposite,
219	SWT.BORDER);
220
221	FormData visibleViewerData = new FormData();
222	visibleViewerData.right = new FormAttachment(visibleItemsLabel, 0,
223	SWT.RIGHT);
224	visibleViewerData.left = new FormAttachment(visibleItemsLabel, 0,
225	SWT.LEFT);
226	visibleViewerData.top = new FormAttachment(visibleItemsLabel,
227	IDialogConstants.BUTTON_MARGIN);
228	visibleViewerData.bottom = new FormAttachment(100, rightMargin);
229	visibleViewerData.height = convertHeightInCharsToPixels(15);
230	visibleViewerData.width = convertWidthInCharsToPixels(25);
231
232	visibleViewer.getControl().setLayoutData(visibleViewerData);
233
234	visibleViewer.setContentProvider(new IStructuredContentProvider() {
235
236	/*
237	* (non-Javadoc)
238	*
239	* @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
240	*/
241	public Object[] getElements(Object inputElement) {
242	return visible.toArray();
243	}
244
245	/*
246	* (non-Javadoc)
247	*
248	* @see org.eclipse.jface.viewers.IContentProvider#dispose()
249	*/
250	public void dispose() {
251	}
252
253	/*
254	* (non-Javadoc)
255	*
256	* @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
257	* java.lang.Object, java.lang.Object)
258	*/
259	public void inputChanged(Viewer viewer, Object oldInput,
260	Object newInput) {
261	}
262
263	});
264
265	visibleViewer.setLabelProvider(markerFieldLabelProvider());
266
267	visibleViewer.setInput(this);
268
269	nonVisibleViewer = new ListViewer(columnsComposite,
270	SWT.BORDER);
271
272	nonVisibleViewer.setLabelProvider(markerFieldLabelProvider());
273
274	nonVisibleViewer.setContentProvider(new IStructuredContentProvider() {
275
276	/*
277	* (non-Javadoc)
278	*
279	* @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
280	*/
281	public Object[] getElements(Object inputElement) {
282	return hidden.toArray();
283	}
284
285	/*
286	* (non-Javadoc)
287	*
288	* @see org.eclipse.jface.viewers.IContentProvider#dispose()
289	*/
290	public void dispose() {
291	}
292
293	/*
294	* (non-Javadoc)
295	*
296	* @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
297	* java.lang.Object, java.lang.Object)
298	*/
299	public void inputChanged(Viewer viewer, Object oldInput,
300	Object newInput) {
301	}
302
303	});
304	nonVisibleViewer.setInput(this);
305
306	FormData nonVisibleViewerData = new FormData();
307	nonVisibleViewerData.right = new FormAttachment(nonVisibleLabel, 0,
308	SWT.RIGHT);
309	nonVisibleViewerData.left = new FormAttachment(nonVisibleLabel, 0,
310	SWT.LEFT);
311	nonVisibleViewerData.top = new FormAttachment(nonVisibleLabel,
312	IDialogConstants.BUTTON_MARGIN);
313	nonVisibleViewerData.bottom = new FormAttachment(100, rightMargin);
314	nonVisibleViewerData.height = convertHeightInCharsToPixels(15);
315	nonVisibleViewerData.width = convertWidthInCharsToPixels(25);
316
317	nonVisibleViewer.getControl().setLayoutData(nonVisibleViewerData);
318
319	Button toNonVisibleButton = new Button(columnsComposite, SWT.PUSH);
320	toNonVisibleButton
321	.setText(getDefaultOrientation() == SWT.RIGHT_TO_LEFT ? MarkerMessages.MarkerPreferences_MoveLeft
322	: MarkerMessages.MarkerPreferences_MoveRight);
323
324	FormData toNonVisibleButtonData = new FormData();
325
326	toNonVisibleButtonData.top = new FormAttachment(visibleViewer
327	.getControl(), IDialogConstants.BUTTON_BAR_HEIGHT, SWT.TOP);
328	toNonVisibleButtonData.left = new FormAttachment(visibleViewer
329	.getControl(), IDialogConstants.BUTTON_MARGIN);
330	toNonVisibleButtonData.right = new FormAttachment(nonVisibleViewer
331	.getControl(), rightMargin);
332	toNonVisibleButton.setLayoutData(toNonVisibleButtonData);
333
334	toNonVisibleButton.addSelectionListener(new SelectionAdapter() {
335	/*
336	* (non-Javadoc)
337	*
338	* @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
339	*/
340	public void widgetSelected(SelectionEvent e) {
341	List selection = ((IStructuredSelection) visibleViewer
342	.getSelection()).toList();
343	hidden.addAll(selection);
344	visible.removeAll(selection);
345	visibleViewer.refresh();
346	nonVisibleViewer.refresh();
347	setValid(
348	visible.size() > 0,
349	MarkerMessages.MarkerPreferences_AtLeastOneVisibleColumn);
350	}
351	});
352
353	Button toVisibleButton = new Button(columnsComposite, SWT.PUSH);
354	toVisibleButton
355	.setText(getDefaultOrientation() == SWT.RIGHT_TO_LEFT ? MarkerMessages.MarkerPreferences_MoveRight
356	: MarkerMessages.MarkerPreferences_MoveLeft);
357
358	FormData toVisibleButtonData = new FormData();
359
360	toVisibleButtonData.top = new FormAttachment(toNonVisibleButton,
361	IDialogConstants.BUTTON_MARGIN);
362	toVisibleButtonData.left = new FormAttachment(visibleViewer
363	.getControl(), IDialogConstants.BUTTON_MARGIN);
364	toVisibleButtonData.right = new FormAttachment(nonVisibleViewer
365	.getControl(), rightMargin);
366	toVisibleButton.setLayoutData(toVisibleButtonData);
367
368	toVisibleButton.addSelectionListener(new SelectionAdapter() {
369	/*
370	* (non-Javadoc)
371	*
372	* @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
373	*/
374	public void widgetSelected(SelectionEvent e) {
375	List selection = ((IStructuredSelection) nonVisibleViewer
376	.getSelection()).toList();
377	hidden.removeAll(selection);
378	visible.addAll(selection);
379	visibleViewer.refresh();
380	nonVisibleViewer.refresh();
381	setValid(
382	visible.size() > 0,
383	MarkerMessages.MarkerPreferences_AtLeastOneVisibleColumn);
384	}
385	});
386
387	}
388
389	/**
390	* Return a label provider for fields.
391	* @return LabelProvider
392	*/
393	private LabelProvider markerFieldLabelProvider() {
394	return new LabelProvider() {
395	/*
396	* (non-Javadoc)
397	*
398	* @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
399	*/
400	public String getText(Object element) {
401	return ((MarkerField) element).getName();
402	}
403	};
404	}
405
406	/**
407	* Set the enabled state of the OK button by state.
408	*
409	* @param state
410	*/
411	protected void setValid(boolean state, String errorMessage) {
412	Button okButton = getButton(IDialogConstants.OK_ID);
413
414	if (okButton == null)
415	return;
416
417	if (state)
418	messageLabel.setText(MarkerSupportInternalUtilities.EMPTY_STRING);
419	else
420	messageLabel.setText(errorMessage);
421
422	okButton.setEnabled(state);
423
424	}
425
426	/**
427	* Enable the limitEditor based on checked.
428	*
429	* @param control
430	* The parent of the editor
431	* @param checked
432	*/
433	private void setLimitEditorEnablement(Composite control, boolean checked) {
434	limitEditor.setEnabled(checked, control);
435	}
436
437	/*
438	* (non-Javadoc)
439	*
440	* @see org.eclipse.jface.dialogs.Dialog#okPressed()
441	*/
442	protected void okPressed() {
443
444	limitEditor.store();
445	IDEWorkbenchPlugin.getDefault().getPreferenceStore().setValue(
446	IDEInternalPreferences.USE_MARKER_LIMITS,
447	enablementButton.getSelection());
448	IDEWorkbenchPlugin.getDefault().savePluginPreferences();
449
450	extendedView.setVisibleFields(visible);
451
452	super.okPressed();
453	}
454
455	/*
456	* (non-Javadoc)
457	*
458	* @see org.eclipse.ui.preferences.ViewSettingsDialog#performDefaults()
459	*/
460	protected void performDefaults() {
461	super.performDefaults();
462	limitEditor.loadDefault();
463	boolean checked = IDEWorkbenchPlugin.getDefault().getPreferenceStore()
464	.getDefaultBoolean(IDEInternalPreferences.USE_MARKER_LIMITS);
465	enablementButton.setSelection(checked);
466	setLimitEditorEnablement(editArea, checked);
467
468	Object[] visibleFields=extendedView.getBuilder().getGenerator().getInitialVisible();
469	Object[] allFields=extendedView.getBuilder().getGenerator().getAllFields();
470	visible.clear();
471	hidden.clear();
472	for (int i = 0; i < allFields.length; i++) {
473	hidden.add(allFields[i]);
474	}
475	for (int i = 0; i < visibleFields.length; i++) {
476	hidden.remove(visibleFields[i]);
477	visible.add(visibleFields[i]);
478	}
479	visibleViewer.refresh();
480	nonVisibleViewer.refresh();
481	}
482
483	}

Removed Link Here

(-)src/org/eclipse/ui/internal/views/markers/MarkerPreferencesHandler.java (-38 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005, 2008 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	package org.eclipse.ui.internal.views.markers;
12
13	import org.eclipse.core.commands.ExecutionEvent;
14	import org.eclipse.core.commands.IHandler;
15	import org.eclipse.ui.views.markers.MarkerViewHandler;
16
17	/**
18	* MarkerPreferencesHandler is the handler for opening the marker preferences dialog.
19	* @since 3.4
20	*
21	*/
22	public class MarkerPreferencesHandler extends MarkerViewHandler implements
23	IHandler {
24
25	/* (non-Javadoc)
26	* @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
27	*/
28	public Object execute(ExecutionEvent event) {
29
30	ExtendedMarkersView view = getView(event);
31	if(view == null)
32	return this;
33
34	new MarkerPreferencesDialog(view).open();
35	return this;
36	}
37
38	}

Lines 317-331 Link Here

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

Lines 197-208 Link Here

(-)src/org/eclipse/ui/views/markers/internal/messages.properties (-2 / +3 lines)
197	MarkerPreferences_DialogTitle = Preferences	197	MarkerPreferences_DialogTitle = Preferences
198	MarkerPreferences_MarkerLimits = Use marker &limits	198	MarkerPreferences_MarkerLimits = Use marker &limits
199	MarkerPreferences_VisibleItems = Limit visible &items per group to:	199	MarkerPreferences_VisibleItems = Limit visible &items per group to:
200	MarkerPreferences_MoveLeft = <<	200	MarkerPreferences_MoveLeft = &<<
201	MarkerPreferences_MoveRight = >>	201	MarkerPreferences_MoveRight = &>>
202	MarkerPreferences_ColumnGroupTitle = Hide/Show Columns	202	MarkerPreferences_ColumnGroupTitle = Hide/Show Columns
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		207
207	ProblemFilterDialog_System_Filters_Title = System filte&rs:	208	ProblemFilterDialog_System_Filters_Title = System filte&rs:
208	ProblemFilterDialog_All_Problems = Enabled for all problems	209	ProblemFilterDialog_All_Problems = Enabled for all problems