protected virtual void OnDocumentType(string documentTag)
{
if (String.IsNullOrEmpty(_topicTypeId))
{
_topicTypeId = ConceptualUtils.ToTopicTypeId(documentTag);
}
}
public void Add(string topicId)
{
BuildExceptions.NotNullNotEmpty(topicId, "topicId");
if (ConceptualUtils.IsValidId(topicId) == false)
{
throw new ArgumentException("topicId");
}
if (_dicTopicId != null)
{
_dicTopicId.Add(topicId, true);
}
}
private void ReadTopics(XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
// handle the default topic id...
string defaultTopic = reader.GetAttribute("default");
if (ConceptualUtils.IsValidId(defaultTopic))
{
_defaultTopic = defaultTopic;
}
string startName = reader.Name;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (String.Equals(reader.Name, ConceptualItem.TagName,
StringComparison.OrdinalIgnoreCase))
{
ConceptualItem topicItem = ConceptualItem.Create(
reader.GetAttribute("type"));
if (topicItem != null)
{
topicItem.Content = this;
topicItem.BeginInit();
topicItem.ReadXml(reader);
topicItem.EndInit();
this.Add(topicItem);
}
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (String.Equals(reader.Name, startName,
StringComparison.OrdinalIgnoreCase))
{
break;
}
}
}
}
protected override void OnDocumentType(string documentTag)
{
base.OnDocumentType(documentTag);
_topicType = ConceptualUtils.FromDocumentTag(documentTag);
}
protected virtual bool OnLoadTopicMetadata()
{
if (_filePath == null || !_filePath.Exists)
{
return(false);
}
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreComments = true;
settings.IgnoreWhitespace = true;
settings.IgnoreProcessingInstructions = true;
XmlReader reader = null;
try
{
reader = XmlReader.Create(_filePath, settings);
XmlNodeType nodeType = reader.MoveToContent();
Debug.Assert(nodeType == XmlNodeType.Element);
if (nodeType != XmlNodeType.Element)
{
return(false);
}
if (String.Equals(reader.Name, "topic",
StringComparison.OrdinalIgnoreCase))
{
_includesTopicId = true;
_topicId = reader.GetAttribute("id");
string strTemp = reader.GetAttribute("revisionNumber");
if (!String.IsNullOrEmpty(strTemp))
{
_revNumber = Convert.ToInt32(strTemp);
}
string nodeName = null;
while (reader.Read())
{
nodeType = reader.NodeType;
nodeName = reader.Name;
if (nodeType == XmlNodeType.Element)
{
if (ConceptualUtils.IsValidDocumentTag(nodeName))
{
this.OnDocumentType(nodeName);
break;
}
}
else if (nodeType == XmlNodeType.EndElement)
{
if (String.Equals(nodeName, "topic") ||
ConceptualUtils.IsValidDocumentTag(nodeName))
{
this.OnDocumentType(nodeName);
break;
}
}
}
}
else if (ConceptualUtils.IsValidDocumentTag(reader.Name))
{
_includesTopicId = false;
this.OnDocumentType(reader.Name);
}
}
finally
{
if (reader != null)
{
reader.Close();
}
}
// If the companion file is available, load it...
string companionFile = Path.ChangeExtension(_filePath, ".cmp");
if (!File.Exists(companionFile))
{
return(true);
}
try
{
reader = XmlReader.Create(companionFile, settings);
XmlNodeType nodeType = XmlNodeType.None;
string nodeName = null;
string nodeText = null;
while (reader.Read())
{
nodeType = reader.NodeType;
nodeName = reader.Name;
if (nodeType == XmlNodeType.Element)
{
switch (nodeName)
{
case "title":
nodeText = reader.ReadString().Trim();
if (!String.IsNullOrEmpty(nodeText))
{
_topicTitle = nodeText;
}
break;
case "tableOfContentsTitle":
nodeText = reader.ReadString().Trim();
if (!String.IsNullOrEmpty(nodeText))
{
_topicTocTitle = nodeText;
}
break;
case "linkText":
nodeText = reader.ReadString().Trim();
if (!String.IsNullOrEmpty(nodeText))
{
_topicLinkText = nodeText;
}
break;
case "keyword":
KeywordItem keyItem = new KeywordItem();
keyItem.ReadXml(reader);
if (!keyItem.IsEmpty)
{
_keywords.Add(keyItem);
}
break;
case "attribute":
AttributeItem attrItem = new AttributeItem();
attrItem.ReadXml(reader);
if (!attrItem.IsEmpty)
{
_attributes.Add(attrItem);
}
break;
case "authoring":
break;
}
}
else if (nodeType == XmlNodeType.EndElement)
{
if (String.Equals(nodeName, "metadata"))
{
this.OnDocumentType(nodeName);
break;
}
}
}
}
finally
{
if (reader != null)
{
reader.Close();
}
}
return(true);
}
public override void ReadXml(XmlReader reader)
{
BuildExceptions.NotNull(reader, "reader");
Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (reader.NodeType != XmlNodeType.Element)
{
return;
}
if (!String.Equals(reader.Name, TagName,
StringComparison.OrdinalIgnoreCase))
{
return;
}
string nodeText = reader.GetAttribute("id");
if (ConceptualUtils.IsValidId(nodeText))
{
_topicId = nodeText;
}
nodeText = reader.GetAttribute("visible");
if (!String.IsNullOrEmpty(nodeText))
{
_isVisible = Convert.ToBoolean(nodeText);
}
nodeText = reader.GetAttribute("revision");
if (!String.IsNullOrEmpty(nodeText))
{
_revNumber = Convert.ToInt32(nodeText);
}
string nodeName = null;
XmlNodeType nodeType = XmlNodeType.None;
while (reader.Read())
{
nodeName = reader.Name;
nodeType = reader.NodeType;
if (nodeType == XmlNodeType.Element)
{
switch (nodeName)
{
case "title":
nodeText = reader.ReadString();
if (!String.IsNullOrEmpty(nodeText))
{
_topicTitle = nodeText;
}
break;
case "path":
if (_filePath == null)
{
_filePath = new BuildFilePath();
}
_filePath.ReadXml(reader);
break;
case "excludes":
this.OnReadExcludes(reader);
break;
case "metadata":
this.OnReadMetadata(reader);
break;
case "topic":
ConceptualItem topicItem = ConceptualItem.Create(
reader.GetAttribute("type"));
if (topicItem != null)
{
topicItem.Content = this.Content;
topicItem.BeginInit();
topicItem.ReadXml(reader);
topicItem.EndInit();
this.Add(topicItem);
}
break;
default:
this.OnReadXmlTag(reader);
break;
}
}
else if (nodeType == XmlNodeType.EndElement)
{
if (String.Equals(nodeName, TagName,
StringComparison.OrdinalIgnoreCase))
{
break;
}
}
}
}
private void ReadTopic(XmlReader reader, ConceptualContent content,
ConceptualItem parentItem)
{
XmlNodeType nodeType = XmlNodeType.None;
string nodeName = null;
int revNumber = 1;
while (reader.Read())
{
nodeType = reader.NodeType;
if (nodeType == XmlNodeType.Element)
{
nodeName = reader.Name;
if (String.Equals(nodeName, "Topic"))
{
bool isVisible = true;
string docId = reader.GetAttribute("id");
if (ConceptualUtils.IsValidId(docId))
{
string textTemp = reader.GetAttribute("visible");
if (!String.IsNullOrEmpty(textTemp))
{
isVisible = Convert.ToBoolean(textTemp);
}
string docTitle = reader.GetAttribute("title");
if (!String.IsNullOrEmpty(docTitle))
{
string fullPath = Path.Combine(_contentDir,
docId + ".aml");
ConceptualTopic docItem = new ConceptualTopic(
new BuildFilePath(fullPath), docTitle, docId);
docItem.Content = content;
docItem.BeginInit();
docItem.Visible = isVisible;
docItem.TopicRevisions = revNumber;
//docItem.IncludesTopicId = true;
docItem.EndInit();
// handle the sub-item...
if (!reader.IsEmptyElement)
{
ReadTopic(reader, content, docItem);
}
parentItem.Add(docItem);
}
}
}
else if (String.Equals(nodeName, "HelpKeyword"))
{
string index = reader.GetAttribute("index");
string term = reader.GetAttribute("term");
if (!String.IsNullOrEmpty(index) &&
!String.IsNullOrEmpty(term))
{
KeywordItem keyword = new KeywordItem(
KeywordItem.ParseIndex(index), term);
parentItem.Keywords.Add(keyword);
}
}
}
else if (nodeType == XmlNodeType.EndElement)
{
if (String.Equals(reader.Name, "Topic"))
{
break;
}
}
}
}
