Logo Search packages:      
Sourcecode: ndoc version File versions  Download package

override void NDoc::Documenter::Msdn::MsdnDocumenter::Build ( Project  project  )  [inline, virtual]

See IDocumenter.

Implements NDoc::Core::BaseDocumenter.

Definition at line 163 of file MsdnDocumenter.cs.

References NDoc::Core::TemplateWriter::Close(), NDoc::Core::TemplateWriter::CopyToEnd(), and NDoc::Core::TemplateWriter::CopyToLine().

            {
                  try
                  {
                        OnDocBuildingStep(0, "Initializing...");

                        //Get an Encoding for the current LangID
                        CultureInfo ci = new CultureInfo(MyConfig.LangID);
                        currentFileEncoding = Encoding.GetEncoding(ci.TextInfo.ANSICodePage);

                        // the workspace class is responsible for maintaining the outputdirectory
                        // and compile intermediate locations
                        workspace = new MsdnWorkspace( Path.GetFullPath( MyConfig.OutputDirectory ) );
                        workspace.Clean();
                        workspace.Prepare();

                        // Write the embedded css files to the html output directory
                        EmbeddedResources.WriteEmbeddedResources(
                              this.GetType().Module.Assembly,
                              "NDoc.Documenter.Msdn.css",
                              workspace.WorkingDirectory);

                        // Write the embedded icons to the html output directory
                        EmbeddedResources.WriteEmbeddedResources(
                              this.GetType().Module.Assembly,
                              "NDoc.Documenter.Msdn.images",
                              workspace.WorkingDirectory);

                        // Write the embedded scripts to the html output directory
                        EmbeddedResources.WriteEmbeddedResources(
                              this.GetType().Module.Assembly,
                              "NDoc.Documenter.Msdn.scripts",
                              workspace.WorkingDirectory);

                        if ( ((string)MyConfig.AdditionalContentResourceDirectory).Length > 0 )             
                              workspace.ImportContentDirectory( MyConfig.AdditionalContentResourceDirectory );

                        // Write the external files (FilesToInclude) to the html output directory

                        foreach( string srcFilePattern in MyConfig.FilesToInclude.Split( '|' ) )
                        {
                              if ((srcFilePattern == null) || (srcFilePattern.Length == 0))
                                    continue;

                              string path = Path.GetDirectoryName(srcFilePattern);
                              string pattern = Path.GetFileName(srcFilePattern);
 
                              // Path.GetDirectoryName can return null in some cases.
                              // Treat this as an empty string.
                              if (path == null)
                                    path = string.Empty;
 
                              // Make sure we have a fully-qualified path name
                              if (!Path.IsPathRooted(path))
                                    path = Path.Combine(Environment.CurrentDirectory, path);
 
                              // Directory.GetFiles does not accept null or empty string
                              // for the searchPattern parameter. When no pattern was
                              // specified, assume all files (*) are wanted.
                              if ((pattern == null) || (pattern.Length == 0))
                                    pattern = "*";
 
                              foreach(string srcFile in Directory.GetFiles(path, pattern))
                              {
                                    string dstFile = Path.Combine(workspace.WorkingDirectory, Path.GetFileName(srcFile));
                                    File.Copy(srcFile, dstFile, true);
                                    File.SetAttributes(dstFile, FileAttributes.Archive);
                              }
                        }
                        OnDocBuildingStep(10, "Merging XML documentation...");

                        // Will hold the name of the file name containing the XML doc
                        string tempFileName = null;

                        try 
                        {
                              // determine temp file name
                              tempFileName = Path.GetTempFileName();
                              // Let the Documenter base class do it's thing.
                              MakeXmlFile(project, tempFileName);

                              // Load the XML documentation into DOM and XPATH doc.
                              using (FileStream tempFile = File.Open(tempFileName, FileMode.Open, FileAccess.Read)) 
                              {
                                    FilteringXmlTextReader fxtr = new FilteringXmlTextReader(tempFile);
                                    xmlDocumentation = new XmlDocument();
                                    xmlDocumentation.Load(fxtr);

                                    tempFile.Seek(0,SeekOrigin.Begin);
                                    XmlTextReader reader = new XmlTextReader(tempFile);
                                    xpathDocument = new XPathDocument(reader, XmlSpace.Preserve);
                              }
                        }
                        finally
                        {
                              if (tempFileName != null && File.Exists(tempFileName)) 
                              {
                                    File.Delete(tempFileName);
                              }
                        }

                        XmlNodeList typeNodes = xmlDocumentation.SelectNodes("/ndoc/assembly/module/namespace/*[name()!='documentation']");
                        if (typeNodes.Count == 0)
                        {
                              throw new DocumenterException("There are no documentable types in this project.\n\nAny types that exist in the assemblies you are documenting have been excluded by the current visibility settings.\nFor example, you are attempting to document an internal class, but the 'DocumentInternals' visibility setting is set to False.\n\nNote: C# defaults to 'internal' if no accessibilty is specified, which is often the case for Console apps created in VS.NET...");
                        }

                        XmlNodeList namespaceNodes = xmlDocumentation.SelectNodes("/ndoc/assembly/module/namespace");
                        int[] indexes = SortNodesByAttribute(namespaceNodes, "name");

                        XmlNode defaultNamespace = namespaceNodes[indexes[0]];;

                        string defaultNamespaceName = (string)defaultNamespace.Attributes["name"].Value;
                        string defaultTopic = defaultNamespaceName + ".html";

                        // setup for root page
                        string rootPageFileName = null;
                        string rootPageTOCName = "Overview";

                        if ((MyConfig.RootPageFileName != null) && (MyConfig.RootPageFileName != string.Empty))
                        {
                              rootPageFileName = MyConfig.RootPageFileName;
                              defaultTopic = "default.html";

                              // what to call the top page in the table of contents?
                              if ((MyConfig.RootPageTOCName != null) && (MyConfig.RootPageTOCName != string.Empty))
                              {
                                    rootPageTOCName = MyConfig.RootPageTOCName;
                              }
                        }

                        htmlHelp = new HtmlHelp(
                              workspace.WorkingDirectory,
                              MyConfig.HtmlHelpName,
                              defaultTopic,
                              ((MyConfig.OutputTarget & OutputType.HtmlHelp) == 0));

                        htmlHelp.IncludeFavorites = MyConfig.IncludeFavorites;
                        htmlHelp.BinaryTOC = MyConfig.BinaryTOC;
                        htmlHelp.LangID=MyConfig.LangID;

                        OnDocBuildingStep(25, "Building file mapping...");

                        MakeFilenames();

                        string DocLangCode = Enum.GetName(typeof(SdkLanguage),MyConfig.SdkDocLanguage).Replace("_","-");
                        utilities = new MsdnXsltUtilities(fileNames, elemNames, MyConfig.SdkDocVersion, DocLangCode, MyConfig.SdkLinksOnWeb, currentFileEncoding);

                        OnDocBuildingStep(30, "Loading XSLT files...");

                        stylesheets = StyleSheetCollection.LoadStyleSheets(MyConfig.ExtensibilityStylesheet);

                        OnDocBuildingStep(40, "Generating HTML pages...");

                        htmlHelp.OpenProjectFile();

                        htmlHelp.OpenContentsFile(string.Empty, true);

                        try
                        {
                              if (MyConfig.CopyrightHref != null && MyConfig.CopyrightHref != String.Empty)
                              {
                                    if (!MyConfig.CopyrightHref.StartsWith("http:"))
                                    {
                                          string copyrightFile = Path.Combine(workspace.WorkingDirectory, Path.GetFileName(MyConfig.CopyrightHref));
                                          File.Copy(MyConfig.CopyrightHref, copyrightFile, true);
                                          File.SetAttributes(copyrightFile, FileAttributes.Archive);
                                          htmlHelp.AddFileToProject(Path.GetFileName(MyConfig.CopyrightHref));
                                    }
                              }

                              // add root page if requested
                              if (rootPageFileName != null)
                              {
                                    if (!File.Exists(rootPageFileName))
                                    {
                                          throw new DocumenterException("Cannot find the documentation's root page file:\n" 
                                                + rootPageFileName);
                                    }

                                    // add the file
                                    string rootPageOutputName = Path.Combine(workspace.WorkingDirectory, "default.html");
                                    if (Path.GetFullPath(rootPageFileName) != Path.GetFullPath(rootPageOutputName))
                                    {
                                          File.Copy(rootPageFileName, rootPageOutputName, true);
                                          File.SetAttributes(rootPageOutputName, FileAttributes.Archive);
                                    }
                                    htmlHelp.AddFileToProject(Path.GetFileName(rootPageOutputName));
                                    htmlHelp.AddFileToContents(rootPageTOCName, 
                                          Path.GetFileName(rootPageOutputName));

                                    // depending on peer setting, make root page the container
                                    if (MyConfig.RootPageContainsNamespaces) htmlHelp.OpenBookInContents();
                              }

                              documentedNamespaces = new ArrayList();
                              MakeHtmlForAssemblies();

                              // close root book if applicable
                              if (rootPageFileName != null)
                              {
                                    if (MyConfig.RootPageContainsNamespaces) htmlHelp.CloseBookInContents();
                              }
                        }
                        finally
                        {
                              htmlHelp.CloseContentsFile();
                              htmlHelp.CloseProjectFile();
                        }

                        htmlHelp.WriteEmptyIndexFile();

                        if ((MyConfig.OutputTarget & OutputType.Web) > 0)
                        {
                              OnDocBuildingStep(75, "Generating HTML content file...");

                              // Write the embedded online templates to the html output directory
                              EmbeddedResources.WriteEmbeddedResources(
                                    this.GetType().Module.Assembly,
                                    "NDoc.Documenter.Msdn.onlinefiles",
                                    workspace.WorkingDirectory);

                              using (TemplateWriter indexWriter = new TemplateWriter(
                                             Path.Combine(workspace.WorkingDirectory, "index.html"),
                                             new StreamReader(this.GetType().Module.Assembly.GetManifestResourceStream(
                                             "NDoc.Documenter.Msdn.onlinetemplates.index.html"))))
                              {
                                    indexWriter.CopyToLine("\t\t<title><%TITLE%></title>");
                                    indexWriter.WriteLine("\t\t<title>" + MyConfig.HtmlHelpName + "</title>");
                                    indexWriter.CopyToLine("\t\t<frame name=\"main\" src=\"<%HOME_PAGE%>\" frameborder=\"1\">");
                                    indexWriter.WriteLine("\t\t<frame name=\"main\" src=\"" + defaultTopic + "\" frameborder=\"1\">");
                                    indexWriter.CopyToEnd();
                                    indexWriter.Close();
                              }

                              Trace.WriteLine("transform the HHC contents file into html");
#if DEBUG
                              int start = Environment.TickCount;
#endif
                              //transform the HHC contents file into html
                              using(StreamReader contentsFile = new StreamReader(htmlHelp.GetPathToContentsFile(),Encoding.Default))
                              {
                                    xpathDocument=new XPathDocument(contentsFile);
                              }
                              using ( StreamWriter streamWriter = new StreamWriter(
                                                File.Open(Path.Combine(workspace.WorkingDirectory, "contents.html"), FileMode.CreateNew, FileAccess.Write, FileShare.None ), Encoding.Default ) )
                              {
#if(NET_1_0)
                                    //Use overload that is obsolete in v1.1
                                    stylesheets["htmlcontents"].Transform(xpathDocument, null, streamWriter);
#else
                                    //Use new overload so we don't get obsolete warnings - clean compile :)
                                    stylesheets["htmlcontents"].Transform(xpathDocument, null, streamWriter, null);
#endif
                              }
#if DEBUG
                              Trace.WriteLine((Environment.TickCount - start).ToString() + " msec.");
#endif
                        }

                        if ((MyConfig.OutputTarget & OutputType.HtmlHelp) > 0)
                        {
                              OnDocBuildingStep(85, "Compiling HTML Help file...");
                              htmlHelp.CompileProject();
                        }
                        else
                        {
#if !DEBUG
                              //remove .hhc file
                              File.Delete(htmlHelp.GetPathToContentsFile());
#endif
                        }

                        // if we're only building a CHM, copy that to the Outpur dir
                        if ((MyConfig.OutputTarget & OutputType.HtmlHelp) > 0 && (MyConfig.OutputTarget & OutputType.Web) == 0) 
                        {
                              workspace.SaveOutputs( "*.chm" );
                        } 
                        else 
                        {
                              // otherwise copy everything to the output dir (cause the help file is all the html, not just one chm)
                              workspace.SaveOutputs( "*.*" );
                        }
                        
                        if ( MyConfig.CleanIntermediates )
                              workspace.CleanIntermediates();
                        
                        OnDocBuildingStep(100, "Done.");
                  }
                  catch(Exception ex)
                  {
                        throw new DocumenterException(ex.Message, ex);
                  }
                  finally
                  {
                        xmlDocumentation = null;
                        xpathDocument = null;
                        stylesheets = null;
                        workspace.RemoveResourceDirectory();
                  }
            }


Generated by  Doxygen 1.6.0   Back to index