private void preorder_build(List <abstract_TreeNode> collection, abstract_TreeNode thisNode, bool only_add_pages) { // Since this is pre-order, first 'visit' this if (!only_add_pages) { collection.Add(thisNode); } else { // If we are just getting pages, only add if it is not already added if ((thisNode.Page) && (!collection.Contains(thisNode))) { collection.Add(thisNode); } } // is this a division node? .. which can have children .. if (!thisNode.Page) { Division_TreeNode thisDivNode = (Division_TreeNode)thisNode; // Do the same for all the children foreach (abstract_TreeNode childNode in thisDivNode.Nodes) { preorder_build(collection, childNode, only_add_pages); } } }
/// <summary> Flag indicates if this active reader/writer will write a dmdSec for this node </summary> /// <param name="MetsDivision"> Division to check if a dmdSec will be written </param> /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param> /// <returns> TRUE if the package has data to be written, otherwise fALSE </returns> public bool Include_dmdSec(abstract_TreeNode MetsDivision, Dictionary<string, object> Options) { // GEt the geo-spatial information if it exists GeoSpatial_Information geoInfo = MetsDivision.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY) as GeoSpatial_Information; if ((geoInfo == null) || (!geoInfo.hasData)) return false; return true; }
/// <summary> Reads the dmdSec at the current position in the XmlTextReader and associates it with /// one subsection/division from the METS structure map </summary> /// <param name="Input_XmlReader"> Open XmlReader from which to read the metadata </param> /// <param name="MetsDivision"> Division from the overall package into which to read the metadata</param> /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param> /// <returns> TRUE if successful, otherwise FALSE</returns> public bool Read_dmdSec(XmlReader Input_XmlReader, abstract_TreeNode MetsDivision, Dictionary<string, object> Options) { // Get the geo-spatial information if it exists or create a new one GeoSpatial_Information geoInfo = MetsDivision.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY) as GeoSpatial_Information; if (geoInfo == null) { geoInfo = new GeoSpatial_Information(); MetsDivision.Add_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY, geoInfo); } return Read_Metadata_Section(Input_XmlReader, geoInfo, Options); }
private void preorder_build(List <abstract_TreeNode> Collection, abstract_TreeNode ThisNode, bool OnlyAddPages, bool PagesMustHaveFiles) { // Since this is pre-order, first 'visit' this if (!OnlyAddPages) { Collection.Add(ThisNode); } else { // If we are just getting pages, only add if it is not already added if ((ThisNode.Page) && (!Collection.Contains(ThisNode))) { // If you just add all files, just add it here if (!PagesMustHaveFiles) { Collection.Add(ThisNode); } else { // Must ensure this page has files to add it Page_TreeNode asPage = ThisNode as Page_TreeNode; if (asPage != null) { if ((asPage.Files != null) && (asPage.Files.Count > 0)) { Collection.Add(asPage); } } } } } // is this a division node? .. which can have children .. if (!ThisNode.Page) { Division_TreeNode thisDivNode = (Division_TreeNode)ThisNode; // Do the same for all the children foreach (abstract_TreeNode childNode in thisDivNode.Nodes) { preorder_build(Collection, childNode, OnlyAddPages, PagesMustHaveFiles); } } }
private bool recursively_add_file(abstract_TreeNode Node, SobekCM_File_Info New_File, string SystemName_Upper) { // If this is a page, check for a match first if (Node.Page) { Page_TreeNode pageNode = (Page_TreeNode)Node; if (pageNode.Files.Count >= 1) { if (pageNode.Files[0].File_Name_Sans_Extension == SystemName_Upper) { // Belongs to this page. Now, just make sure it doesn't already exist foreach (SobekCM_File_Info thisFile in pageNode.Files) { if (thisFile.System_Name.ToUpper() == New_File.System_Name.ToUpper()) { return(true); } } // Not found, so add it to this page pageNode.Files.Add(New_File); return(true); } } } // If this was a division, check all pages if (!Node.Page) { Division_TreeNode divNode = (Division_TreeNode)Node; foreach (abstract_TreeNode childNodes in divNode.Nodes) { if (recursively_add_file(childNodes, New_File, SystemName_Upper)) { return(true); } } } // If nothing found that matches under this node, return false return(false); }
private bool recursively_check_for_any_files(abstract_TreeNode Node) { if (Node.Page) { if (((Page_TreeNode)Node).Files.Count > 0) { return(true); } } if (!Node.Page) { Division_TreeNode divNode = (Division_TreeNode)Node; foreach (abstract_TreeNode TreeNode in divNode.Nodes) { if (recursively_check_for_any_files(TreeNode)) { return(true); } } } return(false); }
private void recurse_through_nodes(abstract_TreeNode Node, List<Page_TreeNode> PagesEncountered) { if (Node.Page) { Page_TreeNode pageNode = (Page_TreeNode)Node; if (!PagesEncountered.Contains(pageNode)) { pageseq++; } } else { Division_TreeNode divNode = (Division_TreeNode)Node; foreach (abstract_TreeNode childNode in divNode.Nodes) { recurse_through_nodes(childNode, PagesEncountered); } } }
private static bool recursively_remove_empty_divisions(abstract_TreeNode ChildNode) { // This steps through all the children nodes and checks for emptiness // If the node is empty and should be removed by the parent, TRUE is returned, // otherwise FALSE is returned, in which case the node has some children and // should not be removed if (!ChildNode.Page) { Division_TreeNode divNode = (Division_TreeNode) ChildNode; if (divNode.Nodes.Count > 0) { int nodeCounter = 0; while (nodeCounter < divNode.Nodes.Count) { abstract_TreeNode thisNode = divNode.Nodes[nodeCounter]; if (recursively_remove_empty_divisions(thisNode)) { divNode.Nodes.Remove(thisNode); } else { nodeCounter++; } } return divNode.Nodes.Count <= 0; } return true; } Page_TreeNode pageNode = (Page_TreeNode) ChildNode; return pageNode.Files.Count == 0; }
private static void recursively_add_all_METS_files(abstract_TreeNode RootNode, List<SobekCM_File_Info> METSFiles, Builder_Page_File_Collection METSFileCollection, Dictionary<SobekCM_File_Info, Page_TreeNode> FileToPage, Dictionary<Page_TreeNode, Division_TreeNode> PageToDiv, List<string> FileFilters) { if (RootNode.Page) { Page_TreeNode pageNode = (Page_TreeNode) RootNode; foreach (SobekCM_File_Info thisFile in pageNode.Files) { bool add_file = false; if (FileFilters.Count == 0) { add_file = true; } else { foreach (string file_filter in FileFilters) { if (thisFile.System_Name.ToUpper().IndexOf(file_filter) > 0) { add_file = true; break; } } } if (add_file) { METSFiles.Add(thisFile); Builder_Page_File newPageFile = new Builder_Page_File(thisFile.System_Name, true); newPageFile.METS_Page = pageNode; newPageFile.METS_Division = PageToDiv[pageNode]; METSFileCollection.Insert(newPageFile); FileToPage.Add(thisFile, pageNode); } } } else { Division_TreeNode divNode = (Division_TreeNode) RootNode; foreach (abstract_TreeNode thisNode in divNode.Nodes) { if (thisNode.Page) { try { if (!PageToDiv.ContainsKey((Page_TreeNode) thisNode)) { PageToDiv.Add((Page_TreeNode) thisNode, divNode); } } catch { } } recursively_add_all_METS_files(thisNode, METSFiles, METSFileCollection, FileToPage, PageToDiv, FileFilters); } } }
private void recursively_build_all_files_list(List <SobekCM_File_Info> returnValue, List <Page_TreeNode> handledPages, abstract_TreeNode thisNode) { // Since this is pre-order, first 'visit' this if (thisNode.Page) { Page_TreeNode pageNode = (Page_TreeNode)thisNode; if (!handledPages.Contains(pageNode)) { foreach (SobekCM_File_Info file in pageNode.Files) { returnValue.Add(file); } handledPages.Add(pageNode); } } // is this a division node? .. which can have children .. if (!thisNode.Page) { Division_TreeNode thisDivNode = (Division_TreeNode)thisNode; // Do the same for all the children foreach (abstract_TreeNode childNode in thisDivNode.Nodes) { recursively_build_all_files_list(returnValue, handledPages, childNode); } } }
private void recurse_through_nodes( SobekCM_Item ThisPackage, abstract_TreeNode Node, List<Page_TreeNode> PagesEncountered ) { if (Node.Page) { Page_TreeNode pageNode = (Page_TreeNode)Node; if ( !PagesEncountered.Contains( pageNode )) { pageseq++; // Add each of the files view codes to the list bool page_added = false; foreach (SobekCM_File_Info thisFile in pageNode.Files) { string upper_name = thisFile.System_Name.ToUpper(); if ((upper_name.IndexOf("SOUNDFILESONLY") < 0) && ( upper_name.IndexOf("FILMONLY") < 0 ) && ( upper_name.IndexOf("MULTIMEDIA") < 0 ) && ( upper_name.IndexOf("THM.JPG") < 0 )) { if (!page_added) { // Add this to the simple page collection ThisPackage.Web.Add_Pages_By_Sequence(pageNode); PagesEncountered.Add(pageNode); page_added = true; } View_Object thisViewer = thisFile.Get_Viewer(); if (thisViewer != null) { string[] codes = thisViewer.Viewer_Codes; if ((codes.Length > 0) && (codes[0].Length > 0)) { ThisPackage.Web.Viewer_To_File[pageseq.ToString() + codes[0]] = thisFile; } } } // TEST: Special case for text if ((ThisPackage.BibID == "UF00001672") || ( ThisPackage.BibID == "TEST000003")) { if (thisFile.File_Extension.ToLower().IndexOf("jpg") >= 0) { string filename = thisFile.File_Name_Sans_Extension + ".txt"; SobekCM_File_Info thisFileInfo = new SobekCM_File_Info(filename); ThisPackage.Web.Viewer_To_File[pageseq.ToString() + "t"] = thisFileInfo; } } } } } else { divseq++; Division_TreeNode divNode = (Division_TreeNode)Node; foreach (abstract_TreeNode childNode in divNode.Nodes) { recurse_through_nodes(ThisPackage, childNode, PagesEncountered); } } }
private void recursively_add_div_info(abstract_TreeNode ThisNode, TextWriter Results, Dictionary<abstract_TreeNode, int> PagesToAppearances, int Order) { // Add the div information for this node first if (ThisNode.Page) { // If the ID of this page is SKIP, then just return and do nothing here if (ThisNode.ID == "SKIP") return; if (PagesToAppearances.ContainsKey(ThisNode)) { PagesToAppearances[ThisNode] = PagesToAppearances[ThisNode] + 1; Results.Write("<METS:div ID=\"" + ThisNode.ID + "_repeat" + PagesToAppearances[ThisNode] + "\""); } else { PagesToAppearances[ThisNode] = 1; Results.Write("<METS:div ID=\"" + ThisNode.ID + "\""); } } else { Results.Write("<METS:div ID=\"" + ThisNode.ID + "\""); } // Add links to dmd secs and amd secs if ( !String.IsNullOrEmpty(ThisNode.DMDID)) { Results.Write(" DMDID=\"" + ThisNode.DMDID + "\""); } if (!String.IsNullOrEmpty(ThisNode.ADMID)) { Results.Write(" ADMID=\"" + ThisNode.ADMID + "\""); } // Add the label, if there is one if ((ThisNode.Label.Length > 0) && (ThisNode.Label != ThisNode.Type)) Results.Write(" LABEL=\"" + Convert_String_To_XML_Safe(ThisNode.Label) + "\""); // Finish the start div label for this division Results.WriteLine(" ORDER=\"" + Order + "\" TYPE=\"" + ThisNode.Type + "\">"); // If this is a page, add all the files, otherwise call this method recursively if (ThisNode.Page) { // Add each file Page_TreeNode thisPage = (Page_TreeNode)ThisNode; foreach (SobekCM_File_Info thisFile in thisPage.Files) { // Add the file pointer informatino if ( thisFile.ID.Length > 0 ) Results.WriteLine("<METS:fptr FILEID=\"" + thisFile.ID + "\" />"); } } else { // Call this method for each subdivision int inner_order = 1; Division_TreeNode thisDivision = (Division_TreeNode)ThisNode; foreach (abstract_TreeNode thisSubDivision in thisDivision.Nodes) { recursively_add_div_info(thisSubDivision, Results, PagesToAppearances, inner_order++ ); } } // Close out this division Results.WriteLine("</METS:div>"); }
private void recursively_build_all_files_list(List<SobekCM_File_Info> returnValue, List<Page_TreeNode> handledPages, abstract_TreeNode thisNode) { // Since this is pre-order, first 'visit' this if (thisNode.Page) { Page_TreeNode pageNode = (Page_TreeNode) thisNode; if (!handledPages.Contains(pageNode)) { foreach (SobekCM_File_Info file in pageNode.Files) { returnValue.Add(file); } handledPages.Add(pageNode); } } // is this a division node? .. which can have children .. if (!thisNode.Page) { Division_TreeNode thisDivNode = (Division_TreeNode) thisNode; // Do the same for all the children foreach (abstract_TreeNode childNode in thisDivNode.Nodes) { recursively_build_all_files_list(returnValue, handledPages, childNode); } } }
/// <summary> Flag indicates if this active reader/writer needs to append schema reference information /// to the METS XML header by analyzing the contents of the division </summary> /// <param name="MetsDivision"> Division from the overall package into which to read the metadata</param> /// <returns> TRUE if the schema should be attached, otherwise fALSE </returns> public bool Schema_Reference_Required_Division(abstract_TreeNode MetsDivision) { // GEt the geo-spatial information if it exists GeoSpatial_Information geoInfo = MetsDivision.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY) as GeoSpatial_Information; if ((geoInfo == null) || (!geoInfo.hasData)) return false; return true; }
private void recursively_add_div_page_text( string source_directory, abstract_TreeNode thisNode, TextWriter Output_Stream, ref int page_count ) { if (thisNode.Page) { Page_TreeNode pageNode = (Page_TreeNode) thisNode; if (pageNode.Files.Count > 0) { string pageimage = String.Empty; string textfilename = pageNode.Files[0].File_Name_Sans_Extension + ".txt"; foreach (SobekCM_File_Info thisFile in pageNode.Files) { if (thisFile.File_Extension.ToLower() == "txt") textfilename = thisFile.System_Name; if ((thisFile.File_Extension.ToLower() == "jpg") && (thisFile.System_Name.ToLower().IndexOf("thm.jpg") < 0)) pageimage = thisFile.System_Name; } // Add the page break first Output_Stream.Write("<pb n=\"" + page_count + "\""); if ( pageimage.Length > 0 ) Output_Stream.Write(" facs=\"" + Convert_String_To_XML_Safe(pageimage) + "\""); Output_Stream.WriteLine(" />"); // Does the text file exist? string text_file = source_directory + "\\" + textfilename; try { if (System.IO.File.Exists(text_file)) { Output_Stream.WriteLine(Convert_String_To_XML_Safe(System.IO.File.ReadAllText(text_file))); } } catch { } } page_count++; } else { Division_TreeNode divNode = (Division_TreeNode) thisNode; if (thisNode.Type != "main") { Output_Stream.WriteLine("<div type=\"" + thisNode.Type + "\">"); if ((thisNode.Label.Length > 0) && (thisNode.Label != thisNode.Type)) { Output_Stream.WriteLine("<head>" + Convert_String_To_XML_Safe(thisNode.Label) + "</head>"); } } // Now, step through child nodes foreach (abstract_TreeNode childNode in divNode.Nodes) { recursively_add_div_page_text(source_directory, childNode, Output_Stream, ref page_count); } if (thisNode.Type != "main") { Output_Stream.WriteLine("</div>"); } } }
private void recurse_through_nodes(abstract_TreeNode Node, List<string> Extensions) { // Was this node a page? if (Node.Page) { // Cast back to the PAGE node Page_TreeNode pageNode = (Page_TreeNode)Node; // If no files, do not add this back if (pageNode.Files.Count == 0) return; // Add a filenode for each file foreach (SobekCM_File_Info thisFile in pageNode.Files) { string extension = thisFile.File_Extension.ToLower(); if (!Extensions.Contains(extension)) Extensions.Add(extension); } } else { // This was a division node Division_TreeNode divNode = (Division_TreeNode)Node; // Look for children nodes foreach (abstract_TreeNode childNode in divNode.Nodes) { // Visit each child node recurse_through_nodes(childNode, Extensions); } } }
private void recurse_through_nodes( SobekCM_Item thisPackage, abstract_TreeNode node, List<Page_TreeNode> pages_encountered ) { if (node.Page) { Page_TreeNode pageNode = (Page_TreeNode)node; if ( !pages_encountered.Contains( pageNode )) { pageseq++; // Add each of the files view codes to the list bool page_added = false; foreach (SobekCM_File_Info thisFile in pageNode.Files) { string upper_name = thisFile.System_Name.ToUpper(); if ((upper_name.IndexOf("SOUNDFILESONLY") < 0) && ( upper_name.IndexOf("FILMONLY") < 0 ) && ( upper_name.IndexOf("MULTIMEDIA") < 0 ) && ( upper_name.IndexOf("THM.JPG") < 0 )) { if (!page_added) { // Add this to the simple page collection thisPackage.Web.Add_Pages_By_Sequence(pageNode); pages_encountered.Add(pageNode); page_added = true; } View_Object thisViewer = thisFile.Get_Viewer(); if (thisViewer != null) { string[] codes = thisViewer.Viewer_Codes; if ((codes.Length > 0) && (codes[0].Length > 0)) { thisPackage.Web.Viewer_To_File[pageseq.ToString() + codes[0]] = thisFile; } } } } } } else { divseq++; Division_TreeNode divNode = (Division_TreeNode)node; foreach (abstract_TreeNode childNode in divNode.Nodes) { recurse_through_nodes(thisPackage, childNode, pages_encountered); } } }
private void preorder_build(List<abstract_TreeNode> Collection, abstract_TreeNode ThisNode, bool OnlyAddPages, bool PagesMustHaveFiles) { // Since this is pre-order, first 'visit' this if (!OnlyAddPages) { Collection.Add(ThisNode); } else { // If we are just getting pages, only add if it is not already added if ((ThisNode.Page) && (!Collection.Contains(ThisNode))) { // If you just add all files, just add it here if ( !PagesMustHaveFiles ) Collection.Add(ThisNode); else { // Must ensure this page has files to add it Page_TreeNode asPage = ThisNode as Page_TreeNode; if (asPage != null) { if (( asPage.Files != null ) && ( asPage.Files.Count > 0 )) Collection.Add(asPage); } } } } // is this a division node? .. which can have children .. if (!ThisNode.Page) { Division_TreeNode thisDivNode = (Division_TreeNode) ThisNode; // Do the same for all the children foreach (abstract_TreeNode childNode in thisDivNode.Nodes) { preorder_build(Collection, childNode, OnlyAddPages, PagesMustHaveFiles); } } }
private void preorder_build(List<abstract_TreeNode> collection, abstract_TreeNode thisNode, bool only_add_pages) { // Since this is pre-order, first 'visit' this if (!only_add_pages) { collection.Add(thisNode); } else { // If we are just getting pages, only add if it is not already added if ((thisNode.Page) && (!collection.Contains(thisNode))) collection.Add(thisNode); } // is this a division node? .. which can have children .. if (!thisNode.Page) { Division_TreeNode thisDivNode = (Division_TreeNode) thisNode; // Do the same for all the children foreach (abstract_TreeNode childNode in thisDivNode.Nodes) { preorder_build(collection, childNode, only_add_pages); } } }
private bool recursively_add_file(abstract_TreeNode Node, SobekCM_File_Info New_File, string SystemName_Upper) { // If this is a page, check for a match first if (Node.Page) { Page_TreeNode pageNode = (Page_TreeNode) Node; if (pageNode.Files.Count >= 1) { if (pageNode.Files[0].File_Name_Sans_Extension == SystemName_Upper) { // Belongs to this page. Now, just make sure it doesn't already exist foreach (SobekCM_File_Info thisFile in pageNode.Files) { if (thisFile.System_Name.ToUpper() == New_File.System_Name.ToUpper()) return true; } // Not found, so add it to this page pageNode.Files.Add(New_File); return true; } } } // If this was a division, check all pages if (!Node.Page) { Division_TreeNode divNode = (Division_TreeNode) Node; foreach (abstract_TreeNode childNodes in divNode.Nodes) { if (recursively_add_file(childNodes, New_File, SystemName_Upper)) { return true; } } } // If nothing found that matches under this node, return false return false; }
/// <summary> Writes the dmdSec for one subsection/division of the METS structure map </summary> /// <param name="Output_Stream">Stream to which the formatted text is written </param> /// <param name="MetsDivision">Division from the overall package with all the metadata to save</param> /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param> /// <returns>TRUE if successful, otherwise FALSE </returns> public bool Write_dmdSec(TextWriter Output_Stream, abstract_TreeNode MetsDivision, Dictionary<string, object> Options) { // GEt the geo-spatial information if it exists GeoSpatial_Information geoInfo = MetsDivision.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY) as GeoSpatial_Information; if ((geoInfo == null) || (!geoInfo.hasData)) return true; return Write_Metadata_Section(Output_Stream, geoInfo, Options); }
private bool recursively_check_for_any_files(abstract_TreeNode Node) { if (Node.Page) { if (((Page_TreeNode) Node).Files.Count > 0) return true; } if (!Node.Page) { Division_TreeNode divNode = (Division_TreeNode) Node; foreach (abstract_TreeNode TreeNode in divNode.Nodes) { if (recursively_check_for_any_files(TreeNode)) return true; } } return false; }
private bool recurse_through_nodes(abstract_TreeNode Node, List<BriefItem_FileGrouping> Groupings, List<BriefItem_TocElement> Toc, Stack<BriefItem_TocElement> CurrDivStack, int Level) { // Was this node a page? if (Node.Page) { // Cast back to the PAGE node Page_TreeNode pageNode = (Page_TreeNode) Node; // If no files, do not add this back if (pageNode.Files.Count == 0) return false; // Create the file grouping object for this BriefItem_FileGrouping newNode = new BriefItem_FileGrouping(pageNode.Label); // Add a filenode for each file foreach (SobekCM_File_Info thisFile in pageNode.Files) { BriefItem_File newFile = new BriefItem_File(thisFile.System_Name); if (thisFile.Width > 0) newFile.Width = thisFile.Width; if (thisFile.Height > 0) newFile.Height = thisFile.Height; newNode.Files.Add(newFile); } // Add this to the list of images Groupings.Add(newNode); // Since this was a page with files, return TRUE return true; } else { // Get what will be the sequence (if it turned out to have pages under it) int sequence = Groupings.Count + 1; // This was a division node Division_TreeNode divNode = (Division_TreeNode) Node; // Create the brief item TOC element BriefItem_TocElement divToc = new BriefItem_TocElement { Level = Level, Name = divNode.Label }; if (string.IsNullOrEmpty(divToc.Name)) divToc.Name = divNode.Type; // Add to the stack CurrDivStack.Push(divToc); // Look for children nodes bool some_files_under = false; foreach (abstract_TreeNode childNode in divNode.Nodes) { // Visit each child node if (recurse_through_nodes(childNode, Groupings, Toc, CurrDivStack, Level + 1)) some_files_under = true; } // Were there some files under here? if (some_files_under) { // Now, pop-up all the nodes in the queue and add them if (CurrDivStack.Count > 0) { IEnumerable<BriefItem_TocElement> reversed = CurrDivStack.Reverse(); foreach (BriefItem_TocElement revDiv in reversed) { revDiv.Sequence = sequence; Toc.Add(revDiv); } CurrDivStack.Clear(); } } else { // If this division (with NO pages under it apparently) is on the stack, // just pop it off if (( CurrDivStack.Count > 0 ) && (CurrDivStack.Peek() == divToc)) { CurrDivStack.Pop(); } } // Return whether there were any files under this return some_files_under; } }
/// <summary> Add a new child node under this tree node </summary> /// <param name="childNode"> New node to add </param> public void Add_Child(abstract_TreeNode childNode) { children.Add(childNode); }
private void recursively_add_page_names(abstract_TreeNode thisNode, string parentType, int Order, int Sibling_Count, List<abstract_TreeNode> visitedNodes) { if (thisNode.Page) { if (thisNode.Label.Length == 0) { if ((parentType.ToUpper().IndexOf("CHAPTER") < 0) && (parentType.ToUpper().IndexOf("SUB") != 0)) { if (Sibling_Count != 1) { thisNode.Label = parentType + " " + Order; } else { thisNode.Label = parentType; } } else { thisNode.Label = "Unnumbered ( " + total_order + " )"; } } // Move along the total order counter if (!visitedNodes.Contains(thisNode)) { total_order++; visitedNodes.Add(thisNode); } } else { Division_TreeNode divNode = (Division_TreeNode) thisNode; int new_order = 1; foreach (abstract_TreeNode subNode in divNode.Nodes) { recursively_add_page_names(subNode, divNode.Type, new_order++, divNode.Nodes.Count, visitedNodes); } } }
private void recursively_write_toc(StreamWriter Writer, abstract_TreeNode TreeNode, string Indent) { // Write this label, regardless of whether it is a page or a division (some page names have useful info) if ( TreeNode.Label.Length > 0 ) Writer.WriteLine(Indent + TreeNode.Label + "<br />"); else Writer.WriteLine(Indent + TreeNode.Type + "<br />"); // If not a page, recurse more if (!TreeNode.Page) { Division_TreeNode divNode = (Division_TreeNode)TreeNode; foreach (abstract_TreeNode childNode in divNode.Nodes) { recursively_write_toc(Writer, childNode, Indent + " "); } } }