Attachment #52850 for bug #80318

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser.lookup;

import java.util.List;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.requests.CreateRequest;
import org.eclipse.gmf.runtime.common.core.command.CommandResult;
import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
import org.eclipse.gmf.runtime.diagram.ui.requests.CreateUnspecifiedTypeRequest;
import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand;
import org.eclipse.gmf.runtime.emf.type.core.IElementType;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.uml2.uml.NamedElement;


public class LookupResolverImpl implements LookupResolver {
	private LookupResolveRequest myTheOnlyRequest;
	private Callback myTheOnlyCallback;
	private boolean myIsMultipleResolveRequired;
	private final IGraphicalEditPart myResolvingEditPart;
	
	public LookupResolverImpl(IGraphicalEditPart resolvingEditPart){
		myResolvingEditPart = resolvingEditPart;
	}
	
	public void addLookupResolveRequest(LookupResolveRequest request, Callback callback){
		if (isEmpty()){
			myTheOnlyCallback = callback;
			myTheOnlyRequest = request;
		} else {
			myIsMultipleResolveRequired = true;
		}
	}
	
	public boolean isEmpty(){
		return myTheOnlyCallback == null && myTheOnlyRequest == null;
	}
	
	public boolean canResolve(){
		return !isEmpty() && !myIsMultipleResolveRequired;
	}
	
	public AbstractTransactionalCommand getResolveCommand() {
		if (!canResolve()){
			return null;
		}
		TransactionalEditingDomain domain = myResolvingEditPart.getEditingDomain();
		final CreateUnspecifiedTypeRequest createRequest = new CreateUnspecifiedTypeRequest(myTheOnlyRequest.getElementTypes(), myResolvingEditPart.getDiagramPreferencesHint());
		final Command gefCommand = myResolvingEditPart.getCommand(createRequest);
		if (!gefCommand.canExecute()){
			return null;
		}
		//XXX gef inside transactional command???
		return new AbstractTransactionalCommand(domain, "", null){
			@Override
			protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
				gefCommand.execute();
				NamedElement resolution = getNewObject();
				if (resolution != null){
					resolution.eSet(myTheOnlyRequest.getInitFeature(), myTheOnlyRequest.getInitValue());
					myTheOnlyCallback.lookupResolved(resolution);
				}
				return CommandResult.newOKCommandResult();
			}
			
			private NamedElement getNewObject(){
				for (Object next : createRequest.getElementTypes()){
					IElementType nextElementType = (IElementType)next;
					CreateRequest nextRequest = createRequest.getRequestForType(nextElementType);
					List allNew = (List)nextRequest.getNewObject();
					for (Object nextCreated : allNew){
						if (nextCreated instanceof IAdaptable){
							View createdView = (View) ((IAdaptable)nextCreated).getAdapter(View.class);
							if (createdView != null) {
								EObject createdEntity = createdView.getElement(); 
								if (createdEntity instanceof NamedElement){
									return (NamedElement)createdEntity;
								}
							}
						}
					}
				}
				return null;
			}
		};
	}
	

}

Added Link Here

(-)build.properties (+4 lines)
1	source.. = src/
2	output.. = bin/
3	bin.includes = META-INF/,\
4	.




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.gmf.runtime.common.core.command.CommandResult;
import org.eclipse.gmf.runtime.common.core.command.ICommand;
import org.eclipse.gmf.runtime.common.core.command.UnexecutableCommand;
import org.eclipse.gmf.runtime.common.ui.services.parser.IParser;
import org.eclipse.gmf.runtime.common.ui.services.parser.IParserEditStatus;
import org.eclipse.gmf.runtime.common.ui.services.parser.ParserEditStatus;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand;
import org.eclipse.gmf.runtime.emf.commands.core.command.CompositeTransactionalCommand;
import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
import org.eclipse.uml2.diagram.parser.lookup.LookupResolver;
import org.eclipse.uml2.diagram.parser.lookup.LookupResolverImpl;
import org.eclipse.uml2.diagram.parser.lookup.LookupSuite;
import org.eclipse.uml2.internal.diagram.parser.MDTDiagramParserPlugin;

public class ParserAdapter implements IParser {
	private static final String NOT_AN_OBJECT = "Unknown";
	private final ExternalParserBase myDelegate;
	private final EObject myTester;
	private final ApplyStrategy myApplier;
	private final ExternalToString myView;
	private final ExternalToString myEdit;
	private final static MessageFormatEscaper ourMessageFormatEscaper = new MessageFormatEscaper();
	
	public ParserAdapter(ExternalParserBase delegate, ApplyStrategy applier){
		this(delegate, applier, ExternalToString.NOT_IMPLEMENTED);
	}
	
	public ParserAdapter(ExternalParserBase delegate, ApplyStrategy applier, ExternalToString viewAndEdit){
		this(delegate, applier, viewAndEdit, viewAndEdit);
	}

	public ParserAdapter(ExternalParserBase delegate, ApplyStrategy applier, ExternalToString view, ExternalToString edit){
		myDelegate = delegate;
		myApplier = applier;
		myView = view;
		myEdit = edit;
		myTester = myDelegate.createSubjectPrototype();
	}
	
	public IContentAssistProcessor getCompletionProcessor(IAdaptable element) {
		return null;
	}
	
	public String getEditString(IAdaptable element, int flags) {
		return getToString(element, flags, myEdit);
	}
	
	public String getPrintString(IAdaptable element, int flags) {
		return getToString(element, flags, myView);
	}
	
	public final boolean isAffectingEvent(Object event, int flags) {
		return isAffectingEvent(event);
	}
	
	protected boolean isAffectingEvent(Object event){
		if (event instanceof Notification) {
			Object feature = ((Notification) event).getFeature();
			return (feature instanceof EStructuralFeature) && myView.isAffectingFeature((EStructuralFeature)feature);
		}
		return false;
	}
	
	public IParserEditStatus isValidEditString(IAdaptable adapter, String editString) {
		EObject modelObject = (EObject) adapter.getAdapter(EObject.class);
		if (modelObject == null) {
			return new ParserEditStatus(
					MDTDiagramParserPlugin.getPluginID(), IParserEditStatus.UNEDITABLE, 
					"Can not find context object");			
		}
		
		LookupSuite oldLookup = myDelegate.getLookupSuite();
		try {
			myDelegate.setLookupSuite(LookupSuite.NULL_SUITE);
			myDelegate.parse(myTester, editString, modelObject);
			return ParserEditStatus.EDITABLE_STATUS;
		} catch (ExternalParserException e) {
			//CellEditor uses MessageFormat to format the message
			//we need to escape '{', '}', '\' to prevent failure while formatting an error
			String message = e.getMessage();
			if (message == null){
				message = "";
			}
			message = ourMessageFormatEscaper.getEscaped(message);
			return new ParserEditStatus(
					MDTDiagramParserPlugin.getPluginID(), IParserEditStatus.UNEDITABLE, 
					"Invalid input: " + message);			
		} finally {
			myDelegate.setLookupSuite(oldLookup);
		}
	}
	
	public ICommand getParseCommand(IAdaptable adapter, String newString, int flags) {
		final EObject modelObject = (EObject) adapter.getAdapter(EObject.class);
		if (modelObject == null) {
			return UnexecutableCommand.INSTANCE;
		}
		TransactionalEditingDomain editingDomain = TransactionUtil.getEditingDomain(modelObject);
		if (editingDomain == null) {
			return UnexecutableCommand.INSTANCE;
		}
		
		IGraphicalEditPart diagramEditPart = (DiagramEditPart)adapter.getAdapter(DiagramEditPart.class);
		LookupResolver resolver = LookupResolver.NULL;
		if (diagramEditPart != null){
			resolver = new LookupResolverImpl(diagramEditPart);
		}
		myDelegate.setLookupResolver(resolver);
		
		final EObject parsed; 
		try {
			parsed = myDelegate.parseNewObject(modelObject, newString);
		} catch (ExternalParserException e){
			//strange
			//e.printStackTrace();
			return UnexecutableCommand.INSTANCE;
		} finally {
			myDelegate.setLookupResolver(null);
		}
		
		List commandList = new LinkedList();
		if (resolver.canResolve()){
			AbstractTransactionalCommand resolveCommand = resolver.getResolveCommand();
			AbstractTransactionalCommand computeAndApplyCommand = new AbstractTransactionalCommand(editingDomain, "", null){
				@Override
				protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
					for (Iterator applyCommands = myApplier.apply(modelObject, parsed).iterator(); applyCommands.hasNext();){
						ICommand next = (ICommand)applyCommands.next();
						next.execute(monitor, info);
					}
					return CommandResult.newOKCommandResult();
				}
			};
			commandList.add(resolveCommand);
			commandList.add(computeAndApplyCommand);
		} else {
			commandList.addAll(myApplier.apply(modelObject, parsed));
		}
		return new CompositeTransactionalCommand(editingDomain, getCommandLabel(commandList), commandList);
	}
	
	protected final ExternalToString getViewToString() {
		return myView;
	}
	
	private String getToString(IAdaptable element, int flags, ExternalToString toString) {
		EObject modelObject = (EObject) element.getAdapter(EObject.class);
		return isValidElement(modelObject) ? toString.getToString(modelObject, flags) : NOT_AN_OBJECT;
	}
	
	private String getCommandLabel(List/*1.5 <ICommand>*/ commandList){
		return "-not-implemented-";
	}
	
	protected final boolean isValidElement(Object object){
		return object != null && myDelegate.getSubjectClass().isInstance(object);
	}
	
	private static class MessageFormatEscaper {
		private final char S_QUOTE = '\'';
		
		public String getEscaped(String input){
			if (!input.contains("'")){
				return "'" + input + "'";
			}
			StringBuffer result = new StringBuffer(input.length() + 5);
			result.append(S_QUOTE);
			for (int i = 0; i < input.length(); i++){
				char next = result.charAt(i);
				if (next == S_QUOTE){
					result.append(S_QUOTE);
				}
				result.append(next);
			}
			result.append(S_QUOTE);
			return result.toString();
		}
	}
	
}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser.lookup;

import java.util.List;

import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.gmf.runtime.emf.type.core.IElementType;

public class LookupResolveRequest {
	private final List<IElementType> myElementTypes;
	private final EStructuralFeature myInitFeature;
	private final Object myInitValue;

	public LookupResolveRequest(List<IElementType> elementTypes, EStructuralFeature initFeature, Object initValue){
		myElementTypes = elementTypes;
		myInitFeature = initFeature;
		myInitValue = initValue;
	}
	
	public List<IElementType> getElementTypes() {
		return myElementTypes;
	}
	
	public EStructuralFeature getInitFeature() {
		return myInitFeature;
	}
	
	public Object getInitValue() {
		return myInitValue;
	}
	
}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser;

import java.util.Collections;
import java.util.List;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.gmf.runtime.common.core.command.UnexecutableCommand;

public interface ApplyStrategy {
	public List/*1.5 <ICommand>*/ apply(EObject modelObject, EObject parsedObject);
	
	public static final List/*1.5 <ICommand>*/ NOT_EXECUTABLE = Collections.singletonList(UnexecutableCommand.INSTANCE);
}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser.lookup;

import java.util.HashMap;

public class LookupSuiteImpl implements LookupSuite {
	private final HashMap<Class, Lookup> myLookups = new HashMap<Class, Lookup>();
	private LookupResolver myLookupResolver = LookupResolver.NULL;
	
	public <T> void addLookup(Class<T> clazz, Lookup<T> lookup){
		if (myLookups.containsKey(clazz)){
			throw new IllegalArgumentException("I already have lookup for :" + clazz);
		}
		myLookups.put(clazz, lookup);
	}
	
	public <T> Lookup<T> getLookup(Class<T> clazz) {
		Lookup<T> result = myLookups.get(clazz);
		return result == null ? NULL_LOOKUP : result;
	}
	
	public void setLookupResolver(LookupResolver lookupResolver){
		myLookupResolver = lookupResolver;
		if (myLookupResolver == null){
			myLookupResolver = LookupResolver.NULL;
		}
	}
	
	public LookupResolver getLookupResolver() {
		return myLookupResolver;
	}

}

Added Link Here

(-).classpath (+7 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>
3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
6	<classpathentry kind="output" path="bin"/>
7	</classpath>




Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: UML Diagrams Parser Plug-in
Bundle-SymbolicName: org.eclipse.uml2.diagram.parser; singleton:=true
Bundle-Version: 1.0.0
Bundle-Localization: plugin
Bundle-Activator: org.eclipse.uml2.internal.diagram.parser.MDTDiagramParserPlugin
Require-Bundle: org.eclipse.core.runtime,
 org.eclipse.jface,
 org.eclipse.emf.ecore,
 org.eclipse.emf.ecore.xmi,
 org.eclipse.emf.edit.ui,
 org.eclipse.gef;visibility:=reexport,
 org.eclipse.gmf.runtime.emf.core,
 org.eclipse.gmf.runtime.emf.commands.core,
 org.eclipse.gmf.runtime.emf.ui.properties,
 org.eclipse.gmf.runtime.diagram.ui,
 org.eclipse.gmf.runtime.diagram.ui.properties,
 org.eclipse.uml2.uml;visibility:=reexport,
 org.eclipse.uml2.uml.edit;visibility:=reexport,
 org.eclipse.emf.ecore;visibility:=reexport,
 org.eclipse.emf.ecore.edit;visibility:=reexport,
 org.eclipse.emf.query.ocl;visibility:=reexport,
 org.eclipse.emf.ocl;visibility:=reexport
Export-Package: org.eclipse.uml2.diagram.parser,
 org.eclipse.uml2.diagram.parser.lookup
Eclipse-LazyStart: true





/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.internal.diagram.parser;

import org.eclipse.core.runtime.Plugin;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;

public class MDTDiagramParserPlugin extends Plugin {
	private static MDTDiagramParserPlugin anInstance;

	public void start(BundleContext context) throws Exception {
		super.start(context);
		anInstance = this;
	}

	public void stop(BundleContext context) throws Exception {
		anInstance = null;
		super.stop(context);
	}

	public static String getPluginID() {
		return getDefault().getSymbolicName();
	}

	public static Bundle getDefault() {
		return anInstance.getBundle();
	}

}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser.lookup;

import java.util.Collections;
import java.util.List;

import org.eclipse.emf.ecore.EObject;

public interface LookupSuite {
	public <T> Lookup<T> getLookup(Class<T> clazz);
	
	public static final Lookup NULL_LOOKUP = new Lookup(){
		public Object lookup(String name, EObject context){
			return null;
		}
		
		public List getResolutionElementTypes() {
			return Collections.emptyList();
		}
	};
	
	public static final LookupSuite NULL_SUITE = new LookupSuite(){
		public <T> Lookup<T> getLookup(Class<T> clazz) {
			return NULL_LOOKUP;
		}
	};
	
}

Added Link Here

(-)plugin.xml (+5 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<?eclipse version="3.0"?>
3
4	<plugin>
5	</plugin>




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser;

public class ExternalParserException extends Exception {

	public ExternalParserException() {
		super();
	}

	public ExternalParserException(String message) {
		super(message);
	}

}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */
package org.eclipse.uml2.diagram.parser;

import java.util.List;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.gmf.runtime.emf.type.core.IElementType;
import org.eclipse.uml2.diagram.parser.lookup.Lookup;
import org.eclipse.uml2.diagram.parser.lookup.LookupResolveRequest;
import org.eclipse.uml2.diagram.parser.lookup.LookupResolver;
import org.eclipse.uml2.diagram.parser.lookup.LookupSuite;
import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.UMLPackage;

public abstract class ExternalParserBase {
	private LookupSuite myLookups = LookupSuite.NULL_SUITE;
	private LookupResolver myLookupResolver = LookupResolver.NULL;
	
	private EObject myContext;
	
	public abstract EClass getSubjectClass();

	public abstract void parse(EObject target, String text) throws ExternalParserException;
	
	public final EObject parseNewObject(EObject context, String text) throws ExternalParserException {
		myContext = context;
		try {
			EObject result = createSubjectPrototype();
			parse(result, text);
			return result;
		} finally {
			myContext = null;
		}
	}
	
	public final void parse(EObject target, String text, EObject context) throws ExternalParserException {
		myContext = context;
		try {
			parse(target, text);
		} finally {
			myContext = null;
		}
	}
	
	public final void setLookupSuite(LookupSuite suite){
		myLookups = suite;
		if (myLookups == null){
			myLookups = LookupSuite.NULL_SUITE;
		}
	}
	
	public final void setLookupResolver(LookupResolver lookupResolver){
		myLookupResolver = lookupResolver;
		if (myLookupResolver == null){
			myLookupResolver = LookupResolver.NULL;
		}
	}
	
	public final LookupSuite getLookupSuite(){
		return myLookups;
	}
	
	public final <T> T lookup(Class<T> clazz, String name){
		Lookup<T> lookup = getLookupSuite().getLookup(clazz);
		return lookup.lookup(name, getContext());
	}
	
	public EObject createSubjectPrototype(){
		EClass subjectClass = getSubjectClass();
		return subjectClass.getEPackage().getEFactoryInstance().create(subjectClass);
	}
	
	protected final EObject getContext(){
		return myContext;
	}
	
	protected final void checkContext(){
		if (getContext() == null){
			throw new IllegalStateException("I need context element to perform lookups");
		}
	}
	
	protected <T extends NamedElement> void applyLookup(Class<T> clazz, String name, LookupResolver.Callback callback){
		Lookup<T> lookup = getLookupSuite().getLookup(clazz);
		T result = lookup.lookup(name, getContext());
		if (result != null){
			callback.lookupResolved(result);
			return;
		}
		List<IElementType> allowedTypes = lookup.getResolutionElementTypes();
		if (allowedTypes.isEmpty()){
			return;
		}
		LookupResolveRequest request = new LookupResolveRequest(allowedTypes, UMLPackage.eINSTANCE.getNamedElement_Name(), name);
		myLookupResolver.addLookupResolveRequest(request, callback);
	}
	
}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser;

import org.eclipse.gef.commands.Command;
import org.eclipse.gef.requests.DirectEditRequest;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.LabelDirectEditPolicy;

public class SemanticLabelDirectEditPolicy extends LabelDirectEditPolicy {
	@Override
	protected Command getDirectEditCommand(DirectEditRequest edit) {
		Command applyChanges = super.getDirectEditCommand(edit);
		Command postRefresh = null;
		if (applyChanges != null && applyChanges.canExecute()){
			postRefresh = new PostRefreshCommand();
		}
		return applyChanges.chain(postRefresh);
	}
	
	private class PostRefreshCommand extends Command {
		@Override
		public void execute() {
			getHost().refresh();
		}
	}
}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser.lookup;

import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand;
import org.eclipse.uml2.uml.NamedElement;

public interface LookupResolver {

	public abstract void addLookupResolveRequest(LookupResolveRequest request, Callback callback);

	public abstract boolean isEmpty();

	public abstract boolean canResolve();

	public abstract AbstractTransactionalCommand getResolveCommand();

	public static interface Callback {
		public void lookupResolved(NamedElement resolution);
	}

	public static final LookupResolver NULL = new LookupResolver() {

		public boolean isEmpty() {
			return true;
		}

		public AbstractTransactionalCommand getResolveCommand() {
			return null;
		}

		public boolean canResolve() {
			return false;
		}

		public void addLookupResolveRequest(LookupResolveRequest request, Callback callback) {
			//
		}

	};

}




<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
	<name>org.eclipse.uml2.diagram.parser</name>
	<comment></comment>
	<projects>
	</projects>
	<buildSpec>
		<buildCommand>
			<name>org.eclipse.jdt.core.javabuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
		<buildCommand>
			<name>org.eclipse.pde.ManifestBuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
		<buildCommand>
			<name>org.eclipse.pde.SchemaBuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
	</buildSpec>
	<natures>
		<nature>org.eclipse.pde.PluginNature</nature>
		<nature>org.eclipse.jdt.core.javanature</nature>
	</natures>
</projectDescription>




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser;

import org.eclipse.uml2.uml.LiteralUnlimitedNatural;
import org.eclipse.uml2.uml.MultiplicityElement;
import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.Type;
import org.eclipse.uml2.uml.TypedElement;
import org.eclipse.uml2.uml.VisibilityKind;

public abstract class AbstractToString implements ExternalToString {
	protected String getVisibility(NamedElement namedElement) {
		VisibilityKind visibility = namedElement.getVisibility(); 
		switch (visibility.getValue()){
			case VisibilityKind.PACKAGE : 
				return "~";
			case VisibilityKind.PRIVATE : 
				return "-";
			case VisibilityKind.PROTECTED : 
				return "#";
			case VisibilityKind.PUBLIC : 
				return ""; //omitted
		}
		throw new IllegalArgumentException("Unknown visibility for :" + namedElement + ", that is: " + visibility);
	}
	
	protected void appendName(StringBuffer result, NamedElement namedElement){
		if (namedElement == null){
			return;
		}
		String name = namedElement.getName();
		if (!isEmpty(name)){
			result.append(name);
		}
	}

	protected void appendType(StringBuffer result, TypedElement typedElement) {
		if (typedElement == null){
			return;
		}
		Type type = typedElement.getType();
		if (type == null){
			return;
		}
		appendType(result, type.getName());
	}
	
	protected static void appendType(StringBuffer result, String typeName) {
		if (isEmpty(typeName)){
			return;
		}
		result.append(" : ");
		result.append(typeName);
	}
	
	protected static boolean isEmpty(String text){
		return text == null || text.trim().length() == 0;
	}

	protected void appendMultiplicity(StringBuffer result, MultiplicityElement element) {
		if (element == null){
			return;
		}
		int lower = element.getLower();
		int upper = element.getUpper();
		if (upper == 1 && lower == 1){
			return;
		}
		result.append(" [");
		if (lower != upper){
			result.append(lower);
			result.append('.').append('.');
		}
		if (upper == LiteralUnlimitedNatural.UNLIMITED){
			result.append('*');
		} else {
			result.append(upper);
		}
		result.append(']');
	}
	
	protected static class ModifiersBuilder {
		private final StringBuffer myBuffer;
		
		public ModifiersBuilder(){
			myBuffer = new StringBuffer();
		}
		
		public void appendModifier(String modifier){
			if (modifier.length() == 0){
				return;
			}
			if (myBuffer.length() != 0){
				myBuffer.append(", ");
			}
			myBuffer.append(modifier);
		}
		
		public void writeInto(StringBuffer output){
			if (myBuffer.length() == 0){
				return;
			}
			output.append(" ");
			output.append("{ ");
			output.append(myBuffer);
			output.append(" }");
		}
		
		public String toString() {
			return super.toString();
		}
		
	}

}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser;

import java.util.List;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;

public interface ExternalToString {
	public String getToString(EObject object, int flags);
	
	public boolean isAffectingFeature(EStructuralFeature feature);
	
	public static final ExternalToString NOT_IMPLEMENTED = new ExternalToString(){
	
		public String getToString(EObject object, int flags) {
			return "-NOT-IMPLEMENTED-";
		}
		
		public boolean isAffectingFeature(EStructuralFeature feature) {
			return false;
		}
	};
	
	public static interface WithReferences extends ExternalToString {
		public List getAdditionalReferencedElements(EObject object);
	}
}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser.lookup;

import java.util.List;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.gmf.runtime.emf.type.core.IElementType;

public interface Lookup<T> {
	public T lookup(String name, EObject context);
	public List<IElementType> getResolutionElementTypes(); 
}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.gmf.runtime.emf.type.core.commands.DestroyReferenceCommand;
import org.eclipse.gmf.runtime.emf.type.core.commands.SetValueCommand;
import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyReferenceRequest;
import org.eclipse.gmf.runtime.emf.type.core.requests.SetRequest;

public class BasicApplyStrategy implements ApplyStrategy {
	public List/*1.5 <ICommand>*/ apply(EObject modelObject, EObject parsedObject) {
		List result = new LinkedList(); 
		for (Iterator it = parsedObject.eClass().getEAllStructuralFeatures().iterator(); it.hasNext();){
			EStructuralFeature next = (EStructuralFeature) it.next();
			if (parsedObject.eIsSet(next) && !next.isDerived()){
				transferValue(result, modelObject, parsedObject, next);
			}
		}
		return result.isEmpty() ? NOT_EXECUTABLE : result;
	}
	
	protected final void transferValue(List output, EObject model, EObject parsed, EStructuralFeature feature){
		if (feature.isDerived() || !parsed.eIsSet(feature)){
			return;
		}
		Object parsedValue = parsed.eGet(feature);
		Object actualValue = model.eGet(feature);
		if (safeEquals(parsedValue, actualValue)){
			return;
		}	
		//XXX: workaround for : #152080
		//XXX: can not set multi-valued properties using SetValueCommand,  
		//XXX: see https://bugs.eclipse.org/bugs/show_bug.cgi?id=152080
		if (feature instanceof EReference && feature.isMany()){
			transferValuesList(output, model, parsed, (EReference)feature);
			return;
		}
		SetRequest request = new SetRequest(model, feature, parsedValue);
		output.add(new SetValueCommand(request));
	}
	
	private void transferValuesList(List output, EObject model, EObject parsed, EReference isManyReference){
		assert isManyReference.isMany();
		List<EObject> actualValues = (List<EObject>) model.eGet(isManyReference);
		List<EObject> parsedValues = (List<EObject>) parsed.eGet(isManyReference);
		
		for (EObject nextActual : actualValues){
			DestroyReferenceRequest nextRequest = new DestroyReferenceRequest(model, isManyReference, nextActual, false);
			output.add(new DestroyReferenceCommand(nextRequest));
		}
		
		for (EObject nextParsed : parsedValues){
			SetRequest nextRequest = new SetRequest(model, isManyReference, nextParsed);
			output.add(new SetValueCommand(nextRequest));
		}
	}

	protected static <T> boolean safeEquals(T o1, T o2){
		return o1 == null ? o2 == null : o1.equals(o2);
	}

}

Added Link Here

(-).cvsignore (+1 lines)
1	bin




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser.lookup;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.gmf.runtime.emf.type.core.IElementType;
import org.eclipse.uml2.uml.NamedElement;

public class OCLLookup<T extends NamedElement> implements Lookup<T> {
	public static interface Expression {
		public Object evaluate(Object context);
	}
	
	private Expression mySelector;
	private final ArrayList<IElementType> myResolutionTypes;
	private static final IElementType[] NO_RESOLUTIONS = new IElementType[0];
	
	public OCLLookup(Expression ocl, IElementType[] resolutions){
		mySelector = ocl;
		if (resolutions == null){
			resolutions = NO_RESOLUTIONS;
		}
		myResolutionTypes = new ArrayList<IElementType>(Arrays.asList(resolutions));
	}
	
	public List getResolutionElementTypes() {
		return new ArrayList<IElementType>(myResolutionTypes);
	}
	
	public List<T> computeScope(EObject context){
		Object result = mySelector.evaluate(context);
		if (result instanceof Collection){
			return new LinkedList<T>((Collection<T>)result);
		}
		return Collections.emptyList();
	}
	
	public T lookup(String name, EObject context) {
		List<T> scope = computeScope(context);
		for (T next : scope){
			if (name.equals(next.getName()) || name.equals(next.getQualifiedName())){
				return next;
			}
		}
		return null;
	}

}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.parser;

import java.util.Collections;
import java.util.List;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.gmf.runtime.emf.ui.services.parser.ISemanticParser;

public class SemanticParserAdapter extends ParserAdapter implements ISemanticParser {

	public SemanticParserAdapter(ExternalParserBase delegate, ApplyStrategy applier, ExternalToString.WithReferences view, ExternalToString edit) {
		super(delegate, applier, view, edit);
	}

	public SemanticParserAdapter(ExternalParserBase delegate, ApplyStrategy applier, ExternalToString.WithReferences viewAndEdit) {
		this(delegate, applier, viewAndEdit, viewAndEdit);
	}

	public boolean areSemanticElementsAffected(EObject listener, Object notification) {
		return isAffectingEvent(notification);
	}
	
	public List getSemanticElementsBeingParsed(EObject element) {
		return isValidElement(element) ? 
				getViewToStringImpl().getAdditionalReferencedElements(element) : 
				Collections.EMPTY_LIST;
	}
	
	private ExternalToString.WithReferences getViewToStringImpl(){
		return (ExternalToString.WithReferences)getViewToString();
	}

}

Added Link Here

(-)build.properties (+4 lines)
1	source.. = src/
2	output.. = bin/
3	bin.includes = META-INF/,\
4	.




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.common.draw2d;

import org.eclipse.draw2d.RectangleFigure;

public class PolylineContainer extends RectangleFigure {
	public PolylineContainer(){
		super();
		setOutline(false);
		setFill(false);
	}

	protected boolean useLocalCoordinates() {
		return true;
	}
	
}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.common.draw2d;

import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.PolygonDecoration;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.swt.graphics.Color;
import org.eclipse.uml2.uml.AggregationKind;
import org.eclipse.uml2.uml.Association;
import org.eclipse.uml2.uml.Property;

public class AssociationDecoration extends PolygonDecoration {
	private static final PointList RHOMB = new PointList(new int[] { //
			//
					-1, 1, // 
					0, 0, //
					-1, -1, //
					-2, 0, //
					-1, 1, //
			});

	/**
	 * XXX: navigability arrows and owner-dot decorations are not implemented yet
	 */
	private static final PointList ARROW = new PointList(new int[] { //
			//
					-1, 1, // 
					0, 0, //
					-1, -1, //
					0, 0, // 
					-1, 1, //
			});

	public AssociationDecoration() {
		setTemplate(RHOMB.getCopy());
		setScale(7, 3);
		setVisible(false);
		setFill(true);
	}

	public void update(AggregationKind kind) {
		if (kind == AggregationKind.COMPOSITE_LITERAL) {
			setVisible(true);
			if (getParent() != null && getParent().getForegroundColor() != null){
				setBackgroundColor(getParent().getForegroundColor());	
			}
		} else if (kind == AggregationKind.SHARED_LITERAL) {
			setVisible(true);
			setBackgroundColor(ColorConstants.white);
		} else {
			setVisible(false);
		}
	}
	
	public void update(Association association, Property associationEnd) {
		update(associationEnd.getAggregation());
	}

}




/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 3.0 */
/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */
package org.eclipse.uml2.diagram.common.parser.port;

public class TokenMgrError extends Error
{
   /*
    * Ordinals for various reasons why an Error of this type can be thrown.
    */

   /**
    * Lexical error occured.
    */
   static final int LEXICAL_ERROR = 0;

   /**
    * An attempt wass made to create a second instance of a static token manager.
    */
   static final int STATIC_LEXER_ERROR = 1;

   /**
    * Tried to change to an invalid lexical state.
    */
   static final int INVALID_LEXICAL_STATE = 2;

   /**
    * Detected (and bailed out of) an infinite loop in the token manager.
    */
   static final int LOOP_DETECTED = 3;

   /**
    * Indicates the reason why the exception is thrown. It will have
    * one of the above 4 values.
    */
   int errorCode;

   /**
    * Replaces unprintable characters by their espaced (or unicode escaped)
    * equivalents in the given string
    */
   protected static final String addEscapes(String str) {
      StringBuffer retval = new StringBuffer();
      char ch;
      for (int i = 0; i < str.length(); i++) {
        switch (str.charAt(i))
        {
           case 0 :
              continue;
           case '\b':
              retval.append("\\b");
              continue;
           case '\t':
              retval.append("\\t");
              continue;
           case '\n':
              retval.append("\\n");
              continue;
           case '\f':
              retval.append("\\f");
              continue;
           case '\r':
              retval.append("\\r");
              continue;
           case '\"':
              retval.append("\\\"");
              continue;
           case '\'':
              retval.append("\\\'");
              continue;
           case '\\':
              retval.append("\\\\");
              continue;
           default:
              if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
                 String s = "0000" + Integer.toString(ch, 16);
                 retval.append("\\u" + s.substring(s.length() - 4, s.length()));
              } else {
                 retval.append(ch);
              }
              continue;
        }
      }
      return retval.toString();
   }

   /**
    * Returns a detailed message for the Error when it is thrown by the
    * token manager to indicate a lexical error.
    * Parameters : 
    *    EOFSeen     : indicates if EOF caused the lexicl error
    *    curLexState : lexical state in which this error occured
    *    errorLine   : line number when the error occured
    *    errorColumn : column number when the error occured
    *    errorAfter  : prefix that was seen before this error occured
    *    curchar     : the offending character
    * Note: You can customize the lexical error message by modifying this method.
    */
   protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) {
      return("Lexical error at line " +
           errorLine + ", column " +
           errorColumn + ".  Encountered: " +
           (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") +
           "after : \"" + addEscapes(errorAfter) + "\"");
   }

   /**
    * You can also modify the body of this method to customize your error messages.
    * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
    * of end-users concern, so you can return something like : 
    *
    *     "Internal Error : Please file a bug report .... "
    *
    * from this method for such cases in the release version of your parser.
    */
   public String getMessage() {
      return super.getMessage();
   }

   /*
    * Constructors of various flavors follow.
    */

   public TokenMgrError() {
   }

   public TokenMgrError(String message, int reason) {
      super(message);
      errorCode = reason;
   }

   public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) {
      this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);
   }
}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.common.parser.port;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.uml2.diagram.parser.AbstractToString;
import org.eclipse.uml2.diagram.parser.ExternalToString.WithReferences;
import org.eclipse.uml2.uml.Port;
import org.eclipse.uml2.uml.UMLPackage;
import org.eclipse.uml2.uml.ValueSpecification;

