plugins/org.eclipse.gmf.codegen/models/gmfgen.emf

/**
 * Copyright (c) 2005, 2010 Borland Software Corporation and others
 * 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Artem Tikhomirov (Borland) - initial API and implementation
 */

@namespace(uri="http://www.eclipse.org/gmf/2009/GenModel", prefix="gmfgen")
@EmfaticAnnotationMap(
	constraints="http://www.eclipse.org/gmf/2005/constraints",
	meta="http://www.eclipse.org/gmf/2005/constraints/meta",
	deprecated="http://www.eclipse.org/gmf/2006/deprecated"
)
@constraints("import"="http://www.eclipse.org/gmf/runtime/1.0.0/notation")
package gmfgen;

//import "http://www.eclipse.org/emf/2002/GenModel";
import "platform:/plugin/org.eclipse.emf.codegen.ecore/model/GenModel.ecore";

// TODO introduce sourceRoot argument (or few of them?) to allow targets other than /src/
// TODO Move childNodes, topLevelNodes, links and compartments from GenDiagram here.
class GenEditorGenerator {
	val GenAuditRoot#editorGen audits;
	val GenMetricContainer#editorGen metrics;
	val GenDiagram[1]#editorGen diagram;
	val GenPlugin[1]#editorGen plugin;
	val GenEditorView[1]#editorGen editor;
	val GenNavigator#editorGen navigator;
	val GenDiagramUpdater[1]#editorGen diagramUpdater;
	val GenPropertySheet[?]#editorGen propertySheet;
	@genmodel(documentation="If application is defined within the model then generator should target RCP")
	val GenApplication[?]#editorGen application;
	@genmodel(documentation="This is primary EMF genmodel for user's domain model")
	ref genmodel.GenModel[?] domainGenModel;
	@genmodel(documentation="Returns all genpackages from domain genmodel")
	op genmodel.GenPackage[*] getAllDomainGenPackages(boolean withUsed);
	@genmodel(documentation="Derived from genModel.genPackage[0].getBasePackage() by default")
	attr String packageNamePrefix;
	id attr String[1] modelID;
	@genmodel(documentation="Specified whether editor should create separate file for domain elements if diagram file references no domain model")
	attr boolean sameFileForDiagramAndModel;
	@genmodel(documentation="Distinct even when sameFileForDiagramAndModel is true. On init diagram, we just copy domain model element to new file with that extension. I won't try to set this equal to domainFileExtension")
	attr String diagramFileExtension;
	@genmodel(documentation="By default, genModel.genPackage[0].getPrefix().toLowerCase(), as in emf/templates/editor/pluign.xmljet")
	attr String domainFileExtension;
	attr boolean dynamicTemplates = false;
	attr String templateDirectory;
	attr String copyrightText;
  	val GenExpressionProviderContainer#editorGen expressionProviders;
  	@genmodel(documentation="If present, specifies dynamic access to domain model(s), without using generated Java code")
  	val DynamicModelAccess[?]#editorGen modelAccess;
  	@genmodel(documentation="If present, describes access to and types of parser implementations")
  	@constraints(ocl="labelParsers.oclIsUndefined() implies (diagram.getAllNodes()->forAll(labels->size()=0) and diagram.links->forAll(labels->size()=0) and not diagram.childNodes->exists(oclIsKindOf(GenChildLabelNode)))", description="No label may be declared without a parser")
	val GenParsers[?]#editorGen labelParsers; // labelParser is permitted to be null only when there are basic nodes and links only, no labels
	val GenContextMenu[*] contextMenus; // XXX perhaps, as GenPlugin attribute instead?
	@genmodel(documentation="The target directory for generated editor code. Similar to EMF's GenModel#editorDirectory")
	attr String pluginDirectory; 
}

@constraints(ocl="diagramRunTimeClass.ecoreClass.eAllSuperTypes->including(diagramRunTimeClass.ecoreClass)->one(ePackage.name = 'notation' and name = 'Diagram')", description="'Diagram Runtime Class' must be a notation::Diagram or sub-class")
class GenDiagram extends GenContainerBase, PackageNames, ProviderClassNames, LinkConstraints, EditPartCandies, EditorCandies, Shortcuts, BatchValidation, MeasurementUnit {
	readonly !resolve ref GenEditorGenerator#diagram editorGen;
	ref genmodel.GenClass[?] domainDiagramElement;
	val GenChildNode[*]#diagram childNodes; // to GenEditorGenerator?
	val GenTopLevelNode[*]#diagram topLevelNodes;
	val GenLink[*]#diagram links;
	val GenCompartment[*]#diagram compartments;
	val Palette[?]#diagram palette;
	attr boolean synchronized = true;
	@genmodel(documentation="Handy operation to get top and child nodes")
	op GenNode[*] getAllNodes();
	@genmodel(documentation="All nodes (top and child) and compartments")
	op GenChildContainer[*] getAllChildContainers();
	@genmodel(documentation="All nodes, compartments and diagram itself")
	op GenContainerBase[*] getAllContainers();
	@genmodel(documentation="Gets the name of the class to hold the initializer methods for domain elements")
	op String getElementInitializersClassName(); // XXX WTF? why not a field?
	@genmodel(documentation="Gets the name of the package to hold the element initializers class")
	op String getElementInitializersPackageName();
	val GenDiagramPreferences[?] preferences;
	val GenPreferencePage[*] preferencePages;
}

class GenEditorView {
	readonly !resolve ref GenEditorGenerator#editor editorGen;
	attr String packageName;
	op String getActionBarContributorQualifiedClassName();
	attr String actionBarContributorClassName; // XXX move to InternalEditorView, inherit? Or GenEditorView4GEF extends this?
	op String getQualifiedClassName();
	attr String className;
	attr String[1] iconPath;
	readonly transient derived volatile attr String[1] iconPathX;
	attr String iD;
	attr boolean eclipseEditor = true;
	attr String contextID;
}

abstract class GenPreferencePage {
	attr String[1] iD;
	attr String[1] name;
	val GenPreferencePage[*]#parent children;
	readonly !resolve ref GenPreferencePage[?]#children parent;
	@genmodel(documentation="For a page that doesn't have another GenPreferencePage set as its parent, id of any other preference page to use as parent page may be set with this attribute")
	attr String[?] parentCategory;
	op GenDiagram getDiagram();
	op String getQualifiedClassName();
	op String getClassName();
}
// XXX existing page or parentCategory to insert into?

class GenCustomPreferencePage extends GenPreferencePage {
	attr String[1] qualifiedClassName;
	attr boolean generateBoilerplate = false;
	val GenPreference[*]#page preferences;
}

class GenStandardPreferencePage extends GenPreferencePage {
	attr StandardPreferencePages[1] kind;
	attr String[?] className;
}

enum StandardPreferencePages {
	General;
	Appearance;
	Connections;
	Printing;
	RulersAndGrid;
	Pathmaps;
}

class GenDiagramPreferences {
	attr Routing lineStyle;
	val GenFont defaultFont;
	val GenColor fontColor;
	val GenColor fillColor;
	val GenColor lineColor;
	val GenColor noteFillColor;
	val GenColor noteLineColor;
	attr boolean showConnectionHandles = true;
	attr boolean showPopupBars = true;
	attr boolean promptOnDelFromModel;
	attr boolean promptOnDelFromDiagram;
	attr boolean enableAnimatedLayout = true;
	attr boolean enableAnimatedZoom = true;
	attr boolean enableAntiAlias = true;
	attr boolean showGrid = false;
	attr boolean showRulers = false;
	attr boolean snapToGrid = true;
	attr boolean snapToGeometry = false;
	attr boolean gridInFront = true;
	attr RulerUnits rulerUnits;
	attr double gridSpacing;
	val GenColor gridLineColor;
	attr LineStyle gridLineStyle;
}

enum RulerUnits {
	INCHES;
	CENTIMETERS;
	PIXELS;
}

enum Routing {
	MANUAL;
	RECTILINEAR;
	TREE;
}

enum LineStyle {
	SOLID;
	DASH;
	DOT;
	DASHDOT;
	DASHDOTDOT;
	CUSTOM;
}

abstract interface GenFont {
}

class GenStandardFont extends GenFont {
	attr JFaceFont name;
}

enum JFaceFont {
	Default;
	Text;
	Banner;
	Dialog;
	Header;
}

class GenCustomFont extends GenFont {
	attr String name;
	attr int height;
	attr FontStyle style;
}

enum FontStyle {
	NORMAL;
	BOLD;
	ITALIC;
}

abstract interface GenColor {
}

class GenRGBColor extends GenColor {
	attr int[1] red;
	attr int[1] green;
	attr int[1] blue;
}

class GenConstantColor extends GenColor {
	attr DiagramColors name;
}

