import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IWorkspace;

import org.eclipse.core.resources.IWorkspaceRoot;

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

import org.eclipse.core.runtime.Status;

import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.core.IJavaProject;

import org.eclipse.jdt.core.IPackageFragment;

import org.eclipse.jdt.core.IPackageFragmentRoot;

import org.eclipse.jdt.core.JavaCore;

/**

 * Version 1

 * Java Class constructor that codes everything up from scratch.

 */

	private String className = "MyClass";

	private String packageName = IPackageFragment.DEFAULT_PACKAGE_NAME;

	private String projectName = "My Project";

	/**

	 * Specifies whether this class should be created in the (default package) 

	 * i.e at the root level of the project? 

	 * 

	 * When beginner programmers start out, all of their classes will be created 

	 * at the root level of the project. When they move on to being intermediate 

	 * programmers, they will be able to specify the package the class should

	 * be created in.

	 */

	private Boolean shouldUseDefaultPackage = true;

	/**

	 * Specifies whether to create a new default project if the workspace is

	 * empty. Otherwise we will prompt for project creation.

	 */

	private Boolean shouldCreateProjectIfNecessary = true;

	public void setProjectName(String projectName) {

		this.projectName = projectName.trim();

	}

	public void setPackageName(String packageName) {

		this.packageName = packageName.trim();

	}

	public void setClassName(String className) {

		this.className = className.trim();

	}

	public void setUseDefaultPackage(Boolean shouldUseDefaultPackage) {

		this.shouldUseDefaultPackage = shouldUseDefaultPackage;

	}

	public void setCreateProjectIfNecessary(Boolean shouldCreateProjectIfNecessary) {

		this.shouldCreateProjectIfNecessary = shouldCreateProjectIfNecessary;

	}

	/**

	 * This method returns the status of the receiver in the form of

	 * an {@link IStatus} instance. The answer will reflect any

	 * potential error state in the receiver, or {@link Status#OK_STATUS}

	 * if there is no error.

	 * 

	 * @return Instance of {@link IStatus}

	 */

	public IStatus getStatus() {

		IStatus status = getWorkspace().validateName(className, IResource.FILE);

		if (!status.isOK()) return status;

		IProject project= getWorkspaceRoot().getProject(projectName);

		if (!shouldCreateProjectIfNecessary && !project.exists()) {

			return new Status(IStatus.ERROR, Activator.PLUGIN_ID, 

					"There is no project by the name " + projectName + 

					" to create a new class in.");

		}

		// TODO Add package checking.

		// TODO This should be made more robust so that class names in different locations are allowed.

		// Check that a class of this name doesn't already exist.

		// TODO Check whether it should be "classname.java" or just "classname"

		IFile file = project.getFile(className);

		if (file.exists()){

			return new Status(IStatus.ERROR, Activator.PLUGIN_ID,

					"A class with this name already exists.");

		}

		return Status.OK_STATUS;

	}

	/**

	 * @param monitor

	 * @return The newly created class or null if there were problems creating

	 * 		   the class.

	 * @throws CoreException

	 */

	public ICompilationUnit construct(IProgressMonitor monitor) throws CoreException {

		if (!getStatus().isOK()) return null;

		ICompilationUnit javaClass = null;

		IJavaProject javaProject = getJavaProject(monitor);

		// TODO create package if necessary, probably need to use getPackage(path)

		// TODO if we leave this search in, refactor to a private helper method

		IPackageFragment javaPackage = null;

		IPackageFragment[] packages = javaProject.getPackageFragments();

//		javaProject.getPackageFragmentRoot(resource);

		// Look for the package the new class file will be created within.

		for (IPackageFragment mypackage : packages) {

			// Package fragments include all packages in the classpath

			// We will only look at the package from the source folder

			// K_BINARY would include also included JARS, e.g. rt.jar

			if (mypackage.getKind() == IPackageFragmentRoot.K_SOURCE &&

					mypackage.getElementName() == packageName) {

				javaPackage = mypackage;

				System.out.println("Package: '" + mypackage.getElementName() + "'");

				break;

			}

		}

		String javaClassFilename = className + ".java";

		// TODO fix this when we get a package automatically created so we know we have a package handle

		if (!(javaPackage == null)){

			// TODO make sure this class doesn't already exist? Or do we just deal with the exception thrown by createCompilationUnit if force parameter is false

			javaClass = javaPackage.createCompilationUnit(

					javaClassFilename, 

					"public class " + className + " { }", 

					true, 

					monitor);

		}

		return javaClass;

	}

	private IJavaProject getJavaProject(IProgressMonitor monitor)

			throws CoreException {

		// TODO Do we need to figure out how to get the project that the user right clicked on if the action is coming from the package explorer?

		IProject project = getWorkspaceRoot().getProject(projectName);

		IJavaProject javaProject;

		if (!project.exists()){

			// Create a new project if there is no project by the given name

			if (shouldCreateProjectIfNecessary){

				NewJavaProjectConstructor constructor = new NewJavaProjectConstructor();

				constructor.setProjectName(projectName);

				javaProject = constructor.construct(new NullProgressMonitor());

			} else {

				// TODO deal with the project not existing and shouldCreateProject being false

				javaProject = null; 

			}

		} 

		// Or open the project if we found it and it's not open.

		else {

			// TODO figure out if we need this opening business

			if (!project.isOpen()){

				project.open(monitor);

			}

			javaProject = JavaCore.create(project);

		}

		return javaProject;

	}

	private IWorkspaceRoot getWorkspaceRoot() {

		return getWorkspace().getRoot();

	}

	private IWorkspace getWorkspace() {

		return ResourcesPlugin.getWorkspace();

	}