public class PortToString extends AbstractToString implements WithReferences {
	public String getToString(EObject object, int flags) {
		Port port = asPort(object);
		StringBuffer result = new StringBuffer();
		appendName(result, port);
		appendType(result, port);
		appendMultiplicity(result, port);
		return result.toString();
	}
	
	private static final List AFFECTING = Arrays.asList(new EStructuralFeature[] {
			UMLPackage.eINSTANCE.getNamedElement_Visibility(),
			UMLPackage.eINSTANCE.getNamedElement_Name(),
			UMLPackage.eINSTANCE.getTypedElement_Type(),
			UMLPackage.eINSTANCE.getMultiplicityElement_UpperValue(),
			UMLPackage.eINSTANCE.getMultiplicityElement_LowerValue(),
			UMLPackage.eINSTANCE.getLiteralUnlimitedNatural_Value(), 
			UMLPackage.eINSTANCE.getLiteralInteger_Value(),
			UMLPackage.eINSTANCE.getLiteralString_Value(),
		});

	public boolean isAffectingFeature(EStructuralFeature feature) {
		return AFFECTING.contains(feature);
	}
	
	public List getAdditionalReferencedElements(EObject object) {
		Port port = asPort(object);
		List result = new LinkedList();
		result.add(port);
		ValueSpecification upper = port.getUpperValue();
		if (upper != null){
			result.add(upper);
		}
		ValueSpecification lower = port.getLowerValue();
		if (lower != null){
			result.add(lower);
		}
		if (port.getType() != null){
			result.add(port.getType());
		}
		return result;
	}

	protected Port asPort(EObject object){
		if (false == object instanceof Port){
			throw new IllegalStateException("I can not provide toString for: " + object);
		}
		return (Port)object;
	}
	
}




/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 3.0 */
/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */
package org.eclipse.uml2.diagram.common.parser.port;

import org.eclipse.uml2.diagram.parser.ExternalParserException;

/**
 * This exception is thrown when parse errors are encountered.
 * You can explicitly create objects of this exception type by
 * calling the method generateParseException in the generated
 * parser.
 *
 * You can modify this class to customize your error reporting
 * mechanisms so long as you retain the public fields.
 */
public class ParseException extends ExternalParserException {

  /**
   * This constructor is used by the method "generateParseException"
   * in the generated parser.  Calling this constructor generates
   * a new object of this type with the fields "currentToken",
   * "expectedTokenSequences", and "tokenImage" set.  The boolean
   * flag "specialConstructor" is also set to true to indicate that
   * this constructor was used to create this object.
   * This constructor calls its super class with the empty string
   * to force the "toString" method of parent class "Throwable" to
   * print the error message in the form:
   *     ParseException: <result of getMessage>
   */
  public ParseException(Token currentTokenVal,
                        int[][] expectedTokenSequencesVal,
                        String[] tokenImageVal
                       )
  {
    super("");
    specialConstructor = true;
    currentToken = currentTokenVal;
    expectedTokenSequences = expectedTokenSequencesVal;
    tokenImage = tokenImageVal;
  }

  /**
   * The following constructors are for use by you for whatever
   * purpose you can think of.  Constructing the exception in this
   * manner makes the exception behave in the normal way - i.e., as
   * documented in the class "Throwable".  The fields "errorToken",
   * "expectedTokenSequences", and "tokenImage" do not contain
   * relevant information.  The JavaCC generated code does not use
   * these constructors.
   */

  public ParseException() {
    super();
    specialConstructor = false;
  }

  public ParseException(String message) {
    super(message);
    specialConstructor = false;
  }

  /**
   * This variable determines which constructor was used to create
   * this object and thereby affects the semantics of the
   * "getMessage" method (see below).
   */
  protected boolean specialConstructor;

  /**
   * This is the last token that has been consumed successfully.  If
   * this object has been created due to a parse error, the token
   * followng this token will (therefore) be the first error token.
   */
  public Token currentToken;

  /**
   * Each entry in this array is an array of integers.  Each array
   * of integers represents a sequence of tokens (by their ordinal
   * values) that is expected at this point of the parse.
   */
  public int[][] expectedTokenSequences;

  /**
   * This is a reference to the "tokenImage" array of the generated
   * parser within which the parse error occurred.  This array is
   * defined in the generated ...Constants interface.
   */
  public String[] tokenImage;

  /**
   * This method has the standard behavior when this object has been
   * created using the standard constructors.  Otherwise, it uses
   * "currentToken" and "expectedTokenSequences" to generate a parse
   * error message and returns it.  If this object has been created
   * due to a parse error, and you do not catch it (it gets thrown
   * from the parser), then this method is called during the printing
   * of the final stack trace, and hence the correct error message
   * gets displayed.
   */
  public String getMessage() {
    if (!specialConstructor) {
      return super.getMessage();
    }
    String expected = "";
    int maxSize = 0;
    for (int i = 0; i < expectedTokenSequences.length; i++) {
      if (maxSize < expectedTokenSequences[i].length) {
        maxSize = expectedTokenSequences[i].length;
      }
      for (int j = 0; j < expectedTokenSequences[i].length; j++) {
        expected += tokenImage[expectedTokenSequences[i][j]] + " ";
      }
      if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
        expected += "...";
      }
      expected += eol + "    ";
    }
    String retval = "Encountered \"";
    Token tok = currentToken.next;
    for (int i = 0; i < maxSize; i++) {
      if (i != 0) retval += " ";
      if (tok.kind == 0) {
        retval += tokenImage[0];
        break;
      }
      retval += add_escapes(tok.image);
      tok = tok.next; 
    }
    retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
    retval += "." + eol;
    if (expectedTokenSequences.length == 1) {
      retval += "Was expecting:" + eol + "    ";
    } else {
      retval += "Was expecting one of:" + eol + "    ";
    }
    retval += expected;
    return retval;
  }

  /**
   * The end of line string for this machine.
   */
  protected String eol = System.getProperty("line.separator", "\n");
 
  /**
   * Used to convert raw characters to their escaped version
   * when these raw version cannot be used as part of an ASCII
   * string literal.
   */
  protected String add_escapes(String str) {
      StringBuffer retval = new StringBuffer();
      char ch;
      for (int i = 0; i < str.length(); i++) {
        switch (str.charAt(i))
        {
           case 0 :
              continue;
           case '\b':
              retval.append("\\b");
              continue;
           case '\t':
              retval.append("\\t");
              continue;
           case '\n':
              retval.append("\\n");
              continue;
           case '\f':
              retval.append("\\f");
              continue;
           case '\r':
              retval.append("\\r");
              continue;
           case '\"':
              retval.append("\\\"");
              continue;
           case '\'':
              retval.append("\\\'");
              continue;
           case '\\':
              retval.append("\\\\");
              continue;
           default:
              if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
                 String s = "0000" + Integer.toString(ch, 16);
                 retval.append("\\u" + s.substring(s.length() - 4, s.length()));
              } else {
                 retval.append(ch);
              }
              continue;
        }
      }
      return retval.toString();
   }

}




/* Generated By:JavaCC: Do not edit this line. Token.java Version 3.0 */
/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */
package org.eclipse.uml2.diagram.common.parser.port;

/**
 * Describes the input token stream.
 */

public class Token {

  /**
   * An integer that describes the kind of this token.  This numbering
   * system is determined by JavaCCParser, and a table of these numbers is
   * stored in the file ...Constants.java.
   */
  public int kind;

  /**
   * beginLine and beginColumn describe the position of the first character
   * of this token; endLine and endColumn describe the position of the
   * last character of this token.
   */
  public int beginLine, beginColumn, endLine, endColumn;

  /**
   * The string image of the token.
   */
  public String image;

  /**
   * A reference to the next regular (non-special) token from the input
   * stream.  If this is the last token from the input stream, or if the
   * token manager has not read tokens beyond this one, this field is
   * set to null.  This is true only if this token is also a regular
   * token.  Otherwise, see below for a description of the contents of
   * this field.
   */
  public Token next;

  /**
   * This field is used to access special tokens that occur prior to this
   * token, but after the immediately preceding regular (non-special) token.
   * If there are no such special tokens, this field is set to null.
   * When there are more than one such special token, this field refers
   * to the last of these special tokens, which in turn refers to the next
   * previous special token through its specialToken field, and so on
   * until the first special token (whose specialToken field is null).
   * The next fields of special tokens refer to other special tokens that
   * immediately follow it (without an intervening regular token).  If there
   * is no such token, this field is null.
   */
  public Token specialToken;

  /**
   * Returns the image.
   */
  public String toString()
  {
     return image;
  }

  /**
   * Returns a new Token object, by default. However, if you want, you
   * can create and return subclass objects based on the value of ofKind.
   * Simply add the cases to the switch for all those special cases.
   * For example, if you have a subclass of Token called IDToken that
   * you want to create if ofKind is ID, simlpy add something like :
   *
   *    case MyParserConstants.ID : return new IDToken();
   *
   * to the following switch statement. Then you can cast matchedToken
   * variable to the appropriate type and use it in your lexical actions.
   */
  public static final Token newToken(int ofKind)
  {
     switch(ofKind)
     {
       default : return new Token();
     }
  }

}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.common.draw2d;

import java.util.List;

import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.StackLayout;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Rectangle;

public class CenterLayout extends StackLayout {
	private static final Rectangle RECTANGLE = new Rectangle();
	
	public void layout(IFigure figure) {
		Rectangle r = figure.getClientArea();
		final int centerX = r.x + r.width / 2;
		final int centerY = r.y + r.height / 2;
		List children = figure.getChildren();
		IFigure child;
		for (int i = 0; i < children.size(); i++) {
			child = (IFigure)children.get(i);
			Dimension prefSize = child.getPreferredSize();
			RECTANGLE.x = centerX - prefSize.width / 2;
			RECTANGLE.y = centerY - prefSize.height / 2;
			RECTANGLE.width = prefSize.width;
			RECTANGLE.height = prefSize.height;
			child.setBounds(RECTANGLE);
		}
	}
}




/* Generated By:JavaCC: Do not edit this line. PortParserConstants.java */
/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */
package org.eclipse.uml2.diagram.common.parser.port;

public interface PortParserConstants {

  int EOF = 0;
  int SLASH = 3;
  int COLON = 4;
  int EQUALS = 5;
  int LBRACKET = 6;
  int RBRACKET = 7;
  int LCURLY = 8;
  int RCURLY = 9;
  int COMMA = 10;
  int PLUS = 11;
  int MINUS = 12;
  int NUMBER_SIGN = 13;
  int TILDE = 14;
  int DOT = 15;
  int STAR = 16;
  int READ_ONLY = 17;
  int UNION = 18;
  int SUBSETS = 19;
  int REDEFINES = 20;
  int ORDERED = 21;
  int UNORDERED = 22;
  int UNIQUE = 23;
  int NON_UNIQUE = 24;
  int INTEGER_LITERAL = 25;
  int IDENTIFIER = 26;
  int LETTER = 27;
  int DIGIT = 28;

  int DEFAULT = 0;

  String[] tokenImage = {
    "<EOF>",
    "\" \"",
    "\"\\t\"",
    "\"/\"",
    "\":\"",
    "\"=\"",
    "\"[\"",
    "\"]\"",
    "\"{\"",
    "\"}\"",
    "\",\"",
    "\"+\"",
    "\"-\"",
    "\"#\"",
    "\"~\"",
    "\".\"",
    "\"*\"",
    "\"readOnly\"",
    "\"union\"",
    "\"subsets\"",
    "\"redefines\"",
    "\"ordered\"",
    "\"unordered\"",
    "\"unique\"",
    "\"nonunique\"",
    "<INTEGER_LITERAL>",
    "<IDENTIFIER>",
    "<LETTER>",
    "<DIGIT>",
  };

}




/* Generated By:JavaCC: Do not edit this line. PortParser.java */
/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */
package org.eclipse.uml2.diagram.common.parser.port;

import java.io.*;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.uml2.diagram.parser.*;
import org.eclipse.uml2.diagram.parser.lookup.LookupResolver;
import org.eclipse.uml2.diagram.parser.lookup.LookupSuite;
import org.eclipse.uml2.uml.*;

public class PortParser extends ExternalParserBase implements PortParserConstants {
        private Port mySubject;

    private static class TypeLookupCallback implements LookupResolver.Callback {
        private final Port myPort;

                public TypeLookupCallback(Port property){
                        myPort = property;
        }

        public void lookupResolved(NamedElement resolution) {
                if (resolution instanceof Type){
                        myPort.setType((Type)resolution);
                }
        }
    }

    public PortParser(){
        this(new StringReader(""));
    }

    public PortParser(LookupSuite lookup){
        this();
        setLookupSuite(lookup);
    }

        public EClass getSubjectClass(){
                return UMLPackage.eINSTANCE.getPort();
        }

        public void parse(EObject target, String text) throws ExternalParserException {
                checkContext();
                ReInit(new StringReader(text));
                mySubject = (Port)target;
                Declaration();
                mySubject = null;
        }

        protected static int parseInt(Token t) throws ParseException {
                if (t.kind != PortParserConstants.INTEGER_LITERAL){
                        throw new IllegalStateException("Token: " + t + ", image: " + t.image);
                }
                try {
                        return Integer.parseInt(t.image); //XXX: "0005", "99999999999999999999999"
                } catch (NumberFormatException e){
                        throw new ParseException("Not supported integer value:" + t.image);
                }
        }

  final public void Declaration() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PLUS:
    case MINUS:
    case NUMBER_SIGN:
    case TILDE:
      Visibility();
      break;
    default:
      jj_la1[0] = jj_gen;
      ;
    }
    PortName();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case COLON:
      PortType();
      break;
    default:
      jj_la1[1] = jj_gen;
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACKET:
      Multiplicity();
      break;
    default:
      jj_la1[2] = jj_gen;
      ;
    }
    jj_consume_token(0);
  }

  final public void PortName() throws ParseException {
        String name;
    name = NameWithSpaces();
                mySubject.setName(name);
  }

  final public void Visibility() throws ParseException {
        VisibilityKind kind;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PLUS:
      jj_consume_token(PLUS);
                         kind = VisibilityKind.PUBLIC_LITERAL;
      break;
    case MINUS:
      jj_consume_token(MINUS);
                          kind = VisibilityKind.PRIVATE_LITERAL;
      break;
    case NUMBER_SIGN:
      jj_consume_token(NUMBER_SIGN);
                                kind = VisibilityKind.PROTECTED_LITERAL;
      break;
    case TILDE:
      jj_consume_token(TILDE);
                          kind = VisibilityKind.PACKAGE_LITERAL;
      break;
    default:
      jj_la1[3] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
                mySubject.setVisibility(kind);
  }

  final public void Multiplicity() throws ParseException {
    MultiplicityRange();
  }

