Attachment #47827 for bug #148582




/*******************************************************************************
 * Copyright (c) 2000, 2005 QNX Software Systems 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:
 *     QNX Software Systems - Initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.ui.dialogs;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.PlatformUI;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.CCorePreferenceConstants;
import org.eclipse.cdt.utils.ui.controls.ControlFactory;

import org.eclipse.cdt.internal.ui.ICHelpContextIds;
import org.eclipse.cdt.internal.ui.preferences.PreferencesMessages;

/**
 * 
 */
public class CodeFormatterBlock {

	private HashMap idMap = new HashMap();
	Preferences fPrefs;
	protected Combo fFormatterCombo;
	private static final String ATTR_NAME = "name"; //$NON-NLS-1$
	private static final String ATTR_ID="id"; //$NON-NLS-1$
	// This is a hack until we have a default Formatter.
	// For now it is comment out in the plugin.xml
	private static final String NONE=PreferencesMessages.getString("CodeFormatterPreferencePage.emptyName"); //$NON-NLS-1$


	public CodeFormatterBlock(Preferences prefs) {
		fPrefs = prefs;
		initializeFormatters();
	}

	public void performOk() {
		String text = fFormatterCombo.getText();
		String selection = (String)idMap.get(text);
		if (selection != null && selection.length() > 0) {
			HashMap options = CCorePlugin.getOptions();
			String formatterID = (String)options.get(CCorePreferenceConstants.CODE_FORMATTER);
			if (formatterID == null || !formatterID.equals(selection)) {
				options.put(CCorePreferenceConstants.CODE_FORMATTER, selection);
				CCorePlugin.setOptions(options);
			}
		} else {
			// simply reset to the default one.
			performDefaults();
		}
	}

	public void performDefaults() {
		HashMap optionsDefault = CCorePlugin.getDefaultOptions();
		HashMap options = CCorePlugin.getOptions();
		String formatterID = (String)optionsDefault.get(CCorePreferenceConstants.CODE_FORMATTER);
		options.put(CCorePreferenceConstants.CODE_FORMATTER, formatterID);
		CCorePlugin.setOptions(options);

		fFormatterCombo.clearSelection();
		fFormatterCombo.setText(NONE);
		Iterator iterator = idMap.entrySet().iterator();
		while (iterator.hasNext()) {
			Map.Entry entry = (Map.Entry)iterator.next();
			String val = (String)entry.getValue();
			if (val != null && val.equals(formatterID)) {
				fFormatterCombo.setText((String)entry.getKey());
			}
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public Control createControl(Composite parent) {
		Composite control = ControlFactory.createComposite(parent, 2);
		((GridLayout) control.getLayout()).makeColumnsEqualWidth = false;
		((GridLayout) control.getLayout()).marginWidth = 5;

		PlatformUI.getWorkbench().getHelpSystem().setHelp(control, ICHelpContextIds.CODEFORMATTER_PREFERENCE_PAGE);

		ControlFactory.createEmptySpace(control, 2);

		Label label = ControlFactory.createLabel(control, PreferencesMessages.getString("CodeFormatterPreferencePage.selectionName")); //$NON-NLS-1$
		label.setLayoutData(new GridData());
		fFormatterCombo = new Combo(control, SWT.DROP_DOWN | SWT.READ_ONLY);
		GridData gd = new GridData(GridData.GRAB_HORIZONTAL);
		gd.grabExcessHorizontalSpace = true;
		fFormatterCombo.setLayoutData(gd);
		fFormatterCombo.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleFormatterChanged();
			}
		});
		Iterator items = idMap.keySet().iterator();
		while (items.hasNext()) {
			fFormatterCombo.add((String) items.next());
		}

		initDefault();
		handleFormatterChanged();
		return control;
	}

	public void handleFormatterChanged() {	
		// TODO: UI part.
	}

	public void initDefault() {
		boolean init = false;
		String selection = CCorePlugin.getOption(CCorePreferenceConstants.CODE_FORMATTER);
		if (selection != null) {
			Iterator iterator = idMap.entrySet().iterator();
			while (iterator.hasNext()) {
				Map.Entry entry = (Map.Entry)iterator.next();
				String val = (String)entry.getValue();
				if (val != null && val.equals(selection)) {
					fFormatterCombo.setText((String)entry.getKey());
					init = true;
				}
			}
		}
		if (!init) {
			fFormatterCombo.setText(NONE);
		}
	}

	private void initializeFormatters() {
		idMap = new HashMap();
		idMap.put(NONE, null);
		IExtensionPoint point = Platform.getExtensionRegistry().getExtensionPoint(CCorePlugin.PLUGIN_ID, CCorePlugin.FORMATTER_EXTPOINT_ID);
		if (point != null) {
			IExtension[] exts = point.getExtensions();
			for (int i = 0; i < exts.length; i++) {
		 		IConfigurationElement[] elements = exts[i].getConfigurationElements();
		 		for (int j = 0; j < elements.length; ++j) {
		 			String name = elements[j].getAttribute(ATTR_NAME);
		 			idMap.put(name, elements[j].getAttribute(ATTR_ID));
		 		}
			}
		}
	}

}




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences;


import java.util.MissingResourceException;
import java.util.ResourceBundle;

import org.eclipse.osgi.util.NLS;

public class PreferencesMessages extends NLS {

	private static final String BUNDLE_NAME = "org.eclipse.cdt.internal.ui.preferences.PreferencesMessages";//$NON-NLS-1$

	private PreferencesMessages() {
		// Do not instantiate
	}

	static {
		NLS.initializeMessages(BUNDLE_NAME, PreferencesMessages.class);
	}

	public static String CEditorPreferencePage_empty_input;
	public static String CEditorPreferencePage_invalid_input;
	public static String CEditorPreferencePage_typing_tabTitle;
	public static String CEditorPreferencePage_typing_description;
	public static String CEditorPreferencePage_closeStrings;
	public static String CEditorPreferencePage_closeBrackets;
	public static String CEditorPreferencePage_closeAngularBrackets;
	public static String CEditorPreferencePage_closeBraces;
	public static String CEditorPreferencePage_wrapStrings;
	public static String CEditorPreferencePage_escapeStrings;
	public static String CEditorPreferencePage_smartPaste;

	public static String CEditorPreferencePage_typing_smartTab;

	public static String SmartTypingConfigurationBlock_autoclose_title;
	public static String SmartTypingConfigurationBlock_tabs_title;
	public static String SmartTypingConfigurationBlock_tabs_message_tab_text;
	public static String SmartTypingConfigurationBlock_tabs_message_others_text;
	public static String SmartTypingConfigurationBlock_tabs_message_tooltip;
	public static String SmartTypingConfigurationBlock_tabs_message_spaces;
	public static String SmartTypingConfigurationBlock_tabs_message_tabs;
	public static String SmartTypingConfigurationBlock_tabs_message_tabsAndSpaces;
	public static String SmartTypingConfigurationBlock_pasting_title;
	public static String SmartTypingConfigurationBlock_strings_title;

	public static String CodeFormatterPreferencePage_title;
	public static String CodeFormatterPreferencePage_description; 
	
	// Old style string resource access.
	private static ResourceBundle fgResourceBundle;
	static {
		try {
			fgResourceBundle = ResourceBundle.getBundle(BUNDLE_NAME);
		} catch (MissingResourceException x) {
			fgResourceBundle = null;
		}
	}

	private PreferencesMessages() {
	}

	public static String getString(String key) {
		try {
			return fgResourceBundle.getString(key);




CEditorPreferencePage.behaviorPage.Color=Color:
CEditorPreferencePage.textFont.changeButton=C&hange...

# Smart typing block
SmartTypingConfigurationBlock_autoclose_title=Automatically close
SmartTypingConfigurationBlock_tabs_title=Tabulators
# The argument will be replaced by the tab display size
SmartTypingConfigurationBlock_tabs_message_tab_text=The tab display value (currently {0}) and whether spaces are used to indent lines are configured on the <a>code style preference page</a>. The current indentation mode uses tabs.
# The first argument will be replaced by the tab display size, the second by the indent size and the third by the NLSed string of 'SmartTypingConfigurationBlock_tabs_message_spaces' or 'SmartTypingConfigurationBlock_tabs_message_tabs' (see below)  
SmartTypingConfigurationBlock_tabs_message_others_text=The tab display value (currently {0}) and whether spaces are used to indent lines are configured on the <a>code style preference page</a>. The current indentation size is {1}, using {2}.
SmartTypingConfigurationBlock_tabs_message_tooltip=Go to the code style preference page
SmartTypingConfigurationBlock_tabs_message_spaces=spaces
SmartTypingConfigurationBlock_tabs_message_tabs=tabs
SmartTypingConfigurationBlock_tabs_message_tabsAndSpaces=tabs and spaces
SmartTypingConfigurationBlock_pasting_title=When pasting
SmartTypingConfigurationBlock_strings_title=In string literals

CEditorPreferencePage_empty_input=Empty input
CEditorPreferencePage_invalid_input="{0}" is not a valid input.
CEditorPreferencePage_typing_tabTitle=T&yping
CEditorPreferencePage_typing_description=Enable these typing aids in Smart Insert mode:
CEditorPreferencePage_closeStrings="&Strings"
CEditorPreferencePage_closeBrackets=(&Parentheses) and [square] brackets
CEditorPreferencePage_closeAngularBrackets=<A&ngle> brackets
CEditorPreferencePage_closeBraces={B&races}
CEditorPreferencePage_wrapStrings=&Wrap automatically
CEditorPreferencePage_escapeStrings=Escape text w&hen pasting into a string literal
CEditorPreferencePage_smartPaste=Adjust &indentation

CEditorPreferencePage_typing_smartTab= &Tab key indents the current line

# Code Formatting
CodeFormatterPreferencePage_title=Code Style
CodeFormatterPreferencePage_description=Sele&ct a profile:

TemplatePreferencePage.Viewer.preview=Preview:

CFileTypesPreferencePage.description=C/C++ File Types

FoldingConfigurationBlock.info.no_preferences= The selected folding provider did not provide a preference control
FoldingConfigurationBlock.error.not_exist= The selected folding provider does not exist

#Code Formatting
CodeFormatterPreferencePage.title=Code Formatter
CodeFormatterPreferencePage.selectionName=Formatters:
CodeFormatterPreferencePage.emptyName=(NONE)
CodeFormatterPreferencePage.description=Code Formatter

# --- Linked Resources ---
PathEntryVariablePreference.explanation = PathEntry variables.
PathEntryVariablePreference.enableLinkedResources = &Enable linked resources




 *
 * Contributors:
 *     QNX Software Systems - Initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences;


import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

import org.eclipse.jface.preference.IPreferencePageContainer;

import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.preferences.IWorkbenchPreferenceContainer;
import org.eclipse.ui.preferences.IWorkingCopyManager;
import org.eclipse.ui.preferences.WorkingCopyManager;

import org.eclipse.cdt.internal.ui.ICHelpContextIds;
import org.eclipse.cdt.internal.ui.preferences.formatter.CodeFormatterConfigurationBlock;

/*
 * The page to configure the code formatter options.
 */
public class CodeFormatterPreferencePage extends PropertyAndPreferencePage {

	public static final String PREF_ID= "org.eclipse.jdt.ui.preferences.CodeFormatterPreferencePage"; //$NON-NLS-1$
	public static final String PROP_ID= "org.eclipse.jdt.ui.propertyPages.CodeFormatterPreferencePage"; //$NON-NLS-1$
	
	private CodeFormatterConfigurationBlock fConfigurationBlock;

	public CodeFormatterPreferencePage() {
		setDescription(PreferencesMessages.CodeFormatterPreferencePage_description); 
		
		// only used when page is shown programatically
		setTitle(PreferencesMessages.CodeFormatterPreferencePage_title);		 
		//setDescription(PreferencesMessages.getString("CodeFormatterPreferencePage.description")); //$NON-NLS-1$
		fCodeFormatterBlock= new CodeFormatterBlock(CUIPlugin.getDefault().getPluginPreferences());
	}
	

	/*
	 * @see IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
	 */	
	public void init(IWorkbench workbench) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite parent) {
		IPreferencePageContainer container= getContainer();
		IWorkingCopyManager workingCopyManager;
		if (container instanceof IWorkbenchPreferenceContainer) {
			workingCopyManager= ((IWorkbenchPreferenceContainer) container).getWorkingCopyManager();
		} else {
			workingCopyManager= new WorkingCopyManager(); // non shared 
		}
		PreferencesAccess access= PreferencesAccess.getWorkingCopyPreferences(workingCopyManager);
		fConfigurationBlock= new CodeFormatterConfigurationBlock(getProject(), access);
		
		super.createControl(parent);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(), ICHelpContextIds.CODEFORMATTER_PREFERENCE_PAGE);
		return fCodeFormatterBlock.createControl(topPane);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.ui.preferences.PropertyAndPreferencePage#createPreferenceContent(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createPreferenceContent(Composite composite) {
		return fConfigurationBlock.createContents(composite);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.ui.preferences.PropertyAndPreferencePage#hasProjectSpecificOptions(org.eclipse.core.resources.IProject)
	 */
	protected boolean hasProjectSpecificOptions(IProject project) {
		return fConfigurationBlock.hasProjectSpecificOptions(project);
	}
	
//	/* (non-Javadoc)
//	 * @see org.eclipse.jdt.internal.ui.preferences.PropertyAndPreferencePage#enableProjectSpecificSettings(boolean)
//	 */
//	protected void enableProjectSpecificSettings(boolean useProjectSpecificSettings) {
//		super.enableProjectSpecificSettings(useProjectSpecificSettings);
//		if (fConfigurationBlock != null) {
//			fConfigurationBlock.enableProjectSpecificSettings(useProjectSpecificSettings);
//		}
//	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.ui.preferences.PropertyAndPreferencePage#getPreferencePageID()
	 */
	protected String getPreferencePageID() {
		return PREF_ID;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.ui.preferences.PropertyAndPreferencePage#getPropertyPageID()
	 */
	protected String getPropertyPageID() {
		return PROP_ID;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.DialogPage#dispose()
	 */
	public void dispose() {
		if (fConfigurationBlock != null) {
			fConfigurationBlock.dispose();
		}
		super.dispose();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.IPreferencePage#performDefaults()
	 */
	protected void performDefaults() {
		if (fConfigurationBlock != null) {
			fConfigurationBlock.performDefaults();
		}
		super.performDefaults();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.IPreferencePage#performOk()
	 */
	public boolean performOk() {
		if (fConfigurationBlock != null && !fConfigurationBlock.performOk()) {
			return false;
		}	
		return super.performOk();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.IPreferencePage#performOk()
	 */
	public void performApply() {
		if (fConfigurationBlock != null) {
			fConfigurationBlock.performApply();
		}	
		super.performApply();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.ui.preferences.PropertyAndPreferencePage#setElement(org.eclipse.core.runtime.IAdaptable)
	 */
	public void setElement(IAdaptable element) {
		super.setElement(element);
		setDescription(null); // no description for property page
	}

}




 *******************************************************************************/
package org.eclipse.cdt.utils.ui.controls;


import java.util.StringTokenizer;

import org.eclipse.jface.viewers.CellEditor;

	 *
	 * @param parent  the parent of the new composite
	 * @param numColumns  the number of columns for the new composite
	 * @return the newly-created composite
	 */
	public static Composite createComposite(Composite parent, int numColumns) {
		return createCompositeEx(parent, numColumns, GridData.FILL_HORIZONTAL);

	 * @param parent  the parent of the new composite
	 * @param numColumns  the number of columns for the new composite
	 * @param layoutMode - GridData modes that should be applied to this control
	 * @return the newly-created composite
	 */
	public static Composite createCompositeEx(Composite parent, int numColumns, int layoutMode) {
		Composite composite = new Composite(parent, SWT.NULL);
		composite.setFont(parent.getFont());
	
		composite.setLayout(new GridLayout(numColumns, true));
		composite.setLayoutData(new GridData(layoutMode));

		separator.setLayoutData(data);
		return separator;
	}

	/**
	 * Creates a spacer control.
	 * @param parent The parent composite

	public static Control createEmptySpace(Composite parent) {
		return createEmptySpace(parent, 1);
	}

	/**
	 * Creates a spacer control with the given span.
	 * The composite is assumed to have <code>MGridLayout</code> as


	/**
	 * Creates an new label (basic method)
	 * 
	 *
	 * @param parent  parent object
	 * @param text  the label text

	public static Label createLabel(Composite parent, String text, int widthHint, int heightHint, int style) {

		Label label = new Label(parent, style);		
		label.setFont(parent.getFont());
		label.setText(text);
		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = 1;

		return label;
	}


	/**
	 * Creates an new Wrapped label 
	 * 

		return createLabel(parent, text, widthHint, heightHint, SWT.LEFT | SWT.WRAP);
	}


	/**
	 * Creates an new checkbox instance and sets the default
	 * layout data.

	 */ 
	public static Button createCheckBox(Composite group, String label) {
		Button button = new Button(group, SWT.CHECK | SWT.LEFT);
		button.setFont(group.getFont());
		button.setText(label);
		GridData data = new GridData();
		button.setLayoutData(data);

	 */ 
	public static Button createCheckBoxEx(Composite group, String label, int style) {
		Button button = new Button(group, SWT.CHECK | style);
		button.setFont(group.getFont());
		button.setText(label);
		GridData data = new GridData();
		button.setLayoutData(data);

	 */ 
	public static Button createRadioButton(Composite group, String label, String value, SelectionListener listener) {
		Button button = new Button(group, SWT.RADIO | SWT.LEFT);
		button.setFont(group.getFont());
		button.setText(label);
		button.setData((null == value) ? label : value);
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		data.horizontalAlignment = GridData.FILL;
		data.verticalAlignment = GridData.BEGINNING;
		button.setLayoutData(data);
		if (null != listener)
			button.addSelectionListener(listener);
		return button;
	}

	 */
	public static Button createPushButton(Composite parent, String label) {
		Button button = new Button(parent, SWT.PUSH);
		button.setFont(parent.getFont());
		button.setText(label);
//		button.addSelectionListener(this);
		GridData data = new GridData();

		button.setLayoutData(data);
		return button;
	}

    	
	/**
	 * Create a text field specific for this application

	 */
    public static Group createGroup(Composite parent, String label, int nColumns) {
		Group group = new Group(parent, SWT.NONE);
		group.setFont(parent.getFont());
		group.setText(label);
		GridLayout layout = new GridLayout();
		layout.numColumns = nColumns;

        return group;    	
    }


	/**
	 * Create a List box
	 *

	 */
    public static List createList(Composite parent, String strdata, String selData) {
		List list = new List(parent, SWT.SINGLE);
		list.setFont(parent.getFont());
		GridData data = new GridData();
		list.setLayoutData(data);
		StringTokenizer st = new StringTokenizer(strdata, ","); //$NON-NLS-1$
		while (st.hasMoreTokens())
			list.add(st.nextToken());
	    if (selData == null) {
	    	if (list.getItemCount() > 0)
				list.select(0);
	    } else {
			selectList(list, selData);
	    }
	    else
			selectList(list, selData);	    
		return list;
	}

	public static void selectList(List list, String selData)	{
		int n_sel = list.indexOf(selData);
		if (0 > n_sel)
			n_sel = 0;
	    list.select(n_sel);
	}
	



	/**
	 *	Create this group's list viewer.
	 */

		data.widthHint = width;
		data.heightHint = height;
		listViewer.getTable().setLayoutData(data);
		if (null != opt_list)
			listViewer.add(opt_list);
        return listViewer; 
	}


	/**
	 *	Create this group's list viewer.
	 */

		tableLayout.addColumnData(new ColumnWeightData(colWidths[0], false));
*/		
		TableColumn column;
		for (int i = 0; i < columns.length; ++i) {
			column= new TableColumn(table, SWT.NULL);
			column.setText(columns[i]); 	
			tableLayout.addColumnData(new ColumnWeightData(colWidths[i], true));
			
		}

		table.setLayout(tableLayout);

	}

	public static void deactivateCellEditor(TableViewer viewer) {
		if (null == viewer)
			return;
		CellEditor[] es = viewer.getCellEditors();
		TableItem[] items = viewer.getTable().getSelection();
		if (items.length >= 0)  {
			for (int i = 0; i < es.length; ++i) {
				CellEditor e = es[i];
				if (e.isActivated()) {
					if (e.isValueValid()) {
						Object[] properties = viewer.getColumnProperties();
						Object value = e.getValue();
						viewer.cancelEditing();

	    int width, int height, int style) {
	    	
	    Table table = new Table(parent, SWT.BORDER | SWT.CHECK);
		table.setFont(parent.getFont());
	    CheckboxTableViewer listViewer = new CheckboxTableViewer(table);
		GridData data = new GridData(style);
		data.widthHint = width;
		data.heightHint = height;
		listViewer.getTable().setLayoutData(data);
		if (null != opt_list)
			listViewer.add(opt_list);
//		listViewer.setLabelProvider(listLabelProvider);
//		listViewer.addCheckStateListener(this);
        return listViewer; 
	}



	public static CheckboxTableViewer createListViewer(Composite parent,  
	    int width, int height, int style, String[] columns, int[] colWidths) {
	    CheckboxTableViewer listViewer = createListViewer(parent, null, 
	    	width, height, style);
		
		Table table= listViewer.getTable();
		table.setFont(parent.getFont());
		
		table.setHeaderVisible(true);
		table.setLinesVisible(true);

		column.setText(columns[0]); 	    
		tableLayout.addColumnData(new ColumnWeightData(colWidths[0], false));
		
		for (int i = 1; i < columns.length; ++i) {
			column= new TableColumn(table, SWT.NULL);
			column.setText(columns[i]); 	
			tableLayout.addColumnData(new ColumnWeightData(colWidths[i], false));

	    
        return listViewer; 
	}

  
	/**
	 * Create a selection combo

		
	public static CCombo createSelectCCombo(Composite parent, String strdata, String selData, int style) {
		CCombo combo = new CCombo(parent, style);
		combo.setFont(parent.getFont());
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		combo.setLayoutData(data);
		StringTokenizer st = new StringTokenizer(strdata, ","); //$NON-NLS-1$
		while (st.hasMoreTokens())
			combo.add(st.nextToken());
	    if (selData == null || selData.length() == 0) {
	    	if (combo.getItemCount() > 0)
				combo.select(0);
	    } else {
			selectCCombo(combo, selData);
	    }
	    else
			selectCCombo(combo, selData);	    
		return combo;
	}


	/**
	 * Create a selection combo
	 *

	
	public static CCombo createSelectCCombo(Composite parent, String[] strdata, String selData, int style) {
		CCombo combo = new CCombo(parent, style);
		combo.setFont(parent.getFont());
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		combo.setLayoutData(data);
		for (int i = 0; i < strdata.length; ++i) {
			combo.add(strdata[i]);
		}
	    if (selData == null)
			combo.select(0);
	    else
			selectCCombo(combo, selData);	    


	public static void selectCCombo(CCombo combo, String selData)	{
		int n_sel = combo.indexOf(selData);
		if (0 > n_sel)
			n_sel = 0;
	    combo.select(n_sel);
	} 










	/**
	 * Create a selection combo
	 *

		
	public static Combo createSelectCombo(Composite parent, String strdata, String selData, int style) {
		Combo combo = new Combo(parent, style);
		combo.setFont(parent.getFont());
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		combo.setLayoutData(data);
		StringTokenizer st = new StringTokenizer(strdata, ","); //$NON-NLS-1$
		while (st.hasMoreTokens())
			combo.add(st.nextToken());
	    if (selData == null || selData.length() == 0) {
	    	if (combo.getItemCount() > 0)
				combo.select(0);
	    } else {
			selectCombo(combo, selData);
	    }
	    else
			selectCombo(combo, selData);	    
		return combo;
	}


	/**
	 * Create a selection combo
	 *

	
	public static Combo createSelectCombo(Composite parent, String[] strdata, String selData, int style) {
		Combo combo = new Combo(parent, style);
		combo.setFont(parent.getFont());
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		combo.setLayoutData(data);
		for (int i = 0; i < strdata.length; ++i) {
			combo.add(strdata[i]);
		}
	    if (selData == null)
			combo.select(0);
	    else
			selectCombo(combo, selData);	    


	public static void selectCombo(Combo combo, String selData)	{
		int n_sel = combo.indexOf(selData);
		if (0 > n_sel) {
			if ((combo.getStyle() & SWT.READ_ONLY) == 0) {
				combo.setText( selData );
				return;
			}

	    combo.select(n_sel);
	} 











    /**
	 * Create a dialog shell, child to the top level workbench shell.
	 *

        return new Shell( parent, SWT.DIALOG_TRIM );
    }

	

	public static Composite insertSpace(Composite parent, int nSpan, int height) {
		Composite space = ControlFactory.createCompositeSeparator(parent, parent.getBackground(),
			 (SWT.DEFAULT != height ? height : 5));

    public static MessageBox createOkCancelDialog( String title, String message ) {
        return createDialog( title, message, SWT.OK | SWT.CANCEL | SWT.ICON_INFORMATION );
    }
	
}

Lines 8-18 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/CSourceViewerConfiguration.java (-61 / +217 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* QNX Software System	10	* QNX Software System
		11	* Sergey Prigogin, Google
11	*******************************************************************************/	12	*******************************************************************************/
12	package org.eclipse.cdt.internal.ui.text;	13	package org.eclipse.cdt.internal.ui.text;
13		14
14	import java.util.Vector;	15	import java.util.Vector;
15		16
		17	import org.eclipse.core.resources.IFile;
		18	import org.eclipse.core.runtime.CoreException;
		19	import org.eclipse.core.runtime.IPath;
		20	import org.eclipse.core.runtime.content.IContentType;
16	import org.eclipse.jface.dialogs.IDialogSettings;	21	import org.eclipse.jface.dialogs.IDialogSettings;
17	import org.eclipse.jface.preference.IPreferenceStore;	22	import org.eclipse.jface.preference.IPreferenceStore;
18	import org.eclipse.jface.text.DefaultInformationControl;	23	import org.eclipse.jface.text.DefaultInformationControl;
Lines 41-60 Link Here
41	import org.eclipse.jface.text.source.IAnnotationHover;	46	import org.eclipse.jface.text.source.IAnnotationHover;
42	import org.eclipse.jface.text.source.ISourceViewer;	47	import org.eclipse.jface.text.source.ISourceViewer;
43	import org.eclipse.jface.text.source.SourceViewerConfiguration;	48	import org.eclipse.jface.text.source.SourceViewerConfiguration;
		49	import org.eclipse.jface.util.Assert;
44	import org.eclipse.jface.util.PropertyChangeEvent;	50	import org.eclipse.jface.util.PropertyChangeEvent;
45	import org.eclipse.swt.SWT;	51	import org.eclipse.swt.SWT;
46	import org.eclipse.swt.widgets.Shell;	52	import org.eclipse.swt.widgets.Shell;
47	import org.eclipse.ui.IEditorInput;	53	import org.eclipse.ui.IEditorInput;
		54	import org.eclipse.ui.IPathEditorInput;
		55	import org.eclipse.ui.editors.text.ILocationProvider;
48	import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;	56	import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;
		57	import org.eclipse.ui.ide.ResourceUtil;
49	import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;	58	import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
50	import org.eclipse.ui.texteditor.IDocumentProvider;	59	import org.eclipse.ui.texteditor.IDocumentProvider;
51	import org.eclipse.ui.texteditor.ITextEditor;	60	import org.eclipse.ui.texteditor.ITextEditor;
52		61
		62	import org.eclipse.cdt.core.CCorePlugin;
53	import org.eclipse.cdt.core.dom.ast.gnu.c.GCCLanguage;	63	import org.eclipse.cdt.core.dom.ast.gnu.c.GCCLanguage;
54	import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;	64	import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;
55	import org.eclipse.cdt.core.model.ICElement;	65	import org.eclipse.cdt.core.model.ICElement;
56	import org.eclipse.cdt.core.model.ICProject;	66	import org.eclipse.cdt.core.model.ICProject;
57	import org.eclipse.cdt.core.model.ILanguage;	67	import org.eclipse.cdt.core.model.ILanguage;
		68	import org.eclipse.cdt.core.model.ITranslationUnit;
		69	import org.eclipse.cdt.core.model.LanguageManager;
58	import org.eclipse.cdt.ui.CElementContentProvider;	70	import org.eclipse.cdt.ui.CElementContentProvider;
59	import org.eclipse.cdt.ui.CUIPlugin;	71	import org.eclipse.cdt.ui.CUIPlugin;
60	import org.eclipse.cdt.ui.ILanguageUI;	72	import org.eclipse.cdt.ui.ILanguageUI;
Lines 63-69 Link Here
63	import org.eclipse.cdt.internal.ui.editor.CDocumentProvider;	75	import org.eclipse.cdt.internal.ui.editor.CDocumentProvider;
64	import org.eclipse.cdt.internal.ui.editor.CEditor;	76	import org.eclipse.cdt.internal.ui.editor.CEditor;
65	import org.eclipse.cdt.internal.ui.editor.CElementHyperlinkDetector;	77	import org.eclipse.cdt.internal.ui.editor.CElementHyperlinkDetector;
66	import org.eclipse.cdt.internal.ui.editor.CSourceViewer;
67	import org.eclipse.cdt.internal.ui.text.c.hover.CEditorTextHoverDescriptor;	78	import org.eclipse.cdt.internal.ui.text.c.hover.CEditorTextHoverDescriptor;
68	import org.eclipse.cdt.internal.ui.text.c.hover.CEditorTextHoverProxy;	79	import org.eclipse.cdt.internal.ui.text.c.hover.CEditorTextHoverProxy;
69	import org.eclipse.cdt.internal.ui.text.contentassist.CCompletionProcessor2;	80	import org.eclipse.cdt.internal.ui.text.contentassist.CCompletionProcessor2;
Lines 71-152 Link Here
71		82
72		83
73	/**	84	/**
74	* Configuration for an <code>SourceViewer</code> which shows C code.	85	* Configuration for an <code>SourceViewer</code> which shows C/C++ code.
75	*/	86	*/
76	public class CSourceViewerConfiguration extends TextSourceViewerConfiguration {	87	public class CSourceViewerConfiguration extends TextSourceViewerConfiguration {
77		88
78	private CTextTools fTextTools;	89	private CTextTools fTextTools;
79	private CEditor fEditor;	90	private ITextEditor fTextEditor;
		91	/**
		92	* The document partitioning.
		93	*/
		94	private String fDocumentPartitioning;
		95	/**
		96	* The C++ source code scanner.
		97	*/
		98	private AbstractCScanner fCppCodeScanner;
		99	/**
		100	* The C source code scanner.
		101	*/
		102	private AbstractCScanner fCCodeScanner;
		103	/**
		104	* The C multi-line comment scanner.
		105	*/
		106	private AbstractCScanner fMultilineCommentScanner;
		107	/**
		108	* The C single-line comment scanner.
		109	*/
		110	private AbstractCScanner fSinglelineCommentScanner;
		111	/**
		112	* The C string scanner.
		113	*/
		114	private AbstractCScanner fStringScanner;
		115	/**
		116	* The color manager.
		117	*/
		118	private IColorManager fColorManager;
80		119
81	/**	120	/**
		121	* Creates a new C source viewer configuration for viewers in the given editor
		122	* using the given preference store, the color manager and the specified document partitioning.
		123	* <p>
		124	* Creates a C source viewer configuration in the new setup without text tools. Clients are
		125	* allowed to call {@link CSourceViewerConfiguration#handlePropertyChangeEvent(PropertyChangeEvent)}
		126	* and disallowed to call {@link CSourceViewerConfiguration#getPreferenceStore()} on the resulting
		127	* C source viewer configuration.
		128	* </p>
		129	*
		130	* @param colorManager the color manager
		131	* @param preferenceStore the preference store, can be read-only
		132	* @param editor the editor in which the configured viewer(s) will reside, or <code>null</code> if none
		133	* @param partitioning the document partitioning for this configuration, or <code>null</code> for the default partitioning
		134	*/
		135	public CSourceViewerConfiguration(IColorManager colorManager, IPreferenceStore preferenceStore, ITextEditor editor, String partitioning) {
		136	super(preferenceStore);
		137	fColorManager= colorManager;
		138	fTextEditor= editor;
		139	fDocumentPartitioning= partitioning;
		140	initializeScanners();
		141	}
		142
		143	/**
82	* Creates a new C source viewer configuration for viewers in the given editor using	144	* Creates a new C source viewer configuration for viewers in the given editor using
83	* the given C tools collection.	145	* the given C tools collection.
84	*	146	*
85	* @param tools the C text tools collection to be used	147	* @param tools the C text tools collection to be used
86	* @param editor the editor in which the configured viewer will reside	148	* @param editor the editor in which the configured viewer will reside
87	*/	149	*/
88	public CSourceViewerConfiguration(CTextTools tools, CEditor editor) {	150	public CSourceViewerConfiguration(CTextTools tools, ITextEditor editor) {
89	super(CUIPlugin.getDefault().getCombinedPreferenceStore());	151	super(CUIPlugin.getDefault().getCombinedPreferenceStore());
90	fTextTools= tools;	152	fTextTools= tools;
91	fEditor= editor;	153	fColorManager= tools.getColorManager();
		154	fTextEditor= editor;
		155	fDocumentPartitioning= fTextTools.getDocumentPartitioning();
		156	fCppCodeScanner= (AbstractCScanner) fTextTools.getCppCodeScanner();
		157	fCCodeScanner= (AbstractCScanner) fTextTools.getCCodeScanner();
		158	fMultilineCommentScanner= (AbstractCScanner) fTextTools.getMultilineCommentScanner();
		159	fSinglelineCommentScanner= (AbstractCScanner) fTextTools.getSinglelineCommentScanner();
		160	fStringScanner= (AbstractCScanner) fTextTools.getStringScanner();
92	}	161	}
93		162
94	/**	163	/**
95	* Returns the C multiline comment scanner for this configuration.	164	* Returns the C multi-line comment scanner for this configuration.
96	*	165	*
97	* @return the C multiline comment scanner	166	* @return the C multi-line comment scanner
98	*/	167	*/
99	protected RuleBasedScanner getMultilineCommentScanner() {	168	protected RuleBasedScanner getMultilineCommentScanner() {
100	return fTextTools.getMultilineCommentScanner();	169	return fMultilineCommentScanner;
101	}	170	}
102		171
103	/**	172	/**
104	* Returns the C singleline comment scanner for this configuration.	173	* Returns the C single-line comment scanner for this configuration.
105	*	174	*
106	* @return the C singleline comment scanner	175	* @return the C single-line comment scanner
107	*/	176	*/
108	protected RuleBasedScanner getSinglelineCommentScanner() {	177	protected RuleBasedScanner getSinglelineCommentScanner() {
109	return fTextTools.getSinglelineCommentScanner();	178	return fSinglelineCommentScanner;
110	}	179	}
111		180
112	/**	181	/**
113	* Returns the C string scanner for this configuration.	182	* Returns the C string scanner for this configuration.
114	*	183	*
115	* @return the C string scanner	184	* @return the C string scanner
116	*/	185	*/
117	protected RuleBasedScanner getStringScanner() {	186	protected RuleBasedScanner getStringScanner() {
118	return fTextTools.getStringScanner();	187	return fStringScanner;
119	}	188	}
120		189
121	/**	190	/**
122	* Returns the color manager for this configuration.	191	* Returns the color manager for this configuration.
123	*	192	*
124	* @return the color manager	193	* @return the color manager
125	*/	194	*/
126	protected IColorManager getColorManager() {	195	protected IColorManager getColorManager() {
127	return fTextTools.getColorManager();	196	return fColorManager;
128	}	197	}
129		198
130	/**	199	/**
131	* Returns the editor in which the configured viewer(s) will reside.	200	* Returns the editor in which the configured viewer(s) will reside.
132	*	201	*
133	* @return the enclosing editor	202	* @return the enclosing editor
134	*/	203	*/
135	protected ITextEditor getEditor() {	204	public ITextEditor getEditor() {
136	return fEditor;	205	return fTextEditor;
137	}	206	}
138		207
139
140	/**	208	/**
141	* Creates outline presenter.	209	* Creates outline presenter.
142	* @param editor Editor.
143	* @return Presenter with outline view.	210	* @return Presenter with outline view.
144	*/	211	*/
145	public IInformationPresenter getOutlinePresenter(CEditor editor)	212	public IInformationPresenter getOutlinePresenter(ISourceViewer sourceViewer) {
146	{	213	final IInformationControlCreator outlineControlCreator = getOutlineContolCreator();
147	final IInformationControlCreator outlineControlCreator = getOutlineContolCreator(editor);
148	final InformationPresenter presenter = new InformationPresenter(outlineControlCreator);	214	final InformationPresenter presenter = new InformationPresenter(outlineControlCreator);
149	presenter.setDocumentPartitioning(getConfiguredDocumentPartitioning(null));	215	presenter.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));
150	final IInformationProvider provider = new CElementContentProvider(getEditor());	216	final IInformationProvider provider = new CElementContentProvider(getEditor());
151	presenter.setInformationProvider(provider, IDocument.DEFAULT_CONTENT_TYPE);	217	presenter.setInformationProvider(provider, IDocument.DEFAULT_CONTENT_TYPE);
152	presenter.setInformationProvider(provider, ICPartitions.C_MULTI_LINE_COMMENT);	218	presenter.setInformationProvider(provider, ICPartitions.C_MULTI_LINE_COMMENT);
Lines 158-186 Link Here
158	return presenter;	224	return presenter;
159	}	225	}
160		226
		227	/**
		228	* Initializes the scanners.
		229	*/
		230	private void initializeScanners() {
		231	Assert.isTrue(isNewSetup());
		232	fCppCodeScanner= new CppCodeScanner(getColorManager(), fPreferenceStore);
		233	fCCodeScanner= new CppCodeScanner(getColorManager(), fPreferenceStore);
		234	fMultilineCommentScanner= new CCommentScanner(getColorManager(), fPreferenceStore, ICColorConstants.C_MULTI_LINE_COMMENT);
		235	fSinglelineCommentScanner= new CCommentScanner(getColorManager(), fPreferenceStore, ICColorConstants.C_SINGLE_LINE_COMMENT);
		236	fStringScanner= new SingleTokenCScanner(getColorManager(), fPreferenceStore, ICColorConstants.C_STRING);
		237	}
		238
161	/**	239	/**
162	* @see org.eclipse.jface.text.source.SourceViewerConfiguration#getPresentationReconciler(org.eclipse.jface.text.source.ISourceViewer)	240	* @see org.eclipse.jface.text.source.SourceViewerConfiguration#getPresentationReconciler(org.eclipse.jface.text.source.ISourceViewer)
163	*/	241	*/
164	public IPresentationReconciler getPresentationReconciler(ISourceViewer sourceViewer) {	242	public IPresentationReconciler getPresentationReconciler(ISourceViewer sourceViewer) {
165
166	PresentationReconciler reconciler= new PresentationReconciler();	243	PresentationReconciler reconciler= new PresentationReconciler();
167	reconciler.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));	244	reconciler.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));
168		245
169	RuleBasedScanner scanner = null;	246	RuleBasedScanner scanner = null;
170	if(sourceViewer instanceof CSourceViewer) {	247	ILanguage language = getLanguage();
171	ILanguage language = ((CSourceViewer)sourceViewer).getLanguage();	248	if (language instanceof GPPLanguage) {
172	if (language instanceof GPPLanguage) {	249	scanner = fCppCodeScanner;
173	scanner = fTextTools.getCppCodeScanner();	250	} else if (language instanceof GCCLanguage) {
174	} else if (language instanceof GCCLanguage) {	251	scanner = fCCodeScanner;
175	scanner = fTextTools.getCCodeScanner();	252	} else if (language != null) {
176	} else if (language != null) {	253	ILanguageUI languageUI = (ILanguageUI)language.getAdapter(ILanguageUI.class);
177	ILanguageUI languageUI = (ILanguageUI)language.getAdapter(ILanguageUI.class);	254	if (languageUI != null)
178	if (languageUI != null)	255	scanner = languageUI.getCodeScanner();
179	scanner = languageUI.getCodeScanner();
180	}
181	}	256	}
182	if (scanner == null) {	257	if (scanner == null) {
183	scanner= fTextTools.getCCodeScanner();	258	scanner= fCppCodeScanner;
184	}	259	}
185		260
186	DefaultDamagerRepairer dr= new DefaultDamagerRepairer(scanner);	261	DefaultDamagerRepairer dr= new DefaultDamagerRepairer(scanner);
Lines 238-247 Link Here
238	* @see SourceViewerConfiguration#getReconciler(ISourceViewer)	313	* @see SourceViewerConfiguration#getReconciler(ISourceViewer)
239	*/	314	*/
240	public IReconciler getReconciler(ISourceViewer sourceViewer) {	315	public IReconciler getReconciler(ISourceViewer sourceViewer) {
241	if (fEditor != null && fEditor.isEditable()) {	316	if (fTextEditor != null && fTextEditor.isEditable()) {
242	//Delay changed and non-incremental reconciler used due to	317	//Delay changed and non-incremental reconciler used due to
243	//PR 130089	318	//PR 130089
244	MonoReconciler reconciler= new MonoReconciler(new CReconcilingStrategy(fEditor), false);	319	MonoReconciler reconciler= new MonoReconciler(new CReconcilingStrategy(fTextEditor), false);
245	reconciler.setDelay(500);	320	reconciler.setDelay(500);
246	return reconciler;	321	return reconciler;
247	}	322	}
Lines 255-262 Link Here
255	String partitioning= getConfiguredDocumentPartitioning(sourceViewer);	330	String partitioning= getConfiguredDocumentPartitioning(sourceViewer);
256	if (ICPartitions.C_MULTI_LINE_COMMENT.equals(contentType))	331	if (ICPartitions.C_MULTI_LINE_COMMENT.equals(contentType))
257	return new IAutoEditStrategy[] { new CCommentAutoIndentStrategy() };	332	return new IAutoEditStrategy[] { new CCommentAutoIndentStrategy() };
258	// else if (ICPartitions.C_STRING.equals(contentType))	333	else if (ICPartitions.C_STRING.equals(contentType))
259	// return new IAutoEditStrategy[] { new SmartSemicolonAutoEditStrategy(partitioning), new JavaStringAutoIndentStrategy(partitioning) };	334	return new IAutoEditStrategy[] { /new SmartSemicolonAutoEditStrategy(partitioning),/ new CStringAutoIndentStrategy(partitioning, getProject()) };
260	else	335	else
261	return new IAutoEditStrategy[] { new CAutoIndentStrategy(partitioning, getProject()) };	336	return new IAutoEditStrategy[] { new CAutoIndentStrategy(partitioning, getProject()) };
262	}	337	}
Lines 337-344 Link Here
337	return new CAnnotationHover();	412	return new CAnnotationHover();
338	}	413	}
339		414
340
341
342	/*	415	/*
343	* @see SourceViewerConfiguration#getConfiguredTextHoverStateMasks(ISourceViewer, String)	416	* @see SourceViewerConfiguration#getConfiguredTextHoverStateMasks(ISourceViewer, String)
344	* @since 2.1	417	* @since 2.1
Lines 414-425 Link Here
414		487
415	formatter.setMasterStrategy(new CFormattingStrategy());	488	formatter.setMasterStrategy(new CFormattingStrategy());
416	return formatter;	489	return formatter;
417
418
419	}	490	}
420		491
421	public boolean affectsBehavior(PropertyChangeEvent event) {	492	public boolean affectsBehavior(PropertyChangeEvent event) {
422	return fTextTools.affectsBehavior(event);	493	return fCppCodeScanner.affectsBehavior(event)
		494	\|\| fMultilineCommentScanner.affectsBehavior(event)
		495	\|\| fSinglelineCommentScanner.affectsBehavior(event)
		496	\|\| fStringScanner.affectsBehavior(event);
423	}	497	}
424		498
425	/**	499	/**
Lines 436-441 Link Here
436	return CUIPlugin.getDefault().getPreferenceStore();	510	return CUIPlugin.getDefault().getPreferenceStore();
437	}	511	}
438		512
		513	/**
		514	* @return <code>true</code> iff the new setup without text tools is in use.
		515	*/
		516	private boolean isNewSetup() {
		517	return fTextTools == null;
		518	}
		519
439	/*	520	/*
440	* @see SourceViewerConfiguration#getHoverControlCreator(ISourceViewer)	521	* @see SourceViewerConfiguration#getHoverControlCreator(ISourceViewer)
441	* @since 2.0	522	* @since 2.0
Lines 444-450 Link Here
444	return getInformationControlCreator(sourceViewer, true);	525	return getInformationControlCreator(sourceViewer, true);
445	}	526	}
446		527
447
448	public IInformationControlCreator getInformationControlCreator(ISourceViewer sourceViewer, final boolean cutDown) {	528	public IInformationControlCreator getInformationControlCreator(ISourceViewer sourceViewer, final boolean cutDown) {
449	return new IInformationControlCreator() {	529	return new IInformationControlCreator() {
450	public IInformationControl createInformationControl(Shell parent) {	530	public IInformationControl createInformationControl(Shell parent) {
Lines 463-468 Link Here
463	return super.getInformationPresenter(sourceViewer);	543	return super.getInformationPresenter(sourceViewer);
464	}	544	}
465		545
		546	/**
		547	* Determines whether the preference change encoded by the given event
		548	* changes the behavior of one of its contained components.
		549	*
		550	* @param event the event to be investigated
		551	* @return <code>true</code> if event causes a behavioral change
		552	*/
		553	public boolean affectsTextPresentation(PropertyChangeEvent event) {
		554	return fCppCodeScanner.affectsBehavior(event)
		555	\|\| fCCodeScanner.affectsBehavior(event)
		556	\|\| fMultilineCommentScanner.affectsBehavior(event)
		557	\|\| fSinglelineCommentScanner.affectsBehavior(event)
		558	\|\| fStringScanner.affectsBehavior(event);
		559	}
		560
		561	/**
		562	* Adapts the behavior of the contained components to the change
		563	* encoded in the given event.
		564	* <p>
		565	* Clients are not allowed to call this method if the old setup with
		566	* text tools is in use.
		567	* </p>
		568	*
		569	* @param event the event to which to adapt
		570	* @see CSourceViewerConfiguration#CSourceViewerConfiguration(IColorManager, IPreferenceStore, ITextEditor, String)
		571	*/
		572	public void handlePropertyChangeEvent(PropertyChangeEvent event) {
		573	Assert.isTrue(isNewSetup());
		574	if (fCppCodeScanner.affectsBehavior(event))
		575	fCppCodeScanner.adaptToPreferenceChange(event);
		576	if (fCCodeScanner.affectsBehavior(event))
		577	fCCodeScanner.adaptToPreferenceChange(event);
		578	if (fMultilineCommentScanner.affectsBehavior(event))
		579	fMultilineCommentScanner.adaptToPreferenceChange(event);
		580	if (fSinglelineCommentScanner.affectsBehavior(event))
		581	fSinglelineCommentScanner.adaptToPreferenceChange(event);
		582	if (fStringScanner.affectsBehavior(event))
		583	fStringScanner.adaptToPreferenceChange(event);
		584	}
		585
466	/*	586	/*
467	* @see org.eclipse.jface.text.source.SourceViewerConfiguration#getHyperlinkDetectors(org.eclipse.jface.text.source.ISourceViewer)	587	* @see org.eclipse.jface.text.source.SourceViewerConfiguration#getHyperlinkDetectors(org.eclipse.jface.text.source.ISourceViewer)
468	* @since 3.1	588	* @since 3.1
Lines 473-484 Link Here
473		593
474	IHyperlinkDetector[] inheritedDetectors= super.getHyperlinkDetectors(sourceViewer);	594	IHyperlinkDetector[] inheritedDetectors= super.getHyperlinkDetectors(sourceViewer);
475		595
476	if (fEditor == null)	596	if (fTextEditor == null)
477	return inheritedDetectors;	597	return inheritedDetectors;
478		598
479	int inheritedDetectorsLength= inheritedDetectors != null ? inheritedDetectors.length : 0;	599	int inheritedDetectorsLength= inheritedDetectors != null ? inheritedDetectors.length : 0;
480	IHyperlinkDetector[] detectors= new IHyperlinkDetector[inheritedDetectorsLength + 1];	600	IHyperlinkDetector[] detectors= new IHyperlinkDetector[inheritedDetectorsLength + 1];
481	detectors[0]= new CElementHyperlinkDetector(fEditor);	601	detectors[0]= new CElementHyperlinkDetector(fTextEditor);
482	for (int i= 0; i < inheritedDetectorsLength; i++) {	602	for (int i= 0; i < inheritedDetectorsLength; i++) {
483	detectors[i+1]= inheritedDetectors[i];	603	detectors[i+1]= inheritedDetectors[i];
484	}	604	}
Lines 489-515 Link Here
489	/*	609	/*
490	* @see org.eclipse.jface.text.source.SourceViewerConfiguration#getConfiguredDocumentPartitioning(org.eclipse.jface.text.source.ISourceViewer)	610	* @see org.eclipse.jface.text.source.SourceViewerConfiguration#getConfiguredDocumentPartitioning(org.eclipse.jface.text.source.ISourceViewer)
491	*/	611	*/
492	public String getConfiguredDocumentPartitioning(ISourceViewer sourceViewer) {	612	public String getConfiguredDocumentPartitioning(ISourceViewer sourceViewer) {
493	return fTextTools.getDocumentPartitioning();	613	if (fDocumentPartitioning != null)
		614	return fDocumentPartitioning;
		615	return super.getConfiguredDocumentPartitioning(sourceViewer);
494	}	616	}
495		617
496	/**	618	/**
497	* Creates control for outline presentation in editor.	619	* Creates control for outline presentation in editor.
498	* @param editor Editor.
499	* @return Control.	620	* @return Control.
500	*/	621	*/
501	private IInformationControlCreator getOutlineContolCreator(final CEditor editor)	622	private IInformationControlCreator getOutlineContolCreator() {
502	{	623	final IInformationControlCreator conrolCreator = new IInformationControlCreator() {
503	final IInformationControlCreator conrolCreator = new IInformationControlCreator()
504	{
505	/**	624	/**
506	* @see org.eclipse.jface.text.IInformationControlCreator#createInformationControl(org.eclipse.swt.widgets.Shell)	625	* @see org.eclipse.jface.text.IInformationControlCreator#createInformationControl(org.eclipse.swt.widgets.Shell)
507	*/	626	*/
508	public IInformationControl createInformationControl(Shell parent)	627	public IInformationControl createInformationControl(Shell parent) {
509	{
510	int shellStyle= SWT.RESIZE;	628	int shellStyle= SWT.RESIZE;
511	int treeStyle= SWT.V_SCROLL \| SWT.H_SCROLL;	629	int treeStyle= SWT.V_SCROLL \| SWT.H_SCROLL;
512	return new COutlineInformationControl(editor, parent, shellStyle, treeStyle);	630	return new COutlineInformationControl(parent, shellStyle, treeStyle);
513	}	631	}
514	};	632	};
515	return conrolCreator;	633	return conrolCreator;
Lines 530-533 Link Here
530	return settings;	648	return settings;
531	}	649	}
532		650
		651	private ILanguage getLanguage() {
		652	if (fTextEditor == null) {
		653	return null;
		654	}
		655	ICElement element = CUIPlugin.getDefault().getWorkingCopyManager().getWorkingCopy(fTextEditor.getEditorInput());
		656	if (element instanceof ITranslationUnit) {
		657	try {
		658	return ((ITranslationUnit)element).getLanguage();
		659	} catch (CoreException e) {
		660	CUIPlugin.getDefault().log(e);
		661	}
		662	} else {
		663	// compute the language from the plain editor input
		664	IContentType contentType = null;
		665	IEditorInput input = fTextEditor.getEditorInput();
		666	IFile file = ResourceUtil.getFile(input);
		667	if (file != null) {
		668	contentType = CCorePlugin.getContentType(file.getProject(), file.getName());
		669	} else if (input instanceof IPathEditorInput) {
		670	IPath path = ((IPathEditorInput)input).getPath();
		671	contentType = CCorePlugin.getContentType(path.lastSegment());
		672	} else {
		673	ILocationProvider locationProvider = (ILocationProvider)input.getAdapter(ILocationProvider.class);
		674	if (locationProvider != null) {
		675	IPath path = locationProvider.getPath(input);
		676	contentType = CCorePlugin.getContentType(path.lastSegment());
		677	}
		678	}
		679	if (contentType != null) {
		680	try {
		681	return LanguageManager.getInstance().getLanguage(contentType);
		682	} catch (CoreException exc) {
		683	CUIPlugin.getDefault().log(exc.getStatus());
		684	}
		685	}
		686	}
		687	return null;
		688	}
533	}	689	}

Lines 82-87 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/CCommentScanner.java (+4 lines)
82	private String fDefaultTokenProperty;	82	private String fDefaultTokenProperty;
83	private String[] fTokenProperties;	83	private String[] fTokenProperties;
84		84
		85	public CCommentScanner(IColorManager manager, IPreferenceStore store, String defaultTokenProperty) {
		86	this(manager, store, null, defaultTokenProperty, new String[] { defaultTokenProperty, TASK_TAG });
		87	}
		88
85	public CCommentScanner(IColorManager manager, IPreferenceStore store, Preferences coreStore, String defaultTokenProperty) {	89	public CCommentScanner(IColorManager manager, IPreferenceStore store, Preferences coreStore, String defaultTokenProperty) {
86	this(manager, store, coreStore, defaultTokenProperty, new String[] { defaultTokenProperty, TASK_TAG });	90	this(manager, store, coreStore, defaultTokenProperty, new String[] { defaultTokenProperty, TASK_TAG });
87	}	91	}




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;


			prefIndentBracesForMethods= prefIndentBracesForMethods();
			prefIndentBracesForTypes= prefIndentBracesForTypes();
			prefHasGenerics= hasGenerics();
			prefTabChar= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR);
		}
		
		private boolean prefUseTabs() {
			return !CCorePlugin.SPACE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR));
		}

		private int prefTabSize() {

		}

		private int prefArrayIndent() {
			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER);
			try {
				if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)
					return 1;
			} catch (IllegalArgumentException e) {
				// ignore and return default

		}

		private boolean prefArrayDeepIndent() {
			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER);
			try {
				return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

		}

		private boolean prefTernaryDeepAlign() {
			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION);
			try {
				return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

		}

		private int prefTernaryIndent() {
			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION);
			try {
				if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)
					return 1;
				else
					return prefContinuationIndent();

		}

		private int prefCaseIndent() {
			if (DefaultCodeFormatterConstants.TRUE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH)))
				return prefBlockIndent();
			else
				return 0;

			if (true)
				return prefBlockIndent();

			if (DefaultCodeFormatterConstants.TRUE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES)))
				return prefBlockIndent();
			else
				return 0;

		}

		private boolean prefMethodDeclDeepIndent() {
			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);
			try {
				return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

		}

		private int prefMethodDeclIndent() {
			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);
			try {
				if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)
					return 1;
				else
					return prefContinuationIndent();

		}

		private boolean prefMethodCallDeepIndent() {
			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);
			try {
				return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

		}

		private int prefMethodCallIndent() {
			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);
			try {
				if (DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_BY_ONE)
					return 1;
				else
					return prefContinuationIndent();

			if (true) // don't do parenthesis deep indentation
				return false;

			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION);
			try {
				return DefaultCodeFormatterConstants.getIndentStyle(option) == DefaultCodeFormatterConstants.INDENT_ON_COLUMN;
			} catch (IllegalArgumentException e) {
				// ignore and return default
			}

		}

		private int prefBlockIndent() {
			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK);
			if (DefaultCodeFormatterConstants.FALSE.equals(option))
				return 0;

			return 1; // sensible default
		}

		private int prefMethodBodyIndent() {
			if (DefaultCodeFormatterConstants.FALSE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY)))
				return 0;

			return 1; // sensible default
		}

		private int prefTypeIndent() {
			String option= getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER);
			if (DefaultCodeFormatterConstants.FALSE.equals(option))
				return 0;

			return 1; // sensible default
		}

		private boolean prefIndentBracesForBlocks() {
			return DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK));
		}

		private boolean prefIndentBracesForArrays() {
			return DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER));
		}

		private boolean prefIndentBracesForMethods() {
			return DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION));
		}

		private boolean prefIndentBracesForTypes() {
			return DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION));
		}

		private int prefContinuationIndent() {
			try {
				return Integer.parseInt(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION));
			} catch (NumberFormatException e) {
				// ignore and return default
			}

			return 2; // sensible default
		}
		
		private boolean hasGenerics() {
			return true;
		}

	 * (method defs, array initializers)
	 */
	private int fAlign;
	/** The stateful scan position for the indentation methods. */
	private int fPosition;
	/** The previous position. */
	private int fPreviousPos;

	 *         if it cannot be determined
	 */
	private StringBuffer getReferenceIndentation(int offset, boolean assumeOpeningBrace) {

		int unit;
		if (assumeOpeningBrace)
			unit= findReferencePosition(offset, Symbols.TokenLBRACE);

			return null;

		return getLeadingWhitespace(unit);

	}

	/**

	 *         determined
	 */
	public StringBuffer computeIndentation(int offset, boolean assumeOpeningBrace) {

		StringBuffer reference= getReferenceIndentation(offset, assumeOpeningBrace);

		// handle special alignment

		if (reference == null)
			return null;

		// Add additional indent
		return createReusingIndent(reference, fIndent);
	}

	/**
	 * Computes the indentation for a continuation line at <code>offset</code>.
	 *
	 * @param offset the offset in the document
	 * @return a StringBuffer which reflects the correct indentation for
	 *         the line in  which offset resides, or <code>null</code> if it cannot be
	 *         determined.
	 * @throws BadLocationException
	 */
	public StringBuffer computeContinuationLineIndentation(int offset) throws BadLocationException {
		StringBuffer reference= getLeadingWhitespace(offset);
		IRegion line= fDocument.getLineInformationOfOffset(offset);
		String string= fDocument.get(line.getOffset(), offset - line.getOffset());
		if (string.trim().length() == 0)
			return reference;
		// Add additional indent
		return createReusingIndent(reference, fPrefs.prefContinuationIndent);
	}
	
	/**
	 * Computes the length of a <code>CharacterSequence</code>, counting
	 * a tab character as the size until the next tab stop and every other
	 * character as one.

		try {
			int spaces= 0;
			while (start < indent) {

				char ch= fDocument.getChar(start);
				if (ch == '\t') {
					ret.append('\t');

	 * @return the modified <code>buffer</code> reflecting the indentation
	 *         adapted to <code>additional</code>
	 */
	public StringBuffer createReusingIndent(StringBuffer buffer, int additional) {
		int refLength= computeVisualLength(buffer);
		int addLength= fPrefs.prefIndentationSize * additional; // may be < 0
		int totalLength= Math.max(0, refLength + addLength);


		// copy the reference indentation for the indent up to the last tab
		// stop within the maxCopy area
		int minLength= Math.min(totalLength, refLength);

		int maxCopyLength= tabSize > 0 ? minLength - minLength % tabSize : minLength; // maximum indent to copy
		stripExceedingChars(buffer, maxCopyLength);


		// add additional indent
		int missing= totalLength - maxCopyLength;
		final int tabs, spaces;

		} else if (CCorePlugin.TAB.equals(fPrefs.prefTabChar)) {
			tabs= tabSize > 0 ? missing / tabSize : 0;
			spaces= tabSize > 0 ? missing % tabSize : missing;
		} else if (DefaultCodeFormatterConstants.MIXED.equals(fPrefs.prefTabChar)) {
			tabs= tabSize > 0 ? missing / tabSize : 0;
			spaces= tabSize > 0 ? missing % tabSize : missing;
		} else {
			Assert.isTrue(false);
			return null;
		}
		for (int i= 0; i < tabs; i++)
			buffer.append('\t');
		for (int i= 0; i < spaces; i++)
			buffer.append(' ');
		return buffer;
	}

				// if we are inside a continued expression, then either align with a previous line that has indentation
				// or indent from the expression start line (either a scope introducer or the start of the expr).
				return skipToPreviousListItemOrListStart();

		}
	}





 *
 * Contributors:
 *     QNX Software Systems - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/
/*
 * COutlineInformationControl.java 2004-12-14 / 08:17:41

import org.eclipse.cdt.internal.core.model.CElement;
import org.eclipse.cdt.internal.ui.CPluginImages;
import org.eclipse.cdt.internal.ui.actions.ActionMessages;
import org.eclipse.cdt.internal.ui.actions.OpenActionUtil;
import org.eclipse.cdt.internal.ui.editor.CContentOutlinerProvider;
import org.eclipse.cdt.internal.ui.editor.CEditor;
import org.eclipse.cdt.internal.ui.util.ProblemTreeViewer;
import org.eclipse.cdt.internal.ui.viewsupport.DecoratingCLabelProvider;
import org.eclipse.cdt.internal.ui.viewsupport.StandardCElementLabelProvider;

import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.cdt.ui.CElementGrouping;
import org.eclipse.cdt.ui.CUIPlugin;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.IInformationControlExtension;
import org.eclipse.jface.text.IInformationControlExtension2;
import org.eclipse.jface.text.IInformationControlExtension3;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;

 * @author P.Tomaszewski
 */
public class COutlineInformationControl implements IInformationControl,
        IInformationControlExtension, IInformationControlExtension2,
        IInformationControlExtension3 {

    /** If this option is set, location is not restored. */
    private static final String STORE_RESTORE_SIZE= "ENABLE_RESTORE_SIZE"; //$NON-NLS-1$

    /** Minimum width set by setSizeConstrains to tree viewer. */
    private static final int MIN_WIDTH = 300;

	private ICElement fInput = null;
	
    /** Shell for this control. */
    Shell fShell;
    /** Control's composite. */

    /**
     * Creates new outline control.
     * 
     * @param editor
     *            CEditor editor which uses this control.
     * @param parent
     *            Shell parent.
     * @param shellStyle

     * @param treeStyle
     *            Style of the tree viewer.
     */
    public COutlineInformationControl(Shell parent, int shellStyle, int treeStyle) {
            int shellStyle, int treeStyle) {
        super();
        this.fEditor = editor;
        createShell(parent, shellStyle);
        createComposite();
        createToolbar();

        createTreeeViewer(treeStyle);
    }

	/**
	 * {@inheritDoc}
	 */
	public void setInput(Object information) {
		if (information == null || information instanceof String) {
			inputChanged(null, null);
			return;
		}
		ICElement ce = (ICElement)information;
		ITranslationUnit tu = (ITranslationUnit)ce.getAncestor(ICElement.C_UNIT);
		if (tu != null)
			fInput = tu;

		inputChanged(fInput, information);
	}

	protected void inputChanged(Object newInput, Object newSelection) {
		fFilterText.setText(""); //$NON-NLS-1$
		fTreeViewer.setInput(newInput);
		if (newSelection != null) {
			fTreeViewer.setSelection(new StructuredSelection(newSelection));
		}
	}

	/**
	 * @return the selected element
	 */
	protected Object getSelectedElement() {
		if (fTreeViewer == null)
			return null;

		return ((IStructuredSelection) fTreeViewer.getSelection()).getFirstElement();
	}

	private void gotoSelectedElement() {
		Object selectedElement= getSelectedElement();
		if (selectedElement != null) {
			try {
				dispose();
				OpenActionUtil.open(selectedElement, true);
			} catch (CoreException e) {
				CUIPlugin.getDefault().log(e);
			}
		}
	}

	/**
     * @see org.eclipse.jface.text.IInformationControl#setInformation(java.lang.String)
     */
    public void setInformation(String information) {

     * @param treeStyle Tree style.
     */
    private void createTreeeViewer(int treeStyle) {
        final IWorkingCopyManager manager = CUIPlugin.getDefault()
                .getWorkingCopyManager();
        fTreeViewer = new ProblemTreeViewer(fComposite, treeStyle);
        final Tree tree = fTreeViewer.getTree();
        tree.setLayoutData(new GridData(GridData.FILL_BOTH));

        fTreeViewer.setLabelProvider(new DecoratingCLabelProvider(
                new StandardCElementLabelProvider(), true));
        fTreeViewer.setAutoExpandLevel(AbstractTreeViewer.ALL_LEVELS);
        fTreeViewer.setInput(manager.getWorkingCopy(fEditor.getEditorInput()));
        tree.addKeyListener(createKeyListenerForTreeViewer());
        tree.addSelectionListener(createSelectionListenerForTreeViewer());
        tree.addMouseMoveListener(createMouseMoveListenerForTreeViewer());
        tree.addMouseListener(createMouseListenerForTreeViewer(tree));
    }

    /**

     * 
     * @return Created mouse listener.
     */
    private MouseListener createMouseListenerForTreeViewer(final Tree tree) {
        final MouseListener mouseListener = new MouseAdapter() {
			public void mouseUp(MouseEvent e) {
                final Tree tree = fTreeViewer.getTree();
                if (tree.getSelectionCount() < 1) {
                    return;
                }
                if (e.button != 1) {
                    return;
                }

				if (tree.getSelectionCount() < 1)
					return;

				if (e.button != 1)
					return;

				if (tree.equals(e.getSource())) {
					Object o= tree.getItem(new Point(e.x, e.y));
					TreeItem selection= tree.getSelection()[0];
					if (selection.equals(o))
						gotoSelectedElement();
				}
			}
                }
            }
        };
        return mouseListener;
    }

            /**
             * @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)
             */
			public void widgetDefaultSelected(SelectionEvent e) {
				gotoSelectedElement();
			}
                if (selection.length > 0) {
                    CElement selectedElement = (CElement) selection[0]
                            .getData();
                    fEditor.setSelection(selectedElement);
                    dispose();
                }
            }
        };
        return selectionListener;
    }

            fIsDeactivationActive = true;
        }
    }
    
}

Lines 16-22 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/CFormattingStrategy.java (-3 / +3 lines)
16		16
17	import org.eclipse.cdt.core.CCorePlugin;	17	import org.eclipse.cdt.core.CCorePlugin;
18	import org.eclipse.cdt.core.formatter.CodeFormatter;	18	import org.eclipse.cdt.core.formatter.CodeFormatter;
19	import org.eclipse.cdt.core.formatter.CodeFormatterConstants;	19	import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
20	import org.eclipse.cdt.core.model.CoreModel;	20	import org.eclipse.cdt.core.model.CoreModel;
21	import org.eclipse.cdt.core.parser.ParserLanguage;	21	import org.eclipse.cdt.core.parser.ParserLanguage;
22	import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;	22	import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;
Lines 142-149 Link Here
142	} else	142	} else
143	preferences= new HashMap(CCorePlugin.getOptions());	143	preferences= new HashMap(CCorePlugin.getOptions());
144		144
145	preferences.put(CodeFormatterConstants.FORMATTER_LANGUAGE, language);	145	preferences.put(DefaultCodeFormatterConstants.FORMATTER_LANGUAGE, language);
146	preferences.put(CodeFormatterConstants.FORMATTER_CURRENT_FILE, activeFile);	146	preferences.put(DefaultCodeFormatterConstants.FORMATTER_CURRENT_FILE, activeFile);
147		147
148	context.storeToMap(CUIPlugin.getDefault().getPreferenceStore(), preferences, false);	148	context.storeToMap(CUIPlugin.getDefault().getPreferenceStore(), preferences, false);
149	context.setProperty(FormattingContextProperties.CONTEXT_PREFERENCES, preferences);	149	context.setProperty(FormattingContextProperties.CONTEXT_PREFERENCES, preferences);

Lines 13-25 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/CAutoIndentStrategy.java (-18 / +445 lines)
13	*******************************************************************************/	13	*******************************************************************************/
14	package org.eclipse.cdt.internal.ui.text;	14	package org.eclipse.cdt.internal.ui.text;
15		15
		16	import org.eclipse.core.runtime.Assert;
16	import org.eclipse.jface.preference.IPreferenceStore;	17	import org.eclipse.jface.preference.IPreferenceStore;
17	import org.eclipse.jface.text.BadLocationException;	18	import org.eclipse.jface.text.BadLocationException;
18	import org.eclipse.jface.text.DefaultIndentLineAutoEditStrategy;	19	import org.eclipse.jface.text.DefaultIndentLineAutoEditStrategy;
		20	import org.eclipse.jface.text.Document;
19	import org.eclipse.jface.text.DocumentCommand;	21	import org.eclipse.jface.text.DocumentCommand;
		22	import org.eclipse.jface.text.DocumentRewriteSession;
		23	import org.eclipse.jface.text.DocumentRewriteSessionType;
20	import org.eclipse.jface.text.IDocument;	24	import org.eclipse.jface.text.IDocument;
21	import org.eclipse.jface.text.IRegion;	25	import org.eclipse.jface.text.IRegion;
22	import org.eclipse.jface.text.TextUtilities;	26	import org.eclipse.jface.text.TextUtilities;
		27	import org.eclipse.jface.text.rules.FastPartitioner;
23	import org.eclipse.ui.IEditorPart;	28	import org.eclipse.ui.IEditorPart;
24	import org.eclipse.ui.IWorkbenchPage;	29	import org.eclipse.ui.IWorkbenchPage;
25	import org.eclipse.ui.texteditor.ITextEditorExtension3;	30	import org.eclipse.ui.texteditor.ITextEditorExtension3;
Lines 29-39 Link Here
29	import org.eclipse.cdt.ui.PreferenceConstants;	34	import org.eclipse.cdt.ui.PreferenceConstants;
30	import org.eclipse.cdt.ui.text.ICPartitions;	35	import org.eclipse.cdt.ui.text.ICPartitions;
31		36
		37	import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;
		38
32	/**	39	/**
33	* Auto indent strategy sensitive to brackets.	40	* Auto indent strategy sensitive to brackets.
34	*/	41	*/
35	public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {	42	public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
36	private static final String MULTILINE_COMMENT_CLOSE = "*/"; //$NON-NLS-1$	43	private static final String MULTILINE_COMMENT_CLOSE = "*/"; //$NON-NLS-1$
		44	/** The line comment introducer. Value is "{@value}" */
		45	private static final String LINE_COMMENT= "//"; //$NON-NLS-1$
37	// private static final GCCScannerExtensionConfiguration C_GNU_SCANNER_EXTENSION = new GCCScannerExtensionConfiguration();	46	// private static final GCCScannerExtensionConfiguration C_GNU_SCANNER_EXTENSION = new GCCScannerExtensionConfiguration();
38		47
39	private static class CompilationUnitInfo {	48	private static class CompilationUnitInfo {
Lines 65-76 Link Here
65		74
66	// evaluate the line with the opening bracket that matches the closing bracket on the given line	75	// evaluate the line with the opening bracket that matches the closing bracket on the given line
67	protected int findMatchingOpenBracket(IDocument d, int line, int end, int closingBracketIncrease) throws BadLocationException {	76	protected int findMatchingOpenBracket(IDocument d, int line, int end, int closingBracketIncrease) throws BadLocationException {
68
69
70	int start = d.getLineOffset(line);	77	int start = d.getLineOffset(line);
71	int brackcount = getBracketCount(d, start, end, false) - closingBracketIncrease;	78	int brackcount = getBracketCount(d, start, end, false) - closingBracketIncrease;
72		79
73
74	// sum up the brackets counts of each line (closing brackets count negative,	80	// sum up the brackets counts of each line (closing brackets count negative,
75	// opening positive) until we find a line the brings the count to zero	81	// opening positive) until we find a line the brings the count to zero
76	while (brackcount < 0) {	82	while (brackcount < 0) {
Lines 85-91 Link Here
85	return line;	91	return line;
86	}	92	}
87		93
88
89	private int getBracketCount(IDocument d, int start, int end, boolean ignoreCloseBrackets) throws BadLocationException {	94	private int getBracketCount(IDocument d, int start, int end, boolean ignoreCloseBrackets) throws BadLocationException {
90	int bracketcount = 0;	95	int bracketcount = 0;
91	while (start < end) {	96	while (start < end) {
Lines 135-141 Link Here
135		140
136	// ----------- bracket counting ------------------------------------------------------	141	// ----------- bracket counting ------------------------------------------------------
137		142
138
139	private int getCommentEnd(IDocument d, int pos, int end) throws BadLocationException {	143	private int getCommentEnd(IDocument d, int pos, int end) throws BadLocationException {
140	while (pos < end) {	144	while (pos < end) {
141	char curr = d.getChar(pos);	145	char curr = d.getChar(pos);
Lines 183-189 Link Here
183	int start = d.getLineOffset(line);	187	int start = d.getLineOffset(line);
184	int whiteend = findEndOfWhiteSpace(d, start, c.offset);	188	int whiteend = findEndOfWhiteSpace(d, start, c.offset);
185		189
186
187	// shift only when line does not contain any text up to the closing bracket	190	// shift only when line does not contain any text up to the closing bracket
188	if (whiteend == c.offset) {	191	if (whiteend == c.offset) {
189	// evaluate the line with the opening bracket that matches out closing bracket	192	// evaluate the line with the opening bracket that matches out closing bracket
Lines 257-269 Link Here
257	if (d.get(lineOffset, p - lineOffset).trim().length() != 0)	260	if (d.get(lineOffset, p - lineOffset).trim().length() != 0)
258	return;	261	return;
259		262
260	// line of last javacode	263	// Line of last C code
261	int pos = scanner.findNonWhitespaceBackward(p, CHeuristicScanner.UNBOUND);	264	int pos = scanner.findNonWhitespaceBackward(p, CHeuristicScanner.UNBOUND);
262	if (pos == -1)	265	if (pos == -1)
263	return;	266	return;
264	int lastLine = d.getLineOfOffset(pos);	267	int lastLine = d.getLineOfOffset(pos);
265		268
266	// only shift if the last java line is further up and is a braceless block candidate	269	// Only shift if the last C line is further up and is a braceless block candidate
267	if (lastLine < line) {	270	if (lastLine < line) {
268	CIndenter indenter = new CIndenter(d, scanner, fProject);	271	CIndenter indenter = new CIndenter(d, scanner, fProject);
269	StringBuffer indent = indenter.computeIndentation(p, true);	272	StringBuffer indent = indenter.computeIndentation(p, true);
Lines 405-411 Link Here
405	* Finds a closing parenthesis to the left of <code>position</code> in document, where that parenthesis is only	408	* Finds a closing parenthesis to the left of <code>position</code> in document, where that parenthesis is only
406	* separated by whitespace from <code>position</code>. If no such parenthesis can be found, <code>position</code> is returned.	409	* separated by whitespace from <code>position</code>. If no such parenthesis can be found, <code>position</code> is returned.
407	*	410	*
408	* @param scanner the java heuristic scanner set up on the document	411	* @param scanner the C heuristic scanner set up on the document
409	* @param position the first character position in <code>document</code> to be considered	412	* @param position the first character position in <code>document</code> to be considered
410	* @return the position of a closing parenthesis left to <code>position</code> separated only by whitespace, or <code>position</code> if no parenthesis can be found	413	* @return the position of a closing parenthesis left to <code>position</code> separated only by whitespace, or <code>position</code> if no parenthesis can be found
411	*/	414	*/
Lines 519-524 Link Here
519	return false;	522	return false;
520	}	523	}
521		524
		525	/**
		526	* Installs a C partitioner with <code>document</code>.
		527	*
		528	* @param document the document
		529	*/
		530	private static void installCPartitioner(Document document) {
		531	String[] types= new String[] {
		532	ICPartitions.C_MULTI_LINE_COMMENT,
		533	ICPartitions.C_SINGLE_LINE_COMMENT,
		534	ICPartitions.C_STRING,
		535	ICPartitions.C_CHARACTER,
		536	IDocument.DEFAULT_CONTENT_TYPE
		537	};
		538	FastPartitioner partitioner= new FastPartitioner(new FastCPartitionScanner(), types);
		539	partitioner.connect(document);
		540	document.setDocumentPartitioner(ICPartitions.C_PARTITIONING, partitioner);
		541	}
		542
		543	/**
		544	* Installs a C partitioner with <code>document</code>.
		545	*
		546	* @param document the document
		547	*/
		548	private static void removeCPartitioner(Document document) {
		549	document.setDocumentPartitioner(ICPartitions.C_PARTITIONING, null);
		550	}
		551
		552	private void smartPaste(IDocument document, DocumentCommand command) {
		553	int newOffset= command.offset;
		554	int newLength= command.length;
		555	String newText= command.text;
		556
		557	try {
		558	CHeuristicScanner scanner= new CHeuristicScanner(document);
		559	CIndenter indenter= new CIndenter(document, scanner, fProject);
		560	int offset= newOffset;
		561
		562	// reference position to get the indent from
		563	int refOffset= indenter.findReferencePosition(offset);
		564	if (refOffset == CHeuristicScanner.NOT_FOUND)
		565	return;
		566	int peerOffset= getPeerPosition(document, command);
		567	peerOffset= indenter.findReferencePosition(peerOffset);
		568	refOffset= Math.min(refOffset, peerOffset);
		569
		570	// eat any WS before the insertion to the beginning of the line
		571	int firstLine= 1; // don't format the first line per default, as it has other content before it
		572	IRegion line= document.getLineInformationOfOffset(offset);
		573	String notSelected= document.get(line.getOffset(), offset - line.getOffset());
		574	if (notSelected.trim().length() == 0) {
		575	newLength += notSelected.length();
		576	newOffset= line.getOffset();
		577	firstLine= 0;
		578	}
		579
		580	// prefix: the part we need for formatting but won't paste
		581	IRegion refLine= document.getLineInformationOfOffset(refOffset);
		582	String prefix= document.get(refLine.getOffset(), newOffset - refLine.getOffset());
		583
		584	// handle the indentation computation inside a temporary document
		585	Document temp= new Document(prefix + newText);
		586	DocumentRewriteSession session= temp.startRewriteSession(DocumentRewriteSessionType.STRICTLY_SEQUENTIAL);
		587	scanner= new CHeuristicScanner(temp);
		588	indenter= new CIndenter(temp, scanner, fProject);
589	installCPartitioner(temp);
590
591	// indent the first and second line
592	// compute the relative indentation difference from the second line
593	// (as the first might be partially selected) and use the value to
594	// indent all other lines.
595	boolean isIndentDetected= false;
596	StringBuffer addition= new StringBuffer();
597	int insertLength= 0;
598	int first= document.computeNumberOfLines(prefix) + firstLine; // don't format first line
599	int lines= temp.getNumberOfLines();
600	boolean changed= false;
601
602	for (int l= first; l < lines; l++) { // we don't change the number of lines while adding indents
603	IRegion r= temp.getLineInformation(l);
604	int lineOffset= r.getOffset();
605	int lineLength= r.getLength();
606
607	if (lineLength == 0) // don't modify empty lines
608	continue;
609
610	if (!isIndentDetected) {
611	// indent the first pasted line
612	String current= getCurrentIndent(temp, l);
613	StringBuffer correct= indenter.computeIndentation(lineOffset);
614	if (correct == null)
615	return; // bail out
616
617	insertLength= subtractIndent(correct, current, addition);
618	if (l != first && temp.get(lineOffset, lineLength).trim().length() != 0) {
619	isIndentDetected= true;
620	if (insertLength == 0) {
621	// no adjustment needed, bail out
622	if (firstLine == 0) {
623	// but we still need to adjust the first line
624	command.offset= newOffset;
625	command.length= newLength;
626	if (changed)
627	break; // still need to get the leading indent of the first line
628	}
629	return;
630	}
631	removeCPartitioner(temp);
632	} else {
633	changed= insertLength != 0;
634	}
635	}
636
637	// relatively indent all pasted lines
638	if (insertLength > 0)
639	addIndent(temp, l, addition);
640	else if (insertLength < 0)
641	cutIndent(temp, l, -insertLength);
642	}
643
644	temp.stopRewriteSession(session);
645	newText= temp.get(prefix.length(), temp.getLength() - prefix.length());
646
647	command.offset= newOffset;
648	command.length= newLength;
649	command.text= newText;
650	} catch (BadLocationException e) {
651	CUIPlugin.getDefault().log(e);
652	}
653	}
654
655	/**
656	* Returns the indentation of the line <code>line</code> in <code>document</code>.
657	* The returned string may contain pairs of leading slashes that are considered
658	* part of the indentation. The space before the asterix in a javadoc-like
659	* comment is not considered part of the indentation.
660	*
661	* @param document the document
662	* @param line the line
663	* @return the indentation of <code>line</code> in <code>document</code>
664	* @throws BadLocationException if the document is changed concurrently
665	*/
666	private static String getCurrentIndent(Document document, int line) throws BadLocationException {
667	IRegion region= document.getLineInformation(line);
668	int from= region.getOffset();
669	int endOffset= region.getOffset() + region.getLength();
670
671	// go behind line comments
672	int to= from;
673	while (to < endOffset - 2 && document.get(to, 2).equals(LINE_COMMENT))
674	to += 2;
675
676	while (to < endOffset) {
677	char ch= document.getChar(to);
678	if (!Character.isWhitespace(ch))
679	break;
680	to++;
681	}
682
683	// don't count the space before javadoc like, asterix-style comment lines
684	if (to > from && to < endOffset - 1 && document.get(to - 1, 2).equals(" *")) { //$NON-NLS-1$
685	String type= TextUtilities.getContentType(document, ICPartitions.C_PARTITIONING, to, true);
686	if (type.equals(ICPartitions.C_MULTI_LINE_COMMENT))
687	to--;
688	}
689
690	return document.get(from, to - from);
691	}
692
693	/**
694	* Computes the difference of two indentations and returns the difference in
695	* length of current and correct. If the return value is positive, <code>addition</code>
696	* is initialized with a substring of that length of <code>correct</code>.
697	*
698	* @param correct the correct indentation
699	* @param current the current indentation (migth contain non-whitespace)
700	* @param difference a string buffer - if the return value is positive, it will be cleared and set to the substring of <code>current</code> of that length
701	* @return the difference in lenght of <code>correct</code> and <code>current</code>
702	*/
703	private int subtractIndent(CharSequence correct, CharSequence current, StringBuffer difference) {
704	int c1= computeVisualLength(correct);
705	int c2= computeVisualLength(current);
706	int diff= c1 - c2;
707	if (diff <= 0)
708	return diff;
709
710	difference.setLength(0);
711	int len= 0, i= 0;
712	while (len < diff) {
713	char c= correct.charAt(i++);
714	difference.append(c);
715	len += computeVisualLength(c);
716	}
717
718	return diff;
719	}
720
721	/**
722	* Indents line <code>line</code> in <code>document</code> with <code>indent</code>.
723	* Leaves leading comment signs alone.
724	*
725	* @param document the document
726	* @param line the line
727	* @param indent the indentation to insert
728	* @throws BadLocationException on concurrent document modification
729	*/
730	private static void addIndent(Document document, int line, CharSequence indent) throws BadLocationException {
731	IRegion region= document.getLineInformation(line);
732	int insert= region.getOffset();
733	int endOffset= region.getOffset() + region.getLength();
734
735	// go behind line comments
736	while (insert < endOffset - 2 && document.get(insert, 2).equals(LINE_COMMENT))
737	insert += 2;
738
739	// insert indent
740	document.replace(insert, 0, indent.toString());
741	}
742
743	/**
744	* Cuts the visual equivalent of <code>toDelete</code> characters out of the
745	* indentation of line <code>line</code> in <code>document</code>. Leaves
746	* leading comment signs alone.
747	*
748	* @param document the document
749	* @param line the line
750	* @param toDelete the number of space equivalents to delete.
751	* @throws BadLocationException on concurrent document modification
752	*/
753	private void cutIndent(Document document, int line, int toDelete) throws BadLocationException {
754	IRegion region= document.getLineInformation(line);
755	int from= region.getOffset();
756	int endOffset= region.getOffset() + region.getLength();
757
758	// go behind line comments
759	while (from < endOffset - 2 && document.get(from, 2).equals(LINE_COMMENT))
760	from += 2;
761
762	int to= from;
763	while (toDelete > 0 && to < endOffset) {
764	char ch= document.getChar(to);
765	if (!Character.isWhitespace(ch))
766	break;
767	toDelete -= computeVisualLength(ch);
768	if (toDelete >= 0)
769	to++;
770	else
771	break;
772	}
773
774	document.replace(from, to - from, null);
775	}
776
777	/**
778	* Returns the visual length of a given <code>CharSequence</code> taking into
779	* account the visual tabulator length.
780	*
781	* @param seq the string to measure
782	* @return the visual length of <code>seq</code>
783	*/
784	private int computeVisualLength(CharSequence seq) {
785	int size= 0;
786	int tablen= getVisualTabLengthPreference();
787
788	for (int i= 0; i < seq.length(); i++) {
789	char ch= seq.charAt(i);
790	if (ch == '\t') {
791	if (tablen != 0)
792	size += tablen - size % tablen;
793	// else: size stays the same
794	} else {
795	size++;
796	}
797	}
798	return size;
799	}
800
801	/**
802	* Returns the visual length of a given character taking into
803	* account the visual tabulator length.
804	*
805	* @param ch the character to measure
806	* @return the visual length of <code>ch</code>
807	*/
808	private int computeVisualLength(char ch) {
809	if (ch == '\t')
810	return getVisualTabLengthPreference();
811	else
812	return 1;
813	}
814
815	/**
816	* The preference setting for the visual tabulator display.
817	*
818	* @return the number of spaces displayed for a tabulator in the editor
819	*/
820	private int getVisualTabLengthPreference() {
821	return CodeFormatterUtil.getTabWidth(fProject);
822	}
823
824	private int getPeerPosition(IDocument document, DocumentCommand command) {
825	if (document.getLength() == 0)
826	return 0;
827	/*
828	* Search for scope closers in the pasted text and find their opening peers
829	* in the document.
830	*/
831	Document pasted= new Document(command.text);
832	installCPartitioner(pasted);
833	int firstPeer= command.offset;
834
835	CHeuristicScanner pScanner= new CHeuristicScanner(pasted);
836	CHeuristicScanner dScanner= new CHeuristicScanner(document);
837
838	// add scope relevant after context to peer search
839	int afterToken= dScanner.nextToken(command.offset + command.length, CHeuristicScanner.UNBOUND);
840	try {
841	switch (afterToken) {
842	case Symbols.TokenRBRACE:
843	pasted.replace(pasted.getLength(), 0, "}"); //$NON-NLS-1$
844	break;
845	case Symbols.TokenRPAREN:
846	pasted.replace(pasted.getLength(), 0, ")"); //$NON-NLS-1$
847	break;
848	case Symbols.TokenRBRACKET:
849	pasted.replace(pasted.getLength(), 0, "]"); //$NON-NLS-1$
850	break;
851	}
852	} catch (BadLocationException e) {
853	// cannot happen
854	Assert.isTrue(false);
855	}
856
857	int pPos= 0; // paste text position (increasing from 0)
858	int dPos= Math.max(0, command.offset - 1); // document position (decreasing from paste offset)
859	while (true) {
860	int token= pScanner.nextToken(pPos, CHeuristicScanner.UNBOUND);
861	pPos= pScanner.getPosition();
862	switch (token) {
863	case Symbols.TokenLBRACE:
864	case Symbols.TokenLBRACKET:
865	case Symbols.TokenLPAREN:
866	pPos= skipScope(pScanner, pPos, token);
867	if (pPos == CHeuristicScanner.NOT_FOUND)
868	return firstPeer;
869	break; // closed scope -> keep searching
870	case Symbols.TokenRBRACE:
871	int peer= dScanner.findOpeningPeer(dPos, '{', '}');
872	dPos= peer - 1;
873	if (peer == CHeuristicScanner.NOT_FOUND)
874	return firstPeer;
875	firstPeer= peer;
876	break; // keep searching
877	case Symbols.TokenRBRACKET:
878	peer= dScanner.findOpeningPeer(dPos, '[', ']');
879	dPos= peer - 1;
880	if (peer == CHeuristicScanner.NOT_FOUND)
881	return firstPeer;
882	firstPeer= peer;
883	break; // keep searching
884	case Symbols.TokenRPAREN:
885	peer= dScanner.findOpeningPeer(dPos, '(', ')');
886	dPos= peer - 1;
887	if (peer == CHeuristicScanner.NOT_FOUND)
888	return firstPeer;
889	firstPeer= peer;
890	break; // keep searching
891	case Symbols.TokenCASE:
892	case Symbols.TokenDEFAULT:
893	CIndenter indenter= new CIndenter(document, dScanner, fProject);
894	peer= indenter.findReferencePosition(dPos, false, false, false, true);
895	if (peer == CHeuristicScanner.NOT_FOUND)
896	return firstPeer;
897	firstPeer= peer;
898	break; // keep searching
899
900	case Symbols.TokenEOF:
901	return firstPeer;
902	default:
903	// keep searching
904	}
905	}
906	}
907
908	/**
909	* Skips the scope opened by <code>token</code> in <code>document</code>,
910	* returns either the position of the
911	* @param pos
912	* @param token
913	* @return the position after the scope
914	*/
915	private static int skipScope(CHeuristicScanner scanner, int pos, int token) {
916	int openToken= token;
917	int closeToken;
918	switch (token) {
919	case Symbols.TokenLPAREN:
920	closeToken= Symbols.TokenRPAREN;
921	break;
922	case Symbols.TokenLBRACKET:
923	closeToken= Symbols.TokenRBRACKET;
924	break;
925	case Symbols.TokenLBRACE:
926	closeToken= Symbols.TokenRBRACE;
927	break;
928	default:
929	Assert.isTrue(false);
930	return -1; // dummy
931	}
932
933	int depth= 1;
934	int p= pos;
935
936	while (true) {
937	int tok= scanner.nextToken(p, CHeuristicScanner.UNBOUND);
938	p= scanner.getPosition();
939
940	if (tok == openToken) {
941	depth++;
942	} else if (tok == closeToken) {
943	depth--;
944	if (depth == 0)
945	return p + 1;
946	} else if (tok == Symbols.TokenEOF) {
947	return CHeuristicScanner.NOT_FOUND;
948	}
949	}
950	}
951
522	private void smartIndentOnKeypress(IDocument document, DocumentCommand command) {	952	private void smartIndentOnKeypress(IDocument document, DocumentCommand command) {
523	switch (command.text.charAt(0)) {	953	switch (command.text.charAt(0)) {
524	case '}':	954	case '}':
Lines 551-565 Link Here
551	if (d.get(lineOffset, p - lineOffset).trim().length() != 0)	981	if (d.get(lineOffset, p - lineOffset).trim().length() != 0)
552	return;	982	return;
553		983
554	// line of last javacode	984	// Line of last C code
555	int pos = scanner.findNonWhitespaceBackward(p - 1, CHeuristicScanner.UNBOUND);	985	int pos = scanner.findNonWhitespaceBackward(p - 1, CHeuristicScanner.UNBOUND);
556	if (pos == -1)	986	if (pos == -1)
557	return;	987	return;
558	int lastLine = d.getLineOfOffset(pos);	988	int lastLine = d.getLineOfOffset(pos);
559		989
560	// only shift if the last java line is further up and is a braceless block candidate	990	// Only shift if the last C line is further up and is a braceless block candidate
561	if (lastLine < line) {	991	if (lastLine < line) {
562
563	CIndenter indenter = new CIndenter(d, scanner, fProject);	992	CIndenter indenter = new CIndenter(d, scanner, fProject);
564	int ref = indenter.findReferencePosition(p, true, false, false, false);	993	int ref = indenter.findReferencePosition(p, true, false, false, false);
565	if (ref == CHeuristicScanner.NOT_FOUND)	994	if (ref == CHeuristicScanner.NOT_FOUND)
Lines 589-603 Link Here
589	if (d.get(lineOffset, p - lineOffset).trim().length() != 0)	1018	if (d.get(lineOffset, p - lineOffset).trim().length() != 0)
590	return;	1019	return;
591		1020
592	// line of last javacode	1021	// Line of last C code
593	int pos = scanner.findNonWhitespaceBackward(p - 1, CHeuristicScanner.UNBOUND);	1022	int pos = scanner.findNonWhitespaceBackward(p - 1, CHeuristicScanner.UNBOUND);
594	if (pos == -1)	1023	if (pos == -1)
595	return;	1024	return;
596	int lastLine = d.getLineOfOffset(pos);	1025	int lastLine = d.getLineOfOffset(pos);
597		1026
598	// only shift if the last java line is further up and is a braceless block candidate	1027	// Only shift if the last C line is further up and is a braceless block candidate
599	if (lastLine < line) {	1028	if (lastLine < line) {
600
601	CIndenter indenter = new CIndenter(d, scanner, fProject);	1029	CIndenter indenter = new CIndenter(d, scanner, fProject);
602	int ref = indenter.findReferencePosition(p, false, false, false, true);	1030	int ref = indenter.findReferencePosition(p, false, false, false, true);
603	if (ref == CHeuristicScanner.NOT_FOUND)	1031	if (ref == CHeuristicScanner.NOT_FOUND)
Lines 649-657 Link Here
649	CCommentAutoIndentStrategy.commentIndentForCommentEnd(d, c);	1077	CCommentAutoIndentStrategy.commentIndentForCommentEnd(d, c);
650	} else if (c.text.length() == 1) {	1078	} else if (c.text.length() == 1) {
651	smartIndentOnKeypress(d, c);	1079	smartIndentOnKeypress(d, c);
652	// TODO Support smart paste.	1080	} else if (c.text.length() > 1 && getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SMART_PASTE)) {
653	// } else if (c.text.length() > 1 && getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SMART_PASTE)) {	1081	smartPaste(d, c); // no smart backspace for paste
654	// smartPaste(d, c); // no smart backspace for paste
655	}	1082	}
656	}	1083	}
657		1084




import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.cdt.core.model.IWorkingCopy;
import org.eclipse.cdt.internal.core.model.CModelManager;
import org.eclipse.cdt.internal.ui.editor.CEditor;
import org.eclipse.cdt.internal.ui.editor.IReconcilingParticipant;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.IWorkingCopyManager;

	private IProgressMonitor fProgressMonitor;
	private String txt = null;
	
	public CReconcilingStrategy(ITextEditor editor) {
		fEditor= editor;
		fManager= CUIPlugin.getDefault().getWorkingCopyManager();
	}

	public void setDocument(IDocument document) {
	}	


	/*
	 * @see IReconcilingStrategyExtension#setProgressMonitor(IProgressMonitor)
	 */

Lines 582-587 Link Here

(-)plugin.xml (+6 lines)
582	id="org.eclipse.cdt.ui.preferences.TemplatePreferencePage">	582	id="org.eclipse.cdt.ui.preferences.TemplatePreferencePage">
583	</page>	583	</page>
584	<page	584	<page
		585	name="%SmartTypingPreferencePage.name"
		586	category="org.eclipse.cdt.ui.preferences.CEditorPreferencePage"
		587	class="org.eclipse.cdt.internal.ui.preferences.SmartTypingPreferencePage"
		588	id="org.eclipse.cdt.ui.preferences.SmartTypingPreferencePage">
		589	</page>
		590	<page
585	name="%CodeFormatterPreferencePage.name"	591	name="%CodeFormatterPreferencePage.name"
586	category="org.eclipse.cdt.ui.preferences.CPluginPreferencePage"	592	category="org.eclipse.cdt.ui.preferences.CPluginPreferencePage"
587	class="org.eclipse.cdt.internal.ui.preferences.CodeFormatterPreferencePage"	593	class="org.eclipse.cdt.internal.ui.preferences.CodeFormatterPreferencePage"

Lines 129-136 Link Here

(-)plugin.properties (-1 / +2 lines)
129	CPluginTemplatePreferencePage.name=Templates	129	CPluginTemplatePreferencePage.name=Templates
130	CPluginBuildConsolePreferencePage.name=Build Console	130	CPluginBuildConsolePreferencePage.name=Build Console
131	CPluginFileTypesPreferencePage.name=File Types	131	CPluginFileTypesPreferencePage.name=File Types
132	CodeFormatterPreferencePage.name=Code Formatter	132	CodeFormatterPreferencePage.name=Code Style
133	CodeAssistPreferencePage.name=Content Assist	133	CodeAssistPreferencePage.name=Content Assist
		134	SmartTypingPreferencePage.name=Typing
134		135
135	todoPageName=C/C++ Task Tags	136	todoPageName=C/C++ Task Tags
136	todoTaskPrefName=Task Tags	137	todoTaskPrefName=Task Tags




import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.ToolFactory;
import org.eclipse.cdt.core.formatter.CodeFormatter;
import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.ui.CUIPlugin;


		 * that case.
		 */
		String key;
		if (CCorePlugin.SPACE.equals(getCoreOption(project, DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
			key= DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE;
		else
			key= DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE;
		
		return getCoreOption(project, key, 4);
	}

	 */
	public static int getIndentWidth(ICProject project) {
		String key;
		if (DefaultCodeFormatterConstants.MIXED.equals(getCoreOption(project, DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
			key= DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE;
		else
			key= DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE;
		
		return getCoreOption(project, key, 4);
	}

			return doc.get();
		} catch (BadLocationException e) {
			CUIPlugin.getDefault().log(e); // bug in the formatter
			Assert.isTrue(false, "Formatter created edits with wrong positions: " + e.getMessage()); //$NON-NLS-1$
		}
		return null;
	}

Lines 7-12 Link Here

(-)src/org/eclipse/cdt/internal/ui/editor/CSourceViewer.java (-83 / +37 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* QNX Software Systems - initial API and implementation	9	* QNX Software Systems - initial API and implementation
		10	* Sergey Prigogin, Google
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.cdt.internal.ui.editor;	12	package org.eclipse.cdt.internal.ui.editor;
12		13
Lines 14-23 Link Here
14	import java.util.Iterator;	15	import java.util.Iterator;
15	import java.util.List;	16	import java.util.List;
16		17
17	import org.eclipse.core.resources.IFile;
18	import org.eclipse.core.runtime.CoreException;
19	import org.eclipse.core.runtime.IPath;
20	import org.eclipse.core.runtime.content.IContentType;
21	import org.eclipse.jface.text.DocumentCommand;	18	import org.eclipse.jface.text.DocumentCommand;
22	import org.eclipse.jface.text.ITextViewerExtension;	19	import org.eclipse.jface.text.ITextViewerExtension;
23	import org.eclipse.jface.text.contentassist.IContentAssistant;	20	import org.eclipse.jface.text.contentassist.IContentAssistant;
Lines 26-43 Link Here
26	import org.eclipse.jface.text.source.IVerticalRuler;	23	import org.eclipse.jface.text.source.IVerticalRuler;
27	import org.eclipse.jface.text.source.SourceViewerConfiguration;	24	import org.eclipse.jface.text.source.SourceViewerConfiguration;
28	import org.eclipse.jface.text.source.projection.ProjectionViewer;	25	import org.eclipse.jface.text.source.projection.ProjectionViewer;
		26	import org.eclipse.swt.custom.StyledText;
		27	import org.eclipse.swt.graphics.Color;
29	import org.eclipse.swt.widgets.Composite;	28	import org.eclipse.swt.widgets.Composite;
30	import org.eclipse.ui.IEditorInput;
31	import org.eclipse.ui.IPathEditorInput;
32	import org.eclipse.ui.editors.text.ILocationProvider;
33	import org.eclipse.ui.ide.ResourceUtil;
34
35	import org.eclipse.cdt.core.CCorePlugin;
36	import org.eclipse.cdt.core.model.ICElement;
37	import org.eclipse.cdt.core.model.ILanguage;
38	import org.eclipse.cdt.core.model.ITranslationUnit;
39	import org.eclipse.cdt.core.model.LanguageManager;
40	import org.eclipse.cdt.ui.CUIPlugin;
41		29
42	import org.eclipse.cdt.internal.ui.editor.CEditor.ITextConverter;	30	import org.eclipse.cdt.internal.ui.editor.CEditor.ITextConverter;
43	import org.eclipse.cdt.internal.ui.text.CSourceViewerConfiguration;	31	import org.eclipse.cdt.internal.ui.text.CSourceViewerConfiguration;
Lines 45-58 Link Here
45	/**	33	/**
46	* Adapted source viewer for CEditor	34	* Adapted source viewer for CEditor
47	*/	35	*/
48
49	public class CSourceViewer extends ProjectionViewer implements ITextViewerExtension {	36	public class CSourceViewer extends ProjectionViewer implements ITextViewerExtension {
50		37
51	/** Show outline operation id. */	38	/** Show outline operation id. */
52	public static final int SHOW_OUTLINE = 101;	39	public static final int SHOW_OUTLINE = 101;
53		40
54	/** Editor. */	41	/** Editor. */
55	private final CEditor editor;	42	private CEditor editor;
56	/** Presents outline. */	43	/** Presents outline. */
57	private IInformationPresenter fOutlinePresenter;	44	private IInformationPresenter fOutlinePresenter;
58		45
Lines 60-140 Link Here
60		47
61	/**	48	/**
62	* Creates new source viewer.	49	* Creates new source viewer.
63	* @param editor
64	* @param parent	50	* @param parent
65	* @param ruler	51	* @param ruler
66	* @param styles	52	* @param fOverviewRuler
67	* @param fOverviewRuler	53	* @param isOverviewRulerShowing
68	* @param isOverviewRulerShowing	54	* @param styles
69	*/	55	*/
70	public CSourceViewer(	56	public CSourceViewer(Composite parent, IVerticalRuler ruler, IOverviewRuler fOverviewRuler, boolean isOverviewRulerShowing,
71	CEditor editor, Composite parent,	57	int styles) {
72	IVerticalRuler ruler,
73	int styles,
74	IOverviewRuler fOverviewRuler,
75	boolean isOverviewRulerShowing) {
76	super(parent, ruler, fOverviewRuler, isOverviewRulerShowing, styles);	58	super(parent, ruler, fOverviewRuler, isOverviewRulerShowing, styles);
77	this.editor = editor;
78	}	59	}
79		60
80	public IContentAssistant getContentAssistant() {	61	public IContentAssistant getContentAssistant() {
81	return fContentAssistant;	62	return fContentAssistant;
82	}	63	}
83		64
84	public ILanguage getLanguage() {	65	/*
85	ICElement element = editor.getInputCElement();	66	* @see ISourceViewer#configure(SourceViewerConfiguration)
86	if (element instanceof ITranslationUnit) {	67	*/
87	try {	68	public void configure(SourceViewerConfiguration configuration) {
88	return ((ITranslationUnit)element).getLanguage();	69	// Prevent access to colors disposed in unconfigure().
89	} catch (CoreException e) {	70	StyledText textWidget= getTextWidget();
90	CUIPlugin.getDefault().log(e);	71	if (textWidget != null && !textWidget.isDisposed()) {
91	}	72	Color foregroundColor= textWidget.getForeground();
92	} else {	73	if (foregroundColor != null && foregroundColor.isDisposed())
93	// compute the language from the plain editor input	74	textWidget.setForeground(null);
94	IContentType contentType = null;	75	Color backgroundColor= textWidget.getBackground();
95	IEditorInput input = editor.getEditorInput();	76	if (backgroundColor != null && backgroundColor.isDisposed())
96	IFile file = ResourceUtil.getFile(input);	77	textWidget.setBackground(null);
97	if (file != null) {	78	}
98	contentType = CCorePlugin.getContentType(file.getProject(), file.getName());	79
99	} else if (input instanceof IPathEditorInput) {	80	super.configure(configuration);
100	IPath path = ((IPathEditorInput)input).getPath();	81	if (configuration instanceof CSourceViewerConfiguration) {
101	contentType = CCorePlugin.getContentType(path.lastSegment());	82	CSourceViewerConfiguration cConfiguration= (CSourceViewerConfiguration)configuration;
102	} else {	83	fOutlinePresenter= cConfiguration.getOutlinePresenter(this);
103	ILocationProvider locationProvider = (ILocationProvider)input.getAdapter(ILocationProvider.class);	84	if (fOutlinePresenter != null)
104	if (locationProvider != null) {	85	fOutlinePresenter.install(this);
105	IPath path = locationProvider.getPath(input);	86	editor = (CEditor) cConfiguration.getEditor();
106	contentType = CCorePlugin.getContentType(path.lastSegment());
107	}
108	}
109	if (contentType != null) {
110	try {
111	return LanguageManager.getInstance().getLanguage(contentType);
112	} catch (CoreException exc) {
113	CUIPlugin.getDefault().log(exc.getStatus());
114	}
115	}
116	}	87	}
117	return null;
118	}	88	}
119
120	/**
121	* @see org.eclipse.jface.text.source.SourceViewer#configure(org.eclipse.jface.text.source.SourceViewerConfiguration)
122	*/
123	public void configure(SourceViewerConfiguration configuration)
124	{
125	super.configure(configuration);
126	if (configuration instanceof CSourceViewerConfiguration)
127	{
128	fOutlinePresenter = ((CSourceViewerConfiguration) configuration).getOutlinePresenter(editor);
129	fOutlinePresenter.install(this);
130	}
131	}
132		89
133	/**	90	/**
134	* @see org.eclipse.jface.text.source.SourceViewer#unconfigure()	91	* @see org.eclipse.jface.text.source.SourceViewer#unconfigure()
135	*/	92	*/
136	public void unconfigure()	93	public void unconfigure() {
137	{
138	if (fOutlinePresenter != null) {	94	if (fOutlinePresenter != null) {
139	fOutlinePresenter.uninstall();	95	fOutlinePresenter.uninstall();
140	fOutlinePresenter= null;	96	fOutlinePresenter= null;
Lines 154-160 Link Here
154	case CONTENTASSIST_PROPOSALS:	110	case CONTENTASSIST_PROPOSALS:
155	{	111	{
156	String msg= fContentAssistant.showPossibleCompletions();	112	String msg= fContentAssistant.showPossibleCompletions();
157	this.editor.setStatusLineErrorMessage(msg);	113	editor.setStatusLineErrorMessage(msg);
158	return;	114	return;
159	}	115	}
160	case SHOW_OUTLINE:	116	case SHOW_OUTLINE:
Lines 169-178 Link Here
169	/**	125	/**
170	* @see org.eclipse.jface.text.source.projection.ProjectionViewer#canDoOperation(int)	126	* @see org.eclipse.jface.text.source.projection.ProjectionViewer#canDoOperation(int)
171	*/	127	*/
172	public boolean canDoOperation(int operation)	128	public boolean canDoOperation(int operation) {
173	{	129	if (operation == SHOW_OUTLINE) {
174	if (operation == SHOW_OUTLINE)
175	{
176	return fOutlinePresenter != null;	130	return fOutlinePresenter != null;
177	}	131	}
178	return super.canDoOperation(operation);	132	return super.canDoOperation(operation);

Lines 55-60 Link Here

(-)src/org/eclipse/cdt/internal/ui/editor/ICEditorActionDefinitionIds.java (+6 lines)
55	public static final String JOIN_LINES= "org.eclipse.cdt.ui.edit.text.c.join.lines"; //$NON-NLS-1$	55	public static final String JOIN_LINES= "org.eclipse.cdt.ui.edit.text.c.join.lines"; //$NON-NLS-1$
56		56
57	/**	57	/**
		58	* Action definition ID of the source -> indent action
		59	* (value <code>"org.eclipse.cdt.ui.edit.text.c.indent"</code>).
		60	*/
		61	public static final String INDENT = "org.eclipse.cdt.ui.edit.text.c.indent"; //$NON-NLS-1$
		62
		63	/**
58	* Action definition ID of the source -> format action	64	* Action definition ID of the source -> format action
59	* (value <code>"org.eclipse.cdt.ui.edit.text.c.format"</code>).	65	* (value <code>"org.eclipse.cdt.ui.edit.text.c.format"</code>).
60	*/	66	*/




import java.text.CharacterIterator;
import java.util.Iterator;
import java.util.ResourceBundle;
import java.util.Stack;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.AbstractInformationControlManager;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.BadPositionCategoryException;
import org.eclipse.jface.text.DefaultInformationControl;
import org.eclipse.jface.text.DefaultLineTracker;
import org.eclipse.jface.text.DocumentCommand;
import org.eclipse.jface.text.DocumentEvent;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentExtension;
import org.eclipse.jface.text.IDocumentListener;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.IInformationControlCreator;
import org.eclipse.jface.text.ILineTracker;
import org.eclipse.jface.text.IPositionUpdater;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextHover;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.ITextViewerExtension;
import org.eclipse.jface.text.ITextViewerExtension2;
import org.eclipse.jface.text.ITextViewerExtension4;
import org.eclipse.jface.text.ITextViewerExtension5;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.TextUtilities;

import org.eclipse.jface.text.information.IInformationProviderExtension;
import org.eclipse.jface.text.information.IInformationProviderExtension2;
import org.eclipse.jface.text.information.InformationPresenter;
import org.eclipse.jface.text.link.ILinkedModeListener;
import org.eclipse.jface.text.link.LinkedModeModel;
import org.eclipse.jface.text.link.LinkedModeUI;
import org.eclipse.jface.text.link.LinkedPosition;
import org.eclipse.jface.text.link.LinkedPositionGroup;
import org.eclipse.jface.text.link.LinkedModeUI.ExitFlags;
import org.eclipse.jface.text.link.LinkedModeUI.IExitPolicy;
import org.eclipse.jface.text.source.Annotation;
import org.eclipse.jface.text.source.IAnnotationHover;
import org.eclipse.jface.text.source.IAnnotationHoverExtension;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ST;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.custom.VerifyKeyListener;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSource;
import org.eclipse.swt.dnd.DragSourceListener;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.VerifyEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.part.IShowInSource;
import org.eclipse.ui.part.IShowInTargetList;
import org.eclipse.ui.part.ShowInContext;
import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
import org.eclipse.ui.texteditor.ContentAssistAction;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.IEditorStatusLine;

import org.eclipse.ui.texteditor.TextEditorAction;
import org.eclipse.ui.texteditor.TextNavigationAction;
import org.eclipse.ui.texteditor.TextOperationAction;
import org.eclipse.ui.texteditor.link.EditorLinkedModeUI;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;

import com.ibm.icu.text.BreakIterator;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.CCorePreferenceConstants;
import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.cdt.core.model.CModelException;
import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.model.ISourceRange;
import org.eclipse.cdt.core.model.ISourceReference;
import org.eclipse.cdt.core.model.ITranslationUnit;

import org.eclipse.cdt.ui.text.ICPartitions;
import org.eclipse.cdt.ui.text.folding.ICFoldingStructureProvider;

import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;

import org.eclipse.cdt.internal.ui.ICHelpContextIds;
import org.eclipse.cdt.internal.ui.IContextMenuConstants;
import org.eclipse.cdt.internal.ui.actions.AddBlockCommentAction;
import org.eclipse.cdt.internal.ui.actions.FoldingActionGroup;
import org.eclipse.cdt.internal.ui.actions.GoToNextPreviousMemberAction;
import org.eclipse.cdt.internal.ui.actions.IndentAction;
import org.eclipse.cdt.internal.ui.actions.JoinLinesAction;
import org.eclipse.cdt.internal.ui.actions.RemoveBlockCommentAction;
import org.eclipse.cdt.internal.ui.dnd.TextEditorDropAdapter;

import org.eclipse.cdt.internal.ui.search.actions.OpenDeclarationsAction;
import org.eclipse.cdt.internal.ui.search.actions.OpenDefinitionAction;
import org.eclipse.cdt.internal.ui.search.actions.SelectionSearchGroup;
import org.eclipse.cdt.internal.ui.text.CHeuristicScanner;
import org.eclipse.cdt.internal.ui.text.CPairMatcher;
import org.eclipse.cdt.internal.ui.text.CSourceViewerConfiguration;
import org.eclipse.cdt.internal.ui.text.CTextTools;
import org.eclipse.cdt.internal.ui.text.CWordIterator;
import org.eclipse.cdt.internal.ui.text.DocumentCharacterIterator;
import org.eclipse.cdt.internal.ui.text.HTMLTextPresenter;
import org.eclipse.cdt.internal.ui.text.Symbols;
import org.eclipse.cdt.internal.ui.text.c.hover.SourceViewerInformationControl;
import org.eclipse.cdt.internal.ui.text.contentassist.ContentAssistPreference;
import org.eclipse.cdt.internal.ui.util.CUIHelp;

 */
public class CEditor extends TextEditor implements ISelectionChangedListener, IShowInSource , IReconcilingParticipant{

	interface ITextConverter {
		void customizeDocumentCommand(IDocument document, DocumentCommand command);
	}

	static class TabConverter implements ITextConverter {
		private int fTabRatio;
		private ILineTracker fLineTracker;
		
		public TabConverter() {
		}
		
		public void setNumberOfSpacesPerTab(int ratio) {
			fTabRatio = ratio;
		}
		
		public void setLineTracker(ILineTracker lineTracker) {
			fLineTracker = lineTracker;
		}
		
		private int insertTabString(StringBuffer buffer, int offsetInLine) {
			
			if (fTabRatio == 0)
				return 0;
				
			int remainder = offsetInLine % fTabRatio;
			remainder = fTabRatio - remainder;
			for (int i = 0; i < remainder; i++)
				buffer.append(' ');
			return remainder;
		}
		
		public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
			String text = command.text;
			if (text == null)
				return;
				
			int index = text.indexOf('\t');
			if (index > -1) {
				StringBuffer buffer = new StringBuffer();
				
				fLineTracker.set(command.text);
				int lines = fLineTracker.getNumberOfLines();
				
				try {
					for (int i = 0; i < lines; i++) {
						int offset = fLineTracker.getLineOffset(i);
						int endOffset = offset + fLineTracker.getLineLength(i);
						String line = text.substring(offset, endOffset);
						
						int position = 0;
						if (i == 0) {
							IRegion firstLine = document.getLineInformationOfOffset(command.offset);
							position = command.offset - firstLine.getOffset();	
						}
						
						int length = line.length();
						for (int j = 0; j < length; j++) {
							char c = line.charAt(j);
							if (c == '\t') {
								int oldPosition = position;
								position += insertTabString(buffer, position);
								if (command.caretOffset > command.offset + oldPosition) {
									command.caretOffset += position - oldPosition - 1;
								}
							} else {
								buffer.append(c);
								++position;
							}
						}
					}
						
					command.text = buffer.toString();
				} catch (BadLocationException x) {
				}
			}
		}
	}

	private class ExitPolicy implements IExitPolicy {

		final char fExitCharacter;
		final char fEscapeCharacter;
		final Stack fStack;
		final int fSize;

		public ExitPolicy(char exitCharacter, char escapeCharacter, Stack stack) {
			fExitCharacter = exitCharacter;
			fEscapeCharacter = escapeCharacter;
			fStack = stack;
			fSize = fStack.size();
		}

		/*
		 * @see org.eclipse.jdt.internal.ui.text.link.LinkedPositionUI.ExitPolicy#doExit(org.eclipse.jdt.internal.ui.text.link.LinkedPositionManager, org.eclipse.swt.events.VerifyEvent, int, int)
		 */
		public ExitFlags doExit(LinkedModeModel model, VerifyEvent event, int offset, int length) {

			if (fSize == fStack.size() && !isMasked(offset)) {
				if (event.character == fExitCharacter) {
					BracketLevel level = (BracketLevel) fStack.peek();
					if (level.fFirstPosition.offset > offset || level.fSecondPosition.offset < offset)
						return null;
					if (level.fSecondPosition.offset == offset && length == 0)
						// don't enter the character if if its the closing peer
						return new ExitFlags(ILinkedModeListener.UPDATE_CARET, false);
				}
				// when entering an anonymous class between the parenthesis', we don't want
				// to jump after the closing parenthesis when return is pressed
				if (event.character == SWT.CR && offset > 0) {
					IDocument document = getSourceViewer().getDocument();
					try {
						if (document.getChar(offset - 1) == '{')
							return new ExitFlags(ILinkedModeListener.EXIT_ALL, true);
					} catch (BadLocationException e) {
					}
				}
			}
			return null;
		}

		private boolean isMasked(int offset) {
			IDocument document = getSourceViewer().getDocument();
			try {
				return fEscapeCharacter == document.getChar(offset - 1);
			} catch (BadLocationException e) {
			}
			return false;
		}
	}

	private static class BracketLevel {
		int fOffset;
		int fLength;
		LinkedModeUI fUI;
		Position fFirstPosition;
		Position fSecondPosition;
	}

	/**
	 * Position updater that takes any changes at the borders of a position to not belong to the position.
	 *
	 * @since 4.0
	 */
	private static class ExclusivePositionUpdater implements IPositionUpdater {

		/** The position category. */
		private final String fCategory;

		/**
		 * Creates a new updater for the given <code>category</code>.
		 *
		 * @param category the new category.
		 */
		public ExclusivePositionUpdater(String category) {
			fCategory = category;
		}

		/*
		 * @see org.eclipse.jface.text.IPositionUpdater#update(org.eclipse.jface.text.DocumentEvent)
		 */
		public void update(DocumentEvent event) {

			int eventOffset = event.getOffset();
			int eventOldLength = event.getLength();
			int eventNewLength = event.getText() == null ? 0 : event.getText().length();
			int deltaLength = eventNewLength - eventOldLength;

			try {
				Position[] positions = event.getDocument().getPositions(fCategory);

				for (int i = 0; i != positions.length; i++) {

					Position position = positions[i];

					if (position.isDeleted())
						continue;

					int offset = position.getOffset();
					int length = position.getLength();
					int end = offset + length;

					if (offset >= eventOffset + eventOldLength)
						// position comes
						// after change - shift
						position.setOffset(offset + deltaLength);
					else if (end <= eventOffset) {
						// position comes way before change -
						// leave alone
					} else if (offset <= eventOffset && end >= eventOffset + eventOldLength) {
						// event completely internal to the position - adjust length
						position.setLength(length + deltaLength);
					} else if (offset < eventOffset) {
						// event extends over end of position - adjust length
						int newEnd = eventOffset;
						position.setLength(newEnd - offset);
					} else if (end > eventOffset + eventOldLength) {
						// event extends from before position into it - adjust offset
						// and length
						// offset becomes end of event, length adjusted accordingly
						int newOffset = eventOffset + eventNewLength;
						position.setOffset(newOffset);
						position.setLength(end - newOffset);
					} else {
						// event consumes the position - delete it
						position.delete();
					}
				}
			} catch (BadPositionCategoryException e) {
				// ignore and return
			}
		}

		/**
		 * Returns the position category.
		 *
		 * @return the position category
		 */
		public String getCategory() {
			return fCategory;
		}
	}

	private class BracketInserter implements VerifyKeyListener, ILinkedModeListener {

		private boolean fCloseBrackets = true;
		private boolean fCloseStrings = true;
		private boolean fCloseAngularBrackets = true;
		private final String CATEGORY = toString();
		private IPositionUpdater fUpdater = new ExclusivePositionUpdater(CATEGORY);
		private Stack fBracketLevelStack = new Stack();

		public void setCloseBracketsEnabled(boolean enabled) {
			fCloseBrackets = enabled;
		}

		public void setCloseStringsEnabled(boolean enabled) {
			fCloseStrings = enabled;
		}

		public void setCloseAngularBracketsEnabled(boolean enabled) {
			fCloseAngularBrackets = enabled;
		}

		private boolean isAngularIntroducer(String identifier) {
			return identifier.length() > 0
				&& (Character.isUpperCase(identifier.charAt(0))
					|| identifier.equals("template") //$NON-NLS-1$
					|| identifier.equals("vector") //$NON-NLS-1$
					|| identifier.equals("map") //$NON-NLS-1$
					|| identifier.equals("set") //$NON-NLS-1$
					|| identifier.equals("hash_map") //$NON-NLS-1$
					|| identifier.equals("hash_set") //$NON-NLS-1$
					|| identifier.equals("pair") //$NON-NLS-1$
					|| identifier.endsWith("_ptr") //$NON-NLS-1$
					|| identifier.endsWith("include")); //$NON-NLS-1$
		}

		/*
		 * @see org.eclipse.swt.custom.VerifyKeyListener#verifyKey(org.eclipse.swt.events.VerifyEvent)
		 */
		public void verifyKey(VerifyEvent event) {

			// early pruning to slow down normal typing as little as possible
			if (!event.doit || getInsertMode() != SMART_INSERT)
				return;
			switch (event.character) {
				case '(':
				case '<':
				case '[':
				case '\'':
				case '\"':
					break;
				default:
					return;
			}

			final ISourceViewer sourceViewer = getSourceViewer();
			IDocument document = sourceViewer.getDocument();

			final Point selection = sourceViewer.getSelectedRange();
			final int offset = selection.x;
			final int length = selection.y;

			try {
				IRegion startLine = document.getLineInformationOfOffset(offset);
				IRegion endLine = document.getLineInformationOfOffset(offset + length);

				CHeuristicScanner scanner = new CHeuristicScanner(document);
				int nextToken = scanner.nextToken(offset + length, endLine.getOffset() + endLine.getLength());
				String next = nextToken == Symbols.TokenEOF ? null : document.get(offset, scanner.getPosition() - offset).trim();
				int prevToken = scanner.previousToken(offset - 1, startLine.getOffset());
				int prevTokenOffset = scanner.getPosition() + 1;
				String previous = prevToken == Symbols.TokenEOF ? null : document.get(prevTokenOffset, offset - prevTokenOffset).trim();

				switch (event.character) {
					case '(':
						if (!fCloseBrackets
								|| nextToken == Symbols.TokenLPAREN
								|| nextToken == Symbols.TokenIDENT
								|| next != null && next.length() > 1)
							return;
						break;

					case '<':
						if (!(fCloseAngularBrackets && fCloseBrackets)
								|| nextToken == Symbols.TokenLESSTHAN
								|| 		   prevToken != Symbols.TokenLBRACE
										&& prevToken != Symbols.TokenRBRACE
										&& prevToken != Symbols.TokenSEMICOLON
										&& prevToken != Symbols.TokenSTATIC
										&& (prevToken != Symbols.TokenIDENT || !isAngularIntroducer(previous))
										&& prevToken != Symbols.TokenEOF)
							return;
						break;

					case '[':
						if (!fCloseBrackets
								|| nextToken == Symbols.TokenIDENT
								|| next != null && next.length() > 1)
							return;
						break;

					case '\'':
					case '"':
						if (!fCloseStrings
								|| nextToken == Symbols.TokenIDENT
								|| next != null && next.length() > 1
								|| (!("include".equals(previous) && event.character == '"') //$NON-NLS-1$
										&& (prevToken == Symbols.TokenIDENT
												|| previous != null && previous.length() > 1)))
							return;
						break;

					default:
						return;
				}

				ITypedRegion partition = TextUtilities.getPartition(document, ICPartitions.C_PARTITIONING, offset, true);
				if (!IDocument.DEFAULT_CONTENT_TYPE.equals(partition.getType()))
					return;

				if (!validateEditorInputState())
					return;

				final char character = event.character;
				final char closingCharacter = getPeerCharacter(character);
				final StringBuffer buffer = new StringBuffer();
				buffer.append(character);
				buffer.append(closingCharacter);
				if (closingCharacter == '>' && nextToken != Symbols.TokenEOF
						&& document.getChar(offset + length) == '>') {
					// Insert a space to avoid two consequtive closing angular brackets. 
					buffer.append(' ');
				}

				document.replace(offset, length, buffer.toString());

				BracketLevel level = new BracketLevel();
				fBracketLevelStack.push(level);

				LinkedPositionGroup group = new LinkedPositionGroup();
				group.addPosition(new LinkedPosition(document, offset + 1, 0, LinkedPositionGroup.NO_STOP));

				LinkedModeModel model = new LinkedModeModel();
				model.addLinkingListener(this);
				model.addGroup(group);
				model.forceInstall();

				level.fOffset = offset;
				level.fLength = 2;

				// set up position tracking for our magic peers
				if (fBracketLevelStack.size() == 1) {
					document.addPositionCategory(CATEGORY);
					document.addPositionUpdater(fUpdater);
				}
				level.fFirstPosition = new Position(offset, 1);
				level.fSecondPosition = new Position(offset + 1, 1);
				document.addPosition(CATEGORY, level.fFirstPosition);
				document.addPosition(CATEGORY, level.fSecondPosition);

				level.fUI = new EditorLinkedModeUI(model, sourceViewer);
				level.fUI.setSimpleMode(true);
				level.fUI.setExitPolicy(new ExitPolicy(closingCharacter, getEscapeCharacter(closingCharacter), fBracketLevelStack));
				level.fUI.setExitPosition(sourceViewer, offset + 2, 0, Integer.MAX_VALUE);
				level.fUI.setCyclingMode(LinkedModeUI.CYCLE_NEVER);
				level.fUI.enter();

				IRegion newSelection = level.fUI.getSelectedRegion();
				sourceViewer.setSelectedRange(newSelection.getOffset(), newSelection.getLength());

				event.doit = false;

			} catch (BadLocationException e) {
				CUIPlugin.getDefault().log(e);
			} catch (BadPositionCategoryException e) {
				CUIPlugin.getDefault().log(e);
			}
		}

		/*
		 * @see org.eclipse.jface.text.link.ILinkedModeListener#left(org.eclipse.jface.text.link.LinkedModeModel, int)
		 */
		public void left(LinkedModeModel environment, int flags) {

			final BracketLevel level = (BracketLevel) fBracketLevelStack.pop();

			if (flags != ILinkedModeListener.EXTERNAL_MODIFICATION)
				return;

			// remove brackets
			final ISourceViewer sourceViewer = getSourceViewer();
			final IDocument document = sourceViewer.getDocument();
			if (document instanceof IDocumentExtension) {
				IDocumentExtension extension = (IDocumentExtension) document;
				extension.registerPostNotificationReplace(null, new IDocumentExtension.IReplace() {

					public void perform(IDocument d, IDocumentListener owner) {
						if ((level.fFirstPosition.isDeleted || level.fFirstPosition.length == 0)
								&& !level.fSecondPosition.isDeleted
								&& level.fSecondPosition.offset == level.fFirstPosition.offset)
						{
							try {
								document.replace(level.fSecondPosition.offset,
												 level.fSecondPosition.length,
												 null);
							} catch (BadLocationException e) {
								CUIPlugin.getDefault().log(e);
							}
						}

						if (fBracketLevelStack.size() == 0) {
							document.removePositionUpdater(fUpdater);
							try {
								document.removePositionCategory(CATEGORY);
							} catch (BadPositionCategoryException e) {
								CUIPlugin.getDefault().log(e);
							}
						}
					}
				});
			}
		}

		/*
		 * @see org.eclipse.jface.text.link.ILinkedModeListener#suspend(org.eclipse.jface.text.link.LinkedModeModel)
		 */
		public void suspend(LinkedModeModel environment) {
		}

		/*
		 * @see org.eclipse.jface.text.link.ILinkedModeListener#resume(org.eclipse.jface.text.link.LinkedModeModel, int)
		 */
		public void resume(LinkedModeModel environment, int flags) {
		}
	}

	/**
	 * Updates the C outline page selection and this editor's range indicator.
	 * 
	 * @since 3.0
	 */

		/*
		 * @see org.eclipse.jface.text.information.IInformationProviderExtension#getInformation2(org.eclipse.jface.text.ITextViewer,
		 *      org.eclipse.jface.text.IRegion)
		 * @since 3.2
		 */
		public Object getInformation2(ITextViewer textViewer, IRegion subject) {
			return fHoverInfo;

			} catch (IllegalArgumentException e) {
				return -1;
			}

		}
	}
	
	/**
	 * Text navigation action to navigate to the next sub-word.
	 *
	 * @since 4.0
	 */
	protected abstract class NextSubWordAction extends TextNavigationAction {
	

		protected CWordIterator fIterator = new CWordIterator();
	protected CContentOutlinePage fOutlinePage;
	
	/** Search actions **/
	private ActionGroup fSelectionSearchGroup;
	private ActionGroup fTextSearchGroup;
    /** Action which shows selected element in CView. */
	private ShowInCViewAction fShowInCViewAction;
	
	/** Activity Listeners **/
	protected ISelectionChangedListener fStatusLineClearer;
    protected ISelectionChangedListener fSelectionUpdateListener;
	
	/** Pairs of brackets, used to match. */
    protected final static char[] BRACKETS = { '{', '}', '(', ')', '[', ']', '<', '>' };

		/**
		 * Creates a new next sub-word action.
		 *
		 * @param code Action code for the default operation. Must be an action code from @see org.eclipse.swt.custom.ST.
		 */
		protected NextSubWordAction(int code) {
			super(getSourceViewer().getTextWidget(), code);
		}

		/*
		 * @see org.eclipse.jface.action.IAction#run()
		 */
		public void run() {
			// Check whether sub word navigation is enabled.
			final IPreferenceStore store = getPreferenceStore();
			if (!store.getBoolean(SUB_WORD_NAVIGATION)) {
				super.run();
				return;
			}

			final ISourceViewer viewer = getSourceViewer();
			final IDocument document = viewer.getDocument();
			fIterator.setText((CharacterIterator) new DocumentCharacterIterator(document));
			int position = widgetOffset2ModelOffset(viewer, viewer.getTextWidget().getCaretOffset());
			if (position == -1)
				return;

			int next = findNextPosition(position);
			if (next != BreakIterator.DONE) {
				setCaretPosition(next);
				getTextWidget().showSelection();
				fireSelectionChanged();
			}
		}
	public static final String INACTIVE_CODE_ENABLE = "inactiveCodeEnable"; //$NON-NLS-1$
	/** Preference key for inactive code painter color */
	public static final String INACTIVE_CODE_COLOR = "inactiveCodeColor"; //$NON-NLS-1$
	/** Preference key for inserting spaces rather than tabs */
	public final static String SPACES_FOR_TABS = "spacesForTabs"; //$NON-NLS-1$

    /** Preference key for compiler task tags */
    private final static String TRANSLATION_TASK_TAGS= CCorePreferenceConstants.TRANSLATION_TASK_TAGS;

	/** 
	 * This editor's projection support 
	 */
	private ProjectionSupport fProjectionSupport;
	/** 
	 * This editor's projection model updater 
	 */
	private ICFoldingStructureProvider fProjectionModelUpdater;

		/**
		 * Finds the next position after the given position.
		 *
		 * @param position the current position
		 * @return the next position
		 */
		protected int findNextPosition(int position) {
			ISourceViewer viewer = getSourceViewer();
			int widget = -1;
			while (position != BreakIterator.DONE && widget == -1) { // TODO: optimize
				position = fIterator.following(position);
				if (position != BreakIterator.DONE)
					widget = modelOffset2WidgetOffset(viewer, position);
			}
			return position;
		}

		/**
		 * Sets the caret position to the sub-word boundary given with <code>position</code>.
		 *
		 * @param position Position where the action should move the caret
		 */
		protected abstract void setCaretPosition(int position);
	}

	/**
	 * Text navigation action to navigate to the next sub-word.
	 *
	 * @since 4.0
	 */
	protected class NavigateNextSubWordAction extends NextSubWordAction {
		CTextTools textTools = CUIPlugin.getDefault().getTextTools();
		setSourceViewerConfiguration(new CSourceViewerConfiguration(textTools, this));
		setDocumentProvider(CUIPlugin.getDefault().getDocumentProvider());
	
		setEditorContextMenuId("#CEditorContext"); //$NON-NLS-1$
		setRulerContextMenuId("#CEditorRulerContext"); //$NON-NLS-1$
		setOutlinerContextMenuId("#CEditorOutlinerContext"); //$NON-NLS-1$

		/**
		 * Creates a new navigate next sub-word action.
		 */
		public NavigateNextSubWordAction() {
			super(ST.WORD_NEXT);
		}

		/*
		 * @see org.eclipse.cdt.internal.ui.editor.CEditor.NextSubWordAction#setCaretPosition(int)
		 */
		protected void setCaretPosition(final int position) {
			getTextWidget().setCaretOffset(modelOffset2WidgetOffset(getSourceViewer(), position));
		}
	}

	/**
	 * Text operation action to delete the next sub-word.
	 *
	 * @since 4.0
	 */
	protected class DeleteNextSubWordAction extends NextSubWordAction implements IUpdate {
		super.doSetInput(input);
		setOutlinePageInput(fOutlinePage, input);

		/**
		 * Creates a new delete next sub-word action.
		 */
		public DeleteNextSubWordAction() {
			super(ST.DELETE_WORD_NEXT);
		}
		
		if (getSourceViewer() != null) {
			CSourceViewerDecorationSupport decoSupport = (CSourceViewerDecorationSupport) getSourceViewerDecorationSupport(getSourceViewer());
			decoSupport.editorInputChanged(input);
		}
	}

		/*
		 * @see org.eclipse.cdt.internal.ui.editor.CEditor.NextSubWordAction#setCaretPosition(int)
		 */
		protected void setCaretPosition(final int position) {
			if (!validateEditorInputState())
				return;
	}

			final ISourceViewer viewer = getSourceViewer();
			final int caret, length;
			Point selection = viewer.getSelectedRange();
			if (selection.y != 0) {
				caret = selection.x;
				length = selection.y;
			} else {
				caret = widgetOffset2ModelOffset(viewer, viewer.getTextWidget().getCaretOffset());
				length = position - caret;
			}

			try {
				viewer.getDocument().replace(caret, length, ""); //$NON-NLS-1$
			} catch (BadLocationException exception) {
				// Should not happen
	 * an external file.  Clients should test for <code>null<code> or use getInputCElement()
	 * @deprecated use <code>CEditor.getInputCElement()</code>.
     * @return IFile Input file or null if input is not and IFileEditorInput.
	 */
	public IFile getInputFile() {		
		IEditorInput editorInput = getEditorInput();
		if (editorInput != null) {
			if ((editorInput instanceof IFileEditorInput)) {
				return ((IFileEditorInput) editorInput).getFile();
			}
		}
		return null;
	}

		/*
		 * @see org.eclipse.cdt.internal.ui.editor.CEditor.NextSubWordAction#findNextPosition(int)
		 */
		protected int findNextPosition(int position) {
			return fIterator.following(position);
		}

		/*
		 * @see org.eclipse.ui.texteditor.IUpdate#update()
		 */
		public void update() {
			setEnabled(isEditorInputModifiable());
			fOutlinePage = new CContentOutlinePage(this);
			fOutlinePage.addSelectionChangedListener(this);
		}
		setOutlinePageInput(fOutlinePage, getEditorInput());
		return fOutlinePage;
	}

	/**
	 * Text operation action to select the next sub-word.
	 *
	 * @since 4.0
	 */
	protected class SelectNextSubWordAction extends NextSubWordAction {
		if (IContentOutlinePage.class.equals(required)) {
			return getOutlinePage();
		}
		if (required == IShowInTargetList.class) {
			return new IShowInTargetList() {
				public String[] getShowInTargetIds() {
					return new String[] { CUIPlugin.CVIEW_ID, IPageLayout.ID_OUTLINE, IPageLayout.ID_RES_NAV };
				}

		/**
		 * Creates a new select next sub-word action.
		 */
		public SelectNextSubWordAction() {
			super(ST.SELECT_WORD_NEXT);
		}

		/*
		 * @see org.eclipse.cdt.internal.ui.editor.CEditor.NextSubWordAction#setCaretPosition(int)
		 */
		protected void setCaretPosition(final int position) {
			final ISourceViewer viewer = getSourceViewer();

			final StyledText text = viewer.getTextWidget();
			if (text != null && !text.isDisposed()) {

				final Point selection = text.getSelection();
				final int caret = text.getCaretOffset();
				final int offset = modelOffset2WidgetOffset(viewer, position);

				if (caret == selection.x)
					text.setSelectionRange(selection.y, offset - selection.y);
				else
					text.setSelectionRange(selection.x, offset - selection.x);
			}
		}
		return super.getAdapter(required);
	}

	/**
	 * Text navigation action to navigate to the previous sub-word.
	 *
	 * @since 4.0
	 * 
	 * @param event the property change event
	 */
	protected abstract class PreviousSubWordAction extends TextNavigationAction {
		CSourceViewer asv = (CSourceViewer) getSourceViewer();

		try {
			if (asv != null) {

		protected CWordIterator fIterator = new CWordIterator();

		/**
		 * Creates a new previous sub-word action.
		 *
		 * @param code Action code for the default operation. Must be an action code from @see org.eclipse.swt.custom.ST.
		 */
		protected PreviousSubWordAction(final int code) {
			super(getSourceViewer().getTextWidget(), code);
		}

		/*
		 * @see org.eclipse.jface.action.IAction#run()
		 */
		public void run() {
			// Check whether sub word navigation is enabled.
			final IPreferenceStore store = getPreferenceStore();
			if (!store.getBoolean(SUB_WORD_NAVIGATION)) {
				super.run();
				return;
			}
					else
						stopTabConversion();
					return;
				}
				
				// Not implemented ... for the future.
				if (TRANSLATION_TASK_TAGS.equals(event.getProperty())) {
					ISourceViewer sourceViewer= getSourceViewer();
					if (sourceViewer != null && affectsTextPresentation(event))
						sourceViewer.invalidateTextPresentation();
				}

			final ISourceViewer viewer = getSourceViewer();
			final IDocument document = viewer.getDocument();
			fIterator.setText((CharacterIterator) new DocumentCharacterIterator(document));
			int position = widgetOffset2ModelOffset(viewer, viewer.getTextWidget().getCaretOffset());
			if (position == -1)
				return;
					if (fProjectionModelUpdater != null) {
						fProjectionModelUpdater.install(this, asv);
					}
					return;
				}

			int previous = findPreviousPosition(position);
			if (previous != BreakIterator.DONE) {
				setCaretPosition(previous);
				getTextWidget().showSelection();
				fireSelectionChanged();
			}
		} finally {
			super.handlePreferenceStoreChanged(event);
		}
	}

	/**
	 * React to changed selection.
	 * 
	 * @since 3.0
	 */
	protected void selectionChanged() {
		if (getSelectionProvider() == null)
			return;
		updateStatusLine();
	}

		/**
		 * Finds the previous position before the given position.
		 *
		 * @param position the current position
		 * @return the previous position
		 */
		protected int findPreviousPosition(int position) {
			ISourceViewer viewer = getSourceViewer();
			int widget = -1;
			while (position != BreakIterator.DONE && widget == -1) { // TODO: optimize
				position = fIterator.preceding(position);
				if (position != BreakIterator.DONE)
					widget = modelOffset2WidgetOffset(viewer, position);
					}
				} catch (CModelException e) {
                    // Selection change not applied.
				}
			}
			return position;
		}

		/**
		 * Sets the caret position to the sub-word boundary given with <code>position</code>.
		 *
		 * @param position Position where the action should move the caret
		 */
		protected abstract void setCaretPosition(int position);
	}

	/**
	 * Text navigation action to navigate to the previous sub-word.
	 *
	 * @since 4.0
	 */
	protected class NavigatePreviousSubWordAction extends PreviousSubWordAction {

		/**
		 * Creates a new navigate previous sub-word action.
		 */
		public NavigatePreviousSubWordAction() {
			super(ST.WORD_PREVIOUS);
			 */
			return;
		}
		if (element instanceof ISourceReference) {
			ISourceReference reference = (ISourceReference) element;
			// set hightlight range
			setSelection(reference, true);
		}
	}

		/*
		 * @see org.eclipse.cdt.internal.ui.editor.CEditor.PreviousSubWordAction#setCaretPosition(int)
		 */
		protected void setCaretPosition(final int position) {
			getTextWidget().setCaretOffset(modelOffset2WidgetOffset(getSourceViewer(), position));
    public void setSelection(ISourceReference element, boolean moveCursor) {
		if (element != null) {
			StyledText  textWidget= null;
			
			ISourceViewer sourceViewer= getSourceViewer();
			if (sourceViewer != null)
				textWidget= sourceViewer.getTextWidget();
			
			if (textWidget == null)
				return;

			try {
				setSelection(element.getSourceRange(), moveCursor);
			} catch (CModelException e) {
                // Selection not applied.
			}
		}
	}

	/**
	 * Text operation action to delete the previous sub-word.
	 * sets the current editor position.
	 *
	 * @since 4.0
	 * @param moveCursor if true the editor is scrolled to show the range.
	 */
	protected class DeletePreviousSubWordAction extends PreviousSubWordAction implements IUpdate {

		/**
		 * Creates a new delete previous sub-word action.
		 */
		public DeletePreviousSubWordAction() {
			super(ST.DELETE_WORD_PREVIOUS);
		}

		/*
		 * @see org.eclipse.cdt.internal.ui.editor.CEditor.PreviousSubWordAction#setCaretPosition(int)
		 */
		protected void setCaretPosition(int position) {
			if (!validateEditorInputState())
				return;

			final int length;
			final ISourceViewer viewer = getSourceViewer();
			Point selection = viewer.getSelectedRange();
			if (selection.y != 0) {
				position = selection.x;
				length = selection.y;
			} else {
				length = widgetOffset2ModelOffset(viewer, viewer.getTextWidget().getCaretOffset()) - position;
			}

			try {
				viewer.getDocument().replace(position, length, ""); //$NON-NLS-1$
			} catch (BadLocationException exception) {
				// Should not happen
				// Binary elements return the first executable statement so we have to substract -1
				start = getDocumentProvider().getDocument(getEditorInput()).getLineOffset(element.getStartLine() - 1);
				if (element.getEndLine() > 0) {
					length = getDocumentProvider().getDocument(getEditorInput()).getLineOffset(element.getEndLine()) - start;
				} else {
					length = start;
				}
				// create an alternate region for the keyword highlight.
				alternateRegion = getDocumentProvider().getDocument(getEditorInput()).getLineInformation(element.getStartLine() - 1);
				if (start == length || length < 0) {
					if (alternateRegion != null) {
						start = alternateRegion.getOffset();
						length = alternateRegion.getLength();
					}
				}
			}
		}

		/*
		 * @see org.eclipse.cdt.internal.ui.editor.CEditor.PreviousSubWordAction#findPreviousPosition(int)
		 */
		protected int findPreviousPosition(int position) {
			return fIterator.preceding(position);
					length = alternateRegion.getLength();
				}
				if (start > -1 && getSourceViewer() != null) {
					getSourceViewer().revealRange(start, length);
					getSourceViewer().setSelectedRange(start, length);
				}
				updateStatusField(CTextEditorActionConstants.STATUS_CURSOR_POS);
			}
			return;
		} catch (IllegalArgumentException x) {
            // No information to the user
		} catch (BadLocationException e) {
            // No information to the user
		}

		/*
		 * @see org.eclipse.ui.texteditor.IUpdate#update()
		 */
		public void update() {
			setEnabled(isEditorInputModifiable());
		}
	}

	/**
	 * Text operation action to select the previous sub-word.
	 *
	 * @since 4.0
	 */
	protected class SelectPreviousSubWordAction extends PreviousSubWordAction {
		IWorkbenchWindow window = getSite().getWorkbenchWindow();
		IPartService service = window.getPartService();
		return (this == service.getActivePart());
	}

		/**
		 * Creates a new select previous sub-word action.
		 */
		public SelectPreviousSubWordAction() {
			super(ST.SELECT_WORD_PREVIOUS);
		if (fProjectionModelUpdater != null) {
			fProjectionModelUpdater.uninstall();
			fProjectionModelUpdater= null;
		}
		
		if (fProjectionSupport != null) {
			fProjectionSupport.dispose();
			fProjectionSupport= null;
		}

		if (fCEditorErrorTickUpdater != null) {
			fCEditorErrorTickUpdater.dispose();
			fCEditorErrorTickUpdater = null;
		}
		
        if (fSelectionUpdateListener != null) {
			getSelectionProvider().addSelectionChangedListener(fSelectionUpdateListener);
			fSelectionUpdateListener = null;
        }
        
       	if (fStatusLineClearer != null) {
			ISelectionProvider provider = getSelectionProvider();
       		provider.removeSelectionChangedListener(fStatusLineClearer);
			fStatusLineClearer = null;
		}
        
        if (fBracketMatcher != null) {
			fBracketMatcher.dispose();
			fBracketMatcher = null;
		}
		
		if (fOutlinePage != null) {
			fOutlinePage.dispose();
			fOutlinePage = null;
		}
		
		if (fShowInCViewAction != null) {
			fShowInCViewAction.dispose();
			fShowInCViewAction = null;
		}
		
		if (fSelectionSearchGroup != null) {
			fSelectionSearchGroup.dispose();
			fSelectionSearchGroup = null;
		}

		if (fTextSearchGroup != null) {
			fTextSearchGroup.dispose();
			fTextSearchGroup = null;
		}

		/*
		 * @see org.eclipse.cdt.internal.ui.editor.CEditor.PreviousSubWordAction#setCaretPosition(int)
		 */
		protected void setCaretPosition(final int position) {
			final ISourceViewer viewer = getSourceViewer();

			final StyledText text = viewer.getTextWidget();
			if (text != null && !text.isDisposed()) {
		super.dispose();
	}

				final Point selection = text.getSelection();
				final int caret = text.getCaretOffset();
				final int offset = modelOffset2WidgetOffset(viewer, position);
	protected boolean canHandleMove(IEditorInput originalElement, IEditorInput movedElement) {
		String oldLanguage = ""; //$NON-NLS-1$
		if (originalElement instanceof IFileEditorInput) {
			IFile file= ((IFileEditorInput) originalElement).getFile();
			if (file != null) {
				IContentType type = CCorePlugin.getContentType(file.getProject(), file.getName());
				if (type != null) {
					oldLanguage = type.getId();
				}
				if (oldLanguage == null) {
					return false;
				}
			}
		}

				if (caret == selection.x)
					text.setSelectionRange(selection.y, offset - selection.y);
				else
					text.setSelectionRange(selection.x, offset - selection.x);
				IContentType type = CCorePlugin.getContentType(file.getProject(), file.getName());
				if (type != null) {
					newLanguage = type.getId();
				}
				if (newLanguage == null) {
					return false;
				}
			}
		}
		return oldLanguage.equals(newLanguage);
	}
	

	/**
	 * The information provider used to present focusable information
	 * shells.
	 */
	private InformationPresenter fInformationPresenter;
	
	/**
	 * The editor selection changed listener.
	 * 
	 * @since 3.0
	 */
	private EditorSelectionChangedListener fEditorSelectionChangedListener;

	/** The outline page */
	protected CContentOutlinePage fOutlinePage;
	
	/** Search actions **/
	private ActionGroup fSelectionSearchGroup;
	private ActionGroup fTextSearchGroup;
    /** Action which shows selected element in CView. */
	private ShowInCViewAction fShowInCViewAction;
	
	/** Activity Listeners **/
	protected ISelectionChangedListener fStatusLineClearer;
    protected ISelectionChangedListener fSelectionUpdateListener;
	
	/** Pairs of brackets, used to match. */
    protected final static char[] BRACKETS = { '{', '}', '(', ')', '[', ']', '<', '>' };
		
		action= new ToggleCommentAction(CEditorMessages.getResourceBundle(), "ToggleComment.", this); //$NON-NLS-1$
		action.setActionDefinitionId(ICEditorActionDefinitionIds.TOGGLE_COMMENT);
		setAction("ToggleComment", action); //$NON-NLS-1$
		markAsStateDependentAction("ToggleComment", true); //$NON-NLS-1$
		configureToggleCommentAction();
		
		action= new AddBlockCommentAction(CEditorMessages.getResourceBundle(), "AddBlockComment.", this);  //$NON-NLS-1$
		action.setActionDefinitionId(ICEditorActionDefinitionIds.ADD_BLOCK_COMMENT);		
		setAction("AddBlockComment", action); //$NON-NLS-1$
		markAsStateDependentAction("AddBlockComment", true); //$NON-NLS-1$
		markAsSelectionDependentAction("AddBlockComment", true); //$NON-NLS-1$		
		//WorkbenchHelp.setHelp(action, ICHelpContextIds.ADD_BLOCK_COMMENT_ACTION);

	/** Matches the brackets. */
    protected CPairMatcher fBracketMatcher = new CPairMatcher(BRACKETS);
		setAction("RemoveBlockComment", action); //$NON-NLS-1$
		markAsStateDependentAction("RemoveBlockComment", true); //$NON-NLS-1$
		markAsSelectionDependentAction("RemoveBlockComment", true); //$NON-NLS-1$		
		//WorkbenchHelp.setHelp(action, ICHelpContextIds.REMOVE_BLOCK_COMMENT_ACTION);

	/** The bracket inserter. */
	private BracketInserter fBracketInserter = new BracketInserter();
		setAction("Format", action); //$NON-NLS-1$
		markAsStateDependentAction("Format", true); //$NON-NLS-1$

	/** The editor's tab converter */
	private TabConverter fTabConverter;
		setAction("ContentAssistProposal", action); //$NON-NLS-1$
		markAsStateDependentAction("ContentAssistProposal", true); //$NON-NLS-1$

	/** Listener to annotation model changes that updates the error tick in the tab image */
	private CEditorErrorTickUpdater fCEditorErrorTickUpdater;
		setAction("ContentAssistTip", action); //$NON-NLS-1$

	/** Preference key for sub-word navigation, aka smart caret positioning */
	public final static String SUB_WORD_NAVIGATION = "subWordNavigation"; //$NON-NLS-1$
	/** Preference key for matching brackets */
	public final static String MATCHING_BRACKETS = "matchingBrackets"; //$NON-NLS-1$
	/** Preference key for matching brackets color */
	public final static String MATCHING_BRACKETS_COLOR = "matchingBracketsColor"; //$NON-NLS-1$
	/** Preference key for inactive code painter enablement */
	public static final String INACTIVE_CODE_ENABLE = "inactiveCodeEnable"; //$NON-NLS-1$
	/** Preference key for inactive code painter color */
	public static final String INACTIVE_CODE_COLOR = "inactiveCodeColor"; //$NON-NLS-1$
	/** Preference key for code formatter tab size */
	private final static String CODE_FORMATTER_TAB_SIZE = DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE;
	/** Preference key for inserting spaces rather than tabs */
	public final static String SPACES_FOR_TABS = "spacesForTabs"; //$NON-NLS-1$
	/** Preference key for automatically closing strings */
	private final static String CLOSE_STRINGS = PreferenceConstants.EDITOR_CLOSE_STRINGS;
	/** Preference key for automatically closing brackets and parenthesis */
	private final static String CLOSE_BRACKETS = PreferenceConstants.EDITOR_CLOSE_BRACKETS;
	/** Preference key for automatically closing angular brackets */
	private final static String CLOSE_ANGULAR_BRACKETS = PreferenceConstants.EDITOR_CLOSE_ANGULAR_BRACKETS;

    /** Preference key for compiler task tags */
    private final static String TRANSLATION_TASK_TAGS = CCorePreferenceConstants.TRANSLATION_TASK_TAGS;
        setAction("OpenDefinition", action); //$NON-NLS-1$
        
//		action = new OpenTypeHierarchyAction(this);
//		action.setActionDefinitionId(ICEditorActionDefinitionIds.OPEN_TYPE_HIERARCHY);
//		setAction("OpenTypeHierarchy", action); //$NON-NLS-1$

	/** 
	 * This editor's projection support 
	 */
	private ProjectionSupport fProjectionSupport;
	/** 
	 * This editor's projection model updater 
	 */
	private ICFoldingStructureProvider fProjectionModelUpdater;
        
        action = new GoToNextPreviousMemberAction(CEditorMessages.getResourceBundle(), "GotoNextMember.", this, true); //$NON-NLS-1$
        action.setActionDefinitionId(ICEditorActionDefinitionIds.GOTO_NEXT_MEMBER);
        setAction("GotoNextMember", action); //$NON-NLS-1$*/

	/**
	 * The action group for folding.
	 */
	private FoldingActionGroup fFoldingGroup;

	/**
	 * Default constructor.
	 */
	public CEditor() {
		super();
	}

	/**
	 * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#initializeEditor()
	 */
	protected void initializeEditor() {
		CTextTools textTools = CUIPlugin.getDefault().getTextTools();
		setSourceViewerConfiguration(new CSourceViewerConfiguration(textTools, this));
		setDocumentProvider(CUIPlugin.getDefault().getDocumentProvider());
	
		setEditorContextMenuId("#CEditorContext"); //$NON-NLS-1$
		setRulerContextMenuId("#CEditorRulerContext"); //$NON-NLS-1$
		setOutlinerContextMenuId("#CEditorOutlinerContext"); //$NON-NLS-1$
		addAction(menu, ITextEditorActionConstants.GROUP_EDIT, "ToggleComment"); //$NON-NLS-1$
		addAction(menu, ITextEditorActionConstants.GROUP_EDIT, "AddBlockComment"); //$NON-NLS-1$
		addAction(menu, ITextEditorActionConstants.GROUP_EDIT, "RemoveBlockComment"); //$NON-NLS-1$

		setPreferenceStore(CUIPlugin.getDefault().getCombinedPreferenceStore());
		fCEditorErrorTickUpdater = new CEditorErrorTickUpdater(this);          
	}

	/**
	 * @see org.eclipse.ui.texteditor.AbstractTextEditor#doSetInput(org.eclipse.ui.IEditorInput)
	 */
	protected void doSetInput(IEditorInput input) throws CoreException {
		super.doSetInput(input);
		setOutlinePageInput(fOutlinePage, input);

		if (fProjectionModelUpdater != null) {
			fProjectionModelUpdater.initialize();
		}
		if (fCEditorErrorTickUpdater != null) {
			fCEditorErrorTickUpdater.updateEditorImage(getInputCElement());
		}
		
		if (getSourceViewer() != null) {
			CSourceViewerDecorationSupport decoSupport = (CSourceViewerDecorationSupport) getSourceViewerDecorationSupport(getSourceViewer());
			decoSupport.editorInputChanged(input);
		}
	}

	/**
	 * Update the title image.
     * @param image Title image.
	 */
	public void updatedTitleImage(Image image) {
		setTitleImage(image);
	}

	/**
	 * Returns the C element wrapped by this editors input.
	 *
	 * @return the C element wrapped by this editors input.
	 * @since 3.0
	 */
	public ICElement getInputCElement () {
		return CUIPlugin.getDefault().getWorkingCopyManager().getWorkingCopy(getEditorInput());
	}

	/**
	 * Gets the current IFile input.
	 * This method will be remove after cdt-3.0.
	 * We can not guaranty that the input is an IFile, it may
	 * an external file.  Clients should test for <code>null<code> or use getInputCElement()
	 * @deprecated use <code>CEditor.getInputCElement()</code>.
     * @return IFile Input file or null if input is not and IFileEditorInput.
	 */
	public IFile getInputFile() {		
		IEditorInput editorInput = getEditorInput();
		if (editorInput != null) {
			if ((editorInput instanceof IFileEditorInput)) {
				return ((IFileEditorInput) editorInput).getFile();
			}
		}
		return null;
	}

	/**
     * @see org.eclipse.ui.ISaveablePart#isSaveAsAllowed()
	 * @return <code>true</code> if folding is enabled, <code>false</code> otherwise.
	 */
    public boolean isSaveAsAllowed() {
		return true;
	}
	/**
	 * Gets the outline page of the c-editor.
     * @return Outline page.
	 */
	public CContentOutlinePage getOutlinePage() {
		if (fOutlinePage == null) {
			fOutlinePage = new CContentOutlinePage(this);
			fOutlinePage.addSelectionChangedListener(this);
		}
		setOutlinePageInput(fOutlinePage, getEditorInput());
		return fOutlinePage;
	}

	/**
	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
	 */
	public Object getAdapter(Class required) {
		if (IContentOutlinePage.class.equals(required)) {
			return getOutlinePage();
		}
		if (required == IShowInTargetList.class) {
			return new IShowInTargetList() {
				public String[] getShowInTargetIds() {
					return new String[] { CUIPlugin.CVIEW_ID, IPageLayout.ID_OUTLINE, IPageLayout.ID_RES_NAV };
				}

			};
		}
		if (ProjectionAnnotationModel.class.equals(required)) {
			if (fProjectionSupport != null) {
				Object adapter = fProjectionSupport.getAdapter(getSourceViewer(), required);
				if (adapter != null)
					return adapter;
			}
		}
		return super.getAdapter(required);
	}
	/**
	 * Handles a property change event describing a change
	 * of the editor's preference store and updates the preference
	 * related editor properties.
	 * 
	 * @param event the property change event
	 * and our own listener for cursor/key/selection events to update cursor position in
	 * status bar.

     * @param parent Parent composite of the control.
	 */
	protected void handlePreferenceStoreChanged(PropertyChangeEvent event) {
		CSourceViewer asv = (CSourceViewer) getSourceViewer();
	
		// Sticky hover support
		IInformationControlCreator informationControlCreator = new IInformationControlCreator() {
			public IInformationControl createInformationControl(Shell shell) {
				boolean cutDown = false;
				int style = cutDown ? SWT.NONE : (SWT.V_SCROLL | SWT.H_SCROLL);
				return new DefaultInformationControl(shell, SWT.RESIZE
						| SWT.TOOL, style, new HTMLTextPresenter(cutDown));
			}
		};

		fInformationPresenter = new InformationPresenter(
				informationControlCreator);
		fInformationPresenter.setSizeConstraints(60, 10, true, true);
		fInformationPresenter.install(getSourceViewer());
		fInformationPresenter
				.setDocumentPartitioning(ICPartitions.C_PARTITIONING);
				
		
		ProjectionViewer projectionViewer= (ProjectionViewer) getSourceViewer();
		
		fProjectionSupport= new ProjectionSupport(projectionViewer, getAnnotationAccess(), getSharedColors());
		fProjectionSupport.addSummarizableAnnotationType("org.eclipse.ui.workbench.texteditor.error"); //$NON-NLS-1$
		fProjectionSupport.addSummarizableAnnotationType("org.eclipse.ui.workbench.texteditor.warning"); //$NON-NLS-1$
		fProjectionSupport.install();
		
		fProjectionModelUpdater= CUIPlugin.getDefault().getFoldingStructureProviderRegistry().getCurrentFoldingProvider();
		if (fProjectionModelUpdater != null)
			fProjectionModelUpdater.install(this, projectionViewer);

		if (isFoldingEnabled())
			projectionViewer.doOperation(ProjectionViewer.TOGGLE);
		

		try {
			if (asv != null) {

				String property = event.getProperty();
		fEditorSelectionChangedListener.install(getSelectionProvider());
		

				if (CODE_FORMATTER_TAB_SIZE.equals(property)) {
					SourceViewerConfiguration configuration = getSourceViewerConfiguration();
					String[] types = configuration.getConfiguredContentTypes(asv);
					for (int i = 0; i < types.length; i++) {
						String[] prefixes = configuration.getIndentPrefixes(asv, types[i]);
						if (prefixes != null && prefixes.length > 0)
							asv.setIndentPrefixes(prefixes, types[i]);
					}

					if (fTabConverter != null) {
						fTabConverter.setNumberOfSpacesPerTab(getTabSize());
					}
					return;
				}
		int operations= DND.DROP_MOVE | DND.DROP_COPY;

				if (CLOSE_BRACKETS.equals(property)) {
					fBracketInserter.setCloseBracketsEnabled(getPreferenceStore().getBoolean(property));
					return;
				}

				if (CLOSE_ANGULAR_BRACKETS.equals(property)) {
					fBracketInserter.setCloseAngularBracketsEnabled(getPreferenceStore().getBoolean(property));
					return;
				}
				
				if (CLOSE_STRINGS.equals(property)) {
					fBracketInserter.setCloseStringsEnabled(getPreferenceStore().getBoolean(property));
					return;
				}

				if (SPACES_FOR_TABS.equals(property)) {
					if (isTabConversionEnabled())
						startTabConversion();
					else
						stopTabConversion();
					return;
				}
			configureSourceViewerDecorationSupport(fSourceViewerDecorationSupport);
		}
		return fSourceViewerDecorationSupport;
	}
	
	/*
	 * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#configureSourceViewerDecorationSupport(org.eclipse.ui.texteditor.SourceViewerDecorationSupport)
	 */
	protected void configureSourceViewerDecorationSupport(SourceViewerDecorationSupport support) {
		super.configureSourceViewerDecorationSupport(support);
		//Enhance the stock source viewer decorator with a bracket matcher
		support.setCharacterPairMatcher(fBracketMatcher);
		support.setMatchingCharacterPainterPreferenceKeys(MATCHING_BRACKETS, MATCHING_BRACKETS_COLOR);
		((CSourceViewerDecorationSupport)support).setInactiveCodePainterPreferenceKeys(INACTIVE_CODE_ENABLE, INACTIVE_CODE_COLOR);
	}
	
	/**
	 * Jumps to the matching bracket.
	 */
	public void gotoMatchingBracket() {
		
		ISourceViewer sourceViewer= getSourceViewer();
		IDocument document= sourceViewer.getDocument();
		if (document == null)
			return;
		
		IRegion selection= getSignedSelection(sourceViewer);

				if (PreferenceConstants.EDITOR_SMART_TAB.equals(property)) {
					if (getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SMART_TAB)) {
						setActionActivationCode("IndentOnTab", '\t', -1, SWT.NONE); //$NON-NLS-1$
					} else {
						removeActionActivationCode("IndentOnTab"); //$NON-NLS-1$
					}
				}

				// Not implemented ... for the future.
				if (TRANSLATION_TASK_TAGS.equals(event.getProperty())) {
					ISourceViewer sourceViewer = getSourceViewer();
					if (sourceViewer != null && affectsTextPresentation(event))
						sourceViewer.invalidateTextPresentation();
				}

				if (PreferenceConstants.EDITOR_FOLDING_PROVIDER.equals(property)) {
					if (fProjectionModelUpdater != null) {
						fProjectionModelUpdater.uninstall();
					}
					// either freshly enabled or provider changed
					fProjectionModelUpdater = CUIPlugin.getDefault().getFoldingStructureProviderRegistry().getCurrentFoldingProvider();
					if (fProjectionModelUpdater != null) {
						fProjectionModelUpdater.install(this, asv);
					}
					return;
				}
			return;
			
		int anchor= fBracketMatcher.getAnchor();
		// http://dev.eclipse.org/bugs/show_bug.cgi?id=34195
		int targetOffset= (ICharacterPairMatcher.RIGHT == anchor) ? offset + 1: offset + length;
		
		boolean visible= false;
		if (sourceViewer instanceof ITextViewerExtension5) {
			ITextViewerExtension5 extension= (ITextViewerExtension5) sourceViewer;
			visible= (extension.modelOffset2WidgetOffset(targetOffset) > -1);
		} else {
			IRegion visibleRegion= sourceViewer.getVisibleRegion();
			// http://dev.eclipse.org/bugs/show_bug.cgi?id=34195
			visible= (targetOffset >= visibleRegion.getOffset() && targetOffset <= visibleRegion.getOffset() + visibleRegion.getLength());
		}
		
		if (!visible) {
			setStatusLineErrorMessage(CEditorMessages.getString("GotoMatchingBracket.error.bracketOutsideSelectedElement"));	//$NON-NLS-1$		
			sourceViewer.getTextWidget().getDisplay().beep();
			return;
		}
		
		if (selection.getLength() < 0)
			targetOffset -= selection.getLength();
			
		sourceViewer.setSelectedRange(targetOffset, selection.getLength());
		sourceViewer.revealRange(targetOffset, selection.getLength());
	}

				IContentAssistant c = asv.getContentAssistant();
				if (c instanceof ContentAssistant) {
					ContentAssistPreference.changeConfiguration((ContentAssistant) c, getPreferenceStore(), event);
				}
			}
		} finally {
			super.handlePreferenceStoreChanged(event);
			if (annotation instanceof ICAnnotation && ((ICAnnotation) annotation).isProblem())
				setStatusLineMessage(annotation.getText());
		}
	}

	/**
	 * React to changed selection.
	 * 
	 * @param offset the region offset
	 * @param length the region length
	 * @return the found annotation or <code>null</code>
	 * @since 3.0
	 */
	protected void selectionChanged() {
		if (getSelectionProvider() == null)
			return;
		updateStatusLine();
			Annotation a= (Annotation) e.next();
			if (!isNavigationTarget(a))
				continue;
				
			Position p= model.getPosition(a);
			if (p != null && p.overlapsWith(offset, length))
				return a;
		}
		
		return null;
	}
	/* (non-Javadoc)
	 * @see org.eclipse.ui.part.IShowInSource#getShowInContext()
	 *
	 * This is required by the IShowInSource interface for the "ShowIn"
 	 * navigation menu generalized in Eclipse.
	 */
	public ShowInContext getShowInContext() {
		return new ShowInContext( getEditorInput(), null );
	}

	/**
	 * @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)
	 */
	public void selectionChanged(SelectionChangedEvent event) {
		ISelection sel = event.getSelection();
		if (sel instanceof IStructuredSelection) {
			IStructuredSelection selection = (IStructuredSelection) sel;
			Object obj = selection.getFirstElement();
			if (obj instanceof ISourceReference) {
				try {
					ISourceRange range = ((ISourceReference) obj).getSourceRange();
					if (range != null) {
						setSelection(range, !isActivePart());
					}
				} catch (CModelException e) {
                    // Selection change not applied.
				}
			}
		}
		return null;
	}

	/**
     * Sets selection for C element. 
     * @param element Element to select.
	 * @since 4.0.0
	 */
    public void setSelection(ICElement element) {
		IAction action= getAction("ToggleComment"); //$NON-NLS-1$
		if (action instanceof ToggleCommentAction) {
			ISourceViewer sourceViewer= getSourceViewer();
			SourceViewerConfiguration configuration= getSourceViewerConfiguration();
			((ToggleCommentAction)action).configure(sourceViewer, configuration);
		}
	}

		if (element == null || element instanceof ITranslationUnit) {
			/*
			 * If the element is an ITranslationUnit this unit is either the input
			 * of this editor or not being displayed. In both cases, nothing should
			 * happened.
			 */
			return;
				fTabConverter.setLineTracker(new DefaultLineTracker());
			}
		}
		if (element instanceof ISourceReference) {
			ISourceReference reference = (ISourceReference) element;
			// set hightlight range
			setSelection(reference, true);
			CSourceViewer asv = (CSourceViewer) getSourceViewer();
			SourceViewerConfiguration configuration = getSourceViewerConfiguration();
			fTabConverter = new TabConverter();
			configureTabConverter();
			fTabConverter.setNumberOfSpacesPerTab(configuration.getTabWidth(asv));
			asv.addTextConverter(fTabConverter);
		}
	}

    /**
     * Sets selection for source reference.
     * @param element Source reference to set.
     * @param moveCursor Should cursor be moved.
     */
    public void setSelection(ISourceReference element, boolean moveCursor) {
		if (element != null) {
			StyledText  textWidget = null;
			
			ISourceViewer sourceViewer = getSourceViewer();
			if (sourceViewer != null)
				textWidget = sourceViewer.getTextWidget();
			
			if (textWidget == null)
				return;

			try {
				setSelection(element.getSourceRange(), moveCursor);
			} catch (CModelException e) {
                // Selection not applied.
			}
		}
	}

	/**
	 * Sets the current editor selection to the source range. Optionally
	 * sets the current editor position.
	 *
	 * @param element the source range to be shown in the editor, can be null.
	 * @param moveCursor if true the editor is scrolled to show the range.
	 */
	public void setSelection(ISourceRange element, boolean moveCursor) {
		super.createNavigationActions();

		if (element == null) {
			return;
		}

		try {
			IRegion alternateRegion = null;
			int start = element.getStartPos();
			int length = element.getLength();

			// Sanity check sometimes the parser may throw wrong numbers.
			if (start < 0 || length < 0) {
				start = 0;
				length = 0;
			}

			// 0 length and start and non-zero start line says we know
			// the line for some reason, but not the offset.
			if (length == 0 && start == 0 && element.getStartLine() > 0) {
				// We have the information in term of lines, we can work it out.
				// Binary elements return the first executable statement so we have to substract -1
				start = getDocumentProvider().getDocument(getEditorInput()).getLineOffset(element.getStartLine() - 1);
				if (element.getEndLine() > 0) {
					length = getDocumentProvider().getDocument(getEditorInput()).getLineOffset(element.getEndLine()) - start;
				} else {
					length = start;
				}
				// create an alternate region for the keyword highlight.
				alternateRegion = getDocumentProvider().getDocument(getEditorInput()).getLineInformation(element.getStartLine() - 1);
				if (start == length || length < 0) {
					if (alternateRegion != null) {
						start = alternateRegion.getOffset();
						length = alternateRegion.getLength();
					}
				}
			}
			setHighlightRange(start, length, moveCursor);

			if (moveCursor) {
				start = element.getIdStartPos();
				length = element.getIdLength();
				if (start == 0 && length == 0 && alternateRegion != null) {
					start = alternateRegion.getOffset();
					length = alternateRegion.getLength();
				}
				if (start > -1 && getSourceViewer() != null) {
					getSourceViewer().revealRange(start, length);
					getSourceViewer().setSelectedRange(start, length);
				}
				updateStatusField(CTextEditorActionConstants.STATUS_CURSOR_POS);
			}
			return;
		} catch (IllegalArgumentException x) {
            // No information to the user
		} catch (BadLocationException e) {
            // No information to the user
		}

		if (moveCursor)
			resetHighlightRange();
		setAction(ITextEditorActionDefinitionIds.DELETE_NEXT_WORD, action);
		textWidget.setKeyBinding(SWT.CTRL | SWT.DEL, SWT.NULL);
		markAsStateDependentAction(ITextEditorActionDefinitionIds.DELETE_NEXT_WORD, true);
	}

	/**
     * Checks is the editor active part. 
     * @return <code>true</code> if editor is the active part of the workbench.
	 */
    private boolean isActivePart() {
		IWorkbenchWindow window = getSite().getWorkbenchWindow();
		IPartService service = window.getPartService();
		return (this == service.getActivePart());
	}

    /**
     * @see org.eclipse.ui.IWorkbenchPart#dispose()
     */
    public void dispose() {

		ISourceViewer sourceViewer = getSourceViewer();
		if (sourceViewer instanceof ITextViewerExtension)
			((ITextViewerExtension) sourceViewer).removeVerifyKeyListener(fBracketInserter);

		if (fProjectionModelUpdater != null) {
			fProjectionModelUpdater.uninstall();
			fProjectionModelUpdater = null;
		}
		
		if (fProjectionSupport != null) {
			fProjectionSupport.dispose();
			fProjectionSupport = null;
		}

		if (fCEditorErrorTickUpdater != null) {
			fCEditorErrorTickUpdater.dispose();
			fCEditorErrorTickUpdater = null;
		}
		
        if (fSelectionUpdateListener != null) {
			getSelectionProvider().addSelectionChangedListener(fSelectionUpdateListener);
			fSelectionUpdateListener = null;
        }
        
       	if (fStatusLineClearer != null) {
			ISelectionProvider provider = getSelectionProvider();
       		provider.removeSelectionChangedListener(fStatusLineClearer);
			fStatusLineClearer = null;
		}
        
        if (fBracketMatcher != null) {
			fBracketMatcher.dispose();
			fBracketMatcher = null;
		}
		
		if (fOutlinePage != null) {
			fOutlinePage.dispose();
			fOutlinePage = null;
		}
		
		if (fShowInCViewAction != null) {
			fShowInCViewAction.dispose();
			fShowInCViewAction = null;
		}
		
		if (fSelectionSearchGroup != null) {
			fSelectionSearchGroup.dispose();
			fSelectionSearchGroup = null;
		}

		if (fTextSearchGroup != null) {
			fTextSearchGroup.dispose();
			fTextSearchGroup = null;
		}

		if (fEditorSelectionChangedListener != null)  {
			fEditorSelectionChangedListener.uninstall(getSelectionProvider());
			fEditorSelectionChangedListener = null;
		}

		stopTabConversion();
		
		super.dispose();
	}

	/**
	 * @see org.eclipse.ui.texteditor.AbstractTextEditor#canHandleMove(org.eclipse.ui.IEditorInput, org.eclipse.ui.IEditorInput)
	 */
	protected boolean canHandleMove(IEditorInput originalElement, IEditorInput movedElement) {
		String oldLanguage = ""; //$NON-NLS-1$
		if (originalElement instanceof IFileEditorInput) {
			IFile file = ((IFileEditorInput) originalElement).getFile();
			if (file != null) {
				IContentType type = CCorePlugin.getContentType(file.getProject(), file.getName());
				if (type != null) {
					oldLanguage = type.getId();
				}
				if (oldLanguage == null) {
					return false;
				}
			}
		}

		String newLanguage = ""; //$NON-NLS-1$
		if (movedElement instanceof IFileEditorInput) {
			IFile file = ((IFileEditorInput) movedElement).getFile();
			if (file != null) {
				IContentType type = CCorePlugin.getContentType(file.getProject(), file.getName());
				if (type != null) {
					newLanguage = type.getId();
				}
				if (newLanguage == null) {
					return false;
									command.caretOffset += position - oldPosition - 1;
								}
							} else {
								buffer.append(c);
								++position;
							}
						}
					}
						
					command.text = buffer.toString();
				} catch (BadLocationException x) {
				}
			}
		}
		return oldLanguage.equals(newLanguage);
	}

	/**
	 * @see org.eclipse.ui.texteditor.AbstractTextEditor#createActions()
	 */
	protected void createActions() {
		super.createActions();
			new CSourceViewer(
				this, parent,
				ruler,
				styles,
				getOverviewRuler(),
				isOverviewRulerVisible());

		fFoldingGroup = new FoldingActionGroup(this, getSourceViewer());
		decoSupport.editorInputChanged(getEditorInput());

		// Sticky hover support
		ResourceAction resAction = new TextOperationAction(CEditorMessages.getResourceBundle(), "ShowToolTip.", this, ISourceViewer.INFORMATION, true); //$NON-NLS-1$
		ResourceAction resAction2 = new InformationDispatchAction(CEditorMessages.getResourceBundle(), "ShowToolTip.", (TextOperationAction) resAction); //$NON-NLS-1$
		resAction2.setActionDefinitionId(ICEditorActionDefinitionIds.SHOW_TOOLTIP);
		setAction("ShowToolTip", resAction2); //$NON-NLS-1$
		PlatformUI.getWorkbench().getHelpSystem().setHelp(resAction2, ICHelpContextIds.SHOW_TOOLTIP_ACTION);
		
		// Default text editing menu items
		Action action = new GotoMatchingBracketAction(this);
		action.setActionDefinitionId(ICEditorActionDefinitionIds.GOTO_MATCHING_BRACKET);				
		setAction(GotoMatchingBracketAction.GOTO_MATCHING_BRACKET, action);
		
		action = new JoinLinesAction(CEditorMessages.getResourceBundle(), "JoinLines.", this); //$NON-NLS-1$
		action.setActionDefinitionId(ICEditorActionDefinitionIds.JOIN_LINES);
		setAction("Join Lines", action); //$NON-NLS-1$
		
		action = new ToggleCommentAction(CEditorMessages.getResourceBundle(), "ToggleComment.", this); //$NON-NLS-1$
		action.setActionDefinitionId(ICEditorActionDefinitionIds.TOGGLE_COMMENT);
		setAction("ToggleComment", action); //$NON-NLS-1$
		markAsStateDependentAction("ToggleComment", true); //$NON-NLS-1$
		configureToggleCommentAction();
		
		action = new AddBlockCommentAction(CEditorMessages.getResourceBundle(), "AddBlockComment.", this);  //$NON-NLS-1$
		action.setActionDefinitionId(ICEditorActionDefinitionIds.ADD_BLOCK_COMMENT);		
		setAction("AddBlockComment", action); //$NON-NLS-1$
		markAsStateDependentAction("AddBlockComment", true); //$NON-NLS-1$
		markAsSelectionDependentAction("AddBlockComment", true); //$NON-NLS-1$		
		//WorkbenchHelp.setHelp(action, ICHelpContextIds.ADD_BLOCK_COMMENT_ACTION);

		action = new RemoveBlockCommentAction(CEditorMessages.getResourceBundle(), "RemoveBlockComment.", this);  //$NON-NLS-1$
		action.setActionDefinitionId(ICEditorActionDefinitionIds.REMOVE_BLOCK_COMMENT);		
		setAction("RemoveBlockComment", action); //$NON-NLS-1$
		markAsStateDependentAction("RemoveBlockComment", true); //$NON-NLS-1$
		markAsSelectionDependentAction("RemoveBlockComment", true); //$NON-NLS-1$		
		//WorkbenchHelp.setHelp(action, ICHelpContextIds.REMOVE_BLOCK_COMMENT_ACTION);

		action = new IndentAction(CEditorMessages.getResourceBundle(), "Indent.", this, false); //$NON-NLS-1$
		action.setActionDefinitionId(ICEditorActionDefinitionIds.INDENT);
		setAction("Indent", action); //$NON-NLS-1$
		markAsStateDependentAction("Indent", true); //$NON-NLS-1$
		markAsSelectionDependentAction("Indent", true); //$NON-NLS-1$
//		PlatformUI.getWorkbench().getHelpSystem().setHelp(action, ICHelpContextIds.INDENT_ACTION);

		action = new IndentAction(CEditorMessages.getResourceBundle(), "Indent.", this, true); //$NON-NLS-1$
		setAction("IndentOnTab", action); //$NON-NLS-1$
		markAsStateDependentAction("IndentOnTab", true); //$NON-NLS-1$
		markAsSelectionDependentAction("IndentOnTab", true); //$NON-NLS-1$
		
		if (getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SMART_TAB)) {
			setActionActivationCode("IndentOnTab", '\t', -1, SWT.NONE); //$NON-NLS-1$
		}
		
		action = new TextOperationAction(CEditorMessages.getResourceBundle(), "Format.", this, ISourceViewer.FORMAT); //$NON-NLS-1$
		action.setActionDefinitionId(ICEditorActionDefinitionIds.FORMAT);
		setAction("Format", action); //$NON-NLS-1$
		markAsStateDependentAction("Format", true); //$NON-NLS-1$

		action = new ContentAssistAction(CEditorMessages.getResourceBundle(), "ContentAssistProposal.", this); //$NON-NLS-1$
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);
		setAction("ContentAssistProposal", action); //$NON-NLS-1$
		markAsStateDependentAction("ContentAssistProposal", true); //$NON-NLS-1$

		action = new TextOperationAction(CEditorMessages.getResourceBundle(), "ContentAssistTip.", this, ISourceViewer.CONTENTASSIST_CONTEXT_INFORMATION); //$NON-NLS-1$
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.CONTENT_ASSIST_CONTEXT_INFORMATION);
		setAction("ContentAssistTip", action); //$NON-NLS-1$

		action = new AddIncludeOnSelectionAction(this);
		action.setActionDefinitionId(ICEditorActionDefinitionIds.ADD_INCLUDE);
		setAction("AddIncludeOnSelection", action); //$NON-NLS-1$
	
		action = new OpenDeclarationsAction(this);
		action.setActionDefinitionId(ICEditorActionDefinitionIds.OPEN_DECL);
		setAction("OpenDeclarations", action); //$NON-NLS-1$
	protected void initializeKeyBindingScopes() {
		setKeyBindingScopes(new String [] { "org.eclipse.cdt.ui.cEditorScope" } ); //$NON-NLS-1$
	}

        action = new OpenDefinitionAction(this);
        action.setActionDefinitionId(ICEditorActionDefinitionIds.OPEN_DEF);
        setAction("OpenDefinition", action); //$NON-NLS-1$
        
//		action = new OpenTypeHierarchyAction(this);
//		action.setActionDefinitionId(ICEditorActionDefinitionIds.OPEN_TYPE_HIERARCHY);
//		setAction("OpenTypeHierarchy", action); //$NON-NLS-1$

		fShowInCViewAction = new ShowInCViewAction(this);
		action = fShowInCViewAction;
		action.setActionDefinitionId(ICEditorActionDefinitionIds.OPEN_CVIEW);
		setAction("ShowInCView", action); //$NON-NLS-1$
        
        action = new TextOperationAction(CEditorMessages.getResourceBundle(), "OpenOutline.", this, CSourceViewer.SHOW_OUTLINE, true); //$NON-NLS-1$
        action.setActionDefinitionId(ICEditorActionDefinitionIds.OPEN_OUTLINE);
        setAction("OpenOutline", action); //$NON-NLS-1$*/
        
        action = new GoToNextPreviousMemberAction(CEditorMessages.getResourceBundle(), "GotoNextMember.", this, true); //$NON-NLS-1$
        action.setActionDefinitionId(ICEditorActionDefinitionIds.GOTO_NEXT_MEMBER);
        setAction("GotoNextMember", action); //$NON-NLS-1$*/

        action = new GoToNextPreviousMemberAction(CEditorMessages.getResourceBundle(), "GotoPrevMember.", this, false); //$NON-NLS-1$
        action.setActionDefinitionId(ICEditorActionDefinitionIds.GOTO_PREVIOUS_MEMBER);
        setAction("GotoPrevMember", action); //$NON-NLS-1$*/

        //Assorted action groupings
		fSelectionSearchGroup = new SelectionSearchGroup(this);
		fTextSearchGroup = new TextSearchGroup(this);
	}

	/**
	 * @see org.eclipse.ui.texteditor.AbstractTextEditor#editorContextMenuAboutToShow(org.eclipse.jface.action.IMenuManager)
	 * 
	 * @return the folding action group, or <code>null</code> if there is none
	 */
	public void editorContextMenuAboutToShow(IMenuManager menu) {
		super.editorContextMenuAboutToShow(menu);

		addGroup(menu, ITextEditorActionConstants.GROUP_EDIT, IContextMenuConstants.GROUP_REORGANIZE);
		addGroup(menu, ITextEditorActionConstants.GROUP_EDIT, IContextMenuConstants.GROUP_GENERATE);
		addGroup(menu, ITextEditorActionConstants.GROUP_EDIT, IContextMenuConstants.GROUP_NEW);

		// Code formatting menu items -- only show in C perspective
		addAction(menu, ITextEditorActionConstants.GROUP_EDIT, "ToggleComment"); //$NON-NLS-1$
		addAction(menu, ITextEditorActionConstants.GROUP_EDIT, "AddBlockComment"); //$NON-NLS-1$
		addAction(menu, ITextEditorActionConstants.GROUP_EDIT, "RemoveBlockComment"); //$NON-NLS-1$

		addAction(menu, ITextEditorActionConstants.GROUP_FIND, "OpenDeclarations"); //$NON-NLS-1$
        addAction(menu, ITextEditorActionConstants.GROUP_FIND, "OpenDefinition"); //$NON-NLS-1$

		addAction(menu, ITextEditorActionConstants.GROUP_FIND, "OpenTypeHierarchy"); //$NON-NLS-1$
        addAction(menu, ITextEditorActionConstants.GROUP_FIND, "GotoNextMember"); //$NON-NLS-1$
        addAction(menu, ITextEditorActionConstants.GROUP_FIND, "GotoPrevMember"); //$NON-NLS-1$

		addAction(menu, IContextMenuConstants.GROUP_GENERATE, "ContentAssistProposal"); //$NON-NLS-1$
		addAction(menu, IContextMenuConstants.GROUP_GENERATE, "AddIncludeOnSelection"); //$NON-NLS-1$
		addAction(menu, IContextMenuConstants.GROUP_GENERATE, "Format"); //$NON-NLS-1$
		
		addAction(menu, IContextMenuConstants.GROUP_GENERATE, "ShowInCView"); //$NON-NLS-1$

		fSelectionSearchGroup.fillContextMenu(menu);
		fTextSearchGroup.fillContextMenu(menu);
	}

	/**
     * Sets an input for the outline page.
	 * @param page Page to set the input.
	 * @param input Input to set.
	 */
	public static void setOutlinePageInput(CContentOutlinePage page, IEditorInput input) {
		if (page != null) {
			IWorkingCopyManager manager = CUIPlugin.getDefault().getWorkingCopyManager();
			page.setInput(manager.getWorkingCopy(input));
			
			boolean projectionMode= projectionViewer.isProjectionMode();
			if (projectionMode) {
				projectionViewer.disableProjection();				
				if (fProjectionModelUpdater != null)
					fProjectionModelUpdater.uninstall();
			}
			
			super.performRevert();
			
			if (projectionMode) {
				if (fProjectionModelUpdater != null)
					fProjectionModelUpdater.install(this, projectionViewer);	
				projectionViewer.enableProjection();
			}
			
		} finally {
			projectionViewer.setRedraw(true);
		}
	}

    /**
     * Sets the given message as error message to this editor's status line.
     * 
     * @param msg message to be set
     */
    protected void setStatusLineErrorMessage(String msg) {
    	IEditorStatusLine statusLine= (IEditorStatusLine) getAdapter(IEditorStatusLine.class);
    	if (statusLine != null)
    		statusLine.setMessage(true, msg, null);	

    }  

	/**
     * Determines is folding enabled.
	 * @return <code>true</code> if folding is enabled, <code>false</code> otherwise.
	 * @param msg message to be set
	 * @since 3.0
	 */
	boolean isFoldingEnabled() {
		return CUIPlugin.getDefault().getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_FOLDING_ENABLED);
		if (statusLine != null)
			statusLine.setMessage(false, msg, null);	
	}


	/**
	 * The <code>AbstractTextEditor</code> implementation of this 
	 * <code>IWorkbenchPart</code> method creates the vertical ruler and
	 * source viewer. Subclasses may extend.
	 * <p>
	 * The selection offset is model based.
	 * </p>
	 * 
	 * We attach our own mouseDown listener on the menu bar, 
	 * and our own listener for cursor/key/selection events to update cursor position in
	 * status bar.

     * @param parent Parent composite of the control.
	 */
	public void createPartControl(Composite parent) {
		super.createPartControl(parent);
	
		// Sticky hover support
		IInformationControlCreator informationControlCreator = new IInformationControlCreator() {
			public IInformationControl createInformationControl(Shell shell) {
				boolean cutDown = false;
				int style = cutDown ? SWT.NONE : (SWT.V_SCROLL | SWT.H_SCROLL);
				return new DefaultInformationControl(shell, SWT.RESIZE
						| SWT.TOOL, style, new HTMLTextPresenter(cutDown));
			}
		};

		fInformationPresenter = new InformationPresenter(
				informationControlCreator);
		fInformationPresenter.setSizeConstraints(60, 10, true, true);
		fInformationPresenter.install(getSourceViewer());
		fInformationPresenter
				.setDocumentPartitioning(ICPartitions.C_PARTITIONING);
				
		
		ProjectionViewer projectionViewer = (ProjectionViewer) getSourceViewer();
			selection.x= selection.x + selection.y;
			selection.y= -selection.y;
		}
		
		fProjectionSupport = new ProjectionSupport(projectionViewer, getAnnotationAccess(), getSharedColors());
		fProjectionSupport.addSummarizableAnnotationType("org.eclipse.ui.workbench.texteditor.error"); //$NON-NLS-1$
		fProjectionSupport.addSummarizableAnnotationType("org.eclipse.ui.workbench.texteditor.warning"); //$NON-NLS-1$
		fProjectionSupport.install();
		
		fProjectionModelUpdater = CUIPlugin.getDefault().getFoldingStructureProviderRegistry().getCurrentFoldingProvider();
		if (fProjectionModelUpdater != null)
			fProjectionModelUpdater.install(this, projectionViewer);
	private static boolean isBracket(char character) {
		for (int i= 0; i != BRACKETS.length; ++i)
			if (character == BRACKETS[i])
				return true;
		return false;
	}

		if (isFoldingEnabled())
			projectionViewer.doOperation(ProjectionViewer.TOGGLE);
		
		PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, ICHelpContextIds.CEDITOR_VIEW);

		fEditorSelectionChangedListener = new EditorSelectionChangedListener();
		fEditorSelectionChangedListener.install(getSelectionProvider());
		
		if (isTabConversionEnabled())
			startTabConversion();
			
		IPreferenceStore preferenceStore = getPreferenceStore();
		boolean closeBrackets = preferenceStore.getBoolean(CLOSE_BRACKETS);
		boolean closeAngularBrackets = preferenceStore.getBoolean(CLOSE_ANGULAR_BRACKETS);
		boolean closeStrings = preferenceStore.getBoolean(CLOSE_STRINGS);

		fBracketInserter.setCloseBracketsEnabled(closeBrackets);
		fBracketInserter.setCloseStringsEnabled(closeStrings);
		fBracketInserter.setCloseAngularBracketsEnabled(closeAngularBrackets);

		ISourceViewer sourceViewer = getSourceViewer();
		if (sourceViewer instanceof ITextViewerExtension)
			((ITextViewerExtension) sourceViewer).prependVerifyKeyListener(fBracketInserter);
	}
		

	/*
	 * @see org.eclipse.ui.texteditor.AbstractTextEditor#initializeDragAndDrop(org.eclipse.jface.text.source.ISourceViewer)
	 */
	protected void initializeDragAndDrop(ISourceViewer viewer) {
		Control control = viewer.getTextWidget();
		int operations = DND.DROP_MOVE | DND.DROP_COPY;

		DropTarget dropTarget = new DropTarget(control, operations);
		ITextEditorDropTargetListener dropTargetListener = new TextEditorDropAdapter(viewer, this);
		dropTarget.setTransfer(dropTargetListener.getTransfers());
		dropTarget.addDropListener(dropTargetListener);

		DragSource dragSource = new DragSource(control, operations);
		Transfer[] dragTypes = new Transfer[] { TextTransfer.getInstance() };
		dragSource.setTransfer(dragTypes);
		DragSourceListener dragSourceListener = new TextViewerDragAdapter(viewer, this);
		dragSource.addDragListener(dragSourceListener);
	}

	/*
	 * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#getSourceViewerDecorationSupport(org.eclipse.jface.text.source.ISourceViewer)
	 */
	protected SourceViewerDecorationSupport getSourceViewerDecorationSupport(
			ISourceViewer viewer) {
		if (fSourceViewerDecorationSupport == null) {
			fSourceViewerDecorationSupport = new CSourceViewerDecorationSupport(viewer, getOverviewRuler(), getAnnotationAccess(), getSharedColors());
			configureSourceViewerDecorationSupport(fSourceViewerDecorationSupport);
		}
		return fSourceViewerDecorationSupport;
	}
	
	/*
	 * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#configureSourceViewerDecorationSupport(org.eclipse.ui.texteditor.SourceViewerDecorationSupport)
	 */
	protected void configureSourceViewerDecorationSupport(SourceViewerDecorationSupport support) {
		super.configureSourceViewerDecorationSupport(support);
		//Enhance the stock source viewer decorator with a bracket matcher
		support.setCharacterPairMatcher(fBracketMatcher);
		support.setMatchingCharacterPainterPreferenceKeys(MATCHING_BRACKETS, MATCHING_BRACKETS_COLOR);
		((CSourceViewerDecorationSupport)support).setInactiveCodePainterPreferenceKeys(INACTIVE_CODE_ENABLE, INACTIVE_CODE_COLOR);
		prefPageIds[nIds++] = "org.eclipse.cdt.ui.preferences.CodeAssistPreferencePage"; //$NON-NLS-1$
		prefPageIds[nIds++] = "org.eclipse.cdt.ui.preferences.TemplatePreferencePage"; //$NON-NLS-1$
		prefPageIds[nIds++] = "org.eclipse.cdt.ui.preferences.CodeFormatterPreferencePage"; //$NON-NLS-1$
		System.arraycopy(parentPrefPageIds, 0, prefPageIds, nIds, parentPrefPageIds.length);
		return prefPageIds;
	}
	
	/**
	 * Jumps to the matching bracket.
	 *
	 * @since 4.0
	 */
	public void gotoMatchingBracket() {
		
		ISourceViewer sourceViewer = getSourceViewer();
		IDocument document = sourceViewer.getDocument();
		if (document == null)
			return;
		
		IRegion selection = getSignedSelection(sourceViewer);

		int selectionLength = Math.abs(selection.getLength());
		if (selectionLength > 1) {
			setStatusLineErrorMessage(CEditorMessages.getString("GotoMatchingBracket.error.invalidSelection"));	//$NON-NLS-1$		
			sourceViewer.getTextWidget().getDisplay().beep();
			return;
		protected NextSubWordAction(int code) {
			super(getSourceViewer().getTextWidget(), code);
		}

		// #26314
		int sourceCaretOffset = selection.getOffset() + selection.getLength();
		if (isSurroundedByBrackets(document, sourceCaretOffset))
			sourceCaretOffset -= selection.getLength();
			// Check whether sub word navigation is enabled.
			final IPreferenceStore store = getPreferenceStore();
			if (!store.getBoolean(SUB_WORD_NAVIGATION)) {
				super.run();
				return;
			}

			final ISourceViewer viewer = getSourceViewer();
			final IDocument document = viewer.getDocument();
			fIterator.setText((CharacterIterator) new DocumentCharacterIterator(document));
			int position = widgetOffset2ModelOffset(viewer, viewer.getTextWidget().getCaretOffset());
			if (position == -1)
				return;

			int next = findNextPosition(position);
			if (next != BreakIterator.DONE) {
				setCaretPosition(next);
				getTextWidget().showSelection();
				fireSelectionChanged();
			}

		IRegion region = fBracketMatcher.match(document, sourceCaretOffset);
		if (region == null) {
			setStatusLineErrorMessage(CEditorMessages.getString("GotoMatchingBracket.error.noMatchingBracket"));	//$NON-NLS-1$		
			sourceViewer.getTextWidget().getDisplay().beep();
			return;		
		}
		
		int offset = region.getOffset();
		int length = region.getLength();
		
		if (length < 1)
			return;
			
		int anchor = fBracketMatcher.getAnchor();
		// http://dev.eclipse.org/bugs/show_bug.cgi?id=34195
		int targetOffset = (ICharacterPairMatcher.RIGHT == anchor) ? offset + 1: offset + length;
		
		boolean visible = false;
		if (sourceViewer instanceof ITextViewerExtension5) {
			ITextViewerExtension5 extension = (ITextViewerExtension5) sourceViewer;
			visible = (extension.modelOffset2WidgetOffset(targetOffset) > -1);
		} else {
			IRegion visibleRegion = sourceViewer.getVisibleRegion();
			// http://dev.eclipse.org/bugs/show_bug.cgi?id=34195
			visible = (targetOffset >= visibleRegion.getOffset() && targetOffset <= visibleRegion.getOffset() + visibleRegion.getLength());
		}
		
		if (!visible) {
			setStatusLineErrorMessage(CEditorMessages.getString("GotoMatchingBracket.error.bracketOutsideSelectedElement"));	//$NON-NLS-1$		
			sourceViewer.getTextWidget().getDisplay().beep();
			return;
		}
		
		if (selection.getLength() < 0)
			targetOffset -= selection.getLength();
			
		sourceViewer.setSelectedRange(targetOffset, selection.getLength());
		sourceViewer.revealRange(targetOffset, selection.getLength());
	}

	protected void updateStatusLine() {
		ITextSelection selection = (ITextSelection) getSelectionProvider().getSelection();
		Annotation annotation = getAnnotation(selection.getOffset(), selection.getLength());
		setStatusLineErrorMessage(null);
		setStatusLineMessage(null);
		if (annotation != null) {
			updateMarkerViews(annotation);
			if (annotation instanceof ICAnnotation && ((ICAnnotation) annotation).isProblem())
				setStatusLineMessage(annotation.getText());
		}
	}

	/**
	 * Returns the annotation overlapping with the given range or <code>null</code>.
	 * 
	 * @param offset the region offset
	 * @param length the region length
	 * @return the found annotation or <code>null</code>
	 * @since 3.0
	 */
	private Annotation getAnnotation(int offset, int length) {
		IAnnotationModel model = getDocumentProvider().getAnnotationModel(getEditorInput());
		Iterator e = new CAnnotationIterator(model, true, true);
		while (e.hasNext()) {
			Annotation a = (Annotation) e.next();
			if (!isNavigationTarget(a))
				continue;
				
			Position p = model.getPosition(a);
			if (p != null && p.overlapsWith(offset, length))
				return a;
		}
		
		return null;
	}
	/* (non-Javadoc)
	 * @see org.eclipse.ui.part.IShowInSource#getShowInContext()
	 *
	 * This is required by the IShowInSource interface for the "ShowIn"
 	 * navigation menu generalized in Eclipse.
	 */
	public ShowInContext getShowInContext() {
		return new ShowInContext( getEditorInput(), null );
	}

	/*
	 * Get the dektop's StatusLineManager
	 */
	protected IStatusLineManager getStatusLineManager() {
		IEditorActionBarContributor contributor = getEditorSite().getActionBarContributor();
		if (contributor instanceof EditorActionBarContributor) {
			return ((EditorActionBarContributor) contributor).getActionBars().getStatusLineManager();
		}
		return null;
	}
	
	/**
	 * Configures the toggle comment action
	 *
	 * @since 4.0.0
	 */
	private void configureToggleCommentAction() {
		IAction action = getAction("ToggleComment"); //$NON-NLS-1$
		if (action instanceof ToggleCommentAction) {
			ISourceViewer sourceViewer = getSourceViewer();
			SourceViewerConfiguration configuration = getSourceViewerConfiguration();
			((ToggleCommentAction)action).configure(sourceViewer, configuration);
			super(ST.DELETE_WORD_NEXT);
		}
	}

	private void configureTabConverter() {
		if (fTabConverter != null) {
			IDocumentProvider provider = getDocumentProvider();
			if (provider instanceof CDocumentProvider) {
				CDocumentProvider prov = (CDocumentProvider) provider;
				fTabConverter.setLineTracker(prov.createLineTracker(getEditorInput()));

			final ISourceViewer viewer = getSourceViewer();
			final int caret, length;
			Point selection = viewer.getSelectedRange();
			if (selection.y != 0) {
				caret = selection.x;
				length = selection.y;
			} else {
				fTabConverter.setLineTracker(new DefaultLineTracker());
				length = position - caret;
			}

			try {
				viewer.getDocument().replace(caret, length, ""); //$NON-NLS-1$
			} catch (BadLocationException exception) {
				// Should not happen
			}
		}
	}

	private int getTabSize() {
		ICElement element = getInputCElement();
		ICProject project = element == null ? null : element.getCProject();
		return CodeFormatterUtil.getTabWidth(project);
	}
		}

	private void startTabConversion() {
		if (fTabConverter == null) {
			CSourceViewer asv = (CSourceViewer) getSourceViewer();
			SourceViewerConfiguration configuration = getSourceViewerConfiguration();
			fTabConverter = new TabConverter();
			configureTabConverter();
			fTabConverter.setNumberOfSpacesPerTab(configuration.getTabWidth(asv));
			asv.addTextConverter(fTabConverter);
		}
	}

	private void stopTabConversion() {
		if (fTabConverter != null) {
			CSourceViewer asv = (CSourceViewer) getSourceViewer();
			asv.removeTextConverter(fTabConverter);
			fTabConverter = null;
	protected class SelectNextSubWordAction extends NextSubWordAction {

		/**
		 * Creates a new select next sub-word action.
		 */
		public SelectNextSubWordAction() {
			super(ST.SELECT_WORD_NEXT);
		}
	}

	private boolean isTabConversionEnabled() {
		IPreferenceStore store = getPreferenceStore();
		return store.getBoolean(SPACES_FOR_TABS);
		protected void setCaretPosition(final int position) {
			final ISourceViewer viewer = getSourceViewer();

			final StyledText text = viewer.getTextWidget();
			if (text != null && !text.isDisposed()) {

				final Point selection = text.getSelection();
				final int caret = text.getCaretOffset();
				final int offset = modelOffset2WidgetOffset(viewer, position);

				if (caret == selection.x)
					text.setSelectionRange(selection.y, offset - selection.y);
				else
					text.setSelectionRange(selection.x, offset - selection.x);
			}
		}
	}

	/*
	 * @see org.eclipse.ui.texteditor.AbstractTextEditor#createNavigationActions()
	 *
	 * @since 4.0
	 */
	protected void createNavigationActions() {
		super.createNavigationActions();
		protected CWordIterator fIterator = new CWordIterator();

		/**
		 * Creates a new previous sub-word action.
		 *
		 * @param code Action code for the default operation. Must be an action code from @see org.eclipse.swt.custom.ST.
		 */
		protected PreviousSubWordAction(final int code) {
			super(getSourceViewer().getTextWidget(), code);
		}

		final StyledText textWidget = getSourceViewer().getTextWidget();
		 * @see org.eclipse.jface.action.IAction#run()
		 */
		public void run() {
			// Check whether sub word navigation is enabled.
			final IPreferenceStore store = getPreferenceStore();
			if (!store.getBoolean(SUB_WORD_NAVIGATION)) {
				super.run();
				return;
			}

		IAction action = new NavigatePreviousSubWordAction();
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.WORD_PREVIOUS);
		setAction(ITextEditorActionDefinitionIds.WORD_PREVIOUS, action);
		textWidget.setKeyBinding(SWT.CTRL | SWT.ARROW_LEFT, SWT.NULL);
			if (position == -1)
				return;

		action = new NavigateNextSubWordAction();
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.WORD_NEXT);
		setAction(ITextEditorActionDefinitionIds.WORD_NEXT, action);
		textWidget.setKeyBinding(SWT.CTRL | SWT.ARROW_RIGHT, SWT.NULL);
				fireSelectionChanged();
			}

		action = new SelectPreviousSubWordAction();
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.SELECT_WORD_PREVIOUS);
		setAction(ITextEditorActionDefinitionIds.SELECT_WORD_PREVIOUS, action);
		textWidget.setKeyBinding(SWT.CTRL | SWT.SHIFT | SWT.ARROW_LEFT, SWT.NULL);

		action = new SelectNextSubWordAction();
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.SELECT_WORD_NEXT);
		setAction(ITextEditorActionDefinitionIds.SELECT_WORD_NEXT, action);
		textWidget.setKeyBinding(SWT.CTRL | SWT.SHIFT | SWT.ARROW_RIGHT, SWT.NULL);
		
		action = new DeletePreviousSubWordAction();
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.DELETE_PREVIOUS_WORD);
		setAction(ITextEditorActionDefinitionIds.DELETE_PREVIOUS_WORD, action);
		textWidget.setKeyBinding(SWT.CTRL | SWT.BS, SWT.NULL);
		markAsStateDependentAction(ITextEditorActionDefinitionIds.DELETE_PREVIOUS_WORD, true);
				position = fIterator.preceding(position);
				if (position != BreakIterator.DONE)
					widget = modelOffset2WidgetOffset(viewer, position);
			}
			return position;
		}

		action = new DeleteNextSubWordAction();
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.DELETE_NEXT_WORD);
		setAction(ITextEditorActionDefinitionIds.DELETE_NEXT_WORD, action);
		textWidget.setKeyBinding(SWT.CTRL | SWT.DEL, SWT.NULL);
		markAsStateDependentAction(ITextEditorActionDefinitionIds.DELETE_NEXT_WORD, true);
		protected abstract void setCaretPosition(int position);
	}

	public final ISourceViewer getViewer() {
		return getSourceViewer();
	}

	/*
	 * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#createSourceViewer(org.eclipse.swt.widgets.Composite, org.eclipse.jface.text.source.IVerticalRuler, int)
	 */
	protected ISourceViewer createSourceViewer(Composite parent, IVerticalRuler ruler, int styles) {
		ISourceViewer sourceViewer =
				new CSourceViewer(parent, ruler, getOverviewRuler(), isOverviewRulerVisible(), styles);

		CSourceViewerDecorationSupport decoSupport = (CSourceViewerDecorationSupport) getSourceViewerDecorationSupport(sourceViewer);
		decoSupport.editorInputChanged(getEditorInput());
		 */
		public NavigatePreviousSubWordAction() {
			super(ST.WORD_PREVIOUS);
		}

		CUIHelp.setHelp(this, sourceViewer.getTextWidget(), ICHelpContextIds.CEDITOR_VIEW);

		return sourceViewer;
		protected void setCaretPosition(final int position) {
			getTextWidget().setCaretOffset(modelOffset2WidgetOffset(getSourceViewer(), position));
		}
	}

	/** Outliner context menu Id */
	protected String fOutlinerContextMenuId;

	/**
	 * Sets the outliner's context menu ID.
	 *
	 * @since 4.0
	 */
	protected void setOutlinerContextMenuId(String menuId) {
		fOutlinerContextMenuId = menuId;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.editors.text.TextEditor#initializeKeyBindingScopes()
	 */
	protected void initializeKeyBindingScopes() {
		setKeyBindingScopes(new String [] { "org.eclipse.cdt.ui.cEditorScope" } ); //$NON-NLS-1$
	}

	/* (non-Javadoc)
	 * @see AbstractTextEditor#affectsTextPresentation(PropertyChangeEvent)
	 */
	protected boolean affectsTextPresentation(PropertyChangeEvent event) {
		SourceViewerConfiguration configuration = getSourceViewerConfiguration();
		if (configuration instanceof CSourceViewerConfiguration) {
			return ((CSourceViewerConfiguration)configuration).affectsBehavior(event);
		}
		return false;
	}

	/**
	 * Returns the folding action group, or <code>null</code> if there is none.
	 * 
	 * @return the folding action group, or <code>null</code> if there is none
	 */
	protected FoldingActionGroup getFoldingActionGroup() {
		return fFoldingGroup;
	}

	/*
	 * @see org.eclipse.ui.texteditor.AbstractTextEditor#performRevert()
	 */
	protected void performRevert() {
		ProjectionViewer projectionViewer = (ProjectionViewer) getSourceViewer();
		projectionViewer.setRedraw(false);
		try {
			
			boolean projectionMode = projectionViewer.isProjectionMode();
			if (projectionMode) {
				projectionViewer.disableProjection();				
				if (fProjectionModelUpdater != null)
					fProjectionModelUpdater.uninstall();
			}
			
			super.performRevert();
			
			if (projectionMode) {
				if (fProjectionModelUpdater != null)
					fProjectionModelUpdater.install(this, projectionViewer);	
				projectionViewer.enableProjection();
			}
			
		} finally {
			projectionViewer.setRedraw(true);
		}
	}

    /**
     * Sets the given message as error message to this editor's status line.
     * 
     * @param msg message to be set
     */
    protected void setStatusLineErrorMessage(String msg) {
    	IEditorStatusLine statusLine = (IEditorStatusLine) getAdapter(IEditorStatusLine.class);
    	if (statusLine != null)
    		statusLine.setMessage(true, msg, null);	
    }  

	/**
	 * Sets the given message as message to this editor's status line.
	 * 
	 * @param msg message to be set
	 * @since 3.0
	 */
	protected void setStatusLineMessage(String msg) {
		IEditorStatusLine statusLine = (IEditorStatusLine) getAdapter(IEditorStatusLine.class);
		if (statusLine != null)
			statusLine.setMessage(false, msg, null);	
	}

	/**
	 * Returns the signed current selection.
	 * The length will be negative if the resulting selection
	 * is right-to-left (RtoL).
	 * <p>
	 * The selection offset is model based.
	 * </p>
	 * 
	 * @param sourceViewer the source viewer
	 * @return a region denoting the current signed selection, for a resulting RtoL selections length is < 0 
	 */
	protected IRegion getSignedSelection(ISourceViewer sourceViewer) {
		StyledText text = sourceViewer.getTextWidget();
		Point selection = text.getSelectionRange();
		
		if (text.getCaretOffset() == selection.x) {
			selection.x = selection.x + selection.y;
			selection.y = -selection.y;
		}
		
		selection.x = widgetOffset2ModelOffset(sourceViewer, selection.x);
		
		return new Region(selection.x, selection.y);
	}
	
	private static boolean isBracket(char character) {
		for (int i = 0; i != BRACKETS.length; ++i) {
			if (character == BRACKETS[i])
				return true;
		}
		return false;
	}

	private static boolean isSurroundedByBrackets(IDocument document, int offset) {
		if (offset == 0 || offset == document.getLength())
			return false;

		try {
			return isBracket(document.getChar(offset - 1)) &&
					isBracket(document.getChar(offset));
		} catch (BadLocationException e) {
			return false;	
		}
	}
		
	private static char getEscapeCharacter(char character) {
		switch (character) {
			case '"':
			case '\'':
				return '\\';
			default:
				return 0;
		}
	}

	private static char getPeerCharacter(char character) {
		switch (character) {
			case '(':
				return ')';
			final ISourceViewer viewer = getSourceViewer();

			case ')':
				return '(';

			case '<':
				return '>';
				final int offset = modelOffset2WidgetOffset(viewer, position);

			case '>':
				return '<';

			case '[':
				return ']';

			case ']':
				return '[';

			case '"':
				return character;

			case '\'':
				return character;

			default:
				throw new IllegalArgumentException();
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.cdt.internal.ui.editor.IReconcilingParticipant#reconciled()
	 */
	public void reconciled(boolean somethingHasChanged) {
		// Do nothing the outliner is listener to the
		// CoreModel WorkingCopy changes instead.
		// It will allow more fined grained.
		if (somethingHasChanged && getSourceViewer() != null) {
			CSourceViewerDecorationSupport decoSupport = (CSourceViewerDecorationSupport) getSourceViewerDecorationSupport(getSourceViewer());
			decoSupport.editorInputChanged(getEditorInput());
		}
	}
	
	public CSourceViewer getCSourceViewer()  {
		ISourceViewer viewer = getSourceViewer();
		CSourceViewer cViewer = null ;
		if (viewer instanceof CSourceViewer) {
			cViewer = (CSourceViewer) viewer;
		}
		return cViewer ;
	}
	
	/*
	 * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#collectContextMenuPreferencePages()
	 */
	protected String[] collectContextMenuPreferencePages() {
		// Add C/C++ Editor relevant pages
		String[] parentPrefPageIds = super.collectContextMenuPreferencePages();
		String[] prefPageIds = new String[parentPrefPageIds.length + 4];
		int nIds = 0;
		prefPageIds[nIds++] = "org.eclipse.cdt.ui.preferences.CEditorPreferencePage"; //$NON-NLS-1$
		prefPageIds[nIds++] = "org.eclipse.cdt.ui.preferences.CodeAssistPreferencePage"; //$NON-NLS-1$
		prefPageIds[nIds++] = "org.eclipse.cdt.ui.preferences.TemplatePreferencePage"; //$NON-NLS-1$
		prefPageIds[nIds++] = "org.eclipse.cdt.ui.preferences.CodeFormatterPreferencePage"; //$NON-NLS-1$
		System.arraycopy(parentPrefPageIds, 0, prefPageIds, nIds, parentPrefPageIds.length);
		return prefPageIds;
	}
}

Lines 146-151 Link Here

(-)src/org/eclipse/cdt/ui/PreferenceConstants.java (+41 lines)
146	public final static String EDITOR_EVALUATE_TEMPORARY_PROBLEMS= "handleTemporaryProblems"; //$NON-NLS-1$	146	public final static String EDITOR_EVALUATE_TEMPORARY_PROBLEMS= "handleTemporaryProblems"; //$NON-NLS-1$
147		147
148	/**	148	/**
		149	* The symbolic font name for the Java editor text font
		150	* (value <code>"org.eclipse.cdt.ui.editors.textfont"</code>).
		151	*/
		152	public final static String EDITOR_TEXT_FONT= "org.eclipse.cdt.ui.editors.textfont"; //$NON-NLS-1$
		153
		154	/**
149	* A named preference that defines the key for the hover modifiers.	155	* A named preference that defines the key for the hover modifiers.
150	*	156	*
151	*/	157	*/
Lines 197-202 Link Here
197	public final static String EDITOR_CLOSE_BRACKETS= "closeBrackets"; //$NON-NLS-1$	203	public final static String EDITOR_CLOSE_BRACKETS= "closeBrackets"; //$NON-NLS-1$
198		204
199	/**	205	/**
		206	* A named preference that controls whether the 'close angular brackets' feature is
		207	* enabled.
		208	* <p>
		209	* Value is of type <code>Boolean</code>.
		210	* </p>
		211	*/
		212	public final static String EDITOR_CLOSE_ANGULAR_BRACKETS= "closeAngularBrackets"; //$NON-NLS-1$
		213
		214	/**
200	* A named preference that controls whether the 'close braces' feature is	215	* A named preference that controls whether the 'close braces' feature is
201	* enabled.	216	* enabled.
202	* <p>	217	* <p>
Lines 206-211 Link Here
206	public final static String EDITOR_CLOSE_BRACES= "closeBraces"; //$NON-NLS-1$	221	public final static String EDITOR_CLOSE_BRACES= "closeBraces"; //$NON-NLS-1$
207		222
208	/**	223	/**
		224	* A named preference that controls whether the 'smart paste' feature is
		225	* enabled.
		226	* <p>
		227	* Value is of type <code>Boolean</code>.
		228	* </p>
		229	*/
		230	public final static String EDITOR_SMART_PASTE= "smartPaste"; //$NON-NLS-1$
		231
		232	/**
		233	* A named preference that controls the smart tab behavior.
		234	* <p>
		235	* Value is of type <code>Boolean</code>.
		236	*/
		237	public static final String EDITOR_SMART_TAB= "smart_tab"; //$NON-NLS-1$
		238
		239	/**
209	* The id of the best match hover contributed for extension point	240	* The id of the best match hover contributed for extension point
210	* <code>javaEditorTextHovers</code>.	241	* <code>javaEditorTextHovers</code>.
211	*	242	*
Lines 408-413 Link Here
408	*/	439	*/
409	public static final String TEMPLATES_USE_CODEFORMATTER= "org.eclipse.cdt.ui.text.templates.format"; //$NON-NLS-1$	440	public static final String TEMPLATES_USE_CODEFORMATTER= "org.eclipse.cdt.ui.text.templates.format"; //$NON-NLS-1$
410		441
		442	/**
		443	* A named preference that controls which profile is used by the code formatter.
		444	* <p>
		445	* Value is of type <code>String</code>.
		446	* </p>
		447	*
		448	* @since 4.0
		449	*/
		450	public static final String FORMATTER_PROFILE = "formatter_profile"; //$NON-NLS-1$
411		451
412	/**	452	/**
413	* Preference key for whether to ensure a newline at the end of files when saving.	453	* Preference key for whether to ensure a newline at the end of files when saving.
Lines 467-472 Link Here
467		507
468	store.setDefault(PreferenceConstants.EDITOR_CLOSE_STRINGS, true);	508	store.setDefault(PreferenceConstants.EDITOR_CLOSE_STRINGS, true);
469	store.setDefault(PreferenceConstants.EDITOR_CLOSE_BRACKETS, true);	509	store.setDefault(PreferenceConstants.EDITOR_CLOSE_BRACKETS, true);
		510	store.setDefault(PreferenceConstants.EDITOR_CLOSE_ANGULAR_BRACKETS, true);
470	store.setDefault(PreferenceConstants.EDITOR_CLOSE_BRACES, true);	511	store.setDefault(PreferenceConstants.EDITOR_CLOSE_BRACES, true);
471	store.setDefault(PreferenceConstants.EDITOR_WRAP_STRINGS, true);	512	store.setDefault(PreferenceConstants.EDITOR_WRAP_STRINGS, true);
472	store.setDefault(PreferenceConstants.EDITOR_ESCAPE_STRINGS, false);	513	store.setDefault(PreferenceConstants.EDITOR_ESCAPE_STRINGS, false);

Lines 60-65 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
60	org.eclipse.ui.workbench.texteditor,	60	org.eclipse.ui.workbench.texteditor,
61	org.eclipse.ui.editors,	61	org.eclipse.ui.editors,
62	org.eclipse.ui,	62	org.eclipse.ui,
		63	org.eclipse.ui.forms,
63	org.eclipse.core.resources,	64	org.eclipse.core.resources,
64	org.eclipse.search,	65	org.eclipse.search,
65	org.eclipse.compare,	66	org.eclipse.compare,

Lines 54-59 Link Here

(-)src/org/eclipse/cdt/internal/ui/ICHelpContextIds.java (+1 lines)
54	public static final String C_EDITOR_CONTENT_ASSIST_PREF_PAGE = PREFIX + "c_editor_con_assist"; //$NON-NLS-1$	54	public static final String C_EDITOR_CONTENT_ASSIST_PREF_PAGE = PREFIX + "c_editor_con_assist"; //$NON-NLS-1$
55	public static final String C_EDITOR_NAVIGATION_PAGE = PREFIX + "c_editor_navigation"; //$NON-NLS-1$	55	public static final String C_EDITOR_NAVIGATION_PAGE = PREFIX + "c_editor_navigation"; //$NON-NLS-1$
56	public static final String C_EDITOR_HOVERS_PAGE = PREFIX + "c_editor_hov"; //$NON-NLS-1$	56	public static final String C_EDITOR_HOVERS_PAGE = PREFIX + "c_editor_hov"; //$NON-NLS-1$
		57	public static final String C_EDITOR_TYPING_PAGE = PREFIX + "c_editor_typing"; //$NON-NLS-1$;
57	public static final String FILE_TYPES_STD_PAGE = PREFIX + "std_prop_file_types"; //$NON-NLS-1$	58	public static final String FILE_TYPES_STD_PAGE = PREFIX + "std_prop_file_types"; //$NON-NLS-1$
58	public static final String FILE_TYPES_MAN_PAGE = PREFIX + "std_prop_file_types"; //$NON-NLS-1$	59	public static final String FILE_TYPES_MAN_PAGE = PREFIX + "std_prop_file_types"; //$NON-NLS-1$
59	public static final String FILE_TYPES_PREF_PAGE = PREFIX + "c_file_types"; //$NON-NLS-1$	60	public static final String FILE_TYPES_PREF_PAGE = PREFIX + "c_file_types"; //$NON-NLS-1$




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;


/**
 * Interface for preference configuration blocks which can either be
 * wrapped by a {@link org.eclipse.cdt.internal.ui.preferences.AbstractConfigurationBlockPreferencePage}
 * or be included some preference page.
 * <p>
 * Clients may implement this interface.
 * </p>
 * 
 * @since 3.0
 */
public interface IPreferenceConfigurationBlock {
	
	/**
	 * Creates the preference control.
	 * 
	 * @param parent the parent composite to which to add the preferences control
	 * @return the control that was added to <code>parent</code> 
	 */
	Control createControl(Composite parent);
	
	/**
	 * Called after creating the control. Implementations should load the 
	 * preferences values and update the controls accordingly.
	 */
	void initialize();
	
	/**
	 * Called when the <code>OK</code> button is pressed on the preference
	 * page. Implementations should commit the configured preference settings
	 * into their form of preference storage.
	 */
	void performOk();
	
	/**
	 * Called when the <code>Defaults</code> button is pressed on the
	 * preference page. Implementation should reset any preference settings to
	 * their default values and adjust the controls accordingly.
	 */
	void performDefaults();
	
	/**
	 * Called when the preference page is being disposed. Implementations should
	 * free any resources they are holding on to.
	 */
	void dispose();
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DefaultIndentLineAutoEditStrategy;
import org.eclipse.jface.text.DocumentCommand;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.TextUtilities;

import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.texteditor.ITextEditorExtension3;

import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.PreferenceConstants;

/**
 * Auto indent strategy for C strings
 */
public class CStringAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {

	private String fPartitioning;
	private final ICProject fProject;

	/**
	 * The input string doesn't contain any line delimiter.
	 *
	 * @param inputString the given input string
	 * @return the displayable string.
	 */
	private String displayString(String inputString, CharSequence indentation, String delimiter) {
		int length = inputString.length();
		StringBuffer buffer = new StringBuffer(length);
		java.util.StringTokenizer tokenizer = new java.util.StringTokenizer(inputString, "\n\r", true); //$NON-NLS-1$
		while (tokenizer.hasMoreTokens()) {
			String token = tokenizer.nextToken();
			if (token.equals("\r")) { //$NON-NLS-1$
				buffer.append("\\r"); //$NON-NLS-1$
				if (tokenizer.hasMoreTokens()) {
					token = tokenizer.nextToken();
					if (token.equals("\n")) { //$NON-NLS-1$
						buffer.append("\\n"); //$NON-NLS-1$
						buffer.append("\"" + delimiter); //$NON-NLS-1$
						buffer.append(indentation);
						buffer.append("\""); //$NON-NLS-1$
						continue;
					} else {
						buffer.append("\"" + delimiter); //$NON-NLS-1$
						buffer.append(indentation);
						buffer.append("\""); //$NON-NLS-1$
					}
				} else {
					continue;
				}
			} else if (token.equals("\n")) { //$NON-NLS-1$
				buffer.append("\\n"); //$NON-NLS-1$
				buffer.append("\"" + delimiter); //$NON-NLS-1$
				buffer.append(indentation);
				buffer.append("\""); //$NON-NLS-1$
				continue;
			}

			StringBuffer tokenBuffer = new StringBuffer();
			for (int i = 0; i < token.length(); i++){
				char c = token.charAt(i);
				switch (c) {
					case '\r' :
						tokenBuffer.append("\\r"); //$NON-NLS-1$
						break;
					case '\n' :
						tokenBuffer.append("\\n"); //$NON-NLS-1$
						break;
					case '\b' :
						tokenBuffer.append("\\b"); //$NON-NLS-1$
						break;
					case '\t' :
						// keep tabs verbatim
						tokenBuffer.append("\t"); //$NON-NLS-1$
						break;
					case '\f' :
						tokenBuffer.append("\\f"); //$NON-NLS-1$
						break;
					case '\"' :
						tokenBuffer.append("\\\""); //$NON-NLS-1$
						break;
					case '\'' :
						tokenBuffer.append("\\'"); //$NON-NLS-1$
						break;
					case '\\' :
						tokenBuffer.append("\\\\"); //$NON-NLS-1$
						break;
					default :
						tokenBuffer.append(c);
				}
			}
			buffer.append(tokenBuffer);
		}
		return buffer.toString();
	}

	/**
	 * Creates a new C string auto indent strategy for the given document partitioning.
	 *
	 * @param partitioning the document partitioning
	 */
	public CStringAutoIndentStrategy(String partitioning, ICProject project) {
		super();
		fPartitioning = partitioning;
		fProject = project;
	}

	private boolean isLineDelimiter(IDocument document, String text) {
		String[] delimiters= document.getLegalLineDelimiters();
		if (delimiters != null)
			return TextUtilities.equals(delimiters, text) > -1;
		return false;
	}

	private String getModifiedText(String string, CharSequence indentation, String delimiter) {
		return displayString(string, indentation, delimiter);
	}

	private void indentStringAfterNewLine(IDocument document, DocumentCommand command) throws BadLocationException {
		ITypedRegion partition= TextUtilities.getPartition(document, fPartitioning, command.offset, true);
		int offset= partition.getOffset();
		int length= partition.getLength();

		if (command.offset == offset + length && document.getChar(offset + length - 1) == '\"')
			return;
		
		CHeuristicScanner scanner = new CHeuristicScanner(document);
		CIndenter indenter = new CIndenter(document, scanner, fProject);
		StringBuffer indentation = indenter.computeContinuationLineIndentation(offset);
		if (indentation == null)
			indentation = new StringBuffer(); 

		String delimiter= TextUtilities.getDefaultLineDelimiter(document);
		IPreferenceStore preferenceStore= CUIPlugin.getDefault().getPreferenceStore();
		if (isLineDelimiter(document, command.text))
			command.text= "\"" + command.text + indentation + "\"";  //$NON-NLS-1$//$NON-NLS-2$
		else if (command.text.length() > 1 && preferenceStore.getBoolean(PreferenceConstants.EDITOR_ESCAPE_STRINGS))
			command.text= getModifiedText(command.text, indentation, delimiter);
	}

	private boolean isSmartMode() {
		IWorkbenchPage page= CUIPlugin.getActivePage();
		if (page != null)  {
			IEditorPart part= page.getActiveEditor();
			if (part instanceof ITextEditorExtension3) {
				ITextEditorExtension3 extension= (ITextEditorExtension3) part;
				return extension.getInsertMode() == ITextEditorExtension3.SMART_INSERT;
			}
		}
		return false;
	}

	/*
	 * @see org.eclipse.jface.text.IAutoIndentStrategy#customizeDocumentCommand(IDocument, DocumentCommand)
	 */
	public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
		try {
			if (command.length != 0 || command.text == null)
				return;

			IPreferenceStore preferenceStore= CUIPlugin.getDefault().getPreferenceStore();

			if (preferenceStore.getBoolean(PreferenceConstants.EDITOR_WRAP_STRINGS) && isSmartMode()) {
				indentStringAfterNewLine(document, command);
			}
		} catch (BadLocationException e) {
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.IScopeContext;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.cdt.core.CCorePlugin;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.internal.ui.CUIException;
import org.eclipse.cdt.internal.ui.CUIStatus;
import org.eclipse.cdt.internal.ui.preferences.PreferencesAccess;
import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.CustomProfile;
import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.Profile;

import org.osgi.service.prefs.BackingStoreException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;



public class ProfileStore {
	
	/**
	 * A SAX event handler to parse the xml format for profiles. 
	 */
	private final static class ProfileDefaultHandler extends DefaultHandler {
		
		private List fProfiles;
		private int fVersion;
		
		private String fName;
		private Map fSettings;


		public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {

			if (qName.equals(XML_NODE_SETTING)) {

				final String key= attributes.getValue(XML_ATTRIBUTE_ID);
				final String value= attributes.getValue(XML_ATTRIBUTE_VALUE);
				fSettings.put(key, value);

			} else if (qName.equals(XML_NODE_PROFILE)) {

				fName= attributes.getValue(XML_ATTRIBUTE_NAME);
				fSettings= new HashMap(200);

			}
			else if (qName.equals(XML_NODE_ROOT)) {

				fProfiles= new ArrayList();
				try {
					fVersion= Integer.parseInt(attributes.getValue(XML_ATTRIBUTE_VERSION));
				} catch (NumberFormatException ex) {
					throw new SAXException(ex);
				}

			}
		}
		
		public void endElement(String uri, String localName, String qName) {
			if (qName.equals(XML_NODE_PROFILE)) {
				fProfiles.add(new CustomProfile(fName, fSettings, fVersion));
				fName= null;
				fSettings= null;
			}
		}
		
		public List getProfiles() {
			return fProfiles;
		}
		
	}

	/**
	 * Preference key where all profiles are stored
	 */
	private static final String PREF_FORMATTER_PROFILES= "org.eclipse.cdt.ui.formatterprofiles"; //$NON-NLS-1$
	
	/**
	 * Preference key where all profiles are stored
	 */
	private static final String PREF_FORMATTER_PROFILES_VERSION= "org.eclipse.cdt.ui.formatterprofiles.version"; //$NON-NLS-1$
	
	
	/**
	 * Identifiers for the XML file.
	 */
	private final static String XML_NODE_ROOT= "profiles"; //$NON-NLS-1$
	private final static String XML_NODE_PROFILE= "profile"; //$NON-NLS-1$
	private final static String XML_NODE_SETTING= "setting"; //$NON-NLS-1$
	
	private final static String XML_ATTRIBUTE_VERSION= "version"; //$NON-NLS-1$
	private final static String XML_ATTRIBUTE_ID= "id"; //$NON-NLS-1$
	private final static String XML_ATTRIBUTE_NAME= "name"; //$NON-NLS-1$
	private final static String XML_ATTRIBUTE_VALUE= "value"; //$NON-NLS-1$
		
	private ProfileStore() {
	}
	
	/**
	 * @return Returns the collection of profiles currently stored in the preference store or
	 * <code>null</code> if the loading failed. The elements are of type {@link CustomProfile}
	 * and are all updated to the latest version.
	 * @throws CoreException
	 */
	public static List readProfiles(IScopeContext scope) throws CoreException {
		List res= readProfilesFromPreferences(scope);
		if (res == null) {
			return readOldForCompatibility(scope);
		}
		return res;
	}
	
	public static void writeProfiles(Collection profiles, IScopeContext instanceScope) throws CoreException {
		ByteArrayOutputStream stream= new ByteArrayOutputStream(2000);
		try {
			writeProfilesToStream(profiles, stream);
			String val;
			try {
				val= stream.toString("UTF-8"); //$NON-NLS-1$
			} catch (UnsupportedEncodingException e) {
				val= stream.toString(); 
			}
			IEclipsePreferences uiPreferences = instanceScope.getNode(CUIPlugin.PLUGIN_ID);
			uiPreferences.put(PREF_FORMATTER_PROFILES, val);
			uiPreferences.putInt(PREF_FORMATTER_PROFILES_VERSION, ProfileVersioner.CURRENT_VERSION);
		} finally {
			try { stream.close(); } catch (IOException e) { /* ignore */ }
		}
	}
	
	public static List readProfilesFromPreferences(IScopeContext scope) throws CoreException {
		String string= scope.getNode(CUIPlugin.PLUGIN_ID).get(PREF_FORMATTER_PROFILES, null);
		if (string != null && string.length() > 0) {
			byte[] bytes;
			try {
				bytes= string.getBytes("UTF-8"); //$NON-NLS-1$
			} catch (UnsupportedEncodingException e) {
				bytes= string.getBytes();
			}
			InputStream is= new ByteArrayInputStream(bytes);
			try {
				List res= readProfilesFromStream(new InputSource(is));
				if (res != null) {
					for (int i= 0; i < res.size(); i++) {
						ProfileVersioner.updateAndComplete((CustomProfile) res.get(i));
					}
				}
				return res;
			} finally {
				try { is.close(); } catch (IOException e) { /* ignore */ }
			}
		}
		return null;
	}	

	/**
	 * Read the available profiles from the internal XML file and return them
	 * as collection.
	 * @return returns a list of <code>CustomProfile</code> or <code>null</code>
	 */
	private static List readOldForCompatibility(IScopeContext instanceScope) {
		
		// in 3.0 M9 and less the profiles were stored in a file in the plugin's meta data
		final String STORE_FILE= "code_formatter_profiles.xml"; //$NON-NLS-1$

		File file= CUIPlugin.getDefault().getStateLocation().append(STORE_FILE).toFile();
		if (!file.exists())
			return null;
		
		try {
			// note that it's wrong to use a file reader when XML declares UTF-8: Kept for compatibility
			final FileReader reader= new FileReader(file);
			try {
				List res= readProfilesFromStream(new InputSource(reader));
				if (res != null) {
					for (int i= 0; i < res.size(); i++) {
						ProfileVersioner.updateAndComplete((CustomProfile) res.get(i));
					}
					writeProfiles(res, instanceScope);
				}
				file.delete(); // remove after successful write
				return res;
			} finally {
				reader.close();
			}
		} catch (CoreException e) {
			CUIPlugin.getDefault().log(e); // log but ignore
		} catch (IOException e) {
			CUIPlugin.getDefault().log(e); // log but ignore
		}
		return null;
	}
	
	
	/**
	 * Read the available profiles from the internal XML file and return them
	 * as collection or <code>null</code> if the file is not a profile file.
	 * @param file The file to read from
	 * @return returns a list of <code>CustomProfile</code> or <code>null</code>
	 * @throws CoreException
	 */
	public static List readProfilesFromFile(File file) throws CoreException {
		try {
			final FileInputStream reader= new FileInputStream(file); 
			try {
				return readProfilesFromStream(new InputSource(reader));
			} finally {
				try { reader.close(); } catch (IOException e) { /* ignore */ }
			}
		} catch (IOException e) {
			throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_reading_xml_message);  
		}
	}
	
	/**
	 * Load profiles from a XML stream and add them to a map or <code>null</code> if the source is not a profile store.
	 * @param inputSource The input stream
	 * @return returns a list of <code>CustomProfile</code> or <code>null</code>
	 * @throws CoreException
	 */
	private static List readProfilesFromStream(InputSource inputSource) throws CoreException {
		
		final ProfileDefaultHandler handler= new ProfileDefaultHandler();
		try {
		    final SAXParserFactory factory= SAXParserFactory.newInstance();
			final SAXParser parser= factory.newSAXParser();
			parser.parse(inputSource, handler);
		} catch (SAXException e) {
			throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_reading_xml_message);  
		} catch (IOException e) {
			throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_reading_xml_message);  
		} catch (ParserConfigurationException e) {
			throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_reading_xml_message);  
		}
		return handler.getProfiles();
	}
	
	/**
	 * Write the available profiles to the internal XML file.
	 * @param profiles List of <code>CustomProfile</code>
	 * @param file File to write
	 * @throws CoreException
	 */
	public static void writeProfilesToFile(Collection profiles, File file) throws CoreException {
		final OutputStream writer;
		try {
			writer= new FileOutputStream(file);
			try {
				writeProfilesToStream(profiles, writer);
			} finally {
				try { writer.close(); } catch (IOException e) { /* ignore */ }
			}
		} catch (IOException e) {
			throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_serializing_xml_message);  
		}
	}
	
	/**
	 * Save profiles to an XML stream
	 * @param profiles List of <code>CustomProfile</code>
	 * @param stream Stream to write
	 * @throws CoreException
	 */
	private static void writeProfilesToStream(Collection profiles, OutputStream stream) throws CoreException {

		try {
			final DocumentBuilderFactory factory= DocumentBuilderFactory.newInstance();
			final DocumentBuilder builder= factory.newDocumentBuilder();		
			final Document document= builder.newDocument();
			
			final Element rootElement = document.createElement(XML_NODE_ROOT);
			rootElement.setAttribute(XML_ATTRIBUTE_VERSION, Integer.toString(ProfileVersioner.CURRENT_VERSION));

			document.appendChild(rootElement);
			
			for(final Iterator iter= profiles.iterator(); iter.hasNext();) {
				final Profile profile= (Profile)iter.next();
				if (profile.isProfileToSave()) {
					final Element profileElement= createProfileElement(profile, document);
					rootElement.appendChild(profileElement);
				}
			}

			Transformer transformer=TransformerFactory.newInstance().newTransformer();
			transformer.setOutputProperty(OutputKeys.METHOD, "xml"); //$NON-NLS-1$
			transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); //$NON-NLS-1$
			transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
			transformer.transform(new DOMSource(document), new StreamResult(stream));
		} catch (TransformerException e) {
			throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_serializing_xml_message);  
		} catch (ParserConfigurationException e) {
			throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_serializing_xml_message);  
		}
	}

	
	/*
	 * Create a new profile element in the specified document. The profile is not added
	 * to the document by this method. 
	 */
	private static Element createProfileElement(Profile profile, Document document) {
		final Element element= document.createElement(XML_NODE_PROFILE);
		element.setAttribute(XML_ATTRIBUTE_NAME, profile.getName());
		element.setAttribute(XML_ATTRIBUTE_VERSION, Integer.toString(profile.getVersion()));
		
		final Iterator keyIter= ProfileManager.getKeys().iterator();
		
		while (keyIter.hasNext()) {
			final String key= (String)keyIter.next();
			final String value= (String)profile.getSettings().get(key);
			if (value != null) {
				final Element setting= document.createElement(XML_NODE_SETTING);
				setting.setAttribute(XML_ATTRIBUTE_ID, key);
				setting.setAttribute(XML_ATTRIBUTE_VALUE, value);
				element.appendChild(setting);
			} else {
				CUIPlugin.getDefault().logErrorMessage("ProfileStore: Profile does not contain value for key " + key); //$NON-NLS-1$
			}
		}
		return element;
	}
	
	public static void checkCurrentOptionsVersion() {
		PreferencesAccess access= PreferencesAccess.getOriginalPreferences();
		
		IScopeContext instanceScope= access.getInstanceScope();
		IEclipsePreferences uiPreferences= instanceScope.getNode(CUIPlugin.PLUGIN_ID);
		int version= uiPreferences.getInt(PREF_FORMATTER_PROFILES_VERSION, 0);
		if (version >= ProfileVersioner.CURRENT_VERSION) {
			return; // is up to date
		}
		try {
			List profiles= ProfileStore.readProfiles(instanceScope);
			if (profiles == null) {
				profiles= Collections.EMPTY_LIST;
			}
			ProfileManager manager= new ProfileManager(profiles, instanceScope, access);
			if (manager.getSelected() instanceof CustomProfile) {
				manager.commitChanges(instanceScope); // updates CCorePlugin options
			}
			uiPreferences.putInt(PREF_FORMATTER_PROFILES_VERSION, ProfileVersioner.CURRENT_VERSION);
			savePreferences(instanceScope);
						
			IProject[] projects= ResourcesPlugin.getWorkspace().getRoot().getProjects();
			for (int i= 0; i < projects.length; i++) {
				IScopeContext scope= access.getProjectScope(projects[i]);
				if (ProfileManager.hasProjectSpecificSettings(scope)) {
					manager= new ProfileManager(profiles, scope, access);
					manager.commitChanges(scope); // updates CCorePlugin project options
					savePreferences(scope);
				}
			}
		} catch (CoreException e) {
			CUIPlugin.getDefault().log(e);
		} catch (BackingStoreException e) {
			CUIPlugin.getDefault().log(e);
		}
	}
	
	private static void savePreferences(final IScopeContext context) throws BackingStoreException {
		try {
			context.getNode(CUIPlugin.PLUGIN_ID).flush();
		} finally {
			context.getNode(CCorePlugin.PLUGIN_ID).flush();
		}
	}
	
	/*
	 * Creates a UI exception for logging purposes
	 */
	private static CUIException createException(Throwable t, String message) {
		return new CUIException(CUIStatus.createError(IStatus.ERROR, message, t));
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.StatusDialog;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.CustomProfile;
import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.Profile;

/**
 * The dialog to create a new profile. 
 */
public class CreateProfileDialog extends StatusDialog {
    
    private static final String PREF_OPEN_EDIT_DIALOG= CUIPlugin.PLUGIN_ID + ".codeformatter.create_profile_dialog.open_edit"; //$NON-NLS-1$
    
	private Text fNameText;
	private Combo fProfileCombo;
	private Button fEditCheckbox;
	
	private final static StatusInfo fOk= new StatusInfo();
	private final static StatusInfo fEmpty= new StatusInfo(IStatus.ERROR, FormatterMessages.CreateProfileDialog_status_message_profile_name_is_empty); 
	private final static StatusInfo fDuplicate= new StatusInfo(IStatus.ERROR, FormatterMessages.CreateProfileDialog_status_message_profile_with_this_name_already_exists); 

	private final ProfileManager fProfileManager;
	private final List fSortedProfiles;
	private final String [] fSortedNames;
	
	private CustomProfile fCreatedProfile;
	protected boolean fOpenEditDialog;
	
	public CreateProfileDialog(Shell parentShell, ProfileManager profileManager) {
		super(parentShell);
		fProfileManager= profileManager;
		fSortedProfiles= fProfileManager.getSortedProfiles();
		fSortedNames= fProfileManager.getSortedDisplayNames();
	}
	
	
	public void create() {
		super.create();
		setTitle(FormatterMessages.CreateProfileDialog_dialog_title); 
	}
	
	public Control createDialogArea(Composite parent) {
				
		final int numColumns= 2;
		
		GridData gd;
		
		final GridLayout layout= new GridLayout(numColumns, false);
		layout.marginHeight= convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
		layout.marginWidth= convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
		layout.verticalSpacing= convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
		layout.horizontalSpacing= convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);

		final Composite composite= new Composite(parent, SWT.NONE);
		composite.setLayout(layout);
		
		// Create "Profile name:" label
		gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = numColumns;
		gd.widthHint= convertWidthInCharsToPixels(60);
		final Label nameLabel = new Label(composite, SWT.WRAP);
		nameLabel.setText(FormatterMessages.CreateProfileDialog_profile_name_label_text); 
		nameLabel.setLayoutData(gd);
		
		// Create text field to enter name
		gd = new GridData( GridData.FILL_HORIZONTAL);
		gd.horizontalSpan= numColumns;
		fNameText= new Text(composite, SWT.SINGLE | SWT.BORDER);
		fNameText.setLayoutData(gd);
		fNameText.addModifyListener( new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				doValidation();
			}
		});
		
		// Create "Initialize settings ..." label
		gd = new GridData();
		gd.horizontalSpan = numColumns;
		Label profileLabel = new Label(composite, SWT.WRAP);
		profileLabel.setText(FormatterMessages.CreateProfileDialog_base_profile_label_text); 
		profileLabel.setLayoutData(gd);
		
		gd= new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan= numColumns;
		fProfileCombo = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY);
		fProfileCombo.setLayoutData(gd);
		
		
		// "Open the edit dialog now" checkbox
		gd= new GridData();
		gd.horizontalSpan= numColumns;
		fEditCheckbox= new Button(composite, SWT.CHECK);
		fEditCheckbox.setText(FormatterMessages.CreateProfileDialog_open_edit_dialog_checkbox_text); 
		fEditCheckbox.addSelectionListener(new SelectionListener() {
			public void widgetSelected(SelectionEvent e) {
				fOpenEditDialog= ((Button)e.widget).getSelection();
			}
			public void widgetDefaultSelected(SelectionEvent e) {
			}
		});
		
		final IDialogSettings dialogSettings= CUIPlugin.getDefault().getDialogSettings();//.get(PREF_OPEN_EDIT_DIALOG);
		if (dialogSettings.get(PREF_OPEN_EDIT_DIALOG) != null) {
		    fOpenEditDialog= dialogSettings.getBoolean(PREF_OPEN_EDIT_DIALOG);
		} else {
		    fOpenEditDialog= true;
		}
		fEditCheckbox.setSelection(fOpenEditDialog);
		
		fProfileCombo.setItems(fSortedNames);
		fProfileCombo.setText(fProfileManager.getProfile(ProfileManager.DEFAULT_PROFILE).getName());
		updateStatus(fEmpty);
		
		applyDialogFont(composite);
		
		fNameText.setFocus();
		
		return composite;
	}


	/**
	 * Validate the current settings
	 */
	protected void doValidation() {
		final String name= fNameText.getText().trim();
		
		if (fProfileManager.containsName(name)) {
			updateStatus(fDuplicate);
			return;
		}
		if (name.length() == 0) {
			updateStatus(fEmpty);
			return;
		}
		updateStatus(fOk);
	}
	
	protected void okPressed() {
		if (!getStatus().isOK()) 
			return;

		CUIPlugin.getDefault().getDialogSettings().put(PREF_OPEN_EDIT_DIALOG, fOpenEditDialog);

		final Map baseSettings= new HashMap(((Profile)fSortedProfiles.get(fProfileCombo.getSelectionIndex())).getSettings());
		final String profileName= fNameText.getText();
		
		fCreatedProfile= new CustomProfile(profileName, baseSettings, ProfileVersioner.CURRENT_VERSION);
		fProfileManager.addProfile(fCreatedProfile);
		super.okPressed();
	}
	
	public final CustomProfile getCreatedProfile() {
		return fCreatedProfile;
	}
	
	public final boolean openEditDialog() {
		return fOpenEditDialog;
	}
}




###############################################################################
# Copyright (c) 2000, 2006 IBM Corporation and others.
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/epl-v10.html
#
# Contributors:
#     IBM Corporation - initial API and implementation
#     istvan@benedek-home.de - 103706 [formatter] indent empty lines
#     Aaron Luchko, aluchko@redhat.com - 105926 [Formatter] Exporting Unnamed profile fails silently
#     Sergey Prigogin, Google
###############################################################################


#WhiteSpaceTabPage_assignments=Assignments
#WhiteSpaceTabPage_assignments_before_assignment_operator=before assignment operator
#WhiteSpaceTabPage_assignments_after_assignment_operator=after assignment operator

#WhiteSpaceTabPage_operators=Operators
#WhiteSpaceTabPage_operators_before_binary_operators=before binary operators
#WhiteSpaceTabPage_operators_after_binary_operators=after binary operators
#WhiteSpaceTabPage_operators_before_unary_operators=before unary operators
#WhiteSpaceTabPage_operators_after_unary_operators=after unary operators
#WhiteSpaceTabPage_operators_before_prefix_operators=before prefix operators
#WhiteSpaceTabPage_operators_after_prefix_operators=after prefix operators
#WhiteSpaceTabPage_operators_before_postfix_operators=before postfix operators
#WhiteSpaceTabPage_operators_after_postfix_operators=after postfix operators

#WhiteSpaceTabPage_classes=Classes
#WhiteSpaceTabPage_classes_before_opening_brace_of_a_class=before opening brace of a class
#WhiteSpaceTabPage_classes_before_opening_brace_of_anon_class=before opening brace of an anonymous class
#WhiteSpaceTabPage_classes_before_comma_implements=before comma in implements clause
#WhiteSpaceTabPage_classes_after_comma_implements=after comma in implements clause

#WhiteSpaceTabPage_methods=Methods
#WhiteSpaceTabPage_constructors=Constructors

#WhiteSpaceTabPage_fields=Fields
#WhiteSpaceTabPage_fields_before_comma=before comma in multiple field declarations
#WhiteSpaceTabPage_fields_after_comma=after comma in multiple field declarations

#WhiteSpaceTabPage_localvars=Local variables
#WhiteSpaceTabPage_localvars_before_comma=before comma in multiple local declarations
#WhiteSpaceTabPage_localvars_after_comma=after comma in multiple local declarations

#WhiteSpaceTabPage_arrayinit=Array initializers
#WhiteSpaceTabPage_arraydecls=Array declarations
#WhiteSpaceTabPage_arrayelem=Array element access
#WhiteSpaceTabPage_arrayalloc=Array allocation

#WhiteSpaceTabPage_calls=Function invocations

#WhiteSpaceTabPage_calls_before_comma_in_method_args=before comma in method arguments
#WhiteSpaceTabPage_calls_after_comma_in_method_args=after comma in method arguments
#WhiteSpaceTabPage_calls_before_comma_in_alloc=before comma in object allocation arguments
#WhiteSpaceTabPage_calls_after_comma_in_alloc=after comma in object allocation arguments
#WhiteSpaceTabPage_calls_before_comma_in_qalloc=before comma in explicit constructor call
#WhiteSpaceTabPage_calls_after_comma_in_qalloc=after comma in explicit constructor call

#WhiteSpaceTabPage_statements=Control statements

#WhiteSpaceTabPage_blocks=Blocks

#WhiteSpaceTabPage_switch='switch'
#WhiteSpaceTabPage_switch_before_case_colon=before colon in case
#WhiteSpaceTabPage_switch_before_default_colon=before colon in default

#WhiteSpaceTabPage_do='while' & 'do while'

#WhiteSpaceTabPage_synchronized='synchronized'

#WhiteSpaceTabPage_try='catch'

#WhiteSpaceTabPage_if='if else'
#WhiteSpaceTabPage_assert='assert'

#WhiteSpaceTabPage_for='for'
#WhiteSpaceTabPage_for_before_comma_init=before comma in initialization
#WhiteSpaceTabPage_for_after_comma_init=after comma in initialization
#WhiteSpaceTabPage_for_before_comma_inc=before comma in increments
#WhiteSpaceTabPage_for_after_comma_inc=after comma in increments


#WhiteSpaceTabPage_labels=Labels
#WhiteSpaceTabPage_annotations=Annotations
#WhiteSpaceTabPage_annotation_types=Annotation types
#WhiteSpaceTabPage_enums=Enum types
#WhiteSpaceTabPage_wildcardtype=Wildcard type
#WhiteSpaceTabPage_param_type_ref=Type reference
#WhiteSpaceTabPage_type_arguments=Type arguments
#WhiteSpaceTabPage_type_parameters=Type parameters

#WhiteSpaceTabPage_conditionals=Conditionals

#WhiteSpaceTabPage_typecasts=Type casts

#WhiteSpaceTabPage_parenexpr=Parenthesized expressions
#WhiteSpaceTabPage_declarations=Declarations
#WhiteSpaceTabPage_expressions=Expressions
#WhiteSpaceTabPage_arrays=Arrays
#WhiteSpaceTabPage_parameterized_types=Parameterized types

#WhiteSpaceTabPage_after_opening_brace=after opening brace
#WhiteSpaceTabPage_after_closing_brace=after closing brace
#WhiteSpaceTabPage_before_opening_brace=before opening brace
#WhiteSpaceTabPage_before_closing_brace=before closing brace
#WhiteSpaceTabPage_between_empty_braces=between empty braces


#WhiteSpaceTabPage_after_opening_paren=after opening parenthesis
#WhiteSpaceTabPage_after_closing_paren=after closing parenthesis
#WhiteSpaceTabPage_before_opening_paren=before opening parenthesis
#WhiteSpaceTabPage_before_closing_paren=before closing parenthesis
#WhiteSpaceTabPage_between_empty_parens=between empty parenthesis

#WhiteSpaceTabPage_after_opening_bracket=after opening bracket
#WhiteSpaceTabPage_before_opening_bracket=before opening bracket
#WhiteSpaceTabPage_before_closing_bracket=before closing bracket
#WhiteSpaceTabPage_between_empty_brackets=between empty brackets

#WhiteSpaceTabPage_before_comma_in_params=before comma in parameters
#WhiteSpaceTabPage_after_comma_in_params=after comma in parameters
#WhiteSpaceTabPage_before_comma_in_throws=before comma in 'throws' clause
#WhiteSpaceTabPage_after_comma_in_throws=after comma in 'throws' clause

#WhiteSpaceTabPage_before_ellipsis=before ellipsis in vararg parameters
#WhiteSpaceTabPage_after_ellipsis=after ellipsis in vararg parameters

#WhiteSpaceTabPage_before_comma=before comma
#WhiteSpaceTabPage_after_comma=after comma

#WhiteSpaceTabPage_after_semicolon=after semicolon
#WhiteSpaceTabPage_before_semicolon=before semicolon

#WhiteSpaceTabPage_before_colon=before colon
#WhiteSpaceTabPage_after_colon=after colon

#WhiteSpaceTabPage_before_question=before question mark
#WhiteSpaceTabPage_after_question=after question mark

#WhiteSpaceTabPage_before_at=before @
#WhiteSpaceTabPage_after_at=after @

#WhiteSpaceTabPage_after_opening_angle_bracket=after opening angle bracket
#WhiteSpaceTabPage_after_closing_angle_bracket=after closing angle bracket
#WhiteSpaceTabPage_before_opening_angle_bracket=before opening angle bracket
#WhiteSpaceTabPage_before_closing_angle_bracket=before closing angle bracket
#WhiteSpaceTabPage_before_parenthesized_expressions=before parenthesized expressions

#WhiteSpaceTabPage_before_and_list=before '&' in type bounds
#WhiteSpaceTabPage_after_and_list=after '&' in type bounds

#WhiteSpaceTabPage_enum_decl_before_opening_brace=before opening brace in declaration
#WhiteSpaceTabPage_enum_decl_before_comma=before comma between constants
#WhiteSpaceTabPage_enum_decl_after_comma=after comma between constants

#WhiteSpaceTabPage_enum_const_arg_before_opening_paren=before opening parenthesis in constant arguments
#WhiteSpaceTabPage_enum_const_arg_after_opening_paren=after opening parenthesis in constant arguments
#WhiteSpaceTabPage_enum_const_arg_between_empty_parens=between empty parenthesis in constant arguments
#WhiteSpaceTabPage_enum_const_arg_before_comma=before comma in constant arguments
#WhiteSpaceTabPage_enum_const_arg_after_comma=after comma in constant arguments
#WhiteSpaceTabPage_enum_const_arg_before_closing_paren=before closing parenthesis in constant arguments

#WhiteSpaceTabPage_enum_const_before_opening_brace=before opening brace of constant body

#WhiteSpaceTabPage_annot_type_method_before_opening_paren=before opening parenthesis in annotation type members
#WhiteSpaceTabPage_annot_type_method_between_empty_parens=between parenthesis in annotation type members

#WhiteSpaceTabPage_sort_by_c_element=Sort options by C element
#WhiteSpaceTabPage_sort_by_syntax_element=Sort options by Syntax element

#WhiteSpaceOptions_before=Before
#WhiteSpaceOptions_after=After

#WhiteSpaceOptions_operator=Operator
#WhiteSpaceOptions_assignment_operator=Assignment operator
#WhiteSpaceOptions_binary_operator=Binary operator
#WhiteSpaceOptions_unary_operator=Unary operator
#WhiteSpaceOptions_prefix_operator=Prefix operator
#WhiteSpaceOptions_postfix_operator=Postfix operator


#WhiteSpaceOptions_opening_paren=Opening parenthesis
#WhiteSpaceOptions_catch='catch'
#WhiteSpaceOptions_for='for'
#WhiteSpaceOptions_if='if'
#WhiteSpaceOptions_switch='switch'
#WhiteSpaceOptions_synchronized='synchronized'
#WhiteSpaceOptions_while='while'
#WhiteSpaceOptions_assert='assert'
#WhiteSpaceOptions_member_function_declaration=Member function declaration
#WhiteSpaceOptions_constructor=Constructor
#WhiteSpaceOptions_method=Method
#WhiteSpaceOptions_method_call=Method call
#WhiteSpaceOptions_paren_expr=Parenthesized expression
#WhiteSpaceOptions_enum_constant_body=Enum constant body
#WhiteSpaceOptions_enum_constant_arguments=Enum constant arguments
#WhiteSpaceOptions_enum_declaration=Enum declaration
#WhiteSpaceOptions_annotation_modifier=Annotation
#WhiteSpaceOptions_annotation_modifier_args=Annotation arguments
#WhiteSpaceOptions_annotation_type_member=Annotation type member
#WhiteSpaceOptions_annotation_type=Annotation type

#WhiteSpaceOptions_type_cast=Type cast
#WhiteSpaceOptions_parameterized_type=Parameterized type
#WhiteSpaceOptions_type_arguments=Type arguments
#WhiteSpaceOptions_type_parameters=Type parameters
#WhiteSpaceOptions_vararg_parameter=Vararg parameters

#WhiteSpaceOptions_closing_paren=Closing parenthesis

#WhiteSpaceOptions_opening_brace=Opening brace
#WhiteSpaceOptions_closing_brace=Closing brace
#WhiteSpaceOptions_opening_bracket=Opening bracket
#WhiteSpaceOptions_closing_bracket=Closing bracket
#WhiteSpaceOptions_class_decl=Type declaration
#WhiteSpaceOptions_anon_class_decl=Anonymous type declaration
#WhiteSpaceOptions_initializer=Array initializer
#WhiteSpaceOptions_block=Block

#WhiteSpaceOptions_array_decl=Array declaration
#WhiteSpaceOptions_array_element_access=Array element access
#WhiteSpaceOptions_array_alloc=Array allocation
#WhiteSpaceOptions_array_init=Array initializer

#WhiteSpaceOptions_arguments=Arguments
#WhiteSpaceOptions_initialization=Initialization
#WhiteSpaceOptions_incrementation=Increment
#WhiteSpaceOptions_parameters=Parameters

#WhiteSpaceOptions_explicit_constructor_call=Explicit constructor call
#WhiteSpaceOptions_alloc_expr=Allocation expression
#WhiteSpaceOptions_throws='throws' clause
#WhiteSpaceOptions_mult_decls=Multiple declarations
#WhiteSpaceOptions_local_vars=Local variables
#WhiteSpaceOptions_fields=Fields
#WhiteSpaceOptions_return='return'
#WhiteSpaceOptions_implements_clause='extends'/'implements' clause
#WhiteSpaceOptions_colon=Colon
#WhiteSpaceOptions_conditional=Conditional
#WhiteSpaceOptions_wildcard=Wildcard type
#WhiteSpaceOptions_label=Label
#WhiteSpaceOptions_comma=Comma

#WhiteSpaceOptions_semicolon=Semicolon
#WhiteSpaceOptions_question_mark=Question mark
#WhiteSpaceOptions_between_empty_parens=Between empty parenthesis
#WhiteSpaceOptions_between_empty_braces=Between empty braces
#WhiteSpaceOptions_between_empty_brackets=Between empty brackets
#WhiteSpaceOptions_constructor_decl=Constructor declaration
#WhiteSpaceOptions_method_decl=Method declaration
#WhiteSpaceOptions_case='case'
#WhiteSpaceOptions_default='default'
#WhiteSpaceOptions_statements=Statements



#WhiteSpaceOptions_before_opening_paren=Before opening parenthesis
#WhiteSpaceOptions_after_opening_paren=After opening parenthesis
#WhiteSpaceOptions_before_closing_paren=Before closing parenthesis

#WhiteSpaceOptions_after_closing_paren=After closing parenthesis
#WhiteSpaceOptions_before_opening_brace=Before opening brace
#WhiteSpaceOptions_after_opening_brace=After opening brace
#WhiteSpaceOptions_after_closing_brace=After closing brace
#WhiteSpaceOptions_before_closing_brace=Before closing brace
#WhiteSpaceOptions_before_opening_bracket=Before opening bracket
#WhiteSpaceOptions_after_opening_bracket=After opening bracket
#WhiteSpaceOptions_before_closing_bracket=Before closing bracket

#WhiteSpaceOptions_before_opening_angle_bracket=Before opening angle bracket
#WhiteSpaceOptions_after_opening_angle_bracket=After opening angle bracket
#WhiteSpaceOptions_before_closing_angle_bracket=Before closing angle bracket
#WhiteSpaceOptions_return_with_parenthesized_expression=parenthesized expression
#WhiteSpaceOptions_after_closing_angle_bracket=After closing angle bracket

#WhiteSpaceOptions_before_operator=Before operator
#WhiteSpaceOptions_after_operator=After operator
#WhiteSpaceOptions_before_comma=Before comma
#WhiteSpaceOptions_after_comma=After comma
#WhiteSpaceOptions_after_colon=After colon
#WhiteSpaceOptions_before_colon=Before colon
#WhiteSpaceOptions_before_semicolon=Before semicolon
#WhiteSpaceOptions_after_semicolon=After semicolon
#WhiteSpaceOptions_before_question_mark=Before question mark
#WhiteSpaceOptions_after_question_mark=After question mark
#WhiteSpaceOptions_before_at=Before @
#WhiteSpaceOptions_after_at=After @

#WhiteSpaceOptions_before_and=Before & list
#WhiteSpaceOptions_after_and=After & list

#WhiteSpaceOptions_before_ellipsis=Before Ellipsis
#WhiteSpaceOptions_after_ellipsis=After Ellipsis

#WhiteSpaceTabPage_insert_space=&Insert space:


#LineWrappingTabPage_compact_if_else=Compact 'if else'
#LineWrappingTabPage_extends_clause='extends' clause
#LineWrappingTabPage_enum_constant_arguments=Constant arguments
#LineWrappingTabPage_enum_constants=Constants
#LineWrappingTabPage_implements_clause='implements' clause
#LineWrappingTabPage_parameters=Parameters
#LineWrappingTabPage_arguments=Arguments
#LineWrappingTabPage_qualified_invocations=Qualified invocations
#LineWrappingTabPage_throws_clause='throws' clause
#LineWrappingTabPage_object_allocation=Object allocation arguments
#LineWrappingTabPage_qualified_object_allocation=Qualified object allocation arguments
#LineWrappingTabPage_array_init=Array initializers
#LineWrappingTabPage_explicit_constructor_invocations=Explicit constructor invocations
#LineWrappingTabPage_conditionals=Conditionals
#LineWrappingTabPage_binary_exprs=Binary expressions
#LineWrappingTabPage_indentation_default=Default indentation
#LineWrappingTabPage_indentation_on_column=Indent on column
#LineWrappingTabPage_indentation_by_one=Indent by one
#LineWrappingTabPage_class_decls=Class Declarations
#LineWrappingTabPage_method_decls=Method Declarations
#LineWrappingTabPage_constructor_decls=Constructor declarations
#LineWrappingTabPage_function_calls=Function Calls
#LineWrappingTabPage_expressions=Expressions
#LineWrappingTabPage_statements=Statements
#LineWrappingTabPage_enum_decls='enum' declaration
#LineWrappingTabPage_wrapping_policy_label_text=Lin&e wrapping policy:
#LineWrappingTabPage_indentation_policy_label_text=Indent&ation policy:
#LineWrappingTabPage_force_split_checkbox_text=&Force split
#LineWrappingTabPage_force_split_checkbox_multi_text=&Force split
#LineWrappingTabPage_line_width_for_preview_label_text=&Set line width for preview window:
#LineWrappingTabPage_group=Settings for {0}
#LineWrappingTabPage_multi_group=Settings for {0} ({1} items)
#LineWrappingTabPage_multiple_selections=Settings for multiple selections ({0} items)
#LineWrappingTabPage_occurences={0} ({1} of {2})
#LineWrappingTabPage_splitting_do_not_split=Do not wrap
#LineWrappingTabPage_splitting_wrap_when_necessary=Wrap only when necessary
#LineWrappingTabPage_splitting_always_wrap_first_others_when_necessary=Always wrap first element, others when necessary
#LineWrappingTabPage_splitting_wrap_always=Wrap all elements, every element on a new line
#LineWrappingTabPage_splitting_wrap_always_indent_all_but_first=Wrap all elements, indent all but the first element
#LineWrappingTabPage_splitting_wrap_always_except_first_only_if_necessary=Wrap all elements, except first element if not necessary
#LineWrappingTabPage_width_indent=Line width and indentation levels
#LineWrappingTabPage_width_indent_option_max_line_width=Ma&ximum line width:
#LineWrappingTabPage_width_indent_option_default_indent_wrapped=Defa&ult indentation for wrapped lines:
#LineWrappingTabPage_width_indent_option_default_indent_array=Default indentation for arra&y initializers:
#LineWrappingTabPage_error_invalid_value=The key ''{0}'' contained an invalid value; resetting to defaults.
#LineWrappingTabPage_enum_superinterfaces='implements' clause
#LineWrappingTabPage_assignment_alignment=Assignments


AlreadyExistsDialog_message_profile_already_exists=A profile with this name already exists.
AlreadyExistsDialog_message_profile_name_empty=Profile name is empty
AlreadyExistsDialog_dialog_title=Load Profile
AlreadyExistsDialog_dialog_label=A profile with the name ''{0}'' already exists in this workspace. What would you like to do?
AlreadyExistsDialog_rename_radio_button_desc=&Rename the imported profile:
AlreadyExistsDialog_overwrite_radio_button_desc=&Overwrite the existing profile.


#BlankLinesTabPage_preview_header=Blank Lines
#BlankLinesTabPage_compilation_unit_group_title=Blank lines in compilation unit
#BlankLinesTabPage_compilation_unit_option_before_package=Before p&ackage declaration:
#BlankLinesTabPage_compilation_unit_option_after_package=After packa&ge declaration:
#BlankLinesTabPage_compilation_unit_option_before_import=&Before import declaration:
#BlankLinesTabPage_compilation_unit_option_after_import=After import de&claration:
#BlankLinesTabPage_compilation_unit_option_between_type_declarations=Between class declarat&ions:

#BlankLinesTabPage_class_group_title=Blank lines within class declarations
#BlankLinesTabPage_class_option_before_first_decl=Before &first declaration:
#BlankLinesTabPage_class_option_before_decls_of_same_kind=Before declarations of the same &kind:
#BlankLinesTabPage_class_option_before_member_class_decls=Before member cla&ss declarations:
#BlankLinesTabPage_class_option_before_field_decls=B&efore field declarations:
#BlankLinesTabPage_class_option_before_method_decls=Before met&hod declarations:
#BlankLinesTabPage_class_option_at_beginning_of_method_body= At beginning of method bod&y:

#BlankLinesTabPage_blank_lines_group_title=Existing blank lines
#BlankLinesTabPage_blank_lines_option_empty_lines_to_preserve=N&umber of empty lines to preserve:

#BracesTabPage_preview_header=Braces
#BracesTabPage_position_same_line=Same line
#BracesTabPage_position_next_line=Next line
#BracesTabPage_position_next_line_indented=Next line indented
#BracesTabPage_position_next_line_on_wrap=Next line on wrap

#BracesTabPage_group_brace_positions_title=Brace positions
#BracesTabPage_option_class_declaration=&Class or interface declaration:
#BracesTabPage_option_anonymous_class_declaration=Anon&ymous class declaration:
#BracesTabPage_option_method_declaration=Met&hod declaration:
#BracesTabPage_option_constructor_declaration=Constr&uctor declaration:
#BracesTabPage_option_blocks=&Blocks:
#BracesTabPage_option_blocks_in_case=Bloc&ks in case statement:
#BracesTabPage_option_switch_case='&switch' statement:
#BracesTabPage_option_array_initializer=Array initiali&zer:
#BracesTabPage_option_keep_empty_array_initializer_on_one_line=Keep empty array &initializer on one line
#BracesTabPage_option_enum_declaration=&Enum declaration:
#BracesTabPage_option_enumconst_declaration=Enum c&onstant body:
#BracesTabPage_option_annotation_type_declaration=&Annotation type declaration:
CodingStyleConfigurationBlock_save_profile_dialog_title=Export Profile
CodingStyleConfigurationBlock_save_profile_error_title=Export Profile
CodingStyleConfigurationBlock_save_profile_error_message=Could not export the profiles.
CodingStyleConfigurationBlock_load_profile_dialog_title=Import Profile
CodingStyleConfigurationBlock_load_profile_error_title=Import Profile
CodingStyleConfigurationBlock_load_profile_error_message=Import failed. Not a valid profile.
CodingStyleConfigurationBlock_load_profile_error_too_new_title=Importing Profile
CodingStyleConfigurationBlock_load_profile_error_too_new_message=This profile has been created with \
a more recent CDT build than the one you are using. Due to changes in the code formatter, \
some older settings might be reset to their default values and newer settings are ignored. Please note \
that upgrading profiles from older to newer builds is fully supported.
CodingStyleConfigurationBlock_preview_title=A sample source file for the code formatter preview
CodingStyleConfigurationBlock_save_profile_overwrite_title=Export Profile
CodingStyleConfigurationBlock_save_profile_overwrite_message={0} " already exists.\nDo you want to replace it?"
CodingStyleConfigurationBlock_edit_button_desc=&Edit...
CodingStyleConfigurationBlock_show_button_desc=&Show...
CodingStyleConfigurationBlock_rename_button_desc=Re&name...
CodingStyleConfigurationBlock_remove_button_desc=&Remove
CodingStyleConfigurationBlock_new_button_desc=Ne&w...
CodingStyleConfigurationBlock_load_button_desc=I&mport...
CodingStyleConfigurationBlock_save_button_desc=E&xport...
CodingStyleConfigurationBlock_preview_label_text=Prev&iew:
CodingStyleConfigurationBlock_error_reading_xml_message=Problems reading profiles from XML
CodingStyleConfigurationBlock_error_serializing_xml_message=Problems serializing the profiles to XML
CodingStyleConfigurationBlock_delete_confirmation_title=Confirm Remove
CodingStyleConfigurationBlock_delete_confirmation_question=Are you sure you want to remove profile ''{0}''?

CustomCodeFormatterBlock_formatter_name=Code &Formatter:
CustomCodeFormatterBlock_no_formatter=(NONE)

#CommentsTabPage_group1_title=General settings
#CommentsTabPage_enable_comment_formatting=Enable &comment formatting
#CommentsTabPage_format_header=Format &header comment
#CommentsTabPage_format_html=Format HTML ta&gs
#CommentsTabPage_format_code_snippets=Format &C code snippets

#CommentsTabPage_clear_blank_lines=Clear &blank lines in comments
#CommentsTabPage_group3_title=Line width
#CommentsTabPage_line_width=Ma&ximum line width for comments:


#ControlStatementsTabPage_preview_header=If...else
#ControlStatementsTabPage_general_group_title=General
#ControlStatementsTabPage_general_group_insert_new_line_before_else_statements=Insert new line before '&else' in an 'if' statement
#ControlStatementsTabPage_general_group_insert_new_line_before_catch_statements=Insert new line before '&catch' in a 'try' statement
#ControlStatementsTabPage_general_group_insert_new_line_before_finally_statements=Insert new line before '&finally' in a 'try' statement
#ControlStatementsTabPage_general_group_insert_new_line_before_while_in_do_statements=Insert new line before 'w&hile' in a 'do' statement

#ControlStatementsTabPage_if_else_group_title='if else'
#ControlStatementsTabPage_if_else_group_keep_then_on_same_line=Keep 'then' statement &on same line
#ControlStatementsTabPage_if_else_group_keep_simple_if_on_one_line=Keep &simple 'if' on one line
#ControlStatementsTabPage_if_else_group_keep_else_on_same_line=Keep 'else' st&atement on same line
#ControlStatementsTabPage_if_else_group_keep_else_if_on_one_line=&Keep 'else if' on one line
#ControlStatementsTabPage_if_else_group_keep_guardian_clause_on_one_line=Keep 'return' or 'throw' cla&use on one line

CreateProfileDialog_status_message_profile_with_this_name_already_exists=A profile with this name already exists.
CreateProfileDialog_status_message_profile_name_is_empty=Profile name is empty
CreateProfileDialog_dialog_title=New Code Formatter Profile
CreateProfileDialog_profile_name_label_text=&Profile name:
CreateProfileDialog_base_profile_label_text=I&nitialize settings with the following profile:
CreateProfileDialog_open_edit_dialog_checkbox_text=&Open the edit dialog now

IndentationTabPage_preview_header=Indentation

IndentationTabPage_general_group_title=General settings
IndentationTabPage_general_group_option_tab_policy=Tab polic&y:
IndentationTabPage_general_group_option_tab_policy_SPACE=Spaces only
IndentationTabPage_general_group_option_tab_policy_TAB=Tabs only
IndentationTabPage_general_group_option_tab_policy_MIXED=Mixed
IndentationTabPage_general_group_option_tab_size=Tab &size:
IndentationTabPage_general_group_option_indent_size=&Indentation size:

IndentationTabPage_field_alignment_group_title=Alignment of fields in class declarations
IndentationTabPage_field_alignment_group_align_fields_in_columns=&Align fields in columns

IndentationTabPage_indent_group_title=Indent

IndentationTabPage_class_group_option_indent_declarations_within_class_body=Declarations within class &body
IndentationTabPage_class_group_option_indent_declarations_within_enum_const=Declarations within en&um constants
IndentationTabPage_class_group_option_indent_declarations_within_enum_decl=De&clarations within enum declaration
IndentationTabPage_block_group_option_indent_statements_compare_to_body=Stat&ements within method/constructor body
IndentationTabPage_block_group_option_indent_statements_compare_to_block=Statements within bl&ocks
IndentationTabPage_indent_empty_lines=Empty lines

IndentationTabPage_switch_group_option_indent_statements_within_switch_body=Statements wit&hin 'switch' body
IndentationTabPage_switch_group_option_indent_statements_within_case_body=Statements within 'case' bo&dy
IndentationTabPage_switch_group_option_indent_break_statements='brea&k' statements

IndentationTabPage_use_tabs_only_for_leading_indentations=Use tabs only for leading indentations

ModifyDialog_dialog_title=Edit Profile ''{0}''
ModifyDialog_apply_button=Apply
ModifyDialog_dialog_show_title=Show Profile ''{0}''
ModifyDialog_dialog_show_warning_builtin=This is a built-in profile, you will be prompted to enter a new name after closing this dialog.
ModifyDialog_tabpage_braces_title=B&races
ModifyDialog_tabpage_indentation_title=In&dentation
ModifyDialog_tabpage_whitespace_title=&White Space
ModifyDialog_tabpage_blank_lines_title=Bla&nk Lines
ModifyDialog_tabpage_new_lines_title=New &Lines
ModifyDialog_tabpage_control_statements_title=Con&trol Statements
ModifyDialog_tabpage_line_wrapping_title=Line Wra&pping
ModifyDialog_tabpage_comments_title=Co&mments

ModifyDialogTabPage_preview_label_text=Pre&view:
ModifyDialogTabPage_error_msg_values_text_unassigned=Values and text must be assigned.
ModifyDialogTabPage_error_msg_values_items_text_unassigned=Values, items and text must be assigned.
ModifyDialogTabPage_NumberPreference_error_invalid_key=The key {0} does not yield a valid integer value.
ModifyDialogTabPage_NumberPreference_error_invalid_value=Invalid value: Please enter a number between {0} and {1}.

#NewLinesTabPage_preview_header=New Lines
#NewLinesTabPage_newlines_group_title=Insert new line

#NewLinesTabPage_newlines_group_option_empty_class_body=in empty &class body
#NewLinesTabPage_newlines_group_option_empty_annotation_decl_body=in empty annotation body
#NewLinesTabPage_newlines_group_option_empty_anonymous_class_body=in empty &anonymous class body
#NewLinesTabPage_newlines_group_option_empty_enum_declaration=in empty &enum declaration
#NewLinesTabPage_newlines_group_option_empty_enum_constant=in empty enum c&onstant body
#NewLinesTabPage_newlines_group_option_empty_method_body=in empt&y method body
#NewLinesTabPage_newlines_group_option_empty_block=in empty &block
#NewLinesTabPage_newlines_group_option_empty_end_of_file=at end of &file
#NewLinesTabPage_empty_statement_group_title=Empty statements
#NewLinesTabPage_emtpy_statement_group_option_empty_statement_on_new_line=Put empty &statement on new line

#NewLinesTabPage_arrayInitializer_group_title=Array initializers
#NewLinesTabPage_array_group_option_after_opening_brace_of_array_initializer=Insert new line after openin&g brace of array initializer
#NewLinesTabPage_array_group_option_before_closing_brace_of_array_initializer=Insert new line before closing brace of array initiali&zer

#NewLinesTabPage_annotations_group_title=Annotations
#NewLinesTabPage_annotations_group_option_after_annotation=&Insert new line after annotations

ProfileManager_default_profile_name=Default [built-in]

ProfileManager_unmanaged_profile=Unmanaged profile
ProfileManager_unmanaged_profile_with_name=Unmanaged profile "{0}"

RenameProfileDialog_status_message_profile_with_this_name_already_exists=A profile with this name already exists.
RenameProfileDialog_status_message_profile_name_empty=Profile name is empty
RenameProfileDialog_dialog_title=Rename Profile
RenameProfileDialog_dialog_label_enter_a_new_name=Please &enter a new name:

CPreview_formatter_exception=The formatter threw an unhandled exception while formatting the preview.




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences.formatter;

import org.eclipse.osgi.util.NLS;

/**
 * Helper class to get NLSed messages.
 */
final class FormatterMessages extends NLS {

	private static final String BUNDLE_NAME= FormatterMessages.class.getName(); 

	private FormatterMessages() {
		// Do not instantiate
	}

//	public static String WhiteSpaceTabPage_assignments;
//	public static String WhiteSpaceTabPage_assignments_before_assignment_operator;
//	public static String WhiteSpaceTabPage_assignments_after_assignment_operator;
//	public static String WhiteSpaceTabPage_operators;
//	public static String WhiteSpaceTabPage_operators_before_binary_operators;
//	public static String WhiteSpaceTabPage_operators_after_binary_operators;
//	public static String WhiteSpaceTabPage_operators_before_unary_operators;
//	public static String WhiteSpaceTabPage_operators_after_unary_operators;
//	public static String WhiteSpaceTabPage_operators_before_prefix_operators;
//	public static String WhiteSpaceTabPage_operators_after_prefix_operators;
//	public static String WhiteSpaceTabPage_operators_before_postfix_operators;
//	public static String WhiteSpaceTabPage_operators_after_postfix_operators;
//	public static String WhiteSpaceTabPage_classes;
//	public static String WhiteSpaceTabPage_classes_before_opening_brace_of_a_class;
//	public static String WhiteSpaceTabPage_classes_before_opening_brace_of_anon_class;
//	public static String WhiteSpaceTabPage_classes_before_comma_implements;
//	public static String WhiteSpaceTabPage_classes_after_comma_implements;
//	public static String WhiteSpaceTabPage_methods;
//	public static String WhiteSpaceTabPage_constructors;
//	public static String WhiteSpaceTabPage_fields;
//	public static String WhiteSpaceTabPage_fields_before_comma;
//	public static String WhiteSpaceTabPage_fields_after_comma;
//	public static String WhiteSpaceTabPage_localvars;
//	public static String WhiteSpaceTabPage_localvars_before_comma;
//	public static String WhiteSpaceTabPage_localvars_after_comma;
//	public static String WhiteSpaceTabPage_arrayinit;
//	public static String WhiteSpaceTabPage_arraydecls;
//	public static String WhiteSpaceTabPage_arrayelem;
//	public static String WhiteSpaceTabPage_arrayalloc;
//	public static String WhiteSpaceTabPage_calls;
//	public static String WhiteSpaceTabPage_calls_before_comma_in_method_args;
//	public static String WhiteSpaceTabPage_calls_after_comma_in_method_args;
//	public static String WhiteSpaceTabPage_calls_before_comma_in_alloc;
//	public static String WhiteSpaceTabPage_calls_after_comma_in_alloc;
//	public static String WhiteSpaceTabPage_calls_before_comma_in_qalloc;
//	public static String WhiteSpaceTabPage_calls_after_comma_in_qalloc;
//	public static String WhiteSpaceTabPage_statements;
//	public static String WhiteSpaceTabPage_blocks;
//	public static String WhiteSpaceTabPage_switch;
//	public static String WhiteSpaceTabPage_switch_before_case_colon;
//	public static String WhiteSpaceTabPage_switch_before_default_colon;
//	public static String WhiteSpaceTabPage_do;
//	public static String WhiteSpaceTabPage_synchronized;
//	public static String WhiteSpaceTabPage_try;
//	public static String WhiteSpaceTabPage_if;
//	public static String WhiteSpaceTabPage_assert;
//	public static String WhiteSpaceTabPage_for;
//	public static String WhiteSpaceTabPage_for_before_comma_init;
//	public static String WhiteSpaceTabPage_for_after_comma_init;
//	public static String WhiteSpaceTabPage_for_before_comma_inc;
//	public static String WhiteSpaceTabPage_for_after_comma_inc;
//	public static String WhiteSpaceTabPage_labels;
//	public static String WhiteSpaceTabPage_annotations;
//	public static String WhiteSpaceTabPage_annotation_types;
//	public static String WhiteSpaceTabPage_enums;
//	public static String WhiteSpaceTabPage_wildcardtype;
//	public static String WhiteSpaceTabPage_param_type_ref;
//	public static String WhiteSpaceTabPage_type_arguments;
//	public static String WhiteSpaceTabPage_type_parameters;
//	public static String WhiteSpaceTabPage_conditionals;
//	public static String WhiteSpaceTabPage_typecasts;
//	public static String WhiteSpaceTabPage_parenexpr;
//	public static String WhiteSpaceTabPage_declarations;
//	public static String WhiteSpaceTabPage_expressions;
//	public static String WhiteSpaceTabPage_arrays;
//	public static String WhiteSpaceTabPage_parameterized_types;
//	public static String WhiteSpaceTabPage_after_opening_brace;
//	public static String WhiteSpaceTabPage_after_closing_brace;
//	public static String WhiteSpaceTabPage_before_opening_brace;
//	public static String WhiteSpaceTabPage_before_closing_brace;
//	public static String WhiteSpaceTabPage_between_empty_braces;
//	public static String WhiteSpaceTabPage_after_opening_paren;
//	public static String WhiteSpaceTabPage_after_closing_paren;
//	public static String WhiteSpaceTabPage_before_opening_paren;
//	public static String WhiteSpaceTabPage_before_closing_paren;
//	public static String WhiteSpaceTabPage_between_empty_parens;
//	public static String WhiteSpaceTabPage_after_opening_bracket;
//	public static String WhiteSpaceTabPage_before_opening_bracket;
//	public static String WhiteSpaceTabPage_before_closing_bracket;
//	public static String WhiteSpaceTabPage_between_empty_brackets;
//	public static String WhiteSpaceTabPage_before_comma_in_params;
//	public static String WhiteSpaceTabPage_after_comma_in_params;
//	public static String WhiteSpaceTabPage_before_comma_in_throws;
//	public static String WhiteSpaceTabPage_after_comma_in_throws;
//	public static String WhiteSpaceTabPage_before_ellipsis;
//	public static String WhiteSpaceTabPage_after_ellipsis;
//	public static String WhiteSpaceTabPage_before_comma;
//	public static String WhiteSpaceTabPage_after_comma;
//	public static String WhiteSpaceTabPage_after_semicolon;
//	public static String WhiteSpaceTabPage_before_semicolon;
//	public static String WhiteSpaceTabPage_before_colon;
//	public static String WhiteSpaceTabPage_after_colon;
//	public static String WhiteSpaceTabPage_before_question;
//	public static String WhiteSpaceTabPage_after_question;
//	public static String WhiteSpaceTabPage_before_at;
//	public static String WhiteSpaceTabPage_after_at;
//	public static String WhiteSpaceTabPage_after_opening_angle_bracket;
//	public static String WhiteSpaceTabPage_after_closing_angle_bracket;
//	public static String WhiteSpaceTabPage_before_opening_angle_bracket;
//	public static String WhiteSpaceTabPage_before_closing_angle_bracket;
//	public static String WhiteSpaceTabPage_before_and_list;
//	public static String WhiteSpaceTabPage_after_and_list;
//	public static String WhiteSpaceTabPage_enum_decl_before_opening_brace;
//	public static String WhiteSpaceTabPage_enum_decl_before_comma;
//	public static String WhiteSpaceTabPage_enum_decl_after_comma;
//	public static String WhiteSpaceTabPage_enum_const_arg_before_opening_paren;
//	public static String WhiteSpaceTabPage_enum_const_arg_after_opening_paren;
//	public static String WhiteSpaceTabPage_enum_const_arg_between_empty_parens;
//	public static String WhiteSpaceTabPage_enum_const_arg_before_comma;
//	public static String WhiteSpaceTabPage_enum_const_arg_after_comma;
//	public static String WhiteSpaceTabPage_enum_const_arg_before_closing_paren;
//	public static String WhiteSpaceTabPage_enum_const_before_opening_brace;
//	public static String WhiteSpaceTabPage_annot_type_method_before_opening_paren;
//	public static String WhiteSpaceTabPage_annot_type_method_between_empty_parens;
//	public static String WhiteSpaceTabPage_before_parenthesized_expressions;
//	public static String WhiteSpaceTabPage_insert_space;
//	public static String WhiteSpaceTabPage_sort_by_c_element;
//	public static String WhiteSpaceTabPage_sort_by_syntax_element;
//	public static String WhiteSpaceOptions_return;
//	public static String WhiteSpaceOptions_before;
//	public static String WhiteSpaceOptions_after;
//	public static String WhiteSpaceOptions_operator;
//	public static String WhiteSpaceOptions_assignment_operator;
//	public static String WhiteSpaceOptions_binary_operator;
//	public static String WhiteSpaceOptions_unary_operator;
//	public static String WhiteSpaceOptions_prefix_operator;
//	public static String WhiteSpaceOptions_postfix_operator;
//	public static String WhiteSpaceOptions_opening_paren;
//	public static String WhiteSpaceOptions_catch;
//	public static String WhiteSpaceOptions_for;
//	public static String WhiteSpaceOptions_if;
//	public static String WhiteSpaceOptions_switch;
//	public static String WhiteSpaceOptions_synchronized;
//	public static String WhiteSpaceOptions_while;
//	public static String WhiteSpaceOptions_assert;
//	public static String WhiteSpaceOptions_member_function_declaration;
//	public static String WhiteSpaceOptions_constructor;
//	public static String WhiteSpaceOptions_method;
//	public static String WhiteSpaceOptions_method_call;
//	public static String WhiteSpaceOptions_paren_expr;
//	public static String WhiteSpaceOptions_enum_constant_body;
//	public static String WhiteSpaceOptions_enum_constant_arguments;
//	public static String WhiteSpaceOptions_enum_declaration;
//	public static String WhiteSpaceOptions_annotation_modifier;
//	public static String WhiteSpaceOptions_annotation_modifier_args;
//	public static String WhiteSpaceOptions_annotation_type_member;
//	public static String WhiteSpaceOptions_annotation_type;
//	public static String WhiteSpaceOptions_type_cast;
//	public static String WhiteSpaceOptions_parameterized_type;
//	public static String WhiteSpaceOptions_type_arguments;
//	public static String WhiteSpaceOptions_type_parameters;
//	public static String WhiteSpaceOptions_vararg_parameter;
//	public static String WhiteSpaceOptions_closing_paren;
//	public static String WhiteSpaceOptions_opening_brace;
//	public static String WhiteSpaceOptions_closing_brace;
//	public static String WhiteSpaceOptions_opening_bracket;
//	public static String WhiteSpaceOptions_closing_bracket;
//	public static String WhiteSpaceOptions_class_decl;
//	public static String WhiteSpaceOptions_anon_class_decl;
//	public static String WhiteSpaceOptions_initializer;
//	public static String WhiteSpaceOptions_block;
//	public static String WhiteSpaceOptions_array_decl;
//	public static String WhiteSpaceOptions_array_element_access;
//	public static String WhiteSpaceOptions_array_alloc;
//	public static String WhiteSpaceOptions_array_init;
//	public static String WhiteSpaceOptions_arguments;
//	public static String WhiteSpaceOptions_initialization;
//	public static String WhiteSpaceOptions_incrementation;
//	public static String WhiteSpaceOptions_parameters;
//	public static String WhiteSpaceOptions_explicit_constructor_call;
//	public static String WhiteSpaceOptions_alloc_expr;
//	public static String WhiteSpaceOptions_throws;
//	public static String WhiteSpaceOptions_mult_decls;
//	public static String WhiteSpaceOptions_local_vars;
//	public static String WhiteSpaceOptions_fields;
//	public static String WhiteSpaceOptions_implements_clause;
//	public static String WhiteSpaceOptions_colon;
//	public static String WhiteSpaceOptions_conditional;
//	public static String WhiteSpaceOptions_wildcard;
//	public static String WhiteSpaceOptions_label;
//	public static String WhiteSpaceOptions_comma;
//	public static String WhiteSpaceOptions_semicolon;
//	public static String WhiteSpaceOptions_question_mark;
//	public static String WhiteSpaceOptions_between_empty_parens;
//	public static String WhiteSpaceOptions_between_empty_braces;
//	public static String WhiteSpaceOptions_between_empty_brackets;
//	public static String WhiteSpaceOptions_constructor_decl;
//	public static String WhiteSpaceOptions_method_decl;
//	public static String WhiteSpaceOptions_case;
//	public static String WhiteSpaceOptions_default;
//	public static String WhiteSpaceOptions_statements;
//	public static String WhiteSpaceOptions_before_opening_paren;
//	public static String WhiteSpaceOptions_after_opening_paren;
//	public static String WhiteSpaceOptions_before_closing_paren;
//	public static String WhiteSpaceOptions_after_closing_paren;
//	public static String WhiteSpaceOptions_before_opening_brace;
//	public static String WhiteSpaceOptions_after_opening_brace;
//	public static String WhiteSpaceOptions_after_closing_brace;
//	public static String WhiteSpaceOptions_before_closing_brace;
//	public static String WhiteSpaceOptions_before_opening_bracket;
//	public static String WhiteSpaceOptions_after_opening_bracket;
//	public static String WhiteSpaceOptions_before_closing_bracket;
//	public static String WhiteSpaceOptions_before_opening_angle_bracket;
//	public static String WhiteSpaceOptions_after_opening_angle_bracket;
//	public static String WhiteSpaceOptions_before_closing_angle_bracket;
//	public static String WhiteSpaceOptions_after_closing_angle_bracket;
//	public static String WhiteSpaceOptions_before_operator;
//	public static String WhiteSpaceOptions_after_operator;
//	public static String WhiteSpaceOptions_before_comma;
//	public static String WhiteSpaceOptions_after_comma;
//	public static String WhiteSpaceOptions_after_colon;
//	public static String WhiteSpaceOptions_before_colon;
//	public static String WhiteSpaceOptions_before_semicolon;
//	public static String WhiteSpaceOptions_after_semicolon;
//	public static String WhiteSpaceOptions_before_question_mark;
//	public static String WhiteSpaceOptions_after_question_mark;
//	public static String WhiteSpaceOptions_before_at;
//	public static String WhiteSpaceOptions_after_at;
//	public static String WhiteSpaceOptions_before_and;
//	public static String WhiteSpaceOptions_after_and;
//	public static String WhiteSpaceOptions_before_ellipsis;
//	public static String WhiteSpaceOptions_after_ellipsis;
//	public static String WhiteSpaceOptions_return_with_parenthesized_expression;
//	public static String LineWrappingTabPage_compact_if_else;
//	public static String LineWrappingTabPage_extends_clause;
//	public static String LineWrappingTabPage_enum_constant_arguments;
//	public static String LineWrappingTabPage_enum_constants;
//	public static String LineWrappingTabPage_implements_clause;
//	public static String LineWrappingTabPage_parameters;
//	public static String LineWrappingTabPage_arguments;
//	public static String LineWrappingTabPage_qualified_invocations;
//	public static String LineWrappingTabPage_throws_clause;
//	public static String LineWrappingTabPage_object_allocation;
//	public static String LineWrappingTabPage_qualified_object_allocation;
//	public static String LineWrappingTabPage_array_init;
//	public static String LineWrappingTabPage_explicit_constructor_invocations;
//	public static String LineWrappingTabPage_conditionals;
//	public static String LineWrappingTabPage_binary_exprs;
//	public static String LineWrappingTabPage_indentation_default;
//	public static String LineWrappingTabPage_indentation_on_column;
//	public static String LineWrappingTabPage_indentation_by_one;
//	public static String LineWrappingTabPage_class_decls;
//	public static String LineWrappingTabPage_method_decls;
//	public static String LineWrappingTabPage_constructor_decls;
//	public static String LineWrappingTabPage_function_calls;
//	public static String LineWrappingTabPage_expressions;
//	public static String LineWrappingTabPage_statements;
//	public static String LineWrappingTabPage_enum_decls;
//	public static String LineWrappingTabPage_wrapping_policy_label_text;
//	public static String LineWrappingTabPage_indentation_policy_label_text;
//	public static String LineWrappingTabPage_force_split_checkbox_text;
//	public static String LineWrappingTabPage_force_split_checkbox_multi_text;
//	public static String LineWrappingTabPage_line_width_for_preview_label_text;
//	public static String LineWrappingTabPage_group;
//	public static String LineWrappingTabPage_multi_group;
//	public static String LineWrappingTabPage_multiple_selections;
//	public static String LineWrappingTabPage_occurences;
//	public static String LineWrappingTabPage_splitting_do_not_split;
//	public static String LineWrappingTabPage_splitting_wrap_when_necessary;
//	public static String LineWrappingTabPage_splitting_always_wrap_first_others_when_necessary;
//	public static String LineWrappingTabPage_splitting_wrap_always;
//	public static String LineWrappingTabPage_splitting_wrap_always_indent_all_but_first;
//	public static String LineWrappingTabPage_splitting_wrap_always_except_first_only_if_necessary;
//	public static String LineWrappingTabPage_width_indent;
//	public static String LineWrappingTabPage_width_indent_option_max_line_width;
//	public static String LineWrappingTabPage_width_indent_option_default_indent_wrapped;
//	public static String LineWrappingTabPage_width_indent_option_default_indent_array;
//	public static String LineWrappingTabPage_error_invalid_value;
//	public static String LineWrappingTabPage_enum_superinterfaces;
//	public static String LineWrappingTabPage_assignment_alignment;
	public static String AlreadyExistsDialog_message_profile_already_exists;
	public static String AlreadyExistsDialog_message_profile_name_empty;
	public static String AlreadyExistsDialog_dialog_title;
	public static String AlreadyExistsDialog_dialog_label;
	public static String AlreadyExistsDialog_rename_radio_button_desc;
	public static String AlreadyExistsDialog_overwrite_radio_button_desc;
//	public static String BlankLinesTabPage_preview_header;
//	public static String BlankLinesTabPage_compilation_unit_group_title;
//	public static String BlankLinesTabPage_compilation_unit_option_before_package;
//	public static String BlankLinesTabPage_compilation_unit_option_after_package;
//	public static String BlankLinesTabPage_compilation_unit_option_before_import;
//	public static String BlankLinesTabPage_compilation_unit_option_after_import;
//	public static String BlankLinesTabPage_compilation_unit_option_between_type_declarations;
//	public static String BlankLinesTabPage_class_group_title;
//	public static String BlankLinesTabPage_class_option_before_first_decl;
//	public static String BlankLinesTabPage_class_option_before_decls_of_same_kind;
//	public static String BlankLinesTabPage_class_option_before_member_class_decls;
//	public static String BlankLinesTabPage_class_option_before_field_decls;
//	public static String BlankLinesTabPage_class_option_before_method_decls;
//	public static String BlankLinesTabPage_class_option_at_beginning_of_method_body;
//	public static String BlankLinesTabPage_blank_lines_group_title;
//	public static String BlankLinesTabPage_blank_lines_option_empty_lines_to_preserve;
//	public static String BracesTabPage_preview_header;
//	public static String BracesTabPage_position_same_line;
//	public static String BracesTabPage_position_next_line;
//	public static String BracesTabPage_position_next_line_indented;
//	public static String BracesTabPage_position_next_line_on_wrap;
//	public static String BracesTabPage_group_brace_positions_title;
//	public static String BracesTabPage_option_class_declaration;
//	public static String BracesTabPage_option_anonymous_class_declaration;
//	public static String BracesTabPage_option_method_declaration;
//	public static String BracesTabPage_option_constructor_declaration;
//	public static String BracesTabPage_option_blocks;
//	public static String BracesTabPage_option_blocks_in_case;
//	public static String BracesTabPage_option_switch_case;
//	public static String BracesTabPage_option_array_initializer;
//	public static String BracesTabPage_option_keep_empty_array_initializer_on_one_line;
//	public static String BracesTabPage_option_enum_declaration;
//	public static String BracesTabPage_option_enumconst_declaration;
//	public static String BracesTabPage_option_annotation_type_declaration;
	public static String CodingStyleConfigurationBlock_save_profile_dialog_title;
	public static String CodingStyleConfigurationBlock_save_profile_error_title;
	public static String CodingStyleConfigurationBlock_save_profile_error_message;
	public static String CodingStyleConfigurationBlock_load_profile_dialog_title;
	public static String CodingStyleConfigurationBlock_load_profile_error_title;
	public static String CodingStyleConfigurationBlock_load_profile_error_message;
	public static String CodingStyleConfigurationBlock_load_profile_error_too_new_title;
	public static String CodingStyleConfigurationBlock_load_profile_error_too_new_message;
	public static String CodingStyleConfigurationBlock_preview_title;
	public static String CodingStyleConfigurationBlock_save_profile_overwrite_title;
	public static String CodingStyleConfigurationBlock_save_profile_overwrite_message;
	public static String CodingStyleConfigurationBlock_edit_button_desc;
	public static String CodingStyleConfigurationBlock_show_button_desc;
	public static String CodingStyleConfigurationBlock_rename_button_desc;
	public static String CodingStyleConfigurationBlock_remove_button_desc;
	public static String CodingStyleConfigurationBlock_new_button_desc;
	public static String CodingStyleConfigurationBlock_load_button_desc;
	public static String CodingStyleConfigurationBlock_save_button_desc;
	public static String CodingStyleConfigurationBlock_preview_label_text;
	public static String CodingStyleConfigurationBlock_error_reading_xml_message;
	public static String CodingStyleConfigurationBlock_error_serializing_xml_message;
	public static String CodingStyleConfigurationBlock_delete_confirmation_title;
	public static String CodingStyleConfigurationBlock_delete_confirmation_question;
	public static String CustomCodeFormatterBlock_formatter_name;
	public static String CustomCodeFormatterBlock_no_formatter;
//	public static String CommentsTabPage_group1_title;
//	public static String CommentsTabPage_enable_comment_formatting;
//	public static String CommentsTabPage_format_header;
//	public static String CommentsTabPage_format_html;
//	public static String CommentsTabPage_format_code_snippets;
//	public static String CommentsTabPage_group2_title;
//	public static String CommentsTabPage_clear_blank_lines;
//	public static String CommentsTabPage_indent_description_after_param;
//	public static String CommentsTabPage_new_line_after_param_tags;
//	public static String CommentsTabPage_group3_title;
//	public static String CommentsTabPage_line_width;
//	public static String ControlStatementsTabPage_preview_header;
//	public static String ControlStatementsTabPage_general_group_title;
//	public static String ControlStatementsTabPage_general_group_insert_new_line_before_else_statements;
//	public static String ControlStatementsTabPage_general_group_insert_new_line_before_catch_statements;
//	public static String ControlStatementsTabPage_general_group_insert_new_line_before_finally_statements;
//	public static String ControlStatementsTabPage_general_group_insert_new_line_before_while_in_do_statements;
//	public static String ControlStatementsTabPage_if_else_group_title;
//	public static String ControlStatementsTabPage_if_else_group_keep_then_on_same_line;
//	public static String ControlStatementsTabPage_if_else_group_keep_simple_if_on_one_line;
//	public static String ControlStatementsTabPage_if_else_group_keep_else_on_same_line;
//	public static String ControlStatementsTabPage_if_else_group_keep_else_if_on_one_line;
//	public static String ControlStatementsTabPage_if_else_group_keep_guardian_clause_on_one_line;
	public static String CreateProfileDialog_status_message_profile_with_this_name_already_exists;
	public static String CreateProfileDialog_status_message_profile_name_is_empty;
	public static String CreateProfileDialog_dialog_title;
	public static String CreateProfileDialog_profile_name_label_text;
	public static String CreateProfileDialog_base_profile_label_text;
	public static String CreateProfileDialog_open_edit_dialog_checkbox_text;
	public static String IndentationTabPage_preview_header;
	public static String IndentationTabPage_general_group_title;
	public static String IndentationTabPage_general_group_option_tab_policy;
	public static String IndentationTabPage_general_group_option_tab_policy_SPACE;
	public static String IndentationTabPage_general_group_option_tab_policy_TAB;
	public static String IndentationTabPage_general_group_option_tab_policy_MIXED;
	public static String IndentationTabPage_general_group_option_tab_size;
	public static String IndentationTabPage_general_group_option_indent_size;
	public static String IndentationTabPage_field_alignment_group_title;
	public static String IndentationTabPage_field_alignment_group_align_fields_in_columns;
	public static String IndentationTabPage_indent_group_title;
	public static String IndentationTabPage_class_group_option_indent_declarations_within_class_body;
	public static String IndentationTabPage_class_group_option_indent_declarations_within_enum_const;
	public static String IndentationTabPage_class_group_option_indent_declarations_within_enum_decl;
	public static String IndentationTabPage_block_group_option_indent_statements_compare_to_body;
	public static String IndentationTabPage_block_group_option_indent_statements_compare_to_block;
	public static String IndentationTabPage_switch_group_option_indent_statements_within_switch_body;
	public static String IndentationTabPage_switch_group_option_indent_statements_within_case_body;
	public static String IndentationTabPage_switch_group_option_indent_break_statements;
    public static String IndentationTabPage_indent_empty_lines;
	public static String IndentationTabPage_use_tabs_only_for_leading_indentations;
	public static String ModifyDialog_dialog_title;
	public static String ModifyDialog_apply_button;
	public static String ModifyDialog_dialog_show_title;
	public static String ModifyDialog_dialog_show_warning_builtin;
	public static String ModifyDialog_tabpage_braces_title;
	public static String ModifyDialog_tabpage_indentation_title;
	public static String ModifyDialog_tabpage_whitespace_title;
	public static String ModifyDialog_tabpage_blank_lines_title;
	public static String ModifyDialog_tabpage_new_lines_title;
	public static String ModifyDialog_tabpage_control_statements_title;
	public static String ModifyDialog_tabpage_line_wrapping_title;
	public static String ModifyDialog_tabpage_comments_title;
	public static String ModifyDialogTabPage_preview_label_text;
	public static String ModifyDialogTabPage_error_msg_values_text_unassigned;
	public static String ModifyDialogTabPage_error_msg_values_items_text_unassigned;
	public static String ModifyDialogTabPage_NumberPreference_error_invalid_key;
	public static String ModifyDialogTabPage_NumberPreference_error_invalid_value;
//	public static String NewLinesTabPage_preview_header;
//	public static String NewLinesTabPage_newlines_group_title;
//	public static String NewLinesTabPage_newlines_group_option_empty_class_body;
//	public static String NewLinesTabPage_newlines_group_option_empty_annotation_decl_body;
//	public static String NewLinesTabPage_newlines_group_option_empty_anonymous_class_body;
//	public static String NewLinesTabPage_newlines_group_option_empty_enum_declaration;
//	public static String NewLinesTabPage_newlines_group_option_empty_enum_constant;
//	public static String NewLinesTabPage_newlines_group_option_empty_method_body;
//	public static String NewLinesTabPage_newlines_group_option_empty_block;
//	public static String NewLinesTabPage_newlines_group_option_empty_end_of_file;
//	public static String NewLinesTabPage_empty_statement_group_title;
//	public static String NewLinesTabPage_emtpy_statement_group_option_empty_statement_on_new_line;
//	public static String NewLinesTabPage_arrayInitializer_group_title;
//	public static String NewLinesTabPage_array_group_option_after_opening_brace_of_array_initializer;
//	public static String NewLinesTabPage_array_group_option_before_closing_brace_of_array_initializer;
//	public static String NewLinesTabPage_annotations_group_title;
//	public static String NewLinesTabPage_annotations_group_option_after_annotation;
	public static String ProfileManager_default_profile_name;
	public static String ProfileManager_unmanaged_profile;
	public static String ProfileManager_unmanaged_profile_with_name;
	public static String RenameProfileDialog_status_message_profile_with_this_name_already_exists;
	public static String RenameProfileDialog_status_message_profile_name_empty;
	public static String RenameProfileDialog_dialog_title;
	public static String RenameProfileDialog_dialog_label_enter_a_new_name;

	public static String CPreview_formatter_exception;

	static {
		NLS.initializeMessages(BUNDLE_NAME, FormatterMessages.class);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.util.Map;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.formatter.FormattingContextProperties;
import org.eclipse.jface.text.formatter.IContentFormatter;
import org.eclipse.jface.text.formatter.IContentFormatterExtension;
import org.eclipse.jface.text.formatter.IFormattingContext;

import org.eclipse.cdt.internal.ui.ICStatusConstants;
import org.eclipse.cdt.internal.ui.text.comment.CommentFormattingContext;

import org.eclipse.cdt.ui.CUIPlugin;


public class CompilationUnitPreview extends CPreview {

    private String fPreviewText;

    /**
     * @param workingValues
     * @param parent
     */
    public CompilationUnitPreview(Map workingValues, Composite parent) {
        super(workingValues, parent);
    }

    protected void doFormatPreview() {
        if (fPreviewText == null) {
            fPreviewDocument.set(""); //$NON-NLS-1$
            return;
        }
        fPreviewDocument.set(fPreviewText);
		
		fSourceViewer.setRedraw(false);
		final IFormattingContext context = new CommentFormattingContext();
		try {
			final IContentFormatter formatter =	fViewerConfiguration.getContentFormatter(fSourceViewer);
			if (formatter instanceof IContentFormatterExtension) {
				final IContentFormatterExtension extension = (IContentFormatterExtension) formatter;
				context.setProperty(FormattingContextProperties.CONTEXT_PREFERENCES, fWorkingValues);
				context.setProperty(FormattingContextProperties.CONTEXT_DOCUMENT, Boolean.valueOf(true));
				extension.format(fPreviewDocument, context);
			} else
				formatter.format(fPreviewDocument, new Region(0, fPreviewDocument.getLength()));
		} catch (Exception e) {
			final IStatus status= new Status(IStatus.ERROR, CUIPlugin.getPluginId(), ICStatusConstants.INTERNAL_ERROR, 
				FormatterMessages.CPreview_formatter_exception, e); 
			CUIPlugin.getDefault().log(status);
		} finally {
		    context.dispose();
		    fSourceViewer.setRedraw(true);
		}
    }
    
    public void setPreviewText(String previewText) {
//        if (previewText == null) throw new IllegalArgumentException();
        fPreviewText= previewText;
        update();
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.text.comment;

import org.eclipse.jface.text.formatter.FormattingContext;

import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;

/**
 * Formatting context for the comment formatter.
 *
 * @since 4.0
 */
public class CommentFormattingContext extends FormattingContext {

	/*
	 * @see org.eclipse.jface.text.formatter.IFormattingContext#getPreferenceKeys()
	 */
	public String[] getPreferenceKeys() {
		return new String[] {
			    DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT,
			    DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_HEADER,
			    DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_SOURCE,
			    DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH,
			    DefaultCodeFormatterConstants.FORMATTER_COMMENT_CLEAR_BLANK_LINES};
	}


	/*
	 * @see org.eclipse.jface.text.formatter.IFormattingContext#isBooleanPreference(java.lang.String)
	 */
	public boolean isBooleanPreference(String key) {
		return !key.equals(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH);
	}

	/*
	 * @see org.eclipse.jface.text.formatter.IFormattingContext#isIntegerPreference(java.lang.String)
	 */
	public boolean isIntegerPreference(String key) {
		return key.equals(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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 Corporatio - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;

import org.eclipse.cdt.internal.ui.ICHelpContextIds;
import org.eclipse.cdt.ui.CUIPlugin;

/**
 * The page for setting the editor options.
 */
public final class SmartTypingPreferencePage extends AbstractConfigurationBlockPreferencePage {
	
	/*
	 * @see org.eclipse.ui.internal.editors.text.AbstractConfigureationBlockPreferencePage#getHelpId()
	 */
	protected String getHelpId() {
		return ICHelpContextIds.C_EDITOR_TYPING_PAGE;
	}

	/*
	 * @see org.eclipse.ui.internal.editors.text.AbstractConfigurationBlockPreferencePage#setDescription()
	 */
	protected void setDescription() {
		String description= PreferencesMessages.CEditorPreferencePage_typing_tabTitle; 
		setDescription(description);
	}
	
	/*
	 * @see org.org.eclipse.ui.internal.editors.text.AbstractConfigurationBlockPreferencePage#setPreferenceStore()
	 */
	protected void setPreferenceStore() {
		setPreferenceStore(CUIPlugin.getDefault().getPreferenceStore());
	}
	
	
	protected Label createDescriptionLabel(Composite parent) {
		return null; // no description for new look.
	}
	
	/*
	 * @see org.eclipse.ui.internal.editors.text.AbstractConfigureationBlockPreferencePage#createConfigurationBlock(org.eclipse.ui.internal.editors.text.OverlayPreferenceStore)
	 */
	protected IPreferenceConfigurationBlock createConfigurationBlock(OverlayPreferenceStore overlayPreferenceStore) {
		return new SmartTypingConfigurationBlock(overlayPreferenceStore);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.util.Iterator;
import java.util.Map;

import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.CustomProfile;


public class ProfileVersioner {
	
	public static final int VERSION_1= 1; // < 20040113 (includes M6)
	
	public static final int CURRENT_VERSION= VERSION_1;
	
	public static int getVersionStatus(CustomProfile profile) {
		final int version= profile.getVersion();
		if (version < CURRENT_VERSION) 
			return -1;
		else if (version > CURRENT_VERSION)
			return 1;
		else 
			return 0;
	}
	
	public static void updateAndComplete(CustomProfile profile) {
		final Map oldSettings= profile.getSettings();
		Map newSettings= updateAndComplete(oldSettings, profile.getVersion());
		profile.setVersion(CURRENT_VERSION);
		profile.setSettings(newSettings);
	}
	
	public static Map updateAndComplete(Map oldSettings, int version) {
		final Map newSettings= ProfileManager.getDefaultSettings();
		
		switch (version) {
		    
		default:
		    for (final Iterator iter= oldSettings.keySet().iterator(); iter.hasNext(); ) {
		        final String key= (String)iter.next();
		        if (!newSettings.containsKey(key)) 
		            continue;
		        
		        final String value= (String)oldSettings.get(key);
		        if (value != null) {
		            newSettings.put(key, value);
		        }
		    }
		}
		return newSettings;
	}
 }




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     istvan@benedek-home.de - 103706 [formatter] indent empty lines
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.util.Map;
import java.util.Observable;
import java.util.Observer;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;

import org.eclipse.jface.text.Assert;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;


public class IndentationTabPage extends ModifyDialogTabPage {
	
//	private final String PREVIEW=
//	createPreviewHeader(FormatterMessages.IndentationTabPage_preview_header) + 
//	"class Example {" +	//$NON-NLS-1$
//	"  int [] myArray= {1,2,3,4,5,6};" + //$NON-NLS-1$
//	"  int theInt= 1;" + //$NON-NLS-1$
//	"  String someString= \"Hello\";" + //$NON-NLS-1$
//	"  double aDouble= 3.0;" + //$NON-NLS-1$
//	"  void foo(int a, int b, int c, int d, int e, int f) {" + //$NON-NLS-1$
//	"    switch(a) {" + //$NON-NLS-1$
//	"    case 0: " + //$NON-NLS-1$
//	"      Other.doFoo();" + //$NON-NLS-1$
//	"      break;" + //$NON-NLS-1$
//	"    default:" + //$NON-NLS-1$
//	"      Other.doBaz();" + //$NON-NLS-1$
//	"    }" + //$NON-NLS-1$
//	"  }" + //$NON-NLS-1$
//	"  void bar(List v) {" + //$NON-NLS-1$
//	"    for (int i= 0; i < 10; i++) {" + //$NON-NLS-1$
// 	"      v.add(new Integer(i));" + //$NON-NLS-1$
// 	"    }" + //$NON-NLS-1$
//	"  }" + //$NON-NLS-1$
//	"}" + //$NON-NLS-1$
//	"\n" + //$NON-NLS-1$
//	"enum MyEnum {" + //$NON-NLS-1$
//	"    UNDEFINED(0) {" + //$NON-NLS-1$
//	"        void foo() {}" + //$NON-NLS-1$
//	"    }" + //$NON-NLS-1$
//	"}" + //$NON-NLS-1$
//	"@interface MyAnnotation {" + //$NON-NLS-1$
//	"    int count() default 1;" + //$NON-NLS-1$
//	"}";//$NON-NLS-1$
	
//	private CompilationUnitPreview fPreview;
	private String fOldTabChar= null;
	
	public IndentationTabPage(ModifyDialog modifyDialog, Map workingValues) {
		super(modifyDialog, workingValues);
	}

	protected void doCreatePreferences(Composite composite, int numColumns) {

		final Group generalGroup= createGroup(numColumns, composite, FormatterMessages.IndentationTabPage_general_group_title); 
		
		final String[] tabPolicyValues= new String[] {CCorePlugin.SPACE, CCorePlugin.TAB, DefaultCodeFormatterConstants.MIXED};
		final String[] tabPolicyLabels= new String[] {
				FormatterMessages.IndentationTabPage_general_group_option_tab_policy_SPACE, 
				FormatterMessages.IndentationTabPage_general_group_option_tab_policy_TAB, 
				FormatterMessages.IndentationTabPage_general_group_option_tab_policy_MIXED
		};
		final ComboPreference tabPolicy= createComboPref(generalGroup, numColumns, FormatterMessages.IndentationTabPage_general_group_option_tab_policy, DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, tabPolicyValues, tabPolicyLabels);
		final CheckboxPreference onlyForLeading= createCheckboxPref(generalGroup, numColumns, FormatterMessages.IndentationTabPage_use_tabs_only_for_leading_indentations, DefaultCodeFormatterConstants.FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS, FALSE_TRUE);
		final NumberPreference indentSize= createNumberPref(generalGroup, numColumns, FormatterMessages.IndentationTabPage_general_group_option_indent_size, DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, 0, 32); 
		final NumberPreference tabSize= createNumberPref(generalGroup, numColumns, FormatterMessages.IndentationTabPage_general_group_option_tab_size, DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, 0, 32);
		
		String tabchar= (String) fWorkingValues.get(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR);
		updateTabPreferences(tabchar, tabSize, indentSize, onlyForLeading);
		tabPolicy.addObserver(new Observer() {
			public void update(Observable o, Object arg) {
				updateTabPreferences((String) arg, tabSize, indentSize, onlyForLeading);
			}
		});
		tabSize.addObserver(new Observer() {
			public void update(Observable o, Object arg) {
				indentSize.updateWidget();
			}
		});
		
//		final Group typeMemberGroup= createGroup(numColumns, composite, FormatterMessages.IndentationTabPage_field_alignment_group_title); 
//		createCheckboxPref(typeMemberGroup, numColumns, FormatterMessages.IndentationTabPage_field_alignment_group_align_fields_in_columns, DefaultCodeFormatterConstants.FORMATTER_ALIGN_TYPE_MEMBERS_ON_COLUMNS, FALSE_TRUE); 
		
		final Group classGroup = createGroup(numColumns, composite, FormatterMessages.IndentationTabPage_indent_group_title); 
		createCheckboxPref(classGroup, numColumns, FormatterMessages.IndentationTabPage_class_group_option_indent_declarations_within_class_body, DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER, FALSE_TRUE); 
		createCheckboxPref(classGroup, numColumns, FormatterMessages.IndentationTabPage_class_group_option_indent_declarations_within_enum_decl, DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_DECLARATION_HEADER, FALSE_TRUE);
		createCheckboxPref(classGroup, numColumns, FormatterMessages.IndentationTabPage_class_group_option_indent_declarations_within_enum_const, DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_CONSTANT_HEADER, FALSE_TRUE); 

		createCheckboxPref(classGroup, numColumns, FormatterMessages.IndentationTabPage_block_group_option_indent_statements_compare_to_body, DefaultCodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY, FALSE_TRUE); 
		createCheckboxPref(classGroup, numColumns, FormatterMessages.IndentationTabPage_block_group_option_indent_statements_compare_to_block, DefaultCodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK, FALSE_TRUE); 

		createCheckboxPref(classGroup, numColumns, FormatterMessages.IndentationTabPage_switch_group_option_indent_statements_within_switch_body, DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, FALSE_TRUE); 
		createCheckboxPref(classGroup, numColumns, FormatterMessages.IndentationTabPage_switch_group_option_indent_statements_within_case_body, DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, FALSE_TRUE); 
		createCheckboxPref(classGroup, numColumns, FormatterMessages.IndentationTabPage_switch_group_option_indent_break_statements, DefaultCodeFormatterConstants.FORMATTER_INDENT_BREAKS_COMPARE_TO_CASES, FALSE_TRUE); 
        createCheckboxPref(classGroup, numColumns, FormatterMessages.IndentationTabPage_indent_empty_lines, DefaultCodeFormatterConstants.FORMATTER_INDENT_EMPTY_LINES, FALSE_TRUE); 
	}
	
	public void initializePage() {
//	    fPreview.setPreviewText(PREVIEW);
	}
	
    /* (non-Javadoc)
     * @see org.eclipse.cdt.internal.ui.preferences.formatter.ModifyDialogTabPage#doCreateCPreview(org.eclipse.swt.widgets.Composite)
     */
    protected CPreview doCreateCPreview(Composite parent) {
//        fPreview= new CompilationUnitPreview(fWorkingValues, parent);
//        return fPreview;
    	return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.cdt.internal.ui.preferences.formatter.ModifyDialogTabPage#doUpdatePreview()
     */
    protected void doUpdatePreview() {
//        fPreview.update();
    }

	private void updateTabPreferences(String tabPolicy, NumberPreference tabPreference, NumberPreference indentPreference, CheckboxPreference onlyForLeading) {
		/*
		 * If the tab-char is SPACE (or TAB), INDENTATION_SIZE
		 * preference is not used by the core formatter. We piggy back the
		 * visual tab length setting in that preference in that case. If the
		 * user selects MIXED, we use the previous TAB_SIZE preference as the
		 * new INDENTATION_SIZE (as this is what it really is) and set the 
		 * visual tab size to the value piggy backed in the INDENTATION_SIZE
		 * preference. See also CodeFormatterUtil. 
		 */
		if (DefaultCodeFormatterConstants.MIXED.equals(tabPolicy)) {
			if (CCorePlugin.SPACE.equals(fOldTabChar) || CCorePlugin.TAB.equals(fOldTabChar))
				swapTabValues();
			tabPreference.setEnabled(true);
			tabPreference.setKey(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE);
			indentPreference.setEnabled(true);
			indentPreference.setKey(DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE);
			onlyForLeading.setEnabled(true);
		} else if (CCorePlugin.SPACE.equals(tabPolicy)) {
			if (DefaultCodeFormatterConstants.MIXED.equals(fOldTabChar))
				swapTabValues();
			tabPreference.setEnabled(true);
			tabPreference.setKey(DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE);
			indentPreference.setEnabled(true);
			indentPreference.setKey(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE);
			onlyForLeading.setEnabled(false);
		} else if (CCorePlugin.TAB.equals(tabPolicy)) {
			if (DefaultCodeFormatterConstants.MIXED.equals(fOldTabChar))
				swapTabValues();
			tabPreference.setEnabled(true);
			tabPreference.setKey(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE);
			indentPreference.setEnabled(false);
			indentPreference.setKey(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE);
			onlyForLeading.setEnabled(true);
		} else {
			Assert.isTrue(false);
		}
		fOldTabChar= tabPolicy;
	}

	private void swapTabValues() {
		Object tabSize= fWorkingValues.get(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE);
		Object indentSize= fWorkingValues.get(DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE);
		fWorkingValues.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, indentSize);
		fWorkingValues.put(DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE, tabSize);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;

import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.StatusDialog;
import org.eclipse.jface.window.Window;

import org.eclipse.cdt.internal.ui.util.Messages;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.Profile;

public class ModifyDialog extends StatusDialog {
    
    /**
     * The keys to retrieve the preferred area from the dialog settings.
     */
    private static final String DS_KEY_PREFERRED_WIDTH= CUIPlugin.PLUGIN_ID + "formatter_page.modify_dialog.preferred_width"; //$NON-NLS-1$
    private static final String DS_KEY_PREFERRED_HEIGHT= CUIPlugin.PLUGIN_ID + "formatter_page.modify_dialog.preferred_height"; //$NON-NLS-1$
    private static final String DS_KEY_PREFERRED_X= CUIPlugin.PLUGIN_ID + "formatter_page.modify_dialog.preferred_x"; //$NON-NLS-1$
    private static final String DS_KEY_PREFERRED_Y= CUIPlugin.PLUGIN_ID + "formatter_page.modify_dialog.preferred_y"; //$NON-NLS-1$
    
    /**
     * The key to store the number (beginning at 0) of the tab page which had the 
     * focus last time.
     */
    private static final String DS_KEY_LAST_FOCUS= CUIPlugin.PLUGIN_ID + "formatter_page.modify_dialog.last_focus"; //$NON-NLS-1$ 

	private final String fTitle;
	
	private final boolean fNewProfile;

	private Profile fProfile;
	private final Map fWorkingValues;
	
	private IStatus fStandardStatus;
	
	protected final List fTabPages;
	
	final IDialogSettings fDialogSettings;
//	private TabFolder fTabFolder;
	private ProfileManager fProfileManager;
//	private Button fApplyButton;
		
	protected ModifyDialog(Shell parentShell, Profile profile, ProfileManager profileManager, boolean newProfile) {
		super(parentShell);
		fProfileManager= profileManager;
		fNewProfile= newProfile;
		setShellStyle(getShellStyle() | SWT.RESIZE | SWT.MAX );
				
		fProfile= profile;
		if (fProfile.isBuiltInProfile()) {
		    fStandardStatus= new Status(IStatus.INFO, CUIPlugin.getPluginId(), IStatus.OK, FormatterMessages.ModifyDialog_dialog_show_warning_builtin, null); 
		    fTitle= Messages.format(FormatterMessages.ModifyDialog_dialog_show_title, profile.getName()); 
		} else {
		    fStandardStatus= new Status(IStatus.OK, CUIPlugin.getPluginId(), IStatus.OK, "", null); //$NON-NLS-1$
		    fTitle= Messages.format(FormatterMessages.ModifyDialog_dialog_title, profile.getName()); 
		}
		fWorkingValues= new HashMap(fProfile.getSettings());
		updateStatus(fStandardStatus);
		setStatusLineAboveButtons(false);
		fTabPages= new ArrayList();
		fDialogSettings= CUIPlugin.getDefault().getDialogSettings();	
	}
	
	public void create() {
		super.create();
		int lastFocusNr= 0;
		try {
			lastFocusNr= fDialogSettings.getInt(DS_KEY_LAST_FOCUS);
			if (lastFocusNr < 0) lastFocusNr= 0;
			if (lastFocusNr > fTabPages.size() - 1) lastFocusNr= fTabPages.size() - 1;
		} catch (NumberFormatException x) {
			lastFocusNr= 0;
		}
		
		if (!fNewProfile) {
//			fTabFolder.setSelection(lastFocusNr);
//			((ModifyDialogTabPage)fTabFolder.getSelection()[0].getData()).setInitialFocus();
		}
	}
	
	protected void configureShell(Shell shell) {
		super.configureShell(shell);
		shell.setText(fTitle);
	}

	protected Control createDialogArea(Composite parent) {
		
		final Composite composite= (Composite)super.createDialogArea(parent);

		ModifyDialogTabPage tabPage = new IndentationTabPage(this, fWorkingValues);
		tabPage.createContents(composite);
//		fTabFolder = new TabFolder(composite, SWT.NONE);
//		fTabFolder.setFont(composite.getFont());
//		fTabFolder.setLayoutData(new GridData(GridData.FILL_BOTH));
//
//		addTabPage(fTabFolder, FormatterMessages.ModifyDialog_tabpage_indentation_title, new IndentationTabPage(this, fWorkingValues)); 
//		addTabPage(fTabFolder, FormatterMessages.ModifyDialog_tabpage_braces_title, new BracesTabPage(this, fWorkingValues)); 
//		addTabPage(fTabFolder, FormatterMessages.ModifyDialog_tabpage_whitespace_title, new WhiteSpaceTabPage(this, fWorkingValues)); 
//		addTabPage(fTabFolder, FormatterMessages.ModifyDialog_tabpage_blank_lines_title, new BlankLinesTabPage(this, fWorkingValues)); 
//		addTabPage(fTabFolder, FormatterMessages.ModifyDialog_tabpage_new_lines_title, new NewLinesTabPage(this, fWorkingValues)); 
//		addTabPage(fTabFolder, FormatterMessages.ModifyDialog_tabpage_control_statements_title, new ControlStatementsTabPage(this, fWorkingValues)); 
//		addTabPage(fTabFolder, FormatterMessages.ModifyDialog_tabpage_line_wrapping_title, new LineWrappingTabPage(this, fWorkingValues)); 
//		addTabPage(fTabFolder, FormatterMessages.ModifyDialog_tabpage_comments_title, new CommentsTabPage(this, fWorkingValues)); 
		
		applyDialogFont(composite);
		
//		fTabFolder.addSelectionListener(new SelectionListener() {
//			public void widgetDefaultSelected(SelectionEvent e) {}
//			public void widgetSelected(SelectionEvent e) {
//				final TabItem tabItem= (TabItem)e.item;
//				final ModifyDialogTabPage page= (ModifyDialogTabPage)tabItem.getData();
////				page.fSashForm.setWeights();
//				fDialogSettings.put(DS_KEY_LAST_FOCUS, fTabPages.indexOf(page));
//				page.makeVisible();
//			}
//		});
		return composite;
	}
	
	public void updateStatus(IStatus status) {
	    super.updateStatus(status != null ? status : fStandardStatus);    
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.window.Window#getInitialSize()
	 */
	protected Point getInitialSize() {
    	Point initialSize= super.getInitialSize();
        try {
        	int lastWidth= fDialogSettings.getInt(DS_KEY_PREFERRED_WIDTH);
        	if (initialSize.x > lastWidth)
        		lastWidth= initialSize.x;
        	int lastHeight= fDialogSettings.getInt(DS_KEY_PREFERRED_HEIGHT);
        	if (initialSize.y > lastHeight)
        		lastHeight= initialSize.x;
       		return new Point(lastWidth, lastHeight);
        } catch (NumberFormatException ex) {
        }
        return initialSize;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.window.Window#getInitialLocation(org.eclipse.swt.graphics.Point)
	 */
	protected Point getInitialLocation(Point initialSize) {
        try {
        	return new Point(fDialogSettings.getInt(DS_KEY_PREFERRED_X), fDialogSettings.getInt(DS_KEY_PREFERRED_Y));
        } catch (NumberFormatException ex) {
        	return super.getInitialLocation(initialSize);
        }
	}
	    
	public boolean close() {
		final Rectangle shell= getShell().getBounds();
		
		fDialogSettings.put(DS_KEY_PREFERRED_WIDTH, shell.width);
		fDialogSettings.put(DS_KEY_PREFERRED_HEIGHT, shell.height);
		fDialogSettings.put(DS_KEY_PREFERRED_X, shell.x);
		fDialogSettings.put(DS_KEY_PREFERRED_Y, shell.y);
		
		return super.close();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.Dialog#okPressed()
	 */
	protected void okPressed() {
		applyPressed();
		super.okPressed();
	}
	
    protected void buttonPressed(int buttonId) {
		if (buttonId == IDialogConstants.CLIENT_ID) {
			applyPressed();
		} else {
			super.buttonPressed(buttonId);
		}
    }
	
	private void applyPressed() {
		 if (fProfile.isBuiltInProfile() || fProfile.isSharedProfile()) {
		 	RenameProfileDialog dialog= new RenameProfileDialog(getShell(), fProfile, fProfileManager);
		 	if (dialog.open() != Window.OK) {
		 		return;
		 	}

			fProfile= dialog.getRenamedProfile();
			
		    fStandardStatus= new Status(IStatus.OK, CUIPlugin.getPluginId(), IStatus.OK, "", null); //$NON-NLS-1$
			updateStatus(fStandardStatus);
		 }
		 fProfile.setSettings(new HashMap(fWorkingValues));
//		 fApplyButton.setEnabled(false);
	}
    
    protected void createButtonsForButtonBar(Composite parent) {
//	    fApplyButton= createButton(parent, IDialogConstants.CLIENT_ID, FormatterMessages.ModifyDialog_apply_button, false); 
//		fApplyButton.setEnabled(false);
		
		GridLayout layout= (GridLayout) parent.getLayout();
		layout.numColumns++;
		layout.makeColumnsEqualWidth= false;
		Label label= new Label(parent, SWT.NONE);
		GridData data= new GridData();
		data.widthHint= layout.horizontalSpacing;
		label.setLayoutData(data);
		super.createButtonsForButtonBar(parent);
    }
    
	
//	private final void addTabPage(TabFolder tabFolder, String title, ModifyDialogTabPage tabPage) {
//		final TabItem tabItem= new TabItem(tabFolder, SWT.NONE);
//		applyDialogFont(tabItem.getControl());
//		tabItem.setText(title);
//		tabItem.setData(tabPage);
//		tabItem.setControl(tabPage.createContents(tabFolder));
//		fTabPages.add(tabPage);
//	}

	public void valuesModified() {
//		if (fApplyButton != null && !fApplyButton.isDisposed()) {
//			fApplyButton.setEnabled(hasChanges());
//		}
	}

//	private boolean hasChanges() {
//		Iterator iter= fProfile.getSettings().entrySet().iterator();
//		for (;iter.hasNext();) {
//			Map.Entry curr= (Map.Entry) iter.next();
//			if (!fWorkingValues.get(curr.getKey()).equals(curr.getValue())) {
//				return true;
//			}
//		}
//		return false;
//	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Aaron Luchko, aluchko@redhat.com - 105926 [Formatter] Exporting Unnamed profile fails silently
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.preferences.DefaultScope;
import org.eclipse.core.runtime.preferences.IScopeContext;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ProjectScope;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Label;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.window.Window;

import org.eclipse.cdt.core.CCorePlugin;

import org.eclipse.cdt.internal.ui.util.Messages;

import org.eclipse.cdt.ui.CUIPlugin;

import org.eclipse.cdt.internal.ui.preferences.PreferencesAccess;
import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.CustomProfile;
import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.Profile;
import org.eclipse.cdt.internal.ui.util.ExceptionHandler;
import org.eclipse.cdt.internal.ui.util.PixelConverter;
import org.eclipse.cdt.internal.ui.util.SWTUtil;

import org.osgi.service.prefs.BackingStoreException;


/**
 * The code formatter preference page. 
 */
public class CodeFormatterConfigurationBlock {
    
    private static final String DIALOGSTORE_LASTLOADPATH= CUIPlugin.PLUGIN_ID + ".codeformatter.loadpath"; //$NON-NLS-1$
	private static final String DIALOGSTORE_LASTSAVEPATH= CUIPlugin.PLUGIN_ID + ".codeformatter.savepath"; //$NON-NLS-1$
	
	private class StoreUpdater implements Observer {
		
		public StoreUpdater() {
			fProfileManager.addObserver(this);
		}

		public void update(Observable o, Object arg) {
			final int value= ((Integer)arg).intValue();
			switch (value) {
			case ProfileManager.PROFILE_DELETED_EVENT:
			case ProfileManager.PROFILE_RENAMED_EVENT:
			case ProfileManager.PROFILE_CREATED_EVENT:
			case ProfileManager.SETTINGS_CHANGED_EVENT:
				try {
					ProfileStore.writeProfiles(fProfileManager.getSortedProfiles(), fInstanceScope); // update profile store
					fProfileManager.commitChanges(fCurrContext); // update formatter settings with curently selected profile 
				} catch (CoreException x) {
					CUIPlugin.getDefault().log(x);
				}
				break;
			case ProfileManager.SELECTION_CHANGED_EVENT:
				fProfileManager.commitChanges(fCurrContext); // update formatter settings with curently selected profile
				break;
			}
		}
	}

	private class ProfileComboController implements Observer, SelectionListener {
		
		private final List fSortedProfiles;
		
		public ProfileComboController() {
			fSortedProfiles= fProfileManager.getSortedProfiles();
			fProfileCombo.addSelectionListener(this);
			fProfileManager.addObserver(this);
			updateProfiles();
			updateSelection();
		}
		
		public void widgetSelected(SelectionEvent e) {
			final int index= fProfileCombo.getSelectionIndex();
			fProfileManager.setSelected((Profile)fSortedProfiles.get(index));
		}

		public void widgetDefaultSelected(SelectionEvent e) {}

		public void update(Observable o, Object arg) {
			if (arg == null) return;
			final int value= ((Integer)arg).intValue();
			switch (value) {
				case ProfileManager.PROFILE_CREATED_EVENT:
				case ProfileManager.PROFILE_DELETED_EVENT:
				case ProfileManager.PROFILE_RENAMED_EVENT:
					updateProfiles();
					updateSelection();
					break;
				case ProfileManager.SELECTION_CHANGED_EVENT:
					updateSelection();
					break;
			}
		}
		
		private void updateProfiles() {
			fProfileCombo.setItems(fProfileManager.getSortedDisplayNames());
		}

		private void updateSelection() {
			fProfileCombo.setText(fProfileManager.getSelected().getName());
		}
	}
	
	private class ButtonController implements Observer, SelectionListener {
		
		public ButtonController() {
			fProfileManager.addObserver(this);
			fNewButton.addSelectionListener(this);
			fRenameButton.addSelectionListener(this);
			fEditButton.addSelectionListener(this);
			fDeleteButton.addSelectionListener(this);
			fSaveButton.addSelectionListener(this);
			fLoadButton.addSelectionListener(this);
			update(fProfileManager, null);
		}

		public void update(Observable o, Object arg) {
			Profile selected= ((ProfileManager)o).getSelected();
			final boolean notBuiltIn= !selected.isBuiltInProfile();
			fEditButton.setText(notBuiltIn ? FormatterMessages.CodingStyleConfigurationBlock_edit_button_desc
			    : FormatterMessages.CodingStyleConfigurationBlock_show_button_desc); 
			fDeleteButton.setEnabled(notBuiltIn);
			fSaveButton.setEnabled(notBuiltIn);
			fRenameButton.setEnabled(notBuiltIn);
		}

		public void widgetSelected(SelectionEvent e) {
			final Button button= (Button)e.widget;
			if (button == fSaveButton)
				saveButtonPressed();
			else if (button == fEditButton)
				modifyButtonPressed();
			else if (button == fDeleteButton) 
				deleteButtonPressed();
			else if (button == fNewButton)
				newButtonPressed();
			else if (button == fLoadButton)
				loadButtonPressed();
			else if (button == fRenameButton) 
				renameButtonPressed();
		}
		
		public void widgetDefaultSelected(SelectionEvent e) {
		}
		
		private void renameButtonPressed() {
			if (fProfileManager.getSelected().isBuiltInProfile())
				return;
			final CustomProfile profile= (CustomProfile) fProfileManager.getSelected();
			final RenameProfileDialog renameDialog= new RenameProfileDialog(fComposite.getShell(), profile, fProfileManager);
			if (renameDialog.open() == Window.OK) {
				fProfileManager.setSelected(renameDialog.getRenamedProfile());
			}
		}
		
		private void modifyButtonPressed() {
			final ModifyDialog modifyDialog= new ModifyDialog(fComposite.getShell(), fProfileManager.getSelected(), fProfileManager, false);
			modifyDialog.open();
		}
		
		private void deleteButtonPressed() {
			if (MessageDialog.openQuestion(
				fComposite.getShell(), 
				FormatterMessages.CodingStyleConfigurationBlock_delete_confirmation_title, 
				Messages.format(FormatterMessages.CodingStyleConfigurationBlock_delete_confirmation_question, fProfileManager.getSelected().getName()))) { 
				fProfileManager.deleteSelected();
			}
		}
		
		private void newButtonPressed() {
			final CreateProfileDialog p= new CreateProfileDialog(fComposite.getShell(), fProfileManager);
			if (p.open() != Window.OK) 
				return;
			if (!p.openEditDialog()) 
				return;
			final ModifyDialog modifyDialog= new ModifyDialog(fComposite.getShell(), p.getCreatedProfile(), fProfileManager, true);
			modifyDialog.open();
		}
		
		private void saveButtonPressed() {
			Profile selected= fProfileManager.getSelected();
			if (selected.isSharedProfile()) {
				final RenameProfileDialog renameDialog= new RenameProfileDialog(fComposite.getShell(), selected, fProfileManager);
				if (renameDialog.open() != Window.OK) {
					return;
				}
					
				selected= renameDialog.getRenamedProfile();
				fProfileManager.setSelected(selected);
			}
			
			final FileDialog dialog= new FileDialog(fComposite.getShell(), SWT.SAVE);
			dialog.setText(FormatterMessages.CodingStyleConfigurationBlock_save_profile_dialog_title); 
			dialog.setFilterExtensions(new String [] {"*.xml"}); //$NON-NLS-1$
			
			final String lastPath= CUIPlugin.getDefault().getDialogSettings().get(DIALOGSTORE_LASTSAVEPATH);
			if (lastPath != null) {
				dialog.setFilterPath(lastPath);
			}
			final String path= dialog.open();
			if (path == null) 
				return;
			
			CUIPlugin.getDefault().getDialogSettings().put(DIALOGSTORE_LASTSAVEPATH, dialog.getFilterPath());
			
			final File file= new File(path);
			if (file.exists() && !MessageDialog.openQuestion(fComposite.getShell(), FormatterMessages.CodingStyleConfigurationBlock_save_profile_overwrite_title, Messages.format(FormatterMessages.CodingStyleConfigurationBlock_save_profile_overwrite_message, path))) { 
				return;
			}
			
			final Collection profiles= new ArrayList();

			profiles.add(selected);
			try {
				ProfileStore.writeProfilesToFile(profiles, file);
			} catch (CoreException e) {
				final String title= FormatterMessages.CodingStyleConfigurationBlock_save_profile_error_title; 
				final String message= FormatterMessages.CodingStyleConfigurationBlock_save_profile_error_message; 
				ExceptionHandler.handle(e, fComposite.getShell(), title, message);
			}
		}
		
		private void loadButtonPressed() {
			final FileDialog dialog= new FileDialog(fComposite.getShell(), SWT.OPEN);
			dialog.setText(FormatterMessages.CodingStyleConfigurationBlock_load_profile_dialog_title); 
			dialog.setFilterExtensions(new String [] {"*.xml"}); //$NON-NLS-1$
			final String lastPath= CUIPlugin.getDefault().getDialogSettings().get(DIALOGSTORE_LASTLOADPATH);
			if (lastPath != null) {
				dialog.setFilterPath(lastPath);
			}
			final String path= dialog.open();
			if (path == null) 
				return;
			CUIPlugin.getDefault().getDialogSettings().put(DIALOGSTORE_LASTLOADPATH, dialog.getFilterPath());
			
			final File file= new File(path);
			Collection profiles= null;
			try {
				profiles= ProfileStore.readProfilesFromFile(file);
			} catch (CoreException e) {
				final String title= FormatterMessages.CodingStyleConfigurationBlock_load_profile_error_title; 
				final String message= FormatterMessages.CodingStyleConfigurationBlock_load_profile_error_message; 
				ExceptionHandler.handle(e, fComposite.getShell(), title, message);
			}
			if (profiles == null || profiles.isEmpty())
				return;
			
			final CustomProfile profile= (CustomProfile)profiles.iterator().next();
			
			if (ProfileVersioner.getVersionStatus(profile) > 0) {
				final String title= FormatterMessages.CodingStyleConfigurationBlock_load_profile_error_too_new_title; 
				final String message= FormatterMessages.CodingStyleConfigurationBlock_load_profile_error_too_new_message; 
			    MessageDialog.openWarning(fComposite.getShell(), title, message);
			}
			
			if (fProfileManager.containsName(profile.getName())) {
				final AlreadyExistsDialog aeDialog= new AlreadyExistsDialog(fComposite.getShell(), profile, fProfileManager);
				if (aeDialog.open() != Window.OK) 
					return;
			}
			ProfileVersioner.updateAndComplete(profile);
			fProfileManager.addProfile(profile);
		}
	}
	
//	private class PreviewController implements Observer {
//
//		public PreviewController() {
//			fProfileManager.addObserver(this);
//			fCodeStylePreview.setWorkingValues(fProfileManager.getSelected().getSettings());
//			fCodeStylePreview.update();
//		}
//		
//		public void update(Observable o, Object arg) {
//			final int value= ((Integer)arg).intValue();
//			switch (value) {
//				case ProfileManager.PROFILE_CREATED_EVENT:
//				case ProfileManager.PROFILE_DELETED_EVENT:
//				case ProfileManager.SELECTION_CHANGED_EVENT:
//				case ProfileManager.SETTINGS_CHANGED_EVENT:
//					fCodeStylePreview.setWorkingValues(((ProfileManager)o).getSelected().getSettings());
//					fCodeStylePreview.update();
//			}
//		}
//	}
	
//	/**
//	 * Some C source code used for preview.
//	 */
//	private final static String PREVIEW=
//		"/*\n* " + //$NON-NLS-1$
//		FormatterMessages.CodingStyleConfigurationBlock_preview_title + 
//		"\n*/\n\n" + //$NON-NLS-1$
//		"#include <math.h>\n" + //$NON-NLS-1$
//		"class Point {" +  //$NON-NLS-1$
//		"public:" +  //$NON-NLS-1$
//		"Point(double xc, double yc) : x(xc), y(yc) {}" + //$NON-NLS-1$ 
//		"double distance(const Point& other) const;" + //$NON-NLS-1$
//		"double x;" +  //$NON-NLS-1$
//		"double y;" +  //$NON-NLS-1$
//		"};" +  //$NON-NLS-1$
//		"float Point::distance(const Point& other) const {" + //$NON-NLS-1$
//		"double dx = x - other.x;" + //$NON-NLS-1$
//		"double dy = y - other.y;" + //$NON-NLS-1$
//		"return sqrt(dx * dx + dy * dy);" + //$NON-NLS-1$
//		"}"; //$NON-NLS-1$

	/**
	 * The GUI controls
	 */
	protected Composite fComposite;
	protected Combo fProfileCombo;
	protected Button fEditButton;
	protected Button fRenameButton;
	protected Button fDeleteButton;
	protected Button fNewButton;
	protected Button fLoadButton;
	protected Button fSaveButton;
	
	/**
	 * The ProfileManager, the model of this page.
	 */
	protected final ProfileManager fProfileManager;
	private CustomCodeFormatterBlock fCustomCodeFormatterBlock;
	
	/**
	 * The CPreview.
	 */
//	protected CompilationUnitPreview fCodeStylePreview;
	private PixelConverter fPixConv;

	private IScopeContext fCurrContext;
	private IScopeContext fInstanceScope;
	
	/**
	 * Create a new <code>CodeFormatterConfigurationBlock</code>.
	 */
	public CodeFormatterConfigurationBlock(IProject project, PreferencesAccess access) {
		fInstanceScope= access.getInstanceScope();
		List profiles= null;
		try {
		    profiles= ProfileStore.readProfiles(fInstanceScope);
		} catch (CoreException e) {
			CUIPlugin.getDefault().log(e);
		}
		if (profiles == null) {
			try {
				// bug 129427
			    profiles= ProfileStore.readProfilesFromPreferences(new DefaultScope());
			} catch (CoreException e) {
				CUIPlugin.getDefault().log(e);
			}
		}
		
		if (profiles == null) 
		    profiles= new ArrayList();
		
		if (project != null) {
			fCurrContext= access.getProjectScope(project);
		} else {
			fCurrContext= fInstanceScope;
		}
		
		fProfileManager= new ProfileManager(profiles, fCurrContext, access);
		fCustomCodeFormatterBlock= new CustomCodeFormatterBlock(CUIPlugin.getDefault().getPluginPreferences());

		new StoreUpdater();
	}

	/**
	 * Create the contents
	 * @param parent Parent composite
	 * @return Created control
	 */
	public Composite createContents(Composite parent) {

		final int numColumns = 5;
		
		fPixConv = new PixelConverter(parent);
		fComposite = createComposite(parent, numColumns);

		fProfileCombo= createProfileCombo(fComposite, numColumns - 3, fPixConv.convertWidthInCharsToPixels(20));
		fEditButton= createButton(fComposite, FormatterMessages.CodingStyleConfigurationBlock_edit_button_desc, GridData.HORIZONTAL_ALIGN_BEGINNING); 
		fRenameButton= createButton(fComposite, FormatterMessages.CodingStyleConfigurationBlock_rename_button_desc, GridData.HORIZONTAL_ALIGN_BEGINNING); 
		fDeleteButton= createButton(fComposite, FormatterMessages.CodingStyleConfigurationBlock_remove_button_desc, GridData.HORIZONTAL_ALIGN_BEGINNING); 

		final Composite group= createComposite(fComposite, 4);
		final GridData groupData= new GridData(GridData.HORIZONTAL_ALIGN_FILL);
		groupData.horizontalSpan= numColumns;
		group.setLayoutData(groupData);

		fNewButton= createButton(group, FormatterMessages.CodingStyleConfigurationBlock_new_button_desc, GridData.HORIZONTAL_ALIGN_BEGINNING); 
		((GridData)createLabel(group, "", 1).getLayoutData()).grabExcessHorizontalSpace= true; //$NON-NLS-1$
		fLoadButton= createButton(group, FormatterMessages.CodingStyleConfigurationBlock_load_button_desc, GridData.HORIZONTAL_ALIGN_END); 
		fSaveButton= createButton(group, FormatterMessages.CodingStyleConfigurationBlock_save_button_desc, GridData.HORIZONTAL_ALIGN_END); 

		fCustomCodeFormatterBlock.createControl(fComposite);
		
//		createLabel(fComposite, FormatterMessages.CodingStyleConfigurationBlock_preview_label_text, numColumns); 
//		configurePreview(fComposite, numColumns);
		
		new ButtonController();
		new ProfileComboController();
//		new PreviewController();
		
		return fComposite;
	}

	
	private static Button createButton(Composite composite, String text, final int style) {
		final Button button= new Button(composite, SWT.PUSH);
		button.setFont(composite.getFont());
		button.setText(text);

		final GridData gd= new GridData(style);
		gd.widthHint= SWTUtil.getButtonWidthHint(button);
		button.setLayoutData(gd);
		return button;
	}
	
	private static Combo createProfileCombo(Composite composite, int span, int widthHint) {
		final GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = span;
		gd.widthHint= widthHint;

		final Combo combo= new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY);
		combo.setFont(composite.getFont());
		combo.setLayoutData(gd);
		return combo;
	}
	
	private Label createLabel(Composite composite, String text, int numColumns) {
		final GridData gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
		gd.horizontalSpan = numColumns;
		gd.widthHint= 0;

		final Label label = new Label(composite, SWT.WRAP);
		label.setFont(composite.getFont());
		label.setText(text);
		label.setLayoutData(gd);
		return label;		
	}
	
	private Composite createComposite(Composite parent, int numColumns) {
		final Composite composite = new Composite(parent, SWT.NONE);
		composite.setFont(parent.getFont());
		
		final GridLayout layout = new GridLayout(numColumns, false);
		layout.marginHeight = 0;
		layout.marginWidth = 0;
		composite.setLayout(layout);
		return composite;
	}
	
//	private void configurePreview(Composite composite, int numColumns) {
//		fCodeStylePreview= new CompilationUnitPreview(fProfileManager.getSelected().getSettings(), composite);
//		fCodeStylePreview.setPreviewText(PREVIEW);
//	    
//		final GridData gd = new GridData(GridData.FILL_VERTICAL | GridData.HORIZONTAL_ALIGN_FILL);
//		gd.horizontalSpan = numColumns;
//		gd.verticalSpan= 7;
//		gd.widthHint = 0;
//		gd.heightHint = 0;
//		fCodeStylePreview.getControl().setLayoutData(gd);
//	}

	public final boolean hasProjectSpecificOptions(IProject project) {
		if (project != null) {
			return ProfileManager.hasProjectSpecificSettings(new ProjectScope(project));
		}
		return false;
	}
	
	public boolean performOk() {
		fCustomCodeFormatterBlock.performOk();
		return true;
	}
	
	public void performApply() {
		try {
			fCurrContext.getNode(CUIPlugin.PLUGIN_ID).flush();
			fCurrContext.getNode(CCorePlugin.PLUGIN_ID).flush();
			if (fCurrContext != fInstanceScope) {
				fInstanceScope.getNode(CUIPlugin.PLUGIN_ID).flush();
				fInstanceScope.getNode(CCorePlugin.PLUGIN_ID).flush();
			}
			fCustomCodeFormatterBlock.performOk();
		} catch (BackingStoreException e) {
			CUIPlugin.getDefault().log(e);
		}
	}
	
	public void performDefaults() {
		Profile profile= fProfileManager.getProfile(ProfileManager.DEFAULT_PROFILE);
		if (profile != null) {
			int defaultIndex= fProfileManager.getSortedProfiles().indexOf(profile);
			if (defaultIndex != -1) {
				fProfileManager.setSelected(profile);
			}
		}
		fCustomCodeFormatterBlock.performDefaults();
	}
	
	public void dispose() {
	}

	public void enableProjectSpecificSettings(boolean useProjectSpecificSettings) {
		if (useProjectSpecificSettings) {
			fProfileManager.commitChanges(fCurrContext);
		} else {
			fProfileManager.clearAllSettings(fCurrContext);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.actions;

import java.util.ResourceBundle;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.widgets.Display;

import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.jface.text.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.IRewriteTarget;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.jface.text.source.ISourceViewer;

import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.ui.texteditor.ITextEditorExtension3;
import org.eclipse.ui.texteditor.TextEditorAction;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.model.ITranslationUnit;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.ICPartitions;

import org.eclipse.cdt.internal.ui.editor.CEditor;
import org.eclipse.cdt.internal.ui.text.CHeuristicScanner;
import org.eclipse.cdt.internal.ui.text.CIndenter;


/**
 * Indents a line or range of lines in a C document to its correct position. No complete
 * AST must be present, the indentation is computed using heuristics. The algorithm used is fast for
 * single lines, but does not store any information and therefore not so efficient for large line
 * ranges.
 * 
 * @see org.eclipse.cdt.internal.ui.text.CHeuristicScanner
 * @see org.eclipse.cdt.internal.ui.text.CIndenter
 */
public class IndentAction extends TextEditorAction {
	
	/** The caret offset after an indent operation. */
	private int fCaretOffset;
	
	/** 
	 * Whether this is the action invoked by TAB. When <code>true</code>, indentation behaves 
	 * differently to accommodate normal TAB operation.
	 */
	private final boolean fIsTabAction;
	
	/**
	 * Creates a new instance.
	 * 
	 * @param bundle the resource bundle
	 * @param prefix the prefix to use for keys in <code>bundle</code>
	 * @param editor the text editor
	 * @param isTabAction whether the action should insert tabs if over the indentation
	 */
	public IndentAction(ResourceBundle bundle, String prefix, ITextEditor editor, boolean isTabAction) {
		super(bundle, prefix, editor);
		fIsTabAction= isTabAction;
	}
	
	/*
	 * @see org.eclipse.jface.action.Action#run()
	 */
	public void run() {
		// update has been called by the framework
		if (!isEnabled() || !validateEditorInputState())
			return;
		
		ITextSelection selection= getSelection();
		final IDocument document= getDocument();
		
		if (document != null) {
			final int offset= selection.getOffset();
			final int length= selection.getLength();
			final Position end= new Position(offset + length);
			final int firstLine, nLines;
			fCaretOffset= -1;
			
			try {
				document.addPosition(end);
				firstLine= document.getLineOfOffset(offset);
				// check for marginal (zero-length) lines
				int minusOne= length == 0 ? 0 : 1;
				nLines= document.getLineOfOffset(offset + length - minusOne) - firstLine + 1;
			} catch (BadLocationException e) {
				// will only happen on concurrent modification
				CUIPlugin.getDefault().log(new Status(IStatus.ERROR, CUIPlugin.getPluginId(), IStatus.OK, "", e)); //$NON-NLS-1$
				return;
			}
			
			Runnable runnable= new Runnable() {
				public void run() {
					IRewriteTarget target= (IRewriteTarget)getTextEditor().getAdapter(IRewriteTarget.class);
					if (target != null)
						target.beginCompoundChange();
					
					try {
						CHeuristicScanner scanner= new CHeuristicScanner(document);
						CIndenter indenter= new CIndenter(document, scanner, getCProject());
						final boolean multiLine= nLines > 1;
						boolean hasChanged= false;
						for (int i= 0; i < nLines; i++) {
							hasChanged |= indentLine(document, firstLine + i, offset, indenter, scanner, multiLine);
						}
						
						// update caret position: move to new position when indenting just one line
						// keep selection when indenting multiple
						int newOffset, newLength;
						if (!fIsTabAction && multiLine) {
							newOffset= offset;
							newLength= end.getOffset() - offset;
						} else {
							newOffset= fCaretOffset;
							newLength= 0;
						}
						
						// always reset the selection if anything was replaced
						// but not when we had a single line non-tab invocation
						if (newOffset != -1 && (hasChanged || newOffset != offset || newLength != length))
							selectAndReveal(newOffset, newLength);
						
						document.removePosition(end);
					} catch (BadLocationException e) {
						// will only happen on concurrent modification
						CUIPlugin.getDefault().log(new Status(IStatus.ERROR, CUIPlugin.getPluginId(), IStatus.OK, "ConcurrentModification in IndentAction", e)); //$NON-NLS-1$
					} finally {
						if (target != null)
							target.endCompoundChange();
					}
				}
			};
			
			if (nLines > 50) {
				Display display= getTextEditor().getEditorSite().getWorkbenchWindow().getShell().getDisplay();
				BusyIndicator.showWhile(display, runnable);
			} else {
				runnable.run();
			}
		}
	}
	
	/**
	 * Selects the given range on the editor.
	 * 
	 * @param newOffset the selection offset
	 * @param newLength the selection range
	 */
	private void selectAndReveal(int newOffset, int newLength) {
		Assert.isTrue(newOffset >= 0); 
		Assert.isTrue(newLength >= 0); 
		ITextEditor editor= getTextEditor();
		if (editor instanceof CEditor) {
			ISourceViewer viewer= ((CEditor)editor).getViewer();
			if (viewer != null)
				viewer.setSelectedRange(newOffset, newLength);
		} else {
			// this is too intrusive, but will never get called anyway
			getTextEditor().selectAndReveal(newOffset, newLength);
		}
	}

	/**
	 * Indents a single line using the java heuristic scanner. Cdoc and multiline comments are 
	 * indented as specified by the <code>CDocAutoIndentStrategy</code>.
	 * 
	 * @param document the document
	 * @param line the line to be indented
	 * @param caret the caret position
	 * @param indenter the java indenter
	 * @param scanner the heuristic scanner
	 * @param multiLine <code>true</code> if more than one line is being indented 
	 * @return <code>true</code> if <code>document</code> was modified, <code>false</code> otherwise
	 * @throws BadLocationException if the document got changed concurrently 
	 */
	private boolean indentLine(IDocument document, int line, int caret, CIndenter indenter, CHeuristicScanner scanner, boolean multiLine) throws BadLocationException {
		IRegion currentLine= document.getLineInformation(line);
		int offset= currentLine.getOffset();
		int wsStart= offset; // where we start searching for non-WS; after the "//" in single line comments
		
		String indent= null;
		if (offset < document.getLength()) {
			ITypedRegion partition= TextUtilities.getPartition(document, ICPartitions.C_PARTITIONING, offset, true);
			ITypedRegion startingPartition= TextUtilities.getPartition(document, ICPartitions.C_PARTITIONING, offset, false);
			String type= partition.getType();
			if (type.equals(ICPartitions.C_MULTI_LINE_COMMENT)) {
				indent= computeDocIndent(document, line, scanner, startingPartition);
			} else if (!fIsTabAction && startingPartition.getOffset() == offset && startingPartition.getType().equals(ICPartitions.C_SINGLE_LINE_COMMENT)) {
				// line comment starting at position 0 -> indent inside
				int max= document.getLength() - offset;
				int slashes= 2;
				while (slashes < max - 1 && document.get(offset + slashes, 2).equals("//")) //$NON-NLS-1$
					slashes+= 2;
				
				wsStart= offset + slashes;
				
				StringBuffer computed= indenter.computeIndentation(offset);
				if (computed == null)
					computed= new StringBuffer(0);
				int tabSize= getTabSize();
				while (slashes > 0 && computed.length() > 0) {
					char c= computed.charAt(0);
					if (c == '\t') {
						if (slashes > tabSize)
							slashes-= tabSize;
						else
							break;
					} else if (c == ' ') {
						slashes--;
					} else {
						break;
					}
					
					computed.deleteCharAt(0);
				}
				
				indent= document.get(offset, wsStart - offset) + computed;
			}
		} 
		
		// standard java indentation
		if (indent == null) {
			StringBuffer computed= indenter.computeIndentation(offset);
			if (computed != null)
				indent= computed.toString();
			else
				indent= ""; //$NON-NLS-1$
		}
		
		// change document:
		// get current white space
		int lineLength= currentLine.getLength();
		int end= scanner.findNonWhitespaceForwardInAnyPartition(wsStart, offset + lineLength);
		if (end == CHeuristicScanner.NOT_FOUND) {
			// an empty line
			end= offset + lineLength;
			if (multiLine && !indentEmptyLines())
				indent= ""; //$NON-NLS-1$
		}
		int length= end - offset;
		String currentIndent= document.get(offset, length);
		
		// if we are right before the text start / line end, and already after the insertion point
		// then just insert a tab.
		if (fIsTabAction && caret == end && whiteSpaceLength(currentIndent) >= whiteSpaceLength(indent)) {
			String tab= getTabEquivalent();
			document.replace(caret, 0, tab);
			fCaretOffset= caret + tab.length();
			return true;
		}
		
		// set the caret offset so it can be used when setting the selection
		if (caret >= offset && caret <= end)
			fCaretOffset= offset + indent.length();
		else
			fCaretOffset= -1;
		
		// only change the document if it is a real change
		if (!indent.equals(currentIndent)) {
			document.replace(offset, length, indent);
			return true;
		} else {
			return false;
		}
	}

	/**
	 * Computes and returns the indentation for a javadoc line. The line
	 * must be inside a javadoc comment.
	 * 
	 * @param document the document
	 * @param line the line in document
	 * @param scanner the scanner
	 * @param partition the javadoc partition
	 * @return the indent, or <code>null</code> if not computable
	 * @throws BadLocationException
	 */
	private String computeDocIndent(IDocument document, int line, CHeuristicScanner scanner, ITypedRegion partition) throws BadLocationException {
		if (line == 0) // impossible - the first line is never inside a javadoc comment
			return null;
		
		// don't make any assumptions if the line does not start with \s*\* - it might be
		// commented out code, for which we don't want to change the indent
		final IRegion lineInfo= document.getLineInformation(line);
		final int lineStart= lineInfo.getOffset();
		final int lineLength= lineInfo.getLength();
		final int lineEnd= lineStart + lineLength;
		int nonWS= scanner.findNonWhitespaceForwardInAnyPartition(lineStart, lineEnd);
		if (nonWS == CHeuristicScanner.NOT_FOUND || document.getChar(nonWS) != '*') {
			if (nonWS == CHeuristicScanner.NOT_FOUND)
				return document.get(lineStart, lineLength);
			return document.get(lineStart, nonWS - lineStart);
		}
		
		// take the indent from the previous line and reuse
		IRegion previousLine= document.getLineInformation(line - 1);
		int previousLineStart= previousLine.getOffset();
		int previousLineLength= previousLine.getLength();
		int previousLineEnd= previousLineStart + previousLineLength;
		
		StringBuffer buf= new StringBuffer();
		int previousLineNonWS= scanner.findNonWhitespaceForwardInAnyPartition(previousLineStart, previousLineEnd);
		if (previousLineNonWS == CHeuristicScanner.NOT_FOUND || document.getChar(previousLineNonWS) != '*') {
			// align with the comment start if the previous line is not an asterisked line
			previousLine= document.getLineInformationOfOffset(partition.getOffset());
			previousLineStart= previousLine.getOffset();
			previousLineLength= previousLine.getLength();
			previousLineEnd= previousLineStart + previousLineLength;
			previousLineNonWS= scanner.findNonWhitespaceForwardInAnyPartition(previousLineStart, previousLineEnd);
			if (previousLineNonWS == CHeuristicScanner.NOT_FOUND)
				previousLineNonWS= previousLineEnd;
			
			// add the initial space 
			// TODO this may be controlled by a formatter preference in the future
			buf.append(' ');
		}
		
		String indentation= document.get(previousLineStart, previousLineNonWS - previousLineStart);
		buf.insert(0, indentation);
		return buf.toString();
	}
	
	/**
	 * Returns the size in characters of a string. All characters count one, tabs count the editor's
	 * preference for the tab display 
	 * 
	 * @param indent the string to be measured.
	 * @return the size in characters of a string
	 */
	private int whiteSpaceLength(String indent) {
		if (indent == null)
			return 0;
		else {
			int size= 0;
			int l= indent.length();
			int tabSize= getTabSize();
			
			for (int i= 0; i < l; i++)
				size += indent.charAt(i) == '\t' ? tabSize : 1;
			return size;
		}
	}

	/**
	 * Returns a tab equivalent, either as a tab character or as spaces, depending on the editor and
	 * formatter preferences.
	 * 
	 * @return a string representing one tab in the editor, never <code>null</code>
	 */
	private String getTabEquivalent() {
		String tab;
		if (CCorePlugin.SPACE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR))) {
			int size= getTabSize();
			StringBuffer buf= new StringBuffer();
			for (int i= 0; i< size; i++)
				buf.append(' ');
			tab= buf.toString();
		} else {
			tab= "\t"; //$NON-NLS-1$
		}
	
		return tab;
	}
	
	/**
	 * Returns the tab size used by the java editor, which is deduced from the
	 * formatter preferences.
	 * 
	 * @return the tab size as defined in the current formatter preferences
	 */
	private int getTabSize() {
		return getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, 4);
	}

	/**
	 * Returns <code>true</code> if empty lines should be indented, false otherwise.
	 * 
	 * @return <code>true</code> if empty lines should be indented, false otherwise
	 */
	private boolean indentEmptyLines() {
		return DefaultCodeFormatterConstants.TRUE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_EMPTY_LINES));
	}
	
	/**
	 * Returns the possibly project-specific core preference defined under <code>key</code>.
	 * 
	 * @param key the key of the preference
	 * @return the value of the preference
	 */
	private String getCoreFormatterOption(String key) {
		ICProject project= getCProject();
		if (project == null)
			return CCorePlugin.getOption(key);
		return project.getOption(key, true);
	}

	/**
	 * Returns the possibly project-specific core preference defined under <code>key</code>, or
	 * <code>def</code> if the value is not a integer.
	 * 
	 * @param key the key of the preference
	 * @param def the default value
	 * @return the value of the preference
	 */
	private int getCoreFormatterOption(String key, int def) {
		try {
			return Integer.parseInt(getCoreFormatterOption(key));
		} catch (NumberFormatException e) {
			return def;
		}
	}

	/**
	 * Returns the <code>ICProject</code> of the current editor input, or
	 * <code>null</code> if it cannot be found.
	 * 
	 * @return the <code>ICProject</code> of the current editor input, or
	 *         <code>null</code> if it cannot be found
	 */
	private ICProject getCProject() {
		ITextEditor editor= getTextEditor();
		if (editor == null)
			return null;
		
		ITranslationUnit cu= CUIPlugin.getDefault().getWorkingCopyManager().getWorkingCopy(editor.getEditorInput());
		if (cu == null)
			return null;
		return cu.getCProject();
	}

	/**
	 * Returns the editor's selection provider.
	 * 
	 * @return the editor's selection provider or <code>null</code>
	 */
	private ISelectionProvider getSelectionProvider() {
		ITextEditor editor= getTextEditor();
		if (editor != null) {
			return editor.getSelectionProvider();
		}
		return null;
	}
	
	/*
	 * @see org.eclipse.ui.texteditor.IUpdate#update()
	 */
	public void update() {
		super.update();
		
		if (isEnabled()) {
			if (fIsTabAction)
				setEnabled(canModifyEditor() && isSmartMode() && isValidSelection());
			else
				setEnabled(canModifyEditor() && !getSelection().isEmpty());
		}
	}
	
	/**
	 * Returns if the current selection is valid, i.e. whether it is empty and the caret in the 
	 * whitespace at the start of a line, or covers multiple lines.
	 * 
	 * @return <code>true</code> if the selection is valid for an indent operation
	 */
	private boolean isValidSelection() {
		ITextSelection selection= getSelection();
		if (selection.isEmpty())
			return false;
		
		int offset= selection.getOffset();
		int length= selection.getLength();
		
		IDocument document= getDocument();
		if (document == null)
			return false;
		
		try {
			IRegion firstLine= document.getLineInformationOfOffset(offset);
			int lineOffset= firstLine.getOffset();
			
			// either the selection has to be empty and the caret in the WS at the line start
			// or the selection has to extend over multiple lines
			if (length == 0) {
				return document.get(lineOffset, offset - lineOffset).trim().length() == 0;
			} else {
//				return lineOffset + firstLine.getLength() < offset + length;
				return false; // only enable for empty selections for now
			}
		} catch (BadLocationException e) {
		}
		
		return false;
	}
	
	/**
	 * Returns the smart preference state.
	 * 
	 * @return <code>true</code> if smart mode is on, <code>false</code> otherwise
	 */
	private boolean isSmartMode() {
		ITextEditor editor= getTextEditor();
		
		if (editor instanceof ITextEditorExtension3)
			return ((ITextEditorExtension3) editor).getInsertMode() == ITextEditorExtension3.SMART_INSERT;
		
		return false;
	}
	
	/**
	 * Returns the document currently displayed in the editor, or <code>null</code> if none can be 
	 * obtained.
	 * 
	 * @return the current document or <code>null</code>
	 */
	private IDocument getDocument() {
		
		ITextEditor editor= getTextEditor();
		if (editor != null) {
			
			IDocumentProvider provider= editor.getDocumentProvider();
			IEditorInput input= editor.getEditorInput();
			if (provider != null && input != null)
				return provider.getDocument(input);
			
		}
		return null;
	}
	
	/**
	 * Returns the selection on the editor or an invalid selection if none can be obtained. Returns
	 * never <code>null</code>.
	 * 
	 * @return the current selection, never <code>null</code>
	 */
	private ITextSelection getSelection() {
		ISelectionProvider provider= getSelectionProvider();
		if (provider != null) {
			
			ISelection selection= provider.getSelection();
			if (selection instanceof ITextSelection)
				return (ITextSelection) selection;
		}
		
		// null object
		return TextSelection.emptySelection();
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.preferences.DefaultScope;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.IScopeContext;
import org.eclipse.core.runtime.preferences.InstanceScope;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ProjectScope;

import org.eclipse.ui.preferences.IWorkingCopyManager;

import org.osgi.service.prefs.BackingStoreException;

/**
 * 
 */
public class PreferencesAccess {
	
	public static PreferencesAccess getOriginalPreferences() {
		return new PreferencesAccess();
	}
	
	public static PreferencesAccess getWorkingCopyPreferences(IWorkingCopyManager workingCopyManager) {
		return new WorkingCopyPreferencesAccess(workingCopyManager);
	}
		
	private PreferencesAccess() {
		// can only extends in this file
	}
	
	public IScopeContext getDefaultScope() {
		return new DefaultScope();
	}
	
	public IScopeContext getInstanceScope() {
		return new InstanceScope();
	}
	
	public IScopeContext getProjectScope(IProject project) {
		return new ProjectScope(project);
	}
	
	public void applyChanges() throws BackingStoreException {
	}
	
	
	private static class WorkingCopyPreferencesAccess extends PreferencesAccess {
		
		private final IWorkingCopyManager fWorkingCopyManager;

		private WorkingCopyPreferencesAccess(IWorkingCopyManager workingCopyManager) {
			fWorkingCopyManager= workingCopyManager;
		}
		
		private final IScopeContext getWorkingCopyScopeContext(IScopeContext original) {
			return new WorkingCopyScopeContext(fWorkingCopyManager, original);
		}
		
		public IScopeContext getDefaultScope() {
			return getWorkingCopyScopeContext(super.getDefaultScope());
		}
		
		public IScopeContext getInstanceScope() {
			return getWorkingCopyScopeContext(super.getInstanceScope());
		}
		
		public IScopeContext getProjectScope(IProject project) {
			return getWorkingCopyScopeContext(super.getProjectScope(project));
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.cdt.internal.ui.preferences.PreferencesAccess#applyChanges()
		 */
		public void applyChanges() throws BackingStoreException {
			fWorkingCopyManager.applyChanges();
		}
	}
	
	private static class WorkingCopyScopeContext implements IScopeContext {
		
		private final IWorkingCopyManager fWorkingCopyManager;
		private final IScopeContext fOriginal;

		public WorkingCopyScopeContext(IWorkingCopyManager workingCopyManager, IScopeContext original) {
			fWorkingCopyManager= workingCopyManager;
			fOriginal= original;	
		}

		/* (non-Javadoc)
		 * @see org.eclipse.core.runtime.preferences.IScopeContext#getName()
		 */
		public String getName() {
			return fOriginal.getName();
		}

		/* (non-Javadoc)
		 * @see org.eclipse.core.runtime.preferences.IScopeContext#getNode(java.lang.String)
		 */
		public IEclipsePreferences getNode(String qualifier) {
			return fWorkingCopyManager.getWorkingCopy(fOriginal.getNode(qualifier));
		}

		/* (non-Javadoc)
		 * @see org.eclipse.core.runtime.preferences.IScopeContext#getLocation()
		 */
		public IPath getLocation() {
			return fOriginal.getLocation();
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 QNX Software Systems 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:
 *     QNX Software Systems - Initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.PlatformUI;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.CCorePreferenceConstants;
import org.eclipse.cdt.utils.ui.controls.ControlFactory;

import org.eclipse.cdt.internal.ui.ICHelpContextIds;

/**
 * 
 */
public class CustomCodeFormatterBlock {

	private HashMap idMap = new HashMap();
	Preferences fPrefs;
	protected Combo fFormatterCombo;
	private static final String ATTR_NAME = "name"; //$NON-NLS-1$
	private static final String ATTR_ID="id"; //$NON-NLS-1$
	// This is a hack until we have a default Formatter.
	// For now it is comment out in the plugin.xml
	private static final String NONE=FormatterMessages.CustomCodeFormatterBlock_no_formatter;


	public CustomCodeFormatterBlock(Preferences prefs) {
		fPrefs = prefs;
		initializeFormatters();
	}

	public void performOk() {
		String text = fFormatterCombo.getText();
		String selection = (String)idMap.get(text);
		if (selection != null && selection.length() > 0) {
			HashMap options = CCorePlugin.getOptions();
			String formatterID = (String)options.get(CCorePreferenceConstants.CODE_FORMATTER);
			if (formatterID == null || !formatterID.equals(selection)) {
				options.put(CCorePreferenceConstants.CODE_FORMATTER, selection);
				CCorePlugin.setOptions(options);
			}
		} else {
			// simply reset to the default one.
			performDefaults();
		}
	}

	public void performDefaults() {
		HashMap optionsDefault = CCorePlugin.getDefaultOptions();
		HashMap options = CCorePlugin.getOptions();
		String formatterID = (String)optionsDefault.get(CCorePreferenceConstants.CODE_FORMATTER);
		options.put(CCorePreferenceConstants.CODE_FORMATTER, formatterID);
		CCorePlugin.setOptions(options);

		fFormatterCombo.clearSelection();
		fFormatterCombo.setText(NONE);
		Iterator iterator = idMap.entrySet().iterator();
		while (iterator.hasNext()) {
			Map.Entry entry = (Map.Entry)iterator.next();
			String val = (String)entry.getValue();
			if (val != null && val.equals(formatterID)) {
				fFormatterCombo.setText((String)entry.getKey());
			}
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public Control createControl(Composite parent) {
		Composite control = ControlFactory.createComposite(parent, 1);
		((GridLayout)control.getLayout()).marginWidth = 0;
		((GridData)control.getLayoutData()).horizontalSpan = 2;

		PlatformUI.getWorkbench().getHelpSystem().setHelp(control, ICHelpContextIds.CODEFORMATTER_PREFERENCE_PAGE);

		ControlFactory.createEmptySpace(control, 1);

		Label label = ControlFactory.createLabel(control, FormatterMessages.CustomCodeFormatterBlock_formatter_name);
		label.setLayoutData(new GridData());
		fFormatterCombo = new Combo(control, SWT.DROP_DOWN | SWT.READ_ONLY);
		fFormatterCombo.setFont(parent.getFont());
		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		fFormatterCombo.setLayoutData(gd);
		fFormatterCombo.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleFormatterChanged();
			}
		});
		Iterator items = idMap.keySet().iterator();
		while (items.hasNext()) {
			fFormatterCombo.add((String) items.next());
		}

		initDefault();
		handleFormatterChanged();
		
		if (getNumberOfAvailableFormatters() == 0) {
			control.setVisible(false);
		}
		return control;
	}

	private void handleFormatterChanged() {	
		// TODO: UI part.
	}

	private void initDefault() {
		boolean init = false;
		String selection = CCorePlugin.getOption(CCorePreferenceConstants.CODE_FORMATTER);
		if (selection != null) {
			Iterator iterator = idMap.entrySet().iterator();
			while (iterator.hasNext()) {
				Map.Entry entry = (Map.Entry)iterator.next();
				String val = (String)entry.getValue();
				if (val != null && val.equals(selection)) {
					fFormatterCombo.setText((String)entry.getKey());
					init = true;
				}
			}
		}
		if (!init) {
			fFormatterCombo.setText(NONE);
		}
	}

	private void initializeFormatters() {
		idMap = new HashMap();
		idMap.put(NONE, null);
		IExtensionPoint point = Platform.getExtensionRegistry().getExtensionPoint(CCorePlugin.PLUGIN_ID, CCorePlugin.FORMATTER_EXTPOINT_ID);
		if (point != null) {
			IExtension[] exts = point.getExtensions();
			for (int i = 0; i < exts.length; i++) {
		 		IConfigurationElement[] elements = exts[i].getConfigurationElements();
		 		for (int j = 0; j < elements.length; ++j) {
		 			String name = elements[j].getAttribute(ATTR_NAME);
		 			idMap.put(name, elements[j].getAttribute(ATTR_ID));
		 		}
			}
		}
	}
	
	private final int getNumberOfAvailableFormatters() {
		return idMap.size() - 1;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IInformationControlCreator;
import org.eclipse.jface.text.ITextHover;
import org.eclipse.jface.text.formatter.IContentFormatter;
import org.eclipse.jface.text.hyperlink.IHyperlinkDetector;
import org.eclipse.jface.text.information.IInformationPresenter;
import org.eclipse.jface.text.source.IAnnotationHover;
import org.eclipse.jface.text.source.ISourceViewer;

import org.eclipse.ui.texteditor.ITextEditor;


/**
 * A simple {@linkplain org.eclipse.cdt.internal.ui.text.CSourceViewerConfiguration C source viewer configuration}.
 * <p>
 * This simple source viewer configuration basically provides syntax coloring
 * and disables all other features like code assist, quick outlines, hyperlinking, etc.
 * </p>
 */
public class SimpleCSourceViewerConfiguration extends CSourceViewerConfiguration {


	private boolean fConfigureFormatter;

	/**
	 * Creates a new C source viewer configuration for viewers in the given editor
	 * using the given preference store, the color manager and the specified document partitioning.
	 *
	 * @param colorManager the color manager
	 * @param preferenceStore the preference store, can be read-only
	 * @param editor the editor in which the configured viewer(s) will reside, or <code>null</code> if none
	 * @param partitioning the document partitioning for this configuration, or <code>null</code> for the default partitioning
	 * @param configureFormatter <code>true</code> if a content formatter should be configured
	 */
	public SimpleCSourceViewerConfiguration(IColorManager colorManager, IPreferenceStore preferenceStore, ITextEditor editor, String partitioning, boolean configureFormatter) {
		super(colorManager, preferenceStore, editor, partitioning);
		fConfigureFormatter= configureFormatter;
	}
	
	/*
	 * @see org.eclipse.jface.text.source.SourceViewerConfiguration#getAutoEditStrategies(org.eclipse.jface.text.source.ISourceViewer, java.lang.String)
	 */
	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {
		return null;
	}

	/*
	 * @see SourceViewerConfiguration#getAnnotationHover(ISourceViewer)
	 */
	public IAnnotationHover getAnnotationHover(ISourceViewer sourceViewer) {
		return null;
	}

	/*
	 * @see SourceViewerConfiguration#getOverviewRulerAnnotationHover(ISourceViewer)
	 */
	public IAnnotationHover getOverviewRulerAnnotationHover(ISourceViewer sourceViewer) {
		return null;
	}

	/*
	 * @see SourceViewerConfiguration#getConfiguredTextHoverStateMasks(ISourceViewer, String)
	 */
	public int[] getConfiguredTextHoverStateMasks(ISourceViewer sourceViewer, String contentType) {
		return null;
	}

	/*
	 * @see SourceViewerConfiguration#getTextHover(ISourceViewer, String, int)
	 */
	public ITextHover getTextHover(ISourceViewer sourceViewer, String contentType, int stateMask) {
		return null;
	}

	/*
	 * @see SourceViewerConfiguration#getTextHover(ISourceViewer, String)
	 */
	public ITextHover getTextHover(ISourceViewer sourceViewer, String contentType) {
		return null;
	}

	/*
	 * @see SourceViewerConfiguration#getContentFormatter(ISourceViewer)
	 */
	public IContentFormatter getContentFormatter(ISourceViewer sourceViewer) {
		if (fConfigureFormatter)
			return super.getContentFormatter(sourceViewer);
		else
			return null;
	}

	/*
	 * @see SourceViewerConfiguration#getInformationControlCreator(ISourceViewer)
	 */
	public IInformationControlCreator getInformationControlCreator(ISourceViewer sourceViewer) {
		return null;
	}

	/*
	 * @see SourceViewerConfiguration#getInformationPresenter(ISourceViewer)
	 */
	public IInformationPresenter getInformationPresenter(ISourceViewer sourceViewer) {
		return null;
	}

	/*
	 * @see org.eclipse.cdt.ui.text.CSourceViewerConfiguration#getOutlinePresenter(org.eclipse.jface.text.source.ISourceViewer, boolean)
	 */
	public IInformationPresenter getOutlinePresenter(ISourceViewer sourceViewer, boolean doCodeResolve) {
		return null;
	}

	/*
	 * @see org.eclipse.cdt.ui.text.CSourceViewerConfiguration#getHierarchyPresenter(org.eclipse.jface.text.source.ISourceViewer, boolean)
	 */
	public IInformationPresenter getHierarchyPresenter(ISourceViewer sourceViewer, boolean doCodeResolve) {
		return null;
	}

	/*
	 * @see org.eclipse.jface.text.source.SourceViewerConfiguration#getHyperlinkDetectors(org.eclipse.jface.text.source.ISourceViewer)
	 */
	public IHyperlinkDetector[] getHyperlinkDetectors(ISourceViewer sourceViewer) {
		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences;

import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

import org.eclipse.ui.forms.FormColors;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.SharedScrolledComposite;


public class ScrolledPageContent extends SharedScrolledComposite {

	private FormToolkit fToolkit;
	
	public ScrolledPageContent(Composite parent) {
		this(parent, SWT.V_SCROLL | SWT.H_SCROLL);
	}
	
	public ScrolledPageContent(Composite parent, int style) {
		super(parent, style);
		
		setFont(parent.getFont());
		
		FormColors colors= new FormColors(parent.getDisplay());
		colors.setBackground(null);
		colors.setForeground(null);
		
		fToolkit= new FormToolkit(colors);
		
		setExpandHorizontal(true);
		setExpandVertical(true);
		
		Composite body= new Composite(this, SWT.NONE);
		body.setFont(parent.getFont());
		setContent(body);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.swt.widgets.Widget#dispose()
	 */
	public void dispose() {
		fToolkit.dispose();
		super.dispose();
	}
	
	public void adaptChild(Control childControl) {
		fToolkit.adapt(childControl, true, true);
	}
	
	public Composite getBody() {
		return (Composite) getContent();
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Observable;

import org.eclipse.core.runtime.preferences.DefaultScope;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.IScopeContext;
import org.eclipse.core.runtime.preferences.InstanceScope;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;

import org.eclipse.cdt.internal.ui.util.Messages;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.PreferenceConstants;

import org.eclipse.cdt.internal.ui.preferences.PreferencesAccess;

import org.osgi.service.prefs.BackingStoreException;


/**
 * The model for the set of profiles which are available in the workbench.
 */
public class ProfileManager extends Observable {
	
    /**
     * A prefix which is prepended to every ID of a user-defined profile, in order
     * to differentiate it from a built-in profile.
     */
	private final static String ID_PREFIX= "_"; //$NON-NLS-1$
	
	/**
	 * Represents a profile with a unique ID, a name and a map 
	 * containing the code formatter settings.
	 */
	public static abstract class Profile implements Comparable {
		
		public abstract String getName();
		public abstract Profile rename(String name, ProfileManager manager);
		
		public abstract Map getSettings();
		public abstract void setSettings(Map settings);
		
		public int getVersion() {
			return ProfileVersioner.CURRENT_VERSION;
		}
		
		public boolean hasEqualSettings(Map otherMap, List allKeys) {
			Map settings= getSettings();
			for (Iterator iter= allKeys.iterator(); iter.hasNext(); ){
				String key= (String) iter.next();
				Object other= otherMap.get(key);
				Object curr= settings.get(key);
				if (other == null) {
					if (curr != null) {
						return false;
					}
				} else if (!other.equals(curr)) {
					return false;
				}
			}
			return true;
		}
		
		public abstract boolean isProfileToSave();
		
		public abstract String getID();
		
		public boolean isSharedProfile() {
			return false;
		}
		
		public boolean isBuiltInProfile() {
			return false;
		}
	}
	
	/**
	 * Represents a built-in profile. The state of a built-in profile 
	 * cannot be changed after instantiation.
	 */
	public final static class BuiltInProfile extends Profile {
		private final String fName;
		private final String fID;
		private final Map fSettings;
		private final int fOrder;
		
		protected BuiltInProfile(String ID, String name, Map settings, int order) {
			fName= name;
			fID= ID;
			fSettings= settings;
			fOrder= order;
		}
		
		public String getName() { 
			return fName;	
		}
		
		public Profile rename(String name, ProfileManager manager) {
			final String trimmed= name.trim();
		 	CustomProfile newProfile= new CustomProfile(trimmed, fSettings, ProfileVersioner.CURRENT_VERSION);
		 	manager.addProfile(newProfile);
			return newProfile;
		}
		
		public Map getSettings() {
			return fSettings;
		}
	
		public void setSettings(Map settings) {
		}
	
		public String getID() { 
			return fID; 
		}
		
		public final int compareTo(Object o) {
			if (o instanceof BuiltInProfile) {
				return fOrder - ((BuiltInProfile)o).fOrder;
			}
			return -1;
		}

		public boolean isProfileToSave() {
			return false;
		}
		
		public boolean isBuiltInProfile() {
			return true;
		}
	
	}

	/**
	 * Represents a user-defined profile. A custom profile can be modified after instantiation.
	 */
	public static class CustomProfile extends Profile {
		private String fName;
		private Map fSettings;
		protected ProfileManager fManager;
		private int fVersion;

		public CustomProfile(String name, Map settings, int version) {
			fName= name;
			fSettings= settings;
			fVersion= version;
		}
		
		public String getName() {
			return fName;
		}
		
		public Profile rename(String name, ProfileManager manager) {
			final String trimmed= name.trim();
			if (trimmed.equals(getName())) 
				return this;
			
			String oldID= getID(); // remember old id before changing name
			fName= trimmed;
			
			manager.profileRenamed(this, oldID);
			return this;
		}

		public Map getSettings() { 
			return fSettings;
		}
		
		public void setSettings(Map settings) {
			if (settings == null)
				throw new IllegalArgumentException();
			fSettings= settings;
			if (fManager != null) {
				fManager.profileChanged(this);
			}
		}
		
		public String getID() { 
			return ID_PREFIX + fName;
		}
		
		public void setManager(ProfileManager profileManager) {
			fManager= profileManager;
		}
		
		public ProfileManager getManager() {
			return fManager;
		}

		public int getVersion() {
			return fVersion;
		}
		
		public void setVersion(int version)	{
			fVersion= version;
		}
		
		public int compareTo(Object o) {
			if (o instanceof SharedProfile) {
				return -1;
			}
			if (o instanceof CustomProfile) {
				return getName().compareToIgnoreCase(((Profile)o).getName());
			}
			return 1;
		}
		
		public boolean isProfileToSave() {
			return true;
		}

	}
	
	public final static class SharedProfile extends CustomProfile {
		
		public SharedProfile(String oldName, Map options) {
			super(oldName, options, ProfileVersioner.CURRENT_VERSION);
		}
		
		public Profile rename(String name, ProfileManager manager) {
			CustomProfile profile= new CustomProfile(name.trim(), getSettings(), getVersion());

			manager.profileReplaced(this, profile);
			return profile;
		}
				
		public String getID() { 
			return SHARED_PROFILE;
		}
		
		public final int compareTo(Object o) {
			return 1;
		}
		
		public boolean isProfileToSave() {
			return false;
		}
		
		public boolean isSharedProfile() {
			return true;
		}
	}
	

	/**
	 * The possible events for observers listening to this class.
	 */
	public final static int SELECTION_CHANGED_EVENT= 1;
	public final static int PROFILE_DELETED_EVENT= 2;
	public final static int PROFILE_RENAMED_EVENT= 3;
	public final static int PROFILE_CREATED_EVENT= 4;
	public final static int SETTINGS_CHANGED_EVENT= 5;
	
	/**
	 * The key of the preference where the selected profile is stored.
	 */
	private final static String PROFILE_KEY= PreferenceConstants.FORMATTER_PROFILE;
	
	/**
	 * The key of the preference where the version of the current settings is stored
	 */
	private final static String FORMATTER_SETTINGS_VERSION= "formatter_settings_version";  //$NON-NLS-1$

	/**
	 * The keys of the built-in profiles
	 */
	public final static String ECLIPSE_PROFILE= "org.eclipse.cdt.ui.default.eclipse_profile"; //$NON-NLS-1$
	public final static String SHARED_PROFILE= "org.eclipse.cdt.ui.default.shared"; //$NON-NLS-1$
	
	public final static String DEFAULT_PROFILE= ECLIPSE_PROFILE;
	
	/**
	 * A map containing the available profiles, using the IDs as keys.
	 */
	private final Map fProfiles;
	
	/**
	 * The available profiles, sorted by name.
	 */
	private final List fProfilesByName;
	

	/**
	 * The currently selected profile. 
	 */
	private Profile fSelected;
	
	/**
	 * The keys of the options to be saved with each profile
	 */
	private final static List fUIKeys= Collections.EMPTY_LIST; 
	private final static List fCoreKeys= new ArrayList(DefaultCodeFormatterConstants.getEclipseDefaultSettings().keySet());

	/**
	 * All keys appearing in a profile, sorted alphabetically
	 */
	private final static List fKeys;
	private final PreferencesAccess fPreferencesAccess;
	
	static {
	    fKeys= new ArrayList();
	    fKeys.addAll(fUIKeys);
	    fKeys.addAll(fCoreKeys);
	    Collections.sort(fKeys);
	}
	

	/**
	 * Create and initialize a new profile manager.
	 * @param profiles Initial custom profiles (List of type <code>CustomProfile</code>)
	 */
	public ProfileManager(List profiles, IScopeContext context, PreferencesAccess preferencesAccess) {
		fPreferencesAccess= preferencesAccess;
		
		fProfiles= new HashMap();
		fProfilesByName= new ArrayList();
	
		addBuiltinProfiles(fProfiles, fProfilesByName);
		
		for (final Iterator iter = profiles.iterator(); iter.hasNext();) {
			final CustomProfile profile= (CustomProfile) iter.next();
			profile.setManager(this);
			fProfiles.put(profile.getID(), profile);
			fProfilesByName.add(profile);
		}
		
		Collections.sort(fProfilesByName);
		
		IScopeContext instanceScope= fPreferencesAccess.getInstanceScope(); 
		String profileId= instanceScope.getNode(CUIPlugin.PLUGIN_ID).get(PROFILE_KEY, null);
		if (profileId == null) {
			profileId= new DefaultScope().getNode(CUIPlugin.PLUGIN_ID).get(PROFILE_KEY, null);
		}
		
		Profile profile= (Profile) fProfiles.get(profileId);
		if (profile == null) {
			profile= (Profile) fProfiles.get(DEFAULT_PROFILE);
		}
		fSelected= profile;
		
		if (context.getName() == ProjectScope.SCOPE && hasProjectSpecificSettings(context)) {
			Map map= readFromPreferenceStore(context, profile);
			if (map != null) {
				Profile matching= null;
			
				String projProfileId= context.getNode(CUIPlugin.PLUGIN_ID).get(PROFILE_KEY, null);
				if (projProfileId != null) {
					Profile curr= (Profile) fProfiles.get(projProfileId);
					if (curr != null && (curr.isBuiltInProfile() || curr.hasEqualSettings(map, getKeys()))) {
						matching= curr;
					}
				} else {
					// old version: look for similar
					for (final Iterator iter = fProfilesByName.iterator(); iter.hasNext();) {
						Profile curr= (Profile) iter.next();
						if (curr.hasEqualSettings(map, getKeys())) {
							matching= curr;
							break;
						}
					}
				}
				if (matching == null) {
					String name;
					if (projProfileId != null && !fProfiles.containsKey(projProfileId)) {
						name= Messages.format(FormatterMessages.ProfileManager_unmanaged_profile_with_name, projProfileId.substring(ID_PREFIX.length()));
					} else {
						name= FormatterMessages.ProfileManager_unmanaged_profile;
					}
					// current settings do not correspond to any profile -> create a 'team' profile
					SharedProfile shared= new SharedProfile(name, map);
					shared.setManager(this);
					fProfiles.put(shared.getID(), shared);
					fProfilesByName.add(shared); // add last
					matching= shared;
				}
				fSelected= matching;
			}
		}
	}
	




	/**
	 * Notify observers with a message. The message must be one of the following:
	 * @param message Message to send out
	 * 
	 * @see #SELECTION_CHANGED_EVENT
	 * @see #PROFILE_DELETED_EVENT
	 * @see #PROFILE_RENAMED_EVENT
	 * @see #PROFILE_CREATED_EVENT
	 * @see #SETTINGS_CHANGED_EVENT
	 */
	protected void notifyObservers(int message) {
		setChanged();
		notifyObservers(new Integer(message));
	}
	
	public static boolean hasProjectSpecificSettings(IScopeContext context) {
		IEclipsePreferences corePrefs= context.getNode(CCorePlugin.PLUGIN_ID);
		for (final Iterator keyIter = fCoreKeys.iterator(); keyIter.hasNext(); ) {
			final String key= (String) keyIter.next();
			Object val= corePrefs.get(key, null);
			if (val != null) {
				return true;
			}
		}
		
		IEclipsePreferences uiPrefs= context.getNode(CUIPlugin.PLUGIN_ID);
		for (final Iterator keyIter = fUIKeys.iterator(); keyIter.hasNext(); ) {
			final String key= (String) keyIter.next();
			Object val= uiPrefs.get(key, null);
			if (val != null) {
				return true;
			}
		}
		return false;
	}

	
	/**
	 * Only to read project specific settings to find out to what profile it matches.
	 * @param context The project context
	 */
	public Map readFromPreferenceStore(IScopeContext context, Profile workspaceProfile) {
		final Map profileOptions= new HashMap();
		IEclipsePreferences uiPrefs= context.getNode(CUIPlugin.PLUGIN_ID);
		IEclipsePreferences corePrefs= context.getNode(CCorePlugin.PLUGIN_ID);
				
		int version= uiPrefs.getInt(FORMATTER_SETTINGS_VERSION, ProfileVersioner.VERSION_1);
		if (version != ProfileVersioner.CURRENT_VERSION) {
			Map allOptions= new HashMap();
			addAll(uiPrefs, allOptions);
			addAll(corePrefs, allOptions);
			return ProfileVersioner.updateAndComplete(allOptions, version);
		}
		
		boolean hasValues= false;
		for (final Iterator keyIter = fCoreKeys.iterator(); keyIter.hasNext(); ) {
			final String key= (String) keyIter.next();
			Object val= corePrefs.get(key, null);
			if (val != null) {
				hasValues= true;
			} else {
				val= workspaceProfile.getSettings().get(key);
			}
			profileOptions.put(key, val);
		}
		
		for (final Iterator keyIter = fUIKeys.iterator(); keyIter.hasNext(); ) {
			final String key= (String) keyIter.next();
			Object val= uiPrefs.get(key, null);
			if (val != null) {
				hasValues= true;
			} else {
				val= workspaceProfile.getSettings().get(key);
			}
			profileOptions.put(key, val);
		}
		
		if (!hasValues) {
			return null;
		}

		return profileOptions;
	}
	
	/**
	 * @param uiPrefs
	 * @param allOptions
	 */
	private void addAll(IEclipsePreferences uiPrefs, Map allOptions) {
		try {
			String[] keys= uiPrefs.keys();
			for (int i= 0; i < keys.length; i++) {
				String key= keys[i];
				String val= uiPrefs.get(key, null);
				if (val != null) {
					allOptions.put(key, val);
				}
			}
		} catch (BackingStoreException e) {
			// ignore
		}
		
	}

	private boolean updatePreferences(IEclipsePreferences prefs, List keys, Map profileOptions) {
		boolean hasChanges= false;
		for (final Iterator keyIter = keys.iterator(); keyIter.hasNext(); ) {
			final String key= (String) keyIter.next();
			final String oldVal= prefs.get(key, null);
			final String val= (String) profileOptions.get(key);
			if (val == null) {
				if (oldVal != null) {
					prefs.remove(key);
					hasChanges= true;
				}
			} else if (!val.equals(oldVal)) {
				prefs.put(key, val);
				hasChanges= true;
			}
		}
		return hasChanges;
	}
	
	
	/**
	 * Update all formatter settings with the settings of the specified profile. 
	 * @param profile The profile to write to the preference store
	 */
	private void writeToPreferenceStore(Profile profile, IScopeContext context) {
		final Map profileOptions= profile.getSettings();
		
		final IEclipsePreferences corePrefs= context.getNode(CCorePlugin.PLUGIN_ID);
		updatePreferences(corePrefs, fCoreKeys, profileOptions);
		
		final IEclipsePreferences uiPrefs= context.getNode(CUIPlugin.PLUGIN_ID);
		updatePreferences(uiPrefs, fUIKeys, profileOptions);
		
		if (uiPrefs.getInt(FORMATTER_SETTINGS_VERSION, 0) != ProfileVersioner.CURRENT_VERSION) {
			uiPrefs.putInt(FORMATTER_SETTINGS_VERSION, ProfileVersioner.CURRENT_VERSION);
		}
		
		if (context.getName() == InstanceScope.SCOPE) {
			uiPrefs.put(PROFILE_KEY, profile.getID());
		} else if (context.getName() == ProjectScope.SCOPE && !profile.isSharedProfile()) {
			uiPrefs.put(PROFILE_KEY, profile.getID());
		}
	}
	
	/**
	 * Add all the built-in profiles to the map and to the list.
	 * @param profiles The map to add the profiles to
	 * @param profilesByName List of profiles by
	 */
	private void addBuiltinProfiles(Map profiles, List profilesByName) {
		final Profile eclipseProfile= new BuiltInProfile(ECLIPSE_PROFILE, FormatterMessages.ProfileManager_default_profile_name, getEclipseSettings(), 2); 
		profiles.put(eclipseProfile.getID(), eclipseProfile);
		profilesByName.add(eclipseProfile);
	}
	
	/**
	 * @return Returns the settings for the new eclipse profile.
	 */	
	public static Map getEclipseSettings() {
		return DefaultCodeFormatterConstants.getEclipseDefaultSettings();
	}

	/** 
	 * @return Returns the default settings.
	 */
	public static Map getDefaultSettings() {
		return getEclipseSettings();
	}
	
	/**
	 * @return All keys appearing in a profile, sorted alphabetically.
	 */
	public static List getKeys() {
	    return fKeys;
	}
	
	/** 
	 * Get an immutable list as view on all profiles, sorted alphabetically. Unless the set 
	 * of profiles has been modified between the two calls, the sequence is guaranteed to 
	 * correspond to the one returned by <code>getSortedNames</code>.
	 * @return a list of elements of type <code>Profile</code>
	 * 
	 * @see #getSortedDisplayNames()
	 */
	public List getSortedProfiles() {
		return Collections.unmodifiableList(fProfilesByName);
	}

	/**
	 * Get the names of all profiles stored in this profile manager, sorted alphabetically. Unless the set of 
	 * profiles has been modified between the two calls, the sequence is guaranteed to correspond to the one 
	 * returned by <code>getSortedProfiles</code>.
	 * @return All names, sorted alphabetically
	 * @see #getSortedProfiles()  
	 */	
	public String[] getSortedDisplayNames() {
		final String[] sortedNames= new String[fProfilesByName.size()];
		int i= 0;
		for (final Iterator iter = fProfilesByName.iterator(); iter.hasNext();) {
			Profile curr= (Profile) iter.next();
			sortedNames[i++]= curr.getName();
		}
		return sortedNames;
	}
	
	/**
	 * Get the profile for this profile id.
	 * @param ID The profile ID
	 * @return The profile with the given ID or <code>null</code> 
	 */
	public Profile getProfile(String ID) {
		return (Profile)fProfiles.get(ID);
	}
	
	/**
	 * Activate the selected profile, update all necessary options in
	 * preferences and save profiles to disk.
	 */
	public void commitChanges(IScopeContext scopeContext) {
		if (fSelected != null) {
			writeToPreferenceStore(fSelected, scopeContext);
		}
	}
	
	public void clearAllSettings(IScopeContext context) {
		final IEclipsePreferences corePrefs= context.getNode(CCorePlugin.PLUGIN_ID);
		updatePreferences(corePrefs, fCoreKeys, Collections.EMPTY_MAP);
		
		final IEclipsePreferences uiPrefs= context.getNode(CUIPlugin.PLUGIN_ID);
		updatePreferences(uiPrefs, fUIKeys, Collections.EMPTY_MAP);
		
		uiPrefs.remove(PROFILE_KEY);
	}
	
	/**
	 * Get the currently selected profile.
	 * @return The currently selected profile.
	 */
	public Profile getSelected() {
		return fSelected;
	}

	/**
	 * Set the selected profile. The profile must already be contained in this profile manager.
	 * @param profile The profile to select
	 */
	public void setSelected(Profile profile) {
		final Profile newSelected= (Profile)fProfiles.get(profile.getID());
		if (newSelected != null && !newSelected.equals(fSelected)) {
			fSelected= newSelected;
			notifyObservers(SELECTION_CHANGED_EVENT);
		}
	}

	/**
	 * Check whether a user-defined profile in this profile manager
	 * already has this name.
	 * @param name The name to test for
	 * @return Returns <code>true</code> if a profile with the given name exists
	 */
	public boolean containsName(String name) {
		for (final Iterator iter = fProfilesByName.iterator(); iter.hasNext();) {
			Profile curr= (Profile) iter.next();
			if (name.equals(curr.getName())) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Add a new custom profile to this profile manager.
	 * @param profile The profile to add
	 */	
	public void addProfile(CustomProfile profile) {
		profile.setManager(this);
		final CustomProfile oldProfile= (CustomProfile)fProfiles.get(profile.getID());
		if (oldProfile != null) {
			fProfiles.remove(oldProfile.getID());
			fProfilesByName.remove(oldProfile);
			oldProfile.setManager(null);
		}
		fProfiles.put(profile.getID(), profile);
		fProfilesByName.add(profile);
		Collections.sort(fProfilesByName);
		fSelected= profile;
		notifyObservers(PROFILE_CREATED_EVENT);
	}
	
	/**
	 * Delete the currently selected profile from this profile manager. The next profile
	 * in the list is selected.
	 * @return true if the profile has been successfully removed, false otherwise.
	 */
	public boolean deleteSelected() {
		if (!(fSelected instanceof CustomProfile)) 
			return false;
		
		Profile removedProfile= fSelected;
		
		int index= fProfilesByName.indexOf(removedProfile);
		
		fProfiles.remove(removedProfile.getID());
		fProfilesByName.remove(removedProfile);
		
		((CustomProfile)removedProfile).setManager(null);
		
		if (index >= fProfilesByName.size())
			index--;
		fSelected= (Profile) fProfilesByName.get(index);

		if (!removedProfile.isSharedProfile()) {
			updateProfilesWithName(removedProfile.getID(), null, false);
		}
		
		notifyObservers(PROFILE_DELETED_EVENT);
		return true;
	}
	
	public void profileRenamed(CustomProfile profile, String oldID) {
		fProfiles.remove(oldID);
		fProfiles.put(profile.getID(), profile);

		if (!profile.isSharedProfile()) {
			updateProfilesWithName(oldID, profile, false);
		}
		
		Collections.sort(fProfilesByName);
		notifyObservers(PROFILE_RENAMED_EVENT);
	}
	
	public void profileReplaced(CustomProfile oldProfile, CustomProfile newProfile) {
		fProfiles.remove(oldProfile.getID());
		fProfiles.put(newProfile.getID(), newProfile);
		fProfilesByName.remove(oldProfile);
		fProfilesByName.add(newProfile);
		Collections.sort(fProfilesByName);
		
		if (!oldProfile.isSharedProfile()) {
			updateProfilesWithName(oldProfile.getID(), null, false);
		}
		
		setSelected(newProfile);
		notifyObservers(PROFILE_CREATED_EVENT);
		notifyObservers(SELECTION_CHANGED_EVENT);
	}
	
	public void profileChanged(CustomProfile profile) {
		if (!profile.isSharedProfile()) {
			updateProfilesWithName(profile.getID(), profile, true);
		}
		
		notifyObservers(SETTINGS_CHANGED_EVENT);
	}
	
	
	private void updateProfilesWithName(String oldName, Profile newProfile, boolean applySettings) {
		IProject[] projects= ResourcesPlugin.getWorkspace().getRoot().getProjects();
		for (int i= 0; i < projects.length; i++) {
			IScopeContext projectScope= fPreferencesAccess.getProjectScope(projects[i]);
			IEclipsePreferences node= projectScope.getNode(CUIPlugin.PLUGIN_ID);
			String profileId= node.get(PROFILE_KEY, null);
			if (oldName.equals(profileId)) {
				if (newProfile == null) {
					node.remove(PROFILE_KEY);
				} else {
					if (applySettings) {
						writeToPreferenceStore(newProfile, projectScope);
					} else {
						node.put(PROFILE_KEY, newProfile.getID());
					}
				}
			}
		}
		
		IScopeContext instanceScope= fPreferencesAccess.getInstanceScope();
		final IEclipsePreferences uiPrefs= instanceScope.getNode(CUIPlugin.PLUGIN_ID);
		if (newProfile != null && oldName.equals(uiPrefs.get(PROFILE_KEY, null))) {
			writeToPreferenceStore(newProfile, instanceScope);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;

import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;

import org.eclipse.cdt.ui.CUIPlugin;

import org.eclipse.cdt.internal.ui.util.Messages;
import org.eclipse.cdt.internal.ui.util.PixelConverter;


public abstract class ModifyDialogTabPage {
	
	/**
	 * This is the default listener for any of the Preference
	 * classes. It is added by the respective factory methods and
	 * updates the page's preview on each change. 
	 */
	protected final Observer fUpdater= new Observer() {
		public void update(Observable o, Object arg) {
			doUpdatePreview();
			notifyValuesModified();
		}
	};
	
	/**
	 * The base class of all Preference classes. A preference class provides a wrapper
	 * around one or more SWT widgets and handles the input of values for some key.
	 * On each change, the new value is written to the map and the listeners are notified.
	 */
	protected abstract class Preference extends Observable {
	    private final Map fPreferences;
	    private boolean fEnabled;
	    private String fKey;
	    
	    /**
	     * Create a new Preference.
	     * @param preferences The map where the value is written.
	     * @param key The key for which a value is managed.
	     */
	    public Preference(Map preferences, String key) {
	        fPreferences= preferences;
	        fEnabled= true;
	        fKey= key;
	    }
	    /**
	     * @return Gets the map of this Preference.
	     */
	    protected final Map getPreferences() {
	        return fPreferences;
	    }

	    /**
	     * Set the enabled state of all SWT widgets of this preference. 
	     * @param enabled new value
	     */
	    public final void setEnabled(boolean enabled) {
	        fEnabled= enabled;
	        updateWidget();
	    }
	    
	    /**
	     * @return Gets the enabled state of all SWT widgets of this Preference.
	     */
	    public final boolean getEnabled() {
	        return fEnabled;
	    }
	    
	    /**
	     * Set the key which is used to store the value.
	     * @param key New value
	     */
	    public final void setKey(String key) {
	        if (key == null || !fKey.equals(key)) {
	            fKey= key;
	            updateWidget();
	        }
	    }
	    /**
	     * @return Gets the currently used key which is used to store the value.
	     */	    
	    public final String getKey() {
	        return fKey;
	    }
	    
	    /**
	     * Returns the main control of a preference, which is mainly used to 
	     * manage the focus. This may be <code>null</code> if the preference doesn't
	     * have a control which is able to have the focus. 
	     * @return The main control
	     */
	    public abstract Control getControl();
	    
	    /**
	     * To be implemented in subclasses. Update the SWT widgets when the state 
	     * of this object has changed (enabled, key, ...).
	     */
	    protected abstract void updateWidget();
	}
	
	/**
	 * Wrapper around a checkbox and a label. 
	 */	
	protected final class CheckboxPreference extends Preference {
		private final String[] fValues;
		private final Button fCheckbox;
		
		/**
		 * Create a new CheckboxPreference.
		 * @param composite The composite on which the SWT widgets are added.
		 * @param numColumns The number of columns in the composite's GridLayout.
		 * @param preferences The map to store the values.
		 * @param key The key to store the values.
		 * @param values An array of two elements indicating the values to store on unchecked/checked.
		 * @param text The label text for this Preference.
		 */
		public CheckboxPreference(Composite composite, int numColumns,
								  Map preferences, String key, 
								  String [] values, String text) {
		    super(preferences, key);
		    if (values == null || text == null) 
		        throw new IllegalArgumentException(FormatterMessages.ModifyDialogTabPage_error_msg_values_text_unassigned); 
			fValues= values;

			fCheckbox= new Button(composite, SWT.CHECK);
			fCheckbox.setText(text);
			fCheckbox.setLayoutData(createGridData(numColumns, GridData.FILL_HORIZONTAL, SWT.DEFAULT));
			fCheckbox.setFont(composite.getFont());
			
			updateWidget();

			fCheckbox.addSelectionListener(new SelectionAdapter() {
				public void widgetSelected(SelectionEvent e) {
					checkboxChecked(((Button)e.widget).getSelection());
				}
			});
		}
		
		protected void checkboxChecked(boolean state) {
			getPreferences().put(getKey(), state ? fValues[1] : fValues[0]);
			setChanged();
			notifyObservers();
		}
		
		protected void updateWidget() {
			if (getKey() != null) {
				fCheckbox.setEnabled(getEnabled());
				fCheckbox.setSelection(getChecked());
			} else {
				fCheckbox.setSelection(false);
				fCheckbox.setEnabled(false);
			}
		}
		
		public boolean getChecked() {
			return fValues[1].equals(getPreferences().get(getKey()));
		}
		
		public Control getControl() {
			return fCheckbox;
		}
	}
	
	
	/**
	 * Wrapper around a Combo box.
	 */
	protected final class ComboPreference extends Preference {
		private final String [] fItems;
		private final String[] fValues;
		private final Combo fCombo;
		
		/**
		 * Create a new ComboPreference.
		 * @param composite The composite on which the SWT widgets are added.
		 * @param numColumns The number of columns in the composite's GridLayout.
		 * @param preferences The map to store the values.
		 * @param key The key to store the values.
		 * @param values An array of n elements indicating the values to store for each selection.
		 * @param text The label text for this Preference.
		 * @param items An array of n elements indicating the text to be written in the combo box.
		 */
		public ComboPreference(Composite composite, int numColumns,
								  Map preferences, String key, 
								  String [] values, String text, String [] items) {
		    super(preferences, key);
		    if (values == null || items == null || text == null) 
		        throw new IllegalArgumentException(FormatterMessages.ModifyDialogTabPage_error_msg_values_items_text_unassigned); 
			fValues= values;
			fItems= items;
			createLabel(numColumns - 1, composite, text);
			fCombo= new Combo(composite, SWT.SINGLE | SWT.READ_ONLY);
			fCombo.setFont(composite.getFont());
			fCombo.setItems(items);
			
			int max= 0;
			for (int i= 0; i < items.length; i++)
			    if (items[i].length() > max) max= items[i].length();
			
			fCombo.setLayoutData(createGridData(1, GridData.HORIZONTAL_ALIGN_FILL, fCombo.computeSize(SWT.DEFAULT, SWT.DEFAULT).x));			

			updateWidget();

			fCombo.addSelectionListener(new SelectionAdapter() {
				public void widgetSelected(SelectionEvent e) {
					comboSelected(((Combo)e.widget).getSelectionIndex());
				}
			});
		}
		
		protected void comboSelected(int index) {
			getPreferences().put(getKey(), fValues[index]);
			setChanged();
			notifyObservers(fValues[index]);
		}
		
		protected void updateWidget() {
			if (getKey() != null) {
				fCombo.setEnabled(getEnabled());
				fCombo.setText(getSelectedItem());
			} else {
				fCombo.setText(""); //$NON-NLS-1$
				fCombo.setEnabled(false);
			}
		}
		
		public String getSelectedItem() {
			final String selected= (String)getPreferences().get(getKey());
			for (int i= 0; i < fValues.length; i++) {
				if (fValues[i].equals(selected)) {
					return fItems[i];
				}
			}
			return ""; //$NON-NLS-1$
		}
		
		public boolean hasValue(String value) {
			return value.equals(getPreferences().get(getKey()));
		}
		
		public Control getControl() {
			return fCombo;
		}
	}
	
	/**
	 * Wrapper around a textfied which requests an integer input of a given range.
	 */
	protected final class NumberPreference extends Preference {
		
		private final int fMinValue, fMaxValue;
		private final Label fNumberLabel;
		private final Text fNumberText;

		protected int fSelected;
        protected int fOldSelected;
        
        
		/**
		 * Create a new NumberPreference.
		 * @param composite The composite on which the SWT widgets are added.
		 * @param numColumns The number of columns in the composite's GridLayout.
		 * @param preferences The map to store the values.
		 * @param key The key to store the values.
		 * @param minValue The minimum value which is valid input.
		 * @param maxValue The maximum value which is valid input.
		 * @param text The label text for this Preference.
		 */
		public NumberPreference(Composite composite, int numColumns,
							   Map preferences, String key, 
							   int minValue, int maxValue, String text) {
		    super(preferences, key);
		    
			fNumberLabel= createLabel(numColumns - 1, composite, text, GridData.FILL_HORIZONTAL);
			fNumberText= new Text(composite, SWT.SINGLE | SWT.BORDER | SWT.RIGHT);
			fNumberText.setFont(composite.getFont());

			final int length= Integer.toString(maxValue).length() + 3; 
			fNumberText.setLayoutData(createGridData(1, GridData.HORIZONTAL_ALIGN_END, fPixelConverter.convertWidthInCharsToPixels(length)));
			
			fMinValue= minValue;
			fMaxValue= maxValue;
			
			updateWidget();
			
			fNumberText.addFocusListener(new FocusListener() {
				public void focusGained(FocusEvent e) {
				    NumberPreference.this.focusGained();
				}
                public void focusLost(FocusEvent e) {
				    NumberPreference.this.focusLost();
				}
			});
			
			fNumberText.addModifyListener(new ModifyListener() {
				public void modifyText(ModifyEvent e) {
					fieldModified();
				}
			});
		}
		
		private IStatus createErrorStatus() {
		    return new Status(IStatus.ERROR, CUIPlugin.getPluginId(), 0, Messages.format(FormatterMessages.ModifyDialogTabPage_NumberPreference_error_invalid_value, new String [] {Integer.toString(fMinValue), Integer.toString(fMaxValue)}), null); 
		}

		protected void focusGained() {
		    fOldSelected= fSelected;
		    fNumberText.setSelection(0, fNumberText.getCharCount());
		}
		
		protected void focusLost() {
		    updateStatus(null);
		    final String input= fNumberText.getText();
		    if (!validInput(input))
		        fSelected= fOldSelected;
		    else
		        fSelected= Integer.parseInt(input);
		    if (fSelected != fOldSelected) {
		    	saveSelected();
		    	fNumberText.setText(Integer.toString(fSelected));
		    }
		}
		
		
		protected void fieldModified() {
		    final String trimInput= fNumberText.getText().trim();
		    final boolean valid= validInput(trimInput);
		    
		    updateStatus(valid ? null : createErrorStatus());

		    if (valid) {
		        final int number= Integer.parseInt(trimInput);
		        if (fSelected != number) {
		            fSelected= number;
		            saveSelected();
		        }
		    }
		}
		
		private boolean validInput(String trimInput) {
		    int number;
		    
		    try {
		        number= Integer.parseInt(trimInput);
		    } catch (NumberFormatException x) {
		        return false;
		    }
		    
		    if (number < fMinValue) return false;
		    if (number > fMaxValue) return false;
		    return true;
		}
		
		private void saveSelected() {
			getPreferences().put(getKey(), Integer.toString(fSelected));
			setChanged();
			notifyObservers();
		}
		
		protected void updateWidget() {
		    final boolean hasKey= getKey() != null;

		    fNumberLabel.setEnabled(hasKey && getEnabled());
			fNumberText.setEnabled(hasKey && getEnabled());

			if (hasKey) {
			    String s= (String)getPreferences().get(getKey());
			    try {
			        fSelected= Integer.parseInt(s);
			    } catch (NumberFormatException e) {
			        final String message= Messages.format(FormatterMessages.ModifyDialogTabPage_NumberPreference_error_invalid_key, getKey()); 
			        CUIPlugin.getDefault().log(new Status(IStatus.ERROR, CUIPlugin.getPluginId(), IStatus.OK, message, e));
			        s= ""; //$NON-NLS-1$
			    }
			    fNumberText.setText(s);
			} else {
			    fNumberText.setText(""); //$NON-NLS-1$
			}
		}
		
		public Control getControl() {
			return fNumberText;
		}
	}

	
	/**
	 * This class provides the default way to preserve and re-establish the focus
	 * over multiple modify sessions. Each ModifyDialogTabPage has its own instance,
	 * and it should add all relevant controls upon creation, always in the same sequence.
	 * This established a mapping of controls to indexes, which allows to restore the focus
	 * in a later session. 
	 * The index is saved in the dialog settings, and there is only one common preference for 
	 * all tab pages. It is always the currently active tab page which stores its focus
	 * index. 
	 */
	protected final static class DefaultFocusManager extends FocusAdapter {
		
		private final static String PREF_LAST_FOCUS_INDEX= CUIPlugin.PLUGIN_ID + "formatter_page.modify_dialog_tab_page.last_focus_index"; //$NON-NLS-1$ 
		
		private final IDialogSettings fDialogSettings;
		
		private final Map fItemMap;
		private final List fItemList;
		
		private int fIndex;
		
		public DefaultFocusManager() {
			fDialogSettings= CUIPlugin.getDefault().getDialogSettings();
			fItemMap= new HashMap();
			fItemList= new ArrayList();
			fIndex= 0;
		}

		public void focusGained(FocusEvent e) {
			fDialogSettings.put(PREF_LAST_FOCUS_INDEX, ((Integer)fItemMap.get(e.widget)).intValue());
		}
		
		public void add(Control control) {
			control.addFocusListener(this);
			fItemList.add(fIndex, control);
			fItemMap.put(control, new Integer(fIndex++));
		}
		
		public void add(Preference preference) {
			final Control control= preference.getControl();
			if (control != null) 
				add(control);
		}
		
		public boolean isUsed() {
			return fIndex != 0;
		}
		
		public void restoreFocus() {
			int index= 0;
			try {
				index= fDialogSettings.getInt(PREF_LAST_FOCUS_INDEX);
				// make sure the value is within the range
				if ((index >= 0) && (index <= fItemList.size() - 1)) {
					((Control)fItemList.get(index)).setFocus();
				}
			} catch (NumberFormatException ex) {
				// this is the first time
			}
		}
		
		public void resetFocus() {
			fDialogSettings.put(PREF_LAST_FOCUS_INDEX, -1);
		}
	}

	/**
	 * The default focus manager. This widget knows all widgets which can have the focus
	 * and listens for focusGained events, on which it stores the index of the current
	 * focus holder. When the dialog is restarted, <code>restoreFocus()</code> sets the 
	 * focus to the last control which had it.
	 * 
	 * The standard Preference object are managed by this focus manager if they are created
	 * using the respective factory methods. Other SWT widgets can be added in subclasses 
	 * when they are created.
	 */
	protected final DefaultFocusManager fDefaultFocusManager;
	
	
	
	/**
	 * Constant array for boolean selection 
	 */
	protected static String[] FALSE_TRUE = {
		DefaultCodeFormatterConstants.FALSE,
		DefaultCodeFormatterConstants.TRUE
	};	
	
    /**
     * Constant array for insert / not_insert. 
     */
    protected static String[] DO_NOT_INSERT_INSERT = {
        CCorePlugin.DO_NOT_INSERT,
        CCorePlugin.INSERT
    };

	/**
	 * A pixel converter for layout calculations
	 */
	protected PixelConverter fPixelConverter;
	
	
	/**
	 * The map where the current settings are stored.
	 */
	protected final Map fWorkingValues;
	
	/**
	 * The modify dialog where we can display status messages.
	 */
	private final ModifyDialog fModifyDialog;


	/*
	 * Create a new <code>ModifyDialogTabPage</code>
	 */
	public ModifyDialogTabPage(ModifyDialog modifyDialog, Map workingValues) {
		fWorkingValues= workingValues;
		fModifyDialog= modifyDialog;
		fDefaultFocusManager= new DefaultFocusManager();
	}
	
	/**
	 * Create the contents of this tab page. Subclasses cannot override this, 
	 * instead they must implement <code>doCreatePreferences</code>. <code>doCreatePreview</code> may also
	 * be overridden as necessary.
	 * @param parent The parent composite
	 * @return Created content control
	 */
	public final Composite createContents(Composite parent) {
		final int numColumns= 4;
		
		if (fPixelConverter == null) {
		    fPixelConverter= new PixelConverter(parent);
		}
		
//		final SashForm fSashForm = new SashForm(parent, SWT.HORIZONTAL);
//		fSashForm.setFont(parent.getFont());
		
//		final Composite settingsPane= new Composite(fSashForm, SWT.NONE);
//		settingsPane.setFont(fSashForm.getFont());
		
		final Composite settingsPane= new Composite(parent, SWT.NONE);
		settingsPane.setFont(parent.getFont());
		settingsPane.setLayoutData(new GridData(GridData.FILL_BOTH));
		
		final GridLayout layout= new GridLayout(numColumns, false);
		layout.verticalSpacing= (int)(1.5 * fPixelConverter.convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING));
		layout.horizontalSpacing= fPixelConverter.convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
		layout.marginHeight= fPixelConverter.convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
		layout.marginWidth= fPixelConverter.convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
		settingsPane.setLayout(layout);
		doCreatePreferences(settingsPane, numColumns);

		return settingsPane;
//		final Composite previewPane= new Composite(fSashForm, SWT.NONE);
//		previewPane.setLayout(createGridLayout(numColumns, true));
//		previewPane.setFont(fSashForm.getFont());
//		doCreatePreviewPane(previewPane, numColumns);
//
//		initializePage();
//	
//		fSashForm.setWeights(new int [] {3, 3});
//		return fSashForm;
	}
	
	/**
	 * This method is called after all controls have been alloated, including the preview. 
	 * It can be used to set the preview text and to create listeners.
	 *
	 */
	protected abstract void initializePage();
	

	/**
	 * Create the left side of the modify dialog. This is meant to be implemented by subclasses. 
	 * @param composite Composite to create in
	 * @param numColumns Number of columns to use
	 */
	protected abstract void doCreatePreferences(Composite composite, int numColumns);
	

	/**
	 * Create the right side of the modify dialog. By default, the preview is displayed there.
	 * Subclasses can override this method in order to customize the right-hand side of the 
	 * dialog.
	 * @param composite Composite to create in
	 * @param numColumns Number of columns to use
	 * @return Created composite
	 */
	protected Composite doCreatePreviewPane(Composite composite, int numColumns) {
		createLabel(numColumns, composite, FormatterMessages.ModifyDialogTabPage_preview_label_text);  
		
		final CPreview preview= doCreateCPreview(composite);
		fDefaultFocusManager.add(preview.getControl());
		
		final GridData gd= createGridData(numColumns, GridData.FILL_BOTH, 0);
		gd.widthHint= 0;
		gd.heightHint=0;
		preview.getControl().setLayoutData(gd);
		
		return composite;
	}

	/**
	 * To be implemented by subclasses. This method should return an instance of CPreview.
	 * Currently, the choice is between CompilationUnitPreview which contains a valid compilation
	 * unit, or a SnippetPreview which formats several independent code snippets and displays them 
	 * in the same window.
	 * @param parent Parent composite
	 * @return Created preview
	 */
	protected abstract CPreview doCreateCPreview(Composite parent);
	
	/**
	 * This is called when the page becomes visible. 
	 * Common tasks to do include:
	 * <ul><li>Updating the preview.</li>
	 * <li>Setting the focus</li>
	 * </ul>
	 */
	final public void makeVisible() {
		fDefaultFocusManager.resetFocus();
		doUpdatePreview();
	}
	
	/**
	 * Update the preview. To be implemented by subclasses.
	 */
	protected abstract void doUpdatePreview();
	
	protected void notifyValuesModified() {
		fModifyDialog.valuesModified();
	}
    /**
     * Each tab page should remember where its last focus was, and reset it
     * correctly within this method. This method is only called after
     * initialization on the first tab page to be displayed in order to restore
     * the focus of the last session.
     */
    public void setInitialFocus() {
		if (fDefaultFocusManager.isUsed()) {
			fDefaultFocusManager.restoreFocus();
		}
	}
	

    /**
     * Set the status field on the dialog. This can be used by tab pages to report 
     * inconsistent input. The OK button is disabled if the kind is IStatus.ERROR. 
     * @param status Status describing the current page error state
     */
	protected void updateStatus(IStatus status) {
	    fModifyDialog.updateStatus(status);
	}
	
	/*
	 * Factory methods to make GUI construction easier
	 */
	
	/*
	 * Create a GridLayout with the default margin and spacing settings, as
	 * well as the specified number of columns.
	 */
	protected GridLayout createGridLayout(int numColumns, boolean margins) {
		final GridLayout layout= new GridLayout(numColumns, false);
		layout.verticalSpacing= fPixelConverter.convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
		layout.horizontalSpacing= fPixelConverter.convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
		if (margins) {
			layout.marginHeight= fPixelConverter.convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
			layout.marginWidth= fPixelConverter.convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
		} else {
			layout.marginHeight= 0;
			layout.marginWidth= 0;
		}
		return layout;
	}

	/*
	 * Convenience method to create a GridData.
	 */
	protected static GridData createGridData(int numColumns, int style, int widthHint) {
		final GridData gd= new GridData(style);
		gd.horizontalSpan= numColumns;
		gd.widthHint= widthHint;
		return gd;		
	}


	/* 
	 * Convenience method to create a label.  
	 */
	protected static Label createLabel(int numColumns, Composite parent, String text) {
		return createLabel(numColumns, parent, text, GridData.FILL_HORIZONTAL);
	}
	
	/*
	 * Convenience method to create a label
	 */
	protected static Label createLabel(int numColumns, Composite parent, String text, int gridDataStyle) {
		final Label label= new Label(parent, SWT.WRAP);
		label.setFont(parent.getFont());
		label.setText(text);
		label.setLayoutData(createGridData(numColumns, gridDataStyle, SWT.DEFAULT));
		return label;
	}

	/*
	 * Convenience method to create a group
	 */
	protected Group createGroup(int numColumns, Composite parent, String text ) {
		final Group group= new Group(parent, SWT.NONE);
		group.setFont(parent.getFont());
		group.setLayoutData(createGridData(numColumns, GridData.FILL_HORIZONTAL, SWT.DEFAULT));
		
		final GridLayout layout= new GridLayout(numColumns, false);
		layout.verticalSpacing=  fPixelConverter.convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
		layout.horizontalSpacing= fPixelConverter.convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
		layout.marginHeight=  fPixelConverter.convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);

		//layout.marginHeight= fPixelConverter.convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
		//layout.marginWidth= fPixelConverter.convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
		
		group.setLayout(layout);//createGridLayout(numColumns, true));
		group.setText(text);
		return group;
	}
	
	/*
	 * Convenience method to create a NumberPreference. The widget is registered as 
	 * a potential focus holder, and the default updater is added.
	 */
	protected NumberPreference createNumberPref(Composite composite, int numColumns, String name, String key,
												int minValue, int maxValue) {
		final NumberPreference pref= new NumberPreference(composite, numColumns, fWorkingValues, 
			key, minValue, maxValue, name);
		fDefaultFocusManager.add(pref);
		pref.addObserver(fUpdater);
		return pref;
	}
	
	/*
	 * Convenience method to create a ComboPreference. The widget is registered as 
	 * a potential focus holder, and the default updater is added.
	 */
	protected ComboPreference createComboPref(Composite composite, int numColumns, String name, 
											  String key, String [] values, String [] items) {
		final ComboPreference pref= new ComboPreference(composite, numColumns, 
			fWorkingValues, key, values, name, items);
		fDefaultFocusManager.add(pref);
		pref.addObserver(fUpdater);
		return pref;
	}

	/*
	 * Convenience method to create a CheckboxPreference. The widget is registered as 
	 * a potential focus holder, and the default updater is added.
	 */
	protected CheckboxPreference createCheckboxPref(Composite composite, int numColumns, String name, String key,
													String [] values) {
		final CheckboxPreference pref= new CheckboxPreference(composite, numColumns, 
			fWorkingValues, key, values, name);
		fDefaultFocusManager.add(pref);
		pref.addObserver(fUpdater);
		return pref;
	}
	
	/*
	 * Create a nice javadoc comment for some string.
	 */
	protected static String createPreviewHeader(String title) {
		return "/**\n* " + title + "\n*/\n"; //$NON-NLS-1$ //$NON-NLS-2$
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
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.Text;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.resource.JFaceResources;

import org.eclipse.jface.text.Assert;

import org.eclipse.ui.forms.events.ExpansionAdapter;
import org.eclipse.ui.forms.events.ExpansionEvent;
import org.eclipse.ui.forms.widgets.ExpandableComposite;

import org.eclipse.cdt.internal.ui.util.Messages;

import org.eclipse.cdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.cdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.cdt.internal.ui.util.PixelConverter;

/**
 * Configures Java Editor typing preferences.
 * 
 * @since 3.1
 */
abstract class AbstractConfigurationBlock implements IPreferenceConfigurationBlock {

	/**
	 * Use as follows:
	 * 
	 * <pre>
	 * SectionManager manager= new SectionManager();
	 * Composite composite= manager.createSectionComposite(parent);
	 * 
	 * Composite xSection= manager.createSection("section X"));
	 * xSection.setLayout(new FillLayout());
	 * new Button(xSection, SWT.PUSH); // add controls to section..
	 * 
	 * [...]
	 * 
	 * return composite; // return main composite
	 * </pre>
	 */
	protected final class SectionManager {
		/** The preference setting for keeping no section open. */
		private static final String __NONE= "__none"; //$NON-NLS-1$
		private Set fSections= new HashSet();
		private boolean fIsBeingManaged= false;
		private ExpansionAdapter fListener= new ExpansionAdapter() {
			public void expansionStateChanged(ExpansionEvent e) {
				ExpandableComposite source= (ExpandableComposite) e.getSource();
				updateSectionStyle(source);
				if (fIsBeingManaged)
					return;
				if (e.getState()) {
					try {
						fIsBeingManaged= true;
						for (Iterator iter= fSections.iterator(); iter.hasNext();) {
							ExpandableComposite composite= (ExpandableComposite) iter.next();
							if (composite != source)
								composite.setExpanded(false);
						}
					} finally {
						fIsBeingManaged= false;
					}
					if (fLastOpenKey != null && fDialogSettingsStore != null)
						fDialogSettingsStore.setValue(fLastOpenKey, source.getText());
				} else {
					if (!fIsBeingManaged && fLastOpenKey != null && fDialogSettingsStore != null)
						fDialogSettingsStore.setValue(fLastOpenKey, __NONE);
				}
				ExpandableComposite exComp= getParentExpandableComposite(source);
				if (exComp != null)
					exComp.layout(true, true);
				ScrolledPageContent parentScrolledComposite= getParentScrolledComposite(source);
				if (parentScrolledComposite != null) {
					parentScrolledComposite.reflow(true);
				}
			}
		};
		private Composite fBody;
		private final String fLastOpenKey;
		private final IPreferenceStore fDialogSettingsStore;
		private ExpandableComposite fFirstChild= null;
		/**
		 * Creates a new section manager.
		 */
		public SectionManager() {
			this(null, null);
		}
		/**
		 * Creates a new section manager.
		 */
		public SectionManager(IPreferenceStore dialogSettingsStore, String lastOpenKey) {
			fDialogSettingsStore= dialogSettingsStore;
			fLastOpenKey= lastOpenKey;
		}
		private void manage(ExpandableComposite section) {
			if (section == null)
				throw new NullPointerException();
			if (fSections.add(section))
				section.addExpansionListener(fListener);
			makeScrollableCompositeAware(section);
		}
		
		/**
		 * Creates a new composite that can contain a set of expandable
		 * sections. A <code>ScrolledPageComposite</code> is created and a new
		 * composite within that, to ensure that expanding the sections will
		 * always have enough space, unless there already is a
		 * <code>ScrolledComposite</code> along the parent chain of
		 * <code>parent</code>, in which case a normal <code>Composite</code>
		 * is created.
		 * <p>
		 * The receiver keeps a reference to the inner body composite, so that
		 * new sections can be added via <code>createSection</code>.
		 * </p>
		 * 
		 * @param parent the parent composite
		 * @return the newly created composite
		 */
		public Composite createSectionComposite(Composite parent) {
			Assert.isTrue(fBody == null);
			boolean isNested= isNestedInScrolledComposite(parent);
			Composite composite;
			if (isNested) {
				composite= new Composite(parent, SWT.NONE);
				fBody= composite;
			} else {
				composite= new ScrolledPageContent(parent);
				fBody= ((ScrolledPageContent) composite).getBody();
			}
			
			fBody.setLayout(new GridLayout());
			
			return composite;
		}
		
		/**
		 * Creates an expandable section within the parent created previously by
		 * calling <code>createSectionComposite</code>. Controls can be added 
		 * directly to the returned composite, which has no layout initially.
		 * 
		 * @param label the display name of the section
		 * @return a composite within the expandable section
		 */
		public Composite createSection(String label) {
			Assert.isNotNull(fBody);
			final ExpandableComposite excomposite= new ExpandableComposite(fBody, SWT.NONE, ExpandableComposite.TWISTIE | ExpandableComposite.CLIENT_INDENT | ExpandableComposite.COMPACT);
			if (fFirstChild == null)
				fFirstChild= excomposite;
			excomposite.setText(label);
			String last= null;
			if (fLastOpenKey != null && fDialogSettingsStore != null)
				last= fDialogSettingsStore.getString(fLastOpenKey);
			
			if (fFirstChild == excomposite && !__NONE.equals(last) || label.equals(last)) {
				excomposite.setExpanded(true);
				if (fFirstChild != excomposite)
					fFirstChild.setExpanded(false);
			} else {
				excomposite.setExpanded(false);
			}
			excomposite.setLayoutData(new GridData(GridData.FILL, GridData.BEGINNING, true, false));
			
			updateSectionStyle(excomposite);
			manage(excomposite);
			
			Composite contents= new Composite(excomposite, SWT.NONE);
			excomposite.setClient(contents);
			
			return contents;
		}
	}

	protected static final int INDENT= 20;
	private OverlayPreferenceStore fStore;
	
	private Map fCheckBoxes= new HashMap();
	private SelectionListener fCheckBoxListener= new SelectionListener() {
		public void widgetDefaultSelected(SelectionEvent e) {
		}
		public void widgetSelected(SelectionEvent e) {
			Button button= (Button) e.widget;
			fStore.setValue((String) fCheckBoxes.get(button), button.getSelection());
		}
	};
	
	
	private Map fTextFields= new HashMap();
	private ModifyListener fTextFieldListener= new ModifyListener() {
		public void modifyText(ModifyEvent e) {
			Text text= (Text) e.widget;
			fStore.setValue((String) fTextFields.get(text), text.getText());
		}
	};

	private ArrayList fNumberFields= new ArrayList();
	private ModifyListener fNumberFieldListener= new ModifyListener() {
		public void modifyText(ModifyEvent e) {
			numberFieldChanged((Text) e.widget);
		}
	};
	
	/**
	 * List of master/slave listeners when there's a dependency.
	 * 
	 * @see #createDependency(Button, Control)
	 * @since 3.0
	 */
	private ArrayList fMasterSlaveListeners= new ArrayList();
	
	private StatusInfo fStatus;
	private final PreferencePage fMainPage;

	public AbstractConfigurationBlock(OverlayPreferenceStore store) {
		Assert.isNotNull(store);
		fStore= store;
		fMainPage= null;
	}
	
	public AbstractConfigurationBlock(OverlayPreferenceStore store, PreferencePage mainPreferencePage) {
		Assert.isNotNull(store);
		Assert.isNotNull(mainPreferencePage);
		fStore= store;
		fMainPage= mainPreferencePage;
	}

	protected final ScrolledPageContent getParentScrolledComposite(Control control) {
		Control parent= control.getParent();
		while (!(parent instanceof ScrolledPageContent) && parent != null) {
			parent= parent.getParent();
		}
		if (parent instanceof ScrolledPageContent) {
			return (ScrolledPageContent) parent;
		}
		return null;
	}

	private final ExpandableComposite getParentExpandableComposite(Control control) {
		Control parent= control.getParent();
		while (!(parent instanceof ExpandableComposite) && parent != null) {
			parent= parent.getParent();
		}
		if (parent instanceof ExpandableComposite) {
			return (ExpandableComposite) parent;
		}
		return null;
	}

	protected void updateSectionStyle(ExpandableComposite excomposite) {
		excomposite.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DIALOG_FONT));
	}
	
	private void makeScrollableCompositeAware(Control control) {
		ScrolledPageContent parentScrolledComposite= getParentScrolledComposite(control);
		if (parentScrolledComposite != null) {
			parentScrolledComposite.adaptChild(control);
		}
	}
	
	private boolean isNestedInScrolledComposite(Composite parent) {
		return getParentScrolledComposite(parent) != null;
	}
	
	protected Button addCheckBox(Composite parent, String label, String key, int indentation) {		
		Button checkBox= new Button(parent, SWT.CHECK);
		checkBox.setText(label);
		
		GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
		gd.horizontalIndent= indentation;
		gd.horizontalSpan= 2;
		checkBox.setLayoutData(gd);
		checkBox.addSelectionListener(fCheckBoxListener);
		makeScrollableCompositeAware(checkBox);

		fCheckBoxes.put(checkBox, key);
		
		return checkBox;
	}

	/**
	 * Returns an array of size 2:
	 *  - first element is of type <code>Label</code>
	 *  - second element is of type <code>Text</code>
	 * Use <code>getLabelControl</code> and <code>getTextControl</code> to get the 2 controls.
	 * 
	 * @param composite 	the parent composite
	 * @param label			the text field's label
	 * @param key			the preference key
	 * @param textLimit		the text limit
	 * @param indentation	the field's indentation
	 * @param isNumber		<code>true</code> iff this text field is used to e4dit a number
	 * @return the controls added
	 */
	protected Control[] addLabelledTextField(Composite composite, String label, String key, int textLimit, int indentation, boolean isNumber) {
		
		PixelConverter pixelConverter= new PixelConverter(composite);
		
		Label labelControl= new Label(composite, SWT.NONE);
		labelControl.setText(label);
		GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
		gd.horizontalIndent= indentation;
		labelControl.setLayoutData(gd);
		
		Text textControl= new Text(composite, SWT.BORDER | SWT.SINGLE);		
		gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
		gd.widthHint= pixelConverter.convertWidthInCharsToPixels(textLimit + 1);
		textControl.setLayoutData(gd);
		textControl.setTextLimit(textLimit);
		fTextFields.put(textControl, key);
		if (isNumber) {
			fNumberFields.add(textControl);
			textControl.addModifyListener(fNumberFieldListener);
		} else {
			textControl.addModifyListener(fTextFieldListener);
		}
			
		return new Control[]{labelControl, textControl};
	}

	protected void createDependency(final Button master, final Control slave) {
		createDependency(master, new Control[] {slave});
	}
	
	protected void createDependency(final Button master, final Control[] slaves) {
		Assert.isTrue(slaves.length > 0);
		indent(slaves[0]);
		SelectionListener listener= new SelectionListener() {
			public void widgetSelected(SelectionEvent e) {
				boolean state= master.getSelection();
				for (int i= 0; i < slaves.length; i++) {
					slaves[i].setEnabled(state);
				}
			}

			public void widgetDefaultSelected(SelectionEvent e) {}
		};
		master.addSelectionListener(listener);
		fMasterSlaveListeners.add(listener);
	}

	protected static void indent(Control control) {
		((GridData) control.getLayoutData()).horizontalIndent+= INDENT;
	}

	public void initialize() {
		initializeFields();
	}

	private void initializeFields() {
		
		Iterator iter= fCheckBoxes.keySet().iterator();
		while (iter.hasNext()) {
			Button b= (Button) iter.next();
			String key= (String) fCheckBoxes.get(b);
			b.setSelection(fStore.getBoolean(key));
		}
		
		iter= fTextFields.keySet().iterator();
		while (iter.hasNext()) {
			Text t= (Text) iter.next();
			String key= (String) fTextFields.get(t);
			t.setText(fStore.getString(key));
		}
		
        // Update slaves
        iter= fMasterSlaveListeners.iterator();
        while (iter.hasNext()) {
            SelectionListener listener= (SelectionListener)iter.next();
            listener.widgetSelected(null);
        }
     
        updateStatus(new StatusInfo());
	}

	public void performOk() {
	}

	public void performDefaults() {
		initializeFields();
	}

	IStatus getStatus() {
		if (fStatus == null)
			fStatus= new StatusInfo();
		return fStatus;
	}

	/*
	 * @see org.eclipse.jdt.internal.ui.preferences.IPreferenceConfigurationBlock#dispose()
	 * @since 3.0
	 */
	public void dispose() {
	}
	
	private void numberFieldChanged(Text textControl) {
		String number= textControl.getText();
		IStatus status= validatePositiveNumber(number);
		if (!status.matches(IStatus.ERROR))
			fStore.setValue((String) fTextFields.get(textControl), number);
		updateStatus(status);
	}
	
	private IStatus validatePositiveNumber(String number) {
		StatusInfo status= new StatusInfo();
		if (number.length() == 0) {
			status.setError(PreferencesMessages.CEditorPreferencePage_empty_input); 
		} else {
			try {
				int value= Integer.parseInt(number);
				if (value < 0)
					status.setError(Messages.format(PreferencesMessages.CEditorPreferencePage_invalid_input, number)); 
			} catch (NumberFormatException e) {
				status.setError(Messages.format(PreferencesMessages.CEditorPreferencePage_invalid_input, number)); 
			}
		}
		return status;
	}

	protected void updateStatus(IStatus status) {
		if (fMainPage == null)
			return;
		fMainPage.setValid(status.isOK());
		StatusUtil.applyToStatusLine(fMainPage, status);
	}
	
	protected final OverlayPreferenceStore getPreferenceStore() {
		return fStore;
	}

	protected Composite createSubsection(Composite parent, SectionManager manager, String label) {
		if (manager != null) {
			return manager.createSection(label);
		} else {
			Group group= new Group(parent, SWT.SHADOW_NONE);
			group.setText(label);
			GridData data= new GridData(SWT.FILL, SWT.CENTER, true, false);
			group.setLayoutData(data);
			return group;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Aaron Luchko, aluchko@redhat.com - 105926 [Formatter] Exporting Unnamed profile fails silently
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences.formatter;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.StatusDialog;

import org.eclipse.cdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.Profile;
import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.SharedProfile;

/**
 * The dialog to rename a new profile. 
 */
public class RenameProfileDialog extends StatusDialog {
	
	private Label fNameLabel;
	private Text fNameText;
	
	private final StatusInfo fOk;
	private final StatusInfo fEmpty;
	private final StatusInfo fDuplicate;
	private final StatusInfo fNoMessage;

	private final Profile fProfile;
	private final ProfileManager fManager;
	private Profile fRenamedProfile;
	
	public RenameProfileDialog(Shell parentShell, Profile profile, ProfileManager manager) {
		super(parentShell);
		fManager= manager;
		setTitle(FormatterMessages.RenameProfileDialog_dialog_title); 
		fProfile= profile;
		fOk= new StatusInfo();
		fDuplicate= new StatusInfo(IStatus.ERROR, FormatterMessages.RenameProfileDialog_status_message_profile_with_this_name_already_exists); 
		fEmpty= new StatusInfo(IStatus.ERROR, FormatterMessages.RenameProfileDialog_status_message_profile_name_empty);
		fNoMessage= new StatusInfo(IStatus.ERROR, new String());
	}
	
	public Control createDialogArea(Composite parent) {
				
		final int numColumns= 2;
		
		GridLayout layout= new GridLayout();
		layout.marginHeight= convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
		layout.marginWidth= convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
		layout.verticalSpacing= convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
		layout.horizontalSpacing= convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
		layout.numColumns= numColumns;
		
		final Composite composite= new Composite(parent, SWT.NULL);
		composite.setLayout(layout);
		
		// Create "Please enter a new name:" label
		GridData gd = new GridData();
		gd.horizontalSpan = numColumns;
		gd.widthHint= convertWidthInCharsToPixels(60);
		fNameLabel = new Label(composite, SWT.NONE);
		fNameLabel.setText(FormatterMessages.RenameProfileDialog_dialog_label_enter_a_new_name); 
		fNameLabel.setLayoutData(gd);
		
		// Create text field to enter name
		gd = new GridData( GridData.FILL_HORIZONTAL);
		gd.horizontalSpan= numColumns;
		fNameText= new Text(composite, SWT.SINGLE | SWT.BORDER);
		if (fProfile instanceof SharedProfile) {
			fNameText.setText(fProfile.getName());
		}
		fNameText.setSelection(0, fProfile.getName().length());
		fNameText.setLayoutData(gd);
		fNameText.addModifyListener( new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				doValidation();
			}
		});
		fNameText.setText(fProfile.getName());
		fNameText.selectAll();
		
		applyDialogFont(composite);
		
		return composite;
	}


	/**
	 * Validate the current settings.
	 */
	protected void doValidation() {
		final String name= fNameText.getText().trim();
		
		if (name.length() == 0) {
			updateStatus(fEmpty);
			return;
		}
		
		if (name.equals(fProfile.getName())) {
			updateStatus(fNoMessage);
			return;
		}
		
		if (fManager.containsName(name)) {
			updateStatus(fDuplicate);
			return;
		}
		
		updateStatus(fOk);
	}
	
	public Profile getRenamedProfile() {
		return fRenamedProfile;
	}
	
	protected void okPressed() {
		if (!getStatus().isOK()) 
			return;
		fRenamedProfile= fProfile.rename(fNameText.getText(), fManager);
		super.okPressed();
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences;

import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.Assert;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Link;
import org.eclipse.ui.dialogs.PreferencesUtil;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.PreferenceConstants;

import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;

import org.eclipse.cdt.internal.ui.util.Messages;

/**
 * Configures C Editor typing preferences.
 */
class SmartTypingConfigurationBlock extends AbstractConfigurationBlock {

	public SmartTypingConfigurationBlock(OverlayPreferenceStore store) {
		super(store);
		
		store.addKeys(createOverlayStoreKeys());
	}
	
	private OverlayPreferenceStore.OverlayKey[] createOverlayStoreKeys() {
		return new OverlayPreferenceStore.OverlayKey[] {
			new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_SMART_PASTE),
			
			new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_CLOSE_STRINGS),
			new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_CLOSE_BRACKETS),
			new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_CLOSE_ANGULAR_BRACKETS),
			new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_CLOSE_BRACES),
			new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_WRAP_STRINGS),
			new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_ESCAPE_STRINGS),
			
//			new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_SMART_SEMICOLON),
			new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_SMART_TAB),
//			new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_SMART_OPENING_BRACE),
		};
	}	

	/**
	 * Creates page for mark occurrences preferences.
	 * 
	 * @param parent the parent composite
	 * @return the control for the preference page
	 */
	public Control createControl(Composite parent) {
		ScrolledPageContent scrolled= new ScrolledPageContent(parent, SWT.H_SCROLL | SWT.V_SCROLL);
		scrolled.setExpandHorizontal(true);
		scrolled.setExpandVertical(true);
		
		Composite control= new Composite(scrolled, SWT.NONE);
		GridLayout layout= new GridLayout();
		control.setLayout(layout);

		Composite composite;
		
		composite= createSubsection(control, null, PreferencesMessages.SmartTypingConfigurationBlock_autoclose_title); 
		addAutoclosingSection(composite);
		
//		composite= createSubsection(control, null, PreferencesMessages.SmartTypingConfigurationBlock_automove_title); 
//		addAutopositionSection(composite);
		
		composite= createSubsection(control, null, PreferencesMessages.SmartTypingConfigurationBlock_tabs_title); 
		addTabSection(composite);

		composite= createSubsection(control, null, PreferencesMessages.SmartTypingConfigurationBlock_pasting_title); 
		addPasteSection(composite);
		
		composite= createSubsection(control, null, PreferencesMessages.SmartTypingConfigurationBlock_strings_title); 
		addStringsSection(composite);

		scrolled.setContent(control);
		final Point size= control.computeSize(SWT.DEFAULT, SWT.DEFAULT);
		scrolled.setMinSize(size.x, size.y);
		return scrolled;
	}

	private void addStringsSection(Composite composite) {
		GridLayout layout= new GridLayout();
		composite.setLayout(layout);

		String label;
		Button master, slave;
		label= PreferencesMessages.CEditorPreferencePage_wrapStrings; 
		master= addCheckBox(composite, label, PreferenceConstants.EDITOR_WRAP_STRINGS, 0);
		
		label= PreferencesMessages.CEditorPreferencePage_escapeStrings; 
		slave= addCheckBox(composite, label, PreferenceConstants.EDITOR_ESCAPE_STRINGS, 0);
		createDependency(master, slave);
	}

	private void addPasteSection(Composite composite) {
		GridLayout layout= new GridLayout();
		composite.setLayout(layout);

		String label;
		label= PreferencesMessages.CEditorPreferencePage_smartPaste; 
		addCheckBox(composite, label, PreferenceConstants.EDITOR_SMART_PASTE, 0);
	}

	private void addTabSection(Composite composite) {
		GridLayout layout= new GridLayout();
		composite.setLayout(layout);

		String label;
		label= PreferencesMessages.CEditorPreferencePage_typing_smartTab; 
		addCheckBox(composite, label, PreferenceConstants.EDITOR_SMART_TAB, 0);
		
		createMessage(composite);
	}

//	private void addAutopositionSection(Composite composite) {
//		GridLayout layout= new GridLayout();
//		composite.setLayout(layout);
//
//		String label;
//		
//		label= PreferencesMessages.CEditorPreferencePage_typing_smartSemicolon; 
//		addCheckBox(composite, label, PreferenceConstants.EDITOR_SMART_SEMICOLON, 0);
//		
//		label= PreferencesMessages.CEditorPreferencePage_typing_smartOpeningBrace; 
//		addCheckBox(composite, label, PreferenceConstants.EDITOR_SMART_OPENING_BRACE, 0);
//	}

	private void addAutoclosingSection(Composite composite) {
		
		GridLayout layout= new GridLayout();
		layout.numColumns= 1;
		composite.setLayout(layout);

		String label;

		label= PreferencesMessages.CEditorPreferencePage_closeStrings;
		addCheckBox(composite, label, PreferenceConstants.EDITOR_CLOSE_STRINGS, 0);

		label= PreferencesMessages.CEditorPreferencePage_closeBrackets; 
		addCheckBox(composite, label, PreferenceConstants.EDITOR_CLOSE_BRACKETS, 0);

		label= PreferencesMessages.CEditorPreferencePage_closeAngularBrackets; 
		addCheckBox(composite, label, PreferenceConstants.EDITOR_CLOSE_ANGULAR_BRACKETS, 0);

		label= PreferencesMessages.CEditorPreferencePage_closeBraces; 
		addCheckBox(composite, label, PreferenceConstants.EDITOR_CLOSE_BRACES, 0);
	}
	
	private void createMessage(final Composite composite) {
		// TODO create a link with an argument, so the formatter preference page can open the 
		// current profile automatically.
		String linkTooltip= PreferencesMessages.SmartTypingConfigurationBlock_tabs_message_tooltip; 
		String text;
		String indentMode= CUIPlugin.getDefault().getCombinedPreferenceStore().getString(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR);
		if (CCorePlugin.TAB.equals(indentMode))
			text= Messages.format(PreferencesMessages.SmartTypingConfigurationBlock_tabs_message_tab_text, new String[] {Integer.toString(getTabDisplaySize())});
		else
			text= Messages.format(PreferencesMessages.SmartTypingConfigurationBlock_tabs_message_others_text, new String[] {Integer.toString(getTabDisplaySize()), Integer.toString(getIndentSize()), getIndentMode()}); 
		
		final Link link= new Link(composite, SWT.NONE);
		link.setText(text);
		link.setToolTipText(linkTooltip);
		GridData gd= new GridData(SWT.FILL, SWT.BEGINNING, true, false);
		gd.widthHint= 300; // don't get wider initially
		link.setLayoutData(gd);
		link.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				PreferencesUtil.createPreferenceDialogOn(link.getShell(), "org.eclipse.cdt.ui.preferences.CodeFormatterPreferencePage", null, null); //$NON-NLS-1$
			}
		});
		
		final IPreferenceStore combinedStore= CUIPlugin.getDefault().getCombinedPreferenceStore();
		final IPropertyChangeListener propertyChangeListener= new IPropertyChangeListener() {
			private boolean fHasRun= false;
			public void propertyChange(PropertyChangeEvent event) {
				if (fHasRun)
					return;
				if (composite.isDisposed())
					return;
				String property= event.getProperty();
				if (DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR.equals(property)
						|| DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE.equals(property)) {
					fHasRun= true;
					link.dispose();
					createMessage(composite);
					Dialog.applyDialogFont(composite);
					composite.redraw();
					composite.layout();
				}
			}
		};
		combinedStore.addPropertyChangeListener(propertyChangeListener);
		link.addDisposeListener(new DisposeListener() {
			public void widgetDisposed(org.eclipse.swt.events.DisposeEvent e) {
				combinedStore.removePropertyChangeListener(propertyChangeListener);
			}
		});
	}

	private String getIndentMode() {
		String indentMode= CUIPlugin.getDefault().getCombinedPreferenceStore().getString(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR);
		
		if (CCorePlugin.SPACE.equals(indentMode))
			return PreferencesMessages.SmartTypingConfigurationBlock_tabs_message_spaces; 
		
		if (CCorePlugin.TAB.equals(indentMode))
			return PreferencesMessages.SmartTypingConfigurationBlock_tabs_message_tabs;
		
		if (DefaultCodeFormatterConstants.MIXED.equals(indentMode))
			return PreferencesMessages.SmartTypingConfigurationBlock_tabs_message_tabsAndSpaces;

		Assert.isTrue(false, "Illegal indent mode - must not happen"); //$NON-NLS-1$
		return null;
	}

	private int getIndentSize() {
		return CodeFormatterUtil.getIndentWidth(null);
	}
	
	private int getTabDisplaySize() {
		return CodeFormatterUtil.getTabWidth(null);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.preferences;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.preference.PreferencePage;

import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.PlatformUI;

import org.eclipse.cdt.ui.CUIPlugin;

/**
 * Abstract preference page which is used to wrap a
 * {@link org.eclipse.cdt.internal.ui.preferences.IPreferenceConfigurationBlock}.
 * 
 * @since 3.0
 */
public abstract class AbstractConfigurationBlockPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {
	
	
	private IPreferenceConfigurationBlock fConfigurationBlock;
	private OverlayPreferenceStore fOverlayStore;
	

	/**
	 * Creates a new preference page.
	 */
	public AbstractConfigurationBlockPreferencePage() {
		setDescription();
		setPreferenceStore();
		fOverlayStore= new OverlayPreferenceStore(getPreferenceStore(), new OverlayPreferenceStore.OverlayKey[] {});
		fConfigurationBlock= createConfigurationBlock(fOverlayStore);
	}
		
	protected abstract IPreferenceConfigurationBlock createConfigurationBlock(OverlayPreferenceStore overlayPreferenceStore);
	protected abstract String getHelpId();
	protected abstract void setDescription();
	protected abstract void setPreferenceStore();
	
	/*
	 * @see IWorkbenchPreferencePage#init()
	 */	
	public void init(IWorkbench workbench) {
	}

	/*
	 * @see PreferencePage#createControl(Composite)
	 */
	public void createControl(Composite parent) {
		super.createControl(parent);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(), getHelpId());
	}
	
	/*
	 * @see PreferencePage#createContents(Composite)
	 */
	protected Control createContents(Composite parent) {
		
		fOverlayStore.load();
		fOverlayStore.start();
		
		Control content= fConfigurationBlock.createControl(parent);
		
		initialize();
		
		Dialog.applyDialogFont(content);
		return content;
	}
	
	private void initialize() {
		fConfigurationBlock.initialize();
	}
	
    /*
	 * @see PreferencePage#performOk()
	 */
	public boolean performOk() {
		
		fConfigurationBlock.performOk();

		fOverlayStore.propagate();
		
		CUIPlugin.getDefault().savePluginPreferences();
		
		return true;
	}
	
	/*
	 * @see PreferencePage#performDefaults()
	 */
	public void performDefaults() {
		
		fOverlayStore.loadDefaults();
		fConfigurationBlock.performDefaults();

		super.performDefaults();
	}
	
	/*
	 * @see DialogPage#dispose()
	 */
	public void dispose() {
		
		fConfigurationBlock.dispose();
		
		if (fOverlayStore != null) {
			fOverlayStore.stop();
			fOverlayStore= null;
		}
		
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences;

import java.util.Map;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.ControlEnableState;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Link;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.IWorkbenchPropertyPage;
import org.eclipse.ui.dialogs.PreferencesUtil;

import org.eclipse.cdt.internal.ui.dialogs.IStatusChangeListener;
import org.eclipse.cdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.cdt.internal.ui.dialogs.StatusUtil;

/**
 * Base for project property and preference pages
 */
public abstract class PropertyAndPreferencePage extends PreferencePage implements IWorkbenchPreferencePage, IWorkbenchPropertyPage {
	
	private Control fConfigurationBlockControl;
	private ControlEnableState fBlockEnableState;
	private Link fChangeWorkspaceSettings;
//	private SelectionButtonDialogField fUseProjectSettings;
	private IStatus fBlockStatus;
	private Composite fParentComposite;
	
	private IProject fProject; // project or null
	private Map fData; // page data
	
	public static final String DATA_NO_LINK= "PropertyAndPreferencePage.nolink"; //$NON-NLS-1$
	
	public PropertyAndPreferencePage() {
		fBlockStatus= new StatusInfo();
		fBlockEnableState= null;
		fProject= null;
		fData= null;
	}

	protected abstract Control createPreferenceContent(Composite composite);
	protected abstract boolean hasProjectSpecificOptions(IProject project);
	
	protected abstract String getPreferencePageID();
	protected abstract String getPropertyPageID();
	
	protected boolean supportsProjectSpecificOptions() {
		return getPropertyPageID() != null;
	}
	
	protected boolean offerLink() {
		return fData == null || !Boolean.TRUE.equals(fData.get(DATA_NO_LINK));
	}
	
// TODO: Project specific settings are not supported yet.
//protected Label createDescriptionLabel(Composite parent) {
//		fParentComposite= parent;
//		if (isProjectPreferencePage()) {
//			Composite composite= new Composite(parent, SWT.NONE);
//			composite.setFont(parent.getFont());
//			GridLayout layout= new GridLayout();
//			layout.marginHeight= 0;
//			layout.marginWidth= 0;
//			layout.numColumns= 2;
//			composite.setLayout(layout);
//			composite.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
//			
//			IDialogFieldListener listener= new IDialogFieldListener() {
//				public void dialogFieldChanged(DialogField field) {
//					enableProjectSpecificSettings(((SelectionButtonDialogField)field).isSelected());
//				}
//			};
//			
//			fUseProjectSettings= new SelectionButtonDialogField(SWT.CHECK);
//			fUseProjectSettings.setDialogFieldListener(listener);
//			fUseProjectSettings.setLabelText(PreferencesMessages.PropertyAndPreferencePage_useprojectsettings_label); 
//			fUseProjectSettings.doFillIntoGrid(composite, 1);
//			LayoutUtil.setHorizontalGrabbing(fUseProjectSettings.getSelectionButton(null));
//			
//			if (offerLink()) {
//				fChangeWorkspaceSettings= createLink(composite, PreferencesMessages.PropertyAndPreferencePage_useworkspacesettings_change);
//				fChangeWorkspaceSettings.setLayoutData(new GridData(SWT.END, SWT.CENTER, false, false));
//			} else {
//				LayoutUtil.setHorizontalSpan(fUseProjectSettings.getSelectionButton(null), 2);
//			}
//			
//			Label horizontalLine= new Label(composite, SWT.SEPARATOR | SWT.HORIZONTAL);
//			horizontalLine.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false, 2, 1));
//			horizontalLine.setFont(composite.getFont());
//		} else if (supportsProjectSpecificOptions() && offerLink()) {
//			fChangeWorkspaceSettings= createLink(parent, PreferencesMessages.PropertyAndPreferencePage_showprojectspecificsettings_label);
//			fChangeWorkspaceSettings.setLayoutData(new GridData(SWT.END, SWT.CENTER, true, false));
//		}
//
//		return super.createDescriptionLabel(parent);
//    }
	
	/*
	 * @see org.eclipse.jface.preference.IPreferencePage#createContents(Composite)
	 */
	protected Control createContents(Composite parent) {
		Composite composite= new Composite(parent, SWT.NONE);
		GridLayout layout= new GridLayout();
		layout.marginHeight= 0;
		layout.marginWidth= 0;
		composite.setLayout(layout);
		composite.setFont(parent.getFont());
			
		GridData data= new GridData(GridData.FILL, GridData.FILL, true, true);
		
		fConfigurationBlockControl= createPreferenceContent(composite);
		fConfigurationBlockControl.setLayoutData(data);

//      TODO: Project specific settings are not supported yet.
//		if (isProjectPreferencePage()) {
//			boolean useProjectSettings= hasProjectSpecificOptions(getProject());
//			enableProjectSpecificSettings(useProjectSettings);
//		}

		Dialog.applyDialogFont(composite);
		return composite;
	}

	protected boolean useProjectSettings() {
//      TODO: Project specific settings are not supported yet.
//		return isProjectPreferencePage() && fUseProjectSettings != null && fUseProjectSettings.isSelected();
		return false;
	}
	
	protected boolean isProjectPreferencePage() {
		return fProject != null;
	}
	
	protected IProject getProject() {
		return fProject;
	}
	
	protected final void openWorkspacePreferences(Object data) {
		String id= getPreferencePageID();
		PreferencesUtil.createPreferenceDialogOn(getShell(), id, new String[] { id }, data).open();
	}
	
	protected final void openProjectProperties(IProject project, Object data) {
		String id= getPropertyPageID();
		if (id != null) {
			PreferencesUtil.createPropertyDialogOn(getShell(), project, id, new String[] { id }, data).open();
		}
	}
	
//	TODO: Project specific settings are not supported yet.
//	protected void enableProjectSpecificSettings(boolean useProjectSpecificSettings) {
//		fUseProjectSettings.setSelection(useProjectSpecificSettings);
//		enablePreferenceContent(useProjectSpecificSettings);
//		updateLinkVisibility();
//		doStatusChanged();
//	}
//	
//	private void updateLinkVisibility() {
//		if (fChangeWorkspaceSettings == null || fChangeWorkspaceSettings.isDisposed()) {
//			return;
//		}
//		
//		if (isProjectPreferencePage()) {
//			fChangeWorkspaceSettings.setEnabled(!useProjectSettings());
//		}
//	}
	
	protected void setPreferenceContentStatus(IStatus status) {
		fBlockStatus= status;
		doStatusChanged();
	}
	
	/**
	 * Returns a new status change listener that calls {@link #setPreferenceContentStatus(IStatus)}
	 * when the status has changed
	 * @return The new listener
	 */
	protected IStatusChangeListener getNewStatusChangedListener() {
		return new IStatusChangeListener() {
			public void statusChanged(IStatus status) {
				setPreferenceContentStatus(status);
			}
		};		
	}
	
	protected IStatus getPreferenceContentStatus() {
		return fBlockStatus;
	}

	protected void doStatusChanged() {
		if (!isProjectPreferencePage() || useProjectSettings()) {
			updateStatus(fBlockStatus);
		} else {
			updateStatus(new StatusInfo());
		}
	}
		
	protected void enablePreferenceContent(boolean enable) {
		if (enable) {
			if (fBlockEnableState != null) {
				fBlockEnableState.restore();
				fBlockEnableState= null;
			}
		} else {
			if (fBlockEnableState == null) {
				fBlockEnableState= ControlEnableState.disable(fConfigurationBlockControl);
			}
		}	
	}
	
	/*
	 * @see org.eclipse.jface.preference.IPreferencePage#performDefaults()
	 */
	protected void performDefaults() {
//      TODO: Project specific settings are not supported yet.
//		if (useProjectSettings()) {
//			enableProjectSpecificSettings(false);
//		}
		super.performDefaults();
	}

	private void updateStatus(IStatus status) {
		setValid(!status.matches(IStatus.ERROR));
		StatusUtil.applyToStatusLine(this, status);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
	 */
	public void init(IWorkbench workbench) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWorkbenchPropertyPage#getElement()
	 */
	public IAdaptable getElement() {
		return fProject;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWorkbenchPropertyPage#setElement(org.eclipse.core.runtime.IAdaptable)
	 */
	public void setElement(IAdaptable element) {
		fProject= (IProject) element.getAdapter(IResource.class);
	}
	
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.PreferencePage#applyData(java.lang.Object)
	 */
	public void applyData(Object data) {
		if (data instanceof Map) {
			fData= (Map) data;
		}
		if (fChangeWorkspaceSettings != null) {
			if (!offerLink()) {
				fChangeWorkspaceSettings.dispose();
				fParentComposite.layout(true, true);
			}
		}
 	}
	
	protected Map getData() {
		return fData;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences.formatter;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.StatusDialog;

import org.eclipse.cdt.internal.ui.util.Messages;

import org.eclipse.cdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.CustomProfile;

/**
 * The dialog to rename an imported profile. 
 */
public class AlreadyExistsDialog extends StatusDialog {
	
	private Composite fComposite;
	protected Text fNameText;
	private Button fRenameRadio, fOverwriteRadio;
	
	private final int NUM_COLUMNS= 2;
	
	private final StatusInfo fOk;
	private final StatusInfo fEmpty;
	private final StatusInfo fDuplicate;
	
	private final CustomProfile fProfile;
	private final ProfileManager fProfileManager;
	
	public AlreadyExistsDialog(Shell parentShell, CustomProfile profile, ProfileManager profileManager) {
		super(parentShell);
		fProfile= profile;
		fProfileManager= profileManager;
		fOk= new StatusInfo();
		fDuplicate= new StatusInfo(IStatus.ERROR, FormatterMessages.AlreadyExistsDialog_message_profile_already_exists); 
		fEmpty= new StatusInfo(IStatus.ERROR, FormatterMessages.AlreadyExistsDialog_message_profile_name_empty); 
	}
	
	
	public void create() {
		super.create();
		setTitle(FormatterMessages.AlreadyExistsDialog_dialog_title); 
	}
	
	public Control createDialogArea(Composite parent) {
				
		initializeComposite(parent);
		
		createLabel(Messages.format(FormatterMessages.AlreadyExistsDialog_dialog_label, fProfile.getName())); 

		fRenameRadio= createRadioButton(FormatterMessages.AlreadyExistsDialog_rename_radio_button_desc); 
		fNameText= createTextField();

		fOverwriteRadio= createRadioButton(FormatterMessages.AlreadyExistsDialog_overwrite_radio_button_desc); 

		fRenameRadio.setSelection(true);
		
		fNameText.setText(fProfile.getName());
		fNameText.setSelection(0, fProfile.getName().length());
		fNameText.setFocus();
		
		fNameText.addModifyListener( new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				doValidation();
			}
		});
		
		fRenameRadio.addSelectionListener(new SelectionListener() {
			public void widgetSelected(SelectionEvent e) {
				fNameText.setEnabled(true);
				fNameText.setFocus();
				fNameText.setSelection(0, fNameText.getText().length());
				doValidation();
			}
			public void widgetDefaultSelected(SelectionEvent e) {
			}
		});
		
		fOverwriteRadio.addSelectionListener(new SelectionListener() {
			public void widgetSelected(SelectionEvent e) {
				fNameText.setEnabled(false);
				doValidation();
			}
			public void widgetDefaultSelected(SelectionEvent e) {
			}
		});
		
		updateStatus(fDuplicate);
		
		applyDialogFont(fComposite);
		
		return fComposite;
	}
	
	private void initializeComposite(Composite parent) {
		fComposite= new Composite(parent, SWT.NULL);
		
		final GridLayout layout= new GridLayout();
		layout.marginHeight= convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
		layout.marginWidth= convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
		layout.verticalSpacing= convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
		layout.horizontalSpacing= convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
		layout.numColumns= NUM_COLUMNS;
		
		fComposite.setLayout(layout);
	}
	
	private Label createLabel(String text) {
		final GridData gd= new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan= NUM_COLUMNS;
		gd.widthHint= convertWidthInCharsToPixels(60);
		final Label label= new Label(fComposite, SWT.WRAP);
		label.setText(text);
		label.setLayoutData(gd);
		return label;
	}
	
	private Button createRadioButton(String text) {
		final GridData gd = new GridData();
		gd.horizontalSpan = NUM_COLUMNS;
		gd.widthHint= convertWidthInCharsToPixels(60);
		final Button radio= new Button(fComposite, SWT.RADIO);
		radio.setLayoutData(gd);
		radio.setText(text);
		return radio;
	}
	
	private Text createTextField() {
		final GridData gd = new GridData( GridData.FILL_HORIZONTAL);
		gd.horizontalSpan= NUM_COLUMNS;
		final Text text= new Text(fComposite, SWT.SINGLE | SWT.BORDER);
		text.setLayoutData(gd);
		return text;
	}

	/**
	 * Validate the current settings
	 */
	protected void doValidation() {

		if (fOverwriteRadio.getSelection()) {
			updateStatus(fOk);
			return;
		}

		final String name= fNameText.getText().trim();
		
		if (name.length() == 0) {
			updateStatus(fEmpty);
			return;
		}
		
		if (fProfileManager.containsName(name)) {
			updateStatus(fDuplicate);
			return;
		}
		
		updateStatus(fOk);
	}
	
	protected void okPressed() {
		if (!getStatus().isOK()) 
			return;
		if (fRenameRadio.getSelection())
			fProfile.rename(fNameText.getText().trim(), fProfileManager);
		super.okPressed();
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.preferences.formatter;

import java.util.Map;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.preference.PreferenceStore;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.MarginPainter;
import org.eclipse.jface.text.source.SourceViewer;

import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
import org.eclipse.ui.texteditor.ChainedPreferenceStore;

import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;

import org.eclipse.cdt.ui.PreferenceConstants;
import org.eclipse.cdt.ui.text.ICPartitions;

import org.eclipse.cdt.ui.CUIPlugin;

import org.eclipse.cdt.internal.ui.editor.CSourceViewer;
import org.eclipse.cdt.internal.ui.text.CSourceViewerConfiguration;
import org.eclipse.cdt.internal.ui.text.CTextTools;
import org.eclipse.cdt.internal.ui.text.SimpleCSourceViewerConfiguration;


public abstract class CPreview {
    
	private final class CSourcePreviewerUpdater {
	    
	    final IPropertyChangeListener fontListener= new IPropertyChangeListener() {
	        public void propertyChange(PropertyChangeEvent event) {
	            if (event.getProperty().equals(PreferenceConstants.EDITOR_TEXT_FONT)) {
					final Font font= JFaceResources.getFont(PreferenceConstants.EDITOR_TEXT_FONT);
					fSourceViewer.getTextWidget().setFont(font);
					if (fMarginPainter != null) {
						fMarginPainter.initialize();
					}
				}
			}
		};
		
	    final IPropertyChangeListener propertyListener= new IPropertyChangeListener() {
			public void propertyChange(PropertyChangeEvent event) {
				if (fViewerConfiguration.affectsTextPresentation(event)) {
					fViewerConfiguration.handlePropertyChangeEvent(event);
					fSourceViewer.invalidateTextPresentation();
				}
			}
		};
		
		public CSourcePreviewerUpdater() {
			
		    JFaceResources.getFontRegistry().addListener(fontListener);
		    fPreferenceStore.addPropertyChangeListener(propertyListener);
			
			fSourceViewer.getTextWidget().addDisposeListener(new DisposeListener() {
				public void widgetDisposed(DisposeEvent e) {
					JFaceResources.getFontRegistry().removeListener(fontListener);
					fPreferenceStore.removePropertyChangeListener(propertyListener);
				}
			});
		}
	}
	
	protected final CSourceViewerConfiguration fViewerConfiguration;
	protected final Document fPreviewDocument;
	protected final SourceViewer fSourceViewer;
	protected final IPreferenceStore fPreferenceStore;
	
	protected final MarginPainter fMarginPainter;
	
	protected Map fWorkingValues;

	private int fTabSize= 0;
	
	/**
	 * Create a new C preview
	 * @param workingValues
	 * @param parent
	 */
	public CPreview(Map workingValues, Composite parent) {
		CTextTools tools= CUIPlugin.getDefault().getTextTools();
		fPreviewDocument= new Document();
		fWorkingValues= workingValues;
		tools.setupCDocumentPartitioner( fPreviewDocument, ICPartitions.C_PARTITIONING);	
		
		PreferenceStore prioritizedSettings= new PreferenceStore();
		
		IPreferenceStore[] chain= { prioritizedSettings, CUIPlugin.getDefault().getCombinedPreferenceStore() };
		fPreferenceStore= new ChainedPreferenceStore(chain);
		fSourceViewer= new CSourceViewer(parent, null, null, false, SWT.READ_ONLY | SWT.V_SCROLL | SWT.H_SCROLL | SWT.BORDER);
		fViewerConfiguration= new SimpleCSourceViewerConfiguration(tools.getColorManager(), fPreferenceStore, null, ICPartitions.C_PARTITIONING, true);
		fSourceViewer.configure(fViewerConfiguration);
		fSourceViewer.getTextWidget().setFont(JFaceResources.getFont(PreferenceConstants.EDITOR_TEXT_FONT));
		
		fMarginPainter= new MarginPainter(fSourceViewer);
		final RGB rgb= PreferenceConverter.getColor(fPreferenceStore, AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_COLOR);
		fMarginPainter.setMarginRulerColor(tools.getColorManager().getColor(rgb));
		fSourceViewer.addPainter(fMarginPainter);
		
		new CSourcePreviewerUpdater();
		fSourceViewer.setDocument(fPreviewDocument);
	}
	
	public Control getControl() {
	    return fSourceViewer.getControl();
	}
	
	public void update() {
		if (fWorkingValues == null) {
		    fPreviewDocument.set(""); //$NON-NLS-1$
		    return;
		}
		
		// update the print margin
		final String value= (String)fWorkingValues.get(DefaultCodeFormatterConstants.FORMATTER_LINE_SPLIT);
		final int lineWidth= getPositiveIntValue(value, 0);
		fMarginPainter.setMarginRulerColumn(lineWidth);
		
		// update the tab size
		final int tabSize= getPositiveIntValue((String) fWorkingValues.get(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE), 0);
		if (tabSize != fTabSize) fSourceViewer.getTextWidget().setTabs(tabSize);
		fTabSize= tabSize;
		
		final StyledText widget= (StyledText)fSourceViewer.getControl();
		final int height= widget.getClientArea().height;
		final int top0= widget.getTopPixel();
		
		final int totalPixels0= getHeightOfAllLines(widget);
		final int topPixelRange0= totalPixels0 > height ? totalPixels0 - height : 0;
		
		widget.setRedraw(false);
		doFormatPreview();
		fSourceViewer.setSelection(null);
		
		final int totalPixels1= getHeightOfAllLines(widget);
		final int topPixelRange1= totalPixels1 > height ? totalPixels1 - height : 0;

		final int top1= topPixelRange0 > 0 ? (int)(topPixelRange1 * top0 / (double)topPixelRange0) : 0;
		widget.setTopPixel(top1);
		widget.setRedraw(true);
	}
	
	private int getHeightOfAllLines(StyledText styledText) {
		int height= 0;
		int lineCount= styledText.getLineCount();
		for (int i= 0; i < lineCount; i++)
			height= height + styledText.getLineHeight(styledText.getOffsetAtLine(i));
		return height;
	}
	
	protected abstract void doFormatPreview();

	private static int getPositiveIntValue(String string, int defaultValue) {
	    try {
	        int i= Integer.parseInt(string);
	        if (i >= 0) {
	            return i;
	        }
	    } catch (NumberFormatException e) {
	    }
	    return defaultValue;
	}		
	
	public final Map getWorkingValues() {
		return fWorkingValues;
	}
	
	public final void setWorkingValues(Map workingValues) {
		fWorkingValues= workingValues;
	}
}

Lines 46-51 Link Here

(-)src/org/eclipse/cdt/core/formatter/CodeFormatter.java (+9 lines)
46	*/	46	*/
47	public static final int K_COMPILATION_UNIT = 0x08;	47	public static final int K_COMPILATION_UNIT = 0x08;
48		48
		49	/**
		50	* Kind used to format a single-line comment
		51	*/
		52	public static final int K_SINGLE_LINE_COMMENT = 0x10;
		53	/**
		54	* Kind used to format a multi-line comment
		55	*/
		56	public static final int K_MULTI_LINE_COMMENT = 0x20;
		57
49	/**	58	/**
50	* Format <code>source</code>,	59	* Format <code>source</code>,
51	* and returns a text edit that correspond to the difference between the given string and the formatted string.	60	* and returns a text edit that correspond to the difference between the given string and the formatted string.




/*******************************************************************************
 * Copyright (c) 2000, 2006 QNX Software Systems 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:
 *     QNX Software Systems - Initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.core.formatter;

import java.util.Map;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.internal.formatter.DefaultCodeFormatterOptions;
import org.eclipse.cdt.internal.formatter.align.Alignment;

/**
 */
public class CodeFormatterConstants {

	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in allocation expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.language"
	 *     - possible values:   values proposed in class <code>ParserLanguage</code> 
	 *     - default:           ParserLanguage.CPP
	 * </pre>
	 */
	public static final String FORMATTER_LANGUAGE = CCorePlugin.PLUGIN_ID + ".formatter.language";	 //$NON-NLS-1$
	
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in allocation expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.current_file"
	 *     - possible values:   object of class <code>IFile</code> or <code>null</code> 
	 *     - default:           null
	 * </pre>
	 */
	public static final String FORMATTER_CURRENT_FILE = CCorePlugin.PLUGIN_ID + ".formatter.current_file";	 //$NON-NLS-1$
	
	/**
	 * <pre>
	 * FORMATTER / Value to set a brace location at the end of a line.
	 * </pre>
	 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
	 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
	 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
	 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
 	 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
 	 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
	 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
	 */
	public static final String END_OF_LINE = "end_of_line";	//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Value to set an option to false.
	 * </pre>
	 */
	public static final String FALSE = "false"; //$NON-NLS-1$
	
	/**
	 * <pre>
	 * FORMATTER / Option to align type members of a type declaration on column
	 *     - option id:         "org.eclipse.cdt.core.formatter.formatter.align_type_members_on_columns"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           FALSE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_ALIGN_TYPE_MEMBERS_ON_COLUMNS = CCorePlugin.PLUGIN_ID + ".formatter.align_type_members_on_columns";	 //$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in allocation expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_allocation_expression"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_allocation_expression";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in enum constant
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_enum_constant"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_enum_constant";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in explicit constructor call
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_EXPLICIT_CONSTRUCTOR_CALL = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_explicit_constructor_call";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in method invocation
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_method_invocation"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_method_invocation";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in qualified allocation expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_QUALIFIED_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_qualified_allocation_expression";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of assignment
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_assignment"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, M_NO_ALIGNMENT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ASSIGNMENT  = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_assignment";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of binary expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_binary_expression"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_binary_expression";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of compact if
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_compact_if"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_BY_ONE)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_COMPACT_IF = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_compact_if";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of conditional expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_conditional_expression"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_conditional_expression";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of enum constants
	 *     - option id:        "org.eclipse.cdt.core.formatter.alignment_for_enum_constants"
	 *     - possible values:  values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:          createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ENUM_CONSTANTS = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_enum_constants";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of expressions in array initializer
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_expressions_in_array_initializer"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_expressions_in_array_initializer";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of multiple fields
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_multiple_fields"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_MULTIPLE_FIELDS = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_multiple_fields";//$NON-NLS-1$	
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of parameters in constructor declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_parameters_in_constructor_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_parameters_in_constructor_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of parameters in method declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_parameters_in_method_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_parameters_in_method_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of selector in method invocation
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_selector_in_method_invocation"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_SELECTOR_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_selector_in_method_invocation";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of superclass in type declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_superclass_in_type_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_NEXT_SHIFTED, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_SUPERCLASS_IN_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_superclass_in_type_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of superinterfaces in enum declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_enum_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of superinterfaces in type declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_superinterfaces_in_type_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_type_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of throws clause in constructor declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_throws_clause_in_constructor_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of throws clause in method declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_throws_clause_in_method_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_throws_clause_in_method_declaration";	 //$NON-NLS-1$

//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines after the imports declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_after_imports"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_AFTER_IMPORTS = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_after_imports";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines after the package declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_after_package"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_AFTER_PACKAGE = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_after_package";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines at the beginning of the method body
//	 *     - option id:         "org.eclipse.cdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_AT_BEGINNING_OF_METHOD_BODY = CCorePlugin.PLUGIN_ID + ".formatter.number_of_blank_lines_at_beginning_of_method_body"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before a field declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_field"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_FIELD = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_field";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before the first class body declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_first_class_body_declaration"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_FIRST_CLASS_BODY_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_first_class_body_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before the imports declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_imports"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_IMPORTS = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_imports";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before a member type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_member_type"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_MEMBER_TYPE = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_member_type";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_method"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_METHOD = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_method";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before a new chunk
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_new_chunk"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_NEW_CHUNK = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_new_chunk";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before the package declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_package"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_PACKAGE = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_package";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines between type declarations
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_between_type_declarations"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BETWEEN_TYPE_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_between_type_declarations";	//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of an annotation type declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_annotation_type_declaration"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_array_initializer";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a block
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_block"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_block";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a block in a case statement when the block is the first statement following
	 *             the case
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_block_in_case"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_BLOCK_IN_CASE = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_block_in_case";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a constructor declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_constructor_declaration"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_constructor_declaration";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of an enum constant
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_enum_constant"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_enum_constant";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of an enum declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_enum_declaration"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_enum_declaration";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a method declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_method_declaration"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_method_declaration";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a switch statement
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_switch"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_switch";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a type declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_type_declaration"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_type_declaration";	//$NON-NLS-1$

//	/**
//	 * <pre>
//	 * FORMATTER / Option to control whether blank lines are cleared inside comments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.clear_blank_lines"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */	
//	public final static String FORMATTER_COMMENT_CLEAR_BLANK_LINES = CCorePlugin.PLUGIN_ID + ".formatter.comment.clear_blank_lines"; //$NON-NLS-1$
	
//	/**
//	 * <pre>
//	 * FORMATTER / Option to control whether comments are formatted
//	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.format_comments"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           TRUE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */	
//	public final static String FORMATTER_COMMENT_FORMAT = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_comments"; //$NON-NLS-1$

//	/**
//	 * <pre>
//	 * FORMATTER / Option to control whether the header comment of a C/C++ source file is formatted
//	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.format_header"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */	
//	public final static String FORMATTER_COMMENT_FORMAT_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_header"; //$NON-NLS-1$

//	/**
//	 * <pre>
//	 * FORMATTER / Option to control whether HTML tags are formatted.
//	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.format_html"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           TRUE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */	
//	public final static String FORMATTER_COMMENT_FORMAT_HTML = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_html"; //$NON-NLS-1$

//	/**
//	 * <pre>
//	 * FORMATTER / Option to control whether code snippets are formatted in comments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.format_source_code"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           TRUE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */	
//	public final static String FORMATTER_COMMENT_FORMAT_SOURCE = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_source_code"; //$NON-NLS-1$
	
//	/**
//	 * <pre>
//	 * FORMATTER / Option to specify the line length for comments.
//	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.line_length"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "80"
//	 * </pre>
//	 */	
//	public final static String FORMATTER_COMMENT_LINE_LENGTH = CCorePlugin.PLUGIN_ID + ".formatter.comment.line_length"; //$NON-NLS-1$

//	/**
//	 * <pre>
//	 * FORMATTER / Option to compact else/if
//	 *     - option id:         "org.eclipse.cdt.core.formatter.compact_else_if"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           TRUE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_COMPACT_ELSE_IF = CCorePlugin.PLUGIN_ID + ".formatter.compact_else_if";	//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to set the continuation indentation
	 *     - option id:         "org.eclipse.cdt.core.formatter.continuation_indentation"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "2"
	 * </pre>
	 */
	public static final String FORMATTER_CONTINUATION_INDENTATION = CCorePlugin.PLUGIN_ID + ".formatter.continuation_indentation";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to set the continuation indentation inside array initializer
	 *     - option id:         "org.eclipse.cdt.core.formatter.continuation_indentation_for_array_initializer"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "2"
	 * </pre>
	 */
	public static final String FORMATTER_CONTINUATION_INDENTATION_FOR_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.continuation_indentation_for_array_initializer";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent body declarations compare to its enclosing annotation declaration header
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ANNOTATION_DECLARATION_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_annotation_declaration_header";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent body declarations compare to its enclosing enum constant header
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_CONSTANT_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_enum_constant_header";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent body declarations compare to its enclosing enum declaration header
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_DECLARATION_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_enum_declaration_header";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent body declarations compare to its enclosing type header
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_type_header"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_type_header";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent breaks compare to cases
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_breaks_compare_to_cases"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_BREAKS_COMPARE_TO_CASES = CCorePlugin.PLUGIN_ID + ".formatter.indent_breaks_compare_to_cases";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent empty lines
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_empty_lines"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           FALSE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_EMPTY_LINES = CCorePlugin.PLUGIN_ID + ".formatter.indent_empty_lines"; //$NON-NLS-1$	
	/**
	 * <pre>
	 * FORMATTER / Option to indent statements inside a block
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_statements_compare_to_block"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.indent_statements_compare_to_block"; //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent statements inside the body of a method or a constructor
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_statements_compare_to_body"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY = CCorePlugin.PLUGIN_ID + ".formatter.indent_statements_compare_to_body"; //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent switch statements compare to cases
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_switchstatements_compare_to_cases"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES = CCorePlugin.PLUGIN_ID + ".formatter.indent_switchstatements_compare_to_cases";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent switch statements compare to switch
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_switchstatements_compare_to_switch"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.indent_switchstatements_compare_to_switch";	//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to specify the equivalent number of spaces that represents one indentation 
	 *     - option id:         "org.eclipse.cdt.core.formatter.indentation.size"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "4"
	 * </pre>
	 * <p>This option is used only if the tab char is set to MIXED.
	 * </p>
	 * @see #FORMATTER_TAB_CHAR
	 */
	public static final String FORMATTER_INDENTATION_SIZE = CCorePlugin.PLUGIN_ID + ".formatter.indentation.size"; //$NON-NLS-1$

//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line after an annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_after_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_after_annotation";//$NON-NLS-1$
//
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line after the opening brace in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_after_opening_brace_in_array_initializer";//$NON-NLS-1$
//
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line at the end of the current file if missing
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_at_end_of_file_if_missing"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_AT_END_OF_FILE_IF_MISSING = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_at_end_of_file_if_missing";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line before the catch keyword in try statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_before_catch_in_try_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_catch_in_try_statement";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line before the closing brace in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_closing_brace_in_array_initializer";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line before the else keyword in if statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_before_else_in_if_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_else_in_if_statement";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line before the finally keyword in try statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_before_finally_in_try_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_finally_in_try_statement";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line before while in do statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_before_while_in_do_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_while_in_do_statement";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty annotation declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_annotation_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ANNOTATION_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_annotation_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty anonymous type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ANONYMOUS_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_anonymous_type_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty block
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_block"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_block";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_enum_constant";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty enum declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_enum_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_enum_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty method body
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_method_body"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_METHOD_BODY = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_method_body";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_type_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after and in wilcard
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_and_in_type_parameter"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_AND_IN_TYPE_PARAMETER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_and_in_type_parameter"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after an assignment operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_assignment_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_ASSIGNMENT_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_assignment_operator"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after at in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_at_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_AT_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_at_in_annotation"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after at in annotation type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_at_in_annotation_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_AT_IN_ANNOTATION_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_at_in_annotation_type_declaration"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after a binary operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_binary_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_BINARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_binary_operator"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the closing angle bracket in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_angle_bracket_in_type_arguments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the closing angle bracket in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_angle_bracket_in_type_parameters"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the closing brace of a block
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_closing_brace_in_block"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_BRACE_IN_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_brace_in_block"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the closing parenthesis of a cast expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_closing_paren_in_cast"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_paren_in_cast"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the colon in an assert statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_assert"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_ASSERT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_assert"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after colon in a case statement when a opening brace follows the colon
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_case"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CASE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_case";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the colon in a conditional expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_conditional"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_conditional"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after colon in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_for";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the colon in a labeled statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_labeled_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_LABELED_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_labeled_statement"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in an allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_allocation_expression"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_annotation"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_array_initializer"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the parameters of a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_constructor_declaration_parameters"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the exception names in a throws clause of a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_constructor_declaration_throws"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the arguments of an enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_CONSTANT_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_enum_constant_arguments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in enum declarations
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_enum_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_enum_declarations"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the arguments of an explicit constructor call
//	 *     - option id:         "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_explicitconstructorcall_arguments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the increments of a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_for_increments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INCREMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_for_increments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the initializations of a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_for_inits"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INITS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_for_inits"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the parameters of a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_declaration_parameters"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the exception names in a throws clause of a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_declaration_throws"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_declaration_throws"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the arguments of a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_INVOCATION_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_invocation_arguments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in multiple field declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_multiple_field_declarations"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in multiple local declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_multiple_local_declarations"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in parameterized type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_parameterized_type_reference"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in superinterfaces names of a type header
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_superinterfaces"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_SUPERINTERFACES = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_superinterfaces"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_type_arguments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_type_parameters"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after ellipsis
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_ellipsis"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_ELLIPSIS  = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_ellipsis";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening angle bracket in parameterized type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening angle bracket in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_type_arguments";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening angle bracket in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_type_parameters";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening brace in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_brace_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_brace_in_array_initializer";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening bracket inside an array allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_bracket_in_array_allocation_expression";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening bracket inside an array reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_bracket_in_array_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_bracket_in_array_reference";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_annotation"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a cast expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_cast"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CAST = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_cast"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a catch
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_catch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CATCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_catch"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_constructor_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_enum_constant"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_for"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in an if statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_if"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_IF = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_if"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_method_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_method_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_method_invocation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_method_invocation"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a parenthesized expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_parenthesized_expression"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a switch statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_switch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_switch"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a synchronized statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_synchronized"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SYNCHRONIZED = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_synchronized"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a while statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_while"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_WHILE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_while"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after a postfix operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_postfix_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_POSTFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_postfix_operator"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after a prefix operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_prefix_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_PREFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_prefix_operator"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after question mark in a conditional expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_question_in_conditional"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_question_in_conditional"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after question mark in a wildcard
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_question_in_wildcard"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_WILDCARD = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_question_in_wildcard"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after semicolon in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_semicolon_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_SEMICOLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_semicolon_in_for"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after an unary operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_unary_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_UNARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_unary_operator"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before and in wildcard
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_and_in_type_parameter"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_AND_IN_TYPE_PARAMETER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_and_in_type_parameter";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before an assignment operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_assignment_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_assignment_operator";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before at in annotation type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_at_in_annotation_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_AT_IN_ANNOTATION_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_at_in_annotation_type_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before an binary operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_binary_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_BINARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_binary_operator";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing angle bracket in parameterized type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference";		//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing angle bracket in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_type_arguments";		//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing angle bracket in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_type_parameters";		//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing brace in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_brace_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_brace_in_array_initializer";		//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing bracket in an array allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_bracket_in_array_allocation_expression";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing bracket in an array reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_bracket_in_array_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_bracket_in_array_reference";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_annotation";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a cast expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_cast"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CAST = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_cast";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a catch
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_catch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CATCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_catch";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_constructor_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_enum_constant";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_for";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in an if statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_if"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_IF = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_if";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_method_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_method_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_method_invocation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_method_invocation"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a parenthesized expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_PARENTHESIZED_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_parenthesized_expression"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a switch statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_switch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_switch";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a synchronized statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_synchronized"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SYNCHRONIZED = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_synchronized";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a while statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_while"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_WHILE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_while";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in an assert statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_assert"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_ASSERT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_assert";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in a case statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_case"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CASE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_case";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in a conditional expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_conditional"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_conditional";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in a default statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_default"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_DEFAULT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_default";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_for";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in a labeled statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_labeled_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_LABELED_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_labeled_statement";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in an allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_allocation_expression";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_annotation";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_array_initializer";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the parameters of a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_constructor_declaration_parameters";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the exception names of the throws clause of a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_constructor_declaration_throws";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the arguments of enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_CONSTANT_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_enum_constant_arguments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in enum declarations
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_enum_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_enum_declarations";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the arguments of an explicit constructor call
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_explicitconstructorcall_arguments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the increments of a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_for_increments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INCREMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_for_increments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the initializations of a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_for_inits"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INITS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_for_inits";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the parameters of a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_declaration_parameters";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the exception names of the throws clause of a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_declaration_throws"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_declaration_throws";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the arguments of a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_INVOCATION_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_invocation_arguments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in a multiple field declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_multiple_field_declarations";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in a multiple local declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_multiple_local_declarations";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in parameterized type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_parameterized_type_reference";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the superinterfaces names in a type header
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_superinterfaces"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_SUPERINTERFACES = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_superinterfaces";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_type_arguments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_type_parameters";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before ellipsis
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_ellipsis"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_ELLIPSIS  = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_ellipsis";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening angle bracket in parameterized type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE  = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening angle bracket in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_type_arguments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening angle bracket in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_type_parameters";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in an annotation type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ANNOTATION_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_annotation_type_declaration"; 	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in an anonymous type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ANONYMOUS_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_anonymous_type_declaration"; 	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_array_initializer"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in a block
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_block"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_block";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_constructor_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in an enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_enum_constant";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in an enum declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_enum_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_method_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_method_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in a switch statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_switch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_switch";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in a type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_type_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening bracket in an array allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_allocation_expression";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening bracket in an array reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_bracket_in_array_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_reference";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening bracket in an array type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_type_reference";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_annotation";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in annotation type member declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ANNOTATION_TYPE_MEMBER_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a catch
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_catch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CATCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_catch";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_constructor_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_enum_constant";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_for";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in an if statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_if"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_IF = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_if";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_method_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_method_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_method_invocation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_method_invocation";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a parenthesized expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_parenthesized_expression"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a switch statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_switch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_switch";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a synchronized statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_synchronized"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SYNCHRONIZED = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_synchronized";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a while statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_while"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_WHILE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_while";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before parenthesized expression in return statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_parenthesized_expression_in_return"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * 
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_PARENTHESIZED_EXPRESSION_IN_RETURN  = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_parenthesized_expression_in_return";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before a postfix operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_postfix_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_POSTFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_postfix_operator";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before a prefix operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_prefix_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_PREFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_prefix_operator";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before question mark in a conditional expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_question_in_conditional"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_question_in_conditional";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before question mark in a wildcard
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_question_in_wildcard"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_WILDCARD = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_question_in_wildcard"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before semicolon
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_semicolon"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_semicolon";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before semicolon in for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_semicolon_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_semicolon_in_for";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before unary operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_unary_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_UNARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_unary_operator";	//$NON-NLS-1$
//
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between brackets in an array type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_brackets_in_array_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_BRACKETS_IN_ARRAY_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_brackets_in_array_type_reference";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty braces in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_braces_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACES_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_braces_in_array_initializer";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty brackets in an array allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACKETS_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_brackets_in_array_allocation_expression";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty parenthesis in an annotation type member declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_ANNOTATION_TYPE_MEMBER_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty parenthesis in a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_constructor_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty parenthesis in enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_enum_constant";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty parenthesis in a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_method_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_method_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty parenthesis in a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_method_invocation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_method_invocation";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to keep else statement on the same line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.keep_else_statement_on_same_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_KEEP_ELSE_STATEMENT_ON_SAME_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_else_statement_on_same_line"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to keep empty array initializer one one line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.keep_empty_array_initializer_on_one_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_KEEP_EMPTY_ARRAY_INITIALIZER_ON_ONE_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_empty_array_initializer_on_one_line"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to keep guardian clause on one line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.format_guardian_clause_on_one_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_KEEP_GUARDIAN_CLAUSE_ON_ONE_LINE = CCorePlugin.PLUGIN_ID + ".formatter.format_guardian_clause_on_one_line";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to keep simple if statement on the one line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.keep_imple_if_on_one_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_KEEP_SIMPLE_IF_ON_ONE_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_imple_if_on_one_line"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to keep then statement on the same line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.keep_then_statement_on_same_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_KEEP_THEN_STATEMENT_ON_SAME_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_then_statement_on_same_line";//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to specify the length of the page. Beyond this length, the formatter will try to split the code
	 *     - option id:         "org.eclipse.cdt.core.formatter.lineSplit"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "80"
	 * </pre>
	 */
	public static final String FORMATTER_LINE_SPLIT = CCorePlugin.PLUGIN_ID + ".formatter.lineSplit"; //$NON-NLS-1$
//
//	/**
//	 * <pre>
//	 * FORMATTER / Option to specify the number of empty lines to preserve
//	 *     - option id:         "org.eclipse.cdt.core.formatter.number_of_empty_lines_to_preserve"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE = CCorePlugin.PLUGIN_ID + ".formatter.number_of_empty_lines_to_preserve";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to specify whether or not empty statement should be on a new line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.put_empty_statement_on_new_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_PUT_EMPTY_STATEMENT_ON_NEW_LINE = CCorePlugin.PLUGIN_ID + ".formatter.put_empty_statement_on_new_line";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to specify the tabulation size
	 *     - option id:         "org.eclipse.cdt.core.formatter.tabulation.char"
	 *     - possible values:   { TAB, SPACE, MIXED }
	 *     - default:           TAB
	 * </pre>
	 * More values may be added in the future.
	 * 
	 * @see CCorePlugin#TAB
	 * @see CCorePlugin#SPACE
	 * @see #MIXED
	 */
	public static final String FORMATTER_TAB_CHAR = CCorePlugin.PLUGIN_ID + ".formatter.tabulation.char"; //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to specify the equivalent number of spaces that represents one tabulation 
	 *     - option id:         "org.eclipse.cdt.core.formatter.tabulation.size"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "4"
	 * </pre>
	 */
	public static final String FORMATTER_TAB_SIZE = CCorePlugin.PLUGIN_ID + ".formatter.tabulation.size"; //$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to use tabulations only for leading indentations 
	 *     - option id:         "org.eclipse.cdt.core.formatter.use_tabs_only_for_leading_indentations"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           FALSE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS = CCorePlugin.PLUGIN_ID + ".formatter.use_tabs_only_for_leading_indentations"; //$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by indenting by one compare to the current indentation.
	 * </pre>
	 */
	public static final int INDENT_BY_ONE= 2;
	
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by using the current indentation.
	 * </pre>
	 */
	public static final int INDENT_DEFAULT= 0;
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by indenting on column under the splitting location.
	 * </pre>
	 */
	public static final int INDENT_ON_COLUMN = 1;
	
	/**
	 * <pre>
	 * FORMATTER / Possible value for the option FORMATTER_TAB_CHAR
	 * </pre>
	 * @see CCorePlugin#TAB
	 * @see CCorePlugin#SPACE
	 * @see #FORMATTER_TAB_CHAR
	 */
	public static final String MIXED = "mixed"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Value to set a brace location at the start of the next line with
//	 *             the right indentation.
//	 * </pre>
//	 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
//	 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
//	 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
//	 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
// 	 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
// 	 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
//	 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
//	 */
//	public static final String NEXT_LINE = "next_line"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Value to set a brace location at the start of the next line if a wrapping
//	 *             occured.
//	 * </pre>
//	 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
//	 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
//	 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
//	 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
// 	 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
// 	 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
//	 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
//	 */
//    public static final String NEXT_LINE_ON_WRAP = "next_line_on_wrap"; //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Value to set a brace location at the start of the next line with
	 *             an extra indentation.
	 * </pre>
	 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
	 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
	 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
	 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
 	 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
 	 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
	 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
	 */
	public static final String NEXT_LINE_SHIFTED = "next_line_shifted";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Value to set an option to true.
	 * </pre>
	 */
	public static final String TRUE = "true"; //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done using as few lines as possible.
	 * </pre>
	 */
	public static final int WRAP_COMPACT= 1;
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done putting the first element on a new
	 *             line and then wrapping next elements using as few lines as possible.
	 * </pre>
	 */
	public static final int WRAP_COMPACT_FIRST_BREAK= 2;
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by putting each element on its own line
	 *             except the first element.
	 * </pre>
	 */
	public static final int WRAP_NEXT_PER_LINE= 5;
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by putting each element on its own line.
	 *             All elements are indented by one except the first element.
	 * </pre>
	 */
	public static final int WRAP_NEXT_SHIFTED= 4;

	/**
	 * <pre>
	 * FORMATTER / Value to disable alignment.
	 * </pre>
	 */
	public static final int WRAP_NO_SPLIT= 0;
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by putting each element on its own line.
	 * </pre>
	 */
	public static final int WRAP_ONE_PER_LINE= 3;

	/*
	 * Private constants.
	 */
	private static final IllegalArgumentException WRONG_ARGUMENT = new IllegalArgumentException();
	
	/**
	 * Create a new alignment value according to the given values. This must be used to set up
	 * the alignment options.
	 * 
	 * @param forceSplit the given force value
	 * @param wrapStyle the given wrapping style
	 * @param indentStyle the given indent style
	 * 
	 * @return the new alignement value
	 */
	public static String createAlignmentValue(boolean forceSplit, int wrapStyle, int indentStyle) {
		int alignmentValue = 0; 
		switch(wrapStyle) {
			case WRAP_COMPACT :
				alignmentValue |= Alignment.M_COMPACT_SPLIT;
				break;
			case WRAP_COMPACT_FIRST_BREAK :
				alignmentValue |= Alignment.M_COMPACT_FIRST_BREAK_SPLIT;
				break;
			case WRAP_NEXT_PER_LINE :
				alignmentValue |= Alignment.M_NEXT_PER_LINE_SPLIT;
				break;
			case WRAP_NEXT_SHIFTED :
				alignmentValue |= Alignment.M_NEXT_SHIFTED_SPLIT;
				break;
			case WRAP_ONE_PER_LINE :
				alignmentValue |= Alignment.M_ONE_PER_LINE_SPLIT;
				break;
		}		
		if (forceSplit) {
			alignmentValue |= Alignment.M_FORCE;
		}
		switch(indentStyle) {
			case INDENT_BY_ONE :
				alignmentValue |= Alignment.M_INDENT_BY_ONE;
				break;
			case INDENT_ON_COLUMN :
				alignmentValue |= Alignment.M_INDENT_ON_COLUMN;
		}
		return String.valueOf(alignmentValue);
	}

	/**
	 * Returns the default Eclipse formatter settings
	 * 
	 * @return the Eclipse default settings
	 */
	public static Map getEclipseDefaultSettings() {
		return DefaultCodeFormatterOptions.getEclipseDefaultSettings().getMap();
	}

	/**
	 * <p>Return the force value of the given alignment value.
	 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @return the force value of the given alignment value
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, or if it 
	 * doesn't have a valid format.
	 */
	public static boolean getForceWrapping(String value) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value);
			return (existingValue & Alignment.M_FORCE) != 0;
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}
	}
	
	/**
	 * <p>Return the indentation style of the given alignment value.
	 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @return the indentation style of the given alignment value
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, or if it 
	 * doesn't have a valid format.
	 */
	public static int getIndentStyle(String value) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value);
			if ((existingValue & Alignment.M_INDENT_BY_ONE) != 0) {
				return INDENT_BY_ONE;
			} else if ((existingValue & Alignment.M_INDENT_ON_COLUMN) != 0) {
				return INDENT_ON_COLUMN;
			} else {
				return INDENT_DEFAULT;
			}
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}
	}

	/**
	 * <p>Return the wrapping style of the given alignment value.
	 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @return the wrapping style of the given alignment value
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, or if it 
	 * doesn't have a valid format.
	 */
	public static int getWrappingStyle(String value) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value) & Alignment.SPLIT_MASK;
			switch(existingValue) {
				case Alignment.M_COMPACT_SPLIT :
					return WRAP_COMPACT;
				case Alignment.M_COMPACT_FIRST_BREAK_SPLIT :
					return WRAP_COMPACT_FIRST_BREAK;
				case Alignment.M_NEXT_PER_LINE_SPLIT :
					return WRAP_NEXT_PER_LINE;
				case Alignment.M_NEXT_SHIFTED_SPLIT :
					return WRAP_NEXT_SHIFTED;
				case Alignment.M_ONE_PER_LINE_SPLIT :
					return WRAP_ONE_PER_LINE;
				default:
					return WRAP_NO_SPLIT;
			}
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}
	}
	/**
	 * <p>Set the force value of the given alignment value and return the new value.
	 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @param force the given force value
	 * @return the new alignment value
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, or if it 
	 * doesn't have a valid format.
	 */
	public static String setForceWrapping(String value, boolean force) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value);
			// clear existing force bit
			existingValue &= ~Alignment.M_FORCE;
			if (force) {
				existingValue |= Alignment.M_FORCE;
			}
			return String.valueOf(existingValue);
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}		
	}
	
	/**
	 * <p>Set the indentation style of the given alignment value and return the new value.
	 * The given value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @param indentStyle the given indentation style
	 * @return the new alignment value
	 * @see #INDENT_BY_ONE
	 * @see #INDENT_DEFAULT
	 * @see #INDENT_ON_COLUMN
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, if the given
	 * indentation style is not one of the possible indentation styles, or if the given
	 * alignment value doesn't have a valid format.
	 */
	public static String setIndentStyle(String value, int indentStyle) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		switch(indentStyle) {
			case INDENT_BY_ONE :
			case INDENT_DEFAULT :
			case INDENT_ON_COLUMN :
				break;
			default :
				throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value);
			// clear existing indent bits
			existingValue &= ~(Alignment.M_INDENT_BY_ONE | Alignment.M_INDENT_ON_COLUMN);
			switch(indentStyle) {
				case INDENT_BY_ONE :
					existingValue |= Alignment.M_INDENT_BY_ONE;
					break;
				case INDENT_ON_COLUMN :
					existingValue |= Alignment.M_INDENT_ON_COLUMN;
			}
			return String.valueOf(existingValue);
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}
	}
	/**
	 * <p>Set the wrapping style of the given alignment value and return the new value.
	 * The given value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @param wrappingStyle the given wrapping style
	 * @return the new alignment value
	 * @see #WRAP_COMPACT
	 * @see #WRAP_COMPACT_FIRST_BREAK
	 * @see #WRAP_NEXT_PER_LINE
	 * @see #WRAP_NEXT_SHIFTED
	 * @see #WRAP_NO_SPLIT
	 * @see #WRAP_ONE_PER_LINE
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, if the given
	 * wrapping style is not one of the possible wrapping styles, or if the given
	 * alignment value doesn't have a valid format.
	 */
	public static String setWrappingStyle(String value, int wrappingStyle) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		switch(wrappingStyle) {
			case WRAP_COMPACT :
			case WRAP_COMPACT_FIRST_BREAK :
			case WRAP_NEXT_PER_LINE :
			case WRAP_NEXT_SHIFTED :
			case WRAP_NO_SPLIT :
			case WRAP_ONE_PER_LINE :
				break;
			default:
				throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value);
			// clear existing split bits
			existingValue &= ~(Alignment.SPLIT_MASK);
			switch(wrappingStyle) {
				case WRAP_COMPACT :
					existingValue |= Alignment.M_COMPACT_SPLIT;
					break;
				case WRAP_COMPACT_FIRST_BREAK :
					existingValue |= Alignment.M_COMPACT_FIRST_BREAK_SPLIT;
					break;
				case WRAP_NEXT_PER_LINE :
					existingValue |= Alignment.M_NEXT_PER_LINE_SPLIT;
					break;
				case WRAP_NEXT_SHIFTED :
					existingValue |= Alignment.M_NEXT_SHIFTED_SPLIT;
					break;
				case WRAP_ONE_PER_LINE :
					existingValue |= Alignment.M_ONE_PER_LINE_SPLIT;
					break;
			}
			return String.valueOf(existingValue);
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}
	}
}




import java.util.HashMap;
import java.util.Map;

import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.internal.formatter.align.Alignment;



	public Map getMap() {
		Map options = new HashMap();
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ALLOCATION_EXPRESSION, getAlignment(this.alignment_for_arguments_in_allocation_expression));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ENUM_CONSTANT, getAlignment(this.alignment_for_arguments_in_enum_constant));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_EXPLICIT_CONSTRUCTOR_CALL, getAlignment(this.alignment_for_arguments_in_explicit_constructor_call));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION, getAlignment(this.alignment_for_arguments_in_method_invocation));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_QUALIFIED_ALLOCATION_EXPRESSION, getAlignment(this.alignment_for_arguments_in_qualified_allocation_expression));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ASSIGNMENT, getAlignment(this.alignment_for_assignment));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION, getAlignment(this.alignment_for_binary_expression));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_COMPACT_IF, getAlignment(this.alignment_for_compact_if));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION, getAlignment(this.alignment_for_conditional_expression));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ENUM_CONSTANTS, getAlignment(this.alignment_for_enum_constants));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER, getAlignment(this.alignment_for_expressions_in_array_initializer));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_MULTIPLE_FIELDS, getAlignment(this.alignment_for_multiple_fields));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_CONSTRUCTOR_DECLARATION, getAlignment(this.alignment_for_parameters_in_constructor_declaration));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION, getAlignment(this.alignment_for_parameters_in_method_declaration));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SELECTOR_IN_METHOD_INVOCATION, getAlignment(this.alignment_for_selector_in_method_invocation));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERCLASS_IN_TYPE_DECLARATION, getAlignment(this.alignment_for_superclass_in_type_declaration));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_ENUM_DECLARATION, getAlignment(this.alignment_for_superinterfaces_in_enum_declaration));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_TYPE_DECLARATION, getAlignment(this.alignment_for_superinterfaces_in_type_declaration));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_CONSTRUCTOR_DECLARATION, getAlignment(this.alignment_for_throws_clause_in_constructor_declaration));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_METHOD_DECLARATION, getAlignment(this.alignment_for_throws_clause_in_method_declaration));
		options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGN_TYPE_MEMBERS_ON_COLUMNS, this.align_type_members_on_columns ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER, this.brace_position_for_array_initializer);
		options.put(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK, this.brace_position_for_block);
		options.put(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK_IN_CASE, this.brace_position_for_block_in_case);
		options.put(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION, this.brace_position_for_constructor_declaration);
		options.put(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ENUM_CONSTANT, this.brace_position_for_enum_constant);
		options.put(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ENUM_DECLARATION, this.brace_position_for_enum_declaration);
		options.put(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION, this.brace_position_for_method_declaration);
		options.put(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION, this.brace_position_for_type_declaration);
		options.put(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_SWITCH, this.brace_position_for_switch);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_CLEAR_BLANK_LINES, this.comment_clear_blank_lines ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT, this.comment_format ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT_HEADER, this.comment_format_header ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT_HTML, this.comment_format_html ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_FORMAT_SOURCE, this.comment_format_source ? CodeFormatterConstants.TRUE : CodeFormatterConstants.FALSE);
//		options.put(CodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, Integer.toString(this.comment_line_length));
		options.put(DefaultCodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION, Integer.toString(this.continuation_indentation));
		options.put(DefaultCodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION_FOR_ARRAY_INITIALIZER, Integer.toString(this.continuation_indentation_for_array_initializer));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_AFTER_IMPORTS, Integer.toString(this.blank_lines_after_imports));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_AFTER_PACKAGE, Integer.toString(this.blank_lines_after_package));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_FIELD, Integer.toString(this.blank_lines_before_field));

//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_PACKAGE, Integer.toString(this.blank_lines_before_package));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_BETWEEN_TYPE_DECLARATIONS, Integer.toString(this.blank_lines_between_type_declarations));
//		options.put(CodeFormatterConstants.FORMATTER_BLANK_LINES_AT_BEGINNING_OF_METHOD_BODY, Integer.toString(this.blank_lines_at_beginning_of_method_body));
		options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK, this.indent_statements_compare_to_block ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY, this.indent_statements_compare_to_body ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_CONSTANT_HEADER, this.indent_body_declarations_compare_to_enum_constant_header ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_DECLARATION_HEADER, this.indent_body_declarations_compare_to_enum_declaration_header ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER, this.indent_body_declarations_compare_to_type_header ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_BREAKS_COMPARE_TO_CASES, this.indent_breaks_compare_to_cases ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_EMPTY_LINES, this.indent_empty_lines ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, this.indent_switchstatements_compare_to_cases ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, this.indent_switchstatements_compare_to_switch ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE, Integer.toString(this.indentation_size));
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER, this.insert_new_line_after_opening_brace_in_array_initializer? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_AT_END_OF_FILE_IF_MISSING, this.insert_new_line_at_end_of_file_if_missing ? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);
//		options.put(CodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT, this.insert_new_line_before_catch_in_try_statement? CCorePlugin.INSERT : CCorePlugin.DO_NOT_INSERT);

//		options.put(CodeFormatterConstants.FORMATTER_LINE_SPLIT, Integer.toString(this.page_width));
		switch(this.tab_char) {
			case SPACE :
				options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, CCorePlugin.SPACE);
				break;
			case TAB :
				options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, CCorePlugin.TAB);
				break;
			case MIXED :
				options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, DefaultCodeFormatterConstants.MIXED);
				break;
		}
		options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, Integer.toString(this.tab_size));
		options.put(DefaultCodeFormatterConstants.FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS, this.use_tabs_only_for_leading_indentations ?  DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
		return options;
	}

	public void set(Map settings) {
		final Object alignmentForArgumentsInAllocationExpressionOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ALLOCATION_EXPRESSION);
		if (alignmentForArgumentsInAllocationExpressionOption != null) {
			try {
				this.alignment_for_arguments_in_allocation_expression = Integer.parseInt((String) alignmentForArgumentsInAllocationExpressionOption);

				this.alignment_for_arguments_in_allocation_expression = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForArgumentsInEnumConstantOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ENUM_CONSTANT);
		if (alignmentForArgumentsInEnumConstantOption != null) {
			try {
				this.alignment_for_arguments_in_enum_constant = Integer.parseInt((String) alignmentForArgumentsInEnumConstantOption);

				this.alignment_for_arguments_in_enum_constant = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForArgumentsInExplicitConstructorCallOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_EXPLICIT_CONSTRUCTOR_CALL);
		if (alignmentForArgumentsInExplicitConstructorCallOption != null) {
			try {
				this.alignment_for_arguments_in_explicit_constructor_call = Integer.parseInt((String) alignmentForArgumentsInExplicitConstructorCallOption);

				this.alignment_for_arguments_in_explicit_constructor_call = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForArgumentsInMethodInvocationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION);
		if (alignmentForArgumentsInMethodInvocationOption != null) {
			try {
				this.alignment_for_arguments_in_method_invocation = Integer.parseInt((String) alignmentForArgumentsInMethodInvocationOption);

				this.alignment_for_arguments_in_method_invocation = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForArgumentsInQualifiedAllocationExpressionOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_QUALIFIED_ALLOCATION_EXPRESSION);
		if (alignmentForArgumentsInQualifiedAllocationExpressionOption != null) {
			try {
				this.alignment_for_arguments_in_qualified_allocation_expression = Integer.parseInt((String) alignmentForArgumentsInQualifiedAllocationExpressionOption);

				this.alignment_for_arguments_in_qualified_allocation_expression = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForAssignmentOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ASSIGNMENT);
		if (alignmentForAssignmentOption != null) {
			try {
				this.alignment_for_assignment = Integer.parseInt((String) alignmentForAssignmentOption);

				this.alignment_for_assignment =  Alignment.M_ONE_PER_LINE_SPLIT;
			}
		}
		final Object alignmentForBinaryExpressionOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION);
		if (alignmentForBinaryExpressionOption != null) {
			try {
				this.alignment_for_binary_expression = Integer.parseInt((String) alignmentForBinaryExpressionOption);

				this.alignment_for_binary_expression =  Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForCompactIfOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_COMPACT_IF);
		if (alignmentForCompactIfOption != null) {
			try {
				this.alignment_for_compact_if = Integer.parseInt((String) alignmentForCompactIfOption);

				this.alignment_for_compact_if = Alignment.M_ONE_PER_LINE_SPLIT | Alignment.M_INDENT_BY_ONE;
			}
		}
		final Object alignmentForConditionalExpressionOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION);
		if (alignmentForConditionalExpressionOption != null) {
			try {
				this.alignment_for_conditional_expression = Integer.parseInt((String) alignmentForConditionalExpressionOption);

				this.alignment_for_conditional_expression = Alignment.M_ONE_PER_LINE_SPLIT;
			}
		}
		final Object alignmentForEnumConstantsOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_ENUM_CONSTANTS);
		if (alignmentForEnumConstantsOption != null) {
			try {
				this.alignment_for_enum_constants = Integer.parseInt((String) alignmentForEnumConstantsOption);

				this.alignment_for_enum_constants = Alignment.NONE;
			}
		}
		final Object alignmentForExpressionsInArrayInitializerOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER);
		if (alignmentForExpressionsInArrayInitializerOption != null) {
			try {
				this.alignment_for_expressions_in_array_initializer = Integer.parseInt((String) alignmentForExpressionsInArrayInitializerOption);

				this.alignment_for_expressions_in_array_initializer = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForMultipleFieldsOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_MULTIPLE_FIELDS);
		if (alignmentForMultipleFieldsOption != null) {
			try {
				this.alignment_for_multiple_fields = Integer.parseInt((String) alignmentForMultipleFieldsOption);

				this.alignment_for_multiple_fields = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForParametersInConstructorDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_CONSTRUCTOR_DECLARATION);
		if (alignmentForParametersInConstructorDeclarationOption != null) {
			try {
				this.alignment_for_parameters_in_constructor_declaration = Integer.parseInt((String) alignmentForParametersInConstructorDeclarationOption);

				this.alignment_for_parameters_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForParametersInMethodDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION);
		if (alignmentForParametersInMethodDeclarationOption != null) {
			try {
				this.alignment_for_parameters_in_method_declaration = Integer.parseInt((String) alignmentForParametersInMethodDeclarationOption);

				this.alignment_for_parameters_in_method_declaration = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForSelectorInMethodInvocationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SELECTOR_IN_METHOD_INVOCATION);
		if (alignmentForSelectorInMethodInvocationOption != null) {
			try {
				this.alignment_for_selector_in_method_invocation = Integer.parseInt((String) alignmentForSelectorInMethodInvocationOption);

				this.alignment_for_selector_in_method_invocation = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForSuperclassInTypeDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERCLASS_IN_TYPE_DECLARATION);
		if (alignmentForSuperclassInTypeDeclarationOption != null) {
			try {
				this.alignment_for_superclass_in_type_declaration = Integer.parseInt((String) alignmentForSuperclassInTypeDeclarationOption);

				this.alignment_for_superclass_in_type_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
			}
		}
		final Object alignmentForSuperinterfacesInEnumDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_ENUM_DECLARATION);
		if (alignmentForSuperinterfacesInEnumDeclarationOption != null) {
			try {
				this.alignment_for_superinterfaces_in_enum_declaration = Integer.parseInt((String) alignmentForSuperinterfacesInEnumDeclarationOption);

				this.alignment_for_superinterfaces_in_enum_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
			}
		}
		final Object alignmentForSuperinterfacesInTypeDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_TYPE_DECLARATION);
		if (alignmentForSuperinterfacesInTypeDeclarationOption != null) {
			try {
				this.alignment_for_superinterfaces_in_type_declaration = Integer.parseInt((String) alignmentForSuperinterfacesInTypeDeclarationOption);

				this.alignment_for_superinterfaces_in_type_declaration = Alignment.M_NEXT_SHIFTED_SPLIT;
			}
		}
		final Object alignmentForThrowsClauseInConstructorDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_CONSTRUCTOR_DECLARATION);
		if (alignmentForThrowsClauseInConstructorDeclarationOption != null) {
			try {
				this.alignment_for_throws_clause_in_constructor_declaration = Integer.parseInt((String) alignmentForThrowsClauseInConstructorDeclarationOption);

				this.alignment_for_throws_clause_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignmentForThrowsClauseInMethodDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_METHOD_DECLARATION);
		if (alignmentForThrowsClauseInMethodDeclarationOption != null) {
			try {
				this.alignment_for_throws_clause_in_method_declaration = Integer.parseInt((String) alignmentForThrowsClauseInMethodDeclarationOption);

				this.alignment_for_throws_clause_in_method_declaration = Alignment.M_COMPACT_SPLIT;
			}
		}
		final Object alignTypeMembersOnColumnsOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_ALIGN_TYPE_MEMBERS_ON_COLUMNS);
		if (alignTypeMembersOnColumnsOption != null) {
			this.align_type_members_on_columns = DefaultCodeFormatterConstants.TRUE.equals(alignTypeMembersOnColumnsOption);
		}
		final Object bracePositionForArrayInitializerOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER);
		if (bracePositionForArrayInitializerOption != null) {
			try {
				this.brace_position_for_array_initializer = (String) bracePositionForArrayInitializerOption;
			} catch(ClassCastException e) {
				this.brace_position_for_array_initializer = DefaultCodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForBlockOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK);
		if (bracePositionForBlockOption != null) {
			try {
				this.brace_position_for_block = (String) bracePositionForBlockOption;
			} catch(ClassCastException e) {
				this.brace_position_for_block = DefaultCodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForBlockInCaseOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK_IN_CASE);
		if (bracePositionForBlockInCaseOption != null) {
			try {
				this.brace_position_for_block_in_case = (String) bracePositionForBlockInCaseOption;
			} catch(ClassCastException e) {
				this.brace_position_for_block_in_case = DefaultCodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForConstructorDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION);
		if (bracePositionForConstructorDeclarationOption != null) {
			try {
				this.brace_position_for_constructor_declaration = (String) bracePositionForConstructorDeclarationOption;
			} catch(ClassCastException e) {
				this.brace_position_for_constructor_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForEnumConstantOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ENUM_CONSTANT);
		if (bracePositionForEnumConstantOption != null) {
			try {
				this.brace_position_for_enum_constant = (String) bracePositionForEnumConstantOption;
			} catch(ClassCastException e) {
				this.brace_position_for_enum_constant = DefaultCodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForEnumDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ENUM_DECLARATION);
		if (bracePositionForEnumDeclarationOption != null) {
			try {
				this.brace_position_for_enum_declaration = (String) bracePositionForEnumDeclarationOption;
			} catch(ClassCastException e) {
				this.brace_position_for_enum_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForMethodDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION);
		if (bracePositionForMethodDeclarationOption != null) {
			try {
				this.brace_position_for_method_declaration = (String) bracePositionForMethodDeclarationOption;
			} catch(ClassCastException e) {
				this.brace_position_for_method_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForSwitchOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_SWITCH);
		if (bracePositionForSwitchOption != null) {
			try {
				this.brace_position_for_switch = (String) bracePositionForSwitchOption;
			} catch(ClassCastException e) {
				this.brace_position_for_switch = DefaultCodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object bracePositionForTypeDeclarationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION);
		if (bracePositionForTypeDeclarationOption != null) {
			try {
				this.brace_position_for_type_declaration = (String) bracePositionForTypeDeclarationOption;
			} catch(ClassCastException e) {
				this.brace_position_for_type_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
			}
		}
		final Object continuationIndentationOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION);
		if (continuationIndentationOption != null) {
			try {
				this.continuation_indentation = Integer.parseInt((String) continuationIndentationOption);

				this.continuation_indentation = 2;
			}
		}
		final Object continuationIndentationForArrayInitializerOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_CONTINUATION_INDENTATION_FOR_ARRAY_INITIALIZER);
		if (continuationIndentationForArrayInitializerOption != null) {
			try {
				this.continuation_indentation_for_array_initializer = Integer.parseInt((String) continuationIndentationForArrayInitializerOption);

//				this.comment_line_length = 80;
//			}
//		}
		final Object indentStatementsCompareToBlockOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK);
		if (indentStatementsCompareToBlockOption != null) {
			this.indent_statements_compare_to_block = DefaultCodeFormatterConstants.TRUE.equals(indentStatementsCompareToBlockOption);
		}
		final Object indentStatementsCompareToBodyOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY);
		if (indentStatementsCompareToBodyOption != null) {
			this.indent_statements_compare_to_body = DefaultCodeFormatterConstants.TRUE.equals(indentStatementsCompareToBodyOption);
		}
		final Object indentBodyDeclarationsCompareToEnumConstantHeaderOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_CONSTANT_HEADER);
		if (indentBodyDeclarationsCompareToEnumConstantHeaderOption != null) {
			this.indent_body_declarations_compare_to_enum_constant_header = DefaultCodeFormatterConstants.TRUE.equals(indentBodyDeclarationsCompareToEnumConstantHeaderOption);
		}
		final Object indentBodyDeclarationsCompareToEnumDeclarationHeaderOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_DECLARATION_HEADER);
		if (indentBodyDeclarationsCompareToEnumDeclarationHeaderOption != null) {
			this.indent_body_declarations_compare_to_enum_declaration_header = DefaultCodeFormatterConstants.TRUE.equals(indentBodyDeclarationsCompareToEnumDeclarationHeaderOption);
		}
		final Object indentBodyDeclarationsCompareToTypeHeaderOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER);
		if (indentBodyDeclarationsCompareToTypeHeaderOption != null) {
			this.indent_body_declarations_compare_to_type_header = DefaultCodeFormatterConstants.TRUE.equals(indentBodyDeclarationsCompareToTypeHeaderOption);
		}
		final Object indentBreaksCompareToCasesOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_BREAKS_COMPARE_TO_CASES);
		if (indentBreaksCompareToCasesOption != null) {
			this.indent_breaks_compare_to_cases = DefaultCodeFormatterConstants.TRUE.equals(indentBreaksCompareToCasesOption);
		}
		final Object indentEmptyLinesOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_EMPTY_LINES);
		if (indentEmptyLinesOption != null) {
			this.indent_empty_lines = DefaultCodeFormatterConstants.TRUE.equals(indentEmptyLinesOption);
		}
		final Object indentSwitchstatementsCompareToCasesOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES);
		if (indentSwitchstatementsCompareToCasesOption != null) {
			this.indent_switchstatements_compare_to_cases = DefaultCodeFormatterConstants.TRUE.equals(indentSwitchstatementsCompareToCasesOption);
		}
		final Object indentSwitchstatementsCompareToSwitchOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH);
		if (indentSwitchstatementsCompareToSwitchOption != null) {
			this.indent_switchstatements_compare_to_switch = DefaultCodeFormatterConstants.TRUE.equals(indentSwitchstatementsCompareToSwitchOption);
		}
		final Object indentationSizeOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE);
		if (indentationSizeOption != null) {
			try {
				this.indentation_size = Integer.parseInt((String) indentationSizeOption);

//		if (putEmptyStatementOnNewLineOption != null) {
//			this.put_empty_statement_on_new_line = CodeFormatterConstants.TRUE.equals(putEmptyStatementOnNewLineOption);
//		}
		final Object tabSizeOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE);
		if (tabSizeOption != null) {
			try {
				this.tab_size = Integer.parseInt((String) tabSizeOption);

				this.tab_size = 4;
			}
		}
		final Object useTabsOnlyForLeadingIndentationsOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS);
		if (useTabsOnlyForLeadingIndentationsOption != null) {
			this.use_tabs_only_for_leading_indentations = DefaultCodeFormatterConstants.TRUE.equals(useTabsOnlyForLeadingIndentationsOption);
		}
		final Object pageWidthOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_LINE_SPLIT);
		if (pageWidthOption != null) {
			try {
				this.page_width = Integer.parseInt((String) pageWidthOption);

				this.page_width = 80;
			}
		}
		final Object useTabOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR);
		if (useTabOption != null) {
			if (CCorePlugin.TAB.equals(useTabOption)) {
				this.tab_char = TAB;

		this.alignment_for_throws_clause_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_throws_clause_in_method_declaration = Alignment.M_COMPACT_SPLIT;
		this.align_type_members_on_columns = false;
		this.brace_position_for_array_initializer = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_block = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_block_in_case = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_constructor_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_enum_constant = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_enum_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_method_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_type_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_switch = DefaultCodeFormatterConstants.END_OF_LINE;
//		this.comment_clear_blank_lines = false;
//		this.comment_format = true;
//		this.comment_format_header = false;

		this.alignment_for_throws_clause_in_constructor_declaration = Alignment.M_COMPACT_SPLIT;
		this.alignment_for_throws_clause_in_method_declaration = Alignment.M_COMPACT_SPLIT;
		this.align_type_members_on_columns = false;
		this.brace_position_for_array_initializer = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_block = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_block_in_case = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_constructor_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_enum_constant = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_enum_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_method_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_type_declaration = DefaultCodeFormatterConstants.END_OF_LINE;
		this.brace_position_for_switch = DefaultCodeFormatterConstants.END_OF_LINE;
//		this.comment_clear_blank_lines = false;
//		this.comment_format = true;
//		this.comment_format_header = false;

Lines 17-23 Link Here

(-)src/org/eclipse/cdt/internal/core/CCorePreferenceInitializer.java (-2 / +2 lines)
17		17
18	import org.eclipse.cdt.core.CCorePlugin;	18	import org.eclipse.cdt.core.CCorePlugin;
19	import org.eclipse.cdt.core.CCorePreferenceConstants;	19	import org.eclipse.cdt.core.CCorePreferenceConstants;
20	import org.eclipse.cdt.core.formatter.CodeFormatterConstants;	20	import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
21	import org.eclipse.cdt.internal.core.model.CModelManager;	21	import org.eclipse.cdt.internal.core.model.CModelManager;
22	//import org.eclipse.core.runtime.Preferences;	22	//import org.eclipse.core.runtime.Preferences;
23	import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;	23	import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;
Lines 35-41 Link Here
35	HashSet optionNames = CModelManager.OptionNames;	35	HashSet optionNames = CModelManager.OptionNames;
36		36
37	// Formatter settings	37	// Formatter settings
38	Map defaultOptionsMap = CodeFormatterConstants.getEclipseDefaultSettings(); // code formatter defaults	38	Map defaultOptionsMap = DefaultCodeFormatterConstants.getEclipseDefaultSettings(); // code formatter defaults
39		39
40	// Compiler settings	40	// Compiler settings
41	defaultOptionsMap.put(CCorePreferenceConstants.TRANSLATION_TASK_TAGS, CCorePreferenceConstants.DEFAULT_TASK_TAG);	41	defaultOptionsMap.put(CCorePreferenceConstants.TRANSLATION_TASK_TAGS, CCorePreferenceConstants.DEFAULT_TASK_TAG);




/*******************************************************************************
 * Copyright (c) 2000, 2006 QNX Software Systems 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:
 *     QNX Software Systems - Initial API and implementation
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.core.formatter;

import java.util.Map;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.internal.formatter.DefaultCodeFormatterOptions;
import org.eclipse.cdt.internal.formatter.align.Alignment;

/**
 */
public class DefaultCodeFormatterConstants {

	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in allocation expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.language"
	 *     - possible values:   values proposed in class <code>ParserLanguage</code> 
	 *     - default:           ParserLanguage.CPP
	 * </pre>
	 */
	public static final String FORMATTER_LANGUAGE = CCorePlugin.PLUGIN_ID + ".formatter.language";	 //$NON-NLS-1$
	
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in allocation expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.current_file"
	 *     - possible values:   object of class <code>IFile</code> or <code>null</code> 
	 *     - default:           null
	 * </pre>
	 */
	public static final String FORMATTER_CURRENT_FILE = CCorePlugin.PLUGIN_ID + ".formatter.current_file";	 //$NON-NLS-1$
	
	/**
	 * <pre>
	 * FORMATTER / Value to set a brace location at the end of a line.
	 * </pre>
	 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
	 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
	 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
	 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
 	 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
 	 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
	 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
	 */
	public static final String END_OF_LINE = "end_of_line";	//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Value to set an option to false.
	 * </pre>
	 */
	public static final String FALSE = "false"; //$NON-NLS-1$
	
	/**
	 * <pre>
	 * FORMATTER / Option to align type members of a type declaration on column
	 *     - option id:         "org.eclipse.cdt.core.formatter.formatter.align_type_members_on_columns"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           FALSE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_ALIGN_TYPE_MEMBERS_ON_COLUMNS = CCorePlugin.PLUGIN_ID + ".formatter.align_type_members_on_columns";	 //$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in allocation expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_allocation_expression"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_allocation_expression";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in enum constant
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_enum_constant"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_enum_constant";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in explicit constructor call
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_EXPLICIT_CONSTRUCTOR_CALL = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_explicit_constructor_call";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in method invocation
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_method_invocation"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_method_invocation";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of arguments in qualified allocation expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_QUALIFIED_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_arguments_in_qualified_allocation_expression";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of assignment
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_assignment"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, M_NO_ALIGNMENT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ASSIGNMENT  = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_assignment";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of binary expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_binary_expression"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_binary_expression";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of compact if
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_compact_if"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_BY_ONE)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_COMPACT_IF = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_compact_if";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of conditional expression
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_conditional_expression"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_conditional_expression";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of enum constants
	 *     - option id:        "org.eclipse.cdt.core.formatter.alignment_for_enum_constants"
	 *     - possible values:  values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:          createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_ENUM_CONSTANTS = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_enum_constants";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of expressions in array initializer
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_expressions_in_array_initializer"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_expressions_in_array_initializer";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of multiple fields
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_multiple_fields"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_MULTIPLE_FIELDS = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_multiple_fields";//$NON-NLS-1$	
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of parameters in constructor declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_parameters_in_constructor_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_parameters_in_constructor_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of parameters in method declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_parameters_in_method_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_parameters_in_method_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of selector in method invocation
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_selector_in_method_invocation"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_SELECTOR_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_selector_in_method_invocation";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of superclass in type declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_superclass_in_type_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_NEXT_SHIFTED, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_SUPERCLASS_IN_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_superclass_in_type_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of superinterfaces in enum declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_enum_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of superinterfaces in type declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_superinterfaces_in_type_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_type_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of throws clause in constructor declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_throws_clause_in_constructor_declaration";	 //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option for alignment of throws clause in method declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.alignment_for_throws_clause_in_method_declaration"
	 *     - possible values:   values returned by <code>createAlignmentValue(boolean, int, int)</code> call
	 *     - default:           createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT)
	 * </pre>
	 * @see #createAlignmentValue(boolean, int, int)
	 */
	public static final String FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.alignment_for_throws_clause_in_method_declaration";	 //$NON-NLS-1$

//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines after the imports declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_after_imports"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_AFTER_IMPORTS = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_after_imports";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines after the package declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_after_package"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_AFTER_PACKAGE = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_after_package";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines at the beginning of the method body
//	 *     - option id:         "org.eclipse.cdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_AT_BEGINNING_OF_METHOD_BODY = CCorePlugin.PLUGIN_ID + ".formatter.number_of_blank_lines_at_beginning_of_method_body"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before a field declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_field"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_FIELD = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_field";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before the first class body declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_first_class_body_declaration"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_FIRST_CLASS_BODY_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_first_class_body_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before the imports declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_imports"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_IMPORTS = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_imports";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before a member type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_member_type"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_MEMBER_TYPE = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_member_type";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_method"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_METHOD = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_method";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before a new chunk
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_new_chunk"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_NEW_CHUNK = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_new_chunk";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines before the package declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_before_package"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BEFORE_PACKAGE = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_before_package";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to add blank lines between type declarations
//	 *     - option id:         "org.eclipse.cdt.core.formatter.blank_lines_between_type_declarations"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_BLANK_LINES_BETWEEN_TYPE_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.blank_lines_between_type_declarations";	//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of an annotation type declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_annotation_type_declaration"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_array_initializer";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a block
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_block"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_block";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a block in a case statement when the block is the first statement following
	 *             the case
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_block_in_case"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_BLOCK_IN_CASE = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_block_in_case";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a constructor declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_constructor_declaration"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_constructor_declaration";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of an enum constant
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_enum_constant"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_enum_constant";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of an enum declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_enum_declaration"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_enum_declaration";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a method declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_method_declaration"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_method_declaration";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a switch statement
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_switch"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_switch";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to position the braces of a type declaration
	 *     - option id:         "org.eclipse.cdt.core.formatter.brace_position_for_type_declaration"
	 *     - possible values:   { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP }
	 *     - default:           END_OF_LINE
	 * </pre>
	 * @see #END_OF_LINE
	 * @see #NEXT_LINE
	 * @see #NEXT_LINE_SHIFTED
	 * @see #NEXT_LINE_ON_WRAP
	 */
	public static final String FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.brace_position_for_type_declaration";	//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to control whether blank lines are cleared inside comments
	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.clear_blank_lines"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           FALSE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */	
	public final static String FORMATTER_COMMENT_CLEAR_BLANK_LINES = CCorePlugin.PLUGIN_ID + ".formatter.comment.clear_blank_lines"; //$NON-NLS-1$
	
	/**
	 * <pre>
	 * FORMATTER / Option to control whether comments are formatted
	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.format_comments"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */	
	public final static String FORMATTER_COMMENT_FORMAT = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_comments"; //$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to control whether the header comment of a C/C++ source file is formatted
	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.format_header"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           FALSE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */	
	public final static String FORMATTER_COMMENT_FORMAT_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_header"; //$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to control whether code snippets are formatted in comments
	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.format_source_code"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */	
	public final static String FORMATTER_COMMENT_FORMAT_SOURCE = CCorePlugin.PLUGIN_ID + ".formatter.comment.format_source_code"; //$NON-NLS-1$
	
	/**
	 * <pre>
	 * FORMATTER / Option to specify the line length for comments.
	 *     - option id:         "org.eclipse.cdt.core.formatter.comment.line_length"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "80"
	 * </pre>
	 */	
	public final static String FORMATTER_COMMENT_LINE_LENGTH = CCorePlugin.PLUGIN_ID + ".formatter.comment.line_length"; //$NON-NLS-1$

//	/**
//	 * <pre>
//	 * FORMATTER / Option to compact else/if
//	 *     - option id:         "org.eclipse.cdt.core.formatter.compact_else_if"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           TRUE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_COMPACT_ELSE_IF = CCorePlugin.PLUGIN_ID + ".formatter.compact_else_if";	//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to set the continuation indentation
	 *     - option id:         "org.eclipse.cdt.core.formatter.continuation_indentation"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "2"
	 * </pre>
	 */
	public static final String FORMATTER_CONTINUATION_INDENTATION = CCorePlugin.PLUGIN_ID + ".formatter.continuation_indentation";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to set the continuation indentation inside array initializer
	 *     - option id:         "org.eclipse.cdt.core.formatter.continuation_indentation_for_array_initializer"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "2"
	 * </pre>
	 */
	public static final String FORMATTER_CONTINUATION_INDENTATION_FOR_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.continuation_indentation_for_array_initializer";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent body declarations compare to its enclosing annotation declaration header
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ANNOTATION_DECLARATION_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_annotation_declaration_header";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent body declarations compare to its enclosing enum constant header
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_CONSTANT_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_enum_constant_header";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent body declarations compare to its enclosing enum declaration header
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_DECLARATION_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_enum_declaration_header";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent body declarations compare to its enclosing type header
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_type_header"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER = CCorePlugin.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_type_header";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent breaks compare to cases
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_breaks_compare_to_cases"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_BREAKS_COMPARE_TO_CASES = CCorePlugin.PLUGIN_ID + ".formatter.indent_breaks_compare_to_cases";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent empty lines
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_empty_lines"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           FALSE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_EMPTY_LINES = CCorePlugin.PLUGIN_ID + ".formatter.indent_empty_lines"; //$NON-NLS-1$	
	/**
	 * <pre>
	 * FORMATTER / Option to indent statements inside a block
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_statements_compare_to_block"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.indent_statements_compare_to_block"; //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent statements inside the body of a method or a constructor
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_statements_compare_to_body"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY = CCorePlugin.PLUGIN_ID + ".formatter.indent_statements_compare_to_body"; //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent switch statements compare to cases
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_switchstatements_compare_to_cases"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES = CCorePlugin.PLUGIN_ID + ".formatter.indent_switchstatements_compare_to_cases";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to indent switch statements compare to switch
	 *     - option id:         "org.eclipse.cdt.core.formatter.indent_switchstatements_compare_to_switch"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           TRUE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.indent_switchstatements_compare_to_switch";	//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to specify the equivalent number of spaces that represents one indentation 
	 *     - option id:         "org.eclipse.cdt.core.formatter.indentation.size"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "4"
	 * </pre>
	 * <p>This option is used only if the tab char is set to MIXED.
	 * </p>
	 * @see #FORMATTER_TAB_CHAR
	 */
	public static final String FORMATTER_INDENTATION_SIZE = CCorePlugin.PLUGIN_ID + ".formatter.indentation.size"; //$NON-NLS-1$

//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line after an annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_after_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_after_annotation";//$NON-NLS-1$
//
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line after the opening brace in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_after_opening_brace_in_array_initializer";//$NON-NLS-1$
//
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line at the end of the current file if missing
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_at_end_of_file_if_missing"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_AT_END_OF_FILE_IF_MISSING = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_at_end_of_file_if_missing";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line before the catch keyword in try statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_before_catch_in_try_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_catch_in_try_statement";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line before the closing brace in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_closing_brace_in_array_initializer";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line before the else keyword in if statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_before_else_in_if_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_else_in_if_statement";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line before the finally keyword in try statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_before_finally_in_try_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_finally_in_try_statement";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line before while in do statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_before_while_in_do_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_before_while_in_do_statement";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty annotation declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_annotation_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ANNOTATION_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_annotation_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty anonymous type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ANONYMOUS_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_anonymous_type_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty block
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_block"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_block";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_enum_constant";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty enum declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_enum_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_enum_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty method body
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_method_body"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_METHOD_BODY = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_method_body";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a new line in an empty type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_new_line_in_empty_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_new_line_in_empty_type_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after and in wilcard
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_and_in_type_parameter"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_AND_IN_TYPE_PARAMETER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_and_in_type_parameter"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after an assignment operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_assignment_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_ASSIGNMENT_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_assignment_operator"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after at in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_at_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_AT_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_at_in_annotation"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after at in annotation type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_at_in_annotation_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_AT_IN_ANNOTATION_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_at_in_annotation_type_declaration"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after a binary operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_binary_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_BINARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_binary_operator"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the closing angle bracket in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_angle_bracket_in_type_arguments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the closing angle bracket in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_angle_bracket_in_type_parameters"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the closing brace of a block
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_closing_brace_in_block"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_BRACE_IN_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_brace_in_block"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the closing parenthesis of a cast expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_closing_paren_in_cast"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_closing_paren_in_cast"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the colon in an assert statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_assert"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_ASSERT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_assert"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after colon in a case statement when a opening brace follows the colon
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_case"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CASE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_case";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the colon in a conditional expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_conditional"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_conditional"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after colon in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_for";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the colon in a labeled statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_colon_in_labeled_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_LABELED_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_colon_in_labeled_statement"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in an allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_allocation_expression"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_annotation"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_array_initializer"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the parameters of a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_constructor_declaration_parameters"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the exception names in a throws clause of a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_constructor_declaration_throws"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the arguments of an enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_CONSTANT_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_enum_constant_arguments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in enum declarations
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_enum_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_enum_declarations"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the arguments of an explicit constructor call
//	 *     - option id:         "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_explicitconstructorcall_arguments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the increments of a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_for_increments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INCREMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_for_increments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the initializations of a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_for_inits"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INITS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_for_inits"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the parameters of a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_declaration_parameters"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the exception names in a throws clause of a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_declaration_throws"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_declaration_throws"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in the arguments of a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_INVOCATION_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_invocation_arguments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in multiple field declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_multiple_field_declarations"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in multiple local declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_multiple_local_declarations"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in parameterized type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_parameterized_type_reference"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in superinterfaces names of a type header
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_superinterfaces"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_SUPERINTERFACES = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_superinterfaces"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_type_arguments"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the comma in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_comma_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_comma_in_type_parameters"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after ellipsis
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_ellipsis"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_ELLIPSIS  = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_ellipsis";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening angle bracket in parameterized type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening angle bracket in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_type_arguments";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening angle bracket in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_type_parameters";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening brace in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_brace_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_brace_in_array_initializer";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening bracket inside an array allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_bracket_in_array_allocation_expression";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening bracket inside an array reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_bracket_in_array_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_bracket_in_array_reference";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_annotation"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a cast expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_cast"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CAST = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_cast"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a catch
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_catch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CATCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_catch"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_constructor_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_enum_constant"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_for"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in an if statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_if"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_IF = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_if"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_method_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_method_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_method_invocation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_method_invocation"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a parenthesized expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_parenthesized_expression"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a switch statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_switch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_switch"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a synchronized statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_synchronized"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SYNCHRONIZED = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_synchronized"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after the opening parenthesis in a while statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_while"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_WHILE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_while"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after a postfix operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_postfix_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_POSTFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_postfix_operator"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after a prefix operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_prefix_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_PREFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_prefix_operator"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after question mark in a conditional expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_question_in_conditional"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_question_in_conditional"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after question mark in a wildcard
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_question_in_wildcard"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_WILDCARD = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_question_in_wildcard"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after semicolon in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_semicolon_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_SEMICOLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_semicolon_in_for"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space after an unary operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_after_unary_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_AFTER_UNARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_after_unary_operator"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before and in wildcard
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_and_in_type_parameter"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_AND_IN_TYPE_PARAMETER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_and_in_type_parameter";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before an assignment operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_assignment_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_assignment_operator";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before at in annotation type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_at_in_annotation_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_AT_IN_ANNOTATION_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_at_in_annotation_type_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before an binary operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_binary_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_BINARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_binary_operator";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing angle bracket in parameterized type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference";		//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing angle bracket in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_type_arguments";		//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing angle bracket in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_type_parameters";		//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing brace in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_brace_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_brace_in_array_initializer";		//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing bracket in an array allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_bracket_in_array_allocation_expression";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing bracket in an array reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_bracket_in_array_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_bracket_in_array_reference";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_annotation";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a cast expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_cast"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CAST = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_cast";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a catch
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_catch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CATCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_catch";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_constructor_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_enum_constant";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_for";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in an if statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_if"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_IF = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_if";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_method_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_method_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_method_invocation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_method_invocation"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a parenthesized expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_PARENTHESIZED_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_parenthesized_expression"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a switch statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_switch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_switch";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a synchronized statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_synchronized"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SYNCHRONIZED = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_synchronized";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the closing parenthesis in a while statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_while"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_WHILE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_while";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in an assert statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_assert"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_ASSERT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_assert";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in a case statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_case"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CASE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_case";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in a conditional expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_conditional"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_conditional";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in a default statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_default"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_DEFAULT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_default";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_for";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before colon in a labeled statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_colon_in_labeled_statement"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_LABELED_STATEMENT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_colon_in_labeled_statement";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in an allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_allocation_expression";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_annotation";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_array_initializer";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the parameters of a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_constructor_declaration_parameters";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the exception names of the throws clause of a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_constructor_declaration_throws";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the arguments of enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_CONSTANT_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_enum_constant_arguments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in enum declarations
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_enum_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_enum_declarations";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the arguments of an explicit constructor call
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_explicitconstructorcall_arguments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the increments of a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_for_increments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INCREMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_for_increments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the initializations of a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_for_inits"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INITS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_for_inits";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the parameters of a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_declaration_parameters";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the exception names of the throws clause of a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_declaration_throws"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_THROWS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_declaration_throws";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the arguments of a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_INVOCATION_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_invocation_arguments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in a multiple field declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_multiple_field_declarations";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in a multiple local declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_multiple_local_declarations";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in parameterized type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_parameterized_type_reference";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in the superinterfaces names in a type header
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_superinterfaces"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_SUPERINTERFACES = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_superinterfaces";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_type_arguments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before comma in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_comma_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_comma_in_type_parameters";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before ellipsis
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_ellipsis"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_ELLIPSIS  = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_ellipsis";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening angle bracket in parameterized type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE  = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening angle bracket in type arguments
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_type_arguments";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening angle bracket in type parameters
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_type_parameters";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in an annotation type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ANNOTATION_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_annotation_type_declaration"; 	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in an anonymous type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ANONYMOUS_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_anonymous_type_declaration"; 	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_array_initializer"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in a block
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_block"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_BLOCK = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_block";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_constructor_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in an enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_enum_constant";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in an enum declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_enum_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_method_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_method_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in a switch statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_switch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_switch";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening brace in a type declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_type_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_TYPE_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_type_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening bracket in an array allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_allocation_expression";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening bracket in an array reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_bracket_in_array_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_reference";//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening bracket in an array type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_type_reference";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in annotation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_annotation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ANNOTATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_annotation";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in annotation type member declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ANNOTATION_TYPE_MEMBER_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a catch
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_catch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CATCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_catch";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_constructor_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_enum_constant";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_for";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in an if statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_if"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_IF = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_if";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_method_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_method_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_method_invocation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_method_invocation";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a parenthesized expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_parenthesized_expression"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a switch statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_switch"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SWITCH = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_switch";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a synchronized statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_synchronized"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SYNCHRONIZED = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_synchronized";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before the opening parenthesis in a while statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_while"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_WHILE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_while";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before parenthesized expression in return statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_parenthesized_expression_in_return"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * 
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_PARENTHESIZED_EXPRESSION_IN_RETURN  = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_parenthesized_expression_in_return";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before a postfix operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_postfix_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_POSTFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_postfix_operator";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before a prefix operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_prefix_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_PREFIX_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_prefix_operator";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before question mark in a conditional expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_question_in_conditional"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_CONDITIONAL = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_question_in_conditional";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before question mark in a wildcard
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_question_in_wildcard"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_WILDCARD = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_question_in_wildcard"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before semicolon
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_semicolon"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_semicolon";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before semicolon in for statement
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_semicolon_in_for"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON_IN_FOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_semicolon_in_for";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space before unary operator
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_before_unary_operator"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BEFORE_UNARY_OPERATOR = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_before_unary_operator";	//$NON-NLS-1$
//
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between brackets in an array type reference
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_brackets_in_array_type_reference"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_BRACKETS_IN_ARRAY_TYPE_REFERENCE = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_brackets_in_array_type_reference";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty braces in an array initializer
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_braces_in_array_initializer"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACES_IN_ARRAY_INITIALIZER = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_braces_in_array_initializer";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty brackets in an array allocation expression
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACKETS_IN_ARRAY_ALLOCATION_EXPRESSION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_brackets_in_array_allocation_expression";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty parenthesis in an annotation type member declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_ANNOTATION_TYPE_MEMBER_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty parenthesis in a constructor declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_CONSTRUCTOR_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_constructor_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty parenthesis in enum constant
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_enum_constant"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_ENUM_CONSTANT = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_enum_constant";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty parenthesis in a method declaration
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_method_declaration"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_DECLARATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_method_declaration";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to insert a space between empty parenthesis in a method invocation
//	 *     - option id:         "org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_method_invocation"
//	 *     - possible values:   { INSERT, DO_NOT_INSERT }
//	 *     - default:           DO_NOT_INSERT
//	 * </pre>
//	 * @see CCorePlugin#INSERT
//	 * @see CCorePlugin#DO_NOT_INSERT
//	 */
//	public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_INVOCATION = CCorePlugin.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_method_invocation";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to keep else statement on the same line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.keep_else_statement_on_same_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_KEEP_ELSE_STATEMENT_ON_SAME_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_else_statement_on_same_line"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to keep empty array initializer one one line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.keep_empty_array_initializer_on_one_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_KEEP_EMPTY_ARRAY_INITIALIZER_ON_ONE_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_empty_array_initializer_on_one_line"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to keep guardian clause on one line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.format_guardian_clause_on_one_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_KEEP_GUARDIAN_CLAUSE_ON_ONE_LINE = CCorePlugin.PLUGIN_ID + ".formatter.format_guardian_clause_on_one_line";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to keep simple if statement on the one line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.keep_imple_if_on_one_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_KEEP_SIMPLE_IF_ON_ONE_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_imple_if_on_one_line"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to keep then statement on the same line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.keep_then_statement_on_same_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_KEEP_THEN_STATEMENT_ON_SAME_LINE = CCorePlugin.PLUGIN_ID + ".formatter.keep_then_statement_on_same_line";//$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to specify the length of the page. Beyond this length, the formatter will try to split the code
	 *     - option id:         "org.eclipse.cdt.core.formatter.lineSplit"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "80"
	 * </pre>
	 */
	public static final String FORMATTER_LINE_SPLIT = CCorePlugin.PLUGIN_ID + ".formatter.lineSplit"; //$NON-NLS-1$
//
//	/**
//	 * <pre>
//	 * FORMATTER / Option to specify the number of empty lines to preserve
//	 *     - option id:         "org.eclipse.cdt.core.formatter.number_of_empty_lines_to_preserve"
//	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
//	 *     - default:           "0"
//	 * </pre>
//	 */
//	public static final String FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE = CCorePlugin.PLUGIN_ID + ".formatter.number_of_empty_lines_to_preserve";	//$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Option to specify whether or not empty statement should be on a new line
//	 *     - option id:         "org.eclipse.cdt.core.formatter.put_empty_statement_on_new_line"
//	 *     - possible values:   { TRUE, FALSE }
//	 *     - default:           FALSE
//	 * </pre>
//	 * @see #TRUE
//	 * @see #FALSE
//	 */
//	public static final String FORMATTER_PUT_EMPTY_STATEMENT_ON_NEW_LINE = CCorePlugin.PLUGIN_ID + ".formatter.put_empty_statement_on_new_line";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to specify the tabulation size
	 *     - option id:         "org.eclipse.cdt.core.formatter.tabulation.char"
	 *     - possible values:   { TAB, SPACE, MIXED }
	 *     - default:           TAB
	 * </pre>
	 * More values may be added in the future.
	 * 
	 * @see CCorePlugin#TAB
	 * @see CCorePlugin#SPACE
	 * @see #MIXED
	 */
	public static final String FORMATTER_TAB_CHAR = CCorePlugin.PLUGIN_ID + ".formatter.tabulation.char"; //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Option to specify the equivalent number of spaces that represents one tabulation 
	 *     - option id:         "org.eclipse.cdt.core.formatter.tabulation.size"
	 *     - possible values:   "&lt;n&gt;", where n is zero or a positive integer
	 *     - default:           "4"
	 * </pre>
	 */
	public static final String FORMATTER_TAB_SIZE = CCorePlugin.PLUGIN_ID + ".formatter.tabulation.size"; //$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / Option to use tabulations only for leading indentations 
	 *     - option id:         "org.eclipse.cdt.core.formatter.use_tabs_only_for_leading_indentations"
	 *     - possible values:   { TRUE, FALSE }
	 *     - default:           FALSE
	 * </pre>
	 * @see #TRUE
	 * @see #FALSE
	 */
	public static final String FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS = CCorePlugin.PLUGIN_ID + ".formatter.use_tabs_only_for_leading_indentations"; //$NON-NLS-1$

	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by indenting by one compare to the current indentation.
	 * </pre>
	 */
	public static final int INDENT_BY_ONE= 2;
	
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by using the current indentation.
	 * </pre>
	 */
	public static final int INDENT_DEFAULT= 0;
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by indenting on column under the splitting location.
	 * </pre>
	 */
	public static final int INDENT_ON_COLUMN = 1;
	
	/**
	 * <pre>
	 * FORMATTER / Possible value for the option FORMATTER_TAB_CHAR
	 * </pre>
	 * @see CCorePlugin#TAB
	 * @see CCorePlugin#SPACE
	 * @see #FORMATTER_TAB_CHAR
	 */
	public static final String MIXED = "mixed"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Value to set a brace location at the start of the next line with
//	 *             the right indentation.
//	 * </pre>
//	 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
//	 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
//	 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
//	 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
// 	 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
// 	 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
//	 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
//	 */
//	public static final String NEXT_LINE = "next_line"; //$NON-NLS-1$
//	/**
//	 * <pre>
//	 * FORMATTER / Value to set a brace location at the start of the next line if a wrapping
//	 *             occured.
//	 * </pre>
//	 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
//	 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
//	 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
//	 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
// 	 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
// 	 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
//	 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
//	 */
//    public static final String NEXT_LINE_ON_WRAP = "next_line_on_wrap"; //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Value to set a brace location at the start of the next line with
	 *             an extra indentation.
	 * </pre>
	 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION
	 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER
	 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK
	 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION
 	 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION
 	 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH
	 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION
	 */
	public static final String NEXT_LINE_SHIFTED = "next_line_shifted";	//$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / Value to set an option to true.
	 * </pre>
	 */
	public static final String TRUE = "true"; //$NON-NLS-1$
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done using as few lines as possible.
	 * </pre>
	 */
	public static final int WRAP_COMPACT= 1;
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done putting the first element on a new
	 *             line and then wrapping next elements using as few lines as possible.
	 * </pre>
	 */
	public static final int WRAP_COMPACT_FIRST_BREAK= 2;
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by putting each element on its own line
	 *             except the first element.
	 * </pre>
	 */
	public static final int WRAP_NEXT_PER_LINE= 5;
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by putting each element on its own line.
	 *             All elements are indented by one except the first element.
	 * </pre>
	 */
	public static final int WRAP_NEXT_SHIFTED= 4;

	/**
	 * <pre>
	 * FORMATTER / Value to disable alignment.
	 * </pre>
	 */
	public static final int WRAP_NO_SPLIT= 0;
	/**
	 * <pre>
	 * FORMATTER / The wrapping is done by putting each element on its own line.
	 * </pre>
	 */
	public static final int WRAP_ONE_PER_LINE= 3;

	/*
	 * Private constants.
	 */
	private static final IllegalArgumentException WRONG_ARGUMENT = new IllegalArgumentException();
	
	/**
	 * Create a new alignment value according to the given values. This must be used to set up
	 * the alignment options.
	 * 
	 * @param forceSplit the given force value
	 * @param wrapStyle the given wrapping style
	 * @param indentStyle the given indent style
	 * 
	 * @return the new alignement value
	 */
	public static String createAlignmentValue(boolean forceSplit, int wrapStyle, int indentStyle) {
		int alignmentValue = 0; 
		switch(wrapStyle) {
			case WRAP_COMPACT :
				alignmentValue |= Alignment.M_COMPACT_SPLIT;
				break;
			case WRAP_COMPACT_FIRST_BREAK :
				alignmentValue |= Alignment.M_COMPACT_FIRST_BREAK_SPLIT;
				break;
			case WRAP_NEXT_PER_LINE :
				alignmentValue |= Alignment.M_NEXT_PER_LINE_SPLIT;
				break;
			case WRAP_NEXT_SHIFTED :
				alignmentValue |= Alignment.M_NEXT_SHIFTED_SPLIT;
				break;
			case WRAP_ONE_PER_LINE :
				alignmentValue |= Alignment.M_ONE_PER_LINE_SPLIT;
				break;
		}		
		if (forceSplit) {
			alignmentValue |= Alignment.M_FORCE;
		}
		switch(indentStyle) {
			case INDENT_BY_ONE :
				alignmentValue |= Alignment.M_INDENT_BY_ONE;
				break;
			case INDENT_ON_COLUMN :
				alignmentValue |= Alignment.M_INDENT_ON_COLUMN;
		}
		return String.valueOf(alignmentValue);
	}

	/**
	 * Returns the default Eclipse formatter settings
	 * 
	 * @return the Eclipse default settings
	 */
	public static Map getEclipseDefaultSettings() {
		return DefaultCodeFormatterOptions.getEclipseDefaultSettings().getMap();
	}

	/**
	 * <p>Return the force value of the given alignment value.
	 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @return the force value of the given alignment value
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, or if it 
	 * doesn't have a valid format.
	 */
	public static boolean getForceWrapping(String value) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value);
			return (existingValue & Alignment.M_FORCE) != 0;
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}
	}
	
	/**
	 * <p>Return the indentation style of the given alignment value.
	 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @return the indentation style of the given alignment value
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, or if it 
	 * doesn't have a valid format.
	 */
	public static int getIndentStyle(String value) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value);
			if ((existingValue & Alignment.M_INDENT_BY_ONE) != 0) {
				return INDENT_BY_ONE;
			} else if ((existingValue & Alignment.M_INDENT_ON_COLUMN) != 0) {
				return INDENT_ON_COLUMN;
			} else {
				return INDENT_DEFAULT;
			}
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}
	}

	/**
	 * <p>Return the wrapping style of the given alignment value.
	 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @return the wrapping style of the given alignment value
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, or if it 
	 * doesn't have a valid format.
	 */
	public static int getWrappingStyle(String value) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value) & Alignment.SPLIT_MASK;
			switch(existingValue) {
				case Alignment.M_COMPACT_SPLIT :
					return WRAP_COMPACT;
				case Alignment.M_COMPACT_FIRST_BREAK_SPLIT :
					return WRAP_COMPACT_FIRST_BREAK;
				case Alignment.M_NEXT_PER_LINE_SPLIT :
					return WRAP_NEXT_PER_LINE;
				case Alignment.M_NEXT_SHIFTED_SPLIT :
					return WRAP_NEXT_SHIFTED;
				case Alignment.M_ONE_PER_LINE_SPLIT :
					return WRAP_ONE_PER_LINE;
				default:
					return WRAP_NO_SPLIT;
			}
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}
	}
	/**
	 * <p>Set the force value of the given alignment value and return the new value.
	 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @param force the given force value
	 * @return the new alignment value
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, or if it 
	 * doesn't have a valid format.
	 */
	public static String setForceWrapping(String value, boolean force) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value);
			// clear existing force bit
			existingValue &= ~Alignment.M_FORCE;
			if (force) {
				existingValue |= Alignment.M_FORCE;
			}
			return String.valueOf(existingValue);
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}		
	}
	
	/**
	 * <p>Set the indentation style of the given alignment value and return the new value.
	 * The given value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @param indentStyle the given indentation style
	 * @return the new alignment value
	 * @see #INDENT_BY_ONE
	 * @see #INDENT_DEFAULT
	 * @see #INDENT_ON_COLUMN
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, if the given
	 * indentation style is not one of the possible indentation styles, or if the given
	 * alignment value doesn't have a valid format.
	 */
	public static String setIndentStyle(String value, int indentStyle) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		switch(indentStyle) {
			case INDENT_BY_ONE :
			case INDENT_DEFAULT :
			case INDENT_ON_COLUMN :
				break;
			default :
				throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value);
			// clear existing indent bits
			existingValue &= ~(Alignment.M_INDENT_BY_ONE | Alignment.M_INDENT_ON_COLUMN);
			switch(indentStyle) {
				case INDENT_BY_ONE :
					existingValue |= Alignment.M_INDENT_BY_ONE;
					break;
				case INDENT_ON_COLUMN :
					existingValue |= Alignment.M_INDENT_ON_COLUMN;
			}
			return String.valueOf(existingValue);
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}
	}
	/**
	 * <p>Set the wrapping style of the given alignment value and return the new value.
	 * The given value should be created using the <code>createAlignmentValue(boolean, int, int)</code>
	 * API.
	 * </p>
	 *
	 * @param value the given alignment value
	 * @param wrappingStyle the given wrapping style
	 * @return the new alignment value
	 * @see #WRAP_COMPACT
	 * @see #WRAP_COMPACT_FIRST_BREAK
	 * @see #WRAP_NEXT_PER_LINE
	 * @see #WRAP_NEXT_SHIFTED
	 * @see #WRAP_NO_SPLIT
	 * @see #WRAP_ONE_PER_LINE
	 * @see #createAlignmentValue(boolean, int, int)
	 * @exception IllegalArgumentException if the given alignment value is null, if the given
	 * wrapping style is not one of the possible wrapping styles, or if the given
	 * alignment value doesn't have a valid format.
	 */
	public static String setWrappingStyle(String value, int wrappingStyle) {
		if (value == null) {
			throw WRONG_ARGUMENT;
		}
		switch(wrappingStyle) {
			case WRAP_COMPACT :
			case WRAP_COMPACT_FIRST_BREAK :
			case WRAP_NEXT_PER_LINE :
			case WRAP_NEXT_SHIFTED :
			case WRAP_NO_SPLIT :
			case WRAP_ONE_PER_LINE :
				break;
			default:
				throw WRONG_ARGUMENT;
		}
		try {
			int existingValue = Integer.parseInt(value);
			// clear existing split bits
			existingValue &= ~(Alignment.SPLIT_MASK);
			switch(wrappingStyle) {
				case WRAP_COMPACT :
					existingValue |= Alignment.M_COMPACT_SPLIT;
					break;
				case WRAP_COMPACT_FIRST_BREAK :
					existingValue |= Alignment.M_COMPACT_FIRST_BREAK_SPLIT;
					break;
				case WRAP_NEXT_PER_LINE :
					existingValue |= Alignment.M_NEXT_PER_LINE_SPLIT;
					break;
				case WRAP_NEXT_SHIFTED :
					existingValue |= Alignment.M_NEXT_SHIFTED_SPLIT;
					break;
				case WRAP_ONE_PER_LINE :
					existingValue |= Alignment.M_ONE_PER_LINE_SPLIT;
					break;
			}
			return String.valueOf(existingValue);
		} catch (NumberFormatException e) {
			throw WRONG_ARGUMENT;
		}
	}
}

Return to bug 148582

Removed Link Here

(-)src/org/eclipse/cdt/ui/dialogs/CodeFormatterBlock.java (-168 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 QNX Software Systems 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	* QNX Software Systems - Initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.cdt.ui.dialogs;
13
14	import java.util.HashMap;
15	import java.util.Iterator;
16	import java.util.Map;
17
18	import org.eclipse.core.runtime.IConfigurationElement;
19	import org.eclipse.core.runtime.IExtension;
20	import org.eclipse.core.runtime.IExtensionPoint;
21	import org.eclipse.core.runtime.Platform;
22	import org.eclipse.core.runtime.Preferences;
23	import org.eclipse.swt.SWT;
24	import org.eclipse.swt.events.SelectionAdapter;
25	import org.eclipse.swt.events.SelectionEvent;
26	import org.eclipse.swt.layout.GridData;
27	import org.eclipse.swt.layout.GridLayout;
28	import org.eclipse.swt.widgets.Combo;
29	import org.eclipse.swt.widgets.Composite;
30	import org.eclipse.swt.widgets.Control;
31	import org.eclipse.swt.widgets.Label;
32	import org.eclipse.ui.PlatformUI;
33
34	import org.eclipse.cdt.core.CCorePlugin;
35	import org.eclipse.cdt.core.CCorePreferenceConstants;
36	import org.eclipse.cdt.utils.ui.controls.ControlFactory;
37
38	import org.eclipse.cdt.internal.ui.ICHelpContextIds;
39	import org.eclipse.cdt.internal.ui.preferences.PreferencesMessages;
40
41	/**
42	*
43	*/
44	public class CodeFormatterBlock {
45
46	private HashMap idMap = new HashMap();
47	Preferences fPrefs;
48	protected Combo fFormatterCombo;
49	private static final String ATTR_NAME = "name"; //$NON-NLS-1$
50	private static final String ATTR_ID="id"; //$NON-NLS-1$
51	// This is a hack until we have a default Formatter.
52	// For now it is comment out in the plugin.xml
53	private static final String NONE=PreferencesMessages.getString("CodeFormatterPreferencePage.emptyName"); //$NON-NLS-1$
54
55
56	public CodeFormatterBlock(Preferences prefs) {
57	fPrefs = prefs;
58	initializeFormatters();
59	}
60
61	public void performOk() {
62	String text = fFormatterCombo.getText();
63	String selection = (String)idMap.get(text);
64	if (selection != null && selection.length() > 0) {
65	HashMap options = CCorePlugin.getOptions();
66	String formatterID = (String)options.get(CCorePreferenceConstants.CODE_FORMATTER);
67	if (formatterID == null \|\| !formatterID.equals(selection)) {
68	options.put(CCorePreferenceConstants.CODE_FORMATTER, selection);
69	CCorePlugin.setOptions(options);
70	}
71	} else {
72	// simply reset to the default one.
73	performDefaults();
74	}
75	}
76
77	public void performDefaults() {
78	HashMap optionsDefault = CCorePlugin.getDefaultOptions();
79	HashMap options = CCorePlugin.getOptions();
80	String formatterID = (String)optionsDefault.get(CCorePreferenceConstants.CODE_FORMATTER);
81	options.put(CCorePreferenceConstants.CODE_FORMATTER, formatterID);
82	CCorePlugin.setOptions(options);
83
84	fFormatterCombo.clearSelection();
85	fFormatterCombo.setText(NONE);
86	Iterator iterator = idMap.entrySet().iterator();
87	while (iterator.hasNext()) {
88	Map.Entry entry = (Map.Entry)iterator.next();
89	String val = (String)entry.getValue();
90	if (val != null && val.equals(formatterID)) {
91	fFormatterCombo.setText((String)entry.getKey());
92	}
93	}
94	}
95
96	/* (non-Javadoc)
97	* @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
98	*/
99	public Control createControl(Composite parent) {
100	Composite control = ControlFactory.createComposite(parent, 2);
101	((GridLayout) control.getLayout()).makeColumnsEqualWidth = false;
102	((GridLayout) control.getLayout()).marginWidth = 5;
103
104	PlatformUI.getWorkbench().getHelpSystem().setHelp(control, ICHelpContextIds.CODEFORMATTER_PREFERENCE_PAGE);
105
106	ControlFactory.createEmptySpace(control, 2);
107
108	Label label = ControlFactory.createLabel(control, PreferencesMessages.getString("CodeFormatterPreferencePage.selectionName")); //$NON-NLS-1$
109	label.setLayoutData(new GridData());
110	fFormatterCombo = new Combo(control, SWT.DROP_DOWN \| SWT.READ_ONLY);
111	GridData gd = new GridData(GridData.GRAB_HORIZONTAL);
112	gd.grabExcessHorizontalSpace = true;
113	fFormatterCombo.setLayoutData(gd);
114	fFormatterCombo.addSelectionListener(new SelectionAdapter() {
115	public void widgetSelected(SelectionEvent e) {
116	handleFormatterChanged();
117	}
118	});
119	Iterator items = idMap.keySet().iterator();
120	while (items.hasNext()) {
121	fFormatterCombo.add((String) items.next());
122	}
123
124	initDefault();
125	handleFormatterChanged();
126	return control;
127	}
128
129	public void handleFormatterChanged() {
130	// TODO: UI part.
131	}
132
133	public void initDefault() {
134	boolean init = false;
135	String selection = CCorePlugin.getOption(CCorePreferenceConstants.CODE_FORMATTER);
136	if (selection != null) {
137	Iterator iterator = idMap.entrySet().iterator();
138	while (iterator.hasNext()) {
139	Map.Entry entry = (Map.Entry)iterator.next();
140	String val = (String)entry.getValue();
141	if (val != null && val.equals(selection)) {
142	fFormatterCombo.setText((String)entry.getKey());
143	init = true;
144	}
145	}
146	}
147	if (!init) {
148	fFormatterCombo.setText(NONE);
149	}
150	}
151
152	private void initializeFormatters() {
153	idMap = new HashMap();
154	idMap.put(NONE, null);
155	IExtensionPoint point = Platform.getExtensionRegistry().getExtensionPoint(CCorePlugin.PLUGIN_ID, CCorePlugin.FORMATTER_EXTPOINT_ID);
156	if (point != null) {
157	IExtension[] exts = point.getExtensions();
158	for (int i = 0; i < exts.length; i++) {
159	IConfigurationElement[] elements = exts[i].getConfigurationElements();
160	for (int j = 0; j < elements.length; ++j) {
161	String name = elements[j].getAttribute(ATTR_NAME);
162	idMap.put(name, elements[j].getAttribute(ATTR_ID));
163	}
164	}
165	}
166	}
167
168	}

Lines 7-12 Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/PreferencesMessages.java (-6 / +43 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Sergey Prigogin, Google
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.cdt.internal.ui.preferences;	12	package org.eclipse.cdt.internal.ui.preferences;
12		13
Lines 14-35 Link Here
14	import java.util.MissingResourceException;	15	import java.util.MissingResourceException;
15	import java.util.ResourceBundle;	16	import java.util.ResourceBundle;
16		17
17	public class PreferencesMessages {	18	import org.eclipse.osgi.util.NLS;
18		19
19	private static final String RESOURCE_BUNDLE= "org.eclipse.cdt.internal.ui.preferences.PreferencesMessages";//$NON-NLS-1$	20	public class PreferencesMessages extends NLS {
20		21
		22	private static final String BUNDLE_NAME = "org.eclipse.cdt.internal.ui.preferences.PreferencesMessages";//$NON-NLS-1$
		23
		24	private PreferencesMessages() {
		25	// Do not instantiate
		26	}
		27
		28	static {
		29	NLS.initializeMessages(BUNDLE_NAME, PreferencesMessages.class);
		30	}
		31
		32	public static String CEditorPreferencePage_empty_input;
		33	public static String CEditorPreferencePage_invalid_input;
		34	public static String CEditorPreferencePage_typing_tabTitle;
		35	public static String CEditorPreferencePage_typing_description;
		36	public static String CEditorPreferencePage_closeStrings;
		37	public static String CEditorPreferencePage_closeBrackets;
		38	public static String CEditorPreferencePage_closeAngularBrackets;
		39	public static String CEditorPreferencePage_closeBraces;
		40	public static String CEditorPreferencePage_wrapStrings;
		41	public static String CEditorPreferencePage_escapeStrings;
		42	public static String CEditorPreferencePage_smartPaste;
		43
		44	public static String CEditorPreferencePage_typing_smartTab;
		45
		46	public static String SmartTypingConfigurationBlock_autoclose_title;
		47	public static String SmartTypingConfigurationBlock_tabs_title;
		48	public static String SmartTypingConfigurationBlock_tabs_message_tab_text;
		49	public static String SmartTypingConfigurationBlock_tabs_message_others_text;
		50	public static String SmartTypingConfigurationBlock_tabs_message_tooltip;
		51	public static String SmartTypingConfigurationBlock_tabs_message_spaces;
		52	public static String SmartTypingConfigurationBlock_tabs_message_tabs;
		53	public static String SmartTypingConfigurationBlock_tabs_message_tabsAndSpaces;
		54	public static String SmartTypingConfigurationBlock_pasting_title;
		55	public static String SmartTypingConfigurationBlock_strings_title;
		56
		57	public static String CodeFormatterPreferencePage_title;
		58	public static String CodeFormatterPreferencePage_description;
		59
		60	// Old style string resource access.
21	private static ResourceBundle fgResourceBundle;	61	private static ResourceBundle fgResourceBundle;
22	static {	62	static {
23	try {	63	try {
24	fgResourceBundle = ResourceBundle.getBundle(RESOURCE_BUNDLE);	64	fgResourceBundle = ResourceBundle.getBundle(BUNDLE_NAME);
25	} catch (MissingResourceException x) {	65	} catch (MissingResourceException x) {
26	fgResourceBundle = null;	66	fgResourceBundle = null;
27	}	67	}
28	}	68	}
29		69
30	private PreferencesMessages() {
31	}
32
33	public static String getString(String key) {	70	public static String getString(String key) {
34	try {	71	try {
35	return fgResourceBundle.getString(key);	72	return fgResourceBundle.getString(key);

Lines 117-122 Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/PreferencesMessages.properties (-6 / +32 lines)
117	CEditorPreferencePage.behaviorPage.Color=Color:	117	CEditorPreferencePage.behaviorPage.Color=Color:
118	CEditorPreferencePage.textFont.changeButton=C&hange...	118	CEditorPreferencePage.textFont.changeButton=C&hange...
119		119
		120	# Smart typing block
		121	SmartTypingConfigurationBlock_autoclose_title=Automatically close
		122	SmartTypingConfigurationBlock_tabs_title=Tabulators
		123	# The argument will be replaced by the tab display size
		124	SmartTypingConfigurationBlock_tabs_message_tab_text=The tab display value (currently {0}) and whether spaces are used to indent lines are configured on the <a>code style preference page</a>. The current indentation mode uses tabs.
		125	# The first argument will be replaced by the tab display size, the second by the indent size and the third by the NLSed string of 'SmartTypingConfigurationBlock_tabs_message_spaces' or 'SmartTypingConfigurationBlock_tabs_message_tabs' (see below)
		126	SmartTypingConfigurationBlock_tabs_message_others_text=The tab display value (currently {0}) and whether spaces are used to indent lines are configured on the <a>code style preference page</a>. The current indentation size is {1}, using {2}.
		127	SmartTypingConfigurationBlock_tabs_message_tooltip=Go to the code style preference page
		128	SmartTypingConfigurationBlock_tabs_message_spaces=spaces
		129	SmartTypingConfigurationBlock_tabs_message_tabs=tabs
		130	SmartTypingConfigurationBlock_tabs_message_tabsAndSpaces=tabs and spaces
		131	SmartTypingConfigurationBlock_pasting_title=When pasting
		132	SmartTypingConfigurationBlock_strings_title=In string literals
		133
		134	CEditorPreferencePage_empty_input=Empty input
		135	CEditorPreferencePage_invalid_input="{0}" is not a valid input.
		136	CEditorPreferencePage_typing_tabTitle=T&yping
		137	CEditorPreferencePage_typing_description=Enable these typing aids in Smart Insert mode:
		138	CEditorPreferencePage_closeStrings="&Strings"
		139	CEditorPreferencePage_closeBrackets=(&Parentheses) and [square] brackets
		140	CEditorPreferencePage_closeAngularBrackets=<A&ngle> brackets
		141	CEditorPreferencePage_closeBraces={B&races}
		142	CEditorPreferencePage_wrapStrings=&Wrap automatically
		143	CEditorPreferencePage_escapeStrings=Escape text w&hen pasting into a string literal
		144	CEditorPreferencePage_smartPaste=Adjust &indentation
		145
		146	CEditorPreferencePage_typing_smartTab= &Tab key indents the current line
		147
		148	# Code Formatting
		149	CodeFormatterPreferencePage_title=Code Style
		150	CodeFormatterPreferencePage_description=Sele&ct a profile:
		151
120	TemplatePreferencePage.Viewer.preview=Preview:	152	TemplatePreferencePage.Viewer.preview=Preview:
121		153
122	CFileTypesPreferencePage.description=C/C++ File Types	154	CFileTypesPreferencePage.description=C/C++ File Types
Lines 196-207 Link Here
196	FoldingConfigurationBlock.info.no_preferences= The selected folding provider did not provide a preference control	228	FoldingConfigurationBlock.info.no_preferences= The selected folding provider did not provide a preference control
197	FoldingConfigurationBlock.error.not_exist= The selected folding provider does not exist	229	FoldingConfigurationBlock.error.not_exist= The selected folding provider does not exist
198		230
199	#Code Formatting
200	CodeFormatterPreferencePage.title=Code Formatter
201	CodeFormatterPreferencePage.selectionName=Formatters:
202	CodeFormatterPreferencePage.emptyName=(NONE)
203	CodeFormatterPreferencePage.description=Code Formatter
204
205	# --- Linked Resources ---	231	# --- Linked Resources ---
206	PathEntryVariablePreference.explanation = PathEntry variables.	232	PathEntryVariablePreference.explanation = PathEntry variables.
207	PathEntryVariablePreference.enableLinkedResources = &Enable linked resources	233	PathEntryVariablePreference.enableLinkedResources = &Enable linked resources

Lines 15-21 Link Here

(-)src/org/eclipse/cdt/internal/corext/util/CodeFormatterUtil.java (-8 / +8 lines)
15	import org.eclipse.cdt.core.CCorePlugin;	15	import org.eclipse.cdt.core.CCorePlugin;
16	import org.eclipse.cdt.core.ToolFactory;	16	import org.eclipse.cdt.core.ToolFactory;
17	import org.eclipse.cdt.core.formatter.CodeFormatter;	17	import org.eclipse.cdt.core.formatter.CodeFormatter;
18	import org.eclipse.cdt.core.formatter.CodeFormatterConstants;	18	import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
19	import org.eclipse.cdt.core.model.ICProject;	19	import org.eclipse.cdt.core.model.ICProject;
20	import org.eclipse.cdt.ui.CUIPlugin;	20	import org.eclipse.cdt.ui.CUIPlugin;
21		21
Lines 55-64 Link Here
55	* that case.	55	* that case.
56	*/	56	*/
57	String key;	57	String key;
58	if (CCorePlugin.SPACE.equals(getCoreOption(project, CodeFormatterConstants.FORMATTER_TAB_CHAR)))	58	if (CCorePlugin.SPACE.equals(getCoreOption(project, DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
59	key= CodeFormatterConstants.FORMATTER_INDENTATION_SIZE;	59	key= DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE;
60	else	60	else
61	key= CodeFormatterConstants.FORMATTER_TAB_SIZE;	61	key= DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE;
62		62
63	return getCoreOption(project, key, 4);	63	return getCoreOption(project, key, 4);
64	}	64	}
Lines 72-81 Link Here
72	*/	72	*/
73	public static int getIndentWidth(ICProject project) {	73	public static int getIndentWidth(ICProject project) {
74	String key;	74	String key;
75	if (CodeFormatterConstants.MIXED.equals(getCoreOption(project, CodeFormatterConstants.FORMATTER_TAB_CHAR)))	75	if (DefaultCodeFormatterConstants.MIXED.equals(getCoreOption(project, DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
76	key= CodeFormatterConstants.FORMATTER_INDENTATION_SIZE;	76	key= DefaultCodeFormatterConstants.FORMATTER_INDENTATION_SIZE;
77	else	77	else
78	key= CodeFormatterConstants.FORMATTER_TAB_SIZE;	78	key= DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE;
79		79
80	return getCoreOption(project, key, 4);	80	return getCoreOption(project, key, 4);
81	}	81	}
Lines 131-137 Link Here
131	return doc.get();	131	return doc.get();
132	} catch (BadLocationException e) {	132	} catch (BadLocationException e) {
133	CUIPlugin.getDefault().log(e); // bug in the formatter	133	CUIPlugin.getDefault().log(e); // bug in the formatter
134	Assert.isTrue(false, "Fromatter created edits with wrong positions: " + e.getMessage()); //$NON-NLS-1$	134	Assert.isTrue(false, "Formatter created edits with wrong positions: " + e.getMessage()); //$NON-NLS-1$
135	}	135	}
136	return null;	136	return null;
137	}	137	}

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/IPreferenceConfigurationBlock.java (+64 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 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	* Sergey Prigogin, Google
11	*******************************************************************************/
12
13	package org.eclipse.cdt.internal.ui.preferences;
14
15	import org.eclipse.swt.widgets.Composite;
16	import org.eclipse.swt.widgets.Control;
17
18
19	/**
20	* Interface for preference configuration blocks which can either be
21	* wrapped by a {@link org.eclipse.cdt.internal.ui.preferences.AbstractConfigurationBlockPreferencePage}
22	* or be included some preference page.
23	* <p>
24	* Clients may implement this interface.
25	* </p>
26	*
27	* @since 3.0
28	*/
29	public interface IPreferenceConfigurationBlock {
30
31	/**
32	* Creates the preference control.
33	*
34	* @param parent the parent composite to which to add the preferences control
35	* @return the control that was added to <code>parent</code>
36	*/
37	Control createControl(Composite parent);
38
39	/**
40	* Called after creating the control. Implementations should load the
41	* preferences values and update the controls accordingly.
42	*/
43	void initialize();
44
45	/**
46	* Called when the <code>OK</code> button is pressed on the preference
47	* page. Implementations should commit the configured preference settings
48	* into their form of preference storage.
49	*/
50	void performOk();
51
52	/**
53	* Called when the <code>Defaults</code> button is pressed on the
54	* preference page. Implementation should reset any preference settings to
55	* their default values and adjust the controls accordingly.
56	*/
57	void performDefaults();
58
59	/**
60	* Called when the preference page is being disposed. Implementations should
61	* free any resources they are holding on to.
62	*/
63	void dispose();
64	}

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/formatter/ProfileStore.java (+427 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 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	* Sergey Prigogin, Google
11	*******************************************************************************/
12
13	package org.eclipse.cdt.internal.ui.preferences.formatter;
14
15	import java.io.ByteArrayInputStream;
16	import java.io.ByteArrayOutputStream;
17	import java.io.File;
18	import java.io.FileInputStream;
19	import java.io.FileOutputStream;
20	import java.io.FileReader;
21	import java.io.IOException;
22	import java.io.InputStream;
23	import java.io.OutputStream;
24	import java.io.UnsupportedEncodingException;
25	import java.util.ArrayList;
26	import java.util.Collection;
27	import java.util.Collections;
28	import java.util.HashMap;
29	import java.util.Iterator;
30	import java.util.List;
31	import java.util.Map;
32
33	import javax.xml.parsers.DocumentBuilder;
34	import javax.xml.parsers.DocumentBuilderFactory;
35	import javax.xml.parsers.ParserConfigurationException;
36	import javax.xml.parsers.SAXParser;
37	import javax.xml.parsers.SAXParserFactory;
38	import javax.xml.transform.OutputKeys;
39	import javax.xml.transform.Transformer;
40	import javax.xml.transform.TransformerException;
41	import javax.xml.transform.TransformerFactory;
42	import javax.xml.transform.dom.DOMSource;
43	import javax.xml.transform.stream.StreamResult;
44
45	import org.eclipse.core.runtime.CoreException;
46	import org.eclipse.core.runtime.IStatus;
47	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
48	import org.eclipse.core.runtime.preferences.IScopeContext;
49
50	import org.eclipse.core.resources.IProject;
51	import org.eclipse.core.resources.ResourcesPlugin;
52
53	import org.eclipse.cdt.core.CCorePlugin;
54
55	import org.eclipse.cdt.ui.CUIPlugin;
56	import org.eclipse.cdt.internal.ui.CUIException;
57	import org.eclipse.cdt.internal.ui.CUIStatus;
58	import org.eclipse.cdt.internal.ui.preferences.PreferencesAccess;
59	import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.CustomProfile;
60	import org.eclipse.cdt.internal.ui.preferences.formatter.ProfileManager.Profile;
61
62	import org.osgi.service.prefs.BackingStoreException;
63	import org.w3c.dom.Document;
64	import org.w3c.dom.Element;
65	import org.xml.sax.Attributes;
66	import org.xml.sax.InputSource;
67	import org.xml.sax.SAXException;
68	import org.xml.sax.helpers.DefaultHandler;
69
70
71
72	public class ProfileStore {
73
74	/**
75	* A SAX event handler to parse the xml format for profiles.
76	*/
77	private final static class ProfileDefaultHandler extends DefaultHandler {
78
79	private List fProfiles;
80	private int fVersion;
81
82	private String fName;
83	private Map fSettings;
84
85
86	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
87
88	if (qName.equals(XML_NODE_SETTING)) {
89
90	final String key= attributes.getValue(XML_ATTRIBUTE_ID);
91	final String value= attributes.getValue(XML_ATTRIBUTE_VALUE);
92	fSettings.put(key, value);
93
94	} else if (qName.equals(XML_NODE_PROFILE)) {
95
96	fName= attributes.getValue(XML_ATTRIBUTE_NAME);
97	fSettings= new HashMap(200);
98
99	}
100	else if (qName.equals(XML_NODE_ROOT)) {
101
102	fProfiles= new ArrayList();
103	try {
104	fVersion= Integer.parseInt(attributes.getValue(XML_ATTRIBUTE_VERSION));
105	} catch (NumberFormatException ex) {
106	throw new SAXException(ex);
107	}
108
109	}
110	}
111
112	public void endElement(String uri, String localName, String qName) {
113	if (qName.equals(XML_NODE_PROFILE)) {
114	fProfiles.add(new CustomProfile(fName, fSettings, fVersion));
115	fName= null;
116	fSettings= null;
117	}
118	}
119
120	public List getProfiles() {
121	return fProfiles;
122	}
123
124	}
125
126	/**
127	* Preference key where all profiles are stored
128	*/
129	private static final String PREF_FORMATTER_PROFILES= "org.eclipse.cdt.ui.formatterprofiles"; //$NON-NLS-1$
130
131	/**
132	* Preference key where all profiles are stored
133	*/
134	private static final String PREF_FORMATTER_PROFILES_VERSION= "org.eclipse.cdt.ui.formatterprofiles.version"; //$NON-NLS-1$
135
136
137	/**
138	* Identifiers for the XML file.
139	*/
140	private final static String XML_NODE_ROOT= "profiles"; //$NON-NLS-1$
141	private final static String XML_NODE_PROFILE= "profile"; //$NON-NLS-1$
142	private final static String XML_NODE_SETTING= "setting"; //$NON-NLS-1$
143
144	private final static String XML_ATTRIBUTE_VERSION= "version"; //$NON-NLS-1$
145	private final static String XML_ATTRIBUTE_ID= "id"; //$NON-NLS-1$
146	private final static String XML_ATTRIBUTE_NAME= "name"; //$NON-NLS-1$
147	private final static String XML_ATTRIBUTE_VALUE= "value"; //$NON-NLS-1$
148
149	private ProfileStore() {
150	}
151
152	/**
153	* @return Returns the collection of profiles currently stored in the preference store or
154	* <code>null</code> if the loading failed. The elements are of type {@link CustomProfile}
155	* and are all updated to the latest version.
156	* @throws CoreException
157	*/
158	public static List readProfiles(IScopeContext scope) throws CoreException {
159	List res= readProfilesFromPreferences(scope);
160	if (res == null) {
161	return readOldForCompatibility(scope);
162	}
163	return res;
164	}
165
166	public static void writeProfiles(Collection profiles, IScopeContext instanceScope) throws CoreException {
167	ByteArrayOutputStream stream= new ByteArrayOutputStream(2000);
168	try {
169	writeProfilesToStream(profiles, stream);
170	String val;
171	try {
172	val= stream.toString("UTF-8"); //$NON-NLS-1$
173	} catch (UnsupportedEncodingException e) {
174	val= stream.toString();
175	}
176	IEclipsePreferences uiPreferences = instanceScope.getNode(CUIPlugin.PLUGIN_ID);
177	uiPreferences.put(PREF_FORMATTER_PROFILES, val);
178	uiPreferences.putInt(PREF_FORMATTER_PROFILES_VERSION, ProfileVersioner.CURRENT_VERSION);
179	} finally {
180	try { stream.close(); } catch (IOException e) { /* ignore */ }
181	}
182	}
183
184	public static List readProfilesFromPreferences(IScopeContext scope) throws CoreException {
185	String string= scope.getNode(CUIPlugin.PLUGIN_ID).get(PREF_FORMATTER_PROFILES, null);
186	if (string != null && string.length() > 0) {
187	byte[] bytes;
188	try {
189	bytes= string.getBytes("UTF-8"); //$NON-NLS-1$
190	} catch (UnsupportedEncodingException e) {
191	bytes= string.getBytes();
192	}
193	InputStream is= new ByteArrayInputStream(bytes);
194	try {
195	List res= readProfilesFromStream(new InputSource(is));
196	if (res != null) {
197	for (int i= 0; i < res.size(); i++) {
198	ProfileVersioner.updateAndComplete((CustomProfile) res.get(i));
199	}
200	}
201	return res;
202	} finally {
203	try { is.close(); } catch (IOException e) { /* ignore */ }
204	}
205	}
206	return null;
207	}
208
209	/**
210	* Read the available profiles from the internal XML file and return them
211	* as collection.
212	* @return returns a list of <code>CustomProfile</code> or <code>null</code>
213	*/
214	private static List readOldForCompatibility(IScopeContext instanceScope) {
215
216	// in 3.0 M9 and less the profiles were stored in a file in the plugin's meta data
217	final String STORE_FILE= "code_formatter_profiles.xml"; //$NON-NLS-1$
218
219	File file= CUIPlugin.getDefault().getStateLocation().append(STORE_FILE).toFile();
220	if (!file.exists())
221	return null;
222
223	try {
224	// note that it's wrong to use a file reader when XML declares UTF-8: Kept for compatibility
225	final FileReader reader= new FileReader(file);
226	try {
227	List res= readProfilesFromStream(new InputSource(reader));
228	if (res != null) {
229	for (int i= 0; i < res.size(); i++) {
230	ProfileVersioner.updateAndComplete((CustomProfile) res.get(i));
231	}
232	writeProfiles(res, instanceScope);
233	}
234	file.delete(); // remove after successful write
235	return res;
236	} finally {
237	reader.close();
238	}
239	} catch (CoreException e) {
240	CUIPlugin.getDefault().log(e); // log but ignore
241	} catch (IOException e) {
242	CUIPlugin.getDefault().log(e); // log but ignore
243	}
244	return null;
245	}
246
247
248	/**
249	* Read the available profiles from the internal XML file and return them
250	* as collection or <code>null</code> if the file is not a profile file.
251	* @param file The file to read from
252	* @return returns a list of <code>CustomProfile</code> or <code>null</code>
253	* @throws CoreException
254	*/
255	public static List readProfilesFromFile(File file) throws CoreException {
256	try {
257	final FileInputStream reader= new FileInputStream(file);
258	try {
259	return readProfilesFromStream(new InputSource(reader));
260	} finally {
261	try { reader.close(); } catch (IOException e) { /* ignore */ }
262	}
263	} catch (IOException e) {
264	throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_reading_xml_message);
265	}
266	}
267
268	/**
269	* Load profiles from a XML stream and add them to a map or <code>null</code> if the source is not a profile store.
270	* @param inputSource The input stream
271	* @return returns a list of <code>CustomProfile</code> or <code>null</code>
272	* @throws CoreException
273	*/
274	private static List readProfilesFromStream(InputSource inputSource) throws CoreException {
275
276	final ProfileDefaultHandler handler= new ProfileDefaultHandler();
277	try {
278	final SAXParserFactory factory= SAXParserFactory.newInstance();
279	final SAXParser parser= factory.newSAXParser();
280	parser.parse(inputSource, handler);
281	} catch (SAXException e) {
282	throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_reading_xml_message);
283	} catch (IOException e) {
284	throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_reading_xml_message);
285	} catch (ParserConfigurationException e) {
286	throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_reading_xml_message);
287	}
288	return handler.getProfiles();
289	}
290
291	/**
292	* Write the available profiles to the internal XML file.
293	* @param profiles List of <code>CustomProfile</code>
294	* @param file File to write
295	* @throws CoreException
296	*/
297	public static void writeProfilesToFile(Collection profiles, File file) throws CoreException {
298	final OutputStream writer;
299	try {
300	writer= new FileOutputStream(file);
301	try {
302	writeProfilesToStream(profiles, writer);
303	} finally {
304	try { writer.close(); } catch (IOException e) { /* ignore */ }
305	}
306	} catch (IOException e) {
307	throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_serializing_xml_message);
308	}
309	}
310
311	/**
312	* Save profiles to an XML stream
313	* @param profiles List of <code>CustomProfile</code>
314	* @param stream Stream to write
315	* @throws CoreException
316	*/
317	private static void writeProfilesToStream(Collection profiles, OutputStream stream) throws CoreException {
318
319	try {
320	final DocumentBuilderFactory factory= DocumentBuilderFactory.newInstance();
321	final DocumentBuilder builder= factory.newDocumentBuilder();
322	final Document document= builder.newDocument();
323
324	final Element rootElement = document.createElement(XML_NODE_ROOT);
325	rootElement.setAttribute(XML_ATTRIBUTE_VERSION, Integer.toString(ProfileVersioner.CURRENT_VERSION));
326
327	document.appendChild(rootElement);
328
329	for(final Iterator iter= profiles.iterator(); iter.hasNext();) {
330	final Profile profile= (Profile)iter.next();
331	if (profile.isProfileToSave()) {
332	final Element profileElement= createProfileElement(profile, document);
333	rootElement.appendChild(profileElement);
334	}
335	}
336
337	Transformer transformer=TransformerFactory.newInstance().newTransformer();
338	transformer.setOutputProperty(OutputKeys.METHOD, "xml"); //$NON-NLS-1$
339	transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); //$NON-NLS-1$
340	transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
341	transformer.transform(new DOMSource(document), new StreamResult(stream));
342	} catch (TransformerException e) {
343	throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_serializing_xml_message);
344	} catch (ParserConfigurationException e) {
345	throw createException(e, FormatterMessages.CodingStyleConfigurationBlock_error_serializing_xml_message);
346	}
347	}
348
349
350	/*
351	* Create a new profile element in the specified document. The profile is not added
352	* to the document by this method.
353	*/
354	private static Element createProfileElement(Profile profile, Document document) {
355	final Element element= document.createElement(XML_NODE_PROFILE);
356	element.setAttribute(XML_ATTRIBUTE_NAME, profile.getName());
357	element.setAttribute(XML_ATTRIBUTE_VERSION, Integer.toString(profile.getVersion()));
358
359	final Iterator keyIter= ProfileManager.getKeys().iterator();
360
361	while (keyIter.hasNext()) {
362	final String key= (String)keyIter.next();
363	final String value= (String)profile.getSettings().get(key);
364	if (value != null) {
365	final Element setting= document.createElement(XML_NODE_SETTING);
366	setting.setAttribute(XML_ATTRIBUTE_ID, key);
367	setting.setAttribute(XML_ATTRIBUTE_VALUE, value);
368	element.appendChild(setting);
369	} else {
370	CUIPlugin.getDefault().logErrorMessage("ProfileStore: Profile does not contain value for key " + key); //$NON-NLS-1$
371	}
372	}
373	return element;
374	}
375
376	public static void checkCurrentOptionsVersion() {
377	PreferencesAccess access= PreferencesAccess.getOriginalPreferences();
378
379	IScopeContext instanceScope= access.getInstanceScope();
380	IEclipsePreferences uiPreferences= instanceScope.getNode(CUIPlugin.PLUGIN_ID);
381	int version= uiPreferences.getInt(PREF_FORMATTER_PROFILES_VERSION, 0);
382	if (version >= ProfileVersioner.CURRENT_VERSION) {
383	return; // is up to date
384	}
385	try {
386	List profiles= ProfileStore.readProfiles(instanceScope);
387	if (profiles == null) {
388	profiles= Collections.EMPTY_LIST;
389	}
390	ProfileManager manager= new ProfileManager(profiles, instanceScope, access);
391	if (manager.getSelected() instanceof CustomProfile) {
392	manager.commitChanges(instanceScope); // updates CCorePlugin options
393	}
394	uiPreferences.putInt(PREF_FORMATTER_PROFILES_VERSION, ProfileVersioner.CURRENT_VERSION);
395	savePreferences(instanceScope);
396
397	IProject[] projects= ResourcesPlugin.getWorkspace().getRoot().getProjects();
398	for (int i= 0; i < projects.length; i++) {
399	IScopeContext scope= access.getProjectScope(projects[i]);
400	if (ProfileManager.hasProjectSpecificSettings(scope)) {
401	manager= new ProfileManager(profiles, scope, access);
402	manager.commitChanges(scope); // updates CCorePlugin project options
403	savePreferences(scope);
404	}
405	}
406	} catch (CoreException e) {
407	CUIPlugin.getDefault().log(e);
408	} catch (BackingStoreException e) {
409	CUIPlugin.getDefault().log(e);
410	}
411	}
412
413	private static void savePreferences(final IScopeContext context) throws BackingStoreException {
414	try {
415	context.getNode(CUIPlugin.PLUGIN_ID).flush();
416	} finally {
417	context.getNode(CCorePlugin.PLUGIN_ID).flush();
418	}
419	}
420
421	/*
422	* Creates a UI exception for logging purposes
423	*/
424	private static CUIException createException(Throwable t, String message) {
425	return new CUIException(CUIStatus.createError(IStatus.ERROR, message, t));
426	}
427	}

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/actions/IndentAction.java (+573 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 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	* Sergey Prigogin, Google
11	*******************************************************************************/
12	package org.eclipse.cdt.internal.ui.actions;
13
14	import java.util.ResourceBundle;
15
16	import org.eclipse.core.runtime.IStatus;
17	import org.eclipse.core.runtime.Status;
18
19	import org.eclipse.swt.custom.BusyIndicator;
20	import org.eclipse.swt.widgets.Display;
21
22	import org.eclipse.jface.viewers.ISelection;
23	import org.eclipse.jface.viewers.ISelectionProvider;
24
25	import org.eclipse.jface.text.Assert;
26	import org.eclipse.jface.text.BadLocationException;
27	import org.eclipse.jface.text.IDocument;
28	import org.eclipse.jface.text.IRegion;
29	import org.eclipse.jface.text.IRewriteTarget;
30	import org.eclipse.jface.text.ITextSelection;
31	import org.eclipse.jface.text.ITypedRegion;
32	import org.eclipse.jface.text.Position;
33	import org.eclipse.jface.text.TextSelection;
34	import org.eclipse.jface.text.TextUtilities;
35	import org.eclipse.jface.text.source.ISourceViewer;
36
37	import org.eclipse.ui.IEditorInput;
38	import org.eclipse.ui.texteditor.IDocumentProvider;
39	import org.eclipse.ui.texteditor.ITextEditor;
40	import org.eclipse.ui.texteditor.ITextEditorExtension3;
41	import org.eclipse.ui.texteditor.TextEditorAction;
42
43	import org.eclipse.cdt.core.CCorePlugin;
44	import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
45	import org.eclipse.cdt.core.model.ICProject;
46	import org.eclipse.cdt.core.model.ITranslationUnit;
47
48	import org.eclipse.cdt.ui.CUIPlugin;
49	import org.eclipse.cdt.ui.text.ICPartitions;
50
51	import org.eclipse.cdt.internal.ui.editor.CEditor;
52	import org.eclipse.cdt.internal.ui.text.CHeuristicScanner;
53	import org.eclipse.cdt.internal.ui.text.CIndenter;
54
55
56	/**
57	* Indents a line or range of lines in a C document to its correct position. No complete
58	* AST must be present, the indentation is computed using heuristics. The algorithm used is fast for
59	* single lines, but does not store any information and therefore not so efficient for large line
60	* ranges.
61	*
62	* @see org.eclipse.cdt.internal.ui.text.CHeuristicScanner
63	* @see org.eclipse.cdt.internal.ui.text.CIndenter
64	*/
65	public class IndentAction extends TextEditorAction {
66
67	/** The caret offset after an indent operation. */
68	private int fCaretOffset;
69
70	/**
71	* Whether this is the action invoked by TAB. When <code>true</code>, indentation behaves
72	* differently to accommodate normal TAB operation.
73	*/
74	private final boolean fIsTabAction;
75
76	/**
77	* Creates a new instance.
78	*
79	* @param bundle the resource bundle
80	* @param prefix the prefix to use for keys in <code>bundle</code>
81	* @param editor the text editor
82	* @param isTabAction whether the action should insert tabs if over the indentation
83	*/
84	public IndentAction(ResourceBundle bundle, String prefix, ITextEditor editor, boolean isTabAction) {
85	super(bundle, prefix, editor);
86	fIsTabAction= isTabAction;
87	}
88
89	/*
90	* @see org.eclipse.jface.action.Action#run()
91	*/
92	public void run() {
93	// update has been called by the framework
94	if (!isEnabled() \|\| !validateEditorInputState())
95	return;
96
97	ITextSelection selection= getSelection();
98	final IDocument document= getDocument();
99
100	if (document != null) {
101	final int offset= selection.getOffset();
102	final int length= selection.getLength();
103	final Position end= new Position(offset + length);
104	final int firstLine, nLines;
105	fCaretOffset= -1;
106
107	try {
108	document.addPosition(end);
109	firstLine= document.getLineOfOffset(offset);
110	// check for marginal (zero-length) lines
111	int minusOne= length == 0 ? 0 : 1;
112	nLines= document.getLineOfOffset(offset + length - minusOne) - firstLine + 1;
113	} catch (BadLocationException e) {
114	// will only happen on concurrent modification
115	CUIPlugin.getDefault().log(new Status(IStatus.ERROR, CUIPlugin.getPluginId(), IStatus.OK, "", e)); //$NON-NLS-1$
116	return;
117	}
118
119	Runnable runnable= new Runnable() {
120	public void run() {
121	IRewriteTarget target= (IRewriteTarget)getTextEditor().getAdapter(IRewriteTarget.class);
122	if (target != null)
123	target.beginCompoundChange();
124
125	try {
126	CHeuristicScanner scanner= new CHeuristicScanner(document);
127	CIndenter indenter= new CIndenter(document, scanner, getCProject());
128	final boolean multiLine= nLines > 1;
129	boolean hasChanged= false;
130	for (int i= 0; i < nLines; i++) {
131	hasChanged \|= indentLine(document, firstLine + i, offset, indenter, scanner, multiLine);
132	}
133
134	// update caret position: move to new position when indenting just one line
135	// keep selection when indenting multiple
136	int newOffset, newLength;
137	if (!fIsTabAction && multiLine) {
138	newOffset= offset;
139	newLength= end.getOffset() - offset;
140	} else {
141	newOffset= fCaretOffset;
142	newLength= 0;
143	}
144
145	// always reset the selection if anything was replaced
146	// but not when we had a single line non-tab invocation
147	if (newOffset != -1 && (hasChanged \|\| newOffset != offset \|\| newLength != length))
148	selectAndReveal(newOffset, newLength);
149
150	document.removePosition(end);
151	} catch (BadLocationException e) {
152	// will only happen on concurrent modification
153	CUIPlugin.getDefault().log(new Status(IStatus.ERROR, CUIPlugin.getPluginId(), IStatus.OK, "ConcurrentModification in IndentAction", e)); //$NON-NLS-1$
154	} finally {
155	if (target != null)
156	target.endCompoundChange();
157	}
158	}
159	};
160
161	if (nLines > 50) {
162	Display display= getTextEditor().getEditorSite().getWorkbenchWindow().getShell().getDisplay();
163	BusyIndicator.showWhile(display, runnable);
164	} else {
165	runnable.run();
166	}
167	}
168	}
169
170	/**
171	* Selects the given range on the editor.
172	*
173	* @param newOffset the selection offset
174	* @param newLength the selection range
175	*/
176	private void selectAndReveal(int newOffset, int newLength) {
177	Assert.isTrue(newOffset >= 0);
178	Assert.isTrue(newLength >= 0);
179	ITextEditor editor= getTextEditor();
180	if (editor instanceof CEditor) {
181	ISourceViewer viewer= ((CEditor)editor).getViewer();
182	if (viewer != null)
183	viewer.setSelectedRange(newOffset, newLength);
184	} else {
185	// this is too intrusive, but will never get called anyway
186	getTextEditor().selectAndReveal(newOffset, newLength);
187	}
188	}
189
190	/**
191	* Indents a single line using the java heuristic scanner. Cdoc and multiline comments are
192	* indented as specified by the <code>CDocAutoIndentStrategy</code>.
193	*
194	* @param document the document
195	* @param line the line to be indented
196	* @param caret the caret position
197	* @param indenter the java indenter
198	* @param scanner the heuristic scanner
199	* @param multiLine <code>true</code> if more than one line is being indented
200	* @return <code>true</code> if <code>document</code> was modified, <code>false</code> otherwise
201	* @throws BadLocationException if the document got changed concurrently
202	*/
203	private boolean indentLine(IDocument document, int line, int caret, CIndenter indenter, CHeuristicScanner scanner, boolean multiLine) throws BadLocationException {
204	IRegion currentLine= document.getLineInformation(line);
205	int offset= currentLine.getOffset();
206	int wsStart= offset; // where we start searching for non-WS; after the "//" in single line comments
207
208	String indent= null;
209	if (offset < document.getLength()) {
210	ITypedRegion partition= TextUtilities.getPartition(document, ICPartitions.C_PARTITIONING, offset, true);
211	ITypedRegion startingPartition= TextUtilities.getPartition(document, ICPartitions.C_PARTITIONING, offset, false);
212	String type= partition.getType();
213	if (type.equals(ICPartitions.C_MULTI_LINE_COMMENT)) {
214	indent= computeDocIndent(document, line, scanner, startingPartition);
215	} else if (!fIsTabAction && startingPartition.getOffset() == offset && startingPartition.getType().equals(ICPartitions.C_SINGLE_LINE_COMMENT)) {
216	// line comment starting at position 0 -> indent inside
217	int max= document.getLength() - offset;
218	int slashes= 2;
219	while (slashes < max - 1 && document.get(offset + slashes, 2).equals("//")) //$NON-NLS-1$
220	slashes+= 2;
221
222	wsStart= offset + slashes;
223
224	StringBuffer computed= indenter.computeIndentation(offset);
225	if (computed == null)
226	computed= new StringBuffer(0);
227	int tabSize= getTabSize();
228	while (slashes > 0 && computed.length() > 0) {
229	char c= computed.charAt(0);
230	if (c == '\t') {
231	if (slashes > tabSize)
232	slashes-= tabSize;
233	else
234	break;
235	} else if (c == ' ') {
236	slashes--;
237	} else {
238	break;
239	}
240
241	computed.deleteCharAt(0);
242	}
243
244	indent= document.get(offset, wsStart - offset) + computed;
245	}
246	}
247
248	// standard java indentation
249	if (indent == null) {
250	StringBuffer computed= indenter.computeIndentation(offset);
251	if (computed != null)
252	indent= computed.toString();
253	else
254	indent= ""; //$NON-NLS-1$
255	}
256
257	// change document:
258	// get current white space
259	int lineLength= currentLine.getLength();
260	int end= scanner.findNonWhitespaceForwardInAnyPartition(wsStart, offset + lineLength);
261	if (end == CHeuristicScanner.NOT_FOUND) {
262	// an empty line
263	end= offset + lineLength;
264	if (multiLine && !indentEmptyLines())
265	indent= ""; //$NON-NLS-1$
266	}
267	int length= end - offset;
268	String currentIndent= document.get(offset, length);
269
270	// if we are right before the text start / line end, and already after the insertion point
271	// then just insert a tab.
272	if (fIsTabAction && caret == end && whiteSpaceLength(currentIndent) >= whiteSpaceLength(indent)) {
273	String tab= getTabEquivalent();
274	document.replace(caret, 0, tab);
275	fCaretOffset= caret + tab.length();
276	return true;
277	}
278
279	// set the caret offset so it can be used when setting the selection
280	if (caret >= offset && caret <= end)
281	fCaretOffset= offset + indent.length();
282	else
283	fCaretOffset= -1;
284
285	// only change the document if it is a real change
286	if (!indent.equals(currentIndent)) {
287	document.replace(offset, length, indent);
288	return true;
289	} else {
290	return false;
291	}
292	}
293
294	/**
295	* Computes and returns the indentation for a javadoc line. The line
296	* must be inside a javadoc comment.
297	*
298	* @param document the document
299	* @param line the line in document
300	* @param scanner the scanner
301	* @param partition the javadoc partition
302	* @return the indent, or <code>null</code> if not computable
303	* @throws BadLocationException
304	*/
305	private String computeDocIndent(IDocument document, int line, CHeuristicScanner scanner, ITypedRegion partition) throws BadLocationException {
306	if (line == 0) // impossible - the first line is never inside a javadoc comment
307	return null;
308
309	// don't make any assumptions if the line does not start with \s\ - it might be
310	// commented out code, for which we don't want to change the indent
311	final IRegion lineInfo= document.getLineInformation(line);
312	final int lineStart= lineInfo.getOffset();
313	final int lineLength= lineInfo.getLength();
314	final int lineEnd= lineStart + lineLength;
315	int nonWS= scanner.findNonWhitespaceForwardInAnyPartition(lineStart, lineEnd);
316	if (nonWS == CHeuristicScanner.NOT_FOUND \|\| document.getChar(nonWS) != '*') {
317	if (nonWS == CHeuristicScanner.NOT_FOUND)
318	return document.get(lineStart, lineLength);
319	return document.get(lineStart, nonWS - lineStart);
320	}
321
322	// take the indent from the previous line and reuse
323	IRegion previousLine= document.getLineInformation(line - 1);
324	int previousLineStart= previousLine.getOffset();
325	int previousLineLength= previousLine.getLength();
326	int previousLineEnd= previousLineStart + previousLineLength;
327
328	StringBuffer buf= new StringBuffer();
329	int previousLineNonWS= scanner.findNonWhitespaceForwardInAnyPartition(previousLineStart, previousLineEnd);
330	if (previousLineNonWS == CHeuristicScanner.NOT_FOUND \|\| document.getChar(previousLineNonWS) != '*') {
331	// align with the comment start if the previous line is not an asterisked line
332	previousLine= document.getLineInformationOfOffset(partition.getOffset());
333	previousLineStart= previousLine.getOffset();
334	previousLineLength= previousLine.getLength();
335	previousLineEnd= previousLineStart + previousLineLength;
336	previousLineNonWS= scanner.findNonWhitespaceForwardInAnyPartition(previousLineStart, previousLineEnd);
337	if (previousLineNonWS == CHeuristicScanner.NOT_FOUND)
338	previousLineNonWS= previousLineEnd;
339
340	// add the initial space
341	// TODO this may be controlled by a formatter preference in the future
342	buf.append(' ');
343	}
344
345	String indentation= document.get(previousLineStart, previousLineNonWS - previousLineStart);
346	buf.insert(0, indentation);
347	return buf.toString();
348	}
349
350	/**
351	* Returns the size in characters of a string. All characters count one, tabs count the editor's
352	* preference for the tab display
353	*
354	* @param indent the string to be measured.
355	* @return the size in characters of a string
356	*/
357	private int whiteSpaceLength(String indent) {
358	if (indent == null)
359	return 0;
360	else {
361	int size= 0;
362	int l= indent.length();
363	int tabSize= getTabSize();
364
365	for (int i= 0; i < l; i++)
366	size += indent.charAt(i) == '\t' ? tabSize : 1;
367	return size;
368	}
369	}
370
371	/**
372	* Returns a tab equivalent, either as a tab character or as spaces, depending on the editor and
373	* formatter preferences.
374	*
375	* @return a string representing one tab in the editor, never <code>null</code>
376	*/
377	private String getTabEquivalent() {
378	String tab;
379	if (CCorePlugin.SPACE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR))) {
380	int size= getTabSize();
381	StringBuffer buf= new StringBuffer();
382	for (int i= 0; i< size; i++)
383	buf.append(' ');
384	tab= buf.toString();
385	} else {
386	tab= "\t"; //$NON-NLS-1$
387	}
388
389	return tab;
390	}
391
392	/**
393	* Returns the tab size used by the java editor, which is deduced from the
394	* formatter preferences.
395	*
396	* @return the tab size as defined in the current formatter preferences
397	*/
398	private int getTabSize() {
399	return getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, 4);
400	}
401
402	/**
403	* Returns <code>true</code> if empty lines should be indented, false otherwise.
404	*
405	* @return <code>true</code> if empty lines should be indented, false otherwise
406	*/
407	private boolean indentEmptyLines() {
408	return DefaultCodeFormatterConstants.TRUE.equals(getCoreFormatterOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_EMPTY_LINES));
409	}
410
411	/**
412	* Returns the possibly project-specific core preference defined under <code>key</code>.
413	*
414	* @param key the key of the preference
415	* @return the value of the preference
416	*/
417	private String getCoreFormatterOption(String key) {
418	ICProject project= getCProject();
419	if (project == null)
420	return CCorePlugin.getOption(key);
421	return project.getOption(key, true);
422	}
423
424	/**
425	* Returns the possibly project-specific core preference defined under <code>key</code>, or
426	* <code>def</code> if the value is not a integer.
427	*
428	* @param key the key of the preference
429	* @param def the default value
430	* @return the value of the preference
431	*/
432	private int getCoreFormatterOption(String key, int def) {
433	try {
434	return Integer.parseInt(getCoreFormatterOption(key));
435	} catch (NumberFormatException e) {
436	return def;
437	}
438	}
439
440	/**
441	* Returns the <code>ICProject</code> of the current editor input, or
442	* <code>null</code> if it cannot be found.
443	*
444	* @return the <code>ICProject</code> of the current editor input, or
445	* <code>null</code> if it cannot be found
446	*/
447	private ICProject getCProject() {
448	ITextEditor editor= getTextEditor();
449	if (editor == null)
450	return null;
451
452	ITranslationUnit cu= CUIPlugin.getDefault().getWorkingCopyManager().getWorkingCopy(editor.getEditorInput());
453	if (cu == null)
454	return null;
455	return cu.getCProject();
456	}
457
458	/**
459	* Returns the editor's selection provider.
460	*
461	* @return the editor's selection provider or <code>null</code>
462	*/
463	private ISelectionProvider getSelectionProvider() {
464	ITextEditor editor= getTextEditor();
465	if (editor != null) {
466	return editor.getSelectionProvider();
467	}
468	return null;
469	}
470
471	/*
472	* @see org.eclipse.ui.texteditor.IUpdate#update()
473	*/
474	public void update() {
475	super.update();
476
477	if (isEnabled()) {
478	if (fIsTabAction)
479	setEnabled(canModifyEditor() && isSmartMode() && isValidSelection());
480	else
481	setEnabled(canModifyEditor() && !getSelection().isEmpty());
482	}
483	}
484
485	/**
486	* Returns if the current selection is valid, i.e. whether it is empty and the caret in the
487	* whitespace at the start of a line, or covers multiple lines.
488	*
489	* @return <code>true</code> if the selection is valid for an indent operation
490	*/
491	private boolean isValidSelection() {
492	ITextSelection selection= getSelection();
493	if (selection.isEmpty())
494	return false;
495
496	int offset= selection.getOffset();
497	int length= selection.getLength();
498
499	IDocument document= getDocument();
500	if (document == null)
501	return false;
502
503	try {
504	IRegion firstLine= document.getLineInformationOfOffset(offset);
505	int lineOffset= firstLine.getOffset();
506
507	// either the selection has to be empty and the caret in the WS at the line start
508	// or the selection has to extend over multiple lines
509	if (length == 0) {
510	return document.get(lineOffset, offset - lineOffset).trim().length() == 0;
511	} else {
512	// return lineOffset + firstLine.getLength() < offset + length;
513	return false; // only enable for empty selections for now
514	}
515	} catch (BadLocationException e) {
516	}
517
518	return false;
519	}
520
521	/**
522	* Returns the smart preference state.
523	*
524	* @return <code>true</code> if smart mode is on, <code>false</code> otherwise
525	*/
526	private boolean isSmartMode() {
527	ITextEditor editor= getTextEditor();
528
529	if (editor instanceof ITextEditorExtension3)
530	return ((ITextEditorExtension3) editor).getInsertMode() == ITextEditorExtension3.SMART_INSERT;
531
532	return false;
533	}
534
535	/**
536	* Returns the document currently displayed in the editor, or <code>null</code> if none can be
537	* obtained.
538	*
539	* @return the current document or <code>null</code>
540	*/
541	private IDocument getDocument() {
542
543	ITextEditor editor= getTextEditor();
544	if (editor != null) {
545
546	IDocumentProvider provider= editor.getDocumentProvider();
547	IEditorInput input= editor.getEditorInput();
548	if (provider != null && input != null)
549	return provider.getDocument(input);
550
551	}
552	return null;
553	}
554
555	/**
556	* Returns the selection on the editor or an invalid selection if none can be obtained. Returns
557	* never <code>null</code>.
558	*
559	* @return the current selection, never <code>null</code>
560	*/
561	private ITextSelection getSelection() {
562	ISelectionProvider provider= getSelectionProvider();
563	if (provider != null) {
564
565	ISelection selection= provider.getSelection();
566	if (selection instanceof ITextSelection)
567	return (ITextSelection) selection;
568	}
569
570	// null object
571	return TextSelection.emptySelection();
572	}
573	}