#	------------------------------------------------------------
#   Copyright (c) 2012-2020
#	Q.W.Page Associates Inc.
#	www.qwpage.com
#	All rights reserved.
#	------------------------------------------------------------

::namespace eval ::qw::chtml {}
::itcl::class ::qw::chtml::compiler {
	protected variable _help ""; # The help structure that we are compiling into a binary .chm file.
	protected variable _directory ""; # Directory of target compiled binary .chm file.
	protected variable _name "";  # Name of target compiled binary .chm file.
	protected variable _paths ""; # List of paths to every html page in the source help structure.
	protected variable _ids; # Array of page ids indexed by page path.
	protected variable _bodies; # Array of formatted bodies indexed by page path.
	protected variable _working_directory "";
	protected variable _contents_name "contents.hhc";
	protected variable _index_name "index.hhk";
	protected variable _chtml_title "NewViews Help";
	protected variable _chtml_language "0x409 English (United States)";
	protected variable _project_handle "";
	protected variable _contents_handle "";
	protected variable _index_handle "";
	protected variable _topic_default "";
	protected variable _chtml_version "1.1";
	protected variable _formatter "";
	protected variable _generator "qw help generator";
	protected variable _sargs "";
	protected variable _command "";
#	protected variable _saved_current_directory "";
	method constructor {} {
		::array set _ids {};
		::array set _bodies {};
    }
	destructor {
		::if {$_formatter ne ""} {
			::itcl::delete object $_formatter;
			::set _formatter "";
        }
		close_files;
		working_directory_delete;
    }
	method working_directory_create {} {
		/* {
		Creates a temporary directory to work in when building the chm.

		Then we copy hhc.exe from the lib qw directory into the working directory.
        We do this so that hhc.exe can work on its files in its own directory.
        Although there are probably ways around this, it keeps things simple.

		2.26.0
		Keep working folder where is was but copy hhc.exe and hha.dll into the
        program folder on demand. Windows looks for exe's and dll's according to
        a pre-defined prority list of paths. The program folder is in the list
        and so is the working directory, but the working directory should never
        have been in the list.
        */ }
		::set _working_directory [::file normalize [::qw::fileutil::temporary_path .prefix "qwpage_" .suffix ".tmp"]];
		::file mkdir $_working_directory;
		# 2.26.0 copy files into program folder instead of system folder
		::set DstPath [::file join $::qw_program_folder hhc.exe];
		::if {![::file exists $DstPath]} {
            ::file copy -force [::file join $::qw_library lib qw hhc.exe] $DstPath;
        }
		::set DstPath [::file join $::qw_program_folder hha.dll];
		::if {![::file exists $DstPath]} {
            ::file copy -force [::file join $::qw_library lib qw hha.dll] $DstPath;
        }
    }
	method working_directory_delete {} {
		::if {$_working_directory eq ""} {
        	::return;
        }
		::qw::try {
        	::file delete -force -- _working_directory;
		} catch Exception {
			::qw::warning 314120031117084855 "Deleting chtml compiler working folder $_working_directory generated. Exception:\"$Exception\"";
        }
    }
	method process_pages {} {
		/* {
		We start by getting a list of paths to every page in the help structure.
        Each page has a unique id obtained from its .id field, or
        for now, if there is no .id, it is generated from the structure field id.
        */ }
		::set rwb1_debug 0;
#		::set _paths  [::sargs::select_field $_help .field ".title"];
/* {
		::foreach Path [::sargs::select_field .structure $_help .field ".title"] {
			::if {[::sargs::get $_help ${Path}.id] eq ""} {
				::qw::throw "Encountered help page $Path with empty .id field."
            }
        }
*/ }
		::foreach Path [::sargs::select_field .structure $_help .field ".id"] {
/* {
            ::if {[::lsearch -exact [::sargs::get $_help ${Path}.tags] tag_manual]<0&&[::lsearch -exact [::sargs::get $_help ${Path}.tags] tag_user]>=0} {
				::qw::throw "Encountered page $Path where tag_manual and tag_user are mismatched."
            }
            ::if {[::lsearch -exact [::sargs::get $_help ${Path}.tags] tag_manual]>=0&&[::lsearch -exact [::sargs::get $_help ${Path}.tags] tag_user]<0} {
				::qw::throw "Encountered page $Path where tag_manual and tag_user are mismatched."
            }
*/ }



