j2meprojectpropertiespage.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
 * 
 * Signature support added 2004 by Kevin Hunter
 */
package eclipseme.ui.internal.properties;

import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.Comparator;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jdt.core.ClasspathContainerInitializer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ComboViewer;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
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.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.IWorkbenchPropertyPage;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.PropertyPage;

import eclipseme.core.IEclipseMECoreConstants;
import eclipseme.core.internal.EclipseMECorePlugin;
import eclipseme.core.internal.preprocessor.PreprocessorBuilder;
import eclipseme.core.model.IMidletSuiteProject;
import eclipseme.core.model.MidletSuiteFactory;
import eclipseme.core.model.SymbolDefinitionSet;
import eclipseme.core.model.SymbolDefinitionSetRegistry;
import eclipseme.core.model.device.IDevice;
import eclipseme.core.nature.J2MENature;
import eclipseme.core.persistence.PersistenceException;
import eclipseme.ui.EclipseMEUIErrors;
import eclipseme.ui.EclipseMEUIStrings;
import eclipseme.ui.devices.DeviceSelector;

/**
 * Property page implementation for J2ME properties associated
 * with the project.
 * <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.22 $
 * <br>
 * $Date: 2006/12/20 02:42:22 $
 * <br>
 * @author Craig Setera
 * @see PropertyPage
 */