/* XXX: Parse conflict in case of empty default value
void MultiplicityDesignator() :
{ }
{
	<LCURLY> 
	(
		( MultiplicityUnique() [ MultiplicityOrdered() ] ) 
		|
		( MultiplicityOrdered() [ MultiplicityUnique() ] ) 
	) 
	<RCURLY>
}

void MultiplicityUnique() :
{}
{
		<UNIQUE> { mySubject.setIsUnique(true); }
	|
		<NON_UNIQUE> { mySubject.setIsUnique(false); }	
}

void MultiplicityOrdered() :
{}
{
		<ORDERED> { mySubject.setIsOrdered(true); }
	|
		<UNORDERED> { mySubject.setIsOrdered(false); }
}

*/

/* XXX: ValueSpecification -- how to parse */
  final public void MultiplicityRange() throws ParseException {
        Token tLower = null;
        Token tUpper;
    jj_consume_token(LBRACKET);
    if (jj_2_1(2)) {
      tLower = jj_consume_token(INTEGER_LITERAL);
      jj_consume_token(DOT);
      jj_consume_token(DOT);
                                                                        mySubject.setLower(parseInt(tLower));
    } else {
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STAR:
      tUpper = jj_consume_token(STAR);
                                if (tLower == null){
                                        mySubject.setLower(0);
                                }
                                mySubject.setUpper(LiteralUnlimitedNatural.UNLIMITED);
      break;
    case INTEGER_LITERAL:
      tUpper = jj_consume_token(INTEGER_LITERAL);
                                if (tLower == null){
                                        mySubject.setLower(parseInt(tUpper));
                                }
                                mySubject.setUpper(parseInt(tUpper));
      break;
    default:
      jj_la1[4] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    jj_consume_token(RBRACKET);
  }

  final public void PortType() throws ParseException {
        String type;
    jj_consume_token(COLON);
    type = NameWithSpaces();
                                          applyLookup(Type.class, type, new TypeLookupCallback(mySubject));
  }

  final public String NameWithSpaces() throws ParseException {
        StringBuffer result = new StringBuffer();
        Token t;
    t = jj_consume_token(IDENTIFIER);
                                   result.append(t.image);
    label_1:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IDENTIFIER:
        ;
        break;
      default:
        jj_la1[5] = jj_gen;
        break label_1;
      }
      t = jj_consume_token(IDENTIFIER);
                                     result.append(' '); result.append(t.image);
    }
                {if (true) return result.toString();}
    throw new Error("Missing return statement in function");
  }

  final private boolean jj_2_1(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_1(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(0, xla); }
  }

  final private boolean jj_3_1() {
    if (jj_scan_token(INTEGER_LITERAL)) return true;
    if (jj_scan_token(DOT)) return true;
    return false;
  }

  public PortParserTokenManager token_source;
  JavaCharStream jj_input_stream;
  public Token token, jj_nt;
  private int jj_ntk;
  private Token jj_scanpos, jj_lastpos;
  private int jj_la;
  public boolean lookingAhead = false;
  private boolean jj_semLA;
  private int jj_gen;
  final private int[] jj_la1 = new int[6];
  static private int[] jj_la1_0;
  static {
      jj_la1_0();
   }
   private static void jj_la1_0() {
      jj_la1_0 = new int[] {0x7800,0x10,0x40,0x7800,0x2010000,0x4000000,};
   }
  final private JJCalls[] jj_2_rtns = new JJCalls[1];
  private boolean jj_rescan = false;
  private int jj_gc = 0;

  public PortParser(java.io.InputStream stream) {
    jj_input_stream = new JavaCharStream(stream, 1, 1);
    token_source = new PortParserTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 6; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  public void ReInit(java.io.InputStream stream) {
    jj_input_stream.ReInit(stream, 1, 1);
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 6; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  public PortParser(java.io.Reader stream) {
    jj_input_stream = new JavaCharStream(stream, 1, 1);
    token_source = new PortParserTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 6; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  public void ReInit(java.io.Reader stream) {
    jj_input_stream.ReInit(stream, 1, 1);
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 6; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  public PortParser(PortParserTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 6; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  public void ReInit(PortParserTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 6; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  final private Token jj_consume_token(int kind) throws ParseException {
    Token oldToken;
    if ((oldToken = token).next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    if (token.kind == kind) {
      jj_gen++;
      if (++jj_gc > 100) {
        jj_gc = 0;
        for (int i = 0; i < jj_2_rtns.length; i++) {
          JJCalls c = jj_2_rtns[i];
          while (c != null) {
            if (c.gen < jj_gen) c.first = null;
            c = c.next;
          }
        }
      }
      return token;
    }
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }

  static private final class LookaheadSuccess extends java.lang.Error { }
  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
  final private boolean jj_scan_token(int kind) {
    if (jj_scanpos == jj_lastpos) {
      jj_la--;
      if (jj_scanpos.next == null) {
        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
      } else {
        jj_lastpos = jj_scanpos = jj_scanpos.next;
      }
    } else {
      jj_scanpos = jj_scanpos.next;
    }
    if (jj_rescan) {
      int i = 0; Token tok = token;
      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
      if (tok != null) jj_add_error_token(kind, i);
    }
    if (jj_scanpos.kind != kind) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    return false;
  }

  final public Token getNextToken() {
    if (token.next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    jj_gen++;
    return token;
  }

  final public Token getToken(int index) {
    Token t = lookingAhead ? jj_scanpos : token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  final private int jj_ntk() {
    if ((jj_nt=token.next) == null)
      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    else
      return (jj_ntk = jj_nt.kind);
  }

  private java.util.Vector jj_expentries = new java.util.Vector();
  private int[] jj_expentry;
  private int jj_kind = -1;
  private int[] jj_lasttokens = new int[100];
  private int jj_endpos;

  private void jj_add_error_token(int kind, int pos) {
    if (pos >= 100) return;
    if (pos == jj_endpos + 1) {
      jj_lasttokens[jj_endpos++] = kind;
    } else if (jj_endpos != 0) {
      jj_expentry = new int[jj_endpos];
      for (int i = 0; i < jj_endpos; i++) {
        jj_expentry[i] = jj_lasttokens[i];
      }
      boolean exists = false;
      for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
        int[] oldentry = (int[])(e.nextElement());
        if (oldentry.length == jj_expentry.length) {
          exists = true;
          for (int i = 0; i < jj_expentry.length; i++) {
            if (oldentry[i] != jj_expentry[i]) {
              exists = false;
              break;
            }
          }
          if (exists) break;
        }
      }
      if (!exists) jj_expentries.addElement(jj_expentry);
      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    }
  }

  public ParseException generateParseException() {
    jj_expentries.removeAllElements();
    boolean[] la1tokens = new boolean[29];
    for (int i = 0; i < 29; i++) {
      la1tokens[i] = false;
    }
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 6; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 29; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.addElement(jj_expentry);
      }
    }
    jj_endpos = 0;
    jj_rescan_token();
    jj_add_error_token(0, 0);
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = (int[])jj_expentries.elementAt(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

  final public void enable_tracing() {
  }

  final public void disable_tracing() {
  }

  final private void jj_rescan_token() {
    jj_rescan = true;
    for (int i = 0; i < 1; i++) {
      JJCalls p = jj_2_rtns[i];
      do {
        if (p.gen > jj_gen) {
          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
          switch (i) {
            case 0: jj_3_1(); break;
          }
        }
        p = p.next;
      } while (p != null);
    }
    jj_rescan = false;
  }

  final private void jj_save(int index, int xla) {
    JJCalls p = jj_2_rtns[index];
    while (p.gen > jj_gen) {
      if (p.next == null) { p = p.next = new JJCalls(); break; }
      p = p.next;
    }
    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
  }

  static final class JJCalls {
    int gen;
    Token first;
    int arg;
    JJCalls next;
  }

}




/* Generated By:JavaCC: Do not edit this line. JavaCharStream.java Version 3.0 */
/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */
package org.eclipse.uml2.diagram.common.parser.port;

/**
 * An implementation of interface CharStream, where the stream is assumed to
 * contain only ASCII characters (with java-like unicode escape processing).
 */

public class JavaCharStream
{
  public static final boolean staticFlag = false;
  static final int hexval(char c) throws java.io.IOException {
    switch(c)
    {
       case '0' :
          return 0;
       case '1' :
          return 1;
       case '2' :
          return 2;
       case '3' :
          return 3;
       case '4' :
          return 4;
       case '5' :
          return 5;
       case '6' :
          return 6;
       case '7' :
          return 7;
       case '8' :
          return 8;
       case '9' :
          return 9;

       case 'a' :
       case 'A' :
          return 10;
       case 'b' :
       case 'B' :
          return 11;
       case 'c' :
       case 'C' :
          return 12;
       case 'd' :
       case 'D' :
          return 13;
       case 'e' :
       case 'E' :
          return 14;
       case 'f' :
       case 'F' :
          return 15;
    }

    throw new java.io.IOException(); // Should never come here
  }

  public int bufpos = -1;
  int bufsize;
  int available;
  int tokenBegin;
  protected int bufline[];
  protected int bufcolumn[];

  protected int column = 0;
  protected int line = 1;

  protected boolean prevCharIsCR = false;
  protected boolean prevCharIsLF = false;

  protected java.io.Reader inputStream;

  protected char[] nextCharBuf;
  protected char[] buffer;
  protected int maxNextCharInd = 0;
  protected int nextCharInd = -1;
  protected int inBuf = 0;

  protected void ExpandBuff(boolean wrapAround)
  {
     char[] newbuffer = new char[bufsize + 2048];
     int newbufline[] = new int[bufsize + 2048];
     int newbufcolumn[] = new int[bufsize + 2048];

     try
     {
        if (wrapAround)
        {
           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
           System.arraycopy(buffer, 0, newbuffer,
                                             bufsize - tokenBegin, bufpos);
           buffer = newbuffer;

           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
           System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
           bufline = newbufline;

           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
           System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
           bufcolumn = newbufcolumn;

           bufpos += (bufsize - tokenBegin);
        }
        else
        {
           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
           buffer = newbuffer;

           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
           bufline = newbufline;

           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
           bufcolumn = newbufcolumn;

           bufpos -= tokenBegin;
        }
     }
     catch (Throwable t)
     {
        throw new Error(t.getMessage());
     }

     available = (bufsize += 2048);
     tokenBegin = 0;
  }

  protected void FillBuff() throws java.io.IOException
  {
     int i;
     if (maxNextCharInd == 4096)
        maxNextCharInd = nextCharInd = 0;

     try {
        if ((i = inputStream.read(nextCharBuf, maxNextCharInd,
                                            4096 - maxNextCharInd)) == -1)
        {
           inputStream.close();
           throw new java.io.IOException();
        }
        else
           maxNextCharInd += i;
        return;
     }
     catch(java.io.IOException e) {
        if (bufpos != 0)
        {
           --bufpos;
           backup(0);
        }
        else
        {
           bufline[bufpos] = line;
           bufcolumn[bufpos] = column;
        }
        throw e;
     }
  }

  protected char ReadByte() throws java.io.IOException
  {
     if (++nextCharInd >= maxNextCharInd)
        FillBuff();

     return nextCharBuf[nextCharInd];
  }

  public char BeginToken() throws java.io.IOException
  {     
     if (inBuf > 0)
     {
        --inBuf;

        if (++bufpos == bufsize)
           bufpos = 0;

        tokenBegin = bufpos;
        return buffer[bufpos];
     }

     tokenBegin = 0;
     bufpos = -1;

     return readChar();
  }     

  protected void AdjustBuffSize()
  {
     if (available == bufsize)
     {
        if (tokenBegin > 2048)
        {
           bufpos = 0;
           available = tokenBegin;
        }
        else
           ExpandBuff(false);
     }
     else if (available > tokenBegin)
        available = bufsize;
     else if ((tokenBegin - available) < 2048)
        ExpandBuff(true);
     else
        available = tokenBegin;
  }

  protected void UpdateLineColumn(char c)
  {
     column++;

     if (prevCharIsLF)
     {
        prevCharIsLF = false;
        line += (column = 1);
     }
     else if (prevCharIsCR)
     {
        prevCharIsCR = false;
        if (c == '\n')
        {
           prevCharIsLF = true;
        }
        else
           line += (column = 1);
     }

     switch (c)
     {
        case '\r' :
           prevCharIsCR = true;
           break;
        case '\n' :
           prevCharIsLF = true;
           break;
        case '\t' :
           column--;
           column += (8 - (column & 07));
           break;
        default :
           break;
     }

     bufline[bufpos] = line;
     bufcolumn[bufpos] = column;
  }

  public char readChar() throws java.io.IOException
  {
     if (inBuf > 0)
     {
        --inBuf;

        if (++bufpos == bufsize)
           bufpos = 0;

        return buffer[bufpos];
     }

     char c;

     if (++bufpos == available)
        AdjustBuffSize();

     if ((buffer[bufpos] = c = ReadByte()) == '\\')
     {
        UpdateLineColumn(c);

        int backSlashCnt = 1;

        for (;;) // Read all the backslashes
        {
           if (++bufpos == available)
              AdjustBuffSize();

           try
           {
              if ((buffer[bufpos] = c = ReadByte()) != '\\')
              {
                 UpdateLineColumn(c);
                 // found a non-backslash char.
                 if ((c == 'u') && ((backSlashCnt & 1) == 1))
                 {
                    if (--bufpos < 0)
                       bufpos = bufsize - 1;

                    break;
                 }

                 backup(backSlashCnt);
                 return '\\';
              }
           }
           catch(java.io.IOException e)
           {
              if (backSlashCnt > 1)
                 backup(backSlashCnt);

              return '\\';
           }

           UpdateLineColumn(c);
           backSlashCnt++;
        }

        // Here, we have seen an odd number of backslash's followed by a 'u'
        try
        {
           while ((c = ReadByte()) == 'u')
              ++column;

           buffer[bufpos] = c = (char)(hexval(c) << 12 |
                                       hexval(ReadByte()) << 8 |
                                       hexval(ReadByte()) << 4 |
                                       hexval(ReadByte()));

           column += 4;
        }
        catch(java.io.IOException e)
        {
           throw new Error("Invalid escape character at line " + line +
                                         " column " + column + ".");
        }

        if (backSlashCnt == 1)
           return c;
        else
        {
           backup(backSlashCnt - 1);
           return '\\';
        }
     }
     else
     {
        UpdateLineColumn(c);
        return (c);
     }
  }

  /**
   * @deprecated 
   * @see #getEndColumn
   */

  public int getColumn() {
     return bufcolumn[bufpos];
  }

  /**
   * @deprecated 
   * @see #getEndLine
   */

  public int getLine() {
     return bufline[bufpos];
  }

  public int getEndColumn() {
     return bufcolumn[bufpos];
  }

  public int getEndLine() {
     return bufline[bufpos];
  }

  public int getBeginColumn() {
     return bufcolumn[tokenBegin];
  }

  public int getBeginLine() {
     return bufline[tokenBegin];
  }

  public void backup(int amount) {

    inBuf += amount;
    if ((bufpos -= amount) < 0)
       bufpos += bufsize;
  }

  public JavaCharStream(java.io.Reader dstream,
                 int startline, int startcolumn, int buffersize)
  {
    inputStream = dstream;
    line = startline;
    column = startcolumn - 1;

    available = bufsize = buffersize;
    buffer = new char[buffersize];
    bufline = new int[buffersize];
    bufcolumn = new int[buffersize];
    nextCharBuf = new char[4096];
  }

  public JavaCharStream(java.io.Reader dstream,
                                        int startline, int startcolumn)
  {
     this(dstream, startline, startcolumn, 4096);
  }

  public JavaCharStream(java.io.Reader dstream)
  {
     this(dstream, 1, 1, 4096);
  }
  public void ReInit(java.io.Reader dstream,
                 int startline, int startcolumn, int buffersize)
  {
    inputStream = dstream;
    line = startline;
    column = startcolumn - 1;

    if (buffer == null || buffersize != buffer.length)
    {
      available = bufsize = buffersize;
      buffer = new char[buffersize];
      bufline = new int[buffersize];
      bufcolumn = new int[buffersize];
      nextCharBuf = new char[4096];
    }
    prevCharIsLF = prevCharIsCR = false;
    tokenBegin = inBuf = maxNextCharInd = 0;
    nextCharInd = bufpos = -1;
  }

  public void ReInit(java.io.Reader dstream,
                                        int startline, int startcolumn)
  {
     ReInit(dstream, startline, startcolumn, 4096);
  }

  public void ReInit(java.io.Reader dstream)
  {
     ReInit(dstream, 1, 1, 4096);
  }
  public JavaCharStream(java.io.InputStream dstream, int startline,
  int startcolumn, int buffersize)
  {
     this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
  }

  public JavaCharStream(java.io.InputStream dstream, int startline,
                                                           int startcolumn)
  {
     this(dstream, startline, startcolumn, 4096);
  }

  public JavaCharStream(java.io.InputStream dstream)
  {
     this(dstream, 1, 1, 4096);
  }

  public void ReInit(java.io.InputStream dstream, int startline,
  int startcolumn, int buffersize)
  {
     ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
  }
  public void ReInit(java.io.InputStream dstream, int startline,
                                                           int startcolumn)
  {
     ReInit(dstream, startline, startcolumn, 4096);
  }
  public void ReInit(java.io.InputStream dstream)
  {
     ReInit(dstream, 1, 1, 4096);
  }

  public String GetImage()
  {
     if (bufpos >= tokenBegin)
        return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
     else
        return new String(buffer, tokenBegin, bufsize - tokenBegin) +
                              new String(buffer, 0, bufpos + 1);
  }

  public char[] GetSuffix(int len)
  {
     char[] ret = new char[len];

     if ((bufpos + 1) >= len)
        System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
     else
     {
        System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
                                                          len - bufpos - 1);
        System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
     }

     return ret;
  }

  public void Done()
  {
     nextCharBuf = null;
     buffer = null;
     bufline = null;
     bufcolumn = null;
  }

  /**
   * Method to adjust line and column numbers for the start of a token.
   */
  public void adjustBeginLineColumn(int newLine, int newCol)
  {
     int start = tokenBegin;
     int len;

     if (bufpos >= tokenBegin)
     {
        len = bufpos - tokenBegin + inBuf + 1;
     }
     else
     {
        len = bufsize - tokenBegin + bufpos + 1 + inBuf;
     }

     int i = 0, j = 0, k = 0;
     int nextColDiff = 0, columnDiff = 0;

     while (i < len &&
            bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
     {
        bufline[j] = newLine;
        nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
        bufcolumn[j] = newCol + columnDiff;
        columnDiff = nextColDiff;
        i++;
     } 

     if (i < len)
     {
        bufline[j] = newLine++;
        bufcolumn[j] = newCol + columnDiff;

        while (i++ < len)
        {
           if (bufline[j = start % bufsize] != bufline[++start % bufsize])
              bufline[j] = newLine++;
           else
              bufline[j] = newLine;
        }
     }

     line = bufline[j];
     column = bufcolumn[j];
  }

}




Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: UML Diagram Commons Plug-in
Bundle-SymbolicName: org.eclipse.uml2.diagram.common
Bundle-Version: 1.0.0
Bundle-Localization: plugin
Require-Bundle: org.eclipse.core.runtime,
 org.eclipse.core.resources,
 org.eclipse.uml2.uml;visibility:=reexport,
 org.eclipse.uml2.uml.edit;visibility:=reexport,
 org.eclipse.emf.ecore;visibility:=reexport,
 org.eclipse.emf.ecore.edit;visibility:=reexport,
 org.eclipse.emf.query.ocl;visibility:=reexport,
 org.eclipse.emf.ocl;visibility:=reexport,
 org.eclipse.gmf.runtime.draw2d.ui;visibility:=reexport,
 org.eclipse.draw2d;visibility:=reexport,
 org.eclipse.uml2.diagram.parser
Export-Package: org.eclipse.gmf.internal.codegen.draw2d,
 org.eclipse.uml2.diagram.common.draw2d,
 org.eclipse.uml2.diagram.common.parser.port;x-friends:="org.eclipse.uml2.diagram.clazz,org.eclipse.uml2.diagram.component"




options {
  JAVA_UNICODE_ESCAPE = true;
  STATIC=false;
}

PARSER_BEGIN(PortParser)

/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */
package org.eclipse.uml2.diagram.common.parser.port;

import java.io.*;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.uml2.diagram.parser.*;
import org.eclipse.uml2.diagram.parser.lookup.LookupSuite;
import org.eclipse.uml2.diagram.parser.lookup.LookupResolver;
import org.eclipse.uml2.uml.*;

public class PortParser extends ExternalParserBase {
	private Port mySubject;
	
    private static class TypeLookupCallback implements LookupResolver.Callback {
    	private final Port myPort;

		public TypeLookupCallback(Port property){
			myPort = property;
    	}
    	
    	public void lookupResolved(NamedElement resolution) {
    		if (resolution instanceof Type){
    			myPort.setType((Type)resolution);
    		}
    	}
    }

    public PortParser(){
    	this(new StringReader(""));
    }
    
    public PortParser(LookupSuite lookup){
    	this();
    	setLookupSuite(lookup);
    }

	public EClass getSubjectClass(){
		return UMLPackage.eINSTANCE.getPort();
	}
	
	public void parse(EObject target, String text) throws ExternalParserException {
		checkContext();
		ReInit(new StringReader(text));
		mySubject = (Port)target;
		Declaration();
		mySubject = null;
	}
	
	protected static int parseInt(Token t) throws ParseException {
		if (t.kind != PortParserConstants.INTEGER_LITERAL){
			throw new IllegalStateException("Token: " + t + ", image: " + t.image);
		}
		try {
			return Integer.parseInt(t.image); //XXX: "0005", "99999999999999999999999"
		} catch (NumberFormatException e){
			throw new ParseException("Not supported integer value:" + t.image);
		}
	}
	
}

PARSER_END(PortParser)

/* WHITE SPACE */

SPECIAL_TOKEN :
{
  " "
| "\t"
}

/* SEPARATORS */
TOKEN :
{
	< SLASH: "/" >
|	< COLON: ":" >
|	< EQUALS: "=" >
|	< LBRACKET: "[" >
|	< RBRACKET: "]" >
|	< LCURLY: "{" >
|	< RCURLY: "}" >
|	< COMMA: "," >
}

/* SPECIAL_MEANING */
TOKEN :
{
	< PLUS: "+" >
|	< MINUS: "-" >
|	< NUMBER_SIGN: "#" >
|	< TILDE: "~" >
|	< DOT: "." >
|	< STAR: "*" >
}

/* MODIFIERS */
TOKEN :
{
	< READ_ONLY: "readOnly" >
|	< UNION: "union" >
|	< SUBSETS: "subsets" >
|	< REDEFINES: "redefines" >
|	< ORDERED: "ordered" >
|	< UNORDERED: "unordered" > 
|	< UNIQUE: "unique" >
|	< NON_UNIQUE: "nonunique" >
}
	
/* LITERALS */
TOKEN: 
{
	< INTEGER_LITERAL: ["0"-"9"] (["0"-"9"])* >
}
  
TOKEN :
{
  < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* >
|
  < #LETTER:
      [
       "\u0024",
       "\u0041"-"\u005a",
       "\u005f",
       "\u0061"-"\u007a",
       "\u00c0"-"\u00d6",
       "\u00d8"-"\u00f6",
       "\u00f8"-"\u00ff",
       "\u0100"-"\u1fff",
       "\u3040"-"\u318f",
       "\u3300"-"\u337f",
       "\u3400"-"\u3d2d",
       "\u4e00"-"\u9fff",
       "\uf900"-"\ufaff"
      ]
  >
|
  < #DIGIT:
      [
       "\u0030"-"\u0039",
       "\u0660"-"\u0669",
       "\u06f0"-"\u06f9",
       "\u0966"-"\u096f",
       "\u09e6"-"\u09ef",
       "\u0a66"-"\u0a6f",
       "\u0ae6"-"\u0aef",
       "\u0b66"-"\u0b6f",
       "\u0be7"-"\u0bef",
       "\u0c66"-"\u0c6f",
       "\u0ce6"-"\u0cef",
       "\u0d66"-"\u0d6f",
       "\u0e50"-"\u0e59",
       "\u0ed0"-"\u0ed9",
       "\u1040"-"\u1049"
      ]
  >
}

void Declaration() :
{}
{
	(
		[ Visibility() ]
		PortName()
		[ PortType() ]
		[ Multiplicity() ]
	) <EOF>
}

void PortName() :
{
	String name;
}
{
	name = NameWithSpaces() 
	{
		mySubject.setName(name);
	}
}

void Visibility() :
{ 
	VisibilityKind kind;
}
{
	(
		<PLUS> { kind = VisibilityKind.PUBLIC_LITERAL; }
	|
		<MINUS> { kind = VisibilityKind.PRIVATE_LITERAL; }
	|
		<NUMBER_SIGN> { kind = VisibilityKind.PROTECTED_LITERAL; }
	|
		<TILDE> { kind = VisibilityKind.PACKAGE_LITERAL; }
	)
	{
		mySubject.setVisibility(kind);
	}
}

void Multiplicity() :
{}
{
	MultiplicityRange() 
	/* XXX: Parse conflict in case of empty DefaultValue, consider "a:int[5]{unique}"  
	[ MultiplicityDesignator() ] 
	*/
}

/* XXX: Parse conflict in case of empty default value
void MultiplicityDesignator() :
{ }
{
	<LCURLY> 
	(
		( MultiplicityUnique() [ MultiplicityOrdered() ] ) 
		|
		( MultiplicityOrdered() [ MultiplicityUnique() ] ) 
	) 
	<RCURLY>
}

void MultiplicityUnique() :
{}
{
		<UNIQUE> { mySubject.setIsUnique(true); }
	|
		<NON_UNIQUE> { mySubject.setIsUnique(false); }	
}

void MultiplicityOrdered() :
{}
{
		<ORDERED> { mySubject.setIsOrdered(true); }
	|
		<UNORDERED> { mySubject.setIsOrdered(false); }
}

*/

/* XXX: ValueSpecification -- how to parse */
void MultiplicityRange() :
{
	Token tLower = null;
	Token tUpper;
}
{
	<LBRACKET>
	(
		[ LOOKAHEAD(2) tLower = <INTEGER_LITERAL> <DOT> <DOT> { mySubject.setLower(parseInt(tLower)); } ] 
		(
			tUpper = <STAR> 
			{ 
				if (tLower == null){
					mySubject.setLower(0);
				}
				mySubject.setUpper(LiteralUnlimitedNatural.UNLIMITED); 
			}
		| 
			tUpper = <INTEGER_LITERAL> 
			{ 
				if (tLower == null){
					mySubject.setLower(parseInt(tUpper));
				}
				mySubject.setUpper(parseInt(tUpper)); 
			}
		)
	)
	<RBRACKET>
}

void PortType() :
{
	String type;
}
{
	<COLON> type = NameWithSpaces() { applyLookup(Type.class, type, new TypeLookupCallback(mySubject)); }
}

String NameWithSpaces() :
{
	StringBuffer result = new StringBuffer();
	Token t;
}
{
	(
		t = <IDENTIFIER> { result.append(t.image); } 
		( t = <IDENTIFIER> { result.append(' '); result.append(t.image); } ) *
	)
	{
		return result.toString();
	}
}





/* Generated By:JavaCC: Do not edit this line. PortParserTokenManager.java */
/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */
package org.eclipse.uml2.diagram.common.parser.port;
import java.io.*;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.uml2.diagram.parser.*;
import org.eclipse.uml2.diagram.parser.lookup.LookupResolver;
import org.eclipse.uml2.diagram.parser.lookup.LookupSuite;
import org.eclipse.uml2.uml.*;

public class PortParserTokenManager implements PortParserConstants
{
  public  java.io.PrintStream debugStream = System.out;
  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
private final int jjStopStringLiteralDfa_0(int pos, long active0)
{
   switch (pos)
   {
      case 0:
         if ((active0 & 0x1fe0000L) != 0L)
         {
            jjmatchedKind = 26;
            return 2;
         }
         return -1;
      case 1:
         if ((active0 & 0x1fe0000L) != 0L)
         {
            jjmatchedKind = 26;
            jjmatchedPos = 1;
            return 2;
         }
         return -1;
      case 2:
         if ((active0 & 0x1fe0000L) != 0L)
         {
            jjmatchedKind = 26;
            jjmatchedPos = 2;
            return 2;
         }
         return -1;
      case 3:
         if ((active0 & 0x1fe0000L) != 0L)
         {
            jjmatchedKind = 26;
            jjmatchedPos = 3;
            return 2;
         }
         return -1;
      case 4:
         if ((active0 & 0x40000L) != 0L)
            return 2;
         if ((active0 & 0x1fa0000L) != 0L)
         {
            jjmatchedKind = 26;
            jjmatchedPos = 4;
            return 2;
         }
         return -1;
      case 5:
         if ((active0 & 0x800000L) != 0L)
            return 2;
         if ((active0 & 0x17a0000L) != 0L)
         {
            jjmatchedKind = 26;
            jjmatchedPos = 5;
            return 2;
         }
         return -1;
      case 6:
         if ((active0 & 0x280000L) != 0L)
            return 2;
         if ((active0 & 0x1520000L) != 0L)
         {
            jjmatchedKind = 26;
            jjmatchedPos = 6;
            return 2;
         }
         return -1;
      case 7:
         if ((active0 & 0x20000L) != 0L)
            return 2;
         if ((active0 & 0x1500000L) != 0L)
         {
            jjmatchedKind = 26;
            jjmatchedPos = 7;
            return 2;
         }
         return -1;
      default :
         return -1;
   }
}
private final int jjStartNfa_0(int pos, long active0)
{
   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
}
private final int jjStopAtPos(int pos, int kind)
{
   jjmatchedKind = kind;
   jjmatchedPos = pos;
   return pos + 1;
}
private final int jjStartNfaWithStates_0(int pos, int kind, int state)
{
   jjmatchedKind = kind;
   jjmatchedPos = pos;
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) { return pos + 1; }
   return jjMoveNfa_0(state, pos + 1);
}
private final int jjMoveStringLiteralDfa0_0()
{
   switch(curChar)
   {
      case 9:
         return jjStopAtPos(0, 2);
      case 32:
         return jjStopAtPos(0, 1);
      case 35:
         return jjStopAtPos(0, 13);
      case 42:
         return jjStopAtPos(0, 16);
      case 43:
         return jjStopAtPos(0, 11);
      case 44:
         return jjStopAtPos(0, 10);
      case 45:
         return jjStopAtPos(0, 12);
      case 46:
         return jjStopAtPos(0, 15);
      case 47:
         return jjStopAtPos(0, 3);
      case 58:
         return jjStopAtPos(0, 4);
      case 61:
         return jjStopAtPos(0, 5);
      case 91:
         return jjStopAtPos(0, 6);
      case 93:
         return jjStopAtPos(0, 7);
      case 110:
         return jjMoveStringLiteralDfa1_0(0x1000000L);
      case 111:
         return jjMoveStringLiteralDfa1_0(0x200000L);
      case 114:
         return jjMoveStringLiteralDfa1_0(0x120000L);
      case 115:
         return jjMoveStringLiteralDfa1_0(0x80000L);
      case 117:
         return jjMoveStringLiteralDfa1_0(0xc40000L);
      case 123:
         return jjStopAtPos(0, 8);
      case 125:
         return jjStopAtPos(0, 9);
      case 126:
         return jjStopAtPos(0, 14);
      default :
         return jjMoveNfa_0(1, 0);
   }
}
private final int jjMoveStringLiteralDfa1_0(long active0)
{
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(0, active0);
      return 1;
   }
   switch(curChar)
   {
      case 101:
         return jjMoveStringLiteralDfa2_0(active0, 0x120000L);
      case 110:
         return jjMoveStringLiteralDfa2_0(active0, 0xc40000L);
      case 111:
         return jjMoveStringLiteralDfa2_0(active0, 0x1000000L);
      case 114:
         return jjMoveStringLiteralDfa2_0(active0, 0x200000L);
      case 117:
         return jjMoveStringLiteralDfa2_0(active0, 0x80000L);
      default :
         break;
   }
   return jjStartNfa_0(0, active0);
}
private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(0, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(1, active0);
      return 2;
   }
   switch(curChar)
   {
      case 97:
         return jjMoveStringLiteralDfa3_0(active0, 0x20000L);
      case 98:
         return jjMoveStringLiteralDfa3_0(active0, 0x80000L);
      case 100:
         return jjMoveStringLiteralDfa3_0(active0, 0x300000L);
      case 105:
         return jjMoveStringLiteralDfa3_0(active0, 0x840000L);
      case 110:
         return jjMoveStringLiteralDfa3_0(active0, 0x1000000L);
      case 111:
         return jjMoveStringLiteralDfa3_0(active0, 0x400000L);
      default :
         break;
   }
   return jjStartNfa_0(1, active0);
}
private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(1, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(2, active0);
      return 3;
   }
   switch(curChar)
   {
      case 100:
         return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
      case 101:
         return jjMoveStringLiteralDfa4_0(active0, 0x300000L);
      case 111:
         return jjMoveStringLiteralDfa4_0(active0, 0x40000L);
      case 113:
         return jjMoveStringLiteralDfa4_0(active0, 0x800000L);
      case 114:
         return jjMoveStringLiteralDfa4_0(active0, 0x400000L);
      case 115:
         return jjMoveStringLiteralDfa4_0(active0, 0x80000L);
      case 117:
         return jjMoveStringLiteralDfa4_0(active0, 0x1000000L);
      default :
         break;
   }
   return jjStartNfa_0(2, active0);
}
private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(2, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(3, active0);
      return 4;
   }
   switch(curChar)
   {
      case 79:
         return jjMoveStringLiteralDfa5_0(active0, 0x20000L);
      case 100:
         return jjMoveStringLiteralDfa5_0(active0, 0x400000L);
      case 101:
         return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
      case 102:
         return jjMoveStringLiteralDfa5_0(active0, 0x100000L);
      case 110:
         if ((active0 & 0x40000L) != 0L)
            return jjStartNfaWithStates_0(4, 18, 2);
         return jjMoveStringLiteralDfa5_0(active0, 0x1000000L);
      case 114:
         return jjMoveStringLiteralDfa5_0(active0, 0x200000L);
      case 117:
         return jjMoveStringLiteralDfa5_0(active0, 0x800000L);
      default :
         break;
   }
   return jjStartNfa_0(3, active0);
}
private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(3, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(4, active0);
      return 5;
   }
   switch(curChar)
   {
      case 101:
         if ((active0 & 0x800000L) != 0L)
            return jjStartNfaWithStates_0(5, 23, 2);
         return jjMoveStringLiteralDfa6_0(active0, 0x600000L);
      case 105:
         return jjMoveStringLiteralDfa6_0(active0, 0x1100000L);
      case 110:
         return jjMoveStringLiteralDfa6_0(active0, 0x20000L);
      case 116:
         return jjMoveStringLiteralDfa6_0(active0, 0x80000L);
      default :
         break;
   }
   return jjStartNfa_0(4, active0);
}
private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(4, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(5, active0);
      return 6;
   }
   switch(curChar)
   {
      case 100:
         if ((active0 & 0x200000L) != 0L)
            return jjStartNfaWithStates_0(6, 21, 2);
         break;
      case 108:
         return jjMoveStringLiteralDfa7_0(active0, 0x20000L);
      case 110:
         return jjMoveStringLiteralDfa7_0(active0, 0x100000L);
      case 113:
         return jjMoveStringLiteralDfa7_0(active0, 0x1000000L);
      case 114:
         return jjMoveStringLiteralDfa7_0(active0, 0x400000L);
      case 115:
         if ((active0 & 0x80000L) != 0L)
            return jjStartNfaWithStates_0(6, 19, 2);
         break;
      default :
         break;
   }
   return jjStartNfa_0(5, active0);
}
private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(5, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(6, active0);
      return 7;
   }
   switch(curChar)
   {
      case 101:
         return jjMoveStringLiteralDfa8_0(active0, 0x500000L);
      case 117:
         return jjMoveStringLiteralDfa8_0(active0, 0x1000000L);
      case 121:
         if ((active0 & 0x20000L) != 0L)
            return jjStartNfaWithStates_0(7, 17, 2);
         break;
      default :
         break;
   }
   return jjStartNfa_0(6, active0);
}
private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(6, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(7, active0);
      return 8;
   }
   switch(curChar)
   {
      case 100:
         if ((active0 & 0x400000L) != 0L)
            return jjStartNfaWithStates_0(8, 22, 2);
         break;
      case 101:
         if ((active0 & 0x1000000L) != 0L)
            return jjStartNfaWithStates_0(8, 24, 2);
         break;
      case 115:
         if ((active0 & 0x100000L) != 0L)
            return jjStartNfaWithStates_0(8, 20, 2);
         break;
      default :
         break;
   }
   return jjStartNfa_0(7, active0);
}
private final void jjCheckNAdd(int state)
{
   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
}
private final void jjAddStates(int start, int end)
{
   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
}
private final void jjCheckNAddTwoStates(int state1, int state2)
{
   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
}
private final void jjCheckNAddStates(int start, int end)
{
   do {
      jjCheckNAdd(jjnextStates[start]);
   } while (start++ != end);
}
private final void jjCheckNAddStates(int start)
{
   jjCheckNAdd(jjnextStates[start]);
   jjCheckNAdd(jjnextStates[start + 1]);
}
static final long[] jjbitVec0 = {
   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
};
static final long[] jjbitVec2 = {
   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
};
static final long[] jjbitVec3 = {
   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
};
static final long[] jjbitVec4 = {
   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
};
static final long[] jjbitVec5 = {
   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
};
static final long[] jjbitVec6 = {
   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
};
private final int jjMoveNfa_0(int startState, int curPos)
{
   int[] nextStates;
   int startsAt = 0;
   jjnewStateCnt = 3;
   int i = 1;
   jjstateSet[0] = startState;
   int j, kind = 0x7fffffff;
   for (;;)
   {
      if (++jjround == 0x7fffffff)
         ReInitRounds();
      if (curChar < 64)
      {
         long l = 1L << curChar;
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 1:
                  if ((0x3ff000000000000L & l) != 0L)
                  {
                     if (kind > 25)
                        kind = 25;
                     jjCheckNAdd(0);
                  }
                  else if (curChar == 36)
                  {
                     if (kind > 26)
                        kind = 26;
                     jjCheckNAdd(2);
                  }
                  break;
               case 0:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 25)
                     kind = 25;
                  jjCheckNAdd(0);
                  break;
               case 2:
                  if ((0x3ff001000000000L & l) == 0L)
                     break;
                  if (kind > 26)
                     kind = 26;
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 1:
               case 2:
                  if ((0x7fffffe87fffffeL & l) == 0L)
                     break;
                  if (kind > 26)
                     kind = 26;
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 1:
               case 2:
                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 26)
                     kind = 26;
                  jjCheckNAdd(2);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
}
static final int[] jjnextStates = {
};
private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
{
   switch(hiByte)
   {
      case 0:
         return ((jjbitVec2[i2] & l2) != 0L);
      case 48:
         return ((jjbitVec3[i2] & l2) != 0L);
      case 49:
         return ((jjbitVec4[i2] & l2) != 0L);
      case 51:
         return ((jjbitVec5[i2] & l2) != 0L);
      case 61:
         return ((jjbitVec6[i2] & l2) != 0L);
      default : 
         if ((jjbitVec0[i1] & l1) != 0L)
            return true;
         return false;
   }
}
public static final String[] jjstrLiteralImages = {
"", null, null, "\57", "\72", "\75", "\133", "\135", "\173", "\175", "\54", 
"\53", "\55", "\43", "\176", "\56", "\52", "\162\145\141\144\117\156\154\171", 
"\165\156\151\157\156", "\163\165\142\163\145\164\163", "\162\145\144\145\146\151\156\145\163", 
"\157\162\144\145\162\145\144", "\165\156\157\162\144\145\162\145\144", "\165\156\151\161\165\145", 
"\156\157\156\165\156\151\161\165\145", null, null, null, null, };
public static final String[] lexStateNames = {
   "DEFAULT", 
};
static final long[] jjtoToken = {
   0x7fffff9L, 
};
static final long[] jjtoSkip = {
   0x6L, 
};
static final long[] jjtoSpecial = {
   0x6L, 
};
protected JavaCharStream input_stream;
private final int[] jjrounds = new int[3];
private final int[] jjstateSet = new int[6];
protected char curChar;
public PortParserTokenManager(JavaCharStream stream)
{
   if (JavaCharStream.staticFlag)
      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
   input_stream = stream;
}
public PortParserTokenManager(JavaCharStream stream, int lexState)
{
   this(stream);
   SwitchTo(lexState);
}
public void ReInit(JavaCharStream stream)
{
   jjmatchedPos = jjnewStateCnt = 0;
   curLexState = defaultLexState;
   input_stream = stream;
   ReInitRounds();
}
private final void ReInitRounds()
{
   int i;
   jjround = 0x80000001;
   for (i = 3; i-- > 0;)
      jjrounds[i] = 0x80000000;
}
public void ReInit(JavaCharStream stream, int lexState)
{
   ReInit(stream);
   SwitchTo(lexState);
}
public void SwitchTo(int lexState)
{
   if (lexState >= 1 || lexState < 0)
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
   else
      curLexState = lexState;
}