package org.eclipse.ide4edu.javalite.constructors;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IWorkspace;

import org.eclipse.core.resources.IWorkspaceRoot;

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

import org.eclipse.core.runtime.Status;

import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.core.IJavaProject;

import org.eclipse.jdt.core.IPackageFragment;

import org.eclipse.jdt.core.IPackageFragmentRoot;

import org.eclipse.jdt.core.JavaCore;

import org.eclipse.jdt.ui.wizards.NewTypeWizardPage;

import org.eclipse.swt.widgets.Composite;

/**

 * Version 2

 * Java Class constructor that basically wraps the NewTypeWizardPage in the

 * hopes that this will make initial templating, extending superclasses and

 * implementing interfaces easier to implement.

 */

public class NewJavaClassConstructor2 {

	private NewTypeWizardPageWrapper wrapper = new NewTypeWizardPageWrapper();

	private String packageName = IPackageFragment.DEFAULT_PACKAGE_NAME;

	private String projectName = "My Project";

	/**

	 * Specifies whether this class should be created in the (default package) 

	 * i.e at the root level of the project? 

	 * 

	 * When beginner programmers start out, all of their classes will be created 

	 * at the root level of the project. When they move on to being intermediate 

	 * programmers, they will be able to specify the package the class should

	 * be created in.

	 */

	private Boolean shouldUseDefaultPackage = true;

	/**

	 * Specifies whether to create a new default project if the workspace is

	 * empty. Otherwise we will prompt for project creation.

	 */

	private Boolean shouldCreateProjectIfNecessary = true;

	public NewJavaClassConstructor2(){

		setClassName("MyClass");

	}

	public void setProjectName(String projectName) {

		this.projectName = projectName.trim();

	}

	public void setPackageName(String packageName) {

		this.packageName = packageName.trim();

	}

	public void setClassName(String className) {

		wrapper.setTypeName(className.trim(), true);

	}

	public String getClassName() {

		return wrapper.getTypeName();

	}

	// TODO Eventually add support for Superclasses and Interfaces 

	public void setUseDefaultPackage(Boolean shouldUseDefaultPackage) {

		this.shouldUseDefaultPackage = shouldUseDefaultPackage;

	}

	public void setCreateProjectIfNecessary(Boolean shouldCreateProjectIfNecessary) {

		this.shouldCreateProjectIfNecessary = shouldCreateProjectIfNecessary;

	}

	/**

	 * This method returns the status of the receiver in the form of

	 * an {@link IStatus} instance. The answer will reflect any

	 * potential error state in the receiver, or {@link Status#OK_STATUS}

	 * if there is no error.

	 * 

	 * @return Instance of {@link IStatus}

	 */

	public IStatus getStatus() {

		IStatus status = getWorkspace().validateName(getClassName(), IResource.FILE);

		if (!status.isOK()) return status;

		IProject project= getWorkspaceRoot().getProject(projectName);

		if (!shouldCreateProjectIfNecessary && !project.exists()) {

			return new Status(IStatus.ERROR, Activator.PLUGIN_ID, 

					"There is no project by the name " + projectName + 

					" to create a new class in.");

		}

		return Status.OK_STATUS;

	}