/* {
			::set Tail [::lindex [::split $Path /] end];
			::if {$Tail ne ""} {
				::set Id [::sargs::get $_help ${Path}.id];
				::if {$Tail ne $Id} {
					::qw::throw "Encountered page $Path whose last path tail does not match .id \"$Id\".";
                }
            }
*/ }
/* {
			::if {[::sargs::get $_help ${Path}.title] eq ""} {
				::qw::throw "Encountered help page $Path with empty .title field."
            }
*/ }
/* {
			::if {[::sargs::get $_help ${Path}.tags] eq ""} {
				::qw::throw "Encountered help page $Path with empty .tags field."
            }
*/ }
        }
		::set Paths [::sargs::select_field .structure $_help .field .title];
		::foreach Path $Paths {
            /* {
            We select only those pages that are a hit.
            */ }
			::set PageTagList [::sargs::get $_help ${Path}.page_tag_list];
			::if {[::llength $PageTagList]!=0} {
				::if {[chtml_page_tags_hit [::sargs::get $_help ${Path}]]} {
					::lappend _paths $Path;
				}
			} else {
				/* {
				2.34.0
				Changed .tags to .page_tag_list but maintaining backward compatibility.
                */ }
				::set PageTagList [::sargs::get $_help ${Path}.tags];
				::if {[chtml_page_tags_hit [::sargs::get $_help ${Path}]]} {
					::lappend _paths $Path;
				}
			}
/* {
			::set Tags [::sargs::get $_help ${Path}.tags];
			if {[chtml_page_tags_hit .tags $Tags]} {
				::lappend _paths $Path;
			}
*/ }
        }
		::if {$rwb1_debug} {
            ::puts "root .title==[::sargs::get $_help .title]";
            ::puts "root .body==[::sargs::get $_help .body]";
            ::puts "root .id==[::sargs::get $_help .id]";
            ::puts "root .subs==[::sargs::subs .structure $_help]";
			::puts "paths=="
			::foreach Path $_paths {::puts "$Path"}
        }
		::if {$rwb1_debug} {
            ::set i 0;
            ::foreach Path $_paths {
                ::puts "rwb1_debug,2223.0,_paths\[$i\]==$Path";
                ::incr i;
            }
		}
        ::foreach Path $_paths {
#			::qw::warning "314120050324083416" "Encountered help page with no id,title==[::sargs::get $_help $Path.title]";
			::if {[::sargs::get $_help $Path.id] eq ""} {
                /* {
                Some pages forgot to set an .id so we set it from the last element
                in its path which should be unique id anyway.
                */ }
                ::sargs::var::set _help $Path.id [::lindex [::split $Path /] end];
            }
            ::sargs::var::set _help $Path.path $Path;
			::set Page [::sargs::get $_help $Path];
			::set PageId [::sargs::get $Page .id];
# don't see how this is consistent with anything
#			::if {[::info exists _ids($PageId)]} {::qw::throw "Encountered duplicate page id \"$PageId\".";}
			::if {$Path eq ""} {
				::set Path "root";
            }
            ::set _ids($Path) $PageId;
			::qw::try {
				::sargs::var::+= Page $_sargs;
				::set RenderedPage [$_formatter page_render $Page];
			} catch Exception {
				::qw::throw [::qw::exception::parent $Exception "Could not render the page identified by path \"$Path\"."];
            }
            ::set _bodies($Path) [::sargs::get $RenderedPage .body];
        }
		::foreach Path $_paths {
			::if {$Path eq ""} {
				::set Path "root";
            }
			::set Handle [::open [::file join $_working_directory $_ids($Path).htm] w+];
			::puts -nonewline $Handle $_bodies($Path);
			::close $Handle;
        }
    }
	method check_images {} {
		/* {
		Gets the list of used images and the list of all images in the help folder
        and determines which ones are never actually used. Write these to a sub-folder.
        */ }
		::return;
		::set UsedImages "";
        ::foreach {SrcPath DstName} [$_formatter images] {
			::lappend UsedImages [::string tolower [::file tail $SrcPath]];
        }
		::set Folder [::file join c:/ qw_manual_216];

		::set ImagesInDirectory "";
		::foreach Pattern {*.jpg *.gif *.png *.bmp} {
            ::foreach Path [::glob [::file join $Folder $Pattern]] {
                ::lappend ImagesInDirectory [::string tolower [::file tail $Path]];
            }
		}
		::set Result [::qw::intersect3 $UsedImages $ImagesInDirectory];
		::set ImagesUsedButNotFound [::lindex $Result 0];
		::set UnusedImages [::lindex $Result 2];
		::puts "Images used but not found:"
		::set Handle [::open [::file join $Folder images_used_but_not_found.txt] w+];
		::foreach Image $ImagesUsedButNotFound {
			::puts "$Image";
			::puts $Handle "$Image";
        }
		::close $Handle;
		::set OldFolder [::file join $Folder images_unreferenced];
		::file mkdir $OldFolder;
		::puts "Images found but not used:"
		::set Handle [::open [::file join $Folder images_unused.txt] w+];
		::foreach File $UnusedImages {
			::puts $Handle "$File";
			::set Name [::file tail $File];
			::puts "Moving and deleting $File";
            ::file copy -force [::file join $Folder $File] [::file join $OldFolder $Name];
			::file delete -force -- [::file join $Folder $File];
        }