protected Token jjFillToken()
{
   Token t = Token.newToken(jjmatchedKind);
   t.kind = jjmatchedKind;
   String im = jjstrLiteralImages[jjmatchedKind];
   t.image = (im == null) ? input_stream.GetImage() : im;
   t.beginLine = input_stream.getBeginLine();
   t.beginColumn = input_stream.getBeginColumn();
   t.endLine = input_stream.getEndLine();
   t.endColumn = input_stream.getEndColumn();
   return t;
}

int curLexState = 0;
int defaultLexState = 0;
int jjnewStateCnt;
int jjround;
int jjmatchedPos;
int jjmatchedKind;

public Token getNextToken() 
{
  int kind;
  Token specialToken = null;
  Token matchedToken;
  int curPos = 0;

  EOFLoop :
  for (;;)
  {   
   try   
   {     
      curChar = input_stream.BeginToken();
   }     
   catch(java.io.IOException e)
   {        
      jjmatchedKind = 0;
      matchedToken = jjFillToken();
      matchedToken.specialToken = specialToken;
      return matchedToken;
   }

   jjmatchedKind = 0x7fffffff;
   jjmatchedPos = 0;
   curPos = jjMoveStringLiteralDfa0_0();
   if (jjmatchedKind != 0x7fffffff)
   {
      if (jjmatchedPos + 1 < curPos)
         input_stream.backup(curPos - jjmatchedPos - 1);
      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
      {
         matchedToken = jjFillToken();
         matchedToken.specialToken = specialToken;
         return matchedToken;
      }
      else
      {
         if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
         {
            matchedToken = jjFillToken();
            if (specialToken == null)
               specialToken = matchedToken;
            else
            {
               matchedToken.specialToken = specialToken;
               specialToken = (specialToken.next = matchedToken);
            }
         }
         continue EOFLoop;
      }
   }
   int error_line = input_stream.getEndLine();
   int error_column = input_stream.getEndColumn();
   String error_after = null;
   boolean EOFSeen = false;
   try { input_stream.readChar(); input_stream.backup(1); }
   catch (java.io.IOException e1) {
      EOFSeen = true;
      error_after = curPos <= 1 ? "" : input_stream.GetImage();
      if (curChar == '\n' || curChar == '\r') {
         error_line++;
         error_column = 0;
      }
      else
         error_column++;
   }
   if (!EOFSeen) {
      input_stream.backup(1);
      error_after = curPos <= 1 ? "" : input_stream.GetImage();
   }
   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
  }
}

}

Added Link Here

