symboldefinitionspreferencepage.java

eclipseme的最新版本的source,欢迎j2me程序员使用

/**
 * Copyright (c) 2003-2006 Craig Setera
 * All Rights Reserved.
 * Licensed under the Eclipse Public License - v 1.0
 * For more information see http://www.eclipse.org/legal/epl-v10.html
 */
package eclipseme.ui.internal.preferences;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.xml.transform.TransformerException;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ComboViewer;
import org.eclipse.jface.viewers.ICellEditorListener;
import org.eclipse.jface.viewers.ICellEditorValidator;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
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.graphics.Image;
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.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;

import eclipseme.core.internal.EclipseMECorePlugin;
import eclipseme.core.model.SymbolDefinitionSet;
import eclipseme.core.model.SymbolDefinitionSetRegistry;
import eclipseme.core.persistence.PersistenceException;

/**
 * Preference page for defining and editing the available
 * symbol definition instances that are used for handling
 * device fragmentation.
 * <p />
 * Copyright (c) 2003-2006 Craig Setera<br>
 * All Rights Reserved.<br>
 * Licensed under the Eclipse Public License - v 1.0<p/>
 * <br>
 * $Revision: 1.3 $
 * <br>
 * $Date: 2006/11/27 00:58:10 $
 * <br>
 * @author Craig Setera
 */
