<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="org.eclipse.mtj.ui">

<annotation>

      <appInfo>

         <meta.schema plugin="org.eclipse.mtj.ui" id="midletTemplateWizard" name="Midlet Template Wizard"/>

      </appInfo>

      <documentation>

         Provides an extension point for registering an Midlet Template Wizard. User can create a Midlet from a Midlet Template Wizard.

      </documentation>

   </annotation>

   <element name="extension">

      <complexType>

         <sequence minOccurs="1" maxOccurs="unbounded">

            <element ref="wizard" minOccurs="1" maxOccurs="unbounded"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

               </documentation>

               <appInfo>

                  <meta.attribute translatable="true"/>

               </appInfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="wizard">

      <complexType>

         <sequence>

            <element ref="description" minOccurs="0" maxOccurs="1"/>

         </sequence>

         <attribute name="id" type="string" use="required">

            <annotation>

               <documentation>

                  a unique name that will be used to identify this wizard.

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string" use="required">

            <annotation>

               <documentation>

                  a translatable name that will be used in UI representation

of this wizard.

               </documentation>

               <appInfo>

                  <meta.attribute translatable="true"/>

               </appInfo>

            </annotation>

         </attribute>

         <attribute name="class" type="string" use="required">

            <annotation>

               <documentation>

                  a fully qualified name of a class. The class must extends <samp>org.eclipse.mtj.ui.template.MidletTemplateWizard</samp>

               </documentation>

               <appInfo>

                  <meta.attribute kind="java" basedOn="org.eclipse.mtj.ui.template.MidletTemplateWizard:"/>

               </appInfo>

            </annotation>

         </attribute>

         <attribute name="icon" type="string">

            <annotation>

               <documentation>

                  a relative path of an icon that will be used to visually 

represent the wizard.

               </documentation>

               <appInfo>

                  <meta.attribute kind="resource"/>

               </appInfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="description" type="string">

      <annotation>

         <appInfo>

            <meta.element translatable="true"/>

         </appInfo>

         <documentation>

            Short description of this wizard.

         </documentation>

      </annotation>

   </element>

   <annotation>

      <appInfo>

         <meta.section type="since"/>

      </appInfo>

      <documentation>

         [Enter the first release in which this extension point appears.]

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="examples"/>

      </appInfo>

      <documentation>

         <extension

       point="org.eclipse.mtj.ui.midletTemplateWizard">

    <wizard

          class="org.eclipse.mtj.examples.midlettemplate.helloworld.HelloWorldMidletTemplateWizard"

          icon="icons/class_obj_green.gif"

          id="org.eclipse.mtj.ui.templateWizard.helloWorld"

          name="Hello World Midlet Template">

       <description>

          Hello world Midlet template. This template is just a example template which demonstrate how to create a Midlet template. You may create your own template by mimicing this example.

       </description>

    </wizard>

 </extension>

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="apiInfo"/>

      </appInfo>

      <documentation>

         The class attribute specified a class must extend <samp>org.eclipse.mtj.ui.template.MidletTemplateWizard</samp> class.

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="implementation"/>

      </appInfo>

      <documentation>

         [Enter information about supplied implementation of this extension point.]

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="copyright"/>

      </appInfo>

      <documentation>

         Copyright (c) 2008 Sybase Inc. and others.<br>

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 <a 

href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>

      </documentation>

   </annotation>

</schema>

   <extension-point id="midletTemplateWizard" name="Midlet Template Wizard" schema="schema/midletTemplateWizard.exsd"/>

      <wizard

            category="mtj.category"

            class="org.eclipse.mtj.ui.internal.wizards.template.NewMidletFromTemplateWizard"

            finalPerspective="org.eclipse.jdt.ui.JavaPerspective"

            icon="icons/newclass_wiz_green.gif"

            id="org.eclipse.mtj.ui.wizards.NewMidletFromTemplateWizard"

            name="%wizard.newTemplateMidlet.label">

         <description>

            %wizard.newTemplateMidlet.description

         </description>

      </wizard>

 org.eclipse.mtj.ui.template,

wizard.newTemplateMidlet.label=Java ME MIDlet from Template

wizard.newTemplateMidlet.description=Create a Java ME MIDlet from a Template

/*******************************************************************************

 * Copyright (c) 2008 Sybase Inc. 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:

 *     Feng Wang (Sybase) - initial implementation

 *******************************************************************************/

package org.eclipse.mtj.ui.template;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.mtj.ui.internal.template.TemplateMessages;

/**

 * You can subclass this class to create your own template class.

 * 

 * @author wangf

 * 

 */

public abstract class MidletTemplate {

	/**

	 * The name of the folder that contains Midlet template. We recommend you

	 * create a folder with this name under project root, and put your templates

	 * into it. For example, your template path may like this:

	 * /%PROJECT_ROOT%/templates/helloWorldTemplate/

	 */

	public static final String TEMPLATE_FOLDER = "templates";

	/**

	 * The name of the folder which located in the template folder. All your

	 * Java Source template should be put into this folder. The folder name MUST

	 * be "java". For example, your java source template folder may like this:

	 * /%PROJECT_ROOT%/templates/helloWorldTemplate/java/

	 */

	public static final String JAVA_FOLDER = "java";

	/**

	 * The name of the folder which located in the template folder. All your

	 * resource file should be put into this folder. The folder name MUST be

	 * "resource". For example, your resource file folder may like this:

	 * /%PROJECT_ROOT%/templates/helloWorldTemplate/resource/

	 */

	public static final String RESOURCE_FOLDER = "resource";

	/**

	 * Every java source template need a package declaration. The package

	 * declaration appear like this:

	 * <p>

	 * package $packageName$;

	 * </p>

	 * $packageName$ will be replaced with the real package name.

	 * 

	 */

