コード例 #1
0
ファイル: ExportTool.cs プロジェクト: mpostol/ASMD
        /// <summary>
        /// Exports to document.
        /// </summary>
        /// <param name="tn">The tree node</param>
        /// <param name="typeOfTheDocument">The type of the document.</param>

        #region creatorsOfTermWithDefinition

        /// <summary>
        /// Gets the folder.
        /// </summary>
        /// <param name="imna">The IModelNodeAdvance.</param>
        /// <param name="type">The folder type.</param>
        /// <returns></returns>
        private static IEnumerable <IModelNodeAdvance> GetFolder(IModelNodeAdvance imna, FolderType type)
        {
            if (imna == null)
            {
                return(null);
            }
            Dictionary <FolderType, IEnumerable <IModelNodeAdvance> > folders = imna.GetFolders();

            if (folders == null)
            {
                return(null);
            }
            if (folders.ContainsKey(type))
            {
                return(folders[type]);
            }
            return(null);
        }
コード例 #2
0
ファイル: ExportTool.cs プロジェクト: mpostol/ASMD
        private static bool CheckIfExportIsPossibleAndPrepareListOfTerms(IModelNodeAdvance imna, out List <TermWithDefinitionStructure> listOfAllTerms)
        {
            if (imna == null)
            {
                MessageBox.Show(Resources.ExportTool_NoNodeIsSelected, Resources.ExportTool_Window_Name, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
                listOfAllTerms = null;
                return(false);
            }
            listOfAllTerms = new List <TermWithDefinitionStructure>();
            if (imna.NodeType == NodeTypeEnum.ProjectNode)
            {
                foreach (IModelNodeAdvance imnaInDictionary in ((imna.GetFolders()).Values))
                {
                    if (imnaInDictionary.NodeType == NodeTypeEnum.ModelNode)
                    {
                        List <TermWithDefinitionStructure> temp_listOfAllTerms = new List <TermWithDefinitionStructure>();
                        if (CheckIfExportIsPossibleAndPrepareListOfTerms(imnaInDictionary, out temp_listOfAllTerms))
                        {
                            listOfAllTerms.AddRange(temp_listOfAllTerms);
                        }
                    }
                }
            }
            else
            {
                TermWithDefinitionStructure term = null;
                if (imna.NodeType == NodeTypeEnum.ModelNode)
                {
                    foreach (KeyValuePair <FolderType, IEnumerable <IModelNodeAdvance> > item in imna.GetFolders())
                    {
                        foreach (IModelNodeAdvance imnaInProject in item.Value)
                        {
                            term = CreateTermWithDefinition(imnaInProject);
                            if (term != null)
                            {
                                listOfAllTerms.Add(term);
                            }
                        }
                    }
                }
                else
                {
                    term = CreateTermWithDefinition(imna);
                    if (term != null)
                    {
                        listOfAllTerms.Add(term);
                        foreach (FolderType folderType in FolderType.GetValues(typeof(FolderType)))
                        {
                            if (GetFolder(imna, folderType) != null)
                            {
                                foreach (IModelNodeAdvance imnaInFolder in GetFolder(imna, folderType))
                                {
                                    term = CreateTermWithDefinition(imnaInFolder);
                                    if (term != null)
                                    {
                                        listOfAllTerms.Add(term);
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        MessageBox.Show(Resources.ExportTool_cannot_expot_wrong_node, Resources.ExportTool_Window_Name, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
                        return(false);
                    }
                }
            }

            return(true);
        }
コード例 #3
0
 /// <summary>
 /// Analizes the state machine from tree.
 /// </summary>
 /// <param name="imna">The analized node.</param>
 internal static void AnalizeStateMachine(IModelNodeAdvance imna)
 {
     if ((((TypeDesign <OpcUaModelCompiler.ObjectTypeDesign>)imna.Wrapper4PropertyGrid).BaseType.ToString() == finiteStateMachineTypeString))
     {
         TypeDesign <OpcUaModelCompiler.ObjectTypeDesign> selectedNodeObjectTypeDesign = (TypeDesign <UAOOI.SemanticData.UAModelDesignExport.XML.ObjectTypeDesign>)imna.Wrapper4PropertyGrid;
         try
         {
             string            symbolicNameNameSpace = selectedNodeObjectTypeDesign.SymbolicName.NameSpace;
             ObjectTypeDesign  machineObjectDesign   = (ObjectTypeDesign)selectedNodeObjectTypeDesign.Parent;
             List <string>     allStates             = new List <string>();
             List <Transition> allTransitions        = new List <Transition>();
             Dictionary <FolderType, IEnumerable <IModelNodeAdvance> > folders = imna.GetFolders();
             foreach (Folder folder in folders.Values)
             {
                 if (folder is ChildrenFolder)
                 {
                     foreach (IModelNode machineIModelNode in folder)
                     {
                         if (machineIModelNode.NodeClass == NodeClassesEnum.Object)
                         {
                             FindStatesAndTransitionsInStateMachine((InstanceDesign <UAOOI.SemanticData.UAModelDesignExport.XML.ObjectDesign>)machineIModelNode.Wrapper4PropertyGrid, allStates, allTransitions);
                         }
                     }
                 }
             }
             bool transitionAnalized = false;
             while (transitionAnalized == false)
             {
                 transitionAnalized = StateMachineCrossTable.AddImagesOnTransitionButtons(allStates, allTransitions, symbolicNameNameSpace, machineObjectDesign, imna.IsReadOnly);
             }
         }
         catch (Exception)
         {
             MessageBox.Show(Resources.ProblemWithStateMachine_Header, Resources.ProblemwithDisplayingStateMachine_Info, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
             return;
         }
     }
     else
     {
         MessageBox.Show(Resources.ProblemWithStateMachine_Header, Resources.ProblemWithStateMachine_Info, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
         return;
     }
 }