IfcDoc.FormEdit.LoadNodeSchema C# (CSharp) Méthode

        private void LoadNodeSchema(TreeNode tnSchema, DocSchema schema)
        {
            TreeNode tnTypeHeader = LoadNode(tnSchema, typeof(DocType), "Types", false);
            foreach (DocType type in schema.Types)
            {
                TreeNode tnType = LoadNode(tnTypeHeader, type, type.Name, true);
                if (type is DocEnumeration)
                {
                    DocEnumeration enumeration = (DocEnumeration)type;
                    foreach (DocConstant constant in enumeration.Constants)
                    {
                        LoadNode(tnType, constant, constant.Name, false);
                    }
                }
                else if (type is DocSelect)
                {
                    DocSelect select = (DocSelect)type;
                    foreach (DocSelectItem selitem in select.Selects)
                    {
                        LoadNode(tnType, selitem, selitem.Name, false);
                    }
                }
                else if (type is DocDefined)
                {
                    DocDefined define = (DocDefined)type;
                    foreach(DocWhereRule docRule in define.WhereRules)
                    {
                        LoadNode(tnType, docRule, docRule.Name, false);
                    }
                }
            }

            TreeNode tnEntityHeader = LoadNode(tnSchema, typeof(DocEntity), "Entities", false);
            foreach (DocEntity type in schema.Entities)
            {
                TreeNode tnType = LoadNode(tnEntityHeader, type, type.Name, true);

                string key = type.Name.ToLowerInvariant();

                foreach (DocAttribute attr in type.Attributes)
                {
                    TreeNode tnAttribute = LoadNode(tnType, attr, attr.Name, false);
                    if (!String.IsNullOrEmpty(attr.Derived))
                    {
                        tnAttribute.ImageIndex = ImageIndexAttributeDerived;
                        tnAttribute.SelectedImageIndex = ImageIndexAttributeDerived;
                    }
                    else if (!String.IsNullOrEmpty(attr.Inverse))
                    {
                        tnAttribute.ImageIndex = ImageIndexAttributeInverse;
                        tnAttribute.SelectedImageIndex = ImageIndexAttributeInverse;
                    }
                }

                foreach (DocWhereRule wr in type.WhereRules)
                {
                    LoadNode(tnType, wr, wr.Name, false);
                }

                foreach (DocUniqueRule ur in type.UniqueRules)
                {
                    LoadNode(tnType, ur, ur.Name, false);
                }

                // new style templates
                foreach (DocModelView docModelView in this.m_project.ModelViews)
                {
                    if (docModelView.ConceptRoots != null)
                    {
                        foreach (DocConceptRoot docConceptRoot in docModelView.ConceptRoots)
                        {
                            if (docConceptRoot.ApplicableEntity == type)
                            {
                                string rootname = docConceptRoot.Name;
                                if(String.IsNullOrEmpty(rootname))
                                {
                                    rootname = docModelView.Name;
                                }
                                TreeNode tnConceptRoot = LoadNode(tnType, docConceptRoot, rootname, false);
                                foreach (DocTemplateUsage docConcept in docConceptRoot.Concepts)
                                {
                                    LoadNodeConcept(tnConceptRoot, docConcept);
                                }
                            }
                        }
                    }
                }
            }

            TreeNode tnGlobHeader = LoadNode(tnSchema, typeof(DocGlobalRule), "Global Rules", false);
            if (schema.GlobalRules.Count > 0)
            {
                foreach (DocGlobalRule func in schema.GlobalRules)
                {
                    LoadNode(tnGlobHeader, func, func.Name, true);
                }
            }

            TreeNode tnFuncHeader = LoadNode(tnSchema, typeof(DocFunction), "Functions", false);
            if (schema.Functions.Count > 0)
            {
                foreach (DocFunction func in schema.Functions)
                {
                    LoadNode(tnFuncHeader, func, func.Name, true);
                }
            }

            TreeNode tnPsetHeader = LoadNode(tnSchema, typeof(DocPropertySet), "Property Sets", false);
            foreach (DocPropertySet pset in schema.PropertySets)
            {
                TreeNode tnPset = LoadNode(tnPsetHeader, pset, pset.Name, true);
                foreach (DocProperty docprop in pset.Properties)
                {
                    TreeNode tnProp = LoadNode(tnPset, docprop, docprop.Name, false);

                    // complex properties
                    foreach (DocProperty docpropelem in docprop.Elements)
                    {
                        LoadNode(tnProp, docpropelem, docpropelem.Name, false);
                    }
                }
            }

            TreeNode tnPeHeader = LoadNode(tnSchema, typeof(DocPropertyEnumeration), "Property Enumerations", false);
            foreach (DocPropertyEnumeration en in schema.PropertyEnums)
            {
                TreeNode tnEnum = LoadNode(tnPeHeader, en, en.Name, true);
                foreach (DocPropertyConstant docconst in en.Constants)
                {
                    LoadNode(tnEnum, docconst, docconst.Name, false);
                }
            }

            TreeNode tnQsetHeader = LoadNode(tnSchema, typeof(DocQuantitySet), "Quantity Sets", false);
            if (schema.QuantitySets.Count > 0)
            {
                foreach (DocQuantitySet qset in schema.QuantitySets)
                {
                    TreeNode tnQset = LoadNode(tnQsetHeader, qset, qset.Name, true);
                    foreach (DocQuantity docprop in qset.Quantities)
                    {
                        LoadNode(tnQset, docprop, docprop.Name, false);
                    }
                }
            }

            TreeNode tnGraphicsHeader = LoadNode(tnSchema, typeof(DocSchemaRef), "Schema References", false);
            foreach (DocSchemaRef docItem in schema.SchemaRefs)
            {
                TreeNode tnTarget = LoadNode(tnGraphicsHeader, docItem, docItem.Name, false);
                foreach (DocDefinitionRef docSource in docItem.Definitions)
                {
                    LoadNode(tnTarget, docSource, docSource.Name, false);
                }
            }
            tnGraphicsHeader = LoadNode(tnSchema, typeof(DocPageTarget), "Page References", false);
            foreach (DocPageTarget docItem in schema.PageTargets)
            {
                TreeNode tnTarget = LoadNode(tnGraphicsHeader, docItem, docItem.Name, false);
                foreach (DocPageSource docSource in docItem.Sources)
                {
                    LoadNode(tnTarget, docSource, docSource.Name, false);
                }
            }
            tnGraphicsHeader = LoadNode(tnSchema, typeof(DocPrimitive), "Primitive References", false);
            foreach (DocPrimitive docItem in schema.Primitives)
            {
                LoadNode(tnGraphicsHeader, docItem, docItem.Name, false);
            }
            tnGraphicsHeader = LoadNode(tnSchema, typeof(DocComment), "Comments", false);
            foreach (DocComment docItem in schema.Comments)
            {
                LoadNode(tnGraphicsHeader, docItem, docItem.Name, false);
            }
        }