	public static final String OPTION_PACKAGE = "packageName";

	/**

	 * The list store all template options.

	 */

	private List<TemplateOption> options;

	public MidletTemplate() {

		options = new ArrayList<TemplateOption>();

		// The default value of "packageName" option is

		// {@link TemplateMessages.Option_Package_defaultValue}.

		// You may change the value in the subclass is you don't like it.

		options.add(new StringOption(OPTION_PACKAGE,

				TemplateMessages.Option_Package_label,

				TemplateMessages.Option_Package_defaultValue));

	}

	/**

	 * Get the substitute string for template option. It's default behavior is

	 * to return TemplateOption.getValue().toString().

	 * 

	 * @param optionName

	 *            - the name of the template option.

	 * @return - the substitute string of the template option.

	 */

	public String getSubstituteStringFor(String optionName) {

		TemplateOption option = getOption(optionName);

		if (option != null) {

			return option.getValue().toString();

		} else {

			return "";

		}

	}

	/**

	 * Get a list contains all the options.

	 * 

	 * @return

	 */

	public List<TemplateOption> getOptions() {

		return options;

	}

	/**

	 * Get a option by it's name.

	 * 

	 * @param optionName

	 * @return

	 */

	public TemplateOption getOption(String optionName) {

		List<TemplateOption> options = getOptions();

		int i = options.indexOf(new StringOption(optionName, null, null));

		if (i >= 0) {

			TemplateOption option = options.get(i);

			return option;

		} else {

			return null;

		}

	}

	/**

	 * Add a template option.

	 * 

	 * @param option

	 */

	protected void addOption(TemplateOption option) {

		options.add(option);

	}

	/**

	 * Return the path string of the Midlet icon. This path will be added in to

	 * the JAD file. For example, if this method return a String

	 * "/icons/myIcon.gif", your Midlet declaration in the JAD may like this:

	 * <p>

	 * <code>MIDlet-1: MyTemplateMidlet,/icons/myIcon.gif,myj2meapp.helloworld.MyTemplateMidlet</code>

	 * </p>

	 * You may override this method to provide a icon for your template Midlet.

	 * 

	 * @return - a string stand for the path of the icon for the Midlet

	 */

	protected String getMidletIconPath() {

		return "";

	}

	/**

	 * Get the name of the Midlet template. This name will display as the title

	 * of the wizard page.

	 * 

	 * @return

	 */

	public abstract String getName();

}

/*******************************************************************************

 * Copyright (c) 2008 Sybase Inc. 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:

 *     Feng Wang (Sybase) - initial implementation

 *******************************************************************************/

package org.eclipse.mtj.ui.template;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.Reader;

import java.io.UnsupportedEncodingException;

import java.lang.reflect.InvocationTargetException;

import java.net.URL;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Map;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IWorkspaceRoot;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.FileLocator;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.SafeRunner;

import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.core.IJavaElement;

import org.eclipse.jdt.core.IJavaProject;

import org.eclipse.jdt.core.IPackageFragmentRoot;

import org.eclipse.jdt.core.IType;

import org.eclipse.jdt.core.JavaCore;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.jface.wizard.Wizard;

import org.eclipse.mtj.core.internal.MTJCorePlugin;

import org.eclipse.mtj.core.internal.utils.Utils;

import org.eclipse.mtj.core.model.jad.ApplicationDescriptor;

import org.eclipse.mtj.core.model.project.IMidletSuiteProject;

import org.eclipse.mtj.core.model.project.MidletSuiteFactory;

import org.eclipse.mtj.ui.internal.template.MidletTemplateWizardPage;

import org.eclipse.mtj.ui.internal.template.TemplateMessages;

import org.eclipse.mtj.ui.internal.utils.LogAndDisplaySafeRunnable;

import org.eclipse.mtj.ui.internal.wizards.template.TemplateWizardMessages;

/**

 * You should subclass this class to create your MidletTemplateWizard. You

 * should

 * <p>

 * 1. Provide a MidletTemplate by override {@link #createTemplate()} method

 * <p>

 * 2. Provide the URL of your template by override

 * {@link #getTemplateFolderURL()}

 * <p>

 * Typically you do not need add any more page to this wizard.

 * 

 * @author wangf

 * 

 */

public abstract class MidletTemplateWizard extends Wizard {

	private MidletTemplate template;

	private Pattern SUBSTITUTION_PATTERN = Pattern.compile("\\$.+?\\$");

	/**

	 * The Java source folder of your MTJ Midlet Suite project. You can choose

	 * it on the wizard page.

	 */

	private IPackageFragmentRoot javaRoot;

	/**

	 * The resource folder of your MTJ Midlet Suite project. You can choose it

	 * on the wizard page.

	 */

	private IPackageFragmentRoot resourceRoot;

	public MidletTemplateWizard() {

		this.template = createTemplate();

		setWindowTitle(TemplateMessages.MidletTemplateWizard_title);

		setNeedsProgressMonitor(true);

	}

	@Override

	public void addPages() {

		MidletTemplateWizardPage page = new MidletTemplateWizardPage(template);

		addPage(page);

	}

	@Override

	public boolean performFinish() {

		boolean completed = true;

		IRunnableWithProgress runable = getCreateMidletOperation();

		try {

			getContainer().run(false, true, runable);

		} catch (InvocationTargetException e) {

			MTJCorePlugin.log(IStatus.ERROR, e);

			completed = false;

		} catch (InterruptedException e) {

			MTJCorePlugin.log(IStatus.ERROR, e);

			completed = false;

		}

		return completed;

	}

	/**

	 * Set the Java source folder of your MTJ Midlet Suite project. User can

	 * choose the folder on the wizard page.

	 * 

	 * @param javaRoot

	 */