(-).classpath (+7 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>
3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
6	<classpathentry kind="output" path="bin"/>
7	</classpath>

Added Link Here

(-).cvsignore (+2 lines)
1	bin
2	.settings




package org.eclipse.gmf.internal.codegen.draw2d;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.draw2d.AbstractLayout;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.LayoutManager;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.swt.SWT;


/**
 * Lays out children into a Grid arrangement in which overall aligment and
 * spacing can be configured, as well as specfic layout requirements for the
 * each individual member of the GridLayout. This layout is a Draw2D port of the
 * swt GridLayout.
 * 
 * <code>GridLayout</code> has a number of configuration fields, and the
 * Figures it lays out can have an associated layout data object, called
 * <code>GridLayoutData</code> (similar to the swt GridLayoutData object). The power of
 * <code>GridLayout</code> lies in the ability to configure
 * <code>GridLayoutData</code> for each Figure in the layout.
 * <p>
 * The following code creates a container Figure managed by a
 * <code>GridLayout</code> with 2 columns, containing 3 RectangleFigure
 * shapes, the last of which has been given further layout instructions.
 * Note that it is the <code>GridLayout</code> method <code>setConstraint</code>
 * that binds the child <code>Figure</code> to its layout <code>GridLayoutData</code> object.
 * 
 * <pre>
 *     Figure container = new Figure();
 *     GridLayout gridLayout = new GridLayout();
 *     gridLayout.numColumns = 2;
 *     container.setLayout(gridLayout);
 * 
 *     Shape rect;
 *     rect = new RectangleFigure();
 *     container.add(rect);
 * 
 *     rect = new RectangleFigure();
 *     container.add(rect);
 * 
 *     rect = new RectangleFigure();
 *     GridLayoutData GridLayoutData = new GridLayoutData();
 *     GridLayoutData.widthHint = 150;
 *     layout.setConstraint(rect, GridLayoutData);
 * 
 *     container.add(rect);
 * </pre>
 * 
 * <p>
 * The <code>numColumns</code> field is the most important field in a
 * <code>GridLayout</code>. Widgets are laid out in columns from left to
 * right, and a new row is created when <code>numColumns</code>+ 1 figures
 * are added to the <code>Figure<code> parent container.
 * 
 * @see GridLayoutData
 * 
 * @author Asim Ullah
 * created: Sep 10, 2004
 */
public class GridLayout extends AbstractLayout {
	/**
	 * numColumns specifies the number of cell columns in the layout.
	 * 
	 * The default value is 1.
	 */
	public int numColumns = 1;

	/**
	 * makeColumnsEqualWidth specifies whether all columns in the layout will be
	 * forced to have the same width.
	 * 
	 * The default value is false.
	 */
	public boolean makeColumnsEqualWidth = false;

	/**
	 * marginWidth specifies the number of pixels of horizontal margin that will
	 * be placed along the left and right edges of the layout.
	 * 
	 * The default value is 5.
	 */
	public int marginWidth = 5;

	/**
	 * marginHeight specifies the number of pixels of vertical margin that will
	 * be placed along the top and bottom edges of the layout.
	 * 
	 * The default value is 5.
	 */
	public int marginHeight = 5;

	/**
	 * horizontalSpacing specifies the number of pixels between the right edge
	 * of one cell and the left edge of its neighbouring cell to the right.
	 * 
	 * The default value is 5.
	 */
	public int horizontalSpacing = 5;

	/**
	 * verticalSpacing specifies the number of pixels between the bottom edge of
	 * one cell and the top edge of its neighbouring cell underneath.
	 * 
	 * The default value is 5.
	 */
	public int verticalSpacing = 5;

	/** The layout contraints */
	protected Map constraints = new HashMap();

	/**
	 *  Default Constructor
	 */
	public GridLayout() {
		super();
	}

	/**
	 * Constructs a new instance of this class given the number of columns, and
	 * whether or not the columns should be forced to have the same width.
	 * 
	 * @param numColumns
	 *            the number of columns in the grid
	 * @param makeColumnsEqualWidth
	 *            whether or not the columns will have equal width
	 *  
	 */
	public GridLayout(int numColumns, boolean makeColumnsEqualWidth) {
		this.numColumns = numColumns;
		this.makeColumnsEqualWidth = makeColumnsEqualWidth;
	}

	/**
	 * @param child
	 * @param wHint
	 * @param hHint
	 * @return
	 */
	protected Dimension getChildSize(IFigure child, int wHint, int hHint) {
		return child.getPreferredSize(wHint, hHint);
	}

	GridLayoutData getData(IFigure[][] grid, int row, int column, int rowCount,
			int columnCount, boolean first) {
		IFigure figure = grid[row][column];
		if (figure != null) {
			GridLayoutData data = (GridLayoutData) getConstraint(figure);
			int hSpan = Math.max(1, Math.min(data.horizontalSpan, columnCount));
			int vSpan = Math.max(1, data.verticalSpan);
			int i = first ? row + vSpan - 1 : row - vSpan + 1;
			int j = first ? column + hSpan - 1 : column - hSpan + 1;
			if (0 <= i && i < rowCount) {
				if (0 <= j && j < columnCount) {
					if (figure == grid[i][j])
						return data;
				}
			}
		}
		return null;
	}
    
    void initChildren(IFigure container)
    {
        List children = container.getChildren();
        for (int i = 0; i < children.size(); i++) {
            IFigure child = (IFigure) children.get(i);
            if (child.getLayoutManager()==null)
            	child.setLayoutManager(this);
        }
    }

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.draw2d.AbstractLayout#calculatePreferredSize(org.eclipse.draw2d.IFigure,
	 *      int, int)
	 */
	protected Dimension calculatePreferredSize(IFigure container, int wHint,
			int hHint) {
		Dimension size = layout(container, false, 0, 0, wHint, hHint, /* flushCache */
				true);
    		if (wHint != SWT.DEFAULT)
			size.width = wHint;
		if (hHint != SWT.DEFAULT)
			size.height = hHint;

		return size;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.draw2d.LayoutManager#layout(org.eclipse.draw2d.IFigure)
	 */
	public void layout(IFigure container) {
        //initChildren( container);
		Rectangle rect = container.getClientArea();
		layout(container, true, rect.x, rect.y, rect.width, rect.height, /* flushCache */
				true);

	}

	Dimension layout(IFigure container, boolean move, int x, int y, int width,
			int height, boolean flushCache) {
		if (numColumns < 1)
			return new Dimension(marginWidth * 2, marginHeight * 2);
		List children = container.getChildren();
		for (int i = 0; i < children.size(); i++) {
			IFigure child = (IFigure) children.get(i);

			GridLayoutData data = (GridLayoutData) getConstraint(child);
			if (data == null)
				setConstraint(child, data = new GridLayoutData());
			if (flushCache)
				data.flushCache();
			data.computeSize(child, flushCache);
		}

		/* Build the grid */
		int row = 0, column = 0, rowCount = 0, columnCount = numColumns;
		IFigure[][] grid = new IFigure[4][columnCount];
		for (int i = 0; i < children.size(); i++) {
			IFigure child = (IFigure) children.get(i);
			GridLayoutData data = (GridLayoutData) getConstraint(child);
			int hSpan = Math.max(1, Math.min(data.horizontalSpan, columnCount));
			int vSpan = Math.max(1, data.verticalSpan);
			while (true) {
				int lastRow = row + vSpan;
				if (lastRow >= grid.length) {
					IFigure[][] newGrid = new IFigure[lastRow + 4][columnCount];
					System.arraycopy(grid, 0, newGrid, 0, grid.length);
					grid = newGrid;
				}
				if (grid[row] == null) {
					grid[row] = new IFigure[columnCount];
				}
				while (column < columnCount && grid[row][column] != null) {
					column++;
				}
				int endCount = column + hSpan;
				if (endCount <= columnCount) {
					int index = column;
					while (index < endCount && grid[row][index] == null) {
						index++;
					}
					if (index == endCount)
						break;
					column = index;
				}
				if (column + hSpan >= columnCount) {
					column = 0;
					row++;
				}
			}
			for (int j = 0; j < vSpan; j++) {
				if (grid[row + j] == null) {
					grid[row + j] = new IFigure[columnCount];
				}
				for (int k = 0; k < hSpan; k++) {
					grid[row + j][column + k] = child;
				}
			}
			rowCount = Math.max(rowCount, row + vSpan);
			column += hSpan;
		}

		/* Column widths */
		int availableWidth = width - horizontalSpacing * (columnCount - 1)
				- marginWidth * 2;
		int expandCount = 0;
		int[] widths = new int[columnCount];
		int[] minWidths = new int[columnCount];
		boolean[] expandColumn = new boolean[columnCount];
		for (int j = 0; j < columnCount; j++) {
			for (int i = 0; i < rowCount; i++) {
				GridLayoutData data = getData(grid, i, j, rowCount, columnCount, true);
				if (data != null) {
					int hSpan = Math.max(1, Math.min(data.horizontalSpan,
							columnCount));
					if (hSpan == 1) {
						int w = data.cacheWidth + data.horizontalIndent;
						widths[j] = Math.max(widths[j], w);
						if (data.grabExcessHorizontalSpace) {
							if (!expandColumn[j])
								expandCount++;
							expandColumn[j] = true;
						}
						if (data.widthHint != SWT.DEFAULT
								|| !data.grabExcessHorizontalSpace) {
							minWidths[j] = Math.max(minWidths[j], w);
						}
					}
				}
			}
			for (int i = 0; i < rowCount; i++) {
				GridLayoutData data = getData(grid, i, j, rowCount, columnCount,
						false);
				if (data != null) {
					int hSpan = Math.max(1, Math.min(data.horizontalSpan,
							columnCount));
					if (hSpan > 1) {
						int spanWidth = 0, spanMinWidth = 0, spanExpandCount = 0;
						for (int k = 0; k < hSpan; k++) {
							spanWidth += widths[j - k];
							spanMinWidth += minWidths[j - k];
							if (expandColumn[j - k])
								spanExpandCount++;
						}
						if (data.grabExcessHorizontalSpace
								&& spanExpandCount == 0) {
							expandCount++;
							expandColumn[j] = true;
						}
						int w = data.cacheWidth + data.horizontalIndent
								- spanWidth - (hSpan - 1) * horizontalSpacing;
						if (w > 0) {
							if (spanExpandCount == 0) {
								widths[j] += w;
							} else {
								int delta = w / spanExpandCount;
								int remainder = w % spanExpandCount, last = -1;
								for (int k = 0; k < hSpan; k++) {
									if (expandColumn[j - k]) {
										widths[last = j - k] += delta;
									}
								}
								if (last > -1)
									widths[last] += remainder;
							}
						}
						if (data.widthHint != SWT.DEFAULT
								|| !data.grabExcessHorizontalSpace) {
							w = data.cacheWidth + data.horizontalIndent
									- spanMinWidth - (hSpan - 1)
									* horizontalSpacing;
							if (w > 0) {
								if (spanExpandCount == 0) {
									minWidths[j] += w;
								} else {
									int delta = w / spanExpandCount;
									int remainder = w % spanExpandCount, last = -1;
									for (int k = 0; k < hSpan; k++) {
										if (expandColumn[j - k]) {
											minWidths[last = j - k] += delta;
										}
									}
									if (last > -1)
										minWidths[last] += remainder;
								}
							}
						}
					}
				}
			}
		}
		if (makeColumnsEqualWidth) {
			int minColumnWidth = 0;
			int columnWidth = 0;
			for (int i = 0; i < columnCount; i++) {
				minColumnWidth = Math.max(minColumnWidth, minWidths[i]);
				columnWidth = Math.max(columnWidth, widths[i]);
			}
			columnWidth = width == SWT.DEFAULT || expandCount == 0
					? columnWidth
					: Math.max(minColumnWidth, availableWidth / columnCount);
			for (int i = 0; i < columnCount; i++) {
				expandColumn[i] = expandCount > 0;
				widths[i] = columnWidth;
			}
		} else {
			if (width != SWT.DEFAULT && expandCount > 0) {
				int totalWidth = 0;
				for (int i = 0; i < columnCount; i++) {
					totalWidth += widths[i];
				}
				int count = expandCount;
				int delta = (availableWidth - totalWidth) / count;
				int remainder = (availableWidth - totalWidth) % count;
				int last = -1;
				while (totalWidth != availableWidth) {
					for (int j = 0; j < columnCount; j++) {
						if (expandColumn[j]) {
							if (widths[j] + delta > minWidths[j]) {
								widths[last = j] = widths[j] + delta;
							} else {
								widths[j] = minWidths[j];
								expandColumn[j] = false;
								count--;
							}
						}
					}
					if (last > -1)
						widths[last] += remainder;

					for (int j = 0; j < columnCount; j++) {
						for (int i = 0; i < rowCount; i++) {
							GridLayoutData data = getData(grid, i, j, rowCount,
									columnCount, false);
							if (data != null) {
								int hSpan = Math.max(1, Math.min(
										data.horizontalSpan, columnCount));
								if (hSpan > 1) {
									if (data.widthHint != SWT.DEFAULT
											|| !data.grabExcessHorizontalSpace) {
										int spanWidth = 0, spanExpandCount = 0;
										for (int k = 0; k < hSpan; k++) {
											spanWidth += widths[j - k];
											if (expandColumn[j - k])
												spanExpandCount++;
										}
										int w = data.cacheWidth
												+ data.horizontalIndent
												- spanWidth - (hSpan - 1)
												* horizontalSpacing;
										if (w > 0) {
											if (spanExpandCount == 0) {
												widths[j] += w;
											} else {
												int delta2 = w
														/ spanExpandCount;
												int remainder2 = w
														% spanExpandCount, last2 = -1;
												for (int k = 0; k < hSpan; k++) {
													if (expandColumn[j - k]) {
														widths[last2 = j - k] += delta2;
													}
												}
												if (last2 > -1)
													widths[last2] += remainder2;
											}
										}
									}
								}
							}
						}
					}
					if (count == 0)
						break;
					totalWidth = 0;
					for (int i = 0; i < columnCount; i++) {
						totalWidth += widths[i];
					}
					delta = (availableWidth - totalWidth) / count;
					remainder = (availableWidth - totalWidth) % count;
					last = -1;
				}
			}
		}

		/* Wrapping */
		GridLayoutData[] flush = null;
		int flushLength = 0;
		if (width != SWT.DEFAULT) {
			for (int j = 0; j < columnCount; j++) {
				for (int i = 0; i < rowCount; i++) {
					GridLayoutData data = getData(grid, i, j, rowCount, columnCount,
							false);
					if (data != null) {
						if (data.heightHint == SWT.DEFAULT) {
							IFigure child = grid[i][j];
							//TEMPORARY CODE
							int hSpan = Math.max(1, Math.min(
									data.horizontalSpan, columnCount));
							int currentWidth = 0;
							for (int k = 0; k < hSpan; k++) {
								currentWidth += widths[j - k];
							}
							currentWidth += (hSpan - 1) * horizontalSpacing
									- data.horizontalIndent;
							if ((currentWidth != data.cacheWidth && data.horizontalAlignment == GridLayoutData.FILL)
									|| (data.cacheWidth > currentWidth)) {
								int trim = 0;
								/*
								  // *Note*: Left this in place from SWT
								  // GridLayout. Not sure if Draw2D Borders or
								  // Scrollbars 'trim' will need to be takeninto account.
								  
								  if (child instanceof Group) { 
                                      Group g =(Group)child; trim = g.getSize ().x -
                                      g.getClientArea ().width; 
                                  } else if (child instanceof Scrollable) { 
                                      Rectangle rect =
                                          ((Scrollable) child).computeTrim (0, 0, 0,0);
                                           trim = rect.width; } 
                                  else {
    								  trim = child.getBorderWidth () * 2; 
                                  }
								 */
								int oldWidthHint = data.widthHint;
								data.widthHint = Math.max(0, currentWidth
										- trim);
								data.cacheWidth = data.cacheHeight = SWT.DEFAULT;
								data.computeSize(child, false);
								data.widthHint = oldWidthHint;
								if (flush == null)
									flush = new GridLayoutData[children.size()];
								flush[flushLength++] = data;
							}
						}
					}
				}
			}
		}

		/* Row heights */
		int availableHeight = height - verticalSpacing * (rowCount - 1)
				- marginHeight * 2;
		expandCount = 0;
		int[] heights = new int[rowCount];
		int[] minHeights = new int[rowCount];
		boolean[] expandRow = new boolean[rowCount];
		for (int i = 0; i < rowCount; i++) {
			for (int j = 0; j < columnCount; j++) {
				GridLayoutData data = getData(grid, i, j, rowCount, columnCount, true);
				if (data != null) {
					int vSpan = Math.max(1, Math.min(data.verticalSpan,
							rowCount));
					if (vSpan == 1) {
						int h = data.cacheHeight; // + data.verticalIndent;
						heights[i] = Math.max(heights[i], h);
						if (data.grabExcessVerticalSpace) {
							if (!expandRow[i])
								expandCount++;
							expandRow[i] = true;
						}
						if (data.heightHint != SWT.DEFAULT
								|| !data.grabExcessVerticalSpace) {
							minHeights[i] = Math.max(minHeights[i], h);
						}
					}
				}
			}
			for (int j = 0; j < columnCount; j++) {
				GridLayoutData data = getData(grid, i, j, rowCount, columnCount,
						false);
				if (data != null) {
					int vSpan = Math.max(1, Math.min(data.verticalSpan,
							rowCount));
					if (vSpan > 1) {
						int spanHeight = 0, spanMinHeight = 0, spanExpandCount = 0;
						for (int k = 0; k < vSpan; k++) {
							spanHeight += heights[i - k];
							spanMinHeight += minHeights[i - k];
							if (expandRow[i - k])
								spanExpandCount++;
						}
						if (data.grabExcessVerticalSpace
								&& spanExpandCount == 0) {
							expandCount++;
							expandRow[i] = true;
						}
						int h = data.cacheHeight - spanHeight - (vSpan - 1)
								* verticalSpacing; // + data.verticalalIndent
						if (h > 0) {
							if (spanExpandCount == 0) {
								heights[i] += h;
							} else {
								int delta = h / spanExpandCount;
								int remainder = h % spanExpandCount, last = -1;
								for (int k = 0; k < vSpan; k++) {
									if (expandRow[i - k]) {
										heights[last = i - k] += delta;
									}
								}
								if (last > -1)
									heights[last] += remainder;
							}
						}
						if (data.heightHint != SWT.DEFAULT
								|| !data.grabExcessVerticalSpace) {
							h = data.cacheHeight - spanMinHeight - (vSpan - 1)
									* verticalSpacing; // + data.verticalIndent
							if (h > 0) {
								if (spanExpandCount == 0) {
									minHeights[i] += h;
								} else {
									int delta = h / spanExpandCount;
									int remainder = h % spanExpandCount, last = -1;
									for (int k = 0; k < vSpan; k++) {
										if (expandRow[i - k]) {
											minHeights[last = i - k] += delta;
										}
									}
									if (last > -1)
										minHeights[last] += remainder;
								}
							}
						}
					}
				}
			}
		}
		if (height != SWT.DEFAULT && expandCount > 0) {
			int totalHeight = 0;
			for (int i = 0; i < rowCount; i++) {
				totalHeight += heights[i];
			}
			int count = expandCount;
			int delta = (availableHeight - totalHeight) / count;
			int remainder = (availableHeight - totalHeight) % count;
			int last = -1;
			while (totalHeight != availableHeight) {
				for (int i = 0; i < rowCount; i++) {
					if (expandRow[i]) {
						if (heights[i] + delta > minHeights[i]) {
							heights[last = i] = heights[i] + delta;
						} else {
							heights[i] = minHeights[i];
							expandRow[i] = false;
							count--;
						}
					}
				}
				if (last > -1)
					heights[last] += remainder;

				for (int i = 0; i < rowCount; i++) {
					for (int j = 0; j < columnCount; j++) {
						GridLayoutData data = getData(grid, i, j, rowCount,
								columnCount, false);
						if (data != null) {
							int vSpan = Math.max(1, Math.min(data.verticalSpan,
									rowCount));
							if (vSpan > 1) {
								if (data.heightHint != SWT.DEFAULT
										|| !data.grabExcessVerticalSpace) {
									int spanHeight = 0, spanExpandCount = 0;
									for (int k = 0; k < vSpan; k++) {
										spanHeight += heights[i - k];
										if (expandRow[i - k])
											spanExpandCount++;
									}
									int h = data.cacheHeight - spanHeight
											- (vSpan - 1) * verticalSpacing; // +
																			 // data.verticalIndent
									if (h > 0) {
										if (spanExpandCount == 0) {
											heights[i] += h;
										} else {
											int delta2 = h / spanExpandCount;
											int remainder2 = h
													% spanExpandCount, last2 = -1;
											for (int k = 0; k < vSpan; k++) {
												if (expandRow[i - k]) {
													heights[last2 = i - k] += delta2;
												}
											}
											if (last2 > -1)
												heights[last2] += remainder2;
										}
									}
								}
							}
						}
					}
				}
				if (count == 0)
					break;
				totalHeight = 0;
				for (int i = 0; i < rowCount; i++) {
					totalHeight += heights[i];
				}
				delta = (availableHeight - totalHeight) / count;
				remainder = (availableHeight - totalHeight) % count;
				last = -1;
			}
		}

		/* Position the IFigures */
		if (move) {
			int gridY = y + marginHeight;
			for (int i = 0; i < rowCount; i++) {
				int gridX = x + marginWidth;
				for (int j = 0; j < columnCount; j++) {
					GridLayoutData data = getData(grid, i, j, rowCount, columnCount,
							true);
					if (data != null) {
						int hSpan = Math.max(1, Math.min(data.horizontalSpan,
								columnCount));
						int vSpan = Math.max(1, data.verticalSpan);
						int cellWidth = 0, cellHeight = 0;
						for (int k = 0; k < hSpan; k++) {
							cellWidth += widths[j + k];
						}
						for (int k = 0; k < vSpan; k++) {
							cellHeight += heights[i + k];
						}
						cellWidth += horizontalSpacing * (hSpan - 1);
						int childX = gridX + data.horizontalIndent;
						int childWidth = Math.min(data.cacheWidth, cellWidth);
						switch (data.horizontalAlignment) {
							case GridLayoutData.CENTER :
								childX = gridX
										+ Math.max(0,
												(cellWidth - childWidth) / 2);
								break;
							case GridLayoutData.END :
								childX = gridX
										+ Math.max(0, cellWidth - childWidth);
								break;
							case GridLayoutData.FILL :
								childWidth = cellWidth - data.horizontalIndent;
								break;
						}
						cellHeight += verticalSpacing * (vSpan - 1);
						int childY = gridY; // + data.verticalIndent;
						int childHeight = Math
								.min(data.cacheHeight, cellHeight);
						switch (data.verticalAlignment) {
							case GridLayoutData.CENTER :
								childY = gridY
										+ Math.max(0,
												(cellHeight - childHeight) / 2);
								break;
							case GridLayoutData.END :
								childY = gridY
										+ Math.max(0, cellHeight - childHeight);
								break;
							case GridLayoutData.FILL :
								childHeight = cellHeight; // -
														  // data.verticalIndent;
								break;
						}
						IFigure child = grid[i][j];
						if (child != null) {
							// following param could be replaced by
							// Rectangle.SINGLETON
							child.setBounds(new Rectangle(childX, childY,
									childWidth, childHeight));
						}
					}
					gridX += widths[j] + horizontalSpacing;
				}
				gridY += heights[i] + verticalSpacing;
			}
		}

		// clean up cache
		for (int i = 0; i < flushLength; i++) {
			flush[i].cacheWidth = flush[i].cacheHeight = -1;
		}

		int totalDefaultWidth = 0;
		int totalDefaultHeight = 0;
		for (int i = 0; i < columnCount; i++) {
			totalDefaultWidth += widths[i];
		}
		for (int i = 0; i < rowCount; i++) {
			totalDefaultHeight += heights[i];
		}
		totalDefaultWidth += horizontalSpacing * (columnCount - 1)
				+ marginWidth * 2;
		totalDefaultHeight += verticalSpacing * (rowCount - 1) + marginHeight
				* 2;
		return new Dimension(totalDefaultWidth, totalDefaultHeight);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.draw2d.LayoutManager#getConstraint(org.eclipse.draw2d.IFigure)
	 */
	public Object getConstraint(IFigure child) {
		return constraints.get(child);
	}

	/**
	 * Sets the layout constraint of the given figure. The constraints can only
	 * be of type {@link GridLayoutData}.
	 * 
	 * @see LayoutManager#setConstraint(IFigure, Object)
	 */
	public void setConstraint(IFigure figure, Object newConstraint) {
		super.setConstraint(figure, newConstraint);
		if (newConstraint != null)
        {
			constraints.put(figure, newConstraint);
            
        }
	}

}




package org.eclipse.gmf.internal.codegen.draw2d;

import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.swt.SWT;


/**
 * <code>GridLayoutData</code> is the layout data object associated with
 * <code>GridLayout</code>. To set a <code>GridLayoutData</code> object into a
 * <code>Figure</code>, you use the <code>setConstraint()</code> method of
 * <code>GridLayout</code> to map the <code>Figure</code> to its layout
 * <code>GridLayoutData</code>.
 * <p>
 * There are two ways to create a <code>GridLayoutData</code> object with certain
 * fields set. The first is to set the fields directly, like this:
 * 
 * <pre>
 * GridLayoutData gridData = new GridLayoutData();
 * gridData.horizontalAlignment = GridLayoutData.FILL;
 * gridData.grabExcessHorizontalSpace = true;
 * 
 * // associate the figure to the GridLayoutData object
 * myGridlayout.setConstraint(myFigure, gridData);
 * </pre>
 * 
 * The second is to take advantage of convenience style bits defined by
 * <code>GridLayoutData</code>:
 * 
 * <pre>
 * GridLayoutData gridData = new GridLayoutData(GridLayoutData.HORIZONTAL_ALIGN_FILL | GridLayoutData.GRAB_HORIZONTAL);
 * </pre>
 * 
 * </p>
 * <p>
 * NOTE: Do not reuse <code>GridLayoutData</code> objects. Every child in the parent
 * <code>Figure</code> that is managed by the <code>GridLayout</code> must
 * have a unique <code>GridLayoutData</code> object. If the layout data for a Grid
 * member in a <code>GridLayout</code> is null at layout time, a unique
 * <code>GridLayoutData</code> object is created for it.
 * </p>
 * 
 * [GMF]: NOTE: The set of the ALIGNMENT constants is changed in this class
 * comparing to original version to match the set of constants in the generated
 * code. E.g, <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code>.
 * Thus, this implementation is NOT intended to use SWT.* constants for
 * alignment.
 * 
 * @see GridLayout
 */
public final class GridLayoutData {
    /**
	 * verticalAlignment specifies how figures will be positioned vertically
	 * within a cell.
	 * 
	 * The default value is CENTER.
	 * 
	 * Possible values are:
	 * 
	 * <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code> (or
	 * <code>SWT.TOP - 1</code>): Position the figure at the top of the cell
	 * 
	 * <code>GridLayoutData.CENTER = SWT.CENTER - 1</code>: Position the
	 * figure in the vertical center of the cell
	 * 
	 * <code>GridLayoutData.END = SWT.END - 1</code> (or
	 * <code>SWT.BOTTOM - 1</code>): Position the figure at the bottom of the
	 * cell
	 * 
	 * <code>GridLayoutData.FILL = SWT.FILL - 1</code>: Resize the figure to
	 * fill the cell vertically
	 */
    public int verticalAlignment = CENTER;
    
    /**
	 * horizontalAlignment specifies how figures will be positioned horizontally
	 * within a cell.
	 * 
	 * The default value is BEGINNING.
	 * 
	 * Possible values are:
	 * 
	 * <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code> (or
	 * <code>SWT.TOP - 1</code>): Position the figure at the left of the cell
	 * 
	 * <code>GridLayoutData.CENTER = SWT.CENTER - 1</code>: Position the
	 * figure in the horizontal center of the cell
	 * 
	 * <code>GridLayoutData.END = SWT.END - 1</code> (or
	 * <code>SWT.BOTTOM - 1</code>): Position the figure at the right of the
	 * cell
	 * 
	 * <code>GridLayoutData.FILL = SWT.FILL - 1</code>: : Resize the figure
	 * to fill the cell horizontally
	 */
    public int horizontalAlignment = BEGINNING;
    
    /**
     * widthHint specifies a minimum width for the column. A value of 
     * SWT.DEFAULT indicates that no minimum width is specified.
     *
     * The default value is SWT.DEFAULT.
     */
    public int widthHint = SWT.DEFAULT;
    
    /**
     * heightHint specifies a minimum height for the row. A value of
     * SWT.DEFAULT indicates that no minimum height is specified.
     *
     * The default value is SWT.DEFAULT.
     */
    public int heightHint = SWT.DEFAULT;
    
    /**
     * horizontalIndent specifies the number of pixels of indentation
     * that will be placed along the left side of the cell.
     *
     * The default value is 0.
     */
    public int horizontalIndent = 0;
    
    /**
     * horizontalSpan specifies the number of column cells that the figure
     * will take up.
     *
     * The default value is 1.
     */
    public int horizontalSpan = 1;
    
    /**
     * verticalSpan specifies the number of row cells that the figure
     * will take up.
     *
     * The default value is 1.
     */
    public int verticalSpan = 1;
    
    /**
     * grabExcessHorizontalSpace specifies whether the cell will be made
     * wide enough to fit the remaining horizontal space.
     *
     * The default value is false.
     */ 
    public boolean grabExcessHorizontalSpace = false;
    
    /**
     * grabExcessVerticalSpace specifies whether the cell will be made
     * tall enough to fit the remaining vertical space.
     *
     * The default value is false.
     */ 
    public boolean grabExcessVerticalSpace = false;

    /**
     * Value for horizontalAlignment or verticalAlignment.
     * Position the figure at the top or left of the cell.
     */
    public static final int BEGINNING = 0; //SWT.BEGINNING - 1;
    
    /**
     * Value for horizontalAlignment or verticalAlignment.
     * Position the figure in the vertical or horizontal center of the cell
     */
    public static final int CENTER = 1;
    
    /**
     * Value for horizontalAlignment or verticalAlignment.
     * Position the figure at the bottom or right of the cell
     */
    public static final int END = 2;
    
    /**
     * Value for horizontalAlignment or verticalAlignment.
     * Resize the figure to fill the cell horizontally or vertically.
     */
    public static final int FILL = 3; //SWT.FILL - 1;

    /**
     * Style bit for <code>new GridLayoutData(int)</code>.
     * Position the figure at the top of the cell.
     * Not recommended. Use 
     * <code>new GridLayoutData(int, GridLayoutData.BEGINNING, boolean, boolean)</code>
     * instead.
     */
    public static final int VERTICAL_ALIGN_BEGINNING =  1 << 1;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to position the 
     * figure in the vertical center of the cell.
     * Not recommended. Use
     * <code>new GridLayoutData(int, GridLayoutData.CENTER, boolean, boolean)</code>
     * instead.
     */
    public static final int VERTICAL_ALIGN_CENTER = 1 << 2;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to position the 
     * figure at the bottom of the cell.
     * Not recommended. Use
     * <code>new GridLayoutData(int, GridLayoutData.END, boolean, boolean)</code>
     * instead.
     */
    public static final int VERTICAL_ALIGN_END = 1 << 3;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fill the cell vertically.
     * Not recommended. Use
     * <code>new GridLayoutData(int, GridLayoutData.FILL, boolean, boolean)</code>
     * instead
     */
    public static final int VERTICAL_ALIGN_FILL = 1 << 4;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to position the 
     * figure at the left of the cell.
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.BEGINNING, int, boolean, boolean)</code>
     * instead.
     */
    public static final int HORIZONTAL_ALIGN_BEGINNING =  1 << 5;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to position the 
     * figure in the horizontal center of the cell.
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.CENTER, int, boolean, boolean)</code>
     * instead.
     */
    public static final int HORIZONTAL_ALIGN_CENTER = 1 << 6;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to position the 
     * figure at the right of the cell.
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.END, int, boolean, boolean)</code>
     * instead.
     */
    public static final int HORIZONTAL_ALIGN_END = 1 << 7;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fill the cell horizontally.
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.FILL, int, boolean, boolean)</code>
     * instead.
     */
    public static final int HORIZONTAL_ALIGN_FILL = 1 << 8;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fit the remaining horizontal space.
     * Not recommended. Use
     * <code>new GridLayoutData(int, int, true, boolean)</code>
     * instead.
     */
    public static final int GRAB_HORIZONTAL = 1 << 9;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fit the remaining vertical space.
     * Not recommended. Use
     * <code>new GridLayoutData(int, int, boolean, true)</code>
     * instead.
     */
    public static final int GRAB_VERTICAL = 1 << 10;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fill the cell vertically and to fit the remaining
     * vertical space.
     * FILL_VERTICAL = VERTICAL_ALIGN_FILL | GRAB_VERTICAL
     * Not recommended. Use
     * <code>new GridLayoutData(int, GridLayoutData.FILL, boolean, true)</code>
     * instead.
     */ 
    public static final int FILL_VERTICAL = VERTICAL_ALIGN_FILL | GRAB_VERTICAL;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fill the cell horizontally and to fit the remaining
     * horizontal space.
     * FILL_HORIZONTAL = HORIZONTAL_ALIGN_FILL | GRAB_HORIZONTAL
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.FILL, int, true, boolean)</code>
     * instead.
     */ 
    public static final int FILL_HORIZONTAL = HORIZONTAL_ALIGN_FILL | GRAB_HORIZONTAL;
    
    /**
     * Style bit for <code>new GridLayoutData(int)</code> to resize the 
     * figure to fill the cell horizontally and vertically and 
     * to fit the remaining horizontal and vertical space.
     * FILL_BOTH = FILL_VERTICAL | FILL_HORIZONTAL
     * Not recommended. Use
     * <code>new GridLayoutData(GridLayoutData.FILL, GridLayoutData.FILL, true, true)</code>
     * instead.
     */ 
    public static final int FILL_BOTH = FILL_VERTICAL | FILL_HORIZONTAL;

    int cacheWidth = -1, cacheHeight = -1;
    int [][] cache = new int[2][4];
    int cacheIndex = -1;