enum DiagramColors {
	buttonLightest;
	button;
	buttonDarker;
	buttonDarkest;
	listBackground;
	listForeground;
	menuBackground;
	menuForeground;
	menuBackgroundSelected;
	menuForegroundSelected;
	titleBackground;
	titleGradient;
	titleForeground;
	titleInactiveForeground;
	titleInactiveBackground;
	titleInactiveGradient;
	tooltipForeground;
	tooltipBackground;
	white;
	lightGray;
	gray;
	darkGray;
	black;
	red;
	orange;
	yellow;
	green;
	lightGreen;
	darkGreen;
	cyan;
	lightBlue;
	blue;
	darkBlue;
	diagramGreen;
	diagramLightRed;
	diagramRed;
	diagramLightBlue;
	diagramBlue;
	diagramLightGray;
	diagramGray;
	diagramDarkGray;
	diagramLightYellow;
	diagramDarkYellow;
	diagramLightGoldYellow;
	diagramBurgundyRed;
}

class GenPreference {
	readonly !resolve ref GenCustomPreferencePage[1]#preferences page;
	@genmodel(documentation="Java constant name")
	attr String[1] name;
	@genmodel(documentation="Preference key, derived from constant name if not set")
	attr String[?] key;
	attr String defaultValue;
}

////////////////////////
// Aspects of GenDiagram
//

abstract interface BatchValidation {
 	op String getValidationProviderQualifiedClassName();
	attr String validationProviderClassName;
	@deprecated(documentation="Validation action is no longer contributed via contributionItemProvider")
	attr ProviderPriority validationProviderPriority;
	@genmodel(documentation="Gets diagnostic marker type ID local to the editor plugin. The editor pluginID should be used to fully-qualify this ID.")
	op String getValidationDiagnosticMarkerType();
	op String getMarkerNavigationProviderQualifiedClassName();
	attr String markerNavigationProviderClassName;
	attr ProviderPriority markerNavigationProviderPriority;
	@genmodel(documentation="If enabled, ValidationAction is contributed by the editor plugin")
	attr boolean validationEnabled;
	op String getMetricProviderQualifiedClassName();
	attr String metricProviderClassName;
	@deprecated(documentation="Metrics action is no longer contributed via contributionItemProvider")
	attr ProviderPriority metricProviderPriority;	
	op String getMetricViewID();
	op String getValidationDecoratorProviderQualifiedClassName();  
	attr String validationDecoratorProviderClassName;
	attr boolean validationDecorators;
	attr ProviderPriority validationDecoratorProviderPriority;	
	attr boolean liveValidationUIFeedback;
}

abstract interface ProviderClassNames {
	// providers package class names
	op String getElementTypesQualifiedClassName();
	attr String elementTypesClassName;
	op String getNotationViewProviderQualifiedClassName();
	attr String notationViewProviderClassName;
	attr ProviderPriority notationViewProviderPriority;
	op String getEditPartProviderQualifiedClassName();
	attr String editPartProviderClassName;
	attr ProviderPriority editPartProviderPriority;
	op String getModelingAssistantProviderQualifiedClassName();
	attr String modelingAssistantProviderClassName;
	attr ProviderPriority modelingAssistantProviderPriority;
	op String getIconProviderQualifiedClassName();
	attr String iconProviderClassName;
	attr ProviderPriority iconProviderPriority;
	@deprecated(documentation="Replaced with GenParsers")
	op String getParserProviderQualifiedClassName();
	@deprecated(documentation="Replaced with GenParsers")
	attr String parserProviderClassName;
	@deprecated(documentation="Replaced with GenParsers")
	attr ProviderPriority parserProviderPriority;
	@deprecated(documentation="Actions are no longer contributed using ContributionItemService")
	op String getContributionItemProviderQualifiedClassName();
	@deprecated(documentation="Actions are no longer contributed using ContributionItemService")
	attr String contributionItemProviderClassName;
}

enum ProviderPriority {
	Lowest;
	Low;
	Medium;
	High;
	Highest;
}

abstract interface Shortcuts {
	op String getShortcutsDecoratorProviderQualifiedClassName();
	attr String shortcutsDecoratorProviderClassName;
	attr ProviderPriority shortcutsDecoratorProviderPriority;
	@deprecated(documentation="Use CreateShortcutAction instead")
	op String getCreateShortcutActionQualifiedClassName();
	@deprecated(documentation="Use CreateShortcutAction instead")
	attr String createShortcutActionClassName;
	op String getCreateShortcutDecorationsCommandQualifiedClassName();
	// XXX move and deprecate?
	attr String createShortcutDecorationsCommandClassName;
	op String getShortcutPropertyTesterQualifiedClassName();
	attr String shortcutPropertyTesterClassName;
	@genmodel(documentation="Set of domain meta-model file extensions. Elements of the corresponding models could be added as a shortcut on this diagram.")
	attr String[*] containsShortcutsTo;
	@genmodel(documentation="Set of domain meta-model names. Elements of this diagram domain model could be added as a shortcuts to the diagrams of the specified domains.")
	attr String[*] shortcutsProvidedFor;
	@deprecated(documentation="Use CreateShortcutAction instead")
	op boolean generateCreateShortcutAction();
	op boolean generateShortcutIcon();
}

abstract interface PackageNames {
	attr String editCommandsPackageName;
	attr String editHelpersPackageName;
	attr String editPartsPackageName;
	attr String editPoliciesPackageName;
	attr String preferencesPackageName;
	attr String	providersPackageName;
	@deprecated(documentation="Replaced with GenParsers")
	attr String	parsersPackageName;
	@deprecated(documentation="ViewFactories are no longer generated")
	attr String	notationViewFactoriesPackageName;
}

// FIXME introduce a separate entity to generate single class that keeps link constraints, model element selectors and initializers
// Do not use inner class in BaseItemSemanticEditPolicy
@deprecated(documentation="Operations supplied by this interface are hardly useful and will be removed soon")
abstract interface LinkConstraints {
	@genmodel(documentation="Indicates whether this diagram contains link creation constraints or not")
	@deprecated(documentation="LinkCreationConstants should be generated if diagram has any links")
	op boolean[1] hasLinkCreationConstraints();
	@genmodel(documentation="Gets the name of the constraints holder class")
	op String[1] getLinkCreationConstraintsClassName(); // FIXME rather, implementation detail? We may want to keep constraints not necessarily inside a class
	// and they are operations, anyway, can't modify the value.
	@genmodel(documentation="Gets the qualified name of the constraints holder class")
	op String[1] getLinkCreationConstraintsQualifiedClassName();	
}

abstract interface EditorCandies {
	// editor package class names
	op String getCreationWizardQualifiedClassName();
	attr String creationWizardClassName;
	op String getCreationWizardPageQualifiedClassName();
	attr String creationWizardPageClassName;
	attr String[1] creationWizardIconPath;
	readonly transient derived volatile attr String[1] creationWizardIconPathX;
	attr String creationWizardCategoryID;
	op String getDiagramEditorUtilQualifiedClassName();
	attr String diagramEditorUtilClassName;
	op String getDocumentProviderQualifiedClassName();
	attr String documentProviderClassName;
	@deprecated(documentation="Use InitDiagramAction instead")
	op String getInitDiagramFileActionQualifiedClassName();
	@deprecated(documentation="Use InitDiagramAction instead")
	attr String initDiagramFileActionClassName;
	op String getNewDiagramFileWizardQualifiedClassName(); // XXX move to initDiagramAction?
	attr String newDiagramFileWizardClassName;
	op String getDiagramContentInitializerQualifiedClassName();
	attr String diagramContentInitializerClassName;
	op String getMatchingStrategyQualifiedClassName(); // FIXME move to GenEditorView?
	attr String matchingStrategyClassName;
	op String getVisualIDRegistryQualifiedClassName();
	attr String visualIDRegistryClassName;
	op String getElementChooserQualifiedClassName();
	attr String elementChooserClassName;
	@deprecated(documentation="Use LoadResourceAction instead")
	op String getLoadResourceActionQualifiedClassName();
	@deprecated(documentation="Use LoadResourceAction instead")
	attr String loadResourceActionClassName;
	attr String editingDomainID;
	@deprecated(documentation="Use InitDiagramAction instead")
	op boolean generateInitDiagramAction();
}

abstract interface EditPartCandies {
	// edit commands package class names
	op String getReorientConnectionViewCommandQualifiedClassName();
	attr String reorientConnectionViewCommandClassName;
	// edit helpers package class names
	op String getBaseEditHelperQualifiedClassName();
	attr String baseEditHelperClassName;
	// edit parts package class names
	op String getEditPartFactoryQualifiedClassName();
	attr String editPartFactoryClassName;
	op String getBaseExternalNodeLabelEditPartQualifiedClassName();
	attr String baseExternalNodeLabelEditPartClassName;
	// edit policies package class names
	op String getBaseItemSemanticEditPolicyQualifiedClassName();
	attr String baseItemSemanticEditPolicyClassName;
	@deprecated(documentation="Not in use")
	op String getBaseGraphicalNodeEditPolicyQualifiedClassName();
	@deprecated(documentation="Not in use")
	attr String baseGraphicalNodeEditPolicyClassName; // FIXME delete and safely ignore on load
	op String getTextSelectionEditPolicyQualifiedClassName();
	attr String textSelectionEditPolicyClassName;
	op String getTextNonResizableEditPolicyQualifiedClassName();
	attr String textNonResizableEditPolicyClassName;
}