	public void setJavaRoot(IPackageFragmentRoot javaRoot) {

		this.javaRoot = javaRoot;

	}

	/**

	 * Set the resource folder of your MTJ Midlet Suite project. User can choose

	 * it on the wizard page.

	 * 

	 * @param resourceRoot

	 */

	public void setResourceRoot(IPackageFragmentRoot resourceRoot) {

		this.resourceRoot = resourceRoot;

	}

	/**

	 * Return a IRunnableWithProgress that will run in the

	 * {@link #performFinish()} method. This runnable create the Midlet from

	 * template.

	 * 

	 * @return

	 */

	private IRunnableWithProgress getCreateMidletOperation() {

		IRunnableWithProgress runnable = null;

		URL templateFolderURL = getTemplateFolderURL();

		try {

			templateFolderURL = FileLocator.resolve(templateFolderURL);

			templateFolderURL = FileLocator.toFileURL(templateFolderURL);

		} catch (IOException e) {

			return null;

		}

		if ("file".equals(templateFolderURL.getProtocol())) { //$NON-NLS-1$

			runnable = getDirCopyRunable(templateFolderURL);

		} else if ("jar".equals(templateFolderURL.getProtocol())) { //$NON-NLS-1$

			runnable = getZipCopyRunable(templateFolderURL);

		}

		return runnable;

	}

	/**

	 * Get a IRunnableWithProgress which perform the operation that copy

	 * templates from a jar file.

	 * 

	 * @param jarURL

	 *            - the URL of the Jar file which contains template.

	 * @return

	 */

	private IRunnableWithProgress getZipCopyRunable(URL jarURL) {

		final String file = jarURL.getFile();

		final int exclamation = file.indexOf('!');

		if (exclamation < 0) {

			return null;

		}

		IRunnableWithProgress runnable = new IRunnableWithProgress() {

			public void run(IProgressMonitor monitor)

					throws InvocationTargetException, InterruptedException {

				SafeRunner.run(new LogAndDisplaySafeRunnable(getShell(),

						TemplateWizardMessages.ErrorDialogTitle_duringCopy) {

					public void run() throws Exception {

						URL fileUrl = new URL(file.substring(0, exclamation));

						File pluginJar = new File(fileUrl.getFile());

						String templateDir = file.substring(exclamation + 1);

						IPath templatePath = new Path(templateDir);

						ZipFile zipFile = null;

						try {

							zipFile = new ZipFile(pluginJar);

							generateFilesFromZip(zipFile, templatePath);

						} finally {

							if (zipFile != null) {

								zipFile.close();

							}

						}

					}

				});

			}

		};

		return runnable;

	}

	/**

	 * Generate Midlet files including Java source code and resource files from

	 * jar file.

	 * 

	 * @param zipFile

	 * @param templatePath

	 * @throws CoreException

	 * @throws IOException

	 */

	private void generateFilesFromZip(ZipFile zipFile, IPath templatePath)

			throws IOException, CoreException {

		Map<IPath, ZipEntry>[] entryMaps = collectJavaAndResourceEntries(

				zipFile, templatePath);

		Map<IPath, ZipEntry> javaEntries = entryMaps[0];

		copyAndModifyJavaTemplateFromZip(zipFile, javaEntries);

		Map<IPath, ZipEntry> resourceEntries = entryMaps[1];

		copyResoueceFromZip(zipFile, resourceEntries);

	}

	/**

	 * Return a array contains 2 maps. The first map contains all the Java

	 * source file template ZIP entries. The second map contains all the

	 * resource file ZIP entries.

	 * 

	 * @param zipFile

	 * @param templatePath

	 * @return

	 */

	private Map<IPath, ZipEntry>[] collectJavaAndResourceEntries(

			ZipFile zipFile, IPath templatePath) {

		IPath javaPath = templatePath.append(MidletTemplate.JAVA_FOLDER);

		IPath resourcePath = templatePath

				.append(MidletTemplate.RESOURCE_FOLDER);

		Map<IPath, ZipEntry> javaEntries = new HashMap<IPath, ZipEntry>();

		Map<IPath, ZipEntry> resourceEntries = new HashMap<IPath, ZipEntry>();

		for (Enumeration<?> zipEntries = zipFile.entries(); zipEntries

				.hasMoreElements();) {

			ZipEntry zipEntry = (ZipEntry) zipEntries.nextElement();

			IPath entryPath = new Path(zipEntry.getName());

			if (javaPath.isPrefixOf(entryPath) && !zipEntry.isDirectory()) {

				IPath key = entryPath.removeFirstSegments(javaPath

						.segmentCount());

				javaEntries.put(key, zipEntry);

			} else if (resourcePath.isPrefixOf(entryPath)

					&& !zipEntry.isDirectory()) {

				IPath key = entryPath.removeFirstSegments(resourcePath

						.segmentCount());

				resourceEntries.put(key, zipEntry);

			}

		}

		@SuppressWarnings("unchecked")

		// Do NOT change the sequence of the 2 element

		Map<IPath, ZipEntry>[] entryMaps = new Map[] { javaEntries,

				resourceEntries };

		return entryMaps;

	}

	/**

	 * Get a IRunnableWithProgress which perform the operation that copy

	 * templates from a folder.

	 * 

	 * @param templateFolderURL

	 *            - The URL of the folder which contains template.

	 * @return

	 */

