/// <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 }