/* {
		::foreach Image $UnusedImages {
			::puts $Handle "$Image";
			::set Name [::file tail $Image];
			::set Files [::glob -nocomplain [::file join $Folder [::file rootname $Image]].*];
			::foreach File $Files {
				::puts "Moving and deleting $File";
                ::file copy -force $File [::file join $OldFolder [::file tail $File]];
	        	::file delete -force -- File;
            }
        }
*/ }
	}
	method generate_css_file {} {
		# 2.31.0
        ::if {!$::qw::control(browser_help)} {
            /* {
            When browser_help is true we get the style from the qw web server. But
            when producing chm we need the css file available in the destination
            folder.
            */ }
			::file copy -force [::file join $::qw_program_path doc qw_style0.css] [::file join $_working_directory qw_style0.css];
        }
    }
	method generate_images {} {
		check_images;
		::qw::try {
			::foreach {SrcPath DstName} [$_formatter images] {
#				::puts "314120050408173235,Image,$SrcPath,$DstName";
				::qw::try {
					::set DstPath [::file join $_working_directory $DstName];
			        ::file copy -force $SrcPath $DstPath;
				} catch Exception {
					::qw::throw [::qw::exception::parent $Exception "Could not copy image file \"$SrcPath\" to \"$DstPath\"."];
                }
            }
        } catch Exception {
			::qw::throw [::qw::exception::parent $Exception "Could not generate the images."];
        }
    }
	method working_directory_cleanup {} {
		::if {![::file exists $_working_directory]} {return;}
#			::file delete -force -- $_working_directory;
		::set List "";
		::lappend List [::file join $_working_directory project.hhp];
		::lappend List [::file join $_working_directory $_contents_name];
		::lappend List [::file join $_working_directory $_index_name];
		::lappend List [::file join $_working_directory project.chm];
		::set List [concat $List [::glob -nocomplain $_working_directory/*.htm]]; #*/
		::eval ::file delete -force -- $List;
    }
	method project_options {} {
        ::puts $_project_handle "\[FILES\]";
		::foreach Path $_paths {
			::if {$Path eq ""} {
				::set Path "root";
            }
			::puts $_project_handle html\\$_ids($Path).htm;
        }
    }
	method generate_contents_node {Path} {
		::qw::try {
            ::set Node [::sargs::get $_help $Path];
            ::set Subs [::sargs::subs .structure $Node];
            ::if {![::sargs::exists $Node .title]} {
            	::qw::throw "Encountered a page with no .title field."
            }
			::set Title [::sargs::get $_help $Path.title];
			::set Title [$_formatter render [::sargs .body $Title]];



			::if {$Path ne ""} {



#                ::set _topic_default "$_ids().htm";



#                ::puts $_contents_handle "<LI> <OBJECT type=\"text/sitemap\">";
#                ::puts $_contents_handle "<param name=\"Name\" value=\"$Title\">";
#                ::puts $_contents_handle "<param name=\"Local\" value=\"$_ids($Path).htm\">";
#                ::puts $_contents_handle "<param name=\"ImageNumber\" value=\"2\">";
#                ::puts $_contents_handle "<UL>";
            }

#            ::puts "_topic_default,1,==$_topic_default"
			::if {$_command eq "error"} {
	            ::if {$Path eq ""} {
		            ::set _topic_default "/$_ids(root).htm";
				} else {
	        	    ::set _topic_default "/$_ids($Path).htm";
	            }
			} else {
		            ::set _topic_default "/$_ids(root).htm";
            }

#            ::set _topic_default "/[::sargs::get $_help .id].htm";
#            ::puts "_topic_default,2,==$_topic_default"
            ::puts $_contents_handle "<LI> <OBJECT type=\"text/sitemap\">";
			::puts $_contents_handle "<param name=\"Name\" value=\"$Title\">";
			::if {$Path eq ""} {
	            ::puts $_contents_handle "<param name=\"Local\" value=\"$_ids(root).htm\">";
			} else {
	            ::puts $_contents_handle "<param name=\"Local\" value=\"$_ids($Path).htm\">";
            }
#            ::puts $_contents_handle "<param name=\"Local\" value=\"$_ids(root).htm\">";
            ::if {[::llength $Subs]} {
                ::puts $_contents_handle "<param name=\"ImageNumber\" value=\"2\">";
            }
            ::puts $_contents_handle "</OBJECT>";
            ::if {[::llength $Subs]} {
                ::puts $_contents_handle "<UL>";
				::foreach Sub $Subs {
#tags
     				::if {[::info exists _ids($Path$Sub)]} {
	                	generate_contents_node "$Path$Sub";
					}
                }
                ::puts $_contents_handle "</UL>";
            }
            ::puts $_contents_handle "</LI>";
		} catch Exception {
			::set Id [::sargs::get $Node .id];
			if {$Id ne ""} {
				::qw::throw [::qw::exception::parent $Exception "Could not process contents for help page with path \"$Path\" and id \"$Id\"."];
			}
			::qw::throw [::qw::exception::parent $Exception "Could not process contents for help page \"$Path\"."];

        }
    }
	method generate_contents_file {} {
		::set ContentsPath [::file join $_working_directory $_contents_name];
        ::set _contents_handle [::open $ContentsPath w+];
		::puts $_contents_handle "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML//EN\">";
		::puts $_contents_handle "<HTML>";
		::puts $_contents_handle "<HEAD>";
		::puts $_contents_handle "<meta name=\"GENERATOR\" content=\"$_generator\">";
		::puts $_contents_handle "<!-- Sitemap 1.0 -->";
		::puts $_contents_handle "</HEAD>";
		::puts $_contents_handle "<BODY>";

		::puts $_contents_handle "<OBJECT type=\"text/site properties\">";
		::puts $_contents_handle "<param name=\"ImageType\" value=\"Folder\">";
		::puts $_contents_handle "</OBJECT>";
        ::puts $_contents_handle "<UL>";
        ::puts $_contents_handle "<LI>";
		generate_contents_node "";
        ::puts $_contents_handle "</LI>";
        ::puts $_contents_handle "</UL>";

		::puts $_contents_handle "</BODY>";
		::puts $_contents_handle "</HTML>";
    }
	method generate_index_file {} {
		::set IndexPath [::file join $_working_directory $_index_name];
        ::set _index_handle [::open $IndexPath w+];
		::puts $_index_handle "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML//EN\">";
		::puts $_index_handle "<HTML>";
		::puts $_index_handle "<HEAD>";
		::puts $_index_handle "<meta name=\"GENERATOR\" content=\"qwpage html help generator\">";
		::puts $_index_handle "<!-- Sitemap 1.0 -->";
		::puts $_index_handle "</HEAD>";
		::puts $_index_handle "<BODY>";

/* {
		::puts $_index_handle {
<UL>
	<LI> <OBJECT type="text/sitemap">
		<param name="Name" value="Command">
		<param name="Name" value="Untitled: c:\htmlhelptst\html\44.htm">
		<param name="Local" value="html\44.htm">
		<param name="Name" value="Untitled: c:\htmlhelptst\html\47.htm">
		<param name="Local" value="html\47.htm">
		<param name="Name" value="Untitled: c:\htmlhelptst\html\4b.htm">
		<param name="Local" value="html\4b.htm">
		</OBJECT>
</UL>
}
*/ }
		::puts $_index_handle "</BODY>";
		::puts $_index_handle "</HTML>";
    }
	method generate_project_file {} {
		::qw::try {
            ::set _project_handle [::open [::file join $_working_directory project.hhp] w+];
            ::set Title $_chtml_title;
#			::if {[::sargs::get $_sargs .title] ne ""} {
#				::append Title " - [::sargs::get $_sargs .title]";
#            }
            ::set AboutTitle "About $Title";
            ::puts $_project_handle "\[OPTIONS\]";
            ::puts $_project_handle "Compatibility=$_chtml_version";
            ::puts $_project_handle "Compiled file=project.chm";
            ::puts $_project_handle "Contents file=$_contents_name";
            ::puts $_project_handle "Default Window=Main";
            ::if {$_topic_default ne ""} {
# if no default topic we need the root page
				::puts $_project_handle "Default topic=$_topic_default";
            }
            ::puts $_project_handle "Display compile progress=Yes";
            ::puts $_project_handle "Full-text search=Yes";
            ::puts $_project_handle "Index file=$_index_name";
            ::puts $_project_handle "Language=$_chtml_language";
            ::puts $_project_handle "Title=$_chtml_title";
            ::puts $_project_handle "";

            ::puts $_project_handle "\[WINDOWS\]";
    #        ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$TopicDefault\",\"$TopicDefault\",\"html\\barc4tf7.htm\",\"FAQ\",\"html\\barc8apa.htm\",\"Copyright\",0x2520,,0xc307e,\[0,0,640,440\],,,,0,,,";
#            ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$_topic_default\",\"$_topic_default\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[0,0,640,440\],,,,0,,,";
			::set Type contents_and_search;

			/* {
			We are trying to get window sizes that are appropiate for different
            screen sizes. Cannot yet control the width of the left pane and the
            sizes I am using apparently apply to the right pane. Therefore I
            have a kludge on the width for now. What I need is the meaning of each
            argument in the "Main=". Maybe the other panes have different names
            and that is the only problem.
            */ }
			::set ScreenWidth [::expr {double([::winfo screenwidth .])}];
            ::set ScreenHeight [::expr {double([::winfo screenheight .])}];
			/* {
			::if {$ScreenWidth<1200} {
                ::set WindowWidth [::expr {round($ScreenWidth*0.75)}];
            } else {
                ::set WindowWidth [::expr {round($ScreenWidth*0.50)}];
            }
			::set WindowHeight [::expr {round($ScreenHeight*0.75)}];
			*/ }
			/* {
			2.21.1
            Went to the above hardwired screen size to accomodate video screen
            that is 640 pixels wide. This occurred when we added video tutorials
            to the help.
            */ }
			::set WindowX 50;
			::set WindowY 50;
			::set WindowWidth 1000;
			::set WindowHeight 800;
			::if {$WindowWidth+$WindowX>=$ScreenWidth} {
                ::set WindowWidth [::expr {round(($ScreenWidth-$WindowWidth)*0.75)}];
            }
			::if {$WindowHeight+$WindowY>=$ScreenHeight} {
                ::set WindowHeight [::expr {round(($ScreenHeight-$WindowY)*0.75)}];
            }
			::switch -- $Type {
				"" {
					::set _index_name "";
					::set _contents_name "";
                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$_topic_default\",\"$_topic_default\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[50,50,968,1024\],,,,0,,,";
				}

                three_pane {
                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$_topic_default\",\"$_topic_default\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[50,50,968,1024\],,,,0,,,";
                }
                test {
                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"\",\"\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[50,50,968,1024\],,,,0,,,";
                }
                contents_and_search {
					::set _index_name "";
#                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$_topic_default\",\"$_topic_default\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[50,50,968,1024\],,,,0,,,";
#                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$_topic_default\",\"$_topic_default\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[50,50,$WindowHeight,WindowWidth\],,,,0,,,";
#                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$_topic_default\",\"$_topic_default\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[50,50,WindowWidth,$WindowHeight\],,,,0,,,";


#                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$_topic_default\",\"$_topic_default\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[50,50,$WindowWidth,$WindowHeight\],,,,0,,,";
# change below adds a font button
                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$_topic_default\",\"$_topic_default\",\"\",\"\",\"\",\"\",0x2520,,0x10387E,\[$WindowX,$WindowY,$WindowWidth,$WindowHeight\],,,,0,,,";
                }
				topic_search {
		            ::puts $_project_handle "About=\"$AboutTitle ...\",,,,,,,,,0x100,,0x0,\[103,71,548,411\],,,,0,,,";
                }
				who_knows {
					::puts $_project_handle "msgWindow=\"$Title\",,,,,,,,,,,0x0,\[100,150,620,315\],0x400000,,,0,,,";
                }
				who_knows1 {
					::puts $_project_handle "msgWindow=\"$Title\",,,,,,,,,,,0x0,\[0,0,0,0\],0x400000,,,0,,,";
                }

			}
