Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2011 itemis AG (http://www.itemis.eu) 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 /
  
  package org.eclipse.xtext.ui.preferences;
  
 import java.util.List;
 import java.util.Map;
 
 import  org.eclipse.core.resources.IProject;
 import  org.eclipse.core.resources.IncrementalProjectBuilder;
 import  org.eclipse.core.resources.ResourcesPlugin;
 import  org.eclipse.core.runtime.CoreException;
 import  org.eclipse.core.runtime.IProgressMonitor;
 import  org.eclipse.core.runtime.IStatus;
 import  org.eclipse.core.runtime.OperationCanceledException;
 import  org.eclipse.core.runtime.Status;
 import  org.eclipse.core.runtime.SubProgressMonitor;
 import  org.eclipse.core.runtime.jobs.Job;
 import  org.eclipse.jface.dialogs.IDialogConstants;
 import  org.eclipse.jface.dialogs.IDialogSettings;
 import  org.eclipse.jface.dialogs.MessageDialog;
 import  org.eclipse.jface.preference.IPersistentPreferenceStore;
 import  org.eclipse.jface.preference.IPreferenceStore;
 import  org.eclipse.jface.resource.JFaceResources;
 import  org.eclipse.osgi.util.TextProcessor;
 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.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.swt.widgets.Widget;
 import  org.eclipse.ui.forms.events.ExpansionAdapter;
 import  org.eclipse.ui.forms.events.ExpansionEvent;
 import  org.eclipse.ui.forms.widgets.ExpandableComposite;
 import  org.eclipse.ui.plugin.AbstractUIPlugin;
 import  org.eclipse.ui.preferences.IWorkbenchPreferenceContainer;
 
Initially copied from jdt's OptionsConfigurationBlock

Author(s):
Michael Clay
Since:
2.1
 
 public abstract class OptionsConfigurationBlock {
 	AbstractUIPlugin uiPlugin;
 
 
 	private static final String IS_PROJECT_SPECIFIC = "is_project_specific"//$NON-NLS-1$
 	private static final String SETTINGS_EXPANDED = "expanded"//$NON-NLS-1$
 	private static final String REBUILD_COUNT_KEY = "preferences_build_requested"//$NON-NLS-1$
 
 	protected static class ControlData {
 		private String key;
 		private String[] values;
 
 		public ControlData(String keyString[] values) {
 			this. = key;
 			this. = values;
 		}
 
 		public String getKey() {
 			return ;
 		}
 
 		public String getValue(boolean selection) {
 			int index = selection ? 0 : 1;
 			return [index];
 		}
 
 		public String getValue(int index) {
 			return [index];
 		}
 
 		public int getSelection(String value) {
 			if (value != null) {
				for (int i = 0; i < .i++) {
					if (value.equals([i])) {
						return i;
					}
				}
			}
			return . - 1; // assume the last option is the least severe
		}
	}
	public static final class BuildJob extends Job {
		private final IProject project;
		public BuildJob(String name, IProject project) {
			super(name);
			this. = project;
		}
		public boolean isCoveredBy(BuildJob other) {
			if (other.project == null) {
				return true;
			}
			return  != null && .equals(other.project);
		}
		protected IStatus run(IProgressMonitor monitor) {
			synchronized (getClass()) {
				if (monitor.isCanceled()) {
					return Status.CANCEL_STATUS;
				}
				Job[] buildJobs = Job.getJobManager().find(ResourcesPlugin.FAMILY_MANUAL_BUILD);
				for (int i = 0; i < buildJobs.length; i++) {
					if (buildJobs[i] != this && buildJobs[iinstanceof BuildJob) {
						BuildJob job = (BuildJobbuildJobs[i];
						if (job.isCoveredBy(this)) {
							buildJobs[i].cancel();
						}
					}
				}
			}
			try {
				if ( != null) {
					monitor.beginTask(String.format(
							TextProcessor.process(.getName(), ":.")), //$NON-NLS-2$ //$NON-NLS-1$ //$NON-NLS-1$
							2);
					.build(IncrementalProjectBuilder.FULL_BUILD, new SubProgressMonitor(monitor, 1));
					ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD,
							new SubProgressMonitor(monitor, 1));
else {
					ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD,
							new SubProgressMonitor(monitor, 2));
				}
catch (CoreException e) {
				return e.getStatus();
catch (OperationCanceledException e) {
				return Status.CANCEL_STATUS;
finally {
				monitor.done();
			}
			return Status.OK_STATUS;
		}
		public boolean belongsTo(Object family) {
			return ResourcesPlugin.FAMILY_MANUAL_BUILD == family;
		}
	}
	protected final List<Button> checkBoxes = Lists.newArrayList();
	protected final List<Text> textBoxes = Lists.newArrayList();
	protected final List<Combo> comboBoxes = Lists.newArrayList();
	protected final Map<Control, Label> labels = Maps.newHashMap();
	protected final List<ExpandableComposite> expandedComposites = Lists.newArrayList();
	private SelectionListener selectionListener;
	private ModifyListener textModifyListener;
	protected IProject project;
	protected String[] keys;
	private Shell shell;
	private int rebuildCount;
	private IPreferenceStore preferenceStore;
	private IWorkbenchPreferenceContainer workbenchPreferenceContainer;
	private List<StringkeysToRegister = Lists.newArrayList();
	public IProject getProject() {
		return ;
	}
		this. = fContext;
	}
	public OptionsConfigurationBlock(IProject project, IPreferenceStore preferenceStore,
			IWorkbenchPreferenceContainer container) {
		this. = project;
		this. = new String[] {};
		this.setPreferenceStore(preferenceStore);
		this. = container;
	}
		this. = new String[] {};
	}
	public void setWorkbenchPreferenceContainer(IWorkbenchPreferenceContainer workbenchPreferenceContainer) {
		this. = workbenchPreferenceContainer;
	}
	public void setProject(IProject project) {
		this. = project;
	}
	public void setPreferenceStore(IPreferenceStore preferenceStore) {
		this. = preferenceStore;
	}
	private void updateDisabledProjSettings(IProject project, IPreferenceStore preferenceStoreString[] allKeys) {
		if (project == null || hasProjectSpecificOptions(project)) {
else {
			for (String key : allKeys) {
				.put(keypreferenceStore.getString(key));
			}
		}
	}
	public boolean hasProjectSpecificOptions(IProject project) {
		IPreferenceStore ps = ;
		if (project != getProject()) {
		}
		// backward compatibility
		boolean oldSettingsUsed = ps.getBoolean();
		boolean newSettingsValue = ps.getBoolean(getIsProjectSpecificPropertyKey(getPropertyPrefix()));
		if (oldSettingsUsed) {
			if (!newSettingsValue) {
				return true;
			}
		}
		return newSettingsValue;
	}
	protected void setShell(Shell shell) {
		this. = shell;
	}
	protected Shell getShell() {
		return ;
	}
	public final Control createContents(Composite parent) {
		Control content = doCreateContents(parent);
		return content;
	}
	protected abstract Control doCreateContents(Composite parent);
	protected Button addCheckBox(Composite parentString labelString keyString[] valuesint indent) {
		ControlData data = new ControlData(keyvalues);
		GridData gd = new GridData(SWT.FILL, SWT.CENTER, truefalse);
		gd.horizontalSpan = 3;
		gd.horizontalIndent = indent;
		return addCheckboxWithData(parentlabeldatagd);
	}
	protected Button addCheckboxWithData(Composite parentString labelControlData data, GridData gd) {
		Button checkBox = new Button(parent, SWT.CHECK);
		checkBox.setFont(JFaceResources.getDialogFont());
		checkBox.setText(label);
		checkBox.setData(data);
		checkBox.setLayoutData(gd);
		checkBox.addSelectionListener(getSelectionListener());
		updateCheckBox(checkBox);
		.add(checkBox);
		return checkBox;
	}
	protected Text addTextField(Composite parentString labelString keyint indentint widthHint) {
		Label labelControl = new Label(parent, SWT.WRAP);
		labelControl.setText(label);
		labelControl.setFont(JFaceResources.getDialogFont());
		GridData labelLayoutData = new GridData();
		labelLayoutData.horizontalIndent = indent;
		labelControl.setLayoutData(labelLayoutData);
		Text textBox = new Text(parent, SWT.BORDER | SWT.SINGLE);
		textBox.setData(key);
		.put(textBoxlabelControl);
		updateText(textBox);
		textBox.addModifyListener(getTextModifyListener());
		GridData textLayoutData = new GridData(SWT.FILL, SWT.CENTER, truefalse, 2, 1);
		if (widthHint != 0) {
			textLayoutData.widthHint = widthHint;
		}
		textBox.setLayoutData(textLayoutData);
		.add(textBox);
		return textBox;
	}
	protected Combo addComboBox(Composite parentString labelString keyint indentString[] values,
			String[] valueLabels) {
		GridData gd = new GridData(GridData.FILL, GridData.CENTER, truefalse, 2, 1);
		gd.horizontalIndent = indent;
		Label labelControl = new Label(parent, SWT.LEFT);
		labelControl.setFont(JFaceResources.getDialogFont());
		labelControl.setText(label);
		labelControl.setLayoutData(gd);
		Combo comboBox = newComboControl(parentkeyvaluesvalueLabels);
		comboBox.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, falsefalse));
		.put(comboBoxlabelControl);
		return comboBox;
	}
	protected Combo newComboControl(Composite compositeString keyString[] valuesString[] valueLabels) {
		ControlData data = new ControlData(keyvalues);
		Combo comboBox = new Combo(composite, SWT.READ_ONLY);
		comboBox.setItems(valueLabels);
		comboBox.setData(data);
		comboBox.addSelectionListener(getSelectionListener());
		comboBox.setFont(JFaceResources.getDialogFont());
		comboBox.setVisibleItemCount(30);
		updateCombo(comboBox);
		.add(comboBox);
		return comboBox;
	}
	private ScrolledPageContent getParentScrolledComposite(Control control) {
		Control parent = control.getParent();
		while (!(parent instanceof ScrolledPageContent) && parent != null) {
			parent = parent.getParent();
		}
		if (parent instanceof ScrolledPageContent) {
			return (ScrolledPageContentparent;
		}
		return null;
	}
	private void makeScrollableCompositeAware(Control control) {
		ScrolledPageContent parentScrolledComposite = getParentScrolledComposite(control);
		if (parentScrolledComposite != null) {
			parentScrolledComposite.adaptChild(control);
		}
	}
	protected ExpandableComposite createStyleSection(Composite parentString labelint nColumns) {
		ExpandableComposite excomposite = new ExpandableComposite(parent, SWT.NONE, ExpandableComposite.TWISTIE
				| ExpandableComposite.CLIENT_INDENT);
		excomposite.setText(label);
		excomposite.setExpanded(false);
		excomposite.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DIALOG_FONT));
		excomposite.setLayoutData(new GridData(GridData.FILL, GridData.FILL, truefalsenColumns, 1));
		excomposite.addExpansionListener(new ExpansionAdapter() {
			public void expansionStateChanged(ExpansionEvent e) {
				expandedStateChanged((ExpandableComposite) e.getSource());
			}
		});
		.add(excomposite);
		return excomposite;
	}
	protected final void expandedStateChanged(ExpandableComposite expandable) {
		ScrolledPageContent parentScrolledComposite = getParentScrolledComposite(expandable);
		if (parentScrolledComposite != null) {
			parentScrolledComposite.reflow(true);
		}
	}
	protected void restoreSectionExpansionStates(IDialogSettings settings) {
		for (int i = 0; i < .size(); i++) {
			ExpandableComposite excomposite = .get(i);
			if (settings == null) {
				excomposite.setExpanded(i == 0); // only expand the first node by default
else {
				excomposite.setExpanded(settings.getBoolean( + String.valueOf(i)));
			}
		}
	}
	protected void storeSectionExpansionStates(IDialogSettings settings) {
		for (int i = 0; i < .size(); i++) {
			ExpandableComposite curr = .get(i);
			settings.put( + String.valueOf(i), curr.isExpanded());
		}
	}
	protected SelectionListener getSelectionListener() {
		if ( == null) {
			 = new SelectionListener() {
				public void widgetDefaultSelected(SelectionEvent e) {
				}
				public void widgetSelected(SelectionEvent e) {
					controlChanged(e.widget);
				}
			};
		}
	}
	protected ModifyListener getTextModifyListener() {
		if ( == null) {
			 = new ModifyListener() {
				public void modifyText(ModifyEvent e) {
					textChanged((Text) e.widget);
				}
			};
		}
	}
	protected void controlChanged(Widget widget) {
		ControlData data = (ControlDatawidget.getData();
		String newValue = null;
		if (widget instanceof Button) {
			newValue = data.getValue(((Button) widget).getSelection());
else if (widget instanceof Combo) {
			newValue = data.getValue(((Combo) widget).getSelectionIndex());
else {
			return;
		}
		String oldValue = setValue(data.getKey(), newValue);
		validateSettings(data.getKey(), oldValuenewValue);
	}
	protected void textChanged(Text textControl) {
		String key = (StringtextControl.getData();
		String number = textControl.getText();
		String oldValue = setValue(keynumber);
		validateSettings(keyoldValuenumber);
	}
	protected String getValue(String key) {
		if ( != null) {
		}
		return .getString(key);
	}
	protected String setValue(String keyString value) {
		if ( != null) {
			return .put(keyvalue);
		}
		String oldValue = getValue(key);
		.putValue(keyvalue);
		return oldValue;
	}
	protected String setToDefault(String key) {
		String value = .getDefaultString(key);
		if ( != null) {
			return .put(keyvalue);
		}
		String oldValue = getValue(key);
		.setValue(keyvalue);
		return oldValue;
	}
	public void useProjectSpecificSettings(boolean enable) {
		boolean hasProjectSpecificOption =  == null;
		if (enable != hasProjectSpecificOption &&  != null) {
			if (enable) {
				for (int i = 0; i < .i++) {
					String curr = [i];
					.putValue(currval);
				}
				validateSettings(nullnullnull);
else {
				for (int i = 0; i < .i++) {
					String curr = [i];
					String oldSetting = .getString(curr);
					.put(curroldSetting);
					.setToDefault(curr);
				}
				//backward compatibility
			}
		}
	}
	public boolean performOk() {
	}
	public boolean performApply() {
	}
	private int getRebuildCount() {
		return .getDefaultInt();
	}
	private void incrementRebuildCount() {
	}
	protected boolean processChanges(IWorkbenchPreferenceContainer container) {
		boolean needsBuild = !getPreferenceChanges().isEmpty();
		boolean doBuild = false;
		if (needsBuild) {
			int count = getRebuildCount();
			if (count > ) {
				needsBuild = false;
				 = count;
			}
		}
		if (needsBuild) {
			String[] strings = getFullBuildDialogStrings( == null);
			if (strings != null) {
				MessageDialog dialog = new MessageDialog(strings[0], nullstrings[1], MessageDialog.QUESTION,
						new String[] { IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL,
								IDialogConstants.CANCEL_LABEL }, 2);
				int res = dialog.open();
				if (res == 0) {
					doBuild = true;
else if (res != 1) {
					return false;
				}
			}
		}
		if (container != null) {
			if (doBuild) {
				container.registerUpdateJob(getBuildJob(getProject()));
			}
else {
			if (doBuild) {
				getBuildJob(getProject()).schedule();
			}
		}
		return true;
	}
	protected void savePreferences() {
		try {
			if ( instanceof IPersistentPreferenceStore) {
				((IPersistentPreferenceStore) ).save();
			}
catch (IOException e) {
			logError("Unexpected internal error: "e); //$NON-NLS-1$
		}
	}
	private void logError(String textIOException e) {
		IStatus status = new Status(IStatus.ERROR, .getBundle().getSymbolicName(), texte);
		.getLog().log(status);
	}
		Map<StringStringcurrentSettings = Maps.newHashMapWithExpectedSize(.);
		for (String key : ) {
			currentSettings.put(key.getString(key));
		}
		MapDifference<StringStringmapDifference = Maps.difference(currentSettings);
		Map<StringValueDifference<String>> entriesDiffering = mapDifference.entriesDiffering();
		return entriesDiffering;
	}
	protected abstract Job getBuildJob(IProject project);
	protected abstract String[] getFullBuildDialogStrings(boolean workspaceSettings);
	public void performDefaults() {
		for (int i = 0; i < .i++) {
			String curr = [i];
		}
		validateSettings(nullnullnull);
	}
	public void dispose() {
	}
	protected void updateControls() {
		for (int i = .size() - 1; i >= 0; i--) {
		}
		for (int i = .size() - 1; i >= 0; i--) {
		}
		for (int i = .size() - 1; i >= 0; i--) {
		}
	}
	protected void collectRegistredKeys() {
		List<StringcollectedKeys = Lists.newArrayList();
		for (Combo combo : ) {
			ControlData data = (ControlDatacombo.getData();
			collectedKeys.add(data.getKey());
		}
		for (Button button : ) {
			ControlData data = (ControlDatabutton.getData();
			collectedKeys.add(data.getKey());
		}
		for (Text textField : ) {
			collectedKeys.add((StringtextField.getData());
		}
		collectedKeys.addAll();
		this. = Iterables.toArray(collectedKeysString.class);
	}
	protected void updateCombo(Combo curr) {
		ControlData data = (ControlDatacurr.getData();
		String currValue = getValue(data.getKey());
		int selection = data.getSelection(currValue);
		curr.select(selection);
	}
	protected void updateCheckBox(Button curr) {
		ControlData data = (ControlDatacurr.getData();
		curr.setSelection(checkBoxValue(data));
	}
	private boolean checkBoxValue(ControlData data) {
		String currValue = getValue(data.getKey());
		boolean selection = data.getSelection(currValue) == 0;
		return selection;
	}
	protected void updateText(Text curr) {
		String key = (Stringcurr.getData();
		String currValue = getValue(key);
		if (currValue != null) {
			curr.setText(currValue);
		}
	}
	protected abstract void validateSettings(String changedKeyString oldValueString newValue);
	private void captureOriginalSettings(String[] keys) {
		for (String key : keys) {
			.put(key.getString(key));
		}
	}
	protected void registerKey(String key) {
	}
	public abstract String getPropertyPrefix();
	public String getIsProjectSpecificPropertyKey(String propertyPrefix) {
		if (propertyPrefix != null) {
			key = isProjectSpecificPropertyKey(propertyPrefix);
else {
			logError("Project specific key is not qualified"null);
		}
		return key;
	}
	public static String isProjectSpecificPropertyKey(String propertyPrefix) {
		return propertyPrefix + "." + ;
	}
New to GrepCode? Check out our FAQ X