abstract interface MeasurementUnit {
	attr String units = "Pixel";
}

class GenDiagramUpdater {
	readonly !resolve ref GenEditorGenerator#diagramUpdater editorGen;
	op String getDiagramUpdaterQualifiedClassName();
	attr String diagramUpdaterClassName;
	op String getNodeDescriptorQualifiedClassName();
	attr String nodeDescriptorClassName;
	op String getLinkDescriptorQualifiedClassName();
	attr String linkDescriptorClassName;
	op String getUpdateCommandQualifiedClassName();
	attr String updateCommandClassName; // XXX isn't this is implementation detail and can be generated as a part of updater itself?
	attr String updateCommandID;
}

class GenPlugin {
	readonly !resolve ref GenEditorGenerator#plugin editorGen;
	attr String iD;
	attr String name;
	attr String provider = "Sample Plugin Provider, Inc";
	attr String version = "1.0.0.qualifier";
	attr boolean printingEnabled;
	@genmodel(documentation="Computed additional dependencies (in form of plug-in identifiers), including those explicitly specified by user and those derived from referenced genmodels")
	op String[*] getAllRequiredPlugins();
	unique attr String[*] requiredPlugins;
	// TODO getActivatorPackageName()
	op String getActivatorQualifiedClassName();
	attr String activatorClassName;
	// FIXME introduce JavaComplianceLevel
}

class DynamicModelAccess {
	readonly !resolve ref GenEditorGenerator#modelAccess editorGen;
	attr String packageName;
	attr String className = "MetaModelFacility";
	op String getQualifiedClassName();
}
/////////
// 

@genmodel(documentation = "One that combines attributes that are essential for diagram elements")
@constraints(
	ocl="styles->forAll(style|style.ecoreClass.eAllSuperTypes->including(style.ecoreClass)->one(ePackage.name = 'notation' and name = 'Style'))",
	description="Each style must be a notation::Style or sub-class")
abstract class GenCommonBase {
	ref genmodel.GenClass[1] diagramRunTimeClass;
	@genmodel(documentation="way to decide which editpart to use for specific diagram element. Maps to attribute in DRT.")
	@constraints(ocl="visualID >= 0", description="Visual ID must be a non-negative integer")
	attr int[1] visualID;
	val ElementType[?]#diagramElement elementType; // must be defined for diagram, nodes and links; must not be defined for other descendants
	attr String editPartClassName;
	op String getEditPartQualifiedClassName();
	attr String itemSemanticEditPolicyClassName;
	op String getItemSemanticEditPolicyQualifiedClassName();
	@deprecated(documentation="ViewFactories are no longer generated")
	attr String notationViewFactoryClassName;
	@deprecated(documentation="ViewFactories are no longer generated")
	op String getNotationViewFactoryQualifiedClassName();
	op GenDiagram getDiagram();
	op String getClassNamePrefix();
	@deprecated(documentation="No longer in use")
	op String getClassNameSuffux();
	@genmodel(documentation="This unique string identifier could be used to construct unique identifiers in generated java code")
	op String getUniqueIdentifier();
	val Viewmap[1] viewmap;
	op ViewmapLayoutType getLayoutType();
	ref genmodel.GenClass[*] styles;
	ordered val Behaviour[*]#subject behaviour;
	@genmodel(documentation="Indicates this element has no associated domain model. IOW, pure design element.")
	readonly derived volatile transient attr boolean sansDomain;
}

// TODO documentation=GEF's EditPolicy notion
abstract interface Behaviour {
	readonly !resolve ref GenCommonBase#behaviour subject; // TODO add documentation=subject is the way for generator to know policy's context. note, shared editpolicies are assumed to be ignorant of exact context.
	op String getEditPolicyQualifiedClassName();
}

@genmodel(documentation = "Custom user behaviour")
class CustomBehaviour extends Behaviour {
	@genmodel(documentation = "Key used to register edit policy in host edit part")
	attr String[1] key;
	// perhaps, add field to hold plugin id to import as dependency?
	attr String[1] editPolicyQualifiedClassName;
}

class SharedBehaviour extends Behaviour {
	// ? NOT (delegate instanceof CustomBehaviour) - no sense to reuse, unless to avoid fqn spreading around...
	// NOT (delegate instanceof SharedBehavior)
	ref Behaviour[1] delegate;
}

class OpenDiagramBehaviour extends Behaviour {
	attr String[1] editPolicyClassName;
	// attributes not set are assumed to point to owning GenDiagram.
	attr String[?] diagramKind;
	attr String[?] editorID;
	attr boolean openAsEclipseEditor = true;
}

// XXX add this class along with support in templates. Desperately need better name
//@genmodel(documentation="Allows to remove one of predefined edit policies") 
//class CancelBehaviour extends Behaviour {
//	attr String[1] key;
//}

abstract interface GenContainerBase extends GenCommonBase {
	readonly transient derived volatile ref GenNode[*] containedNodes;
	@genmodel(documentation="Returns child nodes that may be created in this container")
	op GenNode[*] getAssistantNodes();
	op boolean needsCanonicalEditPolicy(); // FIXME attribute with overridable value or anything else when switched to behaviour?
	op String getCanonicalEditPolicyQualifiedClassName();
	attr String canonicalEditPolicyClassName; // FIXME use behaviours instead and stop CenContainerBase extending GenCommonBase
}

@genmodel(documentation = "Base class for all ChildNode containers")
abstract class GenChildContainer extends GenContainerBase {
	ref GenChildNode[*]#containers childNodes;
}

@genmodel(documentation = "EClass mapped to Node")
@constraints(
	ocl="diagramRunTimeClass.ecoreClass.eAllSuperTypes->including(diagramRunTimeClass.ecoreClass)->one(ePackage.name = 'notation' and name = 'Node')", description="Node 'Diagram Runtime Class' must be a notation::Node or sub-class", 
	description="Node 'Diagram Runtime Class' must be a notation::Node or sub-class")
//@constraints(
//	ocl="childNodes->forAll(n|n.modelFacet.containmentMetaFeature.genClass.ecoreClass.isSuperTypeOf(self.getDomainMetaClass().ecoreClass))",
//	description="Node contains child nodes with 'Containment Feature' not available in the node 'Domain Element'"
//)
abstract class GenNode extends GenChildContainer, GenLinkEnd {
	val TypeModelFacet[?] modelFacet;
	@genmodel(documentation="Delegates to modelFacet")
	op genmodel.GenClass[1] getDomainMetaClass();
	val GenNodeLabel[*]#node labels;
	ref GenCompartment[*]#node compartments;
	@genmodel(documentation = "Custom primary drag edit policy")
	attr String primaryDragEditPolicyQualifiedClassName;
	@genmodel(documentation = "valid only when there are compartments")
	op String getGraphicalNodeEditPolicyQualifiedClassName();
	attr String graphicalNodeEditPolicyClassName;
	op String getCreateCommandQualifiedClassName();
	attr String createCommandClassName;
	readonly transient derived volatile ref GenLink[*] reorientedIncomingLinks;
}


// XXX GenTopNode, not GenTopLevelNode?
@constraints(
	ocl="not modelFacet.containmentMetaFeature.oclIsUndefined() implies modelFacet.containmentMetaFeature.genClass.ecoreClass.isSuperTypeOf(diagram.domainDiagramElement.ecoreClass)",
	description="Top level node 'Containment Feature' must be available in the diagram 'Domain Element' or its super-class"
)
class GenTopLevelNode extends GenNode {
	readonly !resolve ref GenDiagram[1]#topLevelNodes diagram;
}

@constraints(ocl="not modelFacet.oclIsUndefined() implies not modelFacet.containmentMetaFeature.oclIsUndefined()", description="Child node must specify 'Containment Meta Feature'")
class GenChildNode extends GenNode {
	readonly !resolve ref GenDiagram[1]#childNodes diagram;
	@constraints(ocl="let cmps:OrderedSet(GenChildContainer)=containers->select(oclIsKindOf(GenCompartment)) in cmps->exists(oclAsType(GenCompartment).listLayout) implies not cmps->exists(not oclAsType(GenCompartment).listLayout)", description="Node is referenced from multiple containers with different 'List Layout' value")
	readonly ref GenChildContainer[*]#childNodes containers;
}

class GenChildSideAffixedNode extends GenChildNode {
	attr String preferredSideName = "NONE";
}