public class SymbolDefinitionsPreferencePage 
	extends PreferencePage 
	implements IWorkbenchPreferencePage 
{
	// A regular expression compiled Pattern that matches on whitespace
	// within a string
	private static final Pattern WHITESPACE_PATTERN = 
		Pattern.compile(".*\\s+.*");
	
	// Column information structure
	private static final Object[] NO_ELEMENTS = new Object[0];

	// Column property names
	private static final String PROP_SYMBOL = "symbol";

	// All of the properties in order
	private static final String[] PROPERTIES = new String[] { PROP_SYMBOL };
	
	// A cell modifier implementation for the device libraries editor
	private class CellModifier implements ICellModifier {
		public boolean canModify(Object element, String property) {
			return true;
		}

		public Object getValue(Object element, String property) {
			return element;
		}

		public void modify(Object element, String property, Object value) {
			String newSymbol = (String) value;
			if (isValidSymbol(newSymbol)) {
				TableItem item = (TableItem) element;
				String oldSymbol = item.getText();
				
				int itemIndex = currentDefinitions.indexOf(oldSymbol);
				if (itemIndex != -1) {
					currentDefinitions.set(itemIndex, value);
					tableViewer.refresh();
				}
			}
			
			setErrorMessage(null);
		}
	}

	// Label provider for the definitions set combo viewer
	private class DefinitionSetLabelProvider extends LabelProvider {
		public String getText(Object element) {
			return ((SymbolDefinitionSet) element).getName();
		}
	}
	
	// Content provider for the definitions set combo viewer
	private class DefinitionSetsContentProvider implements IStructuredContentProvider {
		public Object[] getElements(Object inputElement) {
			Object[] definitions = NO_ELEMENTS;
			
			try {
				definitions = SymbolDefinitionSetRegistry.singleton.getAllSetDefinitions();
			} catch (PersistenceException e) {
				handleException("Error retrieving symbol definitions", e);
			}
			
			return definitions;
		}

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

	/**
	 * Implementation of the table's content provider.
	 */
	private class TableContentProvider implements IStructuredContentProvider {
		/**
		 * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
		 */
		public Object[] getElements(Object inputElement) {
			return (Object[]) currentDefinitions.toArray(new Object[currentDefinitions.size()]);
		}

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

		/**
		 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
		 */
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			if (oldInput != null) {
				commitSymbolDefinitions((SymbolDefinitionSet) oldInput);
			}
			
			Object[] symbols = NO_ELEMENTS;
			if (newInput instanceof SymbolDefinitionSet) {
				SymbolDefinitionSet set = (SymbolDefinitionSet) newInput;
				symbols = set.getDefinedSymbols();
				
				if (set != null) {
					symbolsGroup.setText("Symbols in set \"" + set.getName() + "\"");
				}
			}
			
			currentDefinitions = new ArrayList(Arrays.asList(symbols));
		}
	}
	
	// Validates that the value for the symbol is a valid value 
	private class SymbolNameCellEditorValidator implements ICellEditorValidator {
		public String isValid(Object value) {
			String symbol = (String) value;
			return isValidSymbol(symbol) ?
				null :
				"Whitespace not allowed in symbol definitions."; 
		}
	}
	
	// Label provider for the strings returned by the content provider.
	private class StringLabelProvider extends LabelProvider implements ITableLabelProvider {
		/**
		 * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang.Object, int)
		 */
		public Image getColumnImage(Object element, int columnIndex) {
			return null;
		}

		/**
		 * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object, int)
		 */
		public String getColumnText(Object element, int columnIndex) {
			return (columnIndex == 0) ? (String) element : "";
		}
	}

	// UI widgets
	private IWorkbench workbench;
	private ComboViewer definitionsComboViewer;
	private TableViewer tableViewer;
	private Button addSetButton;
	private Button removeSetButton;
	private Button addSymbolButton;
	private Button removeSymbolButton;

	// Tracks the current definitions in the table viewer until they
	// are committed back to the underlying model
	private ArrayList currentDefinitions;

	private Group symbolsGroup;

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

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		Composite composite = new Composite(parent, SWT.NONE);
		composite.setLayout(new GridLayout(1, true));
		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
		
		Composite nameComposite = new Composite(composite, SWT.NONE);
		nameComposite.setLayout(new GridLayout(3, false));
		nameComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		
		new Label(nameComposite, SWT.NONE).setText("Definition Set: ");
		
		definitionsComboViewer = new ComboViewer(nameComposite, SWT.DROP_DOWN);
		definitionsComboViewer.setContentProvider(new DefinitionSetsContentProvider());
		definitionsComboViewer.setLabelProvider(new DefinitionSetLabelProvider());
		definitionsComboViewer.setSorter(new ViewerSorter());

		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.verticalAlignment = SWT.CENTER;
		definitionsComboViewer.getCombo().setLayoutData(gd);
		definitionsComboViewer.getCombo().addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				updateButtonEnablement();
			}
		});
		
		Composite nameButtonComposite = new Composite(nameComposite, SWT.NONE);
		nameButtonComposite.setLayout(new GridLayout(1, true));

		addSetButton = new Button(nameButtonComposite, SWT.PUSH);
		addSetButton.setText("Add");
		addSetButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		addSetButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleAddSetButton();
			}
		});
		
		removeSetButton = new Button(nameButtonComposite, SWT.PUSH);
		removeSetButton.setText("Remove");
		removeSetButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		removeSetButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleRemoveSetButton();
			}
		});
		
		symbolsGroup = new Group(composite, SWT.NONE);
		symbolsGroup.setLayout(new GridLayout(2, false));
		
		GridData gridData = new GridData(GridData.FILL_BOTH);
		gridData.minimumWidth = 400;
		gridData.heightHint = 300;
		tableViewer = createTableViewer(symbolsGroup);
		tableViewer.getTable().setLayoutData(gridData);
		
		Composite symbolsButtonComposite = new Composite(symbolsGroup, SWT.NONE);
		symbolsButtonComposite.setLayout(new GridLayout(1, true));
		
		addSymbolButton = new Button(symbolsButtonComposite, SWT.PUSH);
		addSymbolButton.setText("Add");
		addSymbolButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		addSymbolButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleAddSymbolButton();
			}
		});
		
		removeSymbolButton = new Button(symbolsButtonComposite, SWT.PUSH);
		removeSymbolButton.setText("Remove");
		removeSymbolButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		removeSymbolButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleRemoveSymbolButton();
			}
		});
		
		definitionsComboViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				updateButtonEnablement();
				
				SymbolDefinitionSet set = getSelectedSymbolDefinitionSet();
				tableViewer.setInput(set);
			}
		});

		initializeDefinitionsCombo();
		
		return composite;
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#performCancel()
	 */
	public boolean performCancel() {
		// Force a reload of the symbol definitions registry
		return reloadSymbolDefinitionsRegistry() && super.performCancel();
	}