	private IRunnableWithProgress getDirCopyRunable(URL templateFolderURL) {

		File templateDirectory = new File(templateFolderURL.getFile());

		if (!templateDirectory.exists())

			return null;

		final File javaTemplateDir = new File(templateDirectory,

				MidletTemplate.JAVA_FOLDER);

		final File resourceFileDir = new File(templateDirectory,

				MidletTemplate.RESOURCE_FOLDER);

		IRunnableWithProgress runnable = new IRunnableWithProgress() {

			public void run(final IProgressMonitor monitor)

					throws InvocationTargetException, InterruptedException {

				SafeRunner.run(new LogAndDisplaySafeRunnable(getShell(),

						TemplateWizardMessages.ErrorDialogTitle_duringCopy) {

					public void run() throws Exception {

						// Do copy

						copyAndModifyJavaTemplateFromDir(javaTemplateDir,

								getMidletProjectPackageFolder(), monitor);

						copyResourceFromDir(resourceFileDir, monitor);

						// refresh

						javaRoot.getResource().refreshLocal(

								IResource.DEPTH_INFINITE, monitor);

						resourceRoot.getResource().refreshLocal(

								IResource.DEPTH_INFINITE, monitor);

					}

				});

			}

		};

		return runnable;

	}

	/**

	 * Copy & substitute template string of all Java template ZIP entries from

	 * jar file. And then add Midlet declaration into JAD.

	 * 

	 * @param zipFile

	 *            - Jar file contains templates.

	 * @param javaEntries

	 *            - a map contains all the Java template ZIP entries.

	 * @throws UnsupportedEncodingException

	 * @throws IOException

	 * @throws FileNotFoundException

	 * @throws CoreException

	 */

	private void copyAndModifyJavaTemplateFromZip(ZipFile zipFile,

			Map<IPath, ZipEntry> javaEntries)

			throws UnsupportedEncodingException, IOException,

			FileNotFoundException, CoreException {

		for (IPath key : javaEntries.keySet()) {

			// Get StringBuffer before template substituting

			StringBuffer sb = getSbBeforeSubstituteTemplates(zipFile

					.getInputStream(javaEntries.get(key)));

			// Get StringBuffer before template substituting

			sb = getSbAfterSubstituteTemplates(sb);

			// Get the absolute path of the destination file.

			IPath destFilePath = getMidletProjectPackagePath().append(key);

			String destFileName = substituteJavaTemplateFileName(destFilePath

					.lastSegment());

			destFilePath = destFilePath.removeLastSegments(1).append(

					destFileName);

			// Do file writing

			writeFile(new File(destFilePath.toOSString()), sb);

			// Must refresh local before add Midlet declaration to JAD

			javaRoot.getResource().refreshLocal(IResource.DEPTH_INFINITE, null);

			// Add Midlet declaration to JAD

			addMidletToJAD(destFilePath.toFile(), null);

		}

	}

	/**

	 * Copy & substitute template string of all Java template files from a

	 * directory contains templates. And then add Midlet declaration into JAD.

	 * 

	 * @param source

	 * @param destination

	 * @param monitor

	 * @throws IOException

	 * @throws CoreException

	 */

	private void copyAndModifyJavaTemplateFromDir(File source,

			File destination, IProgressMonitor monitor) throws IOException,

			CoreException {

		if (source.exists() && source.isDirectory()) {

			destination.mkdirs();

			File[] sources = source.listFiles();

			for (int i = 0; i < sources.length; i++) {

				File currentSrc = sources[i];

				String currentDestName = substituteJavaTemplateFileName(currentSrc

						.getName());

				File currentDest = new File(destination, currentDestName);

				if (currentSrc.isDirectory()) {

					copyAndModifyJavaTemplateFromDir(currentSrc, currentDest,

							monitor);

				} else {

					StringBuffer sb = getSbBeforeSubstituteTemplates(new FileInputStream(

							currentSrc));

					sb = getSbAfterSubstituteTemplates(sb);

					writeFile(currentDest, sb);

					// Must refresh local before add Midlet declaration to JAD

					javaRoot.getResource().refreshLocal(

							IResource.DEPTH_INFINITE, monitor);

					// Add Midlet declaration to JAD

					addMidletToJAD(currentDest, monitor);

				}

			}

		}

	}

	/**

	 * Copy all of the resource files from Jar file to MTJ Midlet suite project

	 * resource folder.

	 * 

	 * @param zipFile

	 *            - the Jar file contains templates

	 * @param resourceEntries

	 *            - a map contains all the resource ZIP entries.

	 * @throws IOException

	 * @throws CoreException

	 */

	private void copyResoueceFromZip(ZipFile zipFile,

			Map<IPath, ZipEntry> resourceEntries) throws IOException,

			CoreException {

		for (IPath key : resourceEntries.keySet()) {

			InputStream in = zipFile.getInputStream(resourceEntries.get(key));

			IPath destFilePath = getMidletProjectResourcePath().append(key);

			writeFile(destFilePath, in);

			resourceRoot.getResource().refreshLocal(IResource.DEPTH_INFINITE,

					null);

		}

	}

	/**

	 * Copy all of the resource files from template resource directory to MTJ

	 * Midlet suite project resource folder.

	 * 

	 * @param resourceDir

	 *            - Directory contains template resource files.

	 * @param monitor

	 * @throws IOException

	 */

	private void copyResourceFromDir(File resourceDir, IProgressMonitor monitor)

			throws IOException {

		Utils.copyDirectory(resourceDir, getMidletProjectResourceDir(), null);

	}

	/**

	 * Get the Java package folder of the MTJ Midlet Suite Project.

	 * 

	 * @return

	 */

	private File getMidletProjectPackageFolder() {

		IPath packagePath = getMidletProjectPackagePath();

		File packageDir = packagePath.toFile();

		return packageDir;

	}

	/**

	 * Get the Java package path of the MTJ Midlet Suite Project.

	 * 

	 * @return

	 */