@genmodel(documentation="Child node represented by label; typically hosted by list compartment")
class GenChildLabelNode extends GenChildNode {
	attr boolean labelReadOnly;
	attr boolean labelElementIcon;
	@genmodel(documentation="If model facet is not specified then custom parser should be provided for the label")
	val LabelModelFacet[?] labelModelFacet;
	@genmodel(documentation="Returns structural features that provide label content")
	op genmodel.GenFeature[*] getLabelMetaFeatures();
}

@genmodel(documentation = "Child container within node. Compartment, iow.")
//@constraints(
//	ocl="childNodes->forAll(n|n.modelFacet.containmentMetaFeature.genClass.ecoreClass.isSuperTypeOf(node.getDomainMetaClass().ecoreClass))",
//	description="Compartment contains child nodes with 'Containment Feature' not available in the compartment containing node 'Domain Element'"
//)
class GenCompartment extends GenChildContainer {
	attr String title;
	attr boolean canCollapse = true;
	attr boolean hideIfEmpty = true;
	attr boolean needsTitle = true;
	readonly !resolve ref GenDiagram[1]#compartments diagram;
	ref GenNode[1]#compartments node;
	attr boolean listLayout = true;
}

@constraints(ocl="diagramRunTimeClass.ecoreClass.eAllSuperTypes->including(diagramRunTimeClass.ecoreClass)->one(ePackage.name = 'notation' and name = 'Edge')", description="Link 'Diagram Runtime Class' must be a notation::Edge or sub-class")
class GenLink extends GenCommonBase, GenLinkEnd {
	readonly !resolve ref GenDiagram[1]#links diagram;
	val LinkModelFacet[?] modelFacet;
	val GenLinkLabel[*]#link labels;
	@genmodel(documentation = "Support link creation from source to target")
	attr boolean outgoingCreationAllowed = true;
	@genmodel(documentation = "Support link creation from target to source")
	attr boolean incomingCreationAllowed = false;
	@genmodel(documentation = "View (Edge) will always be directed from model source to model target")
	attr boolean viewDirectionAlignedWithModel = true;
	@genmodel(documentation="Specifies additional restrictions on link creation")
	val GenLinkConstraints#link creationConstraints;	
	@genmodel(documentation = "Support link target reorienting")
	attr boolean targetReorientingAllowed = true;
	@genmodel(documentation = "Support link source reorienting")
	attr boolean sourceReorientingAllowed = true;
	@genmodel(documentation="Returns link sources in this genmodel")
	op GenCommonBase[*] getAssistantSources();
	@genmodel(documentation="Returns link targets in this genmodel")
	op GenCommonBase[*] getAssistantTargets();
	op String getCreateCommandQualifiedClassName();
	attr String createCommandClassName;
	op String getReorientCommandQualifiedClassName();
	attr String reorientCommandClassName;
	attr boolean treeBranch = true;

	// FIXME Implementation of sources and targets now give empty result if link has no modelFacet. 
	// HOWEVER, before addition of GenLinkEnd, we seemed to assume that link without model facet can be 
	// drawn to any node on the diagram (e.g. see NavigatorHandler#getSourceGenNodes()). Would be great to
	// make that consistent.
	readonly volatile transient derived ref GenLinkEnd[*] sources;
	readonly volatile transient derived ref GenLinkEnd[*] targets;
}

// DON'T forget about same op name bug in emfatic->ecore - arg types are lost

// perhaps, we need some kind of item provider for labels
// which is capable of returing 'design', 'full', 'short' kinds of name?
@genmodel(documentation = "Label on diagram")
abstract class GenLabel extends GenCommonBase {
	attr boolean readOnly;
	attr boolean elementIcon;
	@genmodel(documentation="If model facet is not specified then custom parser should be provided for the label")
	val LabelModelFacet[?] modelFacet;
	@genmodel(documentation="Returns structural features that provide label content")
	op genmodel.GenFeature[*] getMetaFeatures();
}

@genmodel(documentation = "Label within node")
@constraints(
	ocl="getMetaFeatures()->forAll(f|f.ecoreFeature.eContainingClass.isSuperTypeOf(node.getDomainMetaClass().ecoreClass))",
	description="Node label meta features must be owned by the node 'Meta Class' or its super-classes"	
)
class GenNodeLabel extends GenLabel {
	readonly !resolve ref GenNode[1]#labels node;
}

@genmodel(documentation = "Label attached to node")
class GenExternalNodeLabel extends GenNodeLabel {
}

@genmodel(documentation = "Label attached to link")
@constraints(
	ocl="modelFacet.oclIsTypeOf(FeatureLabelModelFacet)=true implies link.modelFacet.oclIsTypeOf(TypeLinkModelFacet)", 
	description="Feature based link labels can only be used on link with class (TypeLinkModelFacet)"
)
@constraints(
	ocl="let tl: TypeLinkModelFacet = link.modelFacet.oclAsType(TypeLinkModelFacet) in not tl.oclIsUndefined() implies self.getMetaFeatures()->forAll(f|f.ecoreFeature.eContainingClass.isSuperTypeOf(tl.metaClass.ecoreClass))",
	description="Link label meta features must be owned by the node 'Meta Class' or its super-classes"
)
class GenLinkLabel extends GenLabel {
	ref GenLink[1]#labels link;
	attr LinkLabelAlignment alignment = "MIDDLE";
}

@genmodel(documentation="Constants from {@link org.eclipse.draw2d.ConnectionLocator}")
enum LinkLabelAlignment {MIDDLE = 4; TARGET = 3; SOURCE = 2;}

@genmodel(documentation="Base element type")
abstract class ElementType {
	ref GenCommonBase[1]#elementType diagramElement;
	attr String[1] uniqueIdentifier;
	@genmodel(documentation="When there's palette, defaults to title of first tool that uses element with this type")
	attr String displayName;
	attr boolean definedExternally;
}

@genmodel(documentation="Element type based on ecore type")
class MetamodelType extends ElementType {
	attr String editHelperClassName;
	op String getEditHelperQualifiedClassName();
	op genmodel.GenClass getMetaClass();
}

@genmodel(documentation="Specialization of metamodel type")
class SpecializationType extends ElementType {
	ref MetamodelType metamodelType; // specializes org.eclipse.gmf.runtime.emf.type.core.null if not set
	op genmodel.GenClass getMetamodelClass();
	attr String editHelperAdviceClassName;
	op String getEditHelperAdviceQualifiedClassName();
}

@genmodel(documentation="Pure design element")
class NotationType extends ElementType {
}

//////////////
// Model Facet
//////////////

@genmodel(documentation="Marker interface for the particular model facets")
abstract interface ModelFacet {
}

@genmodel(documentation="Model facet of links")
abstract interface LinkModelFacet extends ModelFacet {
	op genmodel.GenClass getSourceType();
	op genmodel.GenClass getTargetType();
	op genmodel.GenClass[*] getAssistantSourceTypes();
	op genmodel.GenClass[*] getAssistantTargetTypes();
}

// FIXME As long it's not longer an interface but a class with Parser reference,
// update old convention of null LabelModelFacet to get replaced with bare LabelModelFacet
// pointing to an ExternalParser instance.
@genmodel(documentation="Model facet of labels")
class LabelModelFacet extends ModelFacet {
	ref GenParserImplementation[1]#uses parser;
}

// 'semantic' model facets

@genmodel(documentation="Model facet of an EClass")
class TypeModelFacet extends ModelFacet {
	ref genmodel.GenClass[1] metaClass; // FIXME obsolete comment: not ecore.Classifier because neither datatypes not enums from domain metamodel won't appear as diagram nodes
	@constraints(
		ocl="let r: ecore::EReference=containmentMetaFeature.ecoreFeature.oclAsType(ecore::EReference) in not containmentMetaFeature.oclIsUndefined() implies r.containment or r.eReferenceType.isSuperTypeOf(metaClass.ecoreClass)",
		description="'Containment Meta Feature' must reference 'Meta Class' or its super-classes"
	)
	ref genmodel.GenFeature[?] containmentMetaFeature;
	@genmodel(documentation="Usually the same as containmentMetaFeature, unless you need to distinguish where to put and where to get from")
	@constraints(
		ocl="not childMetaFeature.oclIsUndefined() implies childMetaFeature.ecoreFeature.oclAsType(ecore::EReference).eReferenceType.isSuperTypeOf(metaClass.ecoreClass)",
		description="'Child Meta Feature' must reference 'Meta Class' or its sub-classes"
	)
	ref genmodel.GenFeature[?] childMetaFeature;
	op boolean isPhantomElement();
	@genmodel(documentation="Selection criterion for domain model elements associated with this type model facet")
	@meta(def="context", ocl="metaClass.ecoreClass")	
	ref GenConstraint[?] modelElementSelector;
	@genmodel(documentation="State initializer for domain model elements associated with this type model facet")	
	val GenElementInitializer modelElementInitializer;
}

// 'combined' model facets

