devicemanagementpreferencepage.java

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

/**
 * Copyright (c) 2003-2005 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.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.wizard.WizardDialog;
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.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IActionDelegate;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.PlatformUI;

import eclipseme.core.internal.EclipseMECorePlugin;
import eclipseme.core.model.device.DeviceRegistry;
import eclipseme.core.model.device.IDevice;
import eclipseme.core.persistence.PersistableUtilities;
import eclipseme.core.persistence.PersistenceException;
import eclipseme.ui.internal.EclipseMEUIPlugin;
import eclipseme.ui.internal.devices.DeviceEditorConfigElement;
import eclipseme.ui.internal.devices.DeviceEditorRegistry;
import eclipseme.ui.internal.devices.DeviceImportWizard;
import eclipseme.ui.internal.devices.DeviceTableLabelProvider;
import eclipseme.ui.viewers.TableColumnInfo;
import eclipseme.ui.viewers.TableViewerConfiguration;

/**
 * Implements the preference page for managing the registered
 * devices.
 * <p />
 * Copyright (c) 2003-2005 Craig Setera<br>
 * All Rights Reserved.<br>
 * Licensed under the Eclipse Public License - v 1.0<p/>
 * <br>
 * $Revision: 1.7 $
 * <br>
 * $Date: 2006/05/15 21:31:40 $
 * <br>
 * @author Craig Setera
 */
public class DeviceManagementPreferencePage 
	extends PreferencePage 
	implements IWorkbenchPreferencePage 
{
	/** Identifier of this preference page */
	public static final String ID = "eclipseme.ui.preferences.deviceManagementPreferencePage";
	
	// A pattern for locating previously unique-ified names.
	private static final Pattern UNIQUE_NAME_PATTERN = Pattern.compile("^.+\\((\\d+)\\)$");
	
	// Column information structure
	private static final int DEFAULT_TABLE_WIDTH = 550;
	private static final TableColumnInfo[] COLUMN_INFO = new TableColumnInfo[] {
		new TableColumnInfo("Default", 10f, null),
		new TableColumnInfo("Group", 22.5f, null),
		new TableColumnInfo("Name", 22.5f, null),
		new TableColumnInfo("Configuration", 22.5f, null),
		new TableColumnInfo("Profile", 22.5f, null),
	};
	private static final Object[] NO_ELEMENTS = new Object[0];

	/**
	 * 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) {
			Object[] elements = NO_ELEMENTS;
			
			try {
				List registeredDevices = DeviceRegistry.singleton.getAllDevices();
				elements =  
					registeredDevices.toArray(new IDevice[registeredDevices.size()]);
			} catch (PersistenceException e) {
				handleException("Error retrieving all devices", e);
			}
			
			return elements;
		}

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

	// Widgets
	private IWorkbench workbench;
	private CheckboxTableViewer viewer;
	private Button deleteButton;
	private Button duplicateButton;
	private Button editButton;
	
	private boolean updatingCheckState;
	
	private IAction editAction;
	private IActionDelegate editDelegate;

	/**
	 * Construct a new preference page instance 
	 */
	public DeviceManagementPreferencePage() {
		super("Manage Devices");
		setDescription("Specify the devices to be used by J2ME projects");
		
		editAction = new Action() {};
	}

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

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#performCancel()
	 */
	public boolean performCancel() {
		performDefaults();
		return true;
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#performDefaults()
	 */
	protected void performDefaults() {
		try {
			DeviceRegistry.singleton.clear();
			DeviceRegistry.singleton.load();
		} catch (Exception e) {
			EclipseMEUIPlugin.displayError(
				getShell(), 
				IStatus.ERROR, 
				-999, 
				"Error reloading devices", 
				"Error reloading devices.\nConsult the error log for more information",
				e);
			EclipseMECorePlugin.log(
					IStatus.ERROR, 
					"Devices Load Error " + 
						e.getClass().getName() + 
						": " + e.getMessage(), e);
		}
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#performOk()
	 */
	public boolean performOk() {
		boolean wasOK = false;
		
		try {
			DeviceRegistry.singleton.store();
			wasOK = true;
		} catch (Exception e) {
			EclipseMEUIPlugin.displayError(
				getShell(), 
				IStatus.ERROR, 
				-999, 
				"Error storing devices", 
				"Error storing devices.\nConsult the error log for more information",
				e);
			EclipseMECorePlugin.log(
				IStatus.ERROR, 
				"Devices Store Error " + 
					e.getClass().getName() + 
					": " + e.getMessage(), e);
		}

		return wasOK;
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		Control control = null;
		
		try {
			DeviceRegistry.singleton.load();
			control = createDeviceContents(parent);
		} catch (Exception e) {
			EclipseMECorePlugin.log(IStatus.ERROR, e);
			control = createErrorContents(parent, e);
		} 
		
		PlatformUI.getWorkbench().getHelpSystem().setHelp(control, "eclipseme.ui.help_DeviceManagementPage");
		return control;
	}

	/**
	 * Create contents for a normal error-free case.
	 * 
	 * @param parent
	 * @return
	 */
	private Control createDeviceContents(Composite parent) {
		Composite composite = new Composite(parent, SWT.NONE);
		composite.setLayout(new GridLayout(2, false));
		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
		
		GridData gridData = new GridData(GridData.FILL_BOTH);
		gridData.minimumWidth = DEFAULT_TABLE_WIDTH;
		gridData.heightHint = 400;
		viewer = createTableViewer(composite);
		viewer.getTable().setLayoutData(gridData);

		Composite buttonComposite = new Composite(composite, SWT.NONE);
		buttonComposite.setLayout(new GridLayout(1, true));
		buttonComposite.setLayoutData(new GridData(GridData.FILL_VERTICAL));
		
		Button importButton = new Button(buttonComposite, SWT.PUSH);
		importButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		importButton.setText("Import...");
		importButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				importDevices();
			}
		});
		
		editButton = new Button(buttonComposite, SWT.PUSH);
		editButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		editButton.setText("Edit...");
		editButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleEditButton();
			}
		});

		duplicateButton = new Button(buttonComposite, SWT.PUSH);
		duplicateButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		duplicateButton.setText("Duplicate");
		duplicateButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleDuplicateButton();
			}
		});
		
		deleteButton = new Button(buttonComposite, SWT.PUSH);
		deleteButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		deleteButton.setText("Delete");
		deleteButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleDeleteButton();
			}
		});
		
		// Wire up some enablement handling
		updateButtonEnablement(viewer.getSelection());
		updateCheckboxState();
		viewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				updateButtonEnablement(event.getSelection());
			}
		});

		return composite;
	}

	/**