/// <summary>
/// Constuctor.
/// </summary>
/// <param name="modelData">Document data.</param>
/// <param name="bHookUpEvents">True if events listeners should be initialized.</param>
/// <param name="options">Options.</param>
protected FamilyTreeDSLViewModelStoreBase(DslEditorModeling::ModelData modelData, Tum.PDE.ToolFramework.Modeling.Visualization.Base.ViewModelOptions options)
: base(modelData, true, null)
{
this.Options = options;
if( this.Options == null )
this.Options = new FamilyTreeDSLViewModelOptions();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="modelData"></param>
public DefaultContextModelContextBase(DslEditorModeling::ModelData modelData)
: base(modelData)
{
encodingXml = System.Text.Encoding.GetEncoding("ISO-8859-1");
//validationController = VSPluginDSLValidationController.Instance;
//validationController.Initialize();
serializationResult = new DslEditorModeling::SerializationResult();
}
/// <summary>
/// Initializes the static Validation map as well as the Validation is enabled fields in the actual instance of this class.
/// </summary>
/// <param name="controller">Controller to initalize</param>
/// <param name="discardController">Validation controllers to discard.</param>
public static void Initialize(DslEditorModeling::ModelValidationController controller, System.Collections.Generic.List<string> discardController)
{
InitializeType(controller, typeof(global::Tum.PDE.VSPluginDSL.DomainModel));
InitializeType(controller, typeof(global::Tum.PDE.VSPluginDSL.DomainClass2));
InitializeType(controller, typeof(global::Tum.PDE.VSPluginDSL.DomainModelHasDomainClass2));
// extern controller
discardController.Add("global::Tum.PDE.VSPluginDSL.VSPluginDSL");
}
/// <summary>
/// Initializes the static Validation map as well as the Validation is enabled fields in the actual instance of this class.
/// </summary>
/// <param name="controller">Controller to initalize</param>
/// <param name="discardController">Validation controllers to discard.</param>
public static void Initialize(DslEditorModeling::ModelValidationController controller, System.Collections.Generic.List<string> discardController)
{
InitializeType(controller, typeof(global::Tum.TestLanguage.DomainModel));
InitializeType(controller, typeof(global::Tum.TestLanguage.Test));
InitializeType(controller, typeof(global::Tum.TestLanguage.DomainModelHasTest));
// extern controller
discardController.Add("global::Tum.TestLanguage.TestLanguage");
}
/// <summary>
/// Initializes the static Validation map as well as the Validation is enabled fields in the actual instance of this class.
/// </summary>
/// <param name="controller">Controller to initalize</param>
/// <param name="discardController">Validation controllers to discard.</param>
public static void Initialize(DslEditorModeling::ModelValidationController controller, System.Collections.Generic.List<string> discardController)
{
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainModel));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainElementBase));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainElement));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.BaseElement));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.ReferenceableElement));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.EmbeddableElement));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.NamedDomainElement));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.AttributedDomainElement));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.BaseDomainElement));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainPropertyBase));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainProperty));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainElements));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainTypes));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.ExternalType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainEnumeration));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.EnumerationLiteral));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DETypes));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DRTypes));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DEType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DRType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.BaseDomainElementType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.ReferencingDRType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.EmbeddingDRType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.ConversionModelInfo));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.AttributedDomainElementHasDomainProperty));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.ReferenceRelationship));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.EmbeddingRelationshipBase));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.EmbeddingRelationship));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.BaseElementSourceReferencesBaseElementTargetBase));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.BaseElementSourceReferencesBaseElementTarget));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainModelHasDomainElements));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainElementsHasDomainElement));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainModelHasDomainTypes));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainTypesHasDomainType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainEnumerationHasEnumerationLiteral));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainPropertyReferencesDomainType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainModelHasDETypes));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainModelHasDRTypes));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DETypesHasDEType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DRTypesHasDRType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainElementReferencesDEType));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DRTypeReferencesBaseElementSourceReferencesBaseElementTarget));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DRTypeReferencesDETypeSource));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DRTypeReferencesDETypeTarget));
InitializeType(controller, typeof(global::Tum.PDE.ModelingDSL.DomainModelHasConversionModelInfo));
// extern controller
discardController.Add("global::Tum.PDE.ModelingDSL.PDEModelingDSL");
}
/// <summary>
/// Initializes the static Validation map as well as the Validation is enabled fields in the actual instance of this class.
/// </summary>
/// <param name="controller">Controller to initalize</param>
/// <param name="discardController">Validation controllers to discard.</param>
public static void Initialize(DslEditorModeling::ModelValidationController controller, System.Collections.Generic.List<string> discardController)
{
InitializeType(controller, typeof(global::Tum.FamilyTreeDSL.FamilyTreeModel));
InitializeType(controller, typeof(global::Tum.FamilyTreeDSL.Person));
InitializeType(controller, typeof(global::Tum.FamilyTreeDSL.FamilyTreePerson));
InitializeType(controller, typeof(global::Tum.FamilyTreeDSL.Pet));
InitializeType(controller, typeof(global::Tum.FamilyTreeDSL.FamilyTreeModelHasFamilyTreePerson));
InitializeType(controller, typeof(global::Tum.FamilyTreeDSL.FamilyTreePersonHasPet));
InitializeType(controller, typeof(global::Tum.FamilyTreeDSL.ParentOf));
InitializeType(controller, typeof(global::Tum.FamilyTreeDSL.MarriedTo));
// extern controller
discardController.Add("global::Tum.FamilyTreeDSL.FamilyTreeDSL");
}
/// <summary>
/// Initializes the static Validation map as well as the Validation is enabled fields in the actual instance of this class.
/// </summary>
/// <param name="controller">Controller to initalize</param>
/// <param name="discardController">Validation controllers to discard.</param>
public static void Initialize(DslEditorModeling::ModelValidationController controller, System.Collections.Generic.List<string> discardController)
{
InitializeType(controller, typeof(global::Tum.StateMachineDSL.StateMachineDomainModel));
InitializeType(controller, typeof(global::Tum.StateMachineDSL.StateBase));
InitializeType(controller, typeof(global::Tum.StateMachineDSL.State));
InitializeType(controller, typeof(global::Tum.StateMachineDSL.StartState));
InitializeType(controller, typeof(global::Tum.StateMachineDSL.EndState));
InitializeType(controller, typeof(global::Tum.StateMachineDSL.StateMachineDomainModelHasState));
InitializeType(controller, typeof(global::Tum.StateMachineDSL.StateMachineDomainModelHasStartState));
InitializeType(controller, typeof(global::Tum.StateMachineDSL.StateMachineDomainModelHasEndState));
InitializeType(controller, typeof(global::Tum.StateMachineDSL.Transition));
// extern controller
discardController.Add("global::Tum.StateMachineDSL.StateMachineLanguage");
}
private global::System.IO.MemoryStream InternalSaveModelVModell(DslModeling::SerializationResult serializationResult, global::Tum.VModellXT.VModell modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue, DslEditorModeling.SerializationMode serializationMode)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationResult != null);
global::System.Diagnostics.Debug.Assert(modelRoot != null);
global::System.Diagnostics.Debug.Assert(!serializationResult.Failed);
#endregion
//DslEditorModeling::DomainModelStore dStore = (DslEditorModeling::DomainModelStore)modelRoot.Store;
//if( dStore == null)
// throw new global::System.ArgumentNullException("dStore");
//dStore.WaitForWritingLockRelease();
serializationResult.Encoding = encoding;
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store);
global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream();
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult);
this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = VModellXTSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding);
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings))
{
DslEditorModeling.SerializationOptions options = new DslEditorModeling.SerializationOptions();
//options.SerializationMode = DslEditorModeling.SerializationMode.InternalToString;
options.SerializationMode = serializationMode;
this.WriteRootElementVModell(serializationContext, modelRoot, writer, options);
}
return newFileContent;
}
/// <summary>
/// Return the model in XML format
/// </summary>
/// <param name="modelRoot">Root instance to be saved.</param>
/// <param name="encoding">Encoding to use when saving the root instance.</param>
/// <param name="serializationMode">Serialization Mode.</param>
/// <returns>Model in XML form</returns>
public virtual string GetSerializedModelStringVarianten(global::Tum.VModellXT.Varianten modelRoot, global::System.Text.Encoding encoding, DslEditorModeling.SerializationMode serializationMode)
{
string result = string.Empty;
if (modelRoot == null)
{
return result;
}
//DslEditorModeling::DomainModelStore dStore = (DslEditorModeling::DomainModelStore)modelRoot.Store;
//if( dStore == null)
// throw new global::System.ArgumentNullException("dStore");
//dStore.WaitForWritingLockRelease();
DslModeling::SerializationResult serializationResult = new DslModeling::SerializationResult();
using (global::System.IO.MemoryStream modelFileContent = this.InternalSaveModelVarianten(serializationResult, modelRoot, string.Empty, encoding, false, serializationMode))
{
if (!serializationResult.Failed && modelFileContent != null)
{
char[] chars = encoding.GetChars(modelFileContent.GetBuffer());
// search the open angle bracket and trim off the Byte Of Mark.
result = new string( chars);
int indexPos = result.IndexOf('<');
if (indexPos > 0)
{
// strip off the leading Byte Of Mark.
result = result.Substring(indexPos);
}
// trim off trailing 0s.
result = result.TrimEnd( '\0');
}
}
return result;
}
/// <summary>
/// Write an element as the root of XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="rootElement">Root element instance that will be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="options">Serialization options.</param>
public virtual void WriteRootElementVarianten(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement rootElement, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationContext != null);
if (serializationContext == null)
throw new global::System.ArgumentNullException("serializationContext");
global::System.Diagnostics.Debug.Assert(rootElement != null);
if (rootElement == null)
throw new global::System.ArgumentNullException("rootElement");
global::System.Diagnostics.Debug.Assert(writer != null);
if (writer == null)
throw new global::System.ArgumentNullException("writer");
#endregion
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(rootElement.Store);
DslEditorModeling::SerializationDomainClassXmlSerializer rootSerializer = directory.GetSerializer(rootElement.GetDomainClass().Id) as DslEditorModeling::SerializationDomainClassXmlSerializer;
global::System.Diagnostics.Debug.Assert(rootSerializer != null, "Cannot find serializer for " + rootElement.GetDomainClass().Name + "!");
// Carry out the normal serialization.
rootSerializer.Write(serializationContext, rootElement, writer, new DslModeling::RootElementSettings(), options);
}
/// <summary>
/// Public Write() method that serializes one Test instance into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">Test instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="rootElementSettings">
/// The root element settings if the passed in element is serialized as a root element in the XML. The root element contains additional
/// information like schema target namespace, version, etc.
/// This should only be passed for root-level elements. Null should be passed for rest elements (and ideally call the Write() method
/// without this parameter).
/// </param>
/// <param name="options">Serialization options.</param>
public override void Write(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::RootElementSettings rootElementSettings, DslEditorModeling::SerializationOptions options)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert (serializationContext != null);
if (serializationContext == null)
throw new global::System.ArgumentNullException ("serializationContext");
global::System.Diagnostics.Debug.Assert (element != null);
if (element == null)
throw new global::System.ArgumentNullException ("element");
global::System.Diagnostics.Debug.Assert (writer != null);
if (writer == null)
throw new global::System.ArgumentNullException ("writer");
#endregion
// Write start of element, including schema target namespace if specified.
writer.WriteStartElement(this.XmlTagName);
if (!serializationContext.Result.Failed)
{
WritePropertiesAsAttributes(serializationContext, element, writer, options);
}
if (!serializationContext.Result.Failed)
{
// Write 1) properties serialized as nested XML elements and 2) child model elements into XML.
WriteElements(serializationContext, element, writer, options);
}
writer.WriteEndElement();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="modelData"></param>
public DefaultContextModelContext(DslEditorModeling::ModelData modelData)
: base(modelData)
{
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">View model store containing this view model.</param>
/// <param name="diagram">Diagram.</param>
/// <param name="modelContext">Model context.</param>
/// <param name="parentModelContext">Parent model context.</param>
public TestLanguageDesignerDiagramSurfaceViewModel(TestLanguageViewModelStore viewModelStore, DslEditorDiagrams::Diagram diagram, DslEditorModeling::ModelContext modelContext, DslEditorModeling::ModelContext parentModelContext)
: base(viewModelStore, diagram, modelContext, parentModelContext)
{
}
public virtual void ValidateDomainClass2(DslEditorModeling::ModelValidationContext context)
{
// validate required attribute Name
if( System.String.IsNullOrEmpty(this.Name) )
{
context.AddMessage(new DslEditorModeling::ModelValidationMessage(Tum.PDE.VSPluginDSL.VSPluginDSLValidationMessageIds.DomainClass2_Name, DslEditorModeling::ModelValidationViolationType.Error, "Property 'Name' has no value although it is required", this));
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="modelData">Document data.</param>
/// <param name="options">Options.</param>
public FamilyTreeDSLViewModelStore(DslEditorModeling::ModelData modelData, Tum.PDE.ToolFramework.Modeling.Visualization.Base.ViewModelOptions options)
: base(modelData, options)
{
}
/// <summary>
/// Returns a collection of property grid view models for the given selected elements.
/// </summary>
/// <param name="elements">Selected elements collection.</param>
/// <returns>Collection of property view models. Can be empty.</returns>
public override System.Collections.Generic.List<DslEditorViewModelPropertyGrid::PropertyGridViewModel> CreatePropertyEditorViewModels(DslEditorModeling::SelectedItemsCollection elements)
{
System.Collections.Generic.List<DslEditorViewModelPropertyGrid::PropertyGridViewModel> collection = new System.Collections.Generic.List<DslEditorViewModelPropertyGrid::PropertyGridViewModel>();
foreach(DslModeling::ModelElement modelElement in elements )
{
System.Collections.Generic.List<DslEditorViewModelData::ViewModelStore> handledStores = new System.Collections.Generic.List<DslEditorViewModelData::ViewModelStore>();
AddPropertyEditorViewModels(collection, modelElement, handledStores);
}
return collection;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="modelData">Document data.</param>
public FamilyTreeDSLViewModelStore(DslEditorModeling::ModelData modelData)
: this(modelData, true)
{
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="modelData">Document data.</param>
/// <param name="bHookUpEvents">True if events listeners should be initialized.</param>
/// <param name="ownedByStore">Store owning this store.</param>
protected FamilyTreeDSLViewModelStoreBase(DslEditorModeling::ModelData modelData, bool bHookUpEvents, DslEditorViewModelData::ViewModelStore ownedByStore)
: base(modelData, bHookUpEvents, ownedByStore)
{
this.Options = new FamilyTreeDSLViewModelOptions();
}
/// <summary>
/// This methods serializes 1) properties serialized as nested XML elements and 2) child model elements into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">Test instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="options">Serialization options.</param>
protected override void WriteElements(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
global::Tum.TestLanguage.Test instance = element as global::Tum.TestLanguage.Test;
global::System.Diagnostics.Debug.Assert(instance != null, "Expecting an instance of Test");
}
protected virtual void WritePropertyAsAttributeNumber(DslModeling::SerializationContext serializationContext, global::Tum.TestLanguage.Test instance, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
// Number
object valueNumber = global::Tum.TestLanguage.TestLanguageSerializationHelper.Instance.ConvertTypedObjectTo(serializationContext,instance, "Number" ,instance.Number, typeof(global::System.Double?), true);
if( valueNumber != null )
{
TestLanguageSerializationHelper.Instance.WriteAttributeString(serializationContext, instance, writer, "Number", valueNumber.ToString());
}
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
global::Tum.TestLanguage.Test instance = element as global::Tum.TestLanguage.Test;
global::System.Diagnostics.Debug.Assert(instance != null, "Expecting an instance of Test");
// Domain Element Id
string valueId = TestLanguageSerializationHelper.Instance.ConvertIdTo(serializationContext, element.Id);
writer.WriteAttributeString(TestLanguageSerializationBehavior.Instance.IdSerializationNameDefaultContext, valueId);
if (!serializationContext.Result.Failed)
{
WritePropertyAsAttributeName(serializationContext, instance, writer, options);
}
if (!serializationContext.Result.Failed)
{
WritePropertyAsAttributeNumber(serializationContext, instance, writer, options);
}
}
/// <summary>
/// Constructs a new FamilyTreeDSLDocDataBase.
/// </summary>
/// <param name="modelData">Model data.</param>
/// <param name="serviceProvider">Service Provider</param>
/// <param name="editorFactoryId">EditorFactory id.</param>
protected FamilyTreeDSLDocDataBase(DslEditorModeling::ModelData modelData, global::System.IServiceProvider serviceProvider, global::System.Guid editorFactoryId)
: base(modelData, serviceProvider, editorFactoryId)
{
}
/// <summary>
/// This methods serializes 1) properties serialized as nested XML elements and 2) child model elements into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">DomainModel instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="options">Serialization options.</param>
protected override void WriteElements(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
global::Tum.TestLanguage.DomainModel instance = element as global::Tum.TestLanguage.DomainModel;
global::System.Diagnostics.Debug.Assert(instance != null, "Expecting an instance of DomainModel");
WriteEmbeddingRelationshipDomainModelHasTest(serializationContext, instance, writer, options);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="modelData">Document data.</param>
/// <param name="bHookUpEvents">True if events listeners should be initialized.</param>
public PDEModelingDSLViewModelStore(DslEditorModeling::ModelData modelData, bool bHookUpEvents)
: this(modelData, bHookUpEvents, null)
{
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">View model store containing this view model.</param>
/// <param name="modelContext">Model context.</param>
public TestLanguageDesignerDiagramSurfaceViewModel(TestLanguageViewModelStore viewModelStore, DslEditorModeling::ModelContext modelContext)
: this(viewModelStore, null, modelContext)
{
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="modelData">Document data.</param>
/// <param name="bHookUpEvents">True if events listeners should be initialized.</param>
protected FamilyTreeDSLViewModelStoreBase(DslEditorModeling::ModelData modelData, bool bHookUpEvents)
: this(modelData, bHookUpEvents, null)
{
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">View model store containing this view model.</param>
/// <param name="diagram">Diagram.</param>
/// <param name="modelContext">Model context.</param>
/// <param name="parentModelContext">Parent model context.</param>
protected TestLanguageDesignerDiagramSurfaceViewModelBase(TestLanguageViewModelStore viewModelStore, DslEditorDiagrams::Diagram diagram, DslEditorModeling::ModelContext modelContext, DslEditorModeling::ModelContext parentModelContext)
: base(viewModelStore, diagram, modelContext)
{
this.parentModelContext = parentModelContext;
}
/// <summary>
/// This method is called to copy any existing validation messages (that were added during conversion).
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="validatable">Class that can be validated.</param>
public virtual void CopyValidationMessages(DslModeling::SerializationContext serializationContext, DslEditorModeling::IValidatable validatable)
{
foreach(DslEditorModeling::IValidationMessage message in validatable.ValidationResult)
{
DslModeling.SerializationMessageKind kind = DslModeling.SerializationMessageKind.Error;
if (message.Type == DslEditorModeling.ModelValidationViolationType.Message)
kind = DslModeling.SerializationMessageKind.Info;
else if (message.Type == DslEditorModeling.ModelValidationViolationType.Warning)
kind = DslModeling.SerializationMessageKind.Warning;
serializationContext.Result.AddMessage(new DslModeling.SerializationMessage(kind,
message.Description, validatable.ToString(), 0, 0, null));
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="modelData">Document data.</param>
/// <param name="bHookUpEvents">True if events listeners should be initialized.</param>
/// <param name="ownedByStore">Store owning this store.</param>
public FamilyTreeDSLViewModelStore(DslEditorModeling::ModelData modelData, bool bHookUpEvents, DslEditorViewModelData::ViewModelStore ownedByStore)
: base(modelData, bHookUpEvents, ownedByStore)
{
}
protected virtual void WriteEmbeddingRelationshipDomainModelHasTest(DslModeling::SerializationContext serializationContext, global::Tum.TestLanguage.DomainModel instance, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
#region Save EmbeddingRelationship DomainModelHasTest
global::System.Collections.ObjectModel.ReadOnlyCollection<global::Tum.TestLanguage.DomainModelHasTest> allMDomainModelHasTestInstances = global::Tum.TestLanguage.DomainModelHasTest.GetLinksToTest(instance);
foreach(global::Tum.TestLanguage.DomainModelHasTest allMDomainModelHasTestInstance in allMDomainModelHasTestInstances)
{
if (!serializationContext.Result.Failed)
{
// No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = allMDomainModelHasTestInstance.Test;
DslEditorModeling::SerializationDomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id) as DslEditorModeling::SerializationDomainClassXmlSerializer;
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.Write(serializationContext, targetElement, writer, options);
}
}
#endregion
}