	private IPath getMidletProjectPackagePath() {

		IPath srcPath = getMidletProjectSrcPath();

		String packageName = template

				.getSubstituteStringFor(MidletTemplate.OPTION_PACKAGE);

		IPath packagePath = srcPath.append(packageName.replace(".", "/"));//$NON-NLS-1$

		return packagePath;

	}

	/**

	 * Get the path of the MTJ Midlet Suite project Source folder.

	 * 

	 * @return

	 */

	private IPath getMidletProjectSrcPath() {

		IPath srcPath = null;

		srcPath = javaRoot.getResource().getLocation();

		return srcPath;

	}

	/**

	 * Get the MTJ Midlet Suite project resource folder.

	 * 

	 * @return

	 */

	private File getMidletProjectResourceDir() {

		IPath resourcePath = getMidletProjectResourcePath();

		return resourcePath.toFile();

	}

	/**

	 * Get the MTJ Midlet Suite project resource path.

	 * 

	 * @return

	 */

	private IPath getMidletProjectResourcePath() {

		IPath resourcePath = resourceRoot.getResource().getLocation();

		return resourcePath;

	}

	/**

	 * Write a StringBuffer to a file.

	 * 

	 * @param destFile

	 *            - the destination file.

	 * @param sb

	 *            - the StringBuffer to be written to the destination file.

	 * @throws FileNotFoundException

	 * @throws UnsupportedEncodingException

	 * @throws IOException

	 */

	private void writeFile(File destFile, StringBuffer sb)

			throws FileNotFoundException, UnsupportedEncodingException,

			IOException {

		// Make necessary Dirs

		IPath path = new Path(destFile.getPath());

		path.removeLastSegments(1).toFile().mkdirs();

		// Do write

		FileOutputStream fos = new FileOutputStream(destFile);

		OutputStreamWriter writer = new OutputStreamWriter(fos, "UTF-8");

		writer.write(sb.toString());

		writer.close();

	}

	/**

	 * Write the content from a InputStream to a file.

	 * 

	 * @param destPath

	 *            - the path of the destination file.

	 * @param in

	 *            - the ImputSteam whose content will be written to the

	 *            destination file.

	 * @throws IOException

	 */

	private void writeFile(IPath destPath, InputStream in) throws IOException {

		// Make necessary Dirs

		destPath.removeLastSegments(1).toFile().mkdirs();

		// Do write

		FileOutputStream out = new FileOutputStream(destPath.toFile());

		Utils.copyInputToOutput(in, out);

	}

	/**

	 * Add the created Midlet declaration to JAD file.

	 * 

	 * @param javaSourceFile

	 *            - the Java source file just generated from a template.

	 * @param monitor

	 * @throws IOException

	 * @throws CoreException

	 */

	private void addMidletToJAD(File javaSourceFile, IProgressMonitor monitor)

			throws IOException, CoreException {

		// create ICompilationUnit from File

		String path = javaSourceFile.getAbsolutePath();

		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();

		IFile javaSrcFile = root.getFileForLocation(new Path(path));

		ICompilationUnit cu = (ICompilationUnit) JavaCore.create(javaSrcFile);

		if (cu == null) {

			return;

		}

		// find Midlets and add them to JAD

		IType[] types = cu.getAllTypes();

		for (IType type : types) {

			if (Utils.isMidlet(type, monitor)) {

				writeMidletDeclarationToJAD(type, monitor);

			}

		}

	}

	/**

	 * Add Midlet declaration to JAD file.

	 * 

	 * @param midlet

	 * @param monitor

	 * 

	 * @throws IOException

	 * @throws CoreException

	 */

	private void writeMidletDeclarationToJAD(IType midlet,

			IProgressMonitor monitor) throws IOException, CoreException {

		// Pull out the midlet suite that the type was created in

		IJavaProject javaProject = (IJavaProject) midlet

				.getAncestor(IJavaElement.JAVA_PROJECT);

		IMidletSuiteProject midletSuite = MidletSuiteFactory

				.getMidletSuiteProject(javaProject);

		ApplicationDescriptor desc = midletSuite.getApplicationDescriptor();

		if (desc != null) {

			ApplicationDescriptor.MidletDefinition def = new ApplicationDescriptor.MidletDefinition(

					desc.getMidletCount() + 1, midlet.getElementName(),

					template.getMidletIconPath(), midlet

							.getFullyQualifiedName());

			desc.addMidletDefinition(def);

			desc.store();

			IFile jadFile = midletSuite.getApplicationDescriptorFile();

			jadFile.refreshLocal(IResource.DEPTH_ONE, monitor);

		}

	}

	/**

	 * The Java template file name may need to be substituted.

	 * 

	 * @param fileName

	 * @return

	 */

	private String substituteJavaTemplateFileName(String fileName) {

		StringBuffer sb = getSbAfterSubstituteTemplates(new StringBuffer(

				fileName));

		return sb.toString();

	}

	/**

	 * Substitute all the template options. Before substituting, A StringBuffer

	 * may appear as "abc-$toBeSubstituted$-xyz"; after substituting, the

	 * StringBuffer will be like this: "abc-substituted-xyz".

	 * <p>

	 * "$toBeSubstituted$" is the template option, "substituted" is the value of

	 * the template option.

	 * 

	 * @param sb

	 * @return

	 */

	private StringBuffer getSbAfterSubstituteTemplates(StringBuffer sb) {

		// Replace template values

		int offset = 0;

		Matcher matcher = SUBSTITUTION_PATTERN.matcher(sb);

		while (matcher.find(offset)) {

			// The matched string may like this: $toBeSubstituted$

			String referencedValue = matcher.group();

			// The name of the template option may like this: toBeSubstituted

			String optionName = referencedValue.substring(1, referencedValue

					.length() - 1);

			// The string used to substitute the template option string.

			String resolvedValue = template.getSubstituteStringFor(optionName);

			// do substitute

			sb.replace(matcher.start(), matcher.end(), resolvedValue);

			// Figure out the new offset, based on the replaced

			// string length

			offset = matcher.start() + resolvedValue.length();

		}

		return sb;

	}

