-
#include
- "; if (currentIndexEntry < indexChars.size() && !strncmp(indexChars[currentIndexEntry].c_str(), cdi->GetName(), indexChars[currentIndexEntry].length())) indexFile << ""; TString htmlFile(cdi->GetHtmlFileName()); if (htmlFile.Length()) { indexFile << ""; ReplaceSpecialChars(indexFile, cdi->GetName()); indexFile << " "; } else { indexFile << ""; ReplaceSpecialChars(indexFile, cdi->GetName()); indexFile << " "; } // write title == short doc ReplaceSpecialChars(indexFile, currentClass->GetTitle()); indexFile << " " << endl; } indexFile << "
- "; if (currentIndexEntry < indexChars.size() && !strncmp(indexChars[currentIndexEntry].c_str(), cdi->GetName(), indexChars[currentIndexEntry].length())) outputFile << ""; TString htmlFile(cdi->GetHtmlFileName()); if (htmlFile.Length()) { outputFile << ""; ReplaceSpecialChars(outputFile, classPtr->GetName()); outputFile << " "; } else { outputFile << ""; ReplaceSpecialChars(outputFile, classPtr->GetName()); outputFile << " "; } // write title ReplaceSpecialChars(outputFile, classPtr->GetTitle()); outputFile << " " << endl; } if (count) outputFile << "
- " << endl;
// make loop on data types
std::vector
Jump to
" << endl; // find index chars GetIndexChars(typeNames, 10 /*sections*/, indexChars); for (UInt_t iIdxEntry = 0; iIdxEntry < indexChars.size(); ++iIdxEntry) { typesList << ""; ReplaceSpecialChars(typesList, indexChars[iIdxEntry].c_str()); typesList << "" << endl; } typesList << "
" << endl; } typesList << "- " << endl;
int idx = 0;
UInt_t currentIndexEntry = 0;
for (std::vector
- "; if (currentIndexEntry < indexChars.size() && !strncmp(indexChars[currentIndexEntry].c_str(), iTypeName->c_str(), indexChars[currentIndexEntry].length())) typesList << "" << endl; typesList << "c_str()); typesList << "\">"; ReplaceSpecialChars(typesList, iTypeName->c_str()); typesList << " "; ReplaceSpecialChars(typesList, type->GetTitle()); typesList << " " << endl; ++idx; } typesList << "
"); break; default: Error("DecorateEntityBegin", "Unhandled / invalid entity type %d!", (Int_t)type); return; } Ssiz_t addedLen = str.Length() - originalLen; pos += addedLen; } //______________________________________________________________________________ void TDocOutput::DecorateEntityEnd(TString& str, Ssiz_t& pos, TDocParser::EParseContext type) { // Add some colors etc to a source entity, contained in str. // The type of what's contained in str is given by type. // It's called e.g. by TDocParser::BeautifyLine(). // This function should assume that only str."End()" // (i.e. str.Begin()+str.Length()) is valid. // When inserting into str.String(), str.Length() must be updated. Ssiz_t originalLen = str.Length(); switch (type) { case TDocParser::kCode: break; case TDocParser::kComment: str.Insert(pos, ""); break; case TDocParser::kDirective: break; case TDocParser::kString: str.Insert(pos, ""); break; case TDocParser::kKeyword: str.Insert(pos, ""); break; case TDocParser::kCPP: str.Insert(pos, ""); break; case TDocParser::kVerbatim: str.Insert(pos, ""); break; default: Error("DecorateEntityBegin", "Unhandled / invalid entity type %d!", (Int_t)type); return; } Ssiz_t addedLen = str.Length() - originalLen; pos += addedLen; } //______________________________________________________________________________ void TDocOutput::FixupAuthorSourceInfo(TString& authors) { // Special author treatment; called when TDocParser::fSourceInfo[kInfoAuthor] is set. // Modifies the author(s) description, which is a comma separated list of tokens // either in the format // (i) "FirstName LastName " or // (ii) "FirstName LastName more stuff" // The first one generates an XWho link (CERN compatible), // the second a http link (WORLD compatible), being e.g. //"; // this is what e.g. the html directive expects TDocParser parser(*this); parser.Convert(out, in, "./", kFALSE /* no code */, kTRUE /*process Directives*/); out << ""; } } else if (filename.EndsWith(".html", TString::kIgnoreCase)) { std::ifstream in(filename); TString line; while (in) { if (!line.ReadLine(in)) break; out << line << endl; } } else files.push_back(filename.Data()); } else files.push_back(filename.Data()); } std::stringstream furtherReading; files.sort(); for (std::list"; // this is what e.g. the html directive expects TDocParser parser(*this); parser.Convert(outFurther, inFurther, "../", kFALSE /*no code*/, kTRUE /*process Directives*/); outFurther << ""; } } else { if (gSystem->CopyFile(filename, outfile, kTRUE) == -1) continue; } TString showname(gSystem->BaseName(outfile)); furtherReading << ""; showname.Remove(showname.Length() - 5, 5); // .html showname.ReplaceAll("_", " "); ReplaceSpecialChars(furtherReading, showname); furtherReading << " " << endl; } gSystem->FreeDirectory(dirHandle); if (furtherReading.str().length()) out << "Further Reading
" << endl << furtherReading.str() << "List of Classes
" << endl; } //______________________________________________________________________________ void TDocOutput::ReferenceEntity(TSubString& str, TClass* entity, const char* comment /*= 0*/) { // Create a reference to a class documentation page. // str encloses the text to create the reference for (e.g. name of instance). // comment will be added e.g. as tooltip text. // After the reference is put into str.String(), str will enclose the reference // and the original text. Example: // Input: // str.String(): "a gHtml test" // str.Begin(): 2 // str.Length(): 5 // Output: // str.String(): "a gHtml test" // str.Begin(): 2 // str.Length(): 30 TString link; fHtml->GetHtmlFileName(entity, link); if (comment && !strcmp(comment, entity->GetName())) comment = ""; AddLink(str, link, comment); } //______________________________________________________________________________ void TDocOutput::ReferenceEntity(TSubString& str, TDataMember* entity, const char* comment /*= 0*/) { // Create a reference to a data member documentation page. // str encloses the text to create the reference for (e.g. name of instance). // comment will be added e.g. as tooltip text. // After the reference is put into str.String(), str will enclose the reference // and the original text. Example: // Input: // str.String(): "a gHtml test" // str.Begin(): 2 // str.Length(): 5 // Output: // str.String(): "a gHtml test" // str.Begin(): 2 // str.Length(): 30 TString link; TClass* scope = entity->GetClass(); fHtml->GetHtmlFileName(scope, link); link += "#"; TString mangledName; if (scope) { mangledName = scope->GetName(); NameSpace2FileName(mangledName); link += mangledName; link += ":"; } mangledName = entity->GetName(); NameSpace2FileName(mangledName); link += mangledName; TString description; if (!comment) { description = entity->GetFullTypeName(); description += " "; if (scope) { description += scope->GetName(); description += "::"; } description += entity->GetName(); comment = description.Data(); } if (comment && !strcmp(comment, entity->GetName())) comment = ""; AddLink(str, link, comment); } //______________________________________________________________________________ void TDocOutput::ReferenceEntity(TSubString& str, TDataType* entity, const char* comment /*= 0*/) { // Create a reference to a type documentation page. // str encloses the text to create the reference for (e.g. name of instance). // comment will be added e.g. as tooltip text. // After the reference is put into str.String(), str will enclose the reference // and the original text. Example: // Input: // str.String(): "a gHtml test" // str.Begin(): 2 // str.Length(): 5 // Output: // str.String(): "a gHtml test" // str.Begin(): 2 // str.Length(): 30 TString mangledEntity(entity->GetName()); NameSpace2FileName(mangledEntity); TString link; TClassDocInfo* cdi = 0; bool isClassTypedef = entity->GetType() == -1; if (isClassTypedef) /* is class/ struct / union */ isClassTypedef = isClassTypedef && (entity->Property() & 7); if (isClassTypedef) { std::string shortTypeName(fHtml->ShortType(entity->GetFullTypeName())); cdi = (TClassDocInfo*) GetHtml()->GetListOfClasses()->FindObject(shortTypeName.c_str()); } if (cdi) { link = mangledEntity + ".html"; } else { link = "ListOfTypes.html#"; link += mangledEntity; } if (comment && !strcmp(comment, entity->GetName())) comment = ""; AddLink(str, link, comment); } //______________________________________________________________________________ void TDocOutput::ReferenceEntity(TSubString& str, TMethod* entity, const char* comment /*= 0*/) { // Create a reference to a method documentation page. // str encloses the text to create the reference for (e.g. name of instance). // comment will be added e.g. as tooltip text. // After the reference is put into str.String(), str will enclose the reference // and the original text. Example: // Input: // str.String(): "a gHtml test" // str.Begin(): 2 // str.Length(): 5 // Output: // str.String(): "a gHtml test" // str.Begin(): 2 // str.Length(): 30 TString link; TClass* scope = entity->GetClass(); fHtml->GetHtmlFileName(scope, link); link += "#"; TString mangledName(scope->GetName()); NameSpace2FileName(mangledName); link += mangledName; link += ":"; mangledName = entity->GetName(); NameSpace2FileName(mangledName); link += mangledName; TString description; if (!comment && entity->GetClass()) { TIter iMeth(scope->GetListOfMethods()); TMethod* mCand = 0; while ((mCand = (TMethod*)iMeth())) if (!strcmp(mCand->GetName(), entity->GetName())) { if (description.Length()) { description += " or overloads"; break; } description = mCand->GetPrototype(); } comment = description.Data(); } if (comment && !strcmp(comment, entity->GetName())) comment = ""; AddLink(str, link, comment); } //______________________________________________________________________________ Bool_t TDocOutput::ReferenceIsRelative(const char* reference) const { // Check whether reference is a relative reference, and can (or should) // be prependen by relative paths. For HTML, check that it doesn't start // with "http://" or "https://" return !reference || strncmp(reference, "http", 4) || (strncmp(reference + 4, "://", 3) && strncmp(reference + 4, "s://", 4)); } //______________________________________________________________________________ const char* TDocOutput::ReplaceSpecialChars(char c) { // Replace ampersand, less-than and greater-than character, writing to out. // If 0 is returned, no replacement needs to be done. /* if (fEscFlag) { fEscFlag = kFALSE; return buf; } else if (c == fEsc) { // text.Remove(pos, 1); - NO! we want to keep it nevertheless! fEscFlag = kTRUE; return buf; } */ switch (c) { case '<': return "<"; case '&': return "&"; case '>': return ">"; }; return 0; } //______________________________________________________________________________ void TDocOutput::ReplaceSpecialChars(TString& text, Ssiz_t &pos) { // Replace ampersand, less-than and greater-than character // // // Input: text - text where replacement will happen, // pos - index of char to be replaced; will point to next char to be // replaced when function returns // const char c = text[pos]; const char* replaced = ReplaceSpecialChars(c); if (replaced) { text.Replace(pos, 1, replaced); pos += strlen(replaced) - 1; } ++pos; } //______________________________________________________________________________ void TDocOutput::ReplaceSpecialChars(TString& text) { // Replace ampersand, less-than and greater-than character // // // Input: text - text where replacement will happen, // Ssiz_t pos = 0; while (pos < text.Length()) ReplaceSpecialChars(text, pos); } //______________________________________________________________________________ void TDocOutput::ReplaceSpecialChars(std::ostream& out, const char *string) { // Replace ampersand, less-than and greater-than characters, writing to out // // // Input: out - output file stream // string - pointer to an array of characters // while (string && *string) { const char* replaced = ReplaceSpecialChars(*string); if (replaced) out << replaced; else out << *string; string++; } } //______________________________________________________________________________ Bool_t TDocOutput::RunDot(const char* filename, std::ostream* outMap /* =0 */, EGraphvizTool gvwhat /*= kDot*/) { // Run filename".dot", creating filename".png", and - if outMap is !=0, // filename".map", which gets then included literally into outMap. if (!fHtml->HaveDot()) return kFALSE; TString runDot; switch (gvwhat) { case kNeato: runDot = "neato"; break; case kFdp: runDot = "fdp"; break; case kCirco: runDot = "circo"; break; default: runDot = "dot"; }; if (fHtml->GetDotDir() && *fHtml->GetDotDir()) gSystem->PrependPathName(fHtml->GetDotDir(), runDot); runDot += " -q1 -Tpng -o"; runDot += filename; runDot += ".png "; if (outMap) { runDot += "-Tcmap -o"; runDot += filename; runDot += ".map "; } runDot += filename; runDot += ".dot"; if (gDebug > 3) Info("RunDot", "Running: %s", runDot.Data()); Int_t retDot = gSystem->Exec(runDot); if (gDebug < 4 && !retDot) gSystem->Unlink(Form("%s.dot", filename)); if (!retDot && outMap) { ifstream inmap(Form("%s.map", filename)); std::string line; std::getline(inmap, line); if (inmap && !inmap.eof()) { *outMap << "" << endl; } inmap.close(); if (gDebug < 7) gSystem->Unlink(Form("%s.map", filename)); } if (retDot) { Error("RunDot", "Error running %s!", runDot.Data()); fHtml->SetFoundDot(kFALSE); return kFALSE; } return kTRUE; } //______________________________________________________________________________ void TDocOutput::WriteHtmlHeader(std::ostream& out, const char *titleNoSpecial, const char* dir /*=""*/, TClass *cls /*=0*/, const char* header) { // Write HTML header // // Internal method invoked by the overload ifstream addHeaderFile(header); if (!addHeaderFile.good()) { Warning("THtml::WriteHtmlHeader", "Can't open html header file %s\n", header); return; } TString declFileName; if (cls) fHtml->GetDeclFileName(cls, kFALSE, declFileName); TString implFileName; if (cls) fHtml->GetImplFileName(cls, kFALSE, implFileName); const TString& charset = GetHtml()->GetCharset(); TDatime date; TString strDate(date.AsString()); TString line; while (!addHeaderFile.eof()) { line.ReadLine(addHeaderFile, kFALSE); if (addHeaderFile.eof()) break; if (line) { if (!cls && ( line.Index("%CLASS%") != kNPOS || line.Index("%INCFILE%") != kNPOS || line.Index("%SRCFILE%") != kNPOS)) continue; // skip class line for non-class files TString txt(line); txt.ReplaceAll("%TITLE%", titleNoSpecial); txt.ReplaceAll("%DATE%", strDate); txt.ReplaceAll("%RELDIR%", dir); txt.ReplaceAll("%CHARSET%", charset); if (cls) { txt.ReplaceAll("%CLASS%", cls->GetName()); txt.ReplaceAll("%INCFILE%", declFileName); txt.ReplaceAll("%SRCFILE%", implFileName); } out << txt << endl; } } } //______________________________________________________________________________ void TDocOutput::WriteHtmlHeader(std::ostream& out, const char *title, const char* dir /*=""*/, TClass *cls/*=0*/) { // Write HTML header // // // Input: out - output file stream // title - title for the HTML page // cls - current class // dir - relative directory to reach the top // ("" for html doc, "../" for src/*cxx.html etc) // // evaluates the Root.Html.Header setting: // * if not set, the standard header is written. (ROOT) // * if set, and ends with a "+", the standard header is written and this file // included afterwards. (ROOT, USER) // * if set but doesn't end on "+" the file specified will be written instead // of the standard header (USER) // // Any occurrence of "%TITLE%" (without the quotation marks) in the user // provided header file will be replaced by the value of this method's // parameter "title" before written to the output file. %CLASS% is replaced by // the class name, %INCFILE% by the header file name as given by // TClass::GetDeclFileName() and %SRCFILE% by the source file name as given by // TClass::GetImplFileName(). If the header is written for a non-class page, // i.e. cls==0, lines containing %CLASS%, %INCFILE%, or %SRCFILE% will be // skipped. TString userHeader = GetHtml()->GetHeader(); TString noSpecialCharTitle(title); ReplaceSpecialChars(noSpecialCharTitle); Ssiz_t lenUserHeader = userHeader.Length(); // standard header output if Root.Html.Header is not set, or it's set and it ends with a "+". Bool_t bothHeaders = lenUserHeader > 0 && userHeader[lenUserHeader - 1] == '+'; if (lenUserHeader == 0 || bothHeaders) { TString header("header.html"); gSystem->PrependPathName(fHtml->GetEtcDir(), header); WriteHtmlHeader(out, noSpecialCharTitle, dir, cls, header); } if (lenUserHeader != 0) { if (bothHeaders) userHeader.Remove(lenUserHeader - 1); WriteHtmlHeader(out, noSpecialCharTitle, dir, cls, userHeader); }; } //______________________________________________________________________________ void TDocOutput::WriteHtmlFooter(std::ostream& out, const char* /*dir*/, const char* lastUpdate, const char* author, const char* copyright, const char* footer) { // Write HTML footer // // Internal method invoked by the overload static const char* templateSITags[TDocParser::kNumSourceInfos] = { "%UPDATE%", "%AUTHOR%", "%COPYRIGHT%", "%CHANGED%", "%GENERATED%"}; TString today; TDatime dtToday; today.Form("%d-%02d-%02d %02d:%02d", dtToday.GetYear(), dtToday.GetMonth(), dtToday.GetDay(), dtToday.GetHour(), dtToday.GetMinute()); TString datimeString; if (!lastUpdate || !strlen(lastUpdate)) { lastUpdate = today; } const char* siValues[TDocParser::kNumSourceInfos] = { lastUpdate, author, copyright, lastUpdate, today }; ifstream addFooterFile(footer); if (!addFooterFile.good()) { Warning("THtml::WriteHtmlFooter", "Can't open html footer file %s\n", footer); return; } TString line; while (!addFooterFile.eof()) { line.ReadLine(addFooterFile, kFALSE); if (addFooterFile.eof()) break; if (!line) continue; for (Int_t siTag = 0; siTag < (Int_t) TDocParser::kNumSourceInfos; ++siTag) { Ssiz_t siPos = line.Index(templateSITags[siTag]); if (siPos != kNPOS) { if (siValues[siTag] && siValues[siTag][0]) line.Replace(siPos, strlen(templateSITags[siTag]), siValues[siTag]); else line = ""; // skip e.g. %AUTHOR% lines if no author is set } } out << line << std::endl; } } //______________________________________________________________________________ void TDocOutput::WriteHtmlFooter(std::ostream& out, const char *dir, const char *lastUpdate, const char *author, const char *copyright) { // Write HTML footer // // // Input: out - output file stream // dir - usually equal to "" or "../", depends of // current file directory position, i.e. if // file is in the fHtml->GetOutputDir(), then dir will be "" // lastUpdate - last update string // author - author's name // copyright - copyright note // // Allows optional user provided footer to be written. Root.Html.Footer holds // the file name for this footer. For details see THtml::WriteHtmlHeader (here, // the "+" means the user's footer is written in front of Root's!) Occurences // of %AUTHOR%, %CHANGED%, %GENERATED%, and %COPYRIGHT% in the user's file are replaced by // their corresponding values (author, lastUpdate, today, and copyright) before // written to out. // If no author is set (author == "", e.g. for ClassIndex.html") skip the whole // line of the footer template containing %AUTHOR%. Accordingly for %COPYRIGHT%. out << endl; TString userFooter = GetHtml()->GetFooter(); if (userFooter.Length() != 0) { TString footer(userFooter); if (footer.EndsWith("+")) footer.Remove(footer.Length() - 1); WriteHtmlFooter(out, dir, lastUpdate, author, copyright, footer); }; if (userFooter.Length() == 0 || userFooter.EndsWith("+")) { TString footer("footer.html"); gSystem->PrependPathName(fHtml->GetEtcDir(), footer); WriteHtmlFooter(out, dir, lastUpdate, author, copyright, footer); } } //______________________________________________________________________________ void TDocOutput::WriteModuleLinks(std::ostream& out) { // Create a div containing links to all topmost modules if (fHtml->GetListOfModules()->GetSize()) { out << "Modules
" << endl; // find index chars fHtml->SortListOfModules(); TIter iModule(fHtml->GetListOfModules()); TModuleDocInfo* module = 0; while ((module = (TModuleDocInfo*) iModule())) { if (!module->GetName() || strchr(module->GetName(), '/')) continue; if (module->IsSelected()) { TString name(module->GetName()); name.ToUpper(); out << "" << name << "" << endl; } } out<< "
" << endl; } } //______________________________________________________________________________ void TDocOutput::WriteLineNumbers(std::ostream& out, Long_t nLines, const TString& infileBase) const { // Create a div containing the line numbers (for a source listing) 1 to nLines. // Create links to the source file's line number and anchors, such that one can // jump to SourceFile.cxx.html#27 (using the anchor), and one can copy and paste // the link into e.g. gdb to get the text "SourceFile.cxx:27". out << ""; for (Long_t i = 0; i < nLines; ++i) { // to force correct line height out << "" << std::endl; } //______________________________________________________________________________ void TDocOutput::WriteModuleLinks(std::ostream& out, TModuleDocInfo* super) { // Create a div containing links to all modules if (super->GetSub().GetSize()) { TString superName(super->GetName()); superName.ToUpper(); out << "" << infileBase << ":" << i + 1 << ""; } out << "" << superName << " Modules
" << endl; // find index chars super->GetSub().Sort(); TIter iModule(&super->GetSub()); TModuleDocInfo* module = 0; while ((module = (TModuleDocInfo*) iModule())) { if (module->IsSelected()) { TString name(module->GetName()); name.ToUpper(); TString link(name); link.ReplaceAll("/", "_"); Ssiz_t posSlash = name.Last('/'); if (posSlash != kNPOS) name.Remove(0, posSlash + 1); out << "" << name << "" << endl; } } out<< "
" << endl; } } //______________________________________________________________________________ void TDocOutput::WriteSearch(std::ostream& out) { // Write a search link or a search box, based on THtml::GetSearchStemURL() // and THtml::GetSearchEngine(). The first one is preferred. // e.g. searchCmd = "http://www.google.com/search?q=%s+site%3A%u+-site%3A%u%2Fsrc%2F+-site%3A%u%2Fexamples%2F"; const TString& searchCmd = GetHtml()->GetSearchStemURL(); const TString& searchEngine = GetHtml()->GetSearchEngine(); if (!searchCmd.Length() && !searchEngine.Length()) return; if (searchCmd.Length()) { TUrl url(searchCmd); TString serverName(url.GetHost()); if (serverName.Length()) { serverName.Prepend(" title=\""); serverName += "\" "; } // create search input out << "" << endl << "" << endl; } else if (searchEngine.Length()) // create link to search engine page out << "Search the Class Reference Guide" << endl; } //______________________________________________________________________________ void TDocOutput::WriteLocation(std::ostream& out, TModuleDocInfo* module, const char* classname) { // make a link to the description out << "" << endl; // location const char *productName = fHtml->GetProductName(); out << "" << productName << "" << endl; if (module) { TString modulename(module->GetName()); modulename.ToUpper(); TString modulePart; TString modulePath; Ssiz_t pos = 0; while (modulename.Tokenize(modulePart, pos, "/")) { if (pos == kNPOS && !classname) // we are documenting the module itself, no need to link it: break; if (modulePath.Length()) modulePath += "_"; modulePath += modulePart; out << " » " << modulePart << "" << endl; } } TString entityName; if (classname) entityName = classname; else if (module) { entityName = module->GetName(); Ssiz_t posSlash = entityName.Last('/'); if (posSlash != kNPOS) entityName.Remove(0, posSlash + 1); entityName.ToUpper(); } if (entityName.Length()) { out << " » "; ReplaceSpecialChars(out, entityName); out << "" << endl; } out << "" << endl; // location } //______________________________________________________________________________ void TDocOutput::WriteTopLinks(std::ostream& out, TModuleDocInfo* module, const char* classname, Bool_t withLocation) { // Write the first part of the links shown ontop of each doc page; // onehas to be closed by caller so additional items can still // be added. out << "" << endl; // toplinks // } }" << endl; out << "" << endl; //toplinks WriteLocation(out, module, classname); // descrhead line 2 } // else { // Closed by caller! // out << "" << endl; // descrhead, line 1 if (withLocation) { out << "" << endl // descrhead line 1 << "Quick Links:" << endl; // link to the user home page (if exist) const char* userHomePage = GetHtml()->GetHomepage(); const char* productName = fHtml->GetProductName(); if (!productName) { productName = ""; } else if (!strcmp(productName, "ROOT")) { userHomePage = ""; } if (userHomePage && *userHomePage) out << "" << productName << "" << endl; out << "ROOT Homepage" << endl << "Class Index" << endl << "Class Hierarchy" << endl; WriteSearch(out); out << "
" << title << "
" << endl; Int_t numReuseCanvases = 0; if (includeOutput && !(includeOutput & THtml::kForceOutput)) { void* dirHandle = gSystem->OpenDirectory(gSystem->DirName(htmlFilename)); if (dirHandle) { FileStat_t infile_stat; if (!gSystem->GetPathInfo(infilename, infile_stat)) { // can stat. const char* outfile = 0; TString firstCanvasFileBase(gSystem->BaseName(outfilename)); firstCanvasFileBase += "_0.png"; // first check whether the firstCanvasFile exists: Bool_t haveFirstCanvasFile = false; while ((outfile = gSystem->GetDirEntry(dirHandle))) { if (firstCanvasFileBase == outfile) { haveFirstCanvasFile = true; break; } } gSystem->FreeDirectory(dirHandle); FileStat_t outfile_stat; TString firstCanvasFile = outfilename; firstCanvasFile += "_0.png"; Int_t maxIdx = -1; if (haveFirstCanvasFile && !gSystem->GetPathInfo(firstCanvasFile, outfile_stat) && outfile_stat.fMtime > infile_stat.fMtime) { // the first canvas file exists and it is newer than the script, so we reuse // the canvas files. We need to know how many there are: dirHandle = gSystem->OpenDirectory(gSystem->DirName(htmlFilename)); TString stem(gSystem->BaseName(outfilename)); stem += "_"; TString dir(gSystem->DirName(htmlFilename)); while ((outfile = gSystem->GetDirEntry(dirHandle))) { if (strncmp(outfile, stem, stem.Length())) continue; const char* posext = strrchr(outfile, '.'); if (!posext || strcmp(posext, ".png")) continue; // extract the mod time of the PNG file if (gSystem->GetPathInfo(dir + "/" + outfile, outfile_stat)) // can't stat! continue; if (outfile_stat.fMtime > infile_stat.fMtime) { ++numReuseCanvases; // The canvas PNG is newer than the script, so // extract the index of the canvas TString idxStr(outfile + stem.Length()); idxStr.Remove(idxStr.Length() - 4); Int_t idx = idxStr.Atoi(); if (maxIdx < idx) maxIdx = idx; } } gSystem->FreeDirectory(dirHandle); if (maxIdx + 1 != numReuseCanvases) // bad: the number of canvases to reuse noes not correspond to the highest index we saw. // we will need to regenerate evrything. numReuseCanvases = 0; } } // infile can be stat'ed } // can open output directory } // canvases wanted if (numReuseCanvases) Printf("Convert: %s (reusing %d saved canvas%s)", htmlFilename.Data(), numReuseCanvases, (numReuseCanvases > 1 ? "es" : "")); else Printf("Convert: %s", htmlFilename.Data()); UInt_t nCanvases = numReuseCanvases; if (includeOutput) { if (!numReuseCanvases) { // need to run the script if (includeOutput & THtml::kSeparateProcessOutput) { TString baseInFileName = gSystem->BaseName(infilename); TPMERegexp reOutFile(baseInFileName + "_[[:digit:]]+\\.png"); // remove all files matching what saveScriptOutput.C could produce: void* outdirH = gSystem->OpenDirectory(gSystem->DirName(outfilename)); if (outdirH) { // the directory exists. const char* outdirE = 0; while ((outdirE = gSystem->GetDirEntry(outdirH))) { if (reOutFile.Match(outdirE)) { gSystem->Unlink(outdirE); } } gSystem->FreeDirectory(outdirH); } gSystem->Exec(TString::Format("ROOT_HIST=0 root.exe -l -q %s $ROOTSYS/etc/html/saveScriptOutput.C\\(\\\"%s\\\",\\\"%s\\\",%d\\)", gROOT->IsBatch() ? "-b" : "", infilename, gSystem->DirName(outfilename), includeOutput & THtml::kCompiledOutput)); // determine how many output files were created: outdirH = gSystem->OpenDirectory(gSystem->DirName(outfilename)); if (outdirH) { // the directory exists. const char* outdirE = 0; while ((outdirE = gSystem->GetDirEntry(outdirH))) { if (reOutFile.Match(outdirE)) { ++nCanvases; } } gSystem->FreeDirectory(outdirH); } } else { // run in this ROOT process TString pwd(gSystem->pwd()); gSystem->cd(gSystem->DirName(infilename)); TList* gClientGetListOfWindows = 0; TObject* gClientGetDefaultRoot = 0; std::set" << endl;
}
out << "" << endl;
TDocParser parser(*this);
parser.Convert(out, in, relpath, (includeOutput) /* determines whether it's code or not */,
kFALSE /*interpretDirectives*/);
out << " | " << endl;
out << "
|
Class Hierarchy
" << endl; // loop on all classes TClassDocInfo* cdi = 0; TIter iClass(fHtml->GetListOfClasses()); while ((cdi = (TClassDocInfo*)iClass())) { if (!cdi->HaveSource()) continue; // get class TDictionary *dictPtr = cdi->GetClass(); TClass *basePtr = dynamic_castClass Index
" << endl; WriteModuleLinks(indexFile); std::vectorJump to
" << endl; // find index chars GetIndexChars(classNames, 50 /*sections*/, indexChars); for (UInt_t iIdxEntry = 0; iIdxEntry < indexChars.size(); ++iIdxEntry) { indexFile << ""; ReplaceSpecialChars(indexFile, indexChars[iIdxEntry].c_str()); indexFile << "" << endl; } indexFile << "" << endl; } } indexFile << "
- " << endl;
// loop on all classes
UInt_t currentIndexEntry = 0;
TIter iClass(fHtml->GetListOfClasses());
TClassDocInfo* cdi = 0;
Int_t i = 0;
while ((cdi = (TClassDocInfo*)iClass())) {
if (!cdi->IsSelected() || !cdi->HaveSource())
continue;
// get class
TDictionary *currentDict = cdi->GetClass();
TClass* currentClass = dynamic_cast
" << htmltitle << "
" << endl; // Module doc if (GetHtml()->GetModuleDocPath().Length()) { TString outdir(module->GetName()); gSystem->PrependPathName(GetHtml()->GetOutputDir(), outdir); TString moduleDocDir; GetHtml()->GetPathDefinition().GetDocDir(module->GetName(), moduleDocDir); ProcessDocInDir(outputFile, moduleDocDir, outdir, module->GetName()); } WriteModuleLinks(outputFile, module); std::listClass Index
" << endl; if (classNames.size() > 10) { outputFile << "Jump to
" << endl; UInt_t numSections = classNames.size() / 10; if (numSections < 10) numSections = 10; if (numSections > 50) numSections = 50; // find index chars GetIndexChars(classNames, numSections, indexChars); for (UInt_t iIdxEntry = 0; iIdxEntry < indexChars.size(); ++iIdxEntry) { outputFile << ""; ReplaceSpecialChars(outputFile, indexChars[iIdxEntry].c_str()); outputFile << "" << endl; } outputFile << "" << endl; } outputFile << "
- " << endl;
}
// write a classname to an index file
outputFile << "
Library Dependencies
" << endl; RunDot(dotfilename, &out, kFdp); out << "" << GetHtml()->GetProductName() + " Reference Guide
" << std::endl; TString prodDoc; if (GetHtml()->GetPathDefinition().GetDocDir("", prodDoc)) ProcessDocInDir(out, prodDoc, GetHtml()->GetOutputDir(), "./"); WriteModuleLinks(out); out << "Chapters
" << std::endl << "Class Index
" << std::endl << "A complete list of all classes defined in " << GetHtml()->GetProductName() << "
" << std::endl << "Class Hierarchy
" << std::endl << "A hierarchy graph of all classes, showing each class's base and derived classes
" << std::endl << "Type Index
" << std::endl << "A complete list of all types
" << std::endl << "Library Dependency
" << std::endl << "A diagram showing all of " << GetHtml()->GetProductName() << "'s libraries and their dependencies
" << std::endl; WriteHtmlFooter(out); } //______________________________________________________________________________ void TDocOutput::CreateClassTypeDefs() { // Create a forwarding page for each typedef pointing to a class. TDocParser parser(*this); TIter iClass(GetHtml()->GetListOfClasses()); TClassDocInfo* cdi = 0; while ((cdi = (TClassDocInfo*) iClass())) { if (cdi->GetListOfTypedefs().IsEmpty()) continue; TIter iTypedefs(&cdi->GetListOfTypedefs()); TDataType* dt = 0; while ((dt = (TDataType*) iTypedefs())) { if (gDebug > 0) Info("CreateClassTypeDefs", "Creating typedef %s to class %s", dt->GetName(), cdi->GetName()); // create a filename TString filename(dt->GetName()); NameSpace2FileName(filename); gSystem->PrependPathName(fHtml->GetOutputDir(), filename); filename += ".html"; // open class file std::ofstream outfile(filename); if (!outfile.good()) { Error("CreateClassTypeDefs", "Can't open file '%s' !", filename.Data()); continue; } WriteHtmlHeader(outfile, dt->GetName()); outfile << "" << endl; TString dtName(dt->GetName()); ReplaceSpecialChars(dtName); TString sTitle("typedef "); sTitle += dtName; TClass* cls = dynamic_cast";
outfile << "
" << sTitle << "
" << endl << "" << endl;
outfile << dtName << " is a typedef to ";
std::string shortClsName(fHtml->ShortType(cdi->GetName()));
parser.DecorateKeywords(outfile, shortClsName.c_str());
outfile << endl
<< "
" << std::endl
<< "" << endl
<< "" << endl;
outfile << "
" << endl;
// write footer
WriteHtmlFooter(outfile);
}
}
}
//______________________________________________________________________________
void TDocOutput::CreateTypeIndex()
{
// Create index of all data types
// open file
TString outFile("ListOfTypes.html");
gSystem->PrependPathName(fHtml->GetOutputDir(), outFile);
std::ofstream typesList(outFile);
if (!typesList.good()) {
Error("CreateTypeIndex", "Can't open file '%s' !", outFile.Data());
return;
}
Printf(fHtml->GetCounterFormat(), "", "", outFile.Data());
// write typesList header
WriteHtmlHeader(typesList, "List of data types");
typesList << "| typedef "; parser.DecorateKeywords(outfile, dt->GetFullTypeName()); outfile << " | "; ReplaceSpecialChars(outfile, dt->GetName()); if (dt->GetTitle() && dt->GetTitle()[0]) { outfile << " | "; ReplaceSpecialChars(outfile, dt->GetTitle()); } else outfile << " | "; outfile << " |