@genmodel(documentation="Model facet of an EClass that associates two EClasses")
@constraints(ocl="not containmentMetaFeature.oclIsUndefined()", description="Link 'Containment Meta Feature' must be specified")
class TypeLinkModelFacet extends TypeModelFacet, LinkModelFacet {
	@genmodel(documentation="If source feature is not specified then link container is a link source")
	@constraints(
		ocl="not sourceMetaFeature.oclIsUndefined() implies sourceMetaFeature.genClass.ecoreClass.isSuperTypeOf(metaClass.ecoreClass)", 
		description="Link 'Source Meta Feature' must be owned by link 'Meta Class' or its super-class"
	)
	ref genmodel.GenFeature sourceMetaFeature;
	@constraints(
		ocl="not targetMetaFeature.oclIsUndefined() implies targetMetaFeature.genClass.ecoreClass.isSuperTypeOf(metaClass.ecoreClass)",
		description="Link 'Target Meta Feature' must be owned by link 'Meta Class' or its super-class"
	)
	ref genmodel.GenFeature[1] targetMetaFeature;
}

@genmodel(documentation="Model facet of a feature-based link")
class FeatureLinkModelFacet extends LinkModelFacet {
	@constraints(
		ocl="metaFeature.ecoreFeature.unique", 
		description="All references are unique in EMF due to the current code generation"
	)
	ref genmodel.GenFeature[1] metaFeature;
}

@genmodel(documentation="Model facet of label based on domain model attribute(s)")
class FeatureLabelModelFacet extends LabelModelFacet {
	ref genmodel.GenFeature[1..*] metaFeatures;
	ref genmodel.GenFeature[*] editableMetaFeatures;
	@genmodel(documentation="Pattern to produce label on diagram, depends on view method")
	attr String viewPattern;
	@genmodel(documentation="Pattern to produce text for inplace editor, depends on view method; if not specified then viewPattern should be used")
	attr String editorPattern;
	@genmodel(documentation="Pattern to extract values from input text, depends on edit method; if not specified then viewPattern should be used")
	attr String editPattern;
	@deprecated(documentation="Replaced with GenParsers and PredefinedParser")
	attr LabelTextAccessMethod viewMethod;
	@deprecated(documentation="Replaced with GenParsers and PredefinedParser")
	attr LabelTextAccessMethod editMethod;
}

enum LabelTextAccessMethod {
	MESSAGE_FORMAT; // java.text.MessageFormat
	NATIVE; // EcoreUtil.convertToString(...) / EcoreUtil.createFromString(...)
	REGEXP; // String.split(...)
	PRINTF; // String.format(...)
}

@genmodel(documentation="Model facet of a label with DescriptionStyle")
class DesignLabelModelFacet extends LabelModelFacet {
}

@genmodel(documentation="Model facet of a label calculated with an expression")
class ExpressionLabelModelFacet extends LabelModelFacet {
	// right now it is just a marker, in case we need extra information in future 
	// ExpressionLabelParser doesn't rely on any specific kind of model facet.
	// XXX perhaps, we may try to use other LabelModelFacets (e.g. FeatureLabelModelFacet) to generate 
	// extra support (i.e. handle notification changes based on #features)
}

/////////////
// View Facet
/////////////

@genmodel(documentation = "Captures aspects of variuos draw2d classes")
abstract interface Attributes {
}

@genmodel(documentation = "Deprecated, use StyleAttributes instead")
class ColorAttributes extends Attributes {
	attr String foregroundColor;
	attr String backgroundColor;
}

class StyleAttributes extends Attributes {
	attr boolean fixedFont = false;
	attr boolean fixedForeground = false;
	attr boolean fixedBackground = false;
}

@genmodel(documentation="Bit-wise OR of any {@link org.eclipse.draw2d.PositionConstants#NORTH}, {@link org.eclipse.draw2d.PositionConstants#SOUTH}, {@link org.eclipse.draw2d.PositionConstants#EAST} or {@link org.eclipse.draw2d.PositionConstants#WEST}")
class ResizeConstraints extends Attributes {
	@genmodel(documentation="Any direction mentioned here (and combination thereof, like e.g. NORTH_WEST) is added as resizable handle")
	attr int resizeHandles = 0;
	@genmodel(documentation="Directions mentioned with this attribute are explicitly denoted as non-resizable (i.e. with 'move' cursor). If you'd like to omit handle {@link org.eclipse.gef.editpolicies.ResizableEditPolicy#createSelectionHandles} completely, just don't list it here")
	attr int nonResizeHandles = 0;
	@genmodel(documentation="Convenient method to get {@link org.eclipse.draw2d.PositionConstants} names from resizeHandle attribute")
	readonly volatile transient derived attr String[*] resizeHandleNames;
	@genmodel(documentation="Same as {@link #getResizeHandleNames()}, for nonResizeHandle attribute")
	readonly volatile transient derived attr String[*] nonResizeHandleNames;
}

class DefaultSizeAttributes extends Attributes {
	attr int width = 40;
	attr int height = 30;
}

class LabelOffsetAttributes extends Attributes {
	attr int x;
	attr int y;
}

abstract class Viewmap {
	val Attributes[*] attributes;
	@genmodel(documentation = "Returns first attributes instance of specified class, if any")
	op Attributes find(Class attributesClass); // didn't like EClass.isInstance, when there's easy Java way
	// besides, with j.l.Class we could eventualy use Class<T> mechanism from Java5 to avoid casts
	attr String[*] requiredPluginIDs;
	attr ViewmapLayoutType layoutType = "UNKNOWN";
}

enum ViewmapLayoutType {
	UNKNOWN;
	XY_LAYOUT;
	FLOW_LAYOUT;
	TOOLBAR_LAYOUT;
}

class FigureViewmap extends Viewmap {
	@genmodel(documentation="Name of GEF Figure class")
	attr String[1] figureQualifiedClassName;
}

// XXX for NodeEditPart#getPrimaryShape() I need figure's FQN. 
// Full RT doesn't generate this method, although makes no precautions not to use it from outside
// Lite RT generates (null) in this case.
class SnippetViewmap extends Viewmap {
	attr String body;
}

class InnerClassViewmap extends Viewmap {
	attr String className;
	attr String classBody;
}

@genmodel(documentation="Figure (with specified class name, if any) will be assigned by (or should be taken from) parent")
class ParentAssignedViewmap extends Viewmap {
	@genmodel(documentation="Access figure from parent's figure")
	attr String[1] getterName;
	@genmodel(documentation="Child could provide typed alternative to setFigure() method")
	attr String[?] setterName;
	@genmodel(documentation="When specified, type of child's figure")
	attr String[?] figureQualifiedClassName;
}

@genmodel(documentation="NOTE: Provisional API. Allows to use arbitrary model element to keep information about a figure. May (but not necessarily will) point to e.g. GMFGraph model elements. It's up to template author to handle specific kinds of figure models")
class ModeledViewmap extends Viewmap {
	ref EObject[1] figureModel;
}

@genmodel(documentation="Expression as a is textual statement which results in a value when evaluated in a context")
@meta(def="ValueSpec")
class ValueExpression {
	@genmodel(documentation="The text of the expression")
	@meta(def="body")
	attr String[1] body;
	@genmodel(documentation="Returns valid String literal for the given <code>String</code> as it should appear in java source code.")
	op String getBodyString();
	@meta(def="lang")
	readonly volatile transient derived attr String langName; // XXX what's this for?
	readonly !resolve ref GenExpressionProviderBase[1]#expressions provider;
}

@genmodel(documentation="Boolean type value expression which is to be evaluated in a context")
@meta(def="Constraint")
class GenConstraint extends ValueExpression {
}

//////////
// Palette
//////////

class Palette {
	readonly !resolve ref GenDiagram[1]#palette diagram;
	attr boolean flyout = true;
	@genmodel(documentation="GEF allows only containers as palette immediate children")
	ordered val ToolGroup[+]#palette groups;
	attr String packageName;
	attr String factoryClassName;
	op String getFactoryQualifiedClassName();
	op boolean definesStandardTools();
}

abstract class EntryBase {
	attr String title;
	attr String description;
	attr String largeIconPath;
	attr String smallIconPath;
	attr String createMethodName;
	@genmodel(documentation="Non-mandatory string identification of the entry. Defaults to the quoted value of createMethodName, clients may override. Set to blank string if don't need the identity")
	attr String ~id;
}

abstract class AbstractToolEntry extends EntryBase, ToolGroupItem {
	attr boolean default = false;
	@genmodel(documentation="Optional")
	attr String qualifiedToolName;
	val ecore.EStringToStringMapEntry[*] properties;
}

class ToolEntry extends AbstractToolEntry {
	// FIXME: constraint="only one of these lists may contain elements"
	ref GenNode[*] genNodes;
	ref GenLink[*] genLinks;
	@genmodel(documentation="Enforces 'tool for either node or link' - if there are values in genNodes list, returns it (no respect to values in genLinks); returns value of genLinks otherwise")
	readonly derived transient volatile ref GenCommonBase[*] elements;
}