	/**

	 * Get a StringBuffer from a InputStream.

	 * 

	 * @param is

	 * @return

	 * @throws UnsupportedEncodingException

	 * @throws IOException

	 */

	private StringBuffer getSbBeforeSubstituteTemplates(InputStream is)

			throws UnsupportedEncodingException, IOException {

		// Read in the template

		int charsRead;

		char[] buffer = new char[1024];

		Reader reader = new InputStreamReader(is, "UTF-8");//$NON-NLS-N$

		StringBuffer sb = new StringBuffer();

		while ((charsRead = reader.read(buffer)) != -1) {

			sb.append(buffer, 0, charsRead);

		}

		is.close();

		return sb;

	}

	/**

	 * Get the URL of the template folder. You should implement this method in

	 * your subclass. Typically, your method may appear like this:

	 * <p>

	 * <code>@Override</code>

	 * <p>

	 * <code>protected URL getTemplateFolderURL() {</code>

	 * <p>

	 * <code>   URL templateFolderURL = getClass().getResource(</code>

	 * <p>

	 * <code>		"/" + MidletTemplate.TEMPLATE_FOLDER + "/helloWorld");</code>

	 * <p>

	 * <code>return templateFolderURL;</code>

	 * <p>

	 * <code><p>}</code>

	 * <p>

	 * 

	 * @return - the URL of the folder contains your template.

	 */

	protected abstract URL getTemplateFolderURL();

	/**

	 * Create and return a subclass of {@link MidletTemplate}. The subclass will

	 * be used to substitute template strings in your template.

	 * 

	 * @return - a MidletTemplate

	 */

	protected abstract MidletTemplate createTemplate();

}

/*******************************************************************************

 * Copyright (c) 2008 Sybase Inc. 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:

 *     Feng Wang (Sybase) - initial implementation

 *******************************************************************************/

package org.eclipse.mtj.ui.template;

import org.eclipse.mtj.ui.internal.template.MidletTemplateWizardPage;

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.widgets.Composite;

import org.eclipse.swt.widgets.Text;

/**

 * This class is used to provide a template option that contains a string value.

 * When you add a StringOption to your {@link MidletTemplate}, the

 * {@link MidletTemplateWizardPage} will appear contains one more string field

 * that allow the user to change the default value of this StringOption.

 * 

 * @author wangf

 * 

 */

public class StringOption extends TemplateOption {

	/**

	 * @see TemplateOption#TemplateOption(String, String, Object)

	 * @param name

	 * @param label

	 * @param defaultValue

	 */

	public StringOption(String name, String label, String defaultValue) {

		super(name, label, defaultValue);

	}

	/**

	 * Create a single line Text control with a label. The control will display

	 * on the {@link MidletTemplateWizardPage}. User can change the default

	 * option value by set the text of Text control.

	 */

	@Override

	public void createControl(Composite container, int span) {

		// Create the label of the Text.

		createLabel(container);

		// Create the text.

		final Text text = new Text(container, SWT.SINGLE | SWT.BORDER);

		if (getValue() != null) {

			text.setText(getValue().toString());

		}

		GridData gd = new GridData(GridData.FILL_HORIZONTAL);

		gd.horizontalSpan = span - 1;

		text.setLayoutData(gd);

		text.addModifyListener(new ModifyListener() {

			public void modifyText(ModifyEvent e) {

				StringOption.this.setValue(text.getText());

			}

		});

	}

}

/*******************************************************************************

 * Copyright (c) 2008 Sybase Inc. 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:

 *     Feng Wang (Sybase) - initial implementation

 *******************************************************************************/

package org.eclipse.mtj.ui.template;

import org.eclipse.mtj.ui.internal.template.MidletTemplateWizardPage;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Label;

/**

 * This class is a base class of template options.

 * 

 * @author wangf

 * 

 */

public abstract class TemplateOption {

	private String name;

	private String label;

	private Object value;

	/**

	 * The constructor.

	 * 

	 * @param name

	 *            - the name of the template option. For example, you create a

	 *            TemplateOption for a template key string $toBeSubstituted$,

	 *            the name of this TemplateOption must be "toBeSubstituted"

	 * @param label

	 *            - the label of the template option. It will appear as a label

	 *            on the UI {@link MidletTemplateWizardPage}.

	 * @param value

	 *            - the default value of the TemplateOption. By default(if you

	 *            don't override

	 *            {@link MidletTemplate#getSubstituteStringFor(String optionName)}

	 *            method), value.toString() will be used as the substitute

	 *            string of this TemplateOption.

	 */

	public TemplateOption(String name, String label, Object value) {

		this.name = name;

		this.label = label;

		this.value = value;

	}

	/**

	 * create a label and set the text to the "label" field variable of this

	 * class.

	 * 

	 * @param parent

	 * @return

	 */

	protected Label createLabel(Composite parent) {

		Label label = new Label(parent, SWT.NULL);

		label.setText(getLabel());

		return label;

	}

	/**

	 * Create a control for this template option which will be displayed on

	 * {@link MidletTemplateWizardPage}

	 * 

	 * @param container

	 * @param span

	 */

	public abstract void createControl(Composite container, int span);

	@Override

	public int hashCode() {

		final int prime = 31;

		int result = 1;

		result = prime * result + ((name == null) ? 0 : name.hashCode());

		return result;

	}

	/**

	 * If the name of two objects equal with each other, we assume the objects

	 * equal with each other. Do NOT change the equals behavior in the subclass.

	 */

	@Override

