
<%
/**
 * Copyright (c) 20010 Ed Merks 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:
 *   Ed Merks - Initial API and implementation
 */
%>
<%GenModel genModel = (GenModel)argument; /* Trick to import java.util.* without warnings */Iterator.class.getName();%>
<%@ egf:patternCall patternId="platform:/plugin/org.eclipse.egf.emf.pattern.base/egf/EMF_Pattern_Base.fcore#LogicalName=org.eclipse.egf.emf.pattern.base.HeaderJava" args="parameter:argument"%>
package <%=genModel.getEditorPluginPackageName()%>;

import org.eclipse.emf.edit.ui.EditorEntryPoint;
<%genModel.markImportLocation(stringBuffer);%>

/**
 * This is the entry point.
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
public class <%=genModel.getEditorEntryPointClassName()%> extends EditorEntryPoint
{
<%if (genModel.hasCopyrightField()) {%>
	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public static final <%=genModel.getImportedName("java.lang.String")%> copyright = <%=genModel.getCopyrightFieldLiteral()%>;<%=genModel.getNonNLS()%>
	
<%}%>
	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void onModuleLoad()
	{
		super.onModuleLoad();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	protected void registerPackages(<%=genModel.getImportedName("org.eclipse.emf.ecore.EPackage")%>.Registry packageRegistry)
	{
<%for (GenPackage genPackage : genModel.getAllGenAndUsedGenPackagesWithClassifiers()) {%>
		packageRegistry.put(<%=genPackage.getImportedPackageInterfaceName()%>.eNS_URI, <%=genPackage.getImportedPackageInterfaceName()%>.eINSTANCE);
<%}%>
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	protected void configureItemProviderAdapterFactories(<%=genModel.getImportedName("org.eclipse.emf.edit.provider.ComposedAdapterFactory")%> adapterFactory)
	{
<%for (GenPackage genPackage : genModel.getAllGenAndUsedGenPackagesWithClassifiers()) {%>
		adapterFactory.addAdapterFactory(new <%=genPackage.getImportedItemProviderAdapterFactoryClassName()%>());
<%}%>
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	protected String getApplicationTitle()
	{
		return "<%=genModel.getModelName()%> Application";<%=genModel.getNonNLS()%>
	}
}
<%genModel.emitSortedImports();%>