/* {
			::switch -- contents_and_search {
                three_pane {
                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$_topic_default\",\"$_topic_default\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[50,50,968,1024\],,,,0,,,";
                }
                test {
                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"\",\"\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[50,50,968,1024\],,,,0,,,";
                }
                contents_and_search {
					::set _index_name "";
                    ::puts $_project_handle "Main=\"$Title\",\"$_contents_name\",\"$_index_name\",\"$_topic_default\",\"$_topic_default\",\"\",\"\",\"\",\"\",0x2520,,0xc307e,\[50,50,968,1024\],,,,0,,,";
                }
				topic_search {
		            ::puts $_project_handle "About=\"$AboutTitle ...\",,,,,,,,,0x100,,0x0,\[103,71,548,411\],,,,0,,,";
                }
				who_knows {
					::puts $_project_handle "msgWindow=\"$Title\",,,,,,,,,,,0x0,\[100,150,620,315\],0x400000,,,0,,,";
                }

			}
*/ }


            ::puts $_project_handle "";

            ::puts $_project_handle "\[FILES\]";
            ::foreach Path $_paths {
				::if {$Path eq ""} {
					::set Path "root";
                }
                ::puts $_project_handle html\\$_ids($Path).htm;
            }
		} catch Exception {
			::qw::throw [::qw::exception::parent $Exception "Could not generate the chtml project file for $_working_directory."];
	    }
    }
	method close_files {} {
		::qw::try {
            ::if {$_project_handle ne ""} {
                ::close $_project_handle;
                ::set _project_handle "";
            }
            ::if {$_contents_handle ne ""} {
                ::close $_contents_handle;
                ::set _contents_handle "";
            }
            ::if {$_index_handle ne ""} {
                ::close $_index_handle;
                ::set _index_handle "";
            }
		} catch Exception {
			::qw::warning 314120031117084855 "Attempt to close chtml compiler files generated exception:\"$Exception\"";
        }
    }
	method generate_chtml_binary {} {
		/* {
		Executes hhc.exe to produce a binary .chm file. hhc.exe is the Microsoft
        html help compiler, which is also used internally by the html help workshop.
		The chm file is created in the working directory so if the target binary exists,
        it will not be clobbered if anything goes wrong. We copy the chm to the
        target in a separate step.

		We ensure that all hhc.exe source files are closed first just to be safe.

        We change the current directory to the working directory so that hhc.exe
        can find everything using nice relative paths. Then we restore the current
        directory.

		We have our own copy of hhc.exe in $::qw_library system.
        */ }
		close_files;
        ::set Pwd [::pwd];
        ::cd $_working_directory;
        ::qw::try {
#            ::exec [::file join $_working_directory hhc.exe] project.hhp;
            ::exec [::file join $::qw_program_folder hhc.exe] project.hhp;
        } catch Exception {
	        ::cd $Pwd;
			::qw::throw [::qw::exception::parent $Exception "Help compiler could not compile on \"[::file join $_working_directory project.ctm]\"."];
        }
        ::cd $Pwd;
    }
	method copy_chtml_to_target {} {
		# Just copies project.chm to the target.
		::set SrcPath [::file join $_working_directory project.chm];
		::if {![::file exists $SrcPath]} {
        	::qw::throw "Could not generate the html help .chm file.";
        }
		::set DstPath [::sargs::get $_sargs .destination];
		::if {$DstPath eq ""} {
			::set DstPath [::file join $_directory $_name.chm];
			::file mkdir $_directory;
		}
		::qw::try {
	        ::file copy -force -- $SrcPath $DstPath;
    	} catch Exception {
			::qw::throw [::qw::exception::parent $Exception "Could not copy \"$SrcPath\" to \"$DstPath\"."];
        }
		::return $DstPath;
	}
	method chtml_page_from_id {s_args} {
		/* {
		Added this for the formatter include method. The formatter must be able to
        load the page so that it can extract the body for the include.
        */ }
		::set Id [::sargs::get $s_args .id];
		::set Paths [::sargs::select_field_value .structure $_help .field .id .value $Id];
		::switch -- [::llength $Paths] {
			0 {
				::return "";
            }
			1 {
				::return [::sargs::get $_help [::lindex $Paths 0]];
            }
        }
		::qw::throw "Expected one page with id \"$Id\" but encountered \"$Paths\"";
    }
	method chtml_block_tags_hit {sargs} {
		/* {
        */ }
        ::set rwb1_debug 0;
        ::set MainTagList [::sargs::get $_sargs .block_tag_list];
        ::set BlockTagList [::sargs::get $sargs .block_tag_list];
		::if {$rwb1_debug} {::puts "rwb1_debug,chtml_block_tags_hit,1000.0,MainTagList==$MainTagList,BlockTagList==$BlockTagList";}
        ::if {[::llength $MainTagList]!=0} {
            #	------------------------------------------------------------
            #	Main .block_tag_list was specified so use it directly.
            #	------------------------------------------------------------
			::if {$rwb1_debug} {::puts "rwb1_debug,chtml_block_tags_hit,1000.1";}
            ::foreach Tag $BlockTagList {
                ::if {[::lsearch -exact $MainTagList $Tag]>=0} {
					::if {$rwb1_debug} {::puts "rwb1_debug,chtml_block_tags_hit,1000.2,Tag==$Tag";}
                    ::return 1;
                }
            }
            ::if {$rwb1_debug} {::puts "rwb1_debug,chtml_block_tags_hit,1000.3";}
            ::return 0;
        }
        ::set Command [::sargs::get $sargs .page_is_hit_command];
		::if {$rwb1_debug} {::puts "rwb1_debug,chtml_block_tags_hit,1000.4,Command==$Command";}
        ::if {$Command eq ""} {
            #	------------------------------------------------------------
            #	Neither .block_tag_list or .block_is_hit_command we specified.
            #	------------------------------------------------------------
            /* {
            Every block is a hit.
            */ }
            ::if {$rwb1_debug} {::puts "rwb1_debug,chtml_block_tags_hit,1000.5";}
            return 1;
        }
        #	------------------------------------------------------------
        #	.page_is_hit_command was specified so eval it.
        #	------------------------------------------------------------
		::if {$rwb1_debug} {::puts "rwb1_debug,chtml_block_tags_hit,1000.6";}
        ::set Result [::eval $Command [::sargs .block_tag_list $BlockTagList]];
        ::if {$rwb1_debug} {::puts "rwb1_debug,chtml_block_tags_hit,1000.7";}
        ::return $Result;
    }
	method chtml_page_tags_hit {sargs} {
		/* {
		The qw_chtml_compile caller provides a .page_is_hit script. This script is
        evaluated using ::subst and should return 0 or 1. If the script is empty
        then 1 is assumed. The help page is a structure passed to chtml_page_tags_hit
        as sargs and the callback script has access to sargs; which is the entire
        page structure. It usually examines .tags but it can examine anything
        in the page. We get the script from the original arguments passed to
        chtml_compile, which are stored in _sargs. Actually I believe the callback
        has access to _sargs as well.
        */ }
		::set PageCallback [::sargs::get $_sargs .page_is_hit];
		::if {$PageCallback eq ""} {
			return 1;
        }
