public override void Initialize(ConceptualGroup group,
BuildContext context)
{
_group = group;
_context = context;
string workingDir = context.WorkingDirectory;
BuildSettings settings = context.Settings;
BuildGroupContext groupContext = context.GroupContexts[group.Id];
string manifestFile = Path.Combine(workingDir,
groupContext["$ManifestFile"]);
XmlWriterSettings xmlSettings = new XmlWriterSettings();
xmlSettings.Indent = true;
xmlSettings.Encoding = Encoding.UTF8;
_manifestWriter = XmlWriter.Create(manifestFile, xmlSettings);
_manifestWriter.WriteStartDocument();
_manifestWriter.WriteStartElement("topics"); // start - topics
}
public ConceptualGroupContext(ConceptualGroup group, string contextId)
: base(group, contextId)
{
}
public ConceptualGroupContext(ConceptualGroup group)
: base(group)
{
}
/// <summary> /// Applies the processing operations defined by this visitor to the /// specified conceptual group. /// </summary> /// <param name="group"> /// The <see cref="ConceptualGroup">conceptual group</see> to which /// the processing operations defined by this visitor will be applied. /// </param> /// <exception cref="ArgumentNullException"> /// If the <paramref name="group"/> is <see langword="null"/>. /// </exception> protected abstract void OnVisit(ConceptualGroup group);
public override void Initialize(BuildContext context)
{
if (this.IsInitialized)
{
return;
}
base.Initialize(context);
if (!this.IsInitialized)
{
return;
}
if (_listGroups == null || _listGroups.Count == 0)
{
this.IsInitialized = false;
return;
}
int itemCount = _listGroups.Count;
for (int i = 0; i < itemCount; i++)
{
ConceptualGroup group = _listGroups[i];
BuildGroupContext groupContext = context.GroupContexts[group.Id];
if (groupContext == null)
{
throw new BuildException(
"The group context is not provided, and it is required by the build system.");
}
string indexText = String.Empty;
if (itemCount > 1)
{
indexText = (i + 1).ToString();
}
// Create the build dynamic properties...
groupContext.CreateProperties(indexText);
group.BeginSources(context);
}
_listFormats = new BuildFormatList();
BuildFormatList listFormats = this.Settings.Formats;
if (listFormats == null || listFormats.Count == 0)
{
this.IsInitialized = false;
return;
}
itemCount = listFormats.Count;
for (int i = 0; i < itemCount; i++)
{
BuildFormat format = listFormats[i];
if (format != null && format.Enabled)
{
_listFormats.Add(format);
}
}
if (_listFormats == null || _listFormats.Count == 0)
{
this.IsInitialized = false;
return;
}
itemCount = _listGroups.Count;
for (int i = 0; i < itemCount; i++)
{
ConceptualGroup group = _listGroups[i];
group.Initialize(context);
if (!group.IsInitialized)
{
this.IsInitialized = false;
break;
}
}
}
public override BuildStep CreateInitialSteps(BuildGroup group)
{
ConceptualGroup curGroup = group as ConceptualGroup;
if (curGroup == null)
{
throw new BuildException("The build engine requires conceptual group.");
}
//this.CreateSteps(listSteps, curGroup);
if (_listFormats == null || _listFormats.Count == 0)
{
return(null);
}
BuildSettings settings = this.Settings;
string sandcastleDir = this.Context.StylesDirectory;
BuildStyle outputStyle = settings.Style;
if (String.IsNullOrEmpty(sandcastleDir))
{
return(null);
}
BuildMultiStep listSteps = new BuildMultiStep();
listSteps.Message = "Conceptual topics for the group: " + group.Name;
listSteps.LogTitle = String.Empty;
listSteps.LogTimeSpan = true;
// 1. Initialize the conceptual topics...
StepConceptualInit stepInit = new StepConceptualInit(curGroup);
stepInit.Message = "Initializing and generating conceptual contents";
stepInit.LogTitle = String.Empty;
listSteps.Add(stepInit);
string helpStyle = BuildStyle.StyleFolder(
outputStyle.StyleType);
string workingDir = this.Context.WorkingDirectory;
// 2. Ensure that we have a valid list of folders...
IList <string> listFolders = new List <string>();
IDictionary <string, bool> dicFolders = this.GetOutputFolders(listFolders);
int folderCount = listFolders.Count;
// 3. Handle the resources...
StepDirectoryCopy copyResources = new StepDirectoryCopy(
workingDir);
copyResources.LogTitle = String.Empty;
copyResources.Message = "Copying user-defined resources.";
IList <ResourceContent> resourceContents = group.ResourceContents;
if (resourceContents != null && resourceContents.Count != 0)
{
int contentCount = resourceContents.Count;
for (int j = 0; j < contentCount; j++)
{
ResourceContent resourceContent = resourceContents[j];
if (resourceContent == null || resourceContent.Count == 0)
{
continue;
}
int itemCount = resourceContent.Count;
for (int i = 0; i < itemCount; i++)
{
ResourceItem resource = resourceContent[i];
if (resource != null && !resource.IsEmpty)
{
string destFolder = resource.Destination;
copyResources.Add(resource.Source, destFolder);
// Add this to the output folders so that it is copied
// to the final output/build directories...
if (destFolder.StartsWith("Output",
StringComparison.OrdinalIgnoreCase))
{
DirectoryInfo info = new DirectoryInfo(destFolder);
destFolder = info.Name;
if (!String.IsNullOrEmpty(destFolder) &&
!dicFolders.ContainsKey(destFolder))
{
dicFolders.Add(destFolder, true);
listFolders.Add(destFolder);
}
}
}
}
}
}
if (copyResources.IsValid)
{
listSteps.Add(copyResources);
}
else
{
StepNone placeHolder = new StepNone();
placeHolder.LogTitle = String.Empty;
placeHolder.Message = "Copying user-defined resources.";
listSteps.Add(placeHolder);
}
_listFolders = listFolders;
if (listSteps.Count != 0)
{
return(listSteps);
}
return(null);
}
public abstract void Initialize(ConceptualGroup group,
BuildContext context);
/// <summary>
/// Applies the processing operations defined by this visitor to the
/// specified conceptual group.
/// </summary>
/// <param name="group">
/// The <see cref="ConceptualGroup">conceptual group</see> to which
/// the processing operations defined by this visitor will be applied.
/// </param>
/// <exception cref="ArgumentNullException">
/// If the <paramref name="group"/> is <see langword="null"/>.
/// </exception>
protected override void OnVisit(ConceptualGroup group)
{
BuildExceptions.NotNull(group, "group");
if (!this.IsInitialized)
{
throw new BuildException(
"ConceptualProjectVisitor: The conceptual table of contents generator is not initialized.");
}
BuildContext context = this.Context;
BuildLogger logger = context.Logger;
BuildGroupContext groupContext = context.GroupContexts[group.Id];
if (groupContext == null)
{
throw new BuildException(
"The group context is not provided, and it is required by the build system.");
}
if (logger != null)
{
logger.WriteLine("Begin - Creating Conceptual Resource Settings.",
BuildLoggerLevel.Info);
}
_tocAdapter = new ConceptualTocAdapter();
_metadataAdapter = new ConceptualMetadataAdapter();
_manifestAdapters = new ConceptualManifestAdapter();
try
{
_tocAdapter.Initialize(group, context);
_metadataAdapter.Initialize(group, context);
_manifestAdapters.Initialize(group, context);
string workingDir = context.WorkingDirectory;
_ddueXmlDir = Path.Combine(workingDir, groupContext["$DdueXmlDir"]);
_ddueCompDir = Path.Combine(workingDir, groupContext["$DdueXmlCompDir"]);
_ddueHtmlDir = Path.Combine(workingDir, groupContext["$DdueHtmlDir"]);
if (!Directory.Exists(_ddueXmlDir))
{
Directory.CreateDirectory(_ddueXmlDir);
}
if (!Directory.Exists(_ddueCompDir))
{
Directory.CreateDirectory(_ddueCompDir);
}
if (!Directory.Exists(_ddueHtmlDir))
{
Directory.CreateDirectory(_ddueHtmlDir);
}
ConceptualContent content = group.Content;
int itemCount = content.Count;
for (int i = 0; i < itemCount; i++)
{
this.WriteTopic(content[i]);
}
IList <ConceptualRelatedTopic> relatedTopics = content.RelatedTopics;
if (relatedTopics != null && relatedTopics.Count != 0)
{
itemCount = relatedTopics.Count;
for (int i = 0; i < itemCount; i++)
{
ConceptualRelatedTopic topicItem = relatedTopics[i];
if (topicItem == null || topicItem.IsEmpty)
{
continue;
}
this.WriteTopic(topicItem);
}
}
}
finally
{
_tocAdapter.Uninitialize();
_metadataAdapter.Uninitialize();
_manifestAdapters.Uninitialize();
}
if (logger != null)
{
logger.WriteLine("Completed - Creating Conceptual Resource Settings.",
BuildLoggerLevel.Info);
}
}
