internal static void ExportMvdTemplate(ConceptTemplate mvdTemplate, DocTemplateDefinition docTemplateDef, Dictionary<DocObject, bool> included, bool documentation)
{
ExportMvdObject(mvdTemplate, docTemplateDef, documentation);
mvdTemplate.ApplicableEntity = docTemplateDef.Type;
if (docTemplateDef.Rules != null && docTemplateDef.Rules.Count > 0)
{
mvdTemplate.Rules = new List<AttributeRule>();
foreach (DocModelRule docRule in docTemplateDef.Rules)
{
AttributeRule mvdAttr = new AttributeRule();
mvdTemplate.Rules.Add(mvdAttr);
ExportMvdRule(mvdAttr, docRule);
}
}
// recurse through sub-templates
if (docTemplateDef.Templates != null && docTemplateDef.Templates.Count > 0)
{
foreach (DocTemplateDefinition docSub in docTemplateDef.Templates)
{
if (included == null || included.ContainsKey(docSub))
{
if (mvdTemplate.SubTemplates == null)
{
mvdTemplate.SubTemplates = new List<ConceptTemplate>();
}
ConceptTemplate mvdSub = new ConceptTemplate();
mvdTemplate.SubTemplates.Add(mvdSub);
ExportMvdTemplate(mvdSub, docSub, included, documentation);
}
}
}
}
// each list is optional- if specified then must be followed; if null, then no filter applies (all included)
internal static void ExportMvd(
mvdXML mvd,
DocProject docProject,
Dictionary<DocObject, bool> included)
{
mvd.Uuid = Guid.NewGuid(); // changes every time saved
mvd.Name = String.Empty;
foreach (DocTemplateDefinition docTemplateDef in docProject.Templates)
{
if (included == null || included.ContainsKey(docTemplateDef))
{
ConceptTemplate mvdConceptTemplate = new ConceptTemplate();
mvd.Templates.Add(mvdConceptTemplate);
ExportMvdTemplate(mvdConceptTemplate, docTemplateDef, included, true);
}
}
foreach (DocModelView docModelView in docProject.ModelViews)
{
if (included == null || included.ContainsKey(docModelView))
{
ModelView mvdModelView = new ModelView();
mvd.Views.Add(mvdModelView);
ExportMvdObject(mvdModelView, docModelView, true);
mvdModelView.ApplicableSchema = "IFC4";
mvdModelView.BaseView = docModelView.BaseView;
foreach (DocExchangeDefinition docExchangeDef in docModelView.Exchanges)
{
ExchangeRequirement mvdExchangeDef = new ExchangeRequirement();
mvdModelView.ExchangeRequirements.Add(mvdExchangeDef);
ExportMvdObject(mvdExchangeDef, docExchangeDef, true);
switch (docExchangeDef.Applicability)
{
case DocExchangeApplicabilityEnum.Export:
mvdExchangeDef.Applicability = ApplicabilityEnum.Export;
break;
case DocExchangeApplicabilityEnum.Import:
mvdExchangeDef.Applicability = ApplicabilityEnum.Import;
break;
}
}
// export template usages for model view
foreach (DocConceptRoot docRoot in docModelView.ConceptRoots)
{
if (docRoot.ApplicableEntity != null)
{
// check if entity contains any concept roots
ConceptRoot mvdConceptRoot = new ConceptRoot();
mvdModelView.Roots.Add(mvdConceptRoot);
Program.ExportMvdConceptRoot(mvdConceptRoot, docRoot, true);
}
}
}
}
}
/// <summary>
/// Generates documentation for template and all sub-templates recursively.
/// </summary>
/// <param name="docTemplate"></param>
/// <param name="indexpath"></param>
/// <param name="listFigures"></param>
/// <param name="listTables"></param>
private static void GenerateTemplate(
DocProject docProject,
DocTemplateDefinition docTemplate,
Dictionary<string, DocObject> mapEntity,
Dictionary<string, string> mapSchema,
Dictionary<DocObject, bool> included,
int[] indexpath,
List<ContentRef> listFigures,
List<ContentRef> listTables,
DocPublication docPublication,
string path)
{
string pathTemplate = path + @"\schema\templates\" + MakeLinkName(docTemplate) + ".htm";
using (FormatHTM htmTemplate = new FormatHTM(pathTemplate, mapEntity, mapSchema, included))
{
htmTemplate.WriteHeader(docTemplate.Name, 2, docPublication.Header);
string indexer = "";
foreach (int part in indexpath)
{
if (indexer.Length != 0)
{
indexer += ".";
}
indexer += part.ToString();
}
htmTemplate.WriteLine(
"\r\n" +
"<script type=\"text/javascript\">\r\n" +
"<!--\r\n" +
" parent.index.location.replace(\"../toc-4.htm#" + indexer + "\");\r\n" +
"//-->\r\n" +
"</script>\r\n");
string tag = "h" + indexpath.Length.ToString(); // e.g. <h3>
string id = MakeLinkName(docTemplate);
htmTemplate.WriteLine("<" + tag + " class=\"std\">" + indexer + " " + docTemplate.Name + "</" + tag + ">");
string doc = FormatTemplate(docProject, docTemplate, listFigures, listTables, mapEntity, mapSchema, included, path);
htmTemplate.WriteDocumentationMarkup(doc, docTemplate, docPublication);
// write formatted mvdXML
//htmTemplate.WriteLine("<details open=\"open\">");
//htmTemplate.WriteLine("<summary>mvdXML</summary>");
ConceptTemplate mvdTemplate = new ConceptTemplate();
Program.ExportMvdTemplate(mvdTemplate, docTemplate, included, false);
XmlSerializer ser = new XmlSerializer(typeof(ConceptTemplate));
StringBuilder mvdOutput = new StringBuilder();
using (System.IO.Stream streamMVD = new System.IO.MemoryStream())
{
ser.Serialize(streamMVD, mvdTemplate, null);
streamMVD.Position = 0;
using(System.IO.StreamReader reader = new System.IO.StreamReader(streamMVD))
{
while(!reader.EndOfStream)
{
string mvdLine = reader.ReadLine();
int pos = 0;
while(pos < mvdLine.Length && mvdLine[pos] == ' ')
{
mvdOutput.Append("\t");
pos++;
}
// replace any leading spaces with tabs for proper formatting
string mvdMark = mvdLine.Substring(pos, mvdLine.Length - pos);
mvdOutput.AppendLine(mvdMark);
}
}
}
htmTemplate.WriteSummaryHeader("mvdXML Specification", false);
htmTemplate.WriteLine("<div class=\"xsd\"><code class=\"xsd\">");
htmTemplate.WriteExpression(mvdOutput.ToString()); //... need to use tabs...
htmTemplate.WriteLine("</code></div>");
htmTemplate.WriteSummaryFooter();
//htmTemplate.WriteLine("</details>");
if (docProject.Examples != null)
{
List<DocExample> listExample = new List<DocExample>();
foreach (DocExample docExample in docProject.Examples)
{
BuildExampleList(listExample, docExample, docTemplate, included);
}
if (listExample.Count > 0)
{
htmTemplate.WriteLine("<p class=\"spec-head\">Examples:</p>");
htmTemplate.WriteLine("<ul>");
foreach (DocExample docExample in listExample)
{
if (docExample.Name != null)
{
htmTemplate.Write("<li><a href=\"../../annex/annex-e/");
htmTemplate.Write(MakeLinkName(docExample));
htmTemplate.Write(".htm\">");
htmTemplate.Write(docExample.Name);
htmTemplate.Write("</a></li>");
htmTemplate.WriteLine("");
}
}
htmTemplate.WriteLine("</ul>");
}
}
// write url for incoming page link
htmTemplate.WriteLinkTo(docTemplate);
htmTemplate.WriteFooter(docPublication.Footer);
}
// recurse
int iTemplate = 0;
foreach (DocTemplateDefinition docSubTemplate in docTemplate.Templates)
{
if (included == null || included.ContainsKey(docSubTemplate))
{
iTemplate++;
int[] subindexpath = new int[indexpath.Length + 1];
indexpath.CopyTo(subindexpath, 0);
subindexpath[subindexpath.Length - 1] = iTemplate;
GenerateTemplate(docProject, docSubTemplate, mapEntity, mapSchema, included, subindexpath, listFigures, listTables, docPublication, path);
}
}
}
private static void ImportMvdTemplate(ConceptTemplate mvdTemplate, DocTemplateDefinition docDef, Dictionary<EntityRule, DocModelRuleEntity> fixups)
{
ImportMvdObject(mvdTemplate, docDef);
docDef.Type = mvdTemplate.ApplicableEntity;
docDef.Rules.Clear();
if (mvdTemplate.Rules != null)
{
foreach (AttributeRule mvdRule in mvdTemplate.Rules)
{
DocModelRule docRule = ImportMvdRule(mvdRule, fixups);
docDef.Rules.Add(docRule);
}
}
// recurse through subtemplates
if (mvdTemplate.SubTemplates != null)
{
foreach (ConceptTemplate mvdSub in mvdTemplate.SubTemplates)
{
DocTemplateDefinition docSub = docDef.GetTemplate(mvdSub.Uuid);
if (docSub == null)
{
docSub = new DocTemplateDefinition();
docDef.Templates.Add(docSub);
}
ImportMvdTemplate(mvdSub, docSub, fixups);
}
}
}
// each list is optional- if specified then must be followed; if null, then no filter applies (all included)
internal static void ExportMvd(
mvdXML mvd,
DocProject docProject,
Dictionary<DocObject, bool> included)
{
mvd.Name = String.Empty;
foreach (DocTemplateDefinition docTemplateDef in docProject.Templates)
{
if (included == null || included.ContainsKey(docTemplateDef))
{
ConceptTemplate mvdConceptTemplate = new ConceptTemplate();
mvd.Templates.Add(mvdConceptTemplate);
ExportMvdTemplate(mvdConceptTemplate, docTemplateDef, included);
}
}
foreach (DocModelView docModelView in docProject.ModelViews)
{
if (included == null || included.ContainsKey(docModelView))
{
ModelView mvdModelView = new ModelView();
mvd.Views.Add(mvdModelView);
ExportMvdObject(mvdModelView, docModelView);
mvdModelView.ApplicableSchema = "IFC4";
mvdModelView.BaseView = docModelView.BaseView;
foreach (DocExchangeDefinition docExchangeDef in docModelView.Exchanges)
{
ExchangeRequirement mvdExchangeDef = new ExchangeRequirement();
mvdModelView.ExchangeRequirements.Add(mvdExchangeDef);
ExportMvdObject(mvdExchangeDef, docExchangeDef);
switch (docExchangeDef.Applicability)
{
case DocExchangeApplicabilityEnum.Export:
mvdExchangeDef.Applicability = ApplicabilityEnum.Export;
break;
case DocExchangeApplicabilityEnum.Import:
mvdExchangeDef.Applicability = ApplicabilityEnum.Import;
break;
}
}
// export template usages for model view
foreach (DocConceptRoot docRoot in docModelView.ConceptRoots)
{
if (docRoot.ApplicableEntity != null)
{
// check if entity contains any concept roots
ConceptRoot mvdConceptRoot = new ConceptRoot();
mvdModelView.Roots.Add(mvdConceptRoot);
ExportMvdObject(mvdConceptRoot, docRoot);
mvdConceptRoot.ApplicableRootEntity = docRoot.ApplicableEntity.Name;
if (docRoot.ApplicableTemplate != null)
{
mvdConceptRoot.Applicability = new ApplicabilityRules();
mvdConceptRoot.Applicability.Template = new TemplateRef();
mvdConceptRoot.Applicability.Template.Ref = docRoot.ApplicableTemplate.Uuid;
mvdConceptRoot.Applicability.TemplateRules = new TemplateRules();
mvdConceptRoot.Applicability.TemplateRules.Operator = (TemplateOperator)Enum.Parse(typeof(TemplateOperator), docRoot.ApplicableOperator.ToString());
foreach (DocTemplateItem docItem in docRoot.ApplicableItems)
{
TemplateRule rule = ExportMvdItem(docItem);
mvdConceptRoot.Applicability.TemplateRules.TemplateRule.Add(rule);
}
}
foreach (DocTemplateUsage docTemplateUsage in docRoot.Concepts)
{
Concept mvdConceptLeaf = new Concept();
mvdConceptRoot.Concepts.Add(mvdConceptLeaf);
ExportMvdConcept(mvdConceptLeaf, docTemplateUsage);
}
}
}
}
}
}