/**
 * Constructs a new instance of GridLayoutData using
 * default values.
 */
public GridLayoutData () {
    super ();
}

/**
 * Constructs a new instance based on the GridLayoutData style.
 * This constructor is not recommended.
 * 
 * @param style the GridLayoutData style
 */
public GridLayoutData (int style) {
    super ();
    if ((style & VERTICAL_ALIGN_BEGINNING) != 0) verticalAlignment = BEGINNING;
    if ((style & VERTICAL_ALIGN_CENTER) != 0) verticalAlignment = CENTER;
    if ((style & VERTICAL_ALIGN_FILL) != 0) verticalAlignment = FILL;
    if ((style & VERTICAL_ALIGN_END) != 0) verticalAlignment = END;
    if ((style & HORIZONTAL_ALIGN_BEGINNING) != 0) horizontalAlignment = BEGINNING;
    if ((style & HORIZONTAL_ALIGN_CENTER) != 0) horizontalAlignment = CENTER;
    if ((style & HORIZONTAL_ALIGN_FILL) != 0) horizontalAlignment = FILL;
    if ((style & HORIZONTAL_ALIGN_END) != 0) horizontalAlignment = END;
    grabExcessHorizontalSpace = (style & GRAB_HORIZONTAL) != 0;
    grabExcessVerticalSpace = (style & GRAB_VERTICAL) != 0;
}

/**
 * Constructs a new instance of GridLayoutData according to the parameters.
 * 
 * @param horizontalAlignment how figure will be positioned horizontally within a cell
 * @param verticalAlignment how figure will be positioned vertically within a cell
 * @param grabExcessHorizontalSpace whether cell will be made wide enough to fit the remaining horizontal space
 * @param grabExcessVerticalSpace whether cell will be made high enough to fit the remaining vertical space
 * 
 */
public GridLayoutData (int horizontalAlignment, int verticalAlignment, boolean grabExcessHorizontalSpace, boolean grabExcessVerticalSpace) {
    this (horizontalAlignment, verticalAlignment, grabExcessHorizontalSpace, grabExcessVerticalSpace, 1, 1);
}

/**
 * Constructs a new instance of GridLayoutData according to the parameters.
 *  
 * @param horizontalAlignment how figure will be positioned horizontally within a cell
 * @param verticalAlignment how figure will be positioned vertically within a cell
 * @param grabExcessHorizontalSpace whether cell will be made wide enough to fit the remaining horizontal space
 * @param grabExcessVerticalSpace whether cell will be made high enough to fit the remaining vertical space
 * @param horizontalSpan the number of column cells that the figure will take up
 * @param verticalSpan the number of row cells that the figure will take up
 * 
 */
public GridLayoutData (int horizontalAlignment, int verticalAlignment, boolean grabExcessHorizontalSpace, boolean grabExcessVerticalSpace, int horizontalSpan, int verticalSpan) {
    super ();
    this.horizontalAlignment = horizontalAlignment;
    this.verticalAlignment = verticalAlignment;
    this.grabExcessHorizontalSpace = grabExcessHorizontalSpace;
    this.grabExcessVerticalSpace = grabExcessVerticalSpace;
    this.horizontalSpan = horizontalSpan;
    this.verticalSpan = verticalSpan;
}

/**
 * Constructs a new instance of GridLayoutData according to the parameters.
 * A value of SWT.DEFAULT indicates that no minimum width or
 * no minumum height is specified.
 * 
 * @param width a minimum width for the column
 * @param height a minimum height for the row
 * 
 */
public GridLayoutData (int width, int height) {
    super ();
    this.widthHint = width;
    this.heightHint = height;
}

Dimension computeSize (IFigure figure, boolean flushCache) {
    if (cacheWidth != -1 && cacheHeight != -1) {
        return new Dimension (cacheWidth, cacheHeight);
    }
    for (int i = 0; i < cacheIndex + 1; i++) {
        if (cache [i][0] == widthHint && cache [i][1] == heightHint) {
            cacheWidth = cache [i][2];
            cacheHeight = cache [i][3];
            return new Dimension (cacheWidth, cacheHeight);
        }
    }

    Dimension size = figure.getPreferredSize(widthHint,heightHint);
    if (widthHint!=-1) size.width = widthHint;
    if (heightHint!=-1) size.height = heightHint;    

    if (cacheIndex < cache.length - 1) cacheIndex++;
    cache [cacheIndex][0] = widthHint;
    cache [cacheIndex][1] = heightHint;
    cacheWidth = cache [cacheIndex][2] = size.width;
    cacheHeight = cache [cacheIndex][3] = size.height;
    return size;
}


void flushCache () {
    cacheWidth = cacheHeight = -1;
    cacheIndex = -1;
}

String getName () {
    String string = getClass ().getName ();
    int index = string.lastIndexOf ('.');
    if (index == -1) return string;
    return string.substring (index + 1, string.length ());
}

public String toString () {

    String hAlign = "";
    switch (horizontalAlignment) {
        case FILL: hAlign = "GridLayoutData.FILL"; break;
        case BEGINNING: hAlign = "GridLayoutData.BEGINNING"; break;
        case END: hAlign = "GridLayoutData.LEFT"; break;
        case CENTER: hAlign = "GridLayoutData.CENTER"; break;
        default: hAlign = "Undefined "+horizontalAlignment; break;
    }
    String vAlign = "";
    switch (verticalAlignment) {
        case FILL: vAlign = "GridLayoutData.FILL"; break;
        case BEGINNING: vAlign = "GridLayoutData.BEGINNING"; break;
        case END: vAlign = "GridLayoutData.END"; break;
        case CENTER: vAlign = "GridLayoutData.CENTER"; break;
        default: vAlign = "Undefined "+verticalAlignment; break;
    }
    String string = getName()+" {";
    string += "horizontalAlignment="+hAlign+" ";
    if (horizontalIndent != 0) string += "horizontalIndent="+horizontalIndent+" ";
    if (horizontalSpan != 1) string += "horizontalSpan="+horizontalSpan+" ";
    if (grabExcessHorizontalSpace) string += "grabExcessHorizontalSpace="+grabExcessHorizontalSpace+" ";
    if (widthHint != SWT.DEFAULT) string += "widthHint="+widthHint+" ";
    string += "verticalAlignment="+vAlign+" ";
    if (verticalSpan != 1) string += "verticalSpan="+verticalSpan+" ";
    if (grabExcessVerticalSpace) string += "grabExcessVerticalSpace="+grabExcessVerticalSpace+" ";
    if (heightHint != SWT.DEFAULT) string += "heightHint="+heightHint+" ";
    string = string.trim();
    string += "}";
    return string;

}

}




/*
 * Copyright (c) 2006 Borland Software Corporation
 * 
 * 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:
 *    Michael Golubev (Borland) - initial API and implementation
 */

package org.eclipse.uml2.diagram.common.draw2d;

import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.PolylineDecoration;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.Rectangle;

public class RequiredInterfaceDecoration extends PolylineDecoration {
	private static final Point TEMP_POINT = new Point(); 
	private static final Rectangle TEMP_RECTANGLE = new Rectangle();
	
	private final int GAP = 3;
	private int myRadius;
	private int myAngle;
	
	public RequiredInterfaceDecoration(){
		setRadius(1);
		setScale(1, 1);
	}
	
	public void setRadius(int radius){
		myRadius = radius;
		setTemplate(new PointList(new int[] {radius - GAP, 0} ));
	}
	
	@Override
	public Rectangle getBounds() {
		if (bounds == null){
			//implicitly sets bounds
			super.getBounds();
			computeArcBounds(TEMP_RECTANGLE);
			TEMP_RECTANGLE.expand(1, 1);
			bounds.union(TEMP_RECTANGLE);
		}
		return bounds;
	}
	
	@Override
	public void setRotation(double angle) {
		super.setRotation(angle);
		myAngle = (int) (angle * 180 / Math.PI);
	}
	
	@Override
	protected void fillShape(Graphics g) {
		//do nothing
	}
	
	@Override
	protected void outlineShape(Graphics g) {
		computeArcBounds(TEMP_RECTANGLE);
		g.drawArc(TEMP_RECTANGLE, -myAngle + 90, 180);
	}
	
	private void computeArcBounds(Rectangle output){
		if (getPoints().size() == 0){
			output.setSize(0, 0);
			return;
		}
		getPoints().getPoint(TEMP_POINT, 0);
		output.setLocation(TEMP_POINT.x - myRadius, TEMP_POINT.y - myRadius);
		output.setSize(2 * myRadius, 2 * myRadius);
	}
}




<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
	<name>org.eclipse.uml2.diagram.common</name>
	<comment></comment>
	<projects>
	</projects>
	<buildSpec>
		<buildCommand>
			<name>org.eclipse.jdt.core.javabuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
		<buildCommand>
			<name>org.eclipse.pde.ManifestBuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
		<buildCommand>
			<name>org.eclipse.pde.SchemaBuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
	</buildSpec>
	<natures>
		<nature>org.eclipse.pde.PluginNature</nature>
		<nature>org.eclipse.jdt.core.javanature</nature>
	</natures>
</projectDescription>

Return to bug 80318

Added Link Here

(-)src/org/eclipse/uml2/diagram/parser/lookup/LookupResolverImpl.java (+106 lines)
1	/*
2	* Copyright (c) 2006 Borland Software Corporation
3	*
4	* All rights reserved. This program and the accompanying materials
5	* are made available under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution, and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* Michael Golubev (Borland) - initial API and implementation
11	*/
12
13	package org.eclipse.uml2.diagram.parser.lookup;
14
15	import java.util.List;
16
17	import org.eclipse.core.commands.ExecutionException;
18	import org.eclipse.core.runtime.IAdaptable;
19	import org.eclipse.core.runtime.IProgressMonitor;
20	import org.eclipse.emf.ecore.EObject;
21	import org.eclipse.emf.transaction.TransactionalEditingDomain;
22	import org.eclipse.gef.commands.Command;
23	import org.eclipse.gef.requests.CreateRequest;
24	import org.eclipse.gmf.runtime.common.core.command.CommandResult;
25	import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
26	import org.eclipse.gmf.runtime.diagram.ui.requests.CreateUnspecifiedTypeRequest;
27	import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand;
28	import org.eclipse.gmf.runtime.emf.type.core.IElementType;
29	import org.eclipse.gmf.runtime.notation.View;
30	import org.eclipse.uml2.uml.NamedElement;
31
32
33	public class LookupResolverImpl implements LookupResolver {
34	private LookupResolveRequest myTheOnlyRequest;
35	private Callback myTheOnlyCallback;
36	private boolean myIsMultipleResolveRequired;
37	private final IGraphicalEditPart myResolvingEditPart;
38
39	public LookupResolverImpl(IGraphicalEditPart resolvingEditPart){
40	myResolvingEditPart = resolvingEditPart;
41	}
42
43	public void addLookupResolveRequest(LookupResolveRequest request, Callback callback){
44	if (isEmpty()){
45	myTheOnlyCallback = callback;
46	myTheOnlyRequest = request;
47	} else {
48	myIsMultipleResolveRequired = true;
49	}
50	}
51
52	public boolean isEmpty(){
53	return myTheOnlyCallback == null && myTheOnlyRequest == null;
54	}
55
56	public boolean canResolve(){
57	return !isEmpty() && !myIsMultipleResolveRequired;
58	}
59
60	public AbstractTransactionalCommand getResolveCommand() {
61	if (!canResolve()){
62	return null;
63	}
64	TransactionalEditingDomain domain = myResolvingEditPart.getEditingDomain();
65	final CreateUnspecifiedTypeRequest createRequest = new CreateUnspecifiedTypeRequest(myTheOnlyRequest.getElementTypes(), myResolvingEditPart.getDiagramPreferencesHint());
66	final Command gefCommand = myResolvingEditPart.getCommand(createRequest);
67	if (!gefCommand.canExecute()){
68	return null;
69	}
70	//XXX gef inside transactional command???
71	return new AbstractTransactionalCommand(domain, "", null){
72	@Override
73	protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
74	gefCommand.execute();
75	NamedElement resolution = getNewObject();
76	if (resolution != null){
77	resolution.eSet(myTheOnlyRequest.getInitFeature(), myTheOnlyRequest.getInitValue());
78	myTheOnlyCallback.lookupResolved(resolution);
79	}
80	return CommandResult.newOKCommandResult();
81	}
82
83	private NamedElement getNewObject(){
84	for (Object next : createRequest.getElementTypes()){
85	IElementType nextElementType = (IElementType)next;
86	CreateRequest nextRequest = createRequest.getRequestForType(nextElementType);
87	List allNew = (List)nextRequest.getNewObject();
88	for (Object nextCreated : allNew){
89	if (nextCreated instanceof IAdaptable){
90	View createdView = (View) ((IAdaptable)nextCreated).getAdapter(View.class);
91	if (createdView != null) {
92	EObject createdEntity = createdView.getElement();
93	if (createdEntity instanceof NamedElement){
94	return (NamedElement)createdEntity;
95	}
96	}
97	}
98	}
99	}
100	return null;
101	}
102	};
103	}
104
105
106	}

Added Link Here