class StandardEntry extends AbstractToolEntry {
	attr StandardEntryKind[1] kind;
}

enum StandardEntryKind {
	SELECT; MARQUEE; ZOOM; 
}

abstract interface ToolGroupItem {
	readonly !resolve ref ToolGroup[?]#entries group; // optional because of groups contained in Palette
}

class Separator extends ToolGroupItem {
}

class ToolGroup extends EntryBase, ToolGroupItem {
	readonly !readonly ref Palette[1]#groups palette;
	attr boolean stack;
	attr boolean collapse;
	ordered val ToolGroupItem[+]#group entries;
	readonly derived transient volatile attr boolean toolsOnly;
}

@genmodel(documentation="Base class for initializers of domain model elements")
abstract interface GenElementInitializer {
	@genmodel(documentation="The type model facet whose domain model element is to be intialized by this initializer")
	readonly volatile transient ref TypeModelFacet[1] typeModelFacet;
}

@genmodel(documentation="Feature sequence initializer")
class GenFeatureSeqInitializer extends GenElementInitializer {
	@genmodel(documentation="Value specifications as initializers for individual features which should be initialized in the order given by this list")
	val GenFeatureInitializer[+]#featureSeqInitializer initializers;
	@constraints(ocl="not creatingInitializer.feature.oclIsUndefined() implies creatingInitializer.feature.ecoreFeature.oclAsType(ecore::EReference).eReferenceType.isSuperTypeOf(elementClass.ecoreClass)", description="'elementClass' must be the same as or sub-type of the containing 'GenReferenceNewElementSpec' reference type")
	@constraints(ocl="not creatingInitializer.feature.oclIsUndefined() implies not (elementClass.ecoreClass.interface or elementClass.ecoreClass.abstract)", description="'elementClass' must be a concrete EClass which is the same or sub-type of the containing 'GenReferenceNewElementSpec' reference type")
	ref genmodel.GenClass elementClass;
	readonly !resolve ref GenReferenceNewElementSpec#newElementInitializers creatingInitializer;	
}

@genmodel(documentation="Value specification associated with a specific feature")
class GenFeatureValueSpec extends GenFeatureInitializer {
	// next meta is pure guess
	@meta(def="context", ocl="featureSeqInitializer.elementClass")
	ref ValueExpression[1] value;
}

@constraints(ocl="feature <> null implies feature.ecoreFeature.oclIsKindOf(ecore::EReference)", description="'feature' of 'GenReferenceNewElementSpec' must refer to ecore::EReference")
class GenReferenceNewElementSpec extends GenFeatureInitializer {
	val GenFeatureSeqInitializer[+]#creatingInitializer newElementInitializers;
}

abstract interface GenFeatureInitializer {
	@GenModel(documentation="The feature for which is to be initialized by this initializer")
	@constraints(ocl="feature <> null implies not featureSeqInitializer.initializers->exists(i| i <> self and i.feature = self.feature)", description="The feature is already initialized by another 'GenFeatureInitializer' in the sequence")
	@constraints(ocl="feature <> null implies feature.ecoreFeature.eContainingClass.isSuperTypeOf(featureSeqInitializer.elementClass.ecoreClass)", description="The 'feature' of 'GenFeatureInitializer' must be available in 'Meta Class' of the initialized element")
	ref genmodel.GenFeature[1] feature;
	readonly !resolve ref GenFeatureSeqInitializer[1]#initializers featureSeqInitializer;
}

@genmodel(documentation="Groups constraints on the link source and target end")
@constraints(ocl="not sourceEnd.oclIsUndefined() or not targetEnd.oclIsUndefined()", description="Either 'sourceEnd' or 'targetEnd' constraint must be specified")
class GenLinkConstraints {

	@genmodel(documentation="The domain meta element class of the link restricted by this constraints")
	op genmodel.GenClass getLinkClass();

	@genmodel(documentation="The context class for the source end constraint evaluation")
	op genmodel.GenClass getSourceEndContextClass();

	@genmodel(documentation="The context class for the target end constraint evaluation")
	op genmodel.GenClass getTargetEndContextClass();

	@genmodel(documentation="Returns the name of the field holding Link Constraints instance")
	op String[1] getConstraintsInstanceFieldName();

	@genmodel(documentation="References the owning link of this constraints")
	ref GenLink[1]#creationConstraints link;

	@genmodel(documentation="Restriction enforced by the the source end, may reference variables 'oppositeEnd' pointing to targetEnd and 'link' denoting the link domainmetaElement instance if available.")
	@meta(def="context", ocl="getSourceEndContextClass().ecoreClass")
	@meta(def="variable", name="oppositeEnd", type.ocl="getTargetEndContextClass().ecoreClass")
	ref GenConstraint[?] sourceEnd;

	@genmodel(documentation="Restriction enforced by the the target end, may reference variables 'oppositeEnd' pointing to sourceEnd and 'link' denoting the link domainmetaElement instance if available.")
	@meta(def="context", ocl="getTargetEndContextClass().ecoreClass")
	@meta(def="variable", name="oppositeEnd", type.ocl="getSourceEndContextClass().ecoreClass")
	ref GenConstraint[?] targetEnd;
	
	op boolean isValid();
}

class GenAuditRoot {
	readonly !resolve ref GenEditorGenerator[1]#audits editorGen;
	val GenAuditContainer[*]#root categories;
	val GenAuditRule[*]#root rules;
	val GenAuditContext[*]#root clientContexts;
	// getAllTargetedModelPackages: rules.select(r | r.target != null && r.target.targetClass != null).collect(r | r.target.targetClass.genPackage)
	// hasDiagramElementRule: rules.target.typeSelect(GenDiagramElementTarget).size > 0 || rules.target.typeSelect(GenNotationElementTarget).size() > 0
}

@genmodel(documentation="Represents constraint category of emft.validation framework")
class GenAuditContainer {
	readonly !resolve ref GenAuditRoot[1]#categories root;

	@genmodel(documentation="Identifier which is unique within the scope of its parent container.")
	attr String[1] ~id;

	@genmodel(documentation="A human readable name for the category of audits organized in this container")
	attr String name;

	@genmodel(documentation="The detailed description of this audit container")
	attr String description;

	@genmodel(documentation="Hierarchical path of this audit container as ordered list of containers beginning with the root and ended with this container")
	ordered ref GenAuditContainer[+] path;

	ref GenAuditRule[*]#category audits;
}

@genmodel(documentation="Base class for rule like audit, metric rules...")
abstract class GenRuleBase {
	@genmodel(documentation="A human readable name of this rule")
	attr String name;

	@genmodel(documentation="The detailed description of this rule semantics")
	attr String description;
}

@genmodel(documentation="Auditing rule in the form of a constraint evaluated against its target")
class GenAuditRule extends GenRuleBase {
	readonly !resolve ref GenAuditRoot[1]#rules root;

	op String getConstraintAdapterQualifiedClassName();

	@genmodel(documentation="Unique identifier of this audit rule")
	@constraints(ocl="not id.oclIsUndefined() implies root.rules->one(i | i.id = self.id)", description="Audit rule with the same ID already exists")		
	attr String[1] ~id;

	@genmodel(documentation="A boolean type condition which if not satisfied indicates this audit rule violation. It is evaluated in the context of the target")
	@meta(def="context", ocl="target.getContext()")
	ref GenConstraint[1] rule;
	
	@genmodel(documentation="The target representing the context this audit is evaluated in")
	val GenAuditable[1] target;	

	@genmodel(documentation="The text message to be reported in case of this audit violation")
	attr String message;
	
	@genmodel(documentation="Describes the severity of this audit rule violation")
	attr GenSeverity severity = "ERROR"; // XXX String? if xml is the only use

	@genmodel(documentation="Indicates if this audit should be evaluated also in Live mode. If 'false', only Batch mode is applicable")
	attr boolean useInLiveMode = false;

	readonly derived transient volatile attr boolean requiresConstraintAdapter;

	ref GenAuditContainer[1]#audits category;
	op String[1] getConstraintAdapterLocalClassName();
}

enum GenSeverity {
	INFO;
	WARNING;
	ERROR;
}

@genmodel(documentation="The target against which a rule can be evaluated")
abstract interface GenRuleTarget {

	@genmodel(documentation="Gets the classifier to be used as this rule target evaluation context")
	op genmodel.GenClassifier[1] getContext();
}

@genmodel(documentation="Target for rules applied on domain model elements")
class GenDomainElementTarget extends GenAuditable, GenMeasurable {

	@genmodel(documentation="Targeted domain model element")
	ref genmodel.GenClass[1] element;
}

@genmodel(documentation="Target for rules applied on diagram notation model selectively, for specific visualized element")
class GenDiagramElementTarget extends GenAuditable, GenMeasurable {