	public boolean equals(Object obj) {

		if (this == obj)

			return true;

		if (obj == null)

			return false;

		if (getClass() != obj.getClass())

			return false;

		TemplateOption other = (TemplateOption) obj;

		if (name == null) {

			if (other.name != null)

				return false;

		} else if (!name.equals(other.name))

			return false;

		return true;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getLabel() {

		return label;

	}

	public void setLabel(String label) {

		this.label = label;

	}

	public Object getValue() {

		return value;

	}

	public void setValue(Object value) {

		this.value = value;

	}

}

import org.eclipse.mtj.ui.internal.wizards.StatusUtil;

/*******************************************************************************

 * Copyright (c) 2000, 2007 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

 *******************************************************************************/

/*******************************************************************************

 * Copyright (c) 2008 Sybase Inc. 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:

 *     Feng Wang (Sybase) - Copy from 

 *     		org.eclipse.jdt.internal.ui.dialogs.StatusUtil and modified.

 *******************************************************************************/

package org.eclipse.mtj.ui.internal.wizards;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.dialogs.DialogPage;

import org.eclipse.jface.dialogs.IMessageProvider;

import org.eclipse.mtj.ui.IMTJUIConstants;

/**

 * A utility class to work with IStatus.

 */

public class StatusUtil {

	/**

	 * This method must not be called outside MTJ.

	 * 

	 * Utility method for creating status.

	 * 

	 * @param severity

	 * @param message

	 * @param exception

	 * @return {@link IStatus}

	 */

	public static IStatus newStatus(int severity, String message,

			Throwable exception) {

		String statusMessage = message;

		if (message == null || message.trim().length() == 0) {

			if (exception == null) {

				throw new IllegalArgumentException();

			} else if (exception.getMessage() == null) {

				statusMessage = exception.toString();

			} else {

				statusMessage = exception.getMessage();

			}

		}

		return new Status(severity, IMTJUIConstants.PLUGIN_ID, severity,

				statusMessage, exception);

	}

	/**

	 * This method must not be called outside MTJ.

	 * 

	 * Utility method for creating status.

	 * 

	 * @param severity

	 * @param message

	 * @return {@link IStatus}

	 */

	public static IStatus newStatus(int severity, String message) {

		return new Status(severity, IMTJUIConstants.PLUGIN_ID, message);

	}

	/**

	 * Compares two instances of <code>IStatus</code>. The more severe is

	 * returned: An error is more severe than a warning, and a warning is more

	 * severe than OK. If the two status have the same severity, the second is

	 * returned.

	 * 

	 * @param s1

	 *            first status

	 * @param s2

	 *            second status

	 * @return the more severe status

	 */

	public static IStatus getMoreSevere(IStatus s1, IStatus s2) {

		if (s1.getSeverity() > s2.getSeverity()) {

			return s1;

		} else {

			return s2;

		}

	}

	/**

	 * Finds the most severe status from a array of status. An error is more

	 * severe than a warning, and a warning is more severe than OK.

	 * 

	 * @param statuses

	 *            an array of status

	 * @return the most severe status

	 */

	public static IStatus getMostSevere(IStatus[] statuses) {

		IStatus max = null;

		for (int i = 0; i < statuses.length; i++) {

			IStatus curr = statuses[i];

			if (curr.matches(IStatus.ERROR)) {

				return curr;

			}

			if (max == null || curr.getSeverity() > max.getSeverity()) {

				max = curr;

			}

		}

		return max;

	}

	/**

	 * Decide if all the status are acceptable. If one of the status's severity

	 * is greater than IStatus.WARNING, it will return false.

	 * 

	 * @param statuses

	 *            - A array of status to be decided if all of them are

	 *            acceptable.

	 * @return - If all the statuses are acceptable.

	 */

	public static boolean allAreAcceptable(IStatus[] statuses) {

		IStatus mostSevere = getMostSevere(statuses);

		if (mostSevere.getSeverity() <= IStatus.WARNING) {

			return true;

		} else {

			return false;

		}

	}

	/**

	 * Applies the status to the status line of a dialog page.

	 * 

	 * @param page

	 *            the dialog page

	 * @param status

	 *            the status to apply

	 */