(-)src/org/eclipse/uml2/diagram/parser/ParserAdapter.java (+208 lines)
1	/*
2	* Copyright (c) 2006 Borland Software Corporation
3	*
4	* All rights reserved. This program and the accompanying materials
5	* are made available under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution, and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* Michael Golubev (Borland) - initial API and implementation
11	*/
12
13	package org.eclipse.uml2.diagram.parser;
14
15	import java.util.Iterator;
16	import java.util.LinkedList;
17	import java.util.List;
18
19	import org.eclipse.core.commands.ExecutionException;
20	import org.eclipse.core.runtime.IAdaptable;
21	import org.eclipse.core.runtime.IProgressMonitor;
22	import org.eclipse.emf.common.notify.Notification;
23	import org.eclipse.emf.ecore.EObject;
24	import org.eclipse.emf.ecore.EStructuralFeature;
25	import org.eclipse.emf.transaction.TransactionalEditingDomain;
26	import org.eclipse.emf.transaction.util.TransactionUtil;
27	import org.eclipse.gmf.runtime.common.core.command.CommandResult;
28	import org.eclipse.gmf.runtime.common.core.command.ICommand;
29	import org.eclipse.gmf.runtime.common.core.command.UnexecutableCommand;
30	import org.eclipse.gmf.runtime.common.ui.services.parser.IParser;
31	import org.eclipse.gmf.runtime.common.ui.services.parser.IParserEditStatus;
32	import org.eclipse.gmf.runtime.common.ui.services.parser.ParserEditStatus;
33	import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
34	import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
35	import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand;
36	import org.eclipse.gmf.runtime.emf.commands.core.command.CompositeTransactionalCommand;
37	import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
38	import org.eclipse.uml2.diagram.parser.lookup.LookupResolver;
39	import org.eclipse.uml2.diagram.parser.lookup.LookupResolverImpl;
40	import org.eclipse.uml2.diagram.parser.lookup.LookupSuite;
41	import org.eclipse.uml2.internal.diagram.parser.MDTDiagramParserPlugin;
42
43	public class ParserAdapter implements IParser {
44	private static final String NOT_AN_OBJECT = "Unknown";
45	private final ExternalParserBase myDelegate;
46	private final EObject myTester;
47	private final ApplyStrategy myApplier;
48	private final ExternalToString myView;
49	private final ExternalToString myEdit;
50	private final static MessageFormatEscaper ourMessageFormatEscaper = new MessageFormatEscaper();
51
52	public ParserAdapter(ExternalParserBase delegate, ApplyStrategy applier){
53	this(delegate, applier, ExternalToString.NOT_IMPLEMENTED);
54	}
55
56	public ParserAdapter(ExternalParserBase delegate, ApplyStrategy applier, ExternalToString viewAndEdit){
57	this(delegate, applier, viewAndEdit, viewAndEdit);
58	}
59
60	public ParserAdapter(ExternalParserBase delegate, ApplyStrategy applier, ExternalToString view, ExternalToString edit){
61	myDelegate = delegate;
62	myApplier = applier;
63	myView = view;
64	myEdit = edit;
65	myTester = myDelegate.createSubjectPrototype();
66	}
67
68	public IContentAssistProcessor getCompletionProcessor(IAdaptable element) {
69	return null;
70	}
71
72	public String getEditString(IAdaptable element, int flags) {
73	return getToString(element, flags, myEdit);
74	}
75
76	public String getPrintString(IAdaptable element, int flags) {
77	return getToString(element, flags, myView);
78	}
79
80	public final boolean isAffectingEvent(Object event, int flags) {
81	return isAffectingEvent(event);
82	}
83
84	protected boolean isAffectingEvent(Object event){
85	if (event instanceof Notification) {
86	Object feature = ((Notification) event).getFeature();
87	return (feature instanceof EStructuralFeature) && myView.isAffectingFeature((EStructuralFeature)feature);
88	}
89	return false;
90	}
91
92	public IParserEditStatus isValidEditString(IAdaptable adapter, String editString) {
93	EObject modelObject = (EObject) adapter.getAdapter(EObject.class);
94	if (modelObject == null) {
95	return new ParserEditStatus(
96	MDTDiagramParserPlugin.getPluginID(), IParserEditStatus.UNEDITABLE,
97	"Can not find context object");
98	}
99
100	LookupSuite oldLookup = myDelegate.getLookupSuite();
101	try {
102	myDelegate.setLookupSuite(LookupSuite.NULL_SUITE);
103	myDelegate.parse(myTester, editString, modelObject);
104	return ParserEditStatus.EDITABLE_STATUS;
105	} catch (ExternalParserException e) {
106	//CellEditor uses MessageFormat to format the message
107	//we need to escape '{', '}', '\' to prevent failure while formatting an error
108	String message = e.getMessage();
109	if (message == null){
110	message = "";
111	}
112	message = ourMessageFormatEscaper.getEscaped(message);
113	return new ParserEditStatus(
114	MDTDiagramParserPlugin.getPluginID(), IParserEditStatus.UNEDITABLE,
115	"Invalid input: " + message);
116	} finally {
117	myDelegate.setLookupSuite(oldLookup);
118	}
119	}
120
121	public ICommand getParseCommand(IAdaptable adapter, String newString, int flags) {
122	final EObject modelObject = (EObject) adapter.getAdapter(EObject.class);
123	if (modelObject == null) {
124	return UnexecutableCommand.INSTANCE;
125	}
126	TransactionalEditingDomain editingDomain = TransactionUtil.getEditingDomain(modelObject);
127	if (editingDomain == null) {
128	return UnexecutableCommand.INSTANCE;
129	}
130
131	IGraphicalEditPart diagramEditPart = (DiagramEditPart)adapter.getAdapter(DiagramEditPart.class);
132	LookupResolver resolver = LookupResolver.NULL;
133	if (diagramEditPart != null){
134	resolver = new LookupResolverImpl(diagramEditPart);
135	}
136	myDelegate.setLookupResolver(resolver);
137
138	final EObject parsed;
139	try {
140	parsed = myDelegate.parseNewObject(modelObject, newString);
141	} catch (ExternalParserException e){
142	//strange
143	//e.printStackTrace();
144	return UnexecutableCommand.INSTANCE;
145	} finally {
146	myDelegate.setLookupResolver(null);
147	}
148
149	List commandList = new LinkedList();
150	if (resolver.canResolve()){
151	AbstractTransactionalCommand resolveCommand = resolver.getResolveCommand();
152	AbstractTransactionalCommand computeAndApplyCommand = new AbstractTransactionalCommand(editingDomain, "", null){
153	@Override
154	protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
155	for (Iterator applyCommands = myApplier.apply(modelObject, parsed).iterator(); applyCommands.hasNext();){
156	ICommand next = (ICommand)applyCommands.next();
157	next.execute(monitor, info);
158	}
159	return CommandResult.newOKCommandResult();
160	}
161	};
162	commandList.add(resolveCommand);
163	commandList.add(computeAndApplyCommand);
164	} else {
165	commandList.addAll(myApplier.apply(modelObject, parsed));
166	}
167	return new CompositeTransactionalCommand(editingDomain, getCommandLabel(commandList), commandList);
168	}
169
170	protected final ExternalToString getViewToString() {
171	return myView;
172	}
173
174	private String getToString(IAdaptable element, int flags, ExternalToString toString) {
175	EObject modelObject = (EObject) element.getAdapter(EObject.class);
176	return isValidElement(modelObject) ? toString.getToString(modelObject, flags) : NOT_AN_OBJECT;
177	}
178
179	private String getCommandLabel(List/1.5 <ICommand>/ commandList){
180	return "-not-implemented-";
181	}
182
183	protected final boolean isValidElement(Object object){
184	return object != null && myDelegate.getSubjectClass().isInstance(object);
185	}
186
187	private static class MessageFormatEscaper {
188	private final char S_QUOTE = '\'';
189
190	public String getEscaped(String input){
191	if (!input.contains("'")){
192	return "'" + input + "'";
193	}
194	StringBuffer result = new StringBuffer(input.length() + 5);
195	result.append(S_QUOTE);
196	for (int i = 0; i < input.length(); i++){
197	char next = result.charAt(i);
198	if (next == S_QUOTE){
199	result.append(S_QUOTE);
200	}
201	result.append(next);
202	}
203	result.append(S_QUOTE);
204	return result.toString();
205	}
206	}
207
208	}

Added Link Here

(-)src/org/eclipse/uml2/diagram/parser/ApplyStrategy.java (+25 lines)
1	/*
2	* Copyright (c) 2006 Borland Software Corporation
3	*
4	* All rights reserved. This program and the accompanying materials
5	* are made available under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution, and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* Michael Golubev (Borland) - initial API and implementation
11	*/
12
13	package org.eclipse.uml2.diagram.parser;
14
15	import java.util.Collections;
16	import java.util.List;
17
18	import org.eclipse.emf.ecore.EObject;
19	import org.eclipse.gmf.runtime.common.core.command.UnexecutableCommand;
20
21	public interface ApplyStrategy {
22	public List/1.5 <ICommand>/ apply(EObject modelObject, EObject parsedObject);
23
24	public static final List/1.5 <ICommand>/ NOT_EXECUTABLE = Collections.singletonList(UnexecutableCommand.INSTANCE);
25	}

Added Link Here

(-)META-INF/MANIFEST.MF (+28 lines)
1	Manifest-Version: 1.0
2	Bundle-ManifestVersion: 2
3	Bundle-Name: UML Diagrams Parser Plug-in
4	Bundle-SymbolicName: org.eclipse.uml2.diagram.parser; singleton:=true
5	Bundle-Version: 1.0.0
6	Bundle-Localization: plugin
7	Bundle-Activator: org.eclipse.uml2.internal.diagram.parser.MDTDiagramParserPlugin
8	Require-Bundle: org.eclipse.core.runtime,
9	org.eclipse.jface,
10	org.eclipse.emf.ecore,
11	org.eclipse.emf.ecore.xmi,
12	org.eclipse.emf.edit.ui,
13	org.eclipse.gef;visibility:=reexport,
14	org.eclipse.gmf.runtime.emf.core,
15	org.eclipse.gmf.runtime.emf.commands.core,
16	org.eclipse.gmf.runtime.emf.ui.properties,
17	org.eclipse.gmf.runtime.diagram.ui,
18	org.eclipse.gmf.runtime.diagram.ui.properties,
19	org.eclipse.uml2.uml;visibility:=reexport,
20	org.eclipse.uml2.uml.edit;visibility:=reexport,
21	org.eclipse.emf.ecore;visibility:=reexport,
22	org.eclipse.emf.ecore.edit;visibility:=reexport,
23	org.eclipse.emf.query.ocl;visibility:=reexport,
24	org.eclipse.emf.ocl;visibility:=reexport
25	Export-Package: org.eclipse.uml2.diagram.parser,
26	org.eclipse.uml2.diagram.parser.lookup
27	Eclipse-LazyStart: true
28

Added Link Here

(-)src/org/eclipse/uml2/internal/diagram/parser/MDTDiagramParserPlugin.java (+40 lines)
1	/*
2	* Copyright (c) 2006 Borland Software Corporation
3	*
4	* All rights reserved. This program and the accompanying materials
5	* are made available under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution, and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* Michael Golubev (Borland) - initial API and implementation
11	*/
12
13	package org.eclipse.uml2.internal.diagram.parser;
14
15	import org.eclipse.core.runtime.Plugin;
16	import org.osgi.framework.Bundle;
17	import org.osgi.framework.BundleContext;
18
19	public class MDTDiagramParserPlugin extends Plugin {
20	private static MDTDiagramParserPlugin anInstance;
21
22	public void start(BundleContext context) throws Exception {
23	super.start(context);
24	anInstance = this;
25	}
26
27	public void stop(BundleContext context) throws Exception {
28	anInstance = null;
29	super.stop(context);
30	}
31
32	public static String getPluginID() {
33	return getDefault().getSymbolicName();
34	}
35
36	public static Bundle getDefault() {
37	return anInstance.getBundle();
38	}
39
40	}

Added Link Here

(-)src/org/eclipse/uml2/diagram/parser/ExternalParserException.java (+25 lines)
1	/*
2	* Copyright (c) 2006 Borland Software Corporation
3	*
4	* All rights reserved. This program and the accompanying materials
5	* are made available under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution, and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* Michael Golubev (Borland) - initial API and implementation
11	*/
12
13	package org.eclipse.uml2.diagram.parser;
14
15	public class ExternalParserException extends Exception {
16
17	public ExternalParserException() {
18	super();
19	}
20
21	public ExternalParserException(String message) {
22	super(message);
23	}
24
25	}

Added Link Here

(-)src/org/eclipse/uml2/diagram/parser/SemanticLabelDirectEditPolicy.java (+36 lines)
1	/*
2	* Copyright (c) 2006 Borland Software Corporation
3	*
4	* All rights reserved. This program and the accompanying materials
5	* are made available under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution, and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* Michael Golubev (Borland) - initial API and implementation
11	*/
12
13	package org.eclipse.uml2.diagram.parser;
14
15	import org.eclipse.gef.commands.Command;
16	import org.eclipse.gef.requests.DirectEditRequest;
17	import org.eclipse.gmf.runtime.diagram.ui.editpolicies.LabelDirectEditPolicy;
18
19	public class SemanticLabelDirectEditPolicy extends LabelDirectEditPolicy {
20	@Override
21	protected Command getDirectEditCommand(DirectEditRequest edit) {
22	Command applyChanges = super.getDirectEditCommand(edit);
23	Command postRefresh = null;
24	if (applyChanges != null && applyChanges.canExecute()){
25	postRefresh = new PostRefreshCommand();
26	}
27	return applyChanges.chain(postRefresh);
28	}
29
30	private class PostRefreshCommand extends Command {
31	@Override
32	public void execute() {
33	getHost().refresh();
34	}
35	}
36	}

Added Link Here

(-).project (+28 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<projectDescription>
3	<name>org.eclipse.uml2.diagram.parser</name>
4	<comment></comment>
5	<projects>
6	</projects>
7	<buildSpec>
8	<buildCommand>
9	<name>org.eclipse.jdt.core.javabuilder</name>
10	<arguments>
11	</arguments>
12	</buildCommand>
13	<buildCommand>
14	<name>org.eclipse.pde.ManifestBuilder</name>
15	<arguments>
16	</arguments>
17	</buildCommand>
18	<buildCommand>
19	<name>org.eclipse.pde.SchemaBuilder</name>
20	<arguments>
21	</arguments>
22	</buildCommand>
23	</buildSpec>
24	<natures>
25	<nature>org.eclipse.pde.PluginNature</nature>
26	<nature>org.eclipse.jdt.core.javanature</nature>
27	</natures>
28	</projectDescription>

Added Link Here

(-)src/org/eclipse/uml2/diagram/parser/BasicApplyStrategy.java (+79 lines)
1	/*
2	* Copyright (c) 2006 Borland Software Corporation
3	*
4	* All rights reserved. This program and the accompanying materials
5	* are made available under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution, and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* Michael Golubev (Borland) - initial API and implementation
11	*/
12
13	package org.eclipse.uml2.diagram.parser;
14
15	import java.util.Iterator;
16	import java.util.LinkedList;
17	import java.util.List;
18
19	import org.eclipse.emf.ecore.EObject;
20	import org.eclipse.emf.ecore.EReference;
21	import org.eclipse.emf.ecore.EStructuralFeature;
22	import org.eclipse.gmf.runtime.emf.type.core.commands.DestroyReferenceCommand;
23	import org.eclipse.gmf.runtime.emf.type.core.commands.SetValueCommand;
24	import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyReferenceRequest;
25	import org.eclipse.gmf.runtime.emf.type.core.requests.SetRequest;
26
27	public class BasicApplyStrategy implements ApplyStrategy {
28	public List/1.5 <ICommand>/ apply(EObject modelObject, EObject parsedObject) {
29	List result = new LinkedList();
30	for (Iterator it = parsedObject.eClass().getEAllStructuralFeatures().iterator(); it.hasNext();){
31	EStructuralFeature next = (EStructuralFeature) it.next();
32	if (parsedObject.eIsSet(next) && !next.isDerived()){
33	transferValue(result, modelObject, parsedObject, next);
34	}
35	}
36	return result.isEmpty() ? NOT_EXECUTABLE : result;
37	}
38
39	protected final void transferValue(List output, EObject model, EObject parsed, EStructuralFeature feature){
40	if (feature.isDerived() \|\| !parsed.eIsSet(feature)){
41	return;
42	}
43	Object parsedValue = parsed.eGet(feature);
44	Object actualValue = model.eGet(feature);
45	if (safeEquals(parsedValue, actualValue)){
46	return;
47	}
48	//XXX: workaround for : #152080
49	//XXX: can not set multi-valued properties using SetValueCommand,
50	//XXX: see https://bugs.eclipse.org/bugs/show_bug.cgi?id=152080
51	if (feature instanceof EReference && feature.isMany()){
52	transferValuesList(output, model, parsed, (EReference)feature);
53	return;
54	}
55	SetRequest request = new SetRequest(model, feature, parsedValue);
56	output.add(new SetValueCommand(request));
57	}
58
59	private void transferValuesList(List output, EObject model, EObject parsed, EReference isManyReference){
60	assert isManyReference.isMany();
61	List<EObject> actualValues = (List<EObject>) model.eGet(isManyReference);
62	List<EObject> parsedValues = (List<EObject>) parsed.eGet(isManyReference);
63
64	for (EObject nextActual : actualValues){
65	DestroyReferenceRequest nextRequest = new DestroyReferenceRequest(model, isManyReference, nextActual, false);
66	output.add(new DestroyReferenceCommand(nextRequest));
67	}
68
69	for (EObject nextParsed : parsedValues){
70	SetRequest nextRequest = new SetRequest(model, isManyReference, nextParsed);
71	output.add(new SetValueCommand(nextRequest));
72	}
73	}
74
75	protected static <T> boolean safeEquals(T o1, T o2){
76	return o1 == null ? o2 == null : o1.equals(o2);
77	}
78
79	}

Added Link Here

(-)src/org/eclipse/uml2/diagram/common/draw2d/PolylineContainer.java (+28 lines)
1	/*
2	* Copyright (c) 2006 Borland Software Corporation
3	*
4	* All rights reserved. This program and the accompanying materials
5	* are made available under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution, and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* Michael Golubev (Borland) - initial API and implementation
11	*/
12
13	package org.eclipse.uml2.diagram.common.draw2d;
14
15	import org.eclipse.draw2d.RectangleFigure;
16
17	public class PolylineContainer extends RectangleFigure {
18	public PolylineContainer(){
19	super();
20	setOutline(false);
21	setFill(false);
22	}
23
24	protected boolean useLocalCoordinates() {
25	return true;
26	}
27
28	}

Added Link Here

(-)src/org/eclipse/uml2/diagram/common/parser/port/TokenMgrError.java (+144 lines)
1	/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 3.0 */
2	/*
3	* Copyright (c) 2006 Borland Software Corporation
4	*
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* Michael Golubev (Borland) - initial API and implementation
12	*/
13	package org.eclipse.uml2.diagram.common.parser.port;
14
15	public class TokenMgrError extends Error
16	{
17	/*
18	* Ordinals for various reasons why an Error of this type can be thrown.
19	*/
20
21	/**
22	* Lexical error occured.
23	*/
24	static final int LEXICAL_ERROR = 0;
25
26	/**
27	* An attempt wass made to create a second instance of a static token manager.
28	*/
29	static final int STATIC_LEXER_ERROR = 1;
30
31	/**
32	* Tried to change to an invalid lexical state.
33	*/
34	static final int INVALID_LEXICAL_STATE = 2;
35
36	/**
37	* Detected (and bailed out of) an infinite loop in the token manager.
38	*/
39	static final int LOOP_DETECTED = 3;
40
41	/**
42	* Indicates the reason why the exception is thrown. It will have
43	* one of the above 4 values.
44	*/
45	int errorCode;
46
47	/**
48	* Replaces unprintable characters by their espaced (or unicode escaped)
49	* equivalents in the given string
50	*/
51	protected static final String addEscapes(String str) {
52	StringBuffer retval = new StringBuffer();
53	char ch;
54	for (int i = 0; i < str.length(); i++) {
55	switch (str.charAt(i))
56	{
57	case 0 :
58	continue;
59	case '\b':
60	retval.append("\\b");
61	continue;
62	case '\t':
63	retval.append("\\t");
64	continue;
65	case '\n':
66	retval.append("\\n");
67	continue;
68	case '\f':
69	retval.append("\\f");
70	continue;
71	case '\r':
72	retval.append("\\r");
73	continue;
74	case '\"':
75	retval.append("\\\"");
76	continue;
77	case '\'':
78	retval.append("\\\'");
79	continue;
80	case '\\':
81	retval.append("\\\\");
82	continue;
83	default:
84	if ((ch = str.charAt(i)) < 0x20 \|\| ch > 0x7e) {
85	String s = "0000" + Integer.toString(ch, 16);
86	retval.append("\\u" + s.substring(s.length() - 4, s.length()));
87	} else {
88	retval.append(ch);
89	}
90	continue;
91	}
92	}
93	return retval.toString();
94	}
95
96	/**
97	* Returns a detailed message for the Error when it is thrown by the
98	* token manager to indicate a lexical error.
99	* Parameters :
100	* EOFSeen : indicates if EOF caused the lexicl error
101	* curLexState : lexical state in which this error occured
102	* errorLine : line number when the error occured
103	* errorColumn : column number when the error occured
104	* errorAfter : prefix that was seen before this error occured
105	* curchar : the offending character
106	* Note: You can customize the lexical error message by modifying this method.
107	*/
108	protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) {
109	return("Lexical error at line " +
110	errorLine + ", column " +
111	errorColumn + ". Encountered: " +
112	(EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") +
113	"after : \"" + addEscapes(errorAfter) + "\"");
114	}
115
116	/**
117	* You can also modify the body of this method to customize your error messages.
118	* For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
119	* of end-users concern, so you can return something like :
120	*
121	* "Internal Error : Please file a bug report .... "
122	*
123	* from this method for such cases in the release version of your parser.
124	*/
125	public String getMessage() {
126	return super.getMessage();
127	}
128
129	/*
130	* Constructors of various flavors follow.
131	*/
132
133	public TokenMgrError() {
134	}
135
136	public TokenMgrError(String message, int reason) {
137	super(message);
138	errorCode = reason;
139	}
140
141	public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) {
142	this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);
143	}
144	}

Added Link Here

(-)META-INF/MANIFEST.MF (+20 lines)
1	Manifest-Version: 1.0
2	Bundle-ManifestVersion: 2
3	Bundle-Name: UML Diagram Commons Plug-in
4	Bundle-SymbolicName: org.eclipse.uml2.diagram.common
5	Bundle-Version: 1.0.0
6	Bundle-Localization: plugin
7	Require-Bundle: org.eclipse.core.runtime,
8	org.eclipse.core.resources,
9	org.eclipse.uml2.uml;visibility:=reexport,
10	org.eclipse.uml2.uml.edit;visibility:=reexport,
11	org.eclipse.emf.ecore;visibility:=reexport,
12	org.eclipse.emf.ecore.edit;visibility:=reexport,
13	org.eclipse.emf.query.ocl;visibility:=reexport,
14	org.eclipse.emf.ocl;visibility:=reexport,
15	org.eclipse.gmf.runtime.draw2d.ui;visibility:=reexport,
16	org.eclipse.draw2d;visibility:=reexport,
17	org.eclipse.uml2.diagram.parser
18	Export-Package: org.eclipse.gmf.internal.codegen.draw2d,
19	org.eclipse.uml2.diagram.common.draw2d,
20	org.eclipse.uml2.diagram.common.parser.port;x-friends:="org.eclipse.uml2.diagram.clazz,org.eclipse.uml2.diagram.component"

Added Link Here