public class J2MEProjectPropertiesPage 
	extends PropertyPage 
	implements IWorkbenchPropertyPage 
{
	private static final Object[] NO_ELEMENTS = new Object[0];
	
	// Comparator for definition sets based on name
	private class DefinitionSetComparator implements Comparator {
		public int compare(Object obj1, Object obj2) {
			SymbolDefinitionSet set1 = (SymbolDefinitionSet) obj1;
			SymbolDefinitionSet set2 = (SymbolDefinitionSet) obj2;
			
			return set1.getName().compareTo(set2.getName());
		}
	}
	
	// A content provider wrapped around the available symbol definitions.
	private class SymbolDefinitionSetsContentProvider implements IStructuredContentProvider {
		public Object[] getElements(Object inputElement) {
			Object[] elements = NO_ELEMENTS;
			
			try {
				elements = SymbolDefinitionSetRegistry.singleton.getAllSetDefinitions();
				Arrays.sort(elements, new DefinitionSetComparator());
			} catch (PersistenceException e) {
				EclipseMECorePlugin.log(IStatus.WARNING, e);
			}
			
			return elements;
		}

		public void dispose() {
			// Nothing to do
		}
		
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			// Nothing to do
		}
	}
	
	// Label provider wrapped around a SymbolDefinitionSet
	private class SymbolDefinitionSetLabelProvider extends LabelProvider {
		public String getText(Object element) {
			String text = "";
			
			if (element instanceof SymbolDefinitionSet) {
				text = ((SymbolDefinitionSet) element).getName();
			}
			
			return text;
		}
	}
	
	private DeviceSelector deviceSelector;
	private ComboViewer symbolDefinitionSetViewer;
	
	/**
	 * Returns <code>true</code> if the page data is currently valid.
	 * @see org.eclipse.jface.preference.IPreferencePage#isValid()
	 */
	public boolean isValid()
	{
		return deviceSelector.getSelectedDevice() != null;
	}
	
	/**
	 * @see org.eclipse.jface.preference.IPreferencePage#performOk()
	 */
	public boolean performOk()
	{
		boolean succeeded = false;
		IProject project = getProject();

		try
		{
			if (J2MENature.hasJ2MENature(project)) {
				ProgressMonitorDialog dialog = new ProgressMonitorDialog(getShell());
				dialog.setCancelable(false);
				dialog.setOpenOnRun(true);

				try {
					final IDevice device = deviceSelector.getSelectedDevice();
					final IMidletSuiteProject midletProject = getMidletSuiteProject();
					
					dialog.run(true, false, new IRunnableWithProgress() {
						public void run(IProgressMonitor monitor) 
							throws InvocationTargetException, InterruptedException 
						{
							try {
								midletProject.setDevice(device, monitor);
								midletProject.saveMetaData();
								midletProject.getProject().build(
									IncrementalProjectBuilder.FULL_BUILD, 
									monitor);
								
//								if (isPreprocessingEnabled(getProject())) {
//									refreshPreprocessedProjectContainer();
//								}
							} catch (CoreException e) {
								throw new InvocationTargetException(e);
							}
							
							try {
								final SymbolDefinitionSet[] setholder = new SymbolDefinitionSet[1];
								Display.getDefault().syncExec(new Runnable() {
									public void run() {
										setholder[0] = getSelectedDefinitionSet();
									}
								});
								
								midletProject.setEnabledSymbolDefinitionSet(setholder[0]);
							} catch (CoreException e) {
								throw new InvocationTargetException(e);
							} catch (PersistenceException e) {
								throw new InvocationTargetException(e);
							}
						}
					});
					
					succeeded = true;
					
				} catch (InvocationTargetException e) {
					EclipseMEUIErrors.displayError(	getShell(),
							"EclipseMEUiError.Exception",			//$NON-NLS-1$
							"EclipseMEUiError.SetPlatformFailed",	//$NON-NLS-1$
							e);
				} catch (InterruptedException e) {
					// Ignore this
				} finally {
					dialog.close();
				}
			}
		} 
		catch (CoreException e)
		{
			EclipseMEUIErrors.displayError(	getShell(),
					"EclipseMEUiError.Exception",			//$NON-NLS-1$
					"EclipseMEUiError.SetPlatformFailed",	//$NON-NLS-1$
					e);
		}
		
		return succeeded;
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent)
	{
		Control control = null;
		
		PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, "eclipseme.ui.help_J2MEProjectPropertiesPage");
		
		IProject project = getProject();
		
		if (isJ2MEProject(project)) {
			Composite composite = new Composite(parent, SWT.NONE);
			composite.setLayout(new GridLayout(1, true));
			
			// Create the device selector
			deviceSelector = new DeviceSelector();
			deviceSelector.createContents(composite, true);
			deviceSelector.setSelectionChangedListener(new ISelectionChangedListener() {
				public void selectionChanged(SelectionChangedEvent event) {
					// update container state
					if (getContainer() != null)
						getContainer().updateButtons();

					// update page state
					updateApplyButton();
				}
			});

			// Get the associated midlet suite project
			IMidletSuiteProject midletProject = getMidletSuiteProject();
			deviceSelector.setSelectedDevice(midletProject.getDevice());
			deviceSelector.setEnabled(!isReadOnly(project));

			addSymbolSelector(composite);
			
			control = composite;
			
		} else {
			Label lbl = new Label(parent, SWT.NONE);
			lbl.setText(EclipseMEUIStrings.getString("J2MEProjectPropertiesPage.NotMidletSuiteProject")); //$NON-NLS-1$
			control = lbl;
		}

		return control;
	}
	
	/**
	 * Add the symbol selector information if it is in use.
	 * 
	 * @param parent
	 */
	private void addSymbolSelector(Composite parent) {
		if (isPreprocessingEnabled(getProject())) {
			Composite composite = new Composite(parent, SWT.NONE);
			composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
			composite.setLayout(new GridLayout(2, false));
			
			new Label(composite, SWT.NONE).setText("Symbol Definitions:");
			
			symbolDefinitionSetViewer = new ComboViewer(composite, SWT.READ_ONLY);
			symbolDefinitionSetViewer.getCombo().setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
			symbolDefinitionSetViewer.setContentProvider(new SymbolDefinitionSetsContentProvider());
			symbolDefinitionSetViewer.setLabelProvider(new SymbolDefinitionSetLabelProvider());
			symbolDefinitionSetViewer.setInput(new Object());
			// symbolDefinitionSetViewer.getCombo().setEnabled(isReadOnly(getProject()));
			
			// Attempt to get the current setting and use it to set the
			// current selection
			try {
				SymbolDefinitionSet currentSet = getMidletSuiteProject().getEnabledSymbolDefinitionSet();
				if (currentSet != null) {
					IStructuredSelection selection = new StructuredSelection(currentSet);
					symbolDefinitionSetViewer.setSelection(selection, true);
				}
			} catch (CoreException e) {
				EclipseMECorePlugin.log(IStatus.WARNING, e);
			} catch (PersistenceException e) {
				EclipseMECorePlugin.log(IStatus.WARNING, e);
			}
		}
	}

	/**
	 * Get the midlet suite project for this project.
	 * 
	 * @return
	 */
	private IMidletSuiteProject getMidletSuiteProject() {
		IJavaProject javaProject = JavaCore.create(getProject());
		IMidletSuiteProject midletProject =
			MidletSuiteFactory.getMidletSuiteProject(javaProject);
		
		return midletProject;
	}

	/**
	 * Get the selected project or <code>null</code>
	 * if a project is not selected.
	 * 
	 * @return
	 */
	private IProject getProject() {
		IProject project = null;		
		IAdaptable adaptable = getElement();
		
		if (adaptable instanceof IProject) {
			project = (IProject) adaptable;
		} else if (adaptable instanceof IJavaProject) {
			project = ((IJavaProject) adaptable).getProject();
		}
		
		return project;
	}
	
	/**
	 * Return the selected symbol definition set.
	 * 
	 * @return
	 */
	private SymbolDefinitionSet getSelectedDefinitionSet() {
		SymbolDefinitionSet set = null;
		
		if (isPreprocessingEnabled(getProject())) {
			IStructuredSelection selection = (IStructuredSelection) symbolDefinitionSetViewer.getSelection();
			if (selection.size() > 0) {
				set = (SymbolDefinitionSet) selection.getFirstElement();
			}
		}
		
		return set;
	}
	
	/**
	 * Return a boolean indicating whether the selected
	 * element is a J2ME project.
	 * 
	 * @return
	 */
	private boolean isJ2MEProject(IProject project) {
		boolean j2meProject = false;

		if (project != null) {
			try {
				j2meProject = project.hasNature(IEclipseMECoreConstants.J2ME_NATURE_ID);
			} catch (CoreException e) {
			}
		}
		
		return j2meProject;
	}
	
	/**
	 * Return a boolean indicating whether this is a J2ME project with preprocessing
	 * enabled.
	 * 
	 * @param project
	 * @return
	 */
	private boolean isPreprocessingEnabled(IProject project) {
		boolean enabled = false;
		
		if (project != null) {
			try {
				enabled = 
					isJ2MEProject(project) &&
					project.hasNature(IEclipseMECoreConstants.J2ME_PREPROCESSING_NATURE_ID);
			} catch (CoreException e) {
				EclipseMECorePlugin.log(IStatus.WARNING, e);
			}
		}
		
		return enabled;
	}
	
	/**
	 * Return a boolean indicating whether the controls should be read only
	 * for the specified project.
	 * 
	 * @param project
	 * @return
	 */
	private boolean isReadOnly(IProject project) {
		boolean readOnly = false;

		try {
			readOnly = project.hasNature(IEclipseMECoreConstants.J2ME_PREPROCESSED_NATURE_ID);
		} catch (CoreException e) {
			EclipseMECorePlugin.log(IStatus.WARNING, e);
		}
		
		return readOnly; 
	}
}