	public static void applyToStatusLine(DialogPage page, IStatus status) {

		String message = status.getMessage();

		if (message != null && message.length() == 0) {

			message = null;

		}

		switch (status.getSeverity()) {

		case IStatus.OK:

			page.setMessage(message, IMessageProvider.NONE);

			page.setErrorMessage(null);

			break;

		case IStatus.WARNING:

			page.setMessage(message, IMessageProvider.WARNING);

			page.setErrorMessage(null);

			break;

		case IStatus.INFO:

			page.setMessage(message, IMessageProvider.INFORMATION);

			page.setErrorMessage(null);

			break;

		default:

			page.setMessage(null);

			page.setErrorMessage(message);

			break;

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2008 Sybase Inc. 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:

 *     Feng Wang (Sybase) - initial implementation

 *******************************************************************************/

package org.eclipse.mtj.ui.internal.wizards.template;

import java.util.List;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Path;

import org.eclipse.jdt.core.IJavaElement;

import org.eclipse.jdt.core.IJavaModel;

import org.eclipse.jdt.core.IJavaProject;

import org.eclipse.jdt.core.IPackageFragmentRoot;

import org.eclipse.jdt.core.JavaCore;

import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.ui.JavaElementComparator;

import org.eclipse.jdt.ui.JavaElementLabelProvider;

import org.eclipse.jdt.ui.StandardJavaElementContentProvider;

import org.eclipse.jface.dialogs.Dialog;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.jface.viewers.ILabelProvider;

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.TableViewer;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerFilter;

import org.eclipse.jface.window.Window;

import org.eclipse.jface.wizard.IWizardNode;

import org.eclipse.jface.wizard.Wizard;

import org.eclipse.jface.wizard.WizardSelectionPage;

import org.eclipse.mtj.core.IMTJCoreConstants;

import org.eclipse.mtj.core.internal.MTJCorePlugin;

import org.eclipse.mtj.ui.internal.template.TemplateWizardProxy;

import org.eclipse.mtj.ui.internal.template.TemplateWizardRegistry;

import org.eclipse.mtj.ui.internal.template.WizardNode;

import org.eclipse.mtj.ui.internal.wizards.StatusUtil;

import org.eclipse.mtj.ui.template.MidletTemplateWizard;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.SashForm;

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.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.Label;

import org.eclipse.swt.widgets.Text;

import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;

/**

 * We use this wizard page for the user to select a Midlet template

 * 

 * @author wangf

 * 

 */

public class MidletTemplatesSelectionPage extends WizardSelectionPage implements

		ISelectionChangedListener {

	private TableViewer templateSelectionViewer;

	private Text description;

	/**

	 * The Java source folder of the MTJ Midlet Suite project.

	 */

	private IPackageFragmentRoot currentJavaRoot;

	/**

	 * The resource folder of the MTJ Midlet Suite project.

	 */

	private IPackageFragmentRoot currentResourceRoot;

	private Text javaSourceFolderText;

	private Text resourceFolderText;

	private IStatus javaSourceFolderStatus = getErrorStatus("");

	private IStatus resourceFolderStatus = getErrorStatus("");

	public MidletTemplatesSelectionPage(String pageName) {

		super(pageName);

		setTitle(TemplateWizardMessages.WizardTemplateSelectionPage_title);

		setDescription(TemplateWizardMessages.WizardTemplateSelectionPage_desc);

	}

	// ----------------------- begin initialize---------------------------

	/**

	 * Initialize Java Source Folder and Resource Folder. Since we have no way

	 * to know which source folder is Java Source Folder and which source folder

	 * is Resource Folder, we just take the first source folder as Java Source

	 * folder and take the second folder as the Resource Folder. If there is

	 * only one source folder of the MTJ Midlet Suite project, we set Java

	 * Source Folder and Resource Folder the same one.

	 */

	private void initSourceFolders() {

		IJavaElement initialJavaElement = getInitialJavaElement();

		if (initialJavaElement == null) {

			return;

		}

		try {

			IJavaProject jproject = initialJavaElement.getJavaProject();

			if (jproject != null) {

				if (jproject.exists()) {

					IPackageFragmentRoot[] sourceRoots = new IPackageFragmentRoot[2];

					int sourceRootsAmount = 0;

					IPackageFragmentRoot[] roots = jproject

							.getPackageFragmentRoots();

					// Try to get two source folders

					for (int i = 0; i < roots.length; i++) {

						if (roots[i].getKind() == IPackageFragmentRoot.K_SOURCE) {

							sourceRoots[sourceRootsAmount] = roots[i];

							sourceRootsAmount++;

							if (sourceRootsAmount == 2) {

								break;

							}

						}

					}

					// Initialize Java Source Folder and Resource Folder

					if (sourceRootsAmount == 2) {

						// two source folders

						currentJavaRoot = sourceRoots[0];

						currentResourceRoot = sourceRoots[1];

					} else if (sourceRootsAmount == 1) {

						// one source folder

						currentJavaRoot = sourceRoots[0];

						currentResourceRoot = sourceRoots[0];

					} else if (sourceRootsAmount == 0) {

						// project root as source folder

						sourceRoots[0] = jproject

								.getPackageFragmentRoot(jproject.getResource());

						currentJavaRoot = sourceRoots[0];

						currentResourceRoot = sourceRoots[0];

					}

				}

			}

		} catch (JavaModelException e) {

			MTJCorePlugin.log(IStatus.ERROR, e);

		}

		// initialize the UI

		javaSourceFolderText.setText(getSourceFolderName(currentJavaRoot));

		resourceFolderText.setText(getSourceFolderName(currentResourceRoot));

	}

	/**

	 * Get the initial Java Element. It is the Java element that user selected

	 * from the Package Explorer or Navigator.

	 * 

	 * @return

	 */

	private IJavaElement getInitialJavaElement() {

		IJavaElement javaElement = null;

		NewMidletFromTemplateWizard wizard = (NewMidletFromTemplateWizard) MidletTemplatesSelectionPage.this

				.getWizard();

		javaElement = getJavaElementFromSelection(wizard.getSelection());

		return javaElement;

	}

	/**

	 * Get Java element from selection.

	 * 

	 * @param selection

	 * @return

	 */

	protected IJavaElement getJavaElementFromSelection(

			IStructuredSelection selection) {

		IJavaElement jelem = null;

		if (selection != null && !selection.isEmpty()) {

			Object selectedElement = selection.getFirstElement();

			if (selectedElement instanceof IAdaptable) {

				IAdaptable adaptable = (IAdaptable) selectedElement;

				jelem = (IJavaElement) adaptable.getAdapter(IJavaElement.class);

				if (jelem == null) {

					IResource resource = (IResource) adaptable

							.getAdapter(IResource.class);

					if (resource != null

							&& resource.getType() != IResource.ROOT) {

						while (jelem == null

								&& resource.getType() != IResource.PROJECT) {

							resource = resource.getParent();

							jelem = (IJavaElement) resource

									.getAdapter(IJavaElement.class);

						}

						if (jelem == null) {

							jelem = JavaCore.create(resource); // java project

						}

					}

				}

			}

		}

		return jelem;

	}

	/**

	 * Get the name of source folder.

	 * 

	 * @param root -

	 *            Java source folder or resource folder of MTJ Midlet Suite

	 *            project.

	 * @return