/// <summary> /// /// </summary> /// <param name="nodes"></param> /// <param name="groups"></param> /// <param name="rawData">Represents the current contents of the file. Reference is not held. A copy is made.</param> /// <param name="file"></param> /// <param name="errors"></param> /// <param name="datasource"></param> /// <param name="serializer"></param> /// <param name="nodeFactory"></param> /// <param name="domainUsage"></param> /// <param name="getDocumentSource"></param> /// <param name="autoCompletePatterns"></param> public DomainFile(IEnumerable <GraphAndUI <NodeUIData> > nodes, IEnumerable <NodeGroup> groups, MemoryStream rawData, Id <FileInProject> file, DocumentPath path, ReadOnlyCollection <LoadError> errors, DomainDomain datasource, ISerializer <TData> serializer, INodeFactory nodeFactory, Func <IDomainUsage <ConversationNode, TransitionNoduleUIInfo> > domainUsage, Func <IDynamicEnumParameter, object, DynamicEnumParameter.Source> getDocumentSource, IEnumerable <IAutoCompletePattern> autoCompletePatterns, UpToDateFile.BackEnd backEnd) : base(nodes, groups, errors, nodeFactory, null, getDocumentSource, NoAudio.Instance) { Id = file; m_file = new SaveableFileUndoable(rawData, path.FileInfo, SaveTo, backEnd); m_domainUsage = domainUsage; foreach (var node in m_nodes) { var n = node; node.Modified += () => NodeModified(n); node.Data.Linked += () => NodeLinked(n); } m_nodes.Inserting += (n) => { AddToData(n.Data.Only(), m_datasource); ConversationDomainModified.Execute(); //No need to be picky about false positives n.Modified += () => NodeModified(n); n.Data.Linked += () => NodeLinked(n); }; m_nodes.Removing += RemoveFromData; m_nodes.Clearing += ClearData; //Currently nothing clears the list m_datasource = datasource; //m_conversationDatasource = conversationDataSource; m_serializer = serializer; m_autoCompletePatterns = new List <IAutoCompletePattern>(autoCompletePatterns); }
/// <summary> /// Triggered when the set of linked nodes of 'node' changes. This includes unlinking as well as linking. /// </summary> private void NodeLinked(ConversationNode node) { Action <NodeTypeData> categoryAction = category => { }; //Can't link categories to anything Action <IntegerData> integerAction = data => { }; //Can't link integer definitions to anything Action <DecimalData> decimalAction = data => { }; //Can't link decimal definitions to anything Action <LocalizedStringData> localizedStringAction = data => { }; //Can't link localized string definitions to anything Action <DynamicEnumerationData> dynamicEnumAction = data => { }; //Can't link dynamic enum definitions to anything Action <LocalDynamicEnumerationData> localDynamicEnumAction = data => { }; //Can't link local dynamic enum definitions to anything Action <EnumerationData> enumAction = data => { m_datasource.UpdateEnumeration(data); //m_conversationDatasource.UpdateEnumeration(data); }; Action <EnumerationData> enumValueAction = data => { }; //It's only possible to link to an enum definition and that's already handled by enumAction Action <NodeData> nodeAction = data => { //Doesn't affect the domain domain //m_conversationDatasource.NodeDefinitionModified(data); }; Action <ConnectorDefinitionData> connectorAction = data => { m_datasource.ModifyConnector(data); //update conversation datasource when connector definition is linked to a parameter }; Action <ConnectionDefinitionData> connectionAction = data => { }; //Can't line connection definitions to anything DomainDomain.ForEachNode(node.Only(), categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); ConversationDomainModified.Execute(); //No need to be picky about false positives }
/// <summary> /// Remove the node's content from the domain and conversation datasources. /// </summary> protected override void RemoveFromData(ConversationNode node) { Action <NodeTypeData> categoryAction = category => { m_datasource.RemoveCategory(category.Guid); //m_conversationDatasource.RemoveCategory(category.Guid); }; Action <IntegerData> integerAction = data => { m_datasource.RemoveType(BaseType.Integer, data.TypeId); //m_conversationDatasource.RemoveType(data.TypeID); }; Action <DecimalData> decimalAction = data => { m_datasource.RemoveType(BaseType.Decimal, data.TypeId); //m_conversationDatasource.RemoveType(data.TypeID); }; Action <LocalizedStringData> localizedStringAction = data => { m_datasource.RemoveType(BaseType.LocalizedString, data.TypeId); }; Action <DynamicEnumerationData> dynamicEnumAction = data => { m_datasource.RemoveType(BaseType.DynamicEnumeration, data.TypeId); //m_conversationDatasource.RemoveType(data.TypeID); }; Action <LocalDynamicEnumerationData> localDynamicEnumAction = data => { m_datasource.RemoveType(BaseType.LocalDynamicEnumeration, data.TypeId); //m_conversationDatasource.RemoveType(data.TypeID); }; Action <EnumerationData> enumAction = data => { m_datasource.RemoveType(BaseType.Enumeration, data.TypeId); //m_conversationDatasource.RemoveType(data.TypeID); }; Action <EnumerationData> enumValueAction = data => { m_datasource.UpdateEnumeration(data); //m_conversationDatasource.UpdateEnumeration(data); }; Action <NodeData> nodeAction = data => { //Doesn't affect domain domain //m_conversationDatasource.RemoveNodeType(data.Guid); }; Action <ConnectorDefinitionData> connectorAction = data => { m_datasource.RemoveConnector(data); //m_conversationDatasource.RemoveConnector(data.Id); }; Action <ConnectionDefinitionData> connectionAction = data => { //Doesn't affect domain domain }; DomainDomain.ForEachNode(node.Only(), categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); ConversationDomainModified.Execute(); //No need to be picky about false positives }
public void Removed() { ClearData(); ConversationDomainModified.Execute(); }
private void NodeModified(ConversationNode node) { Action <NodeTypeData> categoryAction = category => { //m_conversationDatasource.RenameCategory(category); m_datasource.RenameCategory(category.Name, category.Guid); }; Action <IntegerData> integerAction = data => { //m_conversationDatasource.ModifyIntegerType(data); m_datasource.RenameType(BaseType.Integer, data.Name, data.TypeId); }; Action <DecimalData> decimalAction = data => { //m_conversationDatasource.ModifyDecimalType(data); m_datasource.RenameType(BaseType.Decimal, data.Name, data.TypeId); }; Action <LocalizedStringData> localizedStringAction = data => { m_datasource.RenameType(BaseType.LocalizedString, data.Name, data.TypeId); }; Action <DynamicEnumerationData> dynamicEnumAction = data => { //There's no data that the conversation domain needs m_datasource.RenameType(BaseType.DynamicEnumeration, data.Name, data.TypeId); }; Action <LocalDynamicEnumerationData> localDynamicEnumAction = data => { //There's no data that the conversation domain needs m_datasource.RenameType(BaseType.LocalDynamicEnumeration, data.Name, data.TypeId); }; Action <EnumerationData> enumAction = data => { //No impact on the conversation datasource m_datasource.RenameType(BaseType.Enumeration, data.Name, data.TypeId); }; Action <EnumerationData> enumValueAction = data => { //m_conversationDatasource.UpdateEnumeration(data); m_datasource.UpdateEnumeration(data); }; Action <NodeData> nodeAction = data => { //m_conversationDatasource.NodeDefinitionModified(data); //Doesn't affect the domain domain }; Action <ConnectorDefinitionData> connectorAction = data => { //Update conversation datasource? m_datasource.ModifyConnector(data); }; Action <ConnectionDefinitionData> connectionAction = data => { //Doesn't affect the domain domain }; if (m_datasource.IsConnector(node.Data.NodeTypeId)) { var nodeConnector = node.Data.Connectors.Single(c => c.Definition.Id == DomainIDs.ConnectorOutputDefinition.Id); var nodes = nodeConnector.Connections.Select(c => c.Parent).Where(n => n.NodeTypeId == DomainIDs.NodeGuid); DomainDomain.ForEachNode(nodes, categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); } else if (m_datasource.IsParameter(node.Data.NodeTypeId)) { var nodeConnector = node.Data.Connectors.Single(c => c.Definition.Id == DomainIDs.ParameterOutputDefinition.Id); var nodes = nodeConnector.Connections.Select(c => c.Parent).Where(n => n.NodeTypeId == DomainIDs.NodeGuid); DomainDomain.ForEachNode(nodes, categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); } else if (m_datasource.IsConfig(node.Data.NodeTypeId)) { var nodeConnector = node.Data.Connectors.Single(c => c.Definition.Id == DomainIDs.ConfigOutputDefinition.Id); var connected = nodeConnector.Connections.Select(c => c.Parent); var nodes = connected.Where(n => n.NodeTypeId == DomainIDs.NodeGuid); DomainDomain.ForEachNode(nodes, categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); //Don't currently need to handle parameter config affecting nodes //var parameters = connected.Where(n => m_datasource.IsParameter(n.NodeTypeID)); //var nodes2 = parameters.SelectMany(p=>p.Connectors.Where(c=>c.m_definition.Id == DomainIDs.PARAMETER_OUTPUT_DEFINITION.Id)) //DomainDomain.ForEachNode } else { DomainDomain.ForEachNode(node.Only(), categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction); } ConversationDomainModified.Execute(); //No need to be picky about false positives }