	/**

	 * @param monitor

	 * @return The newly created class file or null if there were problems 

	 * 		   creating the class.

	 * @throws CoreException

	 * @throws InterruptedException 

	 */

	public ICompilationUnit construct(IProgressMonitor monitor) throws CoreException, InterruptedException {

		if (!getStatus().isOK()) return null;

		ICompilationUnit javaClass = null;

		IJavaProject javaProject = getJavaProject(monitor);

		// TODO create package if it doesn't exist

		// TODO then call wrapper.setPackageFragment()

		// Create new class.

		wrapper.createType(monitor);

		return javaClass;

	}

	private IJavaProject getJavaProject(IProgressMonitor monitor)

			throws CoreException {

		IProject project = getWorkspaceRoot().getProject(projectName);

		IJavaProject javaProject;

		if (!project.exists()) {

			// Create a new project if there is no project by the given name

			if (shouldCreateProjectIfNecessary) {

				NewJavaProjectConstructor constructor = new NewJavaProjectConstructor();

				constructor.setProjectName(projectName);

				javaProject = constructor.construct(new NullProgressMonitor());

			} else {

				// TODO deal with the project not existing and shouldCreateProject being false

				javaProject = null;

			}

		}

		// Or open the project if we found it and it's not open.

		else {

			javaProject = JavaCore.create(project);

		}

		return javaProject;

	}

	private IWorkspaceRoot getWorkspaceRoot() {

		return getWorkspace().getRoot();

	}

	private IWorkspace getWorkspace() {

		return ResourcesPlugin.getWorkspace();

	}

	/**

	 * Wrapper for NewTypeWizardPage that allows us to use all of the class

	 * creation code already written.

	 */

	private class NewTypeWizardPageWrapper extends NewTypeWizardPage {

		public NewTypeWizardPageWrapper(){

			this(true, "");

		}

		public NewTypeWizardPageWrapper(boolean isClass, String pageName) {

			super(isClass, pageName);

		}

		public NewTypeWizardPageWrapper(int typeKind, String pageName) {

			super(typeKind, pageName);

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)

		 */

		public void createControl(Composite parent) {

		}

	}

}

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

 * Copyright (c) 2009 The Eclipse Foundation 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:

 *     Eclipse Foundation - initial API and implementation

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

package org.eclipse.ide4edu.javalite.constructors.tests;

import static org.junit.Assert.*;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.ide4edu.javalite.constructors.NewJavaClassConstructor;

import org.eclipse.ide4edu.javalite.constructors.NewJavaClassConstructor2;

import org.eclipse.ide4edu.javalite.constructors.NewJavaProjectConstructor;

import org.junit.Test;

public class NewJavaClassConstructorTests {

	@Test

	public void testClassCreation() throws Exception {

		NewJavaProjectConstructor projectConstructor = new NewJavaProjectConstructor();

		projectConstructor.setProjectName("AppleProject");

		projectConstructor.construct(new NullProgressMonitor());

		NewJavaClassConstructor classConstructor = new NewJavaClassConstructor();

		classConstructor.setClassName("AppleClass");

		classConstructor.setProjectName("AppleProject");

		classConstructor.construct(new NullProgressMonitor());

		IFile javaClassFile = ResourcesPlugin.getWorkspace(

				).getRoot().getProject("AppleProject").getFile("AppleClass.java");

		assertTrue(javaClassFile.exists());

		// TODO add test for contents of file, are they "public class AppleClass { }"?

	}

	@Test

	public void testClassCreation3() throws Exception {

		NewJavaProjectConstructor projectConstructor = new NewJavaProjectConstructor();

		projectConstructor.setProjectName("AppleProject");

		projectConstructor.construct(new NullProgressMonitor());

		NewJavaClassConstructor2 classConstructor = new NewJavaClassConstructor2();

		classConstructor.setClassName("AppleClass");

		classConstructor.setProjectName("AppleProject");

		classConstructor.construct(new NullProgressMonitor());

		IFile javaClassFile = ResourcesPlugin.getWorkspace(

				).getRoot().getProject("AppleProject").getFile("AppleClass.java");

		assertTrue(javaClassFile.exists());

		// TODO add test for contents of file, are they "public class AppleClass { }"?

	}

}