#		::set Tags [::sargs::get $s_args .tags];
		::set Result [::subst $PageCallback];
		::return $Result;
    }
	method main {sargs} {
		/* {
        .name
        .directory

			This is the target for the binary .chm file that will be generated.
            A file with the specified name with extension .chm appended is placed
            in the specified directory only if everything succeeds. Note that the
            ultimate copy to this file can fail if for example the help system is
            currently running on an already existing target .chm file.

        .help

			This is the actual help structure. It must be gathered up using other
            tools before calling the compiler.


        The compiler takes a help structure and generates a .chm file, i.e. a Microsoft
        html help binary, for that structure. The target .chm file is placed in the specified
        directory and given the specified name.

        The compiler generates the source files needed by hhc.exe, the Microsoft chtml help
        compiler. hhc.exe works on files so we have to create a temporary directory which we
        call he project directory. Within the project directory we create:

            project.hhp		The html help project file.
            project.hhc		The htnl help contents file.
            project.hhk		The html help index file.
            project.chm		The html target binary.

        For each page we create a file whose name is the page id and whose extension
        is .htm. When we are done we copy the target .chm file to the specified directory
        and name and keep the extension .chm.

        For now we clean up the project directory at the beginning of a compile and
        leave it alone for debug purposes. Later we will clean up after the compile.

        For now, the project directory is hardwired to c:/htmlhelptst.

        The pages in the .ctm file can be specified using topics where a topic is
        the help page id followed by the extension .htm.

		returns the name of generated .chm file.
        */ }
		::qw::try {
/* {
	Kludge alert. We need to pass the sargs to the page so that it can get
    the sargs such as .odb.object, i.e. for about.qw_help. But our argument passing
    is not general enough in all of the formatter methods to supply a local sargs
    variable. So for now we are going to stick the value in a global.
*/ }
			::set _sargs $sargs;
			::sargs::var::set _sargs .chtml.compiler $this;
			::set _directory [::sargs::get $sargs .directory];
			::set _root_directory [::sargs::get $sargs .path];
			::set _name [::sargs::get $sargs .name];
			::set _help [::sargs::get $sargs .structure];
            ::set _formatter [::qw::html::formatter #auto .target chtml .root_directory $_root_directory .compiler $this];
			::set _command [::sargs::get $sargs .compiler.command];
			::if {[::sargs::get $sargs .window_title] ne ""} {
				::set _chtml_title [::sargs::get $sargs .window_title];
            }

            working_directory_create;
#            ::if {$_directory eq ""} {::qw::throw "Encountered an empty .directory argument.";}
#            ::if {$_name eq ""} {::qw::throw "Encountered an empty .name argument.";}
            ::if {$_directory eq ""} {
                ::set _directory [::file normalize [::qw::fileutil::temporary_path .prefix "qwpage_" .suffix ".tmp"]];
            }
            ::if {$_name eq ""} {
				::set _name [::file tail [::file normalize [::qw::fileutil::temporary_path .directory $_directory .prefix "qw_page_"]]];
            }
            ::if {$_help eq ""} {
            	::qw::throw "Encountered an empty .help argument.";
            }
#			generate_css_file; # 2.31.0
            process_pages;
            generate_contents_file;
            generate_index_file;
			generate_images;
            generate_project_file;
			generate_chtml_binary;
            ::set Result [copy_chtml_to_target];
            ::return $Result;
#            ::return [copy_chtml_to_target];
#			::return [::file join $_directory $_name.chm];
		} catch Exception {
			# The .structure is usually too big to put out as part of the error message.
			::if {[::sargs::exists $sargs .structure]} {::sargs::var::unset sargs .structure;}
			::qw::throw [::qw::exception::parent $Exception "$_generator encountered an error processing arguments \"$sargs\"."];
        }
    }
}


/* {
	In place.

	Creation has to be top down.

	Erase all indexes except odb_deriveds.index/id

	Cannot erase interactive indexes because they are information baring.

	In fact, at this point, we are only interested in the gatgun indexes.


	We traverse odb_deriveds.index/id.

	We import them.

	The exported file contains the same stuff 777 would contain.

	We run into things like inactive accounts and deal with them.

    Maybe we do not need anything like odb_change_before. It is all done at the
    qw_set/get level except for index record building.

    Audit trails have to go into the piece.

    It is almost as if we need a separate database class.




*/ }
/* {
		bin/freetype6.dll
		bin/jpeg.dll
		bin/libexpat.dll
        /lib/tcldot/pkgindex.tcl
        bin/png.dll
        /lib/tcldot/tcldot.dll
        bin/z.dll
        bin/zlib1.dll

*/ }