	// XXX Radek? unclear why only GenNodes are allowed?
	@genmodel(documentation="Targeted visualized element")
	@constraints(ocl="element <> null and element->size() > 1 implies element->forAll(oclIsKindOf(GenNode))", description="Multiple diagram elements must be GenNode type conformant")
	ref GenCommonBase[+] element;
}

@GenModel(documentation="Represents value based target, useful for audit rules expression not capable of ecore meta-model access")
class GenDomainAttributeTarget extends GenAuditable {
	@constraints(ocl="attribute.ecoreFeature.oclIsKindOf(ecore::EAttribute)", description="EAttribute element required for auditable domain attribute")
	ref genmodel.GenFeature[1] attribute;
	@GenModel(documentation="Indicates whether null value of the attribute is reported as audit failure or success")
	attr boolean nullAsError; // XXX null for EAttribute is rather odd expectation, perhaps, better check defaultValueIsError?
}

@genmodel(documentation="Target for rules applied on diagram notation model elements")
class GenNotationElementTarget extends GenAuditable, GenMeasurable {

	@genmodel(documentation="Targeted diagram notation model element")
	@constraints(ocl="element.ecoreClass.eAllSuperTypes->including(element.ecoreClass)->one(ePackage.name = 'notation' and name = 'View')", description="'notation::View' or its sub-class must be set to NotationElement target")
	ref genmodel.GenClass[1] element;
}

class GenMetricContainer {
	readonly !resolve ref GenEditorGenerator[1]#metrics editorGen;
	val GenMetricRule[+]#container metrics;
}

@constraints(ocl="not lowLimit.oclIsUndefined() and not highLimit.oclIsUndefined()  implies lowLimit < highLimit", description="Metric value 'lowLimit' must be smaller then 'highLimit'")
class GenMetricRule extends GenRuleBase {

	@genmodel(documentation="Unique key identifying this metric an abbreviation for this metric")
	@constraints(ocl="not key.oclIsUndefined() implies container.metrics->one(i | i.key = self.key)", description="Metric rule with the same 'key' already exists")		
	attr String[1] key;

	@genmodel(documentation="Expression that calculates the value of this metric which is of EDataType that encapsulates java.lang.Number subclasses or their primitives")
	@meta(def="context", ocl="target.getContext()")
	@meta(def="type", ocl="'ecore::EDoubleObject'")
	ref ValueExpression[1] rule;

	@genmodel(documentation="The target representing the context this metric is evaluated in")
	val GenMeasurable[1] target;

	attr Double lowLimit;
	attr Double highLimit;

	@genmodel(documentation="The containing metric container of this metric rule")
	ref GenMetricContainer[1]#metrics container;
}

@genmodel(documentation="Target metric which can be evaluated by audit rule. The target context here is the metric rule resulting type classifier")
class GenAuditedMetricTarget extends GenAuditable {

	@genmodel(documentation="Metric wich can be involved in audit")
	ref GenMetricRule[1] metric;
	ref genmodel.GenDataType[1] metricValueContext; // XXX seems this value is not in use
}

// FIXME: perhaps, GenAuditContext should be referenced from another place than GenAuditable - as it effectively
// makes all metric targets aware of auditContext which is useless for them
@genmodel(documentation="Target suitable for auditing")
abstract class GenAuditable extends GenRuleTarget {
	@genmodel(documentation="To apply audit to this target, we need to select appropriate input, and here's selector that helps with that")
	ref GenAuditContext[?]#ruleTargets contextSelector;
  @genmodel(documentation="Gets the validation target class in terms of EMFT validation framework.")
  op genmodel.GenClass getTargetClass();
  @genmodel(documentation="Consists of ecore meta-model only package names and target class simple name")
  op String getTargetClassModelQualifiedName();
}

@genmodel(documentation="")
class GenAuditContext {
	!resolve ref GenAuditRoot[1]#clientContexts root;
	@genmodel(documentation="Identifier of the validation client context for this target. Should be a valid java identifier. Identifier will be qualified automatically (i.e. should be unique within this editor only).")
	attr String[1] ~id = "DefaultCtx"; // former GenAuditable#getClientContextID()
	@genmodel(documentation="Unless explicitly set, equals to 'id'. Note, this class may get generated as inner class.")
	attr String[1] className;
	op String[1] getQualifiedClassName();
	ref GenAuditable[*]#contextSelector ruleTargets;
	// TODO may add isDefault attribute to generate extpoint completely
}

@genmodel(documentation="Marker interface for anything that can be subject to metrics")
abstract interface GenMeasurable extends GenRuleTarget {
}

class GenExpressionProviderContainer {
	op String[1] getAbstractExpressionQualifiedClassName();
	attr String expressionsPackageName;
	attr String abstractExpressionClassName;
	val GenExpressionProviderBase[*]#container providers;
	readonly !resolve ref GenEditorGenerator[1]#expressionProviders editorGen;
}

abstract class GenExpressionProviderBase {
	op GenLanguage[1] getLanguage();
	val ValueExpression[+]#provider expressions;
	readonly !resolve ref GenExpressionProviderContainer[1]#providers container;
}

class GenJavaExpressionProvider extends GenExpressionProviderBase {
	@genmodel(documentaion="Whether to generate default implementation that rises RuntimeException to signal unimplemented method")
	attr boolean throwException = true;
	@genmodel(documentaion="When 'true', body of associated ValueExpression would get injected into Java code as-is, thus allowing to provide method implementations right within the model. Note, if body is empty, default implementation would be generated instead.")
	attr boolean injectExpressionBody = false;
	// NOTE, both throwException and injectExpressionBody are placed here
	// intentionally. Though it's possible to specify them on per-expression
	// basis, it doesn't sound reasonable and handy (usable).
}

class GenExpressionInterpreter extends GenExpressionProviderBase {
	op String[1] getQualifiedClassName();
	op String getExpressionAccessor(ValueExpression[1] expression); // TODO move to .ext
	attr GenLanguage[1] language;
	attr String className;
}

@genmodel(documentation="GenLiteralExpressionProvider#getLanguage() == GenLanguage.LITERAL")
class GenLiteralExpressionProvider extends GenExpressionProviderBase {
}

// XXX perhaps, there's no much value in this enum. Some expressionproviders has fixed language, 
// and some (especially, regex and nregex), might be better to solve with boolean attr
enum GenLanguage {
	ocl = 0;
	java = 1;
	regexp = 2;
	nregexp = 3;
	literal = 4;
}

////////////
// Navigator
////////////

abstract interface GenDomainModelNavigator {
	attr boolean generateDomainModelNavigator = true;
	attr String domainContentExtensionID;
	attr String domainContentExtensionName;
	attr String domainContentExtensionPriority;
	op String getDomainContentProviderQualifiedClassName();
	attr String domainContentProviderClassName;
	op String getDomainLabelProviderQualifiedClassName();
	attr String domainLabelProviderClassName;
	@deprecated(documentation="DomainModelElementTester class will not be generated annymore")
	op String getDomainModelElementTesterQualifiedClassName();
	@deprecated(documentation="DomainModelElementTester class will not be generated annymore")
	attr String domainModelElementTesterClassName;
	op String getDomainNavigatorItemQualifiedClassName();
	attr String domainNavigatorItemClassName;
}

class GenNavigator  extends GenDomainModelNavigator {
	readonly !resolve ref GenEditorGenerator#navigator editorGen;
	attr String contentExtensionID;
	attr String contentExtensionName;
	attr String contentExtensionPriority;
	attr String linkHelperExtensionID;
	attr String sorterExtensionID;
	attr String actionProviderID;
	op String getContentProviderQualifiedClassName();
	attr String contentProviderClassName;
	op String getLabelProviderQualifiedClassName();
	attr String labelProviderClassName;
	op String getLinkHelperQualifiedClassName();
	attr String linkHelperClassName;
	op String getSorterQualifiedClassName();
	attr String sorterClassName;
	op String getActionProviderQualifiedClassName();
	attr String actionProviderClassName;
	op String getAbstractNavigatorItemQualifiedClassName();
	attr String abstractNavigatorItemClassName;
	op String getNavigatorGroupQualifiedClassName();
	attr String navigatorGroupClassName;
	op String getNavigatorItemQualifiedClassName();
	attr String navigatorItemClassName;
	op String getUriInputTesterQualifiedClassName();
	attr String uriInputTesterClassName;
	attr String packageName;
	
	val GenNavigatorChildReference[*]#navigator childReferences;
}

enum GenNavigatorReferenceType {
	children = 0;
	out_target = 1;
	in_source = 2;
}

class GenNavigatorChildReference {
	readonly !resolve ref GenNavigator#childReferences navigator;
// Top-level references has no parent
	ref GenCommonBase parent;
	ref GenCommonBase[1] child;
	attr GenNavigatorReferenceType[1] referenceType;
	
