private void MakeHtmlForFields(WhichType whichType, XmlNode typeNode)
{
XmlNodeList fields = typeNode.SelectNodes("field[not(@declaringType)]");
if (fields.Count > 0)
{
//string typeName = typeNode.Attributes["name"].Value;
string typeID = typeNode.Attributes["id"].Value;
string fileName = GetFilenameForFields(whichType, typeNode);
htmlHelp.AddFileToContents("Fields", fileName);
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("id", String.Empty, typeID);
arguments.AddParam("member-type", String.Empty, "field");
TransformAndWriteResult("individualmembers", arguments, fileName);
htmlHelp.OpenBookInContents();
int[] indexes = SortNodesByAttribute(fields, "id");
foreach (int index in indexes)
{
XmlNode field = fields[index];
string fieldName = field.Attributes["name"].Value;
string fieldID = field.Attributes["id"].Value;
fileName = GetFilenameForField(field);
htmlHelp.AddFileToContents(fieldName + " Field", fileName, HtmlHelpIcon.Page );
arguments = new XsltArgumentList();
arguments.AddParam("field-id", String.Empty, fieldID);
TransformAndWriteResult("field", arguments, fileName);
}
htmlHelp.CloseBookInContents();
}
}
private void MakeHtmlForProperties(WhichType whichType, XmlNode typeNode)
{
XmlNodeList declaredPropertyNodes = typeNode.SelectNodes("property[not(@declaringType)]");
if (declaredPropertyNodes.Count > 0)
{
XmlNodeList propertyNodes;
XmlNode propertyNode;
string propertyName;
string propertyID;
string previousPropertyName;
string nextPropertyName;
bool bOverloaded = false;
string typeName;
string typeID;
string fileName;
int nNodes;
int[] indexes;
int i;
typeName = typeNode.Attributes["name"].Value;
typeID = typeNode.Attributes["id"].Value;
propertyNodes = typeNode.SelectNodes("property[not(@declaringType)]");
nNodes = propertyNodes.Count;
indexes = SortNodesByAttribute(propertyNodes, "id");
fileName = GetFilenameForProperties(whichType, typeNode);
htmlHelp.AddFileToContents("Properties", fileName);
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("id", String.Empty, typeID);
arguments.AddParam("member-type", String.Empty, "property");
TransformAndWriteResult("individualmembers", arguments, fileName);
htmlHelp.OpenBookInContents();
for (i = 0; i < nNodes; i++)
{
propertyNode = propertyNodes[indexes[i]];
propertyName = (string)propertyNode.Attributes["name"].Value;
propertyID = (string)propertyNode.Attributes["id"].Value;
// If the method is overloaded then make an overload page.
previousPropertyName = ((i - 1 < 0) || (propertyNodes[indexes[i - 1]].Attributes.Count == 0))
? "" : propertyNodes[indexes[i - 1]].Attributes[0].Value;
nextPropertyName = ((i + 1 == nNodes) || (propertyNodes[indexes[i + 1]].Attributes.Count == 0))
? "" : propertyNodes[indexes[i + 1]].Attributes[0].Value;
if ((previousPropertyName != propertyName) && (nextPropertyName == propertyName))
{
fileName = GetFilenameForPropertyOverloads(typeNode, propertyNode);
htmlHelp.AddFileToContents(propertyName + " Property", fileName);
arguments = new XsltArgumentList();
arguments.AddParam("member-id", String.Empty, propertyID);
TransformAndWriteResult("memberoverload", arguments, fileName);
htmlHelp.OpenBookInContents();
bOverloaded = true;
}
fileName = GetFilenameForProperty(propertyNode);
if (bOverloaded)
{
XmlNodeList parameterNodes = xmlDocumentation.SelectNodes("/ndoc/assembly/module/namespace/" + lowerCaseTypeNames[whichType] + "[@name=\"" + typeName + "\"]/property[@id=\"" + propertyID + "\"]/parameter");
htmlHelp.AddFileToContents(propertyName + " Property " + GetParamList(parameterNodes), fileName,
HtmlHelpIcon.Page );
}
else
{
htmlHelp.AddFileToContents(propertyName + " Property", fileName,
HtmlHelpIcon.Page );
}
XsltArgumentList arguments2 = new XsltArgumentList();
arguments2.AddParam("property-id", String.Empty, propertyID);
TransformAndWriteResult("property", arguments2, fileName);
if ((previousPropertyName == propertyName) && (nextPropertyName != propertyName))
{
htmlHelp.CloseBookInContents();
bOverloaded = false;
}
}
htmlHelp.CloseBookInContents();
}
}
private void MakeHtmlForInterfaceOrClassOrStructure(
WhichType whichType,
XmlNode typeNode)
{
string typeName = typeNode.Attributes["name"].Value;
string typeID = typeNode.Attributes["id"].Value;
string fileName = GetFilenameForType(typeNode);
htmlHelp.AddFileToContents(typeName + " " + mixedCaseTypeNames[whichType], fileName);
bool hasMembers = typeNode.SelectNodes("constructor|field|property|method|operator|event").Count > 0;
if (hasMembers)
{
htmlHelp.OpenBookInContents();
}
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("type-id", String.Empty, typeID);
TransformAndWriteResult("type", arguments, fileName);
if ( typeNode.SelectNodes( "derivedBy" ).Count > 5 )
{
fileName = GetFilenameForTypeHierarchy(typeNode);
arguments = new XsltArgumentList();
arguments.AddParam("type-id", String.Empty, typeID);
TransformAndWriteResult("typehierarchy", arguments, fileName);
}
if (hasMembers)
{
fileName = GetFilenameForTypeMembers(typeNode);
htmlHelp.AddFileToContents(typeName + " Members",
fileName,
HtmlHelpIcon.Page);
arguments = new XsltArgumentList();
arguments.AddParam("id", String.Empty, typeID);
TransformAndWriteResult("allmembers", arguments, fileName);
MakeHtmlForConstructors(whichType, typeNode);
MakeHtmlForFields(whichType, typeNode);
MakeHtmlForProperties(whichType, typeNode);
MakeHtmlForMethods(whichType, typeNode);
MakeHtmlForOperators(whichType, typeNode);
MakeHtmlForEvents(whichType, typeNode);
htmlHelp.CloseBookInContents();
}
}
private void MakeHtmlForConstructors(WhichType whichType, XmlNode typeNode)
{
XmlNodeList constructorNodes;
string constructorID;
string typeName;
//string typeID;
string fileName;
typeName = typeNode.Attributes["name"].Value;
//typeID = typeNode.Attributes["id"].Value;
constructorNodes = typeNode.SelectNodes("constructor[@contract!='Static']");
// If the constructor is overloaded then make an overload page.
if (constructorNodes.Count > 1)
{
fileName = GetFilenameForConstructors(typeNode);
htmlHelp.AddFileToContents(typeName + " Constructor", fileName);
htmlHelp.OpenBookInContents();
constructorID = constructorNodes[0].Attributes["id"].Value;
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("member-id", String.Empty, constructorID);
TransformAndWriteResult("memberoverload", arguments, fileName);
}
foreach (XmlNode constructorNode in constructorNodes)
{
constructorID = constructorNode.Attributes["id"].Value;
fileName = GetFilenameForConstructor(constructorNode);
if (constructorNodes.Count > 1)
{
XmlNodeList parameterNodes = xmlDocumentation.SelectNodes("/ndoc/assembly/module/namespace/" + lowerCaseTypeNames[whichType] + "[@name=\"" + typeName + "\"]/constructor[@id=\"" + constructorID + "\"]/parameter");
htmlHelp.AddFileToContents(typeName + " Constructor " + GetParamList(parameterNodes), fileName,
HtmlHelpIcon.Page );
}
else
{
htmlHelp.AddFileToContents(typeName + " Constructor", fileName, HtmlHelpIcon.Page );
}
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("member-id", String.Empty, constructorID);
TransformAndWriteResult("member", arguments, fileName);
}
if (constructorNodes.Count > 1)
{
htmlHelp.CloseBookInContents();
}
XmlNode staticConstructorNode = typeNode.SelectSingleNode("constructor[@contract='Static']");
if (staticConstructorNode != null)
{
constructorID = staticConstructorNode.Attributes["id"].Value;
fileName = GetFilenameForConstructor(staticConstructorNode);
htmlHelp.AddFileToContents(typeName + " Static Constructor", fileName, HtmlHelpIcon.Page);
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("member-id", String.Empty, constructorID);
TransformAndWriteResult("member", arguments, fileName);
}
}
private string GetFilenameForMethods(WhichType whichType, XmlNode typeNode)
{
string typeID = (string)typeNode.Attributes["id"].Value;
string fileName = typeID.Substring(2) + "Methods.html";
return fileName;
}
private void MakeHtmlForEnumerationOrDelegate(WhichType whichType, XmlNode typeNode)
{
string typeName = typeNode.Attributes["name"].Value;
string typeID = typeNode.Attributes["id"].Value;
string fileName = GetFilenameForType(typeNode);
htmlHelp.AddFileToContents(typeName + " " + mixedCaseTypeNames[whichType], fileName, HtmlHelpIcon.Page );
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("type-id", String.Empty, typeID);
TransformAndWriteResult("type", arguments, fileName);
}
private string GetFilenameForOperators(WhichType whichType, XmlNode typeNode)
{
string typeID = typeNode.Attributes["id"].Value;
string fileName = typeID.Substring(2) + "Operators.html";
return fileName;
}
private void MakeHtmlForEvents(WhichType whichType, XmlNode typeNode)
{
XmlNodeList declaredEventNodes = typeNode.SelectNodes("event[not(@declaringType)]");
if (declaredEventNodes.Count > 0)
{
XmlNodeList events = typeNode.SelectNodes("event");
if (events.Count > 0)
{
//string typeName = (string)typeNode.Attributes["name"].Value;
string typeID = (string)typeNode.Attributes["id"].Value;
string fileName = GetFilenameForEvents(whichType, typeNode);
htmlHelp.AddFileToContents("Events", fileName);
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("id", String.Empty, typeID);
arguments.AddParam("member-type", String.Empty, "event");
TransformAndWriteResult("individualmembers", arguments, fileName);
htmlHelp.OpenBookInContents();
int[] indexes = SortNodesByAttribute(events, "id");
foreach (int index in indexes)
{
XmlNode eventElement = events[index];
if (eventElement.Attributes["declaringType"] == null)
{
string eventName = (string)eventElement.Attributes["name"].Value;
string eventID = (string)eventElement.Attributes["id"].Value;
fileName = GetFilenameForEvent(eventElement);
htmlHelp.AddFileToContents(eventName + " Event",
fileName,
HtmlHelpIcon.Page);
arguments = new XsltArgumentList();
arguments.AddParam("event-id", String.Empty, eventID);
TransformAndWriteResult("event", arguments, fileName);
}
}
htmlHelp.CloseBookInContents();
}
}
}
private void MakeHtmlForOperators(WhichType whichType, XmlNode typeNode)
{
XmlNodeList operators = typeNode.SelectNodes("operator");
if (operators.Count > 0)
{
string typeName = (string)typeNode.Attributes["name"].Value;
string typeID = (string)typeNode.Attributes["id"].Value;
XmlNodeList opNodes = typeNode.SelectNodes("operator");
string fileName = GetFilenameForOperators(whichType, typeNode);
bool bOverloaded = false;
bool bHasOperators = (typeNode.SelectSingleNode("operator[@name != 'op_Explicit' and @name != 'op_Implicit']") != null);;
bool bHasConverters = (typeNode.SelectSingleNode("operator[@name = 'op_Explicit' or @name = 'op_Implicit']") != null);
string title="";
if (bHasOperators)
{
if (bHasConverters)
{
title = "Operators and Type Conversions";
}
else
{
title = "Operators";
}
}
else
{
if (bHasConverters)
{
title = "Type Conversions";
}
}
htmlHelp.AddFileToContents(title, fileName);
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("id", String.Empty, typeID);
arguments.AddParam("member-type", String.Empty, "operator");
TransformAndWriteResult("individualmembers", arguments, fileName);
htmlHelp.OpenBookInContents();
int[] indexes = SortNodesByAttribute(operators, "id");
int nNodes = opNodes.Count;
//operators first
for (int i = 0; i < nNodes; i++)
{
XmlNode operatorNode = operators[indexes[i]];
string operatorID = operatorNode.Attributes["id"].Value;
string opName = (string)operatorNode.Attributes["name"].Value;
if ((opName != "op_Implicit") && (opName != "op_Explicit"))
{
if (IsMethodFirstOverload(opNodes, indexes, i))
{
bOverloaded = true;
fileName = GetFilenameForOperatorsOverloads(typeNode, operatorNode);
htmlHelp.AddFileToContents(GetOperatorName(operatorNode), fileName);
arguments = new XsltArgumentList();
arguments.AddParam("member-id", String.Empty, operatorID);
TransformAndWriteResult("memberoverload", arguments, fileName);
htmlHelp.OpenBookInContents();
}
fileName = GetFilenameForOperator(operatorNode);
if (bOverloaded)
{
XmlNodeList parameterNodes = xmlDocumentation.SelectNodes("/ndoc/assembly/module/namespace/" + lowerCaseTypeNames[whichType] + "[@name=\"" + typeName + "\"]/operator[@id=\"" + operatorID + "\"]/parameter");
htmlHelp.AddFileToContents(GetOperatorName(operatorNode) + GetParamList(parameterNodes), fileName,
HtmlHelpIcon.Page);
}
else
{
htmlHelp.AddFileToContents(GetOperatorName(operatorNode), fileName,
HtmlHelpIcon.Page );
}
arguments = new XsltArgumentList();
arguments.AddParam("member-id", String.Empty, operatorID);
TransformAndWriteResult("member", arguments, fileName);
if (bOverloaded && IsMethodLastOverload(opNodes, indexes, i))
{
bOverloaded = false;
htmlHelp.CloseBookInContents();
}
}
}
//type converters
for (int i = 0; i < nNodes; i++)
{
XmlNode operatorNode = operators[indexes[i]];
string operatorID = operatorNode.Attributes["id"].Value;
string opName = (string)operatorNode.Attributes["name"].Value;
if ((opName == "op_Implicit") || (opName == "op_Explicit"))
{
fileName = GetFilenameForOperator(operatorNode);
htmlHelp.AddFileToContents(GetOperatorName(operatorNode), fileName,
HtmlHelpIcon.Page );
arguments = new XsltArgumentList();
arguments.AddParam("member-id", String.Empty, operatorID);
TransformAndWriteResult("member", arguments, fileName);
}
}
htmlHelp.CloseBookInContents();
}
}
private void MakeHtmlForMethods(WhichType whichType, XmlNode typeNode)
{
XmlNodeList declaredMethodNodes = typeNode.SelectNodes("method[not(@declaringType)]");
if (declaredMethodNodes.Count > 0)
{
bool bOverloaded = false;
string fileName;
string typeName = typeNode.Attributes["name"].Value;
string typeID = typeNode.Attributes["id"].Value;
XmlNodeList methodNodes = typeNode.SelectNodes("method");
int nNodes = methodNodes.Count;
int[] indexes = SortNodesByAttribute(methodNodes, "id");
fileName = GetFilenameForMethods(whichType, typeNode);
htmlHelp.AddFileToContents("Methods", fileName);
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("id", String.Empty, typeID);
arguments.AddParam("member-type", String.Empty, "method");
TransformAndWriteResult("individualmembers", arguments, fileName);
htmlHelp.OpenBookInContents();
for (int i = 0; i < nNodes; i++)
{
XmlNode methodNode = methodNodes[indexes[i]];
string methodName = (string)methodNode.Attributes["name"].Value;
string methodID = (string)methodNode.Attributes["id"].Value;
if (IsMethodFirstOverload(methodNodes, indexes, i))
{
bOverloaded = true;
fileName = GetFilenameForMethodOverloads(typeNode, methodNode);
htmlHelp.AddFileToContents(methodName + " Method", fileName);
arguments = new XsltArgumentList();
arguments.AddParam("member-id", String.Empty, methodID);
TransformAndWriteResult("memberoverload", arguments, fileName);
htmlHelp.OpenBookInContents();
}
if (methodNode.Attributes["declaringType"] == null)
{
fileName = GetFilenameForMethod(methodNode);
if (bOverloaded)
{
XmlNodeList parameterNodes = xmlDocumentation.SelectNodes("/ndoc/assembly/module/namespace/" + lowerCaseTypeNames[whichType] + "[@name=\"" + typeName + "\"]/method[@id=\"" + methodID + "\"]/parameter");
htmlHelp.AddFileToContents(methodName + " Method " + GetParamList(parameterNodes), fileName,
HtmlHelpIcon.Page );
}
else
{
htmlHelp.AddFileToContents(methodName + " Method", fileName,
HtmlHelpIcon.Page );
}
XsltArgumentList arguments2 = new XsltArgumentList();
arguments2.AddParam("member-id", String.Empty, methodID);
TransformAndWriteResult("member", arguments2, fileName);
}
if (bOverloaded && IsMethodLastOverload(methodNodes, indexes, i))
{
bOverloaded = false;
htmlHelp.CloseBookInContents();
}
}
htmlHelp.CloseBookInContents();
}
}
private string GetFilenameForProperties(WhichType whichType, XmlNode typeNode)
{
string typeID = (string)typeNode.Attributes["id"].Value;
string fileName = typeID.Substring(2) + "Properties.html";
return GetLegalFileName(fileName);
}