(-)src/org/eclipse/uml2/diagram/common/parser/port/port.jj (+310 lines)
1	options {
2	JAVA_UNICODE_ESCAPE = true;
3	STATIC=false;
4	}
5
6	PARSER_BEGIN(PortParser)
7
8	/*
9	* Copyright (c) 2006 Borland Software Corporation
10	*
11	* All rights reserved. This program and the accompanying materials
12	* are made available under the terms of the Eclipse Public License v1.0
13	* which accompanies this distribution, and is available at
14	* http://www.eclipse.org/legal/epl-v10.html
15	*
16	* Contributors:
17	* Michael Golubev (Borland) - initial API and implementation
18	*/
19	package org.eclipse.uml2.diagram.common.parser.port;
20
21	import java.io.*;
22	import org.eclipse.emf.ecore.EClass;
23	import org.eclipse.emf.ecore.EObject;
24	import org.eclipse.uml2.diagram.parser.*;
25	import org.eclipse.uml2.diagram.parser.lookup.LookupSuite;
26	import org.eclipse.uml2.diagram.parser.lookup.LookupResolver;
27	import org.eclipse.uml2.uml.*;
28
29	public class PortParser extends ExternalParserBase {
30	private Port mySubject;
31
32	private static class TypeLookupCallback implements LookupResolver.Callback {
33	private final Port myPort;
34
35	public TypeLookupCallback(Port property){
36	myPort = property;
37	}
38
39	public void lookupResolved(NamedElement resolution) {
40	if (resolution instanceof Type){
41	myPort.setType((Type)resolution);
42	}
43	}
44	}
45
46	public PortParser(){
47	this(new StringReader(""));
48	}
49
50	public PortParser(LookupSuite lookup){
51	this();
52	setLookupSuite(lookup);
53	}
54
55	public EClass getSubjectClass(){
56	return UMLPackage.eINSTANCE.getPort();
57	}
58
59	public void parse(EObject target, String text) throws ExternalParserException {
60	checkContext();
61	ReInit(new StringReader(text));
62	mySubject = (Port)target;
63	Declaration();
64	mySubject = null;
65	}
66
67	protected static int parseInt(Token t) throws ParseException {
68	if (t.kind != PortParserConstants.INTEGER_LITERAL){
69	throw new IllegalStateException("Token: " + t + ", image: " + t.image);
70	}
71	try {
72	return Integer.parseInt(t.image); //XXX: "0005", "99999999999999999999999"
73	} catch (NumberFormatException e){
74	throw new ParseException("Not supported integer value:" + t.image);
75	}
76	}
77
78	}
79
80	PARSER_END(PortParser)
81
82	/* WHITE SPACE */
83
84	SPECIAL_TOKEN :
85	{
86	" "
87	\| "\t"
88	}
89
90	/* SEPARATORS */
91	TOKEN :
92	{
93	< SLASH: "/" >
94	\| < COLON: ":" >
95	\| < EQUALS: "=" >
96	\| < LBRACKET: "[" >
97	\| < RBRACKET: "]" >
98	\| < LCURLY: "{" >
99	\| < RCURLY: "}" >
100	\| < COMMA: "," >
101	}
102
103	/* SPECIAL_MEANING */
104	TOKEN :
105	{
106	< PLUS: "+" >
107	\| < MINUS: "-" >
108	\| < NUMBER_SIGN: "#" >
109	\| < TILDE: "~" >
110	\| < DOT: "." >
111	\| < STAR: "*" >
112	}
113
114	/* MODIFIERS */
115	TOKEN :
116	{
117	< READ_ONLY: "readOnly" >
118	\| < UNION: "union" >
119	\| < SUBSETS: "subsets" >
120	\| < REDEFINES: "redefines" >
121	\| < ORDERED: "ordered" >
122	\| < UNORDERED: "unordered" >
123	\| < UNIQUE: "unique" >
124	\| < NON_UNIQUE: "nonunique" >
125	}
126
127	/* LITERALS */
128	TOKEN:
129	{
130	< INTEGER_LITERAL: ["0"-"9"] (["0"-"9"])* >
131	}
132
133	TOKEN :
134	{
135	< IDENTIFIER: <LETTER> (<LETTER>\|<DIGIT>)* >
136	\|
137	< #LETTER:
138	[
139	"\u0024",
140	"\u0041"-"\u005a",
141	"\u005f",
142	"\u0061"-"\u007a",
143	"\u00c0"-"\u00d6",
144	"\u00d8"-"\u00f6",
145	"\u00f8"-"\u00ff",
146	"\u0100"-"\u1fff",
147	"\u3040"-"\u318f",
148	"\u3300"-"\u337f",
149	"\u3400"-"\u3d2d",
150	"\u4e00"-"\u9fff",
151	"\uf900"-"\ufaff"
152	]
153	>
154	\|
155	< #DIGIT:
156	[
157	"\u0030"-"\u0039",
158	"\u0660"-"\u0669",
159	"\u06f0"-"\u06f9",
160	"\u0966"-"\u096f",
161	"\u09e6"-"\u09ef",
162	"\u0a66"-"\u0a6f",
163	"\u0ae6"-"\u0aef",
164	"\u0b66"-"\u0b6f",
165	"\u0be7"-"\u0bef",
166	"\u0c66"-"\u0c6f",
167	"\u0ce6"-"\u0cef",
168	"\u0d66"-"\u0d6f",
169	"\u0e50"-"\u0e59",
170	"\u0ed0"-"\u0ed9",
171	"\u1040"-"\u1049"
172	]
173	>
174	}
175
176	void Declaration() :
177	{}
178	{
179	(
180	[ Visibility() ]
181	PortName()
182	[ PortType() ]
183	[ Multiplicity() ]
184	) <EOF>
185	}
186
187	void PortName() :
188	{
189	String name;
190	}
191	{
192	name = NameWithSpaces()
193	{
194	mySubject.setName(name);
195	}
196	}
197
198	void Visibility() :
199	{
200	VisibilityKind kind;
201	}
202	{
203	(
204	<PLUS> { kind = VisibilityKind.PUBLIC_LITERAL; }
205	\|
206	<MINUS> { kind = VisibilityKind.PRIVATE_LITERAL; }
207	\|
208	<NUMBER_SIGN> { kind = VisibilityKind.PROTECTED_LITERAL; }
209	\|
210	<TILDE> { kind = VisibilityKind.PACKAGE_LITERAL; }
211	)
212	{
213	mySubject.setVisibility(kind);
214	}
215	}
216
217	void Multiplicity() :
218	{}
219	{
220	MultiplicityRange()
221	/* XXX: Parse conflict in case of empty DefaultValue, consider "a:int[5]{unique}"
222	[ MultiplicityDesignator() ]
223	*/
224	}
225
226	/* XXX: Parse conflict in case of empty default value
227	void MultiplicityDesignator() :
228	{ }
229	{
230	<LCURLY>
231	(
232	( MultiplicityUnique() [ MultiplicityOrdered() ] )
233	\|
234	( MultiplicityOrdered() [ MultiplicityUnique() ] )
235	)
236	<RCURLY>
237	}
238
239	void MultiplicityUnique() :
240	{}
241	{
242	<UNIQUE> { mySubject.setIsUnique(true); }
243	\|
244	<NON_UNIQUE> { mySubject.setIsUnique(false); }
245	}
246
247	void MultiplicityOrdered() :
248	{}
249	{
250	<ORDERED> { mySubject.setIsOrdered(true); }
251	\|
252	<UNORDERED> { mySubject.setIsOrdered(false); }
253	}
254
255	*/
256
257	/* XXX: ValueSpecification -- how to parse */
258	void MultiplicityRange() :
259	{
260	Token tLower = null;
261	Token tUpper;
262	}
263	{
264	<LBRACKET>
265	(
266	[ LOOKAHEAD(2) tLower = <INTEGER_LITERAL> <DOT> <DOT> { mySubject.setLower(parseInt(tLower)); } ]
267	(
268	tUpper = <STAR>
269	{
270	if (tLower == null){
271	mySubject.setLower(0);
272	}
273	mySubject.setUpper(LiteralUnlimitedNatural.UNLIMITED);
274	}
275	\|
276	tUpper = <INTEGER_LITERAL>
277	{
278	if (tLower == null){
279	mySubject.setLower(parseInt(tUpper));
280	}
281	mySubject.setUpper(parseInt(tUpper));
282	}
283	)
284	)
285	<RBRACKET>
286	}
287
288	void PortType() :
289	{
290	String type;
291	}
292	{
293	<COLON> type = NameWithSpaces() { applyLookup(Type.class, type, new TypeLookupCallback(mySubject)); }
294	}
295
296	String NameWithSpaces() :
297	{
298	StringBuffer result = new StringBuffer();
299	Token t;
300	}
301	{
302	(
303	t = <IDENTIFIER> { result.append(t.image); }
304	( t = <IDENTIFIER> { result.append(' '); result.append(t.image); } ) *
305	)
306	{
307	return result.toString();
308	}
309	}
310

Added Link Here

(-)src/org/eclipse/gmf/internal/codegen/draw2d/GridLayoutData.java (+453 lines)
1	package org.eclipse.gmf.internal.codegen.draw2d;
2
3	import org.eclipse.draw2d.IFigure;
4	import org.eclipse.draw2d.geometry.Dimension;
5	import org.eclipse.swt.SWT;
6
7
8	/**
9	* <code>GridLayoutData</code> is the layout data object associated with
10	* <code>GridLayout</code>. To set a <code>GridLayoutData</code> object into a
11	* <code>Figure</code>, you use the <code>setConstraint()</code> method of
12	* <code>GridLayout</code> to map the <code>Figure</code> to its layout
13	* <code>GridLayoutData</code>.
14	* <p>
15	* There are two ways to create a <code>GridLayoutData</code> object with certain
16	* fields set. The first is to set the fields directly, like this:
17	*
18	* <pre>
19	* GridLayoutData gridData = new GridLayoutData();
20	* gridData.horizontalAlignment = GridLayoutData.FILL;
21	* gridData.grabExcessHorizontalSpace = true;
22	*
23	* // associate the figure to the GridLayoutData object
24	* myGridlayout.setConstraint(myFigure, gridData);
25	* </pre>
26	*
27	* The second is to take advantage of convenience style bits defined by
28	* <code>GridLayoutData</code>:
29	*
30	* <pre>
31	* GridLayoutData gridData = new GridLayoutData(GridLayoutData.HORIZONTAL_ALIGN_FILL \| GridLayoutData.GRAB_HORIZONTAL);
32	* </pre>
33	*
34	* </p>
35	* <p>
36	* NOTE: Do not reuse <code>GridLayoutData</code> objects. Every child in the parent
37	* <code>Figure</code> that is managed by the <code>GridLayout</code> must
38	* have a unique <code>GridLayoutData</code> object. If the layout data for a Grid
39	* member in a <code>GridLayout</code> is null at layout time, a unique
40	* <code>GridLayoutData</code> object is created for it.
41	* </p>
42	*
43	* [GMF]: NOTE: The set of the ALIGNMENT constants is changed in this class
44	* comparing to original version to match the set of constants in the generated
45	* code. E.g, <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code>.
46	* Thus, this implementation is NOT intended to use SWT.* constants for
47	* alignment.
48	*
49	* @see GridLayout
50	*/
51	public final class GridLayoutData {
52	/**
53	* verticalAlignment specifies how figures will be positioned vertically
54	* within a cell.
55	*
56	* The default value is CENTER.
57	*
58	* Possible values are:
59	*
60	* <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code> (or
61	* <code>SWT.TOP - 1</code>): Position the figure at the top of the cell
62	*
63	* <code>GridLayoutData.CENTER = SWT.CENTER - 1</code>: Position the
64	* figure in the vertical center of the cell
65	*
66	* <code>GridLayoutData.END = SWT.END - 1</code> (or
67	* <code>SWT.BOTTOM - 1</code>): Position the figure at the bottom of the
68	* cell
69	*
70	* <code>GridLayoutData.FILL = SWT.FILL - 1</code>: Resize the figure to
71	* fill the cell vertically
72	*/
73	public int verticalAlignment = CENTER;
74
75	/**
76	* horizontalAlignment specifies how figures will be positioned horizontally
77	* within a cell.
78	*
79	* The default value is BEGINNING.
80	*
81	* Possible values are:
82	*
83	* <code>GridLayoutData.BEGINNING = SWT.BEGINNING - 1</code> (or
84	* <code>SWT.TOP - 1</code>): Position the figure at the left of the cell
85	*
86	* <code>GridLayoutData.CENTER = SWT.CENTER - 1</code>: Position the
87	* figure in the horizontal center of the cell
88	*
89	* <code>GridLayoutData.END = SWT.END - 1</code> (or
90	* <code>SWT.BOTTOM - 1</code>): Position the figure at the right of the
91	* cell
92	*
93	* <code>GridLayoutData.FILL = SWT.FILL - 1</code>: : Resize the figure
94	* to fill the cell horizontally
95	*/
96	public int horizontalAlignment = BEGINNING;
97
98	/**
99	* widthHint specifies a minimum width for the column. A value of
100	* SWT.DEFAULT indicates that no minimum width is specified.
101	*
102	* The default value is SWT.DEFAULT.
103	*/
104	public int widthHint = SWT.DEFAULT;
105
106	/**
107	* heightHint specifies a minimum height for the row. A value of
108	* SWT.DEFAULT indicates that no minimum height is specified.
109	*
110	* The default value is SWT.DEFAULT.
111	*/
112	public int heightHint = SWT.DEFAULT;
113
114	/**
115	* horizontalIndent specifies the number of pixels of indentation
116	* that will be placed along the left side of the cell.
117	*
118	* The default value is 0.
119	*/
120	public int horizontalIndent = 0;
121
122	/**
123	* horizontalSpan specifies the number of column cells that the figure
124	* will take up.
125	*
126	* The default value is 1.
127	*/
128	public int horizontalSpan = 1;
129
130	/**
131	* verticalSpan specifies the number of row cells that the figure
132	* will take up.
133	*
134	* The default value is 1.
135	*/
136	public int verticalSpan = 1;
137
138	/**
139	* grabExcessHorizontalSpace specifies whether the cell will be made
140	* wide enough to fit the remaining horizontal space.
141	*
142	* The default value is false.
143	*/
144	public boolean grabExcessHorizontalSpace = false;
145
146	/**
147	* grabExcessVerticalSpace specifies whether the cell will be made
148	* tall enough to fit the remaining vertical space.
149	*
150	* The default value is false.
151	*/
152	public boolean grabExcessVerticalSpace = false;
153
154	/**
155	* Value for horizontalAlignment or verticalAlignment.
156	* Position the figure at the top or left of the cell.
157	*/
158	public static final int BEGINNING = 0; //SWT.BEGINNING - 1;
159
160	/**
161	* Value for horizontalAlignment or verticalAlignment.
162	* Position the figure in the vertical or horizontal center of the cell
163	*/
164	public static final int CENTER = 1;
165
166	/**
167	* Value for horizontalAlignment or verticalAlignment.
168	* Position the figure at the bottom or right of the cell
169	*/
170	public static final int END = 2;
171
172	/**
173	* Value for horizontalAlignment or verticalAlignment.
174	* Resize the figure to fill the cell horizontally or vertically.
175	*/
176	public static final int FILL = 3; //SWT.FILL - 1;
177
178	/**
179	* Style bit for <code>new GridLayoutData(int)</code>.
180	* Position the figure at the top of the cell.
181	* Not recommended. Use
182	* <code>new GridLayoutData(int, GridLayoutData.BEGINNING, boolean, boolean)</code>
183	* instead.
184	*/
185	public static final int VERTICAL_ALIGN_BEGINNING = 1 << 1;
186
187	/**
188	* Style bit for <code>new GridLayoutData(int)</code> to position the
189	* figure in the vertical center of the cell.
190	* Not recommended. Use
191	* <code>new GridLayoutData(int, GridLayoutData.CENTER, boolean, boolean)</code>
192	* instead.
193	*/
194	public static final int VERTICAL_ALIGN_CENTER = 1 << 2;
195
196	/**
197	* Style bit for <code>new GridLayoutData(int)</code> to position the
198	* figure at the bottom of the cell.
199	* Not recommended. Use
200	* <code>new GridLayoutData(int, GridLayoutData.END, boolean, boolean)</code>
201	* instead.
202	*/
203	public static final int VERTICAL_ALIGN_END = 1 << 3;
204
205	/**
206	* Style bit for <code>new GridLayoutData(int)</code> to resize the
207	* figure to fill the cell vertically.
208	* Not recommended. Use
209	* <code>new GridLayoutData(int, GridLayoutData.FILL, boolean, boolean)</code>
210	* instead
211	*/
212	public static final int VERTICAL_ALIGN_FILL = 1 << 4;
213
214	/**
215	* Style bit for <code>new GridLayoutData(int)</code> to position the
216	* figure at the left of the cell.
217	* Not recommended. Use
218	* <code>new GridLayoutData(GridLayoutData.BEGINNING, int, boolean, boolean)</code>
219	* instead.
220	*/
221	public static final int HORIZONTAL_ALIGN_BEGINNING = 1 << 5;
222
223	/**
224	* Style bit for <code>new GridLayoutData(int)</code> to position the
225	* figure in the horizontal center of the cell.
226	* Not recommended. Use
227	* <code>new GridLayoutData(GridLayoutData.CENTER, int, boolean, boolean)</code>
228	* instead.
229	*/
230	public static final int HORIZONTAL_ALIGN_CENTER = 1 << 6;
231
232	/**
233	* Style bit for <code>new GridLayoutData(int)</code> to position the
234	* figure at the right of the cell.
235	* Not recommended. Use
236	* <code>new GridLayoutData(GridLayoutData.END, int, boolean, boolean)</code>
237	* instead.
238	*/
239	public static final int HORIZONTAL_ALIGN_END = 1 << 7;
240
241	/**
242	* Style bit for <code>new GridLayoutData(int)</code> to resize the
243	* figure to fill the cell horizontally.
244	* Not recommended. Use
245	* <code>new GridLayoutData(GridLayoutData.FILL, int, boolean, boolean)</code>
246	* instead.
247	*/
248	public static final int HORIZONTAL_ALIGN_FILL = 1 << 8;
249
250	/**
251	* Style bit for <code>new GridLayoutData(int)</code> to resize the
252	* figure to fit the remaining horizontal space.
253	* Not recommended. Use
254	* <code>new GridLayoutData(int, int, true, boolean)</code>
255	* instead.
256	*/
257	public static final int GRAB_HORIZONTAL = 1 << 9;
258
259	/**
260	* Style bit for <code>new GridLayoutData(int)</code> to resize the
261	* figure to fit the remaining vertical space.
262	* Not recommended. Use
263	* <code>new GridLayoutData(int, int, boolean, true)</code>
264	* instead.
265	*/
266	public static final int GRAB_VERTICAL = 1 << 10;
267
268	/**
269	* Style bit for <code>new GridLayoutData(int)</code> to resize the
270	* figure to fill the cell vertically and to fit the remaining
271	* vertical space.
272	* FILL_VERTICAL = VERTICAL_ALIGN_FILL \| GRAB_VERTICAL
273	* Not recommended. Use
274	* <code>new GridLayoutData(int, GridLayoutData.FILL, boolean, true)</code>
275	* instead.
276	*/
277	public static final int FILL_VERTICAL = VERTICAL_ALIGN_FILL \| GRAB_VERTICAL;
278
279	/**
280	* Style bit for <code>new GridLayoutData(int)</code> to resize the
281	* figure to fill the cell horizontally and to fit the remaining
282	* horizontal space.
283	* FILL_HORIZONTAL = HORIZONTAL_ALIGN_FILL \| GRAB_HORIZONTAL
284	* Not recommended. Use
285	* <code>new GridLayoutData(GridLayoutData.FILL, int, true, boolean)</code>
286	* instead.
287	*/
288	public static final int FILL_HORIZONTAL = HORIZONTAL_ALIGN_FILL \| GRAB_HORIZONTAL;
289
290	/**
291	* Style bit for <code>new GridLayoutData(int)</code> to resize the
292	* figure to fill the cell horizontally and vertically and
293	* to fit the remaining horizontal and vertical space.
294	* FILL_BOTH = FILL_VERTICAL \| FILL_HORIZONTAL
295	* Not recommended. Use
296	* <code>new GridLayoutData(GridLayoutData.FILL, GridLayoutData.FILL, true, true)</code>
297	* instead.
298	*/
299	public static final int FILL_BOTH = FILL_VERTICAL \| FILL_HORIZONTAL;
300
301	int cacheWidth = -1, cacheHeight = -1;
302	int [][] cache = new int[2][4];
303	int cacheIndex = -1;
304
305	/**
306	* Constructs a new instance of GridLayoutData using
307	* default values.
308	*/
309	public GridLayoutData () {
310	super ();
311	}
312
313	/**
314	* Constructs a new instance based on the GridLayoutData style.
315	* This constructor is not recommended.
316	*
317	* @param style the GridLayoutData style
318	*/
319	public GridLayoutData (int style) {
320	super ();
321	if ((style & VERTICAL_ALIGN_BEGINNING) != 0) verticalAlignment = BEGINNING;
322	if ((style & VERTICAL_ALIGN_CENTER) != 0) verticalAlignment = CENTER;
323	if ((style & VERTICAL_ALIGN_FILL) != 0) verticalAlignment = FILL;
324	if ((style & VERTICAL_ALIGN_END) != 0) verticalAlignment = END;
325	if ((style & HORIZONTAL_ALIGN_BEGINNING) != 0) horizontalAlignment = BEGINNING;
326	if ((style & HORIZONTAL_ALIGN_CENTER) != 0) horizontalAlignment = CENTER;
327	if ((style & HORIZONTAL_ALIGN_FILL) != 0) horizontalAlignment = FILL;
328	if ((style & HORIZONTAL_ALIGN_END) != 0) horizontalAlignment = END;
329	grabExcessHorizontalSpace = (style & GRAB_HORIZONTAL) != 0;
330	grabExcessVerticalSpace = (style & GRAB_VERTICAL) != 0;
331	}
332
333	/**
334	* Constructs a new instance of GridLayoutData according to the parameters.
335	*
336	* @param horizontalAlignment how figure will be positioned horizontally within a cell
337	* @param verticalAlignment how figure will be positioned vertically within a cell
338	* @param grabExcessHorizontalSpace whether cell will be made wide enough to fit the remaining horizontal space
339	* @param grabExcessVerticalSpace whether cell will be made high enough to fit the remaining vertical space
340	*
341	*/
342	public GridLayoutData (int horizontalAlignment, int verticalAlignment, boolean grabExcessHorizontalSpace, boolean grabExcessVerticalSpace) {
343	this (horizontalAlignment, verticalAlignment, grabExcessHorizontalSpace, grabExcessVerticalSpace, 1, 1);
344	}
345
346	/**
347	* Constructs a new instance of GridLayoutData according to the parameters.
348	*
349	* @param horizontalAlignment how figure will be positioned horizontally within a cell
350	* @param verticalAlignment how figure will be positioned vertically within a cell
351	* @param grabExcessHorizontalSpace whether cell will be made wide enough to fit the remaining horizontal space
352	* @param grabExcessVerticalSpace whether cell will be made high enough to fit the remaining vertical space
353	* @param horizontalSpan the number of column cells that the figure will take up
354	* @param verticalSpan the number of row cells that the figure will take up
355	*
356	*/
357	public GridLayoutData (int horizontalAlignment, int verticalAlignment, boolean grabExcessHorizontalSpace, boolean grabExcessVerticalSpace, int horizontalSpan, int verticalSpan) {
358	super ();
359	this.horizontalAlignment = horizontalAlignment;
360	this.verticalAlignment = verticalAlignment;
361	this.grabExcessHorizontalSpace = grabExcessHorizontalSpace;
362	this.grabExcessVerticalSpace = grabExcessVerticalSpace;
363	this.horizontalSpan = horizontalSpan;
364	this.verticalSpan = verticalSpan;
365	}
366
367	/**
368	* Constructs a new instance of GridLayoutData according to the parameters.
369	* A value of SWT.DEFAULT indicates that no minimum width or
370	* no minumum height is specified.
371	*
372	* @param width a minimum width for the column
373	* @param height a minimum height for the row
374	*
375	*/
376	public GridLayoutData (int width, int height) {
377	super ();
378	this.widthHint = width;
379	this.heightHint = height;
380	}
381
382	Dimension computeSize (IFigure figure, boolean flushCache) {
383	if (cacheWidth != -1 && cacheHeight != -1) {
384	return new Dimension (cacheWidth, cacheHeight);
385	}
386	for (int i = 0; i < cacheIndex + 1; i++) {
387	if (cache [i][0] == widthHint && cache [i][1] == heightHint) {
388	cacheWidth = cache [i][2];
389	cacheHeight = cache [i][3];
390	return new Dimension (cacheWidth, cacheHeight);
391	}
392	}
393
394	Dimension size = figure.getPreferredSize(widthHint,heightHint);
395	if (widthHint!=-1) size.width = widthHint;
396	if (heightHint!=-1) size.height = heightHint;
397
398	if (cacheIndex < cache.length - 1) cacheIndex++;
399	cache [cacheIndex][0] = widthHint;
400	cache [cacheIndex][1] = heightHint;
401	cacheWidth = cache [cacheIndex][2] = size.width;
402	cacheHeight = cache [cacheIndex][3] = size.height;
403	return size;
404	}
405
406
407	void flushCache () {
408	cacheWidth = cacheHeight = -1;
409	cacheIndex = -1;
410	}
411
412	String getName () {
413	String string = getClass ().getName ();
414	int index = string.lastIndexOf ('.');
415	if (index == -1) return string;
416	return string.substring (index + 1, string.length ());
417	}
418
419	public String toString () {
420
421	String hAlign = "";
422	switch (horizontalAlignment) {
423	case FILL: hAlign = "GridLayoutData.FILL"; break;
424	case BEGINNING: hAlign = "GridLayoutData.BEGINNING"; break;
425	case END: hAlign = "GridLayoutData.LEFT"; break;
426	case CENTER: hAlign = "GridLayoutData.CENTER"; break;
427	default: hAlign = "Undefined "+horizontalAlignment; break;
428	}
429	String vAlign = "";
430	switch (verticalAlignment) {
431	case FILL: vAlign = "GridLayoutData.FILL"; break;
432	case BEGINNING: vAlign = "GridLayoutData.BEGINNING"; break;
433	case END: vAlign = "GridLayoutData.END"; break;
434	case CENTER: vAlign = "GridLayoutData.CENTER"; break;
435	default: vAlign = "Undefined "+verticalAlignment; break;
436	}
437	String string = getName()+" {";
438	string += "horizontalAlignment="+hAlign+" ";
439	if (horizontalIndent != 0) string += "horizontalIndent="+horizontalIndent+" ";
440	if (horizontalSpan != 1) string += "horizontalSpan="+horizontalSpan+" ";
441	if (grabExcessHorizontalSpace) string += "grabExcessHorizontalSpace="+grabExcessHorizontalSpace+" ";
442	if (widthHint != SWT.DEFAULT) string += "widthHint="+widthHint+" ";
443	string += "verticalAlignment="+vAlign+" ";
444	if (verticalSpan != 1) string += "verticalSpan="+verticalSpan+" ";
445	if (grabExcessVerticalSpace) string += "grabExcessVerticalSpace="+grabExcessVerticalSpace+" ";
446	if (heightHint != SWT.DEFAULT) string += "heightHint="+heightHint+" ";
447	string = string.trim();
448	string += "}";
449	return string;
450
451	}
452
453	}