	attr String groupName;
	attr String groupIcon;
	attr boolean hideIfEmpty = true;
	op boolean isInsideGroup();
	op GenNavigatorPath[*] findConnectionPaths();
}

class GenNavigatorPath {
	val GenNavigatorPathSegment[*]#path segments;
}

class GenNavigatorPathSegment {
	readonly !resolve ref GenNavigatorPath#segments path;
	ref GenCommonBase[1] from;
	ref GenCommonBase[1] to;
}

/////////////////
// Property Sheet
//

@genmodel(documentation="Sheet consists of few categories (aka tabs)")
class GenPropertySheet {
	readonly !resolve ref GenEditorGenerator[1]#propertySheet editorGen;
	val GenPropertyTab[+]#sheet tabs;
	attr String packageName;
	attr boolean readOnly = false;
	attr boolean needsCaption = true;
	attr String labelProviderClassName;
	op String getLabelProviderQualifiedClassName();
}

abstract class GenPropertyTab {
	readonly !resolve ref GenPropertySheet[1]#tabs sheet;
	attr String[1] ~iD;
	attr String label;
}

@genmodel(documentation="Standard property category plugs in predefined sets of properties (provided by runtime). Identifiers 'appearance', 'diagram' and 'advanced' are known at the moment")
class GenStandardPropertyTab extends GenPropertyTab {
}

class GenCustomPropertyTab extends GenPropertyTab {
	@genmodel(documentation="For custom tabs without generated boilerplate code should be qualified class name. If not, property sheet's package name will be used for qualified names")
	attr String[1] className;
	op String getQualifiedClassName();
	val GenPropertyTabFilter[?]#tab filter;
	attr boolean generateBoilerplate = true; // unlike other similar attributes, true as default to respect legacy models
}

abstract interface GenPropertyTabFilter {
	readonly !resolve ref GenCustomPropertyTab[1]#filter tab;
}

class TypeTabFilter extends GenPropertyTabFilter {
	@genmodel(documentation="Fully-qualified class names for selection to match")
	attr String[+] types;
	unique attr GeneratedType[*] generatedTypes;
	op String[+] getAllTypes();
}

enum GeneratedType {
	abstractNavigatorItem = 0;
}

class CustomTabFilter extends GenPropertyTabFilter {
	@genmodel(documentation="Qualified class name of a tab filter, implementation of org.eclipse.jface.viewers.IFilter. If class name is not qualified, it's prefixed with editor's package name for legacy reasons")
	attr String[1] className;
	op String getQualifiedClassName();
}

//////////////////////
// UI Contributions //
//////////////////////

@genmodel(documentation="Element of UI contribution")
abstract interface GenContributionItem {
	readonly !resolve ref GenContributionManager[?]#items owner;
}

@genmodel(documentation="Reference to the shared contribution item")
class GenSharedContributionItem extends GenContributionItem {
	@constraints(ocl="not actualItem.oclIsKindOf(gmfgen::GenSharedContributionItem)", description="Actual contribution item can't be a reference")
	ref GenContributionItem[1] actualItem;
}

class GenGroupMarker extends GenContributionItem {
	attr String[1] groupName;
}

class GenSeparator extends GenContributionItem {
	attr String[?] groupName;
	// combine with GenGroupMarker and add attr boolean isVisible?
}

@genmodel(documentation="Action from org.eclipse.ui.actions.ActionFactory")
class GenCustomAction extends GenContributionItem {
	attr String[1] qualifiedClassName;
	attr boolean generateBoilerplate = false;
	attr String[?] name;
}

class GenCommandAction extends GenContributionItem {
	attr String[1] commandIdentifier;
	attr String[?] name;
}

@genmodel(documentation="Action that is generated along with diagram action, i.e. there's a template that provides its implementation")
abstract class GenAction extends GenContributionItem {
	attr String qualifiedClassName;
	@genmodel(documentation="Human-readble name")
	attr String name;
}
// XXX it's not completely obvious to me if enum PredefinedActionKind is better than a distinct subclass per action type
class LoadResourceAction extends GenAction {
}
class InitDiagramAction extends GenAction {
}
class CreateShortcutAction extends GenAction {
}

@genmodel(documentation="Action from org.eclipse.ui.actions.ActionFactory")
class GenActionFactoryContributionItem extends GenContributionItem {
	@genmodel(documentation="ActionFactory field name such as 'ABOUT'")
	attr String[1] name;
}

@genmodel(documentation="Group of UI contribution items")
abstract class GenContributionManager {
	attr String[?] iD;
	val GenContributionItem[*]#owner items;
	readonly transient derived volatile !resolve ref GenEditorGenerator[1] editorGen;
}

class GenMenuManager extends GenContributionManager, GenContributionItem {
	attr String[?] name;
}

class GenToolBarManager extends GenContributionManager, GenContributionItem {
}

// XXX GenContextContribution? - as it's no difference if it's toolbar or menu contrib
class GenContextMenu extends GenContributionManager {
	ref GenCommonBase[+] context;
}

/////////////////////
// RCP Application //
/////////////////////

class GenApplication {
	readonly !resolve ref GenEditorGenerator[1]#application editorGen;
	@genmodel(documentation="RCP Application ID for plugin.xml")
	attr String iD;
	attr String title;
	attr String packageName;
	attr String className;
	op String getQualifiedClassName();
	readonly derived transient volatile attr String workbenchAdvisorClassName;
	op String getWorkbenchAdvisorQualifiedClassName();
	readonly derived transient volatile attr String workbenchWindowAdvisorClassName;
	op String getWorkbenchWindowAdvisorQualifiedClassName();
	readonly derived transient volatile attr String actionBarAdvisorClassName;
	op String getActionBarAdvisorQualifiedClassName();
	readonly derived transient volatile attr String perspectiveClassName;
	op String getPerspectiveQualifiedClassName();
	attr String perspectiveId;
	@genmodel(documentation="Option to create/save/open diagrams in/from java files")
	attr boolean supportFiles;
	val GenContributionItem[*] sharedContributionItems;
	val GenMenuManager[?] mainMenu;
	val GenToolBarManager[?] mainToolBar;
}

abstract interface GenLinkEnd extends GenCommonBase {
  readonly volatile transient derived ref GenLink[*] genOutgoingLinks;
  readonly volatile transient derived ref GenLink[*] genIncomingLinks;
}

class GenParsers {
	readonly !resolve ref GenEditorGenerator[1]#labelParsers editorGen; 
	attr String[1] packageName;
	attr String[1] className;
	@genmodel(documentation="Class with parser access methods. In case of using extensible ParserService, that would be provider implementation class.")
	op String getQualifiedClassName();
	// XXX if need mechanism(s) other than direct use and ParserService 
	// (e.g. consult ParserService first, if none, use predefined),
	// might change into enum
	attr boolean extensibleViaService = false;
	attr ProviderPriority providerPriority = "Lowest";
	val GenParserImplementation[+]#holder implementations;
	@genmodel(documentation="Package with parser implementations, same as packageName unless set")
	attr String implPackageName; 
}

abstract class GenParserImplementation {
	readonly !resolve ref GenParsers[1]#implementations holder;
	ref LabelModelFacet[+]#parser uses;
}

@genmodel(documentation="Use one of GMF-provided parser implementations")
class PredefinedParser extends GenParserImplementation {
	// XXX describe contract (i.e. presense of setViewPattern/setEditPattern methods, constructors)
	attr LabelTextAccessMethod viewMethod;
	attr LabelTextAccessMethod editMethod;
	@genmodel(documentation="Provides means to alter name of parser implementation class")
	attr String[?] className;
	op String getQualifiedClassName();
}

@genmodel(documentation="Parser implementation that uses expressions to produce string values")
class ExpressionLabelParser extends GenParserImplementation {
	@genmodel(documentation="Provides means to alter name of parser implementation class")
	attr String[?] className;
	op String getQualifiedClassName();
	ref genmodel.GenClass[1] expressionContext;
	//
	@genmodel(documentation="Expression to calculate user-readable label value; facet's owner type is evaluation context.")
	ref ValueExpression[1] viewExpression;
	@genmodel(documentation="Optional expression to represent value for editing")
	ref ValueExpression[?] editExpression;
	@genmodel(documentation="Optional expression to answer whether user input is ok for further parsing. Note, context here is string, not facet's owner type")
	ref GenConstraint[?] validateExpression;
}

@genmodel(documentation="Handwritten or otherwise available IParser implementation")
class CustomParser extends GenParserImplementation {
	attr String[1] qualifiedName;
	@genmodel(documentation="When true, GMF generates empty implementation class suitable for further customizations")
	attr boolean generateBoilerplate = false;
}

// XXX MIGRATION NOTE: null LabelModelFacets that were used to indicate ParserService, should get transformed into
// ExternalParser
@genmodel(documentation="Delegate to ParserService to find out")
class ExternalParser extends GenParserImplementation {
	@genmodel(documentation="Optionally, override hint value")
	attr String[?] hint;
}