# Utilities2
# Gerald Banon, 1998, 1999

package provide dpi.inpe.br/banon/1998/08.02.08.56 2.1

# ----------------------------------------------------------------------
# DirectorySize
# Return the content size in bytes of a directory

proc DirectorySize {dir {size 0}} {
	set pwd [pwd]
	if [catch {cd $dir} err] {
		puts stderr $err
		return
	}
	set fileList [glob -nocomplain *]
	foreach file $fileList {
		set size [expr $size + [file size $file]]
		if [file isdirectory $file] {
			set size [DirectorySize [file join $dir $file] $size]
		}
	}
	cd $pwd
	return $size
}
		
# puts "[expr [DirectorySize c:/usuario/gerald/URLib] / 1024] Kbytes"

# DirectorySize - end
# ----------------------------------------------------------------------
# FindFile
# inspired from Example 9-11
# Finding a file by name.
# Return the the file path

proc FindFile {filePathName startDir fileName} {
	upvar $filePathName filePath
	if [file exists [file join $startDir $fileName]] {
		set filePath [file join $startDir $fileName]
		return -code return
	}
	foreach file [glob -nocomplain [file join $startDir *]] {
		if [file isdirectory $file] {
			FindFile filePath [file join $startDir $file] \
				$fileName
		}
	}
}

# set filePath ""
# FindFile filePath C:/ netscape.exe
# puts $filePath
# => C:/Program Files/Netscape/Communicator/Program/netscape.exe

# FindFile - end
# ----------------------------------------------------------------------
# DirectoryMTime
# Return the content modification time of a directory
# time is in seccond

proc DirectoryMTime {dir {time 0}} {
	set pwd [pwd]
	if [catch {cd $dir} err] {
		puts stderr $err
		return
	}
	set time [Max $time [file mtime $dir]]
	set fileList [glob -nocomplain *]
	foreach file $fileList {
		if [file isdirectory $file] {
			set time [DirectoryMTime [file join $dir $file] $time]
		} else {
			set time [Max $time [file mtime $file]]
		}
	}
	cd $pwd
	return $time
}
		
# DirectoryMTime - end
# ----------------------------------------------------------------------
# DirectoryContent
# build a list of all the files contained in a directory and its childs
# flag == 0 means no limit to the number of files

proc DirectoryContent {listName homePath dir {flag 0}} {
	upvar $listName list
	set fileList [glob -nocomplain $dir/*]
	foreach file $fileList {
		if [file isdirectory $file] {
			DirectoryContent list $homePath $file $flag
		} else {
			regsub $homePath/ $file {} file
			if {$flag && [llength $list] > 200} {
				return -code return
			}				
			lappend list $file
		}
	}
}

#proc DirectoryContent {homePath dir {flag 0} {fileNameList {}}} {
#	set fileList [glob -nocomplain $dir/*]
#	foreach file $fileList {
#		if [file isdirectory $file] {
#			set fileNameList [DirectoryContent $homePath\
#				$file $flag $fileNameList]
#		} else {
#			regsub $homePath/ $file {} file
#			if {$flag && [llength $fileNameList] > 200} {
#				return -code return
#			}				
#			lappend fileNameList $file
#		}
#	}
#	return $fileNameList
#}

# set fileList ""		
# DirectoryContent fileList c:/tmp/doc2 c:/tmp/doc2
# puts $fileList

# DirectoryContent - end
# ----------------------------------------------------------------------
# DirectoryNewer
# Return 1 if the directory content is newer than the referenceTime
# content

proc DirectoryNewer {dir referenceTime} {
	set pwd [pwd]
	if [catch {cd $dir} err] {
		puts stderr $err
		return
	}
	set mtime [clock format [file mtime $dir] \
		-format %Y:%m.%d.%H.%M.%S]
	if {[string compare $mtime $referenceTime] > 0} {
		cd $pwd
		return 1
	}	
	set fileList [glob -nocomplain *]
	foreach file $fileList {
		if [file isdirectory $file] {
			if [DirectoryNewer [file join $dir $file] \
				$referenceTime] {
				cd $pwd
				return 1
			}
		} else {
			set mtime [clock format [file mtime $file] \
				-format %Y:%m.%d.%H.%M.%S]
			if {[string compare $mtime $referenceTime] > 0} {
				cd $pwd
				return 1
			}
		}	
	}
	cd $pwd
	return 0
}

# puts [clock format [clock seconds] -format %Y:%m.%d.%H.%M.%S]
# puts [DirectoryNewer \
c:/usuario/gerald/URLib/col/dpi.inpe.br/banon/1998/08.02.08.56 \
1999:01.28.16.44.39] 

# DirectoryNewer - end
# ----------------------------------------------------------------------
# Warning

proc Warning {program string {var1 {}} {var2 {}}} {
	upvar #0 {Text::URLib Service} title
	toplevel .warning -borderwidth 10
	wm title .warning $title
	wm resizable .warning 1 0
	set bg [.warning cget -bg]
	set t [text .warning.text -wrap word -fg black \
		-relief flat -bg $bg]
	set font [lindex [lindex [$t configure -font] end] 0]
	$t configure -font {$font 10}
	pack $t -fill x	;# now -tabs is working properly
# insert dialog
	eval [list ${program}ExtraDialog $t $string $var1 $var2]
	ComputeGeometry .warning $t 1c .8c
	return .warning
}

# Warning - end
# ----------------------------------------------------------------------
# ProcessKeyForDialog

proc ProcessKeyForDialog {button underline key} {
	global returnDialog
	set ib [llength $button]	;# number of buttons
	incr ib -1
	set button0 [lindex $button 0] 
	upvar #0 Text::$button0 textButton0 
	set underline0 [lindex $underline 0] 
	if {$underline0 >= 0} {
		set letter [string index $textButton0 $underline0]
		if [regexp -nocase $letter $key] {
			set returnDialog 0
			return
		}
	}
	if $ib {
		set button1 [lindex $button 1] 
		upvar #0 Text::$button1 textButton1 
		set underline1 [lindex $underline 1] 
		if {$underline1 >= 0} {
			set letter [string index $textButton1 $underline1]
			if [regexp -nocase $letter $key] {
				set returnDialog 1
				return
			}
		}
	}
}

# ProcessKeyForDialog - end
# ----------------------------------------------------------------------
# DisplayText
# example:
# $entryName == spPreference or ddDirectory
# $varName == dd(result1)
# $w == .ddhelp or .xxdirectory
# $bg == #ffffcc
# create is 0 or 1; 0 means don't create widget
# (just update if it exists) - used by the SetBackGround procedure,
# 1 means create
# fill is 0 or 1; 0 means don't fill widget
# (just create it if it doesn't exist and create == 1) - used by the
# PerformCheck procedure (the fill will happen later through the
# call to the CompleteEntry procedure),
# 1 means fill
# fileList is used in the XXRepository procedure

proc DisplayText {entryWidget entryName varName w bg \
	{create {1}} {fill {1}}} {
	if [winfo exists $w] {
		wm deiconify $w
		$w.f.t configure -state normal
		$w.f.t delete 1.0 end
	} else {
		if !$create {return}
		toplevel $w
		set W [winfo width .window]
		set H [winfo height .window]
		wm geometry $w 421x$H+[expr $W + 7]+0
		if [regexp {help} $w] {set word Help}
		if {$w == ".xxdirectory"} {set word Check}
		if {$w == ".xxrepository"} {set word Check}
		upvar #0 "Text::URLib Service - $word" varText
		wm title $w $varText
		if [regexp {help} $w] {
			set word word
		} else {
			set word none
		}
		ScrolledText $w.f -wrap $word \
			-bg $bg -fg black -cursor double_arrow \
			-relief raised -borderwidth 2 -padx .2c -pady .2c
# Buttons
		frame $w.sp -height .04c ;# extra space
		set width 2.2
		set height .6
		set b [frame $w.button -width 5c -height .6c]
# Close Button
		set bclose [frame $b.close -width [format "%sc" $width] \
			-height [format "%sc" $height]]
		button $bclose.close -command "destroy $w" -cursor hand2
		ConfigText $bclose.close Close
# Close Button - end
# Reload Button
		set breload [frame $b.reload -width [format "%sc" $width] \
			-height [format "%sc" $height]]
		button $breload.reload \
			-command "PerformCheck $entryWidget $entryName \
				$varName" \
			-cursor hand2
		ConfigText $breload.reload Reload
# Reload Button - end
# Buttons - end
		pack propagate $b false
		pack propagate $bclose false
		pack propagate $breload false
		if [regexp help $w] {
			pack $bclose -side top
		} else {
			pack $bclose -side left
			pack $breload -side right
		}
		pack $bclose.close -fill both
		pack $breload.reload -fill both
		pack $w.f -side top -fill y -expand true
		pack $w.sp -side top	;# extra space
		pack $b -side bottom -pady .2c
		regexp ... $entryWidget win	;# .dd
		bind $w <1> "ProcessButton1 $win"
	}
# Fill Text
	if !$fill {return}
	regexp {.(...)(.*)} $w m first last
	set programName [string toupper $first]$last
	$programName $varName	;# DDHelp or XXDirectory or ...
# Fill Text - end
	raise $w
}

proc ScrolledText {f args} {
	frame $f -borderwidth 2 -relief groove
	eval {text $f.t \
		-xscrollcommand [list $f.xscroll set] \
		-yscrollcommand [list $f.yscroll set]} $args
	scrollbar $f.xscroll -orient horizontal \
		-command [list $f.t xview]
	scrollbar $f.yscroll -orient vertical \
		-command [list $f.t yview]
	grid $f.t $f.yscroll -sticky news
	if ![regexp {help} $f] {grid $f.xscroll -sticky news}
	grid rowconfigure $f 0 -weight 1
	grid columnconfigure $f 0 -weight 1
}

# DisplayText - end
# ----------------------------------------------------------------------
# Selector

proc Selector {parent entryName varName index \
	{listName {}} {flag {1}}} {
# example:
# set aMail [Selector $f.ent sp 1 environmentArray(spEMailAddressList)]
# flag == 1 <==> pack the check button
# flag == 0 <==> doesn't pack the check button
	global environmentArray
	global typeTable
	upvar #0 $entryName xxEntry
	set type $typeTable($xxEntry)
	regexp {\.[^.]*\.[^.]*} $parent parentLabel	;# .dd.dir
	set side .6c	;# button size
	set side2 1.15c
	set a [frame $parent.entry -borderwidth 2 -bg gray \
		-relief sunken -height $side]
	frame $a.button1 -width $side -height $side
	frame $a.button2 -width $side -height $side
	frame $a.button3 -width $side -height $side
	frame $a.button4 -width $side -height $side
	frame $a.button5 -width $side -height $side
	frame $a.button6 -width $side -height $side
	button $a.button1.1 -text < \
		-font {-family courier -size 11 -weight normal} \
		-cursor hand2
	menubutton $a.button2.2 -text > \
		-font {-family courier -size 11 -weight normal} \
		-cursor hand2 -relief raised -menu $a.button2.2.menu
	menubutton $a.button3.3 \
		-font {-size 9 -weight normal} \
		-cursor hand2 -relief raised -menu $a.button3.3.menu
	ConfigText $a.button3.3 S
	button $a.button4.4 -cursor hand2 \
		-font {-size 9 -weight normal}
#		-font {times 9 roman}
	if [regexp {\.ent\.} $type] {
		ConfigText $a.button4.4 Remove
	} else {
		ConfigText $a.button4.4 C
	}
	button $a.button5.5 -cursor hand2 \
		-font {-size 9 -weight normal}
	button $a.button6.6 -cursor hand2 \
		-font {-size 9 -weight normal}
	if [regexp {\.rep\.} $type] {
		set bg [. cget -bg]
		set nc [NewColor . $bg]
		ConfigText $a.button5.5 Reverse
#		upvar #0 ${varName}Reverse$index reverse
		upvar #0 ${varName}Reverse reverse
		if $reverse {
# repository first
			$a.button5.5 configure -bg $nc
			$a.button6.6 configure -state disabled
		} else {
# key first
			$a.button5.5 configure -bg $bg
		}
		ConfigText $a.button6.6 Search
		upvar #0 ${varName}Search search
		if $search {
			$a.button6.6 configure -bg $nc
		} else {
			$a.button6.6 configure -bg $bg
		}
	}
	entry $a.entry -textvariable ${varName}(result$index) \
		-relief flat \
		-font {courier 9 roman}
# SET THE ENTRY
	SetEntry $a ${xxEntry}Entry $varName result$index
# SET THE ENTRY - end
# close the window entry
	if [regexp {\.dir\.|\.rep\.} $parent] {
		upvar #0 ${varName}Choice$index choice
		if ![regexp {^dir|^rep} $choice] {
			DisableEntry $a ${varName}(result$index)
		}
	}
# close the window entry - end
	menu $a.button2.2.menu -tearoff 0 \
		-font {courier 9 roman}
	menu $a.button3.3.menu -tearoff 0 \
		-font {courier 9 roman}
#	$a.button1.1 configure \
		-command "ReduceEntry $a $entryName \
			${varName}(result$index) {$listName}"
	$a.button1.1 configure \
		-command "ReduceEntry $a $entryName \
			${varName}(result$index)"
	if [regexp {\.ent\.} $type] {
		$a.button4.4 configure \
			-command "RemoveEntry $a $entryName \
				${varName}(result$index)"
	} else {
		$a.button4.4 configure -command "PerformCheck $a.entry \
				$entryName ${varName}(result$index)"
	}
	$a.button5.5 configure \
		-command "ReverseEntry $a $entryName $varName $index"
	$a.button6.6 configure \
		-command "SearchEntry $a $entryName $varName $index"
	pack propagate $a false
	pack $a.button1 -side left
	pack propagate $a.button1 false
	pack $a.button3 -side left
	pack propagate $a.button3 false
	pack $a.button2 -side left
	pack propagate $a.button2 false
	pack $a.entry -side left
	if $flag {
		pack $a.button4 -side right
		pack propagate $a.button4 false
	}
	if [regexp {\.rep\.} $type] {
		pack $a.button5 -side right
		pack $a.button6 -side right
		pack propagate $a.button5 false
		pack propagate $a.button6 false
	}
	pack $a.button1.1 -fill both
	pack $a.button2.2 -fill both
	pack $a.entry -fill both -expand true
	pack $a.button3.3 -fill both
	pack $a.button4.4 -fill both
	pack $a.button5.5 -fill both
	pack $a.button6.6 -fill both
	pack $a -side bottom -fill x -pady .2c
#	bind $a.entry <Key> \
		"CompleteEntry %W $entryName ${varName}(result$index) \
			{$listName} %A; break"
	bind $a.entry <Key> \
		"CompleteEntry %W $entryName ${varName}(result$index) \
			%A; break"
	bindtags $a.entry [list Entry $a.entry all]
	label $parentLabel.lb1 -bg #ffffcc -relief solid -borderwidth 1
	ConfigText $parentLabel.lb1 " Backward "
	label $parentLabel.lb2 -bg #ffffcc -relief solid -borderwidth 1
	ConfigText $parentLabel.lb2 " Forward "
	label $parentLabel.lb3 -bg #ffffcc -relief solid -borderwidth 1
	ConfigText $parentLabel.lb3 \
		" Select One of The More Recent Entries "
	label $parentLabel.lb4 -bg #ffffcc -relief solid -borderwidth 1
	if [regexp {\.ent\.} $type] {
		ConfigText $parentLabel.lb4 " Remove the Current Entry "
	} else {
		ConfigText $parentLabel.lb4 " Check "
	}
	label $parentLabel.lb5 -bg #ffffcc -relief solid -borderwidth 1
	ConfigText $parentLabel.lb5 \
		" Reverse "
	label $parentLabel.lb6 -bg #ffffcc -relief solid -borderwidth 1
	ConfigText $parentLabel.lb6 \
		" Search "
	bind $a.button1 <Enter> \
		"DisplayMessage $parentLabel.lb1 $a nw 0 1 0 3"
	bind $a.button1 <Leave> "DeleteMessage"
	bind $a.button1.1 <Button> "DeleteMessage"
#	bind $a.button1.1 <Double-1> "ReduceEntry $a $entryName \
		${varName}(result$index) {$listName} 1"
	bind $a.button1.1 <Double-1> "ReduceEntry $a $entryName \
		${varName}(result$index) 1"
	bind $a.button2 <Enter> \
		"DisplayMessage $parentLabel.lb2 $a nw 0 1 $side2 3"
	bind $a.button2 <Leave> "DeleteMessage"
#	bind $a.button2.2 <Button> "DeleteMessage"
	bind $a.button3 <Enter> \
		"DisplayMessage $parentLabel.lb3 $a nw 0 1 $side 3"
	bind $a.button3 <Leave> "DeleteMessage"
#	bind $a.button3.3 <Button> "DeleteMessage"
	bind $a.button3.3 <Button> "CancelSearch $a $entryName \
		${varName}(result$index)"
	bind $a.button4 <Enter> \
		"DisplayMessage $parentLabel.lb4 $a ne 1 1 0 3"
	bind $a.button4 <Leave> "DeleteMessage"
	bind $a.button4.4 <Button> "DeleteMessage"
	bind $a.button5 <Enter> \
		"DisplayMessage $parentLabel.lb5 $a ne 1 1 -$side 3"
	bind $a.button5 <Leave> "DeleteMessage"
	bind $a.button5.5 <Button> "DeleteMessage"
	bind $a.button6 <Enter> \
		"DisplayMessage $parentLabel.lb6 $a ne 1 1 -$side2 3"
	bind $a.button6 <Leave> "DeleteMessage"
	bind $a.button6.6 <Button> "DeleteMessage"
	regexp {\.([^.]*\.[^.]*)} $a m prefix	;# dd.dir
	bind $a.button1.1 <ButtonRelease-1> \
		"CallFocus $a; SetPostMenu ${prefix}PostMenu"
	bind $a.button2.2 <ButtonPress-1> "CallFocus $a"
	bind $a.button2.2 <ButtonRelease-1> \
		"SetPostMenu ${prefix}PostMenu"
	bind $a.button3.3 <ButtonRelease-1> "CallFocus $a"
	bind $a.button4.4 <ButtonRelease-1> "CallFocus $a"
# puts [bindtags $a.button2.2]
# => $a.button2.2 Menubutton .dd all
# we need to change the order otherwise dd.dirPostMenu is set to
# 0 after to be set to 1
	regexp ... $a win	;# .dd
	bindtags $a.button2.2 [list $win Menubutton $a.button2.2 all]
	return $a
}

proc SetPostMenu {varName} {
	upvar #0 $varName var
	set var 1
}

# Selector - end
# ----------------------------------------------------------------------
# PerformCheck

proc PerformCheck {entryWidget entryName varName} {
	global repositoryProperties
	global environmentArray
	global homePath
#	global numberOfRep
	global keyRepositoryList
	global homePath
	global col
	global referenceTable
	global loCoInRep
	global metadataArray
	global repArray
	global saveMetadata
	global searchRepository
	global commonWords
	global URLibServiceRepository
	upvar #0 $varName var
#	set fileList {}
	switch -regexp -- $entryWidget \
		\.dir\. {
			if [regexp {/$} $var] {
				DisplayText $entryWidget $entryName \
					$varName .xxdirectory #dddddd
			}
		} \
		\.rep\. {
			if ![regexp { } $var] {return}
# rep
			if ![regexp {^(.*/.*/.*/.*) .*} $var m rep] {
				regexp {^.* (.*/.*/.*/.*)} $var m rep
			}
			if ![info exists rep] {return}
			regexp {.(..)} $entryWidget win xx	;# .dd dd
			upvar #0 ${xx}SearchEntry xxSearchEntry
			set nOR [llength $keyRepositoryList]
			if [file isdirectory $homePath/col/$rep] {
# the metadata for rep may have been deleted or added, so the
# keyRepositoryList must be updated
				UpdateKeyRepositoryList $rep
#				AddItem metadataRepList [FindMetadataRep $rep]
				set numberOfRep [llength $keyRepositoryList]
				if {$nOR != "$numberOfRep"} {
					set environmentArray(${xx}SearchEntry) {}
					set xxSearchEntry {}
				}
				SetIndicator $win $numberOfRep
			} else {
# the repository doesn't exist
				UpdateVariables $rep
				set numberOfRep [llength $keyRepositoryList]
				if {$nOR != "$numberOfRep"} {
					set environmentArray(${xx}SearchEntry) {}
					set xxSearchEntry {}
				}
				SetIndicator $win $numberOfRep
				CompleteEntry $entryWidget $entryName \
					$varName check
				return
			}
# Test and update data for new repository content
# referenceTime
			if [info exists \
				repositoryProperties($rep,history)] {
				set referenceTime [lindex [lindex \
					$repositoryProperties($rep,history) \
					end] 0]
			} else {
				set referenceTime \
					[clock format 0 -format %Y:%m.%d.%H.%M.%S]
			}
# Update history
			if [DirectoryNewer $homePath/col/$rep/doc \
				$referenceTime] {
# Start apache server
				if ![info exists \
					repositoryProperties($rep,history)] {
					set repositoryProperties($rep,history) {}
					StartApacheServer
				}
# Start apache server - end
# CREATE A NEW VERSION STAMP
				set versionStamp [CreateVersionStamp \
					[clock seconds]]
				UpdateHistory $rep $versionStamp	
# Update last update fields in the metadata
# >>>>
set metadataRep [FindMetadataRep $rep]
if {$metadataRep != ""} {
# a metadata exists for this rep
	set metadata2List [array get metadataArray $metadataRep-0,*lastupdate]
	set metadataArray($metadataRep-0,lastupdate) $versionStamp
	set metadataArray($metadataRep-0,metadatalastupdate) $versionStamp
	UpdateHistory $metadataRep $versionStamp
# remove
	${searchRepository}::CreateRepArray $metadata2List $commonWords 1
# add
	set metadataList [array get metadataArray $metadataRep-0,*lastupdate]
	${searchRepository}::CreateRepArray $metadataList $commonWords
	set saveMetadata 1
}
# Update last update fields in the metadata - end
# Update metadataArray and repArray in the case of a
# @reference.bib file
if {[info exists repositoryProperties($rep,targetfile)] && \
	$repositoryProperties($rep,targetfile) == "@reference.bib"} {
# remove
	if [file exists $col/$rep/auxdoc/@reference2.tcl] {
		source $col/$rep/auxdoc/@reference2.tcl	;# metadata2List
		if [info exists metadata2] {unset metadata2}
		array set metadata2 $metadata2List
		foreach i [array names metadata2] {
			if [info exists metadataArray($i)] {
				unset metadataArray($i)
			}
		}
		${searchRepository}::CreateRepArray $metadata2List \
			$commonWords 1
	}
# add
	LoadBibTeX $rep metadataList
# SAVE
	set saveMetadata 1
# SAVE - end
}
# Update metadataArray and repArray in the case of a
# @reference.bib file - end
# <<<<
			}
# Update history - end
# SAVE
			StoreArray repositoryProperties \
				../auxdoc/.repositoryProperties.tcl
# SAVE - end
# update references
			UpdateReferenceTable $rep
# SAVE
			StoreArray referenceTable ../auxdoc/.referenceTable.tcl
# SAVE - end
# update references - end
# Test and update data for new repository content - end
# Get clipboard
			catch {selection get -selection CLIPBOARD} clipboard
			if [regexp {^%0 } $clipboard] {
# >>>>
# Load data from the clipboard and update metadataArray and repArray
# set metadataList [LoadMetadata 0 $clipboard {} 1 $varName]
set metadataList [LoadMetadata 0 $clipboard {} 1]
array set metadataImport $metadataList
set indices [array names metadataImport *-0,referencetype]
#set indices [array names metadataImport *-0,*,%0]
foreach index $indices {
# remove
	regexp {^(.*)-0} $index m metadataRep
	if [file exists $col/$metadataRep/auxdoc/@metadata2.refer] {
		Load $col/$metadataRep/auxdoc/@metadata2.refer entry2
		set metadata2List [LoadMetadata 0 $entry2 $metadataRep]
		if [info exists metadata2] {unset metadata2}
		array set metadata2 $metadata2List
		foreach i [array names metadata2] {
			if [info exists metadataArray($i)] {
				unset metadataArray($i)
			}
		}
		${searchRepository}::CreateRepArray $metadata2List \
			$commonWords 1
		file delete $col/$metadataRep/auxdoc/@metadata2.refer
	}
}
# add
array set metadataArray $metadataList
${searchRepository}::CreateRepArray $metadataList $commonWords
# SAVE
set saveMetadata 1
# SAVE - end
# Load data from the clipboard and update metadataArray and repArray - end
# Update entry
regsub {(..).*} $varName {\1Reverse} reverseName	;# ddReverse
upvar #0 $reverseName reverse
if !$reverse {
# key first
	set var [AddKey $rep/ 0]
}
# repository first is updated by CompleteEntry below
# Update entry - end
# Put clipboard
if {[llength $indices] == 1} {
	regexp {^(.*)-0} [join $indices] m metadataRep
	clipboard clear
	clipboard append $metadataRep
}
# Put clipboard - end
# Load data from the clipboard and update metadataArray and repArray - end
# <<<<
			} else {
# no metadata to load
# put clipboard
				clipboard clear
				clipboard append $rep
# put clipboard - end
			}
# Get clipboard - end
			DisplayText $entryWidget $entryName $varName \
				.xxrepository #dddddd 1 0
# SAVE
			SaveMetadata
# SAVE - end
		}
#	CompleteEntry $entryWidget $entryName $varName check $fileList
	CompleteEntry $entryWidget $entryName $varName check
# CompleteEntry calls UpdateEntry
# UpdateEntry calls SetBackgroundEntry
# SetBackgroundEntry calls DisplayText
}

# PerformCheck - end
# ----------------------------------------------------------------------
# UpdateHistory

proc UpdateHistory {rep versionStamp} {
	global col
	global repositoryProperties	
	lappend repositoryProperties($rep,history) $versionStamp
	set numberOfVersions [llength \
		$repositoryProperties($rep,history)]
	if {$numberOfVersions > 5} {
		set repositoryProperties($rep,history) \
			[lreplace $repositoryProperties($rep,history) 0 0]
	}
	Store repositoryProperties($rep,history) \
		$col/$rep/service/history
}

# UpdateHistory - end
# ----------------------------------------------------------------------
# UpdateReferenceTable
# update references
# service/reference is a fileName for a file containing the names
# (starting from doc) like xxx.tcl
# of files in doc that contain relative links to other repositories

proc UpdateReferenceTable {rep} {
	global referenceTable
	global homePath
	global col
# the references may be old and must be discarded
	DiscardRepository $rep referenceTable
	if [file exists $homePath/col/$rep/service/reference] {
		set fileList {}
		Load $homePath/col/$rep/service/reference reference
		set reference [string trim $reference \n]
		if [regexp {^$} $reference] {
# empty reference - get all the files below doc
			set dir $homePath/col/$rep/doc
			DirectoryContent fileList $dir $dir
		} else {
		foreach line [split $reference \n] {
# >>>
	if [regexp {^../} $line] {
# called repository in the reference file
		if [regexp \
"../$col/col/(\[^/\]*/\[^/\]*/\[^/\]*/\[^/ \]*)" $line m calledRep] {
			set referenceTable($rep,$calledRep) 1
		}
	} else {
# the line contains the name of a file to be searched
		lappend fileList $line
	}
# <<<
			}
		}
		foreach file $fileList {
			if [catch {open \
				$col/$rep/doc/$file r} fileId] {
				puts stderr $fileId
			} else {
				set fileContent [read $fileId]
				foreach line [split $fileContent \n] {
					if [regexp \
"../$col/col/(\[^/\]*/\[^/\]*/\[^/\]*/\[^/ \]*)" $line m calledRep] {
						set \
referenceTable($rep,$calledRep) 1
					}
				}
				close $fileId
			}
		}
	}
}

# UpdateReferenceTable - end
# ----------------------------------------------------------------------
# EnableCheckText
# Enable check text

#proc EnableCheckText {entryWidget} {
#	switch -regexp -- $entryWidget \
#		\.dir\. {
#			regexp {\.[^.]*} $entryWidget win	;# .dd
#			if {[winfo exists .xxdirectory] &&
#				[winfo ismapped .xxdirectory]} {
#				wm withdraw .xxdirectory
#				set bg [. cget -bg]
#				$win.dir.h1.h2.v2.entry.button4.4 \
#					configure -bg $bg
#			}
#		} \
#		\.rep\. {
#		}
#}

# EnableCheckText - end
# ----------------------------------------------------------------------
# CallFocus

proc CallFocus {widget} {
	upvar focus focus
	regexp {\.[^.]*} $widget win	;# .dd
	set focus [focus -displayof $win]
	focus $widget.entry
}

# CallFocus - end
# ----------------------------------------------------------------------
# DisplayMessage

proc DisplayMessage {message win {anchor {nw}} \
	{relx {0}} {rely {0}} {x {0}} {y {0}}} {
	global displayMessageId1 displayMessageId2 displayMessage
	set displayMessage $message
#	set win [join [lreplace [split $message .] end end] .]
	set displayMessageId1 [after 1000 place $message -in $win \
		-anchor $anchor -relx $relx -rely $rely -x $x -y $y]
	set displayMessageId2 [after 5000 place forget $message]
	regexp ... $win top	;# .dd
#	raise $top
}

# DisplayMessage - end
# ----------------------------------------------------------------------
# DeleteMessage

proc DeleteMessage {} {
	global displayMessageId1 displayMessageId2 displayMessage
	after cancel $displayMessageId1
	after cancel $displayMessageId2
	place forget $displayMessage
}

# DeleteMessage - end
# ----------------------------------------------------------------------
# DisableEntry

proc DisableEntry {widget varName} {
	global environmentArray
#	upvar #0 $varName var	;# dd(resultx)
	upvar focus focus
	if {[info exists focus] && \
		$focus != "$widget.entry"} {focus $focus}
	$widget.entry config -bg gray -fg gray -state disabled
	$widget.button1.1 configure -state disabled
	$widget.button2.2 configure -state disabled
	$widget.button3.3 configure -state disabled
	$widget.button4.4 configure -state disabled
	$widget.button5.5 configure -state disabled
	$widget.button6.6 configure -state disabled
	if [regexp {\.dir\.} $widget] {
		if {[winfo exists .xxdirectory] &&
			[winfo ismapped .xxdirectory]} {
			wm withdraw .xxdirectory
		}
	}
}

# DisableEntry - end
# ----------------------------------------------------------------------
# EnableEntry

proc EnableEntry {widget entryName varName {listName {}}} {
# this procedure is called from DDDialog
#	global environmentArray
#	upvar #0 $varName var	;# dd(resultx)
	upvar focus focus
	regexp ... $widget win	;# .dd
	set focus [focus -displayof $win]
	focus $widget.entry
	$widget.entry xview moveto 1.0
	SetBackgroundEntry $widget.entry $entryName $varName $listName
	$widget.entry configure -fg black -state normal
	$widget.button1.1 configure -state normal
	$widget.button2.2 configure -state normal
	$widget.button3.3 configure -state normal
	$widget.button4.4 configure -state normal
	$widget.button6.6 configure -state normal
	CompleteEntry $widget.entry $entryName $varName check
}

# EnableEntry - end
# ----------------------------------------------------------------------
# CompleteEntry

proc CompleteEntry {entryWidget entryName varName \
	{flag {}}} {
# It is called originally at each key stroke
# the listName is used when the entryWidget name contains
# the strings .lis. or .ent. or .rep. and reverse == 0 (key first)
# puts $entryName
# => spPreference
	global environmentArray
	global typeTable
	global listNameTable
	global homePath
	upvar #0 $varName var
	upvar #0 $entryName xxEntry
	set listName $listNameTable($xxEntry)
	if {[lindex [$entryWidget configure -state] end] == "disabled"} {
		return
	}
	regexp {^(..)\(result(.)} $varName m xx index	;# dd 2
	set searchName ${xx}Search	;# ddSearch
	upvar #0 $searchName search
	if {[info exists search] && $search} {
		set type .sea.
	} else {
		set type $typeTable($xxEntry)
	}
	regsub {\.entry$} $entryWidget {} widget
	switch -regexp -- $type \
		\.dir\.|\.lis\. {
			set root $var
		} \
		\.rep\. {
			regsub {(..).*} $varName \
				{\1Reverse} reverseName	;# ddReverse
			upvar #0 $reverseName reverse
			if $reverse {
# repository first
				set root $homePath/col/$var
				set root [DeleteKey $root]	;# delete the key
			} else {
# key first
				set bgColor [lindex [$entryWidget config -bg] \
					end]
				if {$bgColor == "#ffccff"} {
# is magenta
					regsub {.* } $var {} rep
					if ![file isdirectory $homePath/col/$rep] {
# the repository has been deleted
						UpdateVariables $rep
						SetIndicator .$xx
					}
				}
				set root $var
			}
		} \
		\.ent\. {
			if ![info exists \
				environmentArray(${xxEntry}SelectMenu)] {
				set environmentArray(${xxEntry}SelectMenu) ""
			}
#			UpdateMenu $widget $entryName $varName $listName
			UpdateMenu $widget $entryName $varName
			CheckConsistency $type $varName \
				$environmentArray(${xxEntry}SelectMenu) \
				$listName  
			set menu $widget.button3.3.menu
			CreateMenu $menu $widget $entryName $type $varName \
				$environmentArray(${xxEntry}SelectMenu) \
				$listName {    }
			if {$flag == "\t"} {
				set string [CompleteLine $listName $var]
			} else {
				set string $var
			}
			UpdateEntry $widget $entryName $type $string \
				$varName $listName
			return
		} \
		\.sea\. {
 			if {$flag == "\r"} {
				SearchEntry $widget $entryName $xx $index
			}
			return
		}

	if ![info exists reverse] {set reverse 0}	;# could be 0 or 1
	set root [CorrectPath $type $root $reverse $listName]
	if {$flag == "check"} {
		set string $root	;# string (nothing more to do)
	} else {
		set inputList [GlobDir $root $type $reverse $listName]
		set string [CommonRoot $inputList $root]	;# string
	}
	regsub {/\.$} $string {/} string		;# /. -> /
	if {$flag == "\b" && $var != "$string" || \
		[regexp {^[A-Za-z]:$} $var]} {
# back space
		regexp {\.([^.]*\.[^.]*)} $widget m prefix	;# dd.dir
		upvar #0 ${prefix}PostMenu postMenu
		set postMenu 0
#		ReduceEntry $widget $entryName $varName $listName
		ReduceEntry $widget $entryName $varName
		return
	}
#	UpdateEntry $widget $entryName $type $string $varName $listName \
		$fileList
	UpdateEntry $widget $entryName $type $string $varName $listName
}

# CompleteEntry - end
# ----------------------------------------------------------------------
# CommonRoot
# Return the first common characters

proc CommonRoot {inputList root} {
# find the common root in inputlist (new root)
	set firstListElement [lindex $inputList 0]
	set lengthOfFirst [string length $firstListElement]
	set rootLength [string length $root]
	for {set i $rootLength} {$i < $lengthOfFirst} {incr i} {
		set character [string index $firstListElement $i]
		foreach listElement $inputList {
			set end no
			if {$character != [string index $listElement $i]} {
				set end yes
				break
			}
		}
		if {$end == "yes"} {break}
	}
	incr i -1
	return [string range $firstListElement 0 $i]	;# new root
}

# CommonRoot - end
# ----------------------------------------------------------------------
# UpdateEntry

proc UpdateEntry {widget entryName type string varName listName} {
#	global environmentArray
	upvar #0 $varName var
	if [regexp {\.rep\.} $type] {
		set string [AddKey $string]
	}
#	$widget.entry delete 0 end
#	$widget.entry insert 0 $string	;# update the entry
	set var $string				;# update the entry
	if {$string == ""} {
# empty entry
		$widget.button1.1 configure -state disabled
		regexp {.(..)} $widget m xx	;# dd
		upvar #0 ${xx}SearchEntry xxSearchEntry
		if [winfo exists .$xx.rep.h1.h1.lb] {
			if ![regexp {/} [lindex \
				[.$xx.rep.h1.h1.lb configure -text] end]] {
# search is not active
				$widget.button5.5 configure -state normal
			}
		}
	} else {
# non-empty entry
		$widget.button1.1 configure -state normal
		$widget.button5.5 configure -state disabled
	}
	$widget.entry icursor end
	$widget.entry xview moveto 1.0
#	SetBackgroundEntry $widget.entry $entryName $varName $listName \
		$fileList
	SetBackgroundEntry $widget.entry $entryName $varName $listName
	UpdateMenu2 $widget $entryName $varName
# add a delay for the case of an empty "which" entry
	if ![regexp {\.sea\.} $type] {
		after 500 [list UpdateMenu $widget $entryName $varName]
	}
}

# UpdateEntry - end
# ----------------------------------------------------------------------
# DeleteKey
# Delete the key at the beginning or at the end

proc DeleteKey {string} {
#	regsub {(^.*/col/[^/]*/[^/]*/[^/]*/[^/]*) [^ ]*:[0-9]*:[^ ]*$} \
#		$string {\1/} string
#	return $string
	if [regsub { [^ ]*:.*:.*$|^.*:[^/]*:[^ ]* } \
		$string {} string] {return $string/}
	return $string
}

# DeleteKey - end
# ----------------------------------------------------------------------
# SetBackgroundEntry

proc SetBackgroundEntry {entryWidget entryName varName \
	{listName {}}} {
	global typeTable
	upvar #0 $varName var
	upvar #0 $entryName xxEntry
	upvar #0 $listName list
	set type $typeTable($xxEntry)
	set root $var
	switch -regexp -- $type \
		\.dir\. {
			if [regexp {/$} $root] {
				$entryWidget config -bg #ffccff	;# magenta
				DisplayText $entryWidget $entryName \
					$varName .xxdirectory #dddddd 0
			} else {
				$entryWidget config -bg #ffffff
				if [winfo exists .xxdirectory] {
					.xxdirectory.f.t configure -state normal
					.xxdirectory.f.t delete 1.0 end
				}
			}
		} \
		\.rep\. {
			regsub {(..).*} $varName \
				{\1Search} searchName	;# ddSearch
			upvar #0 $searchName search
			if $search {
				$entryWidget config -bg #ccffff	;# cian
				return
			}
			regsub {(..).*} $varName \
				{\1Reverse} reverseName	;# ddReverse
			upvar #0 $reverseName reverse
			if $reverse {
# repository first
				if [regexp { } $root] {
					$entryWidget config -bg #ffccff	;# magenta
#					DisplayText \
						$entryWidget $entryName \
						$varName .xxrepository \
						#dddddd 0 1 $fileList
					DisplayText \
						$entryWidget $entryName \
						$varName .xxrepository \
						#dddddd 0 1
				} else {
					$entryWidget config -bg #ffffff
					if [winfo exists .xxrepository] {
						.xxrepository.f.t \
							configure -state normal
						.xxrepository.f.t delete 1.0 end
					}
				}
			} else {
# key first
				if {[lsearch -exact $list $root] != -1} {
					$entryWidget config -bg #ffccff	;# magenta
#					DisplayText \
						$entryWidget $entryName \
						$varName .xxrepository \
						#dddddd 0 1 $fileList
					DisplayText \
						$entryWidget $entryName \
						$varName .xxrepository \
						#dddddd 0 1
				} else {
					$entryWidget config -bg #ffffff
					if [winfo exists .xxrepository] {
						.xxrepository.f.t \
							configure -state normal
						.xxrepository.f.t delete 1.0 end
					}
				}
			}
		} \
		\.lis\. {
			if {[lsearch -exact $list $root] != -1} {
				$entryWidget config -bg #ffccff	;# magenta
			} else {
				$entryWidget config -bg #ffffff
			}
		} \
		\.ent\. {
			$entryWidget config -bg #ffffff
		}
}

# SetBackgroundEntry - end
# ----------------------------------------------------------------------
# ReduceEntry

proc ReduceEntry {widget entryName varName {doubleClick {0}}} {
	global typeTable
	global listNameTable
	global homePath
	upvar #0 $varName var
	upvar #0 $entryName xxEntry
	set listName $listNameTable($xxEntry)
	regsub {(..).*} $varName \
		{\1Search} searchName	;# ddSearch
	upvar #0 $searchName search
	if {[info exists search] && $search} {
		set type .sea.
	} else {
#		set type $widget
		set type $typeTable($xxEntry)
	}
	regexp {\.([^.]*\.[^.]*)} $widget m prefix	;# dd.dir
	upvar #0 ${prefix}PostponeReduceEntry postponeReduceEntry
	if $doubleClick {
		set path ""
		if [regexp {\.dir\.} $type] {
			regexp {^[A-Za-z]:/} $var path
		}
		set var $path
		if {$path == ""} {
			$widget.button1.1 configure -state disabled
			if ![regexp {/} [lindex \
				[.$prefix.h1.h1.lb configure -text] end]] {
# search is not active
				$widget.button5.5 configure -state normal
			}
		}
		return
	}
	if $postponeReduceEntry {return}
	set postponeReduceEntry 1
	if [regexp {\.dir\.|\.lis\.|\.ent\.} $type] {
		set path $var
		set lowerBound 0
	} else {
# \.rep\.
#		regsub {([^\(]*)[^12]*(.)\)} $varName \
			{\1Reverse\2} reverseName	;# ddReverse2
		regsub {(..).*} $varName \
			{\1Reverse} reverseName	;# ddReverse
		upvar #0 $reverseName reverse
		if $reverse {
# repository first
#			regexp {^.*/col/} [pwd] colPath
			set path $homePath/col/$var
			set path [DeleteKey $path]	;# delete the key
			set lowerBound [string length $homePath/col/]
			incr lowerBound -1
		} else {
# key first
			set path $var
			set lowerBound 0
		}
	}
# the path could be out-of-date
	if ![info exists reverse] {set reverse 0}	;# could be 0 or 1 
	set path [CorrectPath $type $path $reverse $listName]
#
	regsub {^[A-Za-z]:/?$} $path {} path	;# c:/ or c: -> {}
	set length [string length $path]
	for {set i [expr $length - 1]} {$i >= $lowerBound} {incr i -1} {
		set root [string range $path 0 $i]
		set inputList [GlobDir $root $type $reverse $listName]
		set root [CommonRoot $inputList $root]	;# new root
		set rootLength [string length $root]
		if {$rootLength < $length} {
			UpdateEntry $widget $entryName $type $root $varName \
				$listName
			return
		}
	}
	UpdateEntry $widget $entryName $type "" $varName $listName
}

# ReduceEntry - end
# ----------------------------------------------------------------------
# ReverseEntry

proc ReverseEntry {widget entryName varName index} {
#	upvar #0 ${varName}Reverse$index reverse
	upvar #0 ${varName}Reverse reverse
	upvar #0 ${varName}(result$index) var
	set bg [. cget -bg]
	set nc [NewColor . $bg]
	if $reverse {
		set reverse 0	;# key first
		$widget.button5.5 configure -bg $bg
		$widget.button6.6 configure -state normal
		if {$var != ""} {
			set var "[lrange $var 1 end] [lindex $var 0]"
		}
	} else {
		set reverse 1	;# repository first
		$widget.button5.5 configure -bg $nc
		$widget.button6.6 configure -state disabled
		if {$var != ""} {
			set i [expr [llength $var] - 2]
			set var "[lindex $var end] [lrange $var 0 $i]"
		}
	}
	UpdateMenu $widget $entryName ${varName}(result$index)
	UpdateMenu2 $widget $entryName ${varName}(result$index)
}

# ReverseEntry - end
# ----------------------------------------------------------------------
# SearchEntry

proc SearchEntry {widget entryName varName index {state {}}} {
# state == 0 or 1, force search == state
# state == {}, do not force
# puts $widget
# => .dd.rep.h1.h2.v2.entry
# puts $entryName
# => spPreference
# puts $varName
# => dd
# puts $index
# => 2
#	global metadataArray
	global environmentArray
	global listNameTable
	global searchRepository
	global localURLibClientSocketId
	upvar #0 ${varName}SearchResult xxSearchResult	;# ddSearchResult
	upvar #0 ${varName}SelectedKeyRepList xxSelectedKeyRepList	;# ddSelectedKeyRepList
	upvar #0 ${varName}SearchEntry xxSearchEntry	;# ddSearchEntry
	upvar #0 ${varName}Search search	;# ddSearch
	upvar #0 ${varName}(result$index) var	;# dd(result2)
	upvar #0 $entryName xxEntry	;# ddRepository
	set r1 $searchRepository
	set listName $listNameTable($xxEntry)
	if {$state != ""} {set search $state}
	set bg [. cget -bg]
	set nc [NewColor . $bg]
	if $search {
		$widget.button1.1 configure -state normal
		$widget.button2.2 configure -state normal
		$widget.button4.4 configure -state normal
		$widget.button6.6 configure -bg $bg
		set xxSearchEntry $var
		UpdateMenu2 $widget $entryName ${varName}(result$index) 0
		set search 0	;# must be after UpdateMenu2
#		set xxSearchResult [Submit $localURLibClientSocketId \
			[list ${r1}::MountSearch $var]]
		set xxSearchResult [${r1}::MountSearch $var]
		if [regexp {<(.*)>} $xxSearchResult m error] {
 puts $error	;# prints the error message
# error variable not used because may be != syntax error
			.$varName.rep.h1.h1.lb configure \
				-text [Translate {syntax error}] \
				-fg #ff0000
			SearchEntry $widget $entryName $varName $index
			return
		} else {
puts >>>$xxSearchResult
			set xxSelectedKeyRepList {}
			set xxSearchResult [Grep {-0$} $xxSearchResult]
			foreach rep-i $xxSearchResult {
#				set rep $metadataArray(${rep-i},Repository)
				regsub -- {-[^-]*$} ${rep-i} {} metadataRep
				set rep [ReturnRepositoryName $metadataRep]
				lappend xxSelectedKeyRepList [AddKey $rep/ 0]
			}
			SetIndicator .$varName
		}
		set var [CompleteLine ${varName}SelectedKeyRepList ""]
		CompleteEntry $widget.entry $entryName \
			${varName}(result$index)
		SetBackgroundEntry $widget.entry $entryName \
			${varName}(result$index) $listName
		$widget.entry xview moveto 1.0
		$widget.entry icursor end
	} else {
		set search 1
		$widget.button1.1 configure -state disabled
		$widget.button2.2 configure -state disabled
		$widget.button4.4 configure -state disabled
		$widget.button5.5 configure -state disabled
		$widget.button6.6 configure -bg $nc
		if [info exists xxSearchEntry] {
			set var $xxSearchEntry	;# set entry
		} else {
			set var ""
		}
		SetBackgroundEntry $widget.entry $entryName \
			${varName}(result$index)
#		$widget.entry configure -state normal
		UpdateMenu2 $widget $entryName ${varName}(result$index)
	}
}

# SearchEntry - end
# ----------------------------------------------------------------------
# UpdateMenu
# puts $widget
# => .dd.rep.h1.h2.v2.entry
# puts $entryName
# => ddRepository
# puts $varName
# => dd(result2)

proc UpdateMenu {widget entryName varName} {
	global typeTable
	global listNameTable
	global homePath
#	global numberOfRep
	global keyRepositoryList
#	global selectedKeyRepList
	global environmentArray
	upvar #0 $varName var
	upvar #0 $entryName xxEntry	;# e.g. ddRepository
#	.dd configure -cursor watch
	set listName $listNameTable($xxEntry)
	set type $typeTable($xxEntry)
	regexp {.(..)} $widget m xx	;# dd
	upvar #0 ${xx}SearchEntry xxSearchEntry
	if {[regexp {\.rep\.} $type] && \
		[info exists xxSearchEntry] && $xxSearchEntry != ""} {
		set listName ${xx}SelectedKeyRepList
	}
	set menu $widget.button2.2.menu
	$menu delete 0 end
	if {[string compare $var ""] != 0} {
		$menu add command -label " .." -underline 2 \
			-command "ReduceEntry $widget $entryName $varName"
	}
	set hcpLength 0	;# home collection path length
	regsub {(..).*} $varName \
		{\1Reverse} reverseName	;# ddReverse
	upvar #0 $reverseName reverse
	if ![info exists reverse] {set reverse 0}	;# could be 0 or 1
	set repFirst [expr [regexp {\.rep\.} $type] && $reverse]
	if !$repFirst {
# not .rep. or key first
		set root $var
	} else {
# repository first
		set root $homePath/col/$var
	}
	if {$repFirst && [regexp { } $var]} {
		set itemList [DeleteKey $root]	;# delete the key
	} else {
		set root [CorrectPath $type $root $reverse $listName]
		set inputList [GlobDir $root $type $reverse $listName]
		set outputList ""
		foreach input $inputList {
			if !$repFirst {
				set output $input
			} else {
# $input == C:/usuario/gerald/URLib/col/test/test/1998/08.29.16.07/bib/
				if [regexp \
					{(^.*/col/[^/]*/[^/]*/[^/]*/[^/]*/).} \
					$input m outputList] {break}
# propagate the search to the next directories
				set inputList2 [GlobDir $input $type $reverse]
				set output [CommonRoot $inputList2 $input]
#
			}
			lappend outputList $output
		}
# Update keyRepositoryList
# (these lists may not be complete)
		if $repFirst {
			foreach output $outputList {
				if [regexp \
					{^.*/col/([^/]*/[^/]*/[^/]*/[^/]*)/$} \
						$output m rep] {
					set nOR [llength $keyRepositoryList]
					UpdateKeyRepositoryList $rep
#					AddItem metadataRepList \
						[FindMetadataRep $rep]
					set numberOfRep \
						[llength $keyRepositoryList]
					if {$nOR != "$numberOfRep"} {
						set environmentArray(${xx}SearchEntry) {}
						set xxSearchEntry {}
					}
					regexp {\.[^.]*} $widget win	;# .dd
					SetIndicator $win $numberOfRep
				}
			}
		}
# Update keyRepositoryList - end
		set listLength [llength $outputList]
		if {$listLength > 8} {
			set itemList \
				[lsort -dictionary [MinMax $outputList $root]]
		} else {
			set itemList [lsort -dictionary $outputList]
		}
	}
	set itemList [CheckConsistency $type $varName $itemList \
		$listName]
	set rootLength [string length $root]
	set listLength [llength $itemList]
# 8 <= 10
	if {$listLength > 10} {
# too many lines - mount submenus
		set j 1	;# submenu number
		for {set i 0} {$i < $listLength} {incr i} {
			set currentItem [lindex $itemList $i]
			if $repFirst {
				set homeColPath ""	;# in case of no match
				regexp {^.*/col/} $currentItem homeColPath
				set hcpLength [string length $homeColPath]
				set currentItem [AddKey $currentItem]
#				regsub {^.*/col/} $currentItem {} currentItem
			}
			set firstCharacter1 \
				[string index $currentItem \
					[expr $rootLength - $hcpLength]]
			set nextItem [lindex $itemList [expr $i + 1]]
			if $repFirst {
				regsub {^.*/col/} $nextItem {} nextItem
			}
			set firstCharacter2 \
				[string index $nextItem \
					[expr $rootLength - $hcpLength]]
			if [regexp -nocase "$firstCharacter1" \
				$firstCharacter2] {
# cascade
				set yy [CutLabel $widget \
"$root\[$firstCharacter1$firstCharacter2\]"] 
				$menu add cascade \
					-label [lindex $yy 1] -menu $menu.sub$j
#				$menu add cascade \
		-label " $root\[$firstCharacter1$firstCharacter2\]" \
					-menu $menu.sub$j
				if ![winfo exists $menu.sub$j] {
					set subMenu [menu $menu.sub$j \
						-tearoff 0 \
						-font {courier 9 roman}]
				} else {
					set subMenu $menu.sub$j
				}
				$subMenu delete 0 end
				regsub "^$root" $currentItem {} \
					currentLabel
				$subMenu add command \
					-label $currentLabel \
					-command "UpdateEntry \
					$widget $entryName $type {$currentItem} \
					$varName {$listName}"
				regsub "^$root" $nextItem {} nextLabel
				$subMenu add command \
					-label $nextLabel \
					-command "UpdateEntry \
					$widget $entryName $type {$nextItem} \
					$varName {$listName}"
				incr i
				incr j
			} else {
# no cascade
				set yy [CutLabel $widget $currentItem] 
				$menu add command \
					-underline [expr $rootLength - \
						[lindex $yy 0] - $hcpLength + 1] \
					-label [lindex $yy 1] \
					-command "UpdateEntry \
					$widget $entryName $type {$currentItem} \
					$varName {$listName}"
#				$menu add command \
					-underline [expr $rootLength - \
						$hcpLength + 1] \
					-label " $currentItem" \
					-command "UpdateEntry \
					$widget $entryName $type {$currentItem} \
					$varName {$listName}"
			}
		}
# too many lines - end
	} else {
		CreateMenu $menu $widget $entryName $type $varName \
			$itemList $listName { } $rootLength
	}
#	.dd configure -cursor arrow
	regexp {\.([^.]*\.[^.]*)} $widget m prefix	;# dd.dir
	upvar #0 ${prefix}PostMenu postMenu
	upvar #0 ${prefix}PostponeReduceEntry postponeReduceEntry
	set index [$menu index last]
	if {$index == 1} {
		set label [$menu entrycget 1 -label]
		set entry [lindex [CutLabel $widget [$widget.entry get]] 1]
		if {[string compare $label $entry] == 0} {
# terminal node; nothing to display
			$menu delete 0 end
			$widget.button2.2 configure -state disabled
			if $repFirst {
				regsub {([^\(]*)[^12]*(.)\)} $varName \
					{\1Choice\2} choiceName	;# ddChoice1
				upvar #0 $choiceName choice
				if ![regexp {^rep} $choice] {return}
			}
			if {![info exists xxSearchEntry] \
				|| $xxSearchEntry == ""} {
				$widget.button5.5 configure -state normal
			}
			set postMenu 0
			set postponeReduceEntry 0
			return
		}
	}
	if [regexp {\.dir\.|\.rep\.} $type] {
		regsub {([^\(]*)[^12]*(.)\)} $varName \
			{\1Choice\2} choiceName	;# ddChoice1
		upvar #0 $choiceName choice
		if ![regexp {^dir|^rep} $choice] {return}
	}
	$widget.button2.2 configure -state normal
# drop out undue underline
	set numberOfEntry [$menu index end]
	if {$numberOfEntry != "none"} {
# nonempty menu
		incr numberOfEntry
		set letter "xx"
		for {set i 0} {$i < $numberOfEntry} {incr i} {
			set index [$menu entrycget $i -underline]
			set label [$menu entrycget $i -label]
			set currentLetter [string index $label $index]
			if {[string compare $letter $currentLetter] == 0} {
# the letters are equal
				$menu entryconfigure $i -underline -1
				$menu entryconfigure [expr $i - 1] -underline -1
			} else {
# the letters are different
				set letter $currentLetter
			} 
		}
	}
# drop out undue underline - end
	if $postMenu {
# post the menu now
		set x [winfo rootx $widget.button2.2]
		set y [winfo rooty $widget.button2.2]
		set h [winfo height $widget.button2.2]
		$menu post $x [expr $y + $h]
	}
	set postponeReduceEntry 0
}

#proc ItemCompare {a b} {
#	set aLetter [string index $a 0]
#	set bLetter [string index $b 0]
#	set result [string compare $aLetter $bLetter]
#	if {$result != 0} {
# different letters
#		set before [list $aLetter $bLetter]
#		set after [lsort -dictionary $before]
#		if {[string compare $after $before] == 0} {
#			return $result
#		} else {
#			return [expr -1 * $result]
#		}
#	} else {
#		return [ItemCompare [string range $a 1 end] \
#			[string range $b 1 end]]
#	}
#}

# UpdateMenu - end
# ----------------------------------------------------------------------
# CutLabel

proc CutLabel {widget label {blank { }}} {
# maxNumberOfCharacters
#	regexp {\.[^.]*} $widget win	;# .dd
#	set geo [wm geometry $win]
#	regexp {^([^x]+)x([^\+]+)\+([^\+]+)\+([^\+]+)$} $geo m W H X Y
	set W [winfo screenwidth .]
	set a [expr 23.0 / 208]
	set maxNumberOfCharacters \
		[expr round([expr $a * [expr $W - 635] + 45])]
	incr maxNumberOfCharacters
# maxNumberOfCharacters - end
	set labelLength [string length $label]
	set begin [Max [expr $labelLength - $maxNumberOfCharacters] 0]
#	set begin 0
	return [list $begin $blank[string range $label $begin end]]
}

# CutLabel - end
# ----------------------------------------------------------------------
# UpdateMenu2
# Update the menu for the S Menu Button
# listName example: keyRepositoryList

proc UpdateMenu2 {widget entryName varName {flag {1}}} {
	global environmentArray
	global typeTable
	global listNameTable
#	global numberOfRep
	upvar #0 $varName var
	regexp {^..} $varName xx	;# dd
#	regsub {(..).*} $varName {\1Search} searchName	;# ddSearch
	set searchName ${xx}Search	;# ddSearch
	upvar #0 $searchName search
	if {[info exists search] && $search} {
		set xxEntry ${xx}Search
		set type .sea.
	} else {
		upvar #0 $entryName xxEntry	;# ddRepository
		set type $typeTable($xxEntry)
	}
	set listName $listNameTable($xxEntry)
	set menu $widget.button3.3.menu
	if ![info exists environmentArray(${xxEntry}SelectMenu)] {
		set environmentArray(${xxEntry}SelectMenu) ""
	}
	set list [UpdateList $type $varName \
		environmentArray(${xxEntry}SelectMenu) $var 8 $listName]
	set list [CheckConsistency $type $varName $list $listName 0]
	set environmentArray(${xxEntry}SelectMenu) $list
	if $flag {CreateMenu $menu $widget $entryName $type $varName \
		$list $listName {    }}
}

# UpdateMenu2 - end
# ----------------------------------------------------------------------
# UpdateList
# Update the menu for the S Menu Button adding one item
# referenceListName example: keyRepositoryList
# example: $varName == sp

proc UpdateList {type varName listName item maxNumberOfItems \
	{referenceListName {}}} {
	upvar #0 $listName list
	upvar #0 $referenceListName referenceList
	if ![info exists list] {set list {}}
	if [regexp {\.sea\.} $type] {
		if [regexp {^\* \*$} $item] {
# don't add this item
			return $list
		}
	}
	regsub {(..).*} $varName \
		{\1Reverse} reverseName	;# ddReverse
	upvar #0 $reverseName reverse
	if ![info exists reverse] {set reverse 0}	;# could be 0 or 1
	set repFirst [expr [regexp {\.rep\.} $type] && $reverse]
	set keyFirst [expr [regexp {\.rep\.} $type] && !$reverse]
	if {[lindex $list end] != "$item" && \
		![regexp {^$} $item]} {
		if {[regexp {\.dir\.} $type] && [regexp {/$} $item] || \
			$repFirst && [regexp { } $item] || \
			[regexp {\.lis\.|\.ent\.} $type] && \
				[lsearch -exact $referenceList $item] != -1 || \
			[regexp {\.sea\.} $type] || \
			$keyFirst && \
				[lsearch -exact $referenceList $item] != -1} {
# drop the item if it exists
			if {[set i [lsearch -exact $list $item]] != -1} {
				set list [lreplace $list $i $i]
			}
# drop the item if it exists - end
			lappend list $item
			set numberOfItems [llength $list]
			if {$numberOfItems > "$maxNumberOfItems"} {
				set list [lreplace $list 0 0]
			}
		}
	}
# uniform the list according to key or repository first
	if [regexp {\.rep\.} $type] {
		set repList ""
		set list2 ""
		foreach item $list {
			set rep [DeleteKey $item]
			if {[lsearch -exact $repList $rep] == -1} {
				lappend repList $rep
				lappend list2 [AddKey $rep $reverse]
			}
		}
		set list $list2
	}
# uniform the list according to key or repository first - end
	return $list
}

# UpdateList - end
# ----------------------------------------------------------------------
# CreateMenu
# listName example: keyRepositoryList

proc CreateMenu {menu widget entryName type varName itemList listName \
	blank {rootLength {-1}}} {
	global referenceTable
	upvar #0 $varName var
#	upvar #0 $listName list
	$menu delete 0 end
	if {[string compare $var ""] != 0 && $blank == " "} {
		$menu add command -label " .." -underline 2 \
			-command "ReduceEntry $widget $entryName $varName"
	}
	if [regexp {\.sea\.} $type] {
		$menu add command -label "" \
			-command "UpdateEntry $widget $entryName $type \
				{} $varName {$listName}"
		$menu add command -label "    * *" \
			-command "UpdateEntry $widget $entryName $type \
				{* *} $varName {$listName}"
	}
	set hcpLength 0	;# home collection path length
	regsub {(..).*} $varName \
		{\1Reverse} reverseName	;# ddReverse
	upvar #0 $reverseName reverse
	if ![info exists reverse] {set reverse 0}	;# could be 0 or 1
	set repFirst [expr [regexp {\.rep\.} $type] && $reverse]
	set itemList [lsort $itemList]
	foreach item $itemList {
		set label $item
		if $repFirst {
			set homeColPath ""	;# in case of no match
			regexp {^.*/col/} $label homeColPath
			set hcpLength [string length $homeColPath]
			set label [AddKey $label]
		}
		set yy [CutLabel $widget $label $blank]
		set underline [expr $rootLength - [lindex $yy 0] \
			- $hcpLength + 1] 
		set label [lindex $yy 1]
#		set underline [expr $rootLength - $hcpLength + 1] 
#		set label $blank$label
		if {$rootLength != -1 && \
			$underline <= [string length $label] && \
			$underline != 0} {
# > button and not a terminal node
			$menu add command \
				-underline $underline \
				-label $label \
				-command "UpdateEntry $widget $entryName $type \
					{$item} $varName {$listName}"
		} else {
# S button
			$menu add command \
				-label $label \
				-command "UpdateEntry $widget $entryName $type \
					{$item} $varName {$listName}"
		}
	}
}

# CreateMenu - end
# ----------------------------------------------------------------------
# CheckConsistency
# Check consistency of itemList and referenceList with respect to the
# current collection
# itemList example: environmentArray(${xxEntry}SelectMenu)
# referenceListName example: keyRepositoryList
# flag value is 0 or 1, when the flag value is 0 the items which are not
# in the referenceList are discarded, when the flag value is 1 the
# items are preserved (default value is 1)

proc CheckConsistency {type varName itemList referenceListName \
	{flag {1}}} {
#	global metadataArray
	global referenceTable
	global homePath
#	global numberOfRep
	upvar #0 $referenceListName referenceList
	if [regexp {\.rep\.} $type] {
# rep case
#		regsub {(..).*} $varName \
			{\1Reverse} reverseName	;# ddReverse
		regexp .. $varName xx	;# dd
		set win .$xx	;# .dd
		set reverseName ${xx}Reverse	;# ddReverse
		upvar #0 $reverseName reverse
		if !$reverse {
# key first
			set outputList ""
			foreach item $itemList {
# check if the item is in the referenceList
				set i [lsearch -exact $referenceList $item]
				if {$i != -1} {
# the item is in the referenceList
					regexp {^.* (.*/.*/.*/.*)} $item m rep
					if ![file isdirectory $homePath/col/$rep] {
# the repository has been deleted
						UpdateVariables $rep
#						set numberOfRep \
							[llength $referenceList]
						SetIndicator $win
					} else {
# the repository has not been deleted
						lappend outputList $item
					}
				} else {
# the item is not in the referenceList
					if $flag {lappend outputList $item}
				}
			}
		}
	}
	if ![info exists outputList] {set outputList $itemList}
	return $outputList
}

# CheckConsistency - end
# ----------------------------------------------------------------------
# UpdateVariables

proc UpdateVariables {rep} {
#	global metadataArray
#	global referenceTable
#	global repositoryProperties
	global keyRepositoryList	
#	global metadataRepList	
# discard rep from metadataArray
#	DiscardRepository $rep-0 metadataArray
# discard rep from referenceTable
	DiscardRepository $rep referenceTable
# discard rep from repositoryProperties
	DiscardRepository $rep repositoryProperties
# discard rep from keyRepositoryList
	set i [lsearch -regexp $keyRepositoryList $rep$]
	set keyRepositoryList [lreplace $keyRepositoryList $i $i]
# discard rep from metadataRepList
#	set i [lsearch -regexp $metadataRepList $rep$]
#	set metadataRepList [lreplace $metadataRepList $i $i]
}

# UpdateVariables - end
# ----------------------------------------------------------------------
# DiscardRepository
# varName examples: repositoryProperties, referenceTable, ...

proc DiscardRepository {rep varName} {
	upvar #0 $varName var
	foreach index [array names var $rep,*] {
		unset var($index)
	}
}

# DiscardRepository - end
# ----------------------------------------------------------------------
# CorrectPath
# Find the longest correct path within a given path
# if [regexp {\.rep\.} $widget] == 1 then
# reverse == 0 (means key first); == 1 (means repository first)
# otherwise the reverse value has no special meaning


proc CorrectPath {type path reverse listName} {
	global tcl_platform
	upvar #0 $listName list
	if {[regexp {\.dir\.} $type] || \
		[regexp {\.rep\.} $type] && $reverse} {
# >
	if {$tcl_platform(platform) == "unix"} {
		if ![regexp {^/} $path] {
			set path "/"	;# should be absolute
		}
	}
	if {$tcl_platform(platform) == "windows"} {
		regsub {^[a-zA-Z]$} $path {&:} path	;# c -> c:
		if ![regexp {^.:|^/} $path] {
			set path ""		;# should be absolute
		}
	}
	set correctPath ""
	foreach fileName [file split $path] {
		set testedPath $correctPath
		lappend testedPath $fileName
		set name [eval file join $testedPath]
# problem with glob
# dir... == dir (windows)
		regsub {[^/]\.+$} $name {*} name	;# dir. -> dir*
		set name [join [glob -nocomplain -- $name]]
# join is necessary in case of directory name with blank
# as in "New Folder". In this case, glob return is {C:/tmp/New Folder}.
#
		if {$name != "" && [file isdirectory $name]} {
			set correctPath [file split $name]
		} else {
			break
		}
	}
	if {$correctPath == ""} {return ""}
	set name [eval file join $correctPath]
	regsub {([^/]$)} $name {\1/} name	;# add missing trailing /
	set length [string length $name]
	set pathLength [string length $path]
	for {set i $length} {$i < $pathLength} {incr i} {
		set pattern [string range $path 0 $i]
		set globResult [glob -nocomplain -- $pattern*]
		set directoryList ""
		foreach fileName $globResult {
			if [file isdirectory $fileName] {
				lappend directoryList $fileName
			}
		}
		set grepResult [Grep $pattern $directoryList]	;# i I
		if {$grepResult == ""} {break}
	}
	incr i -1
	set string [string range $path 0 $i]
	regsub {/\./$} $string {/} string	;# /./ -> / (simplifying)
	return $string
# <
	} else {
# >
	if !$reverse {set path [AddKey $path 0]}
	set length [string length $path]
#	set root ""
	for {set i 0} {$i < $length} {incr i} {
		set pattern [string range $path 0 $i]	;# por (i = 2)
		set end ""
		foreach item $list {
			if [regexp "^$pattern" $item] {
				set end continue
				break
			}
		}
		if {$end == "continue"} {continue}
		break
	}
	incr i -1
	set string [string range $path 0 $i]
	return $string
# <
	}
}

# set list {}
# puts [CorrectPath .dir. {/Program Files/Accessoies/aux} 0 list]
# => /Program Files/Accesso
# set list {{english} {portuguese} {french} {spanish}}
# puts [CorrectPath .lis. porttuguese 0 list]
# => port
# set list {{banon@dpi.inpe.br} {teste@teste}}
# puts [CorrectPath .ent. bannon 0 list]
# => ban 

# CorrectPath - end
# ----------------------------------------------------------------------
# Rootx
# Return the list of "${root}first character" of list elements

proc Rootx {inputList {root {}}} {
	set outputList ""
	set previousRootx ""
	foreach listElement [lsort $inputList] {
		regexp "^$root." $listElement rootx
		if {[string compare $previousRootx $rootx] != 0} {
			lappend outputList $rootx
			set previousRootx $rootx
		}
	}
	return $outputList
}

# puts [Rootx {bs b ansi abc swr}]
# => a b s	
# puts [Rootx {c:/bs c:/b c:/ansi c:/abc c:/swr} c:/]
# => c:/a c:/b c:/s

# Rootx - end
# ----------------------------------------------------------------------
# GlobDir
# Return a list of directory names matching a pattern 
# if [regexp {\.rep\.} $type] == 1 then
# reverse == 0 (means key first); == 1 (means repository first)
# otherwise the reverse value has no special meaning

proc GlobDir {pattern type reverse {list2Name {defaultList}}} {
	upvar #0 $list2Name list2
	if {[regexp {\.dir\.} $type] || \
		[regexp {\.rep\.} $type] && $reverse} {
# >
	set list ""
	if {$pattern == {}} {
		foreach letter {A B C D E F G H I J K L M N \
			O P Q R S T U V W X Y Z} {
			if ![catch {glob $letter:/}] {
				lappend list $letter:/
			}
		}
		if {$list == ""} {set list [glob /*]}
	} else {
		regsub {^([a-z]):?$} $pattern {\1:/} pattern
# c: -> c:/ or c -> c:/
		if [regexp {/$} $pattern] {
			set globResult \
				[glob -nocomplain -- $pattern* $pattern.*]
		} else {
# puts [glob dpi.inpe* dpi.inpe.*]
# => dpi.inpe.br dpi.inpe.br
# should be => dpi.inpe.br
			set globResult [glob -nocomplain -- $pattern*]
		}
		set grepResult [Grep $pattern $globResult]	;# i I
		foreach fileName $grepResult {
			if {[file isdirectory $fileName] && \
				![regexp {/\.$|/\.\.$} $fileName]} {
				lappend list $fileName/
			}
		}
	}
# propagate the search to the next directories
	if [regexp {\.rep\.} $type] {
		if {[llength $list] == 1} {
			set list [GlobDir [join $list] $type $reverse]
		}
	}
#		
	if {[llength $list] == 0} {
#		regsub {/$} $pattern {} list
#		set list [list $list] ;# {xx cc}
		set list [list $pattern] ;# {xx cc}
	}
# <
	} else {
		set list [Grep "^$pattern" $list2]
	}
	return $list
}

# puts [GlobDir {} .dir 0]
# => c:/ d:/
# puts [GlobDir {c:/*} .dir 0]
# puts [GlobDir {c:/zzz*} .dir 0]
# =>			;# empty line
# puts [GlobDir {c:/usuari*} .dir 0]

# Globdir - end 
# ----------------------------------------------------------------------
# MinMax
# Return the minimum list containing the maximum strings
# root must be contained in the intersection of inputList

proc MinMax {inputList root} {
	set root [CommonRoot $inputList $root]	;# new root
	set rootLength [string length $root]
	set outputList ""
	if {[join $inputList] == $root} {
		lappend outputList [join $inputList]
		return $outputList
	}
	foreach rootx [Rootx $inputList $root] {
		set list [Grep "^$rootx" $inputList]
		set firstElement [lindex $list 0]
		set length [string length $firstElement]
		if {$length == [expr $rootLength + 1] || \
			[llength $list] == 1} {
			lappend outputList $firstElement
		} else {
			for {set i $rootLength} {$i < $length} {incr i} {
				foreach otherElement [lrange $list 1 end] {
					set end no
					if {[string index $firstElement $i] != \
						[string index $otherElement $i]} {
						set end yes
						break
					}
				}
				if {$end == "yes"} {break}
			}
			incr i -1
			lappend outputList [string range $firstElement 0 $i]
		}
	}
	return $outputList
}

# puts [MinMax {c:/usuario/gerald c:/usuario/gabi c:/usuario/lise} \
c:/usuario]
# => c:/usuario/g c:/usuario/lise

# MinMax - end
# ----------------------------------------------------------------------
# CompleteLine

proc CompleteLine {listName root} {
	upvar #0 $listName inputList
	set list [Grep "^$root" $inputList]
	if {$list == ""} {return $root}
# find the length of the shortest item
	set length 1000
	foreach item $list {
		set length [Min $length [string length $item]]
	}
#
	set rootLength [string length $root]
	for {set i $rootLength} {$i < $length} {incr i} {
		set letter [string index [lindex $list 0] $i]
		foreach item $list {
			if {$letter != "[string index $item $i]"} {
				incr i -1
				set length $i
				break
			}			
		}
	}
	return [string range [lindex $list 0] 0 $length]
}
# set list {c:/usuario/gerald c:/usuario/gabi c:/usuario/lise}
# puts [CompleteLine list c:/usua]
# => c:/usuario/	
# puts [CompleteLine list c:/usuario/l]
# => c:/usuario/lise
# puts [CompleteLine list c:/usuario/p]
# => c:usuario/p
	
# CompleteLine - end
# ----------------------------------------------------------------------
# Example 27-2
# Scroll_Set manages optional scrollbars.
#

proc Scroll_Set {scrollbar geoCmd offset size} {
	if {$offset != 0.0 || $size != 1.0} {
		eval $geoCmd			;# Make sure it is visible
		$scrollbar set $offset $size
	} else {
		set manager [lindex $geoCmd 0]
		$manager forget $scrollbar	;# hide it
	}
}

# Scroll_Set - end
# ----------------------------------------------------------------------
# NewColor
# Computing a new color.
# Example 35-2

proc NewColor {win color} {
	set rgb [winfo rgb $win $color]
	set mx [Max [lindex $rgb 0] \
		[Max [lindex $rgb 1] [lindex $rgb 2]]]
	set wht [winfo rgb $win white]
	if {$mx < [expr [lindex $wht 0] / 1.4]} {
		return [format "#%03x%03x%03x" \
		[expr round([lindex $rgb 0] * 0.85)] \
		[expr round([lindex $rgb 1] * 0.85)] \
		[expr round([lindex $rgb 2] * 0.85)]]
	} else {
		return [format "#%03x%03x%03x" \
		[expr round([lindex $rgb 0] * 1.15)] \
		[expr round([lindex $rgb 1] * 1.15)] \
		[expr round([lindex $rgb 2] * 1.15)]]
	}
}

# NewColor -end
# ----------------------------------------------------------------------
# Enter
# for help effect

proc Enter {text targets tagName} {
	$text tag configure $tagName -foreground #0000ff
	set bg [. cget -bg]
	set nc [NewColor . $bg]
	foreach target $targets {
		if {[$target cget -bg] == "$bg"} {
			$target configure -background $nc
		} else {
			$target configure -background $bg
		}
	}
}

# Enter - end
# ----------------------------------------------------------------------
# Leave
# for help effect

proc Leave {text targets tagName} {
	$text tag configure $tagName -foreground #000099
	set bg [. cget -bg]
	set nc [NewColor . $bg]
	foreach target $targets {
		if {[$target cget -bg] == "$bg"} {
			$target configure -background $nc
		} else {
			$target configure -background $bg
		}
	}
}

# Leave - end
# ----------------------------------------------------------------------
# TagBind

proc TagBind {t tagName targets {form {}}} {
	if [regexp {^\...\.definition} [join $targets]] {
# for definition, e.g. .dd.definition
# tagName is used as a definition name
		$t tag bind $tagName <1> \
			"PlaceDefinition {$tagName} $targets"
	} else {
# for help effect
		regexp {\.[^.]*} $targets win	;# .sp
		$t tag bind $tagName <Enter> "
			if ![regexp {^$} $form] {
				ProcessPreferenceButtons $win $form
			} 
			Enter $t {$targets} {$tagName}
		"
		$t tag bind $tagName <Leave> "
			Leave $t {$targets} {$tagName}
		"
	}
}

# TagBind - end
# ----------------------------------------------------------------------
# PlaceDefinition

proc PlaceDefinition {definitionName t} {
	regexp {\.[^.]*} $t win	;# .dd
#	eval {"$definitionName"} $t	;# insert text in $t
	eval [list $definitionName $t]	;# insert text in $t
	set text [split [$t get 1.0 end] \n]
	set numberOfLines 0
	foreach line $text {
	set numberOfLines [expr int($numberOfLines + \
		ceil((1 + [string length $line].) / 55))]
# we add 1 because of the blank line
	}
#	incr numberOfLines
	set width 50
	$win.definition configure -width $width \
		-height $numberOfLines 
	$win.umbra configure -width $width \
		-height $numberOfLines 
	place $win.definition -in $win -anchor center \
				-relx .5 -rely .5
	place $win.umbra -in $win -anchor center \
				-relx .51 -rely .51
}

# PlaceDefinition - end
# ----------------------------------------------------------------------
# ProcessButton1

proc ProcessButton1 {win} {
	if {$win == ".dd"} {
		regsub {\.} $win {} xx
		upvar #0 $xx.dirPostMenu dirPostMenu
		upvar #0 $xx.repPostMenu repPostMenu
		set dirPostMenu 0
		set repPostMenu 0
	}
# forget definition
	if [winfo exists $win.definition] {
		if [winfo ismapped $win.definition] {
			place forget $win.definition
			place forget $win.umbra
		}
	}
}

# ProcessButton1 - end
# ----------------------------------------------------------------------
# Header
# used in XXDialog

proc Header {win title} {
# title
 	label $win.lb
	ConfigText $win.lb $title
	set font [lindex [$win.lb configure -font] end]
	$win.lb configure -font {$font 11 roman}
# help button
	button $win.help -cursor hand2
	ConfigText $win.help "Help"
# extra space
	frame $win.sp1 -height .1c
}

# Header - end
# ----------------------------------------------------------------------
# Footer
# used in Dialog_xx

proc Footer {win varName {listName {}}} {
# buttons
	regexp {^\...} $win f	;# .dd
	set width 2.2
	set height .6
	set b [frame $win.buttons -width 8c -height .8c]
	set bok [frame $b.ok -width [format "%sc" $width] \
			-height [format "%sc" $height]]
	set bsp [frame $b.sp -width .2c] ;# extra space
	set bcancel [frame $b.cancel -width [format "%sc" $width] \
			-height [format "%sc" $height]]
	set bhelp [frame $b.help -width [format "%sc" $width] \
			-height [format "%sc" $height]]
	button $bok.ok -command "set $varName 1" -cursor hand2
	ConfigText $bok.ok OK
	button $bcancel.cancel -command "set $varName 0" -cursor hand2
	ConfigText $bcancel.cancel Cancel
	button $bhelp.help \
		-command "DisplayText $win {} $varName ${f}help #ffffcc" \
		-cursor hand2
	ConfigText $bhelp.help Help
	pack propagate $b false
	pack propagate $bok false
	pack propagate $bcancel false
	pack propagate $bhelp false
	pack $bok -side left
	pack $bsp -side left
	pack $bcancel -side left
	pack $bhelp -side right
	pack $bok.ok -fill both
	pack $bcancel.cancel -fill both
	pack $bhelp.help -fill both
# definition window
	text $win.umbra -bg #777777 -relief flat \
		-padx .4c -pady .2c -wrap word
	text $win.definition -bg #ffffcc -relief flat \
		-padx .4c -pady .2c -wrap word
	set font [lindex [lindex [$win.definition configure -font] end] 0]
	$win.definition configure -font {$font 10}
	$win.umbra configure -font {$font 10}
	return $b
}

# Footer - end
# ----------------------------------------------------------------------
# RemoveEntry
# examples:
# RemoveEntry $a $entryName ${varName}($index) $listName
# RemoveEntry $f.ent.entry spPreference sp(result1) \
	environmentArray(spList1)

proc RemoveEntry {widget entryName varName} {
	global environmentArray
	global typeTable
	global listNameTable
	upvar #0 $varName var
	upvar #0 $listName list
	upvar #0 $entryName xxEntry
	set listName $listNameTable($xxEntry)
#	regsub {(..).*} $varName \
		{\1Search} searchName	;# ddSearch
#	upvar #0 $searchName search
#	if {[info exists search] && $search} {
#		set type .lis.
#	} else {
#		set type $widget
		set type $typeTable($xxEntry)
#	}
	set i [lsearch -exact $list $var]
	set list [lreplace $list $i $i]
	set i [lsearch -exact $environmentArray(${xxEntry}SelectMenu) \
		$var]
	set environmentArray(${xxEntry}SelectMenu) \
		[lreplace $environmentArray(${xxEntry}SelectMenu) $i $i]
	set menu $widget.button3.3.menu
	CheckConsistency $type $varName \
		$environmentArray(${xxEntry}SelectMenu) $listName  
	CreateMenu $menu $widget $entryName $type $varName \
		$environmentArray(${xxEntry}SelectMenu) $listName \
		{    }
	set var ""
#	UpdateMenu $widget $entryName $varName $listName
	UpdateMenu $widget $entryName $varName
}

# RemoveEntry - end
# ----------------------------------------------------------------------
# SetEntry

proc SetEntry {widget envIndex varName index \
	{arrayName {environmentArray}}} {
	upvar #0 $arrayName array
	upvar #0 $varName var
	if [info exists array($envIndex)] {
		set var($index) $array($envIndex)	;# set entry
	} else {
		if [regexp {\.dir\.} $widget] {
			set var($index) [lindex [file split [pwd]] 0]
		} else {
			set var($index) ""
		}
	}
	$widget.entry icursor end
}

# SetEntry - end
# ----------------------------------------------------------------------
# ListIntersection

proc ListIntersection {list1 list2} {
	set list {}
	foreach element1 $list1 {
		if {[lsearch -exact $list2 $element1] >= 0} {
			lappend list $element1
		}
	}
	return $list
}

# ListIntersection - end
# ----------------------------------------------------------------------
# CallTrace
# Getting a trace of the Tcl call stack for debugging

proc CallTrace {} {
	puts "Tcl Call Trace"
	for {set x [expr [info level] - 1]} {$x >0} {incr x -1} {
		puts "$x: [info level $x]"
	}
	puts "Tcl Call Trace - end\n"
}

# CallTrace - end
# ----------------------------------------------------------------------
# XXDirectory
# Display the directory content
# called from DisplayText

proc XXDirectory {varName} {
	upvar #0 $varName var
	regsub {/$} $var {} dir	;#delete trailing /
	set fileList {}
	DirectoryContent fileList $dir $dir 1
	set fileList [lsort -dictionary $fileList]
	set t .xxdirectory.f.t	
	ClearSelection $t
	foreach tagName [$t tag names] {
		$t tag remove $tagName 1.0 end	;# remove old tags
	}
	$t configure -font {courier 11}
	TextStyles $t
	Insert $t insert \
{File List}
	TagAdd $t bold {File List}
	$t insert insert \n
	foreach file $fileList {
		eval [list $t insert insert " $file " [list $file]]
		eval [list $t tag bind $file <1> \
			"SelectTargetFile $t {$file}"]
		eval [list $t tag bind $file <3> \
			"SelectFile $t {$file}"]
		eval [list $t tag bind $file <Control-3> \
			"SelectFile $t {$file} 0"]
# /clear cannot be a file name
		$t insert insert \n /clear
	}
	$t tag bind /clear <1> "ClearTargetSelection $t"
	$t tag bind /clear <3> "ClearSelection $t"
	$t configure -state disabled
}

# XXDirectory - end
# ----------------------------------------------------------------------
# SelectTargetFile

proc SelectTargetFile {text tagName {rep {}}} {
	global repositoryProperties
	global log
#	global env
	ClearTargetSelection $text
	if [regexp { } $tagName] {return}	;# URL doesn't work with blank
	set targetFile [FindTargetFile $text]
	$text tag configure $tagName -foreground #ff0000
	foreach tagName2 [$text tag names] {
		set color [$text tag cget $tagName2 -background]
		if {$color == "#000088"} {
			$text tag configure $tagName -background #000088
			break
		}
	}
# not used any more by DD
	if [regexp repository $text] {
		if {$targetFile != ""} {
			if [Dialog {Confirm Cancel} {disabled active} {1 1} \
				Utilities {target file change} \
				$targetFile $tagName] {
# Cancel
					ClearTargetSelection $text
					$text tag configure $targetFile \
						-foreground #ff0000
			} else {
# Confirm
				set targetFile $tagName
				$log insert end \n	;# blank line
# This insert $log should be update, <> missing ...
				Insert $log end \
					{new target file $var1 chosen for\
the repository $var2\n} {} $targetFile $rep
			}
		} else {
			set targetFile $tagName
			$log insert end \n	;# blank line
# This insert $log should be update, <> missing ...
			Insert $log end \
				{target file $var1 chosen for\
the repository $var2\n} {} $targetFile $rep
		}
		set repositoryProperties($rep,targetfile) $targetFile
#		set env(TARGET_FILE_LIST) \
			[array get repositoryProperties *,targetfile]
	}
# not used any more by DD - end
}

# XXDirectory - end
# ----------------------------------------------------------------------
# ClearTargetSelection

proc ClearTargetSelection {text} {
	foreach tagName [$text tag names] {
		set colorFg [$text tag cget $tagName -foreground]
		set colorBg [$text tag cget $tagName -background]
		if {$colorFg == "#ff0000"} {
			if {$colorBg == "#000088"} {
#				$text tag configure $tagName -foreground #ffffff
				$text tag configure $tagName \
					-foreground #000000 \
					-background #dddddd  
			} else {
				$text tag configure $tagName -foreground #000000
			}
			break
		}
	}
}

# ClearTargetSelection - end
# ----------------------------------------------------------------------
# SelectFile

proc SelectFile {text tagName {flag {1}}} {
	if $flag {ClearSelection $text}
	set colorFg [$text tag cget $tagName -foreground]
	set colorBg [$text tag cget $tagName -background]
	if {$colorFg == "#ff0000"} {
		if {$colorBg == "#000088"} {
			$text tag configure $tagName \
				-foreground #ff0000 \
				-background #dddddd
		} else {
			$text tag configure $tagName \
				-foreground #ff0000 \
				-background #000088
		}
	} else {
		if {$colorBg == "#000088"} {
			$text tag configure $tagName \
				-foreground #000000 \
				-background #dddddd  
		} else {
			$text tag configure $tagName \
				-foreground #ffffff \
				-background #000088
		}
	}
#	set targetFileSelected no
	foreach tagName2 [$text tag names] {
		set color [$text tag cget $tagName2 -foreground]
		if {$color == "#ff0000"} {
			$text tag configure $tagName2 -background #000088
#			set targetFileSelected yes
			break
		}
	}
#	if {$targetFileSelected == "no"} {
#		$text tag configure $tagName -foreground #ff0000
#	}
}

# SelectFile - end
# ----------------------------------------------------------------------
# ClearSelection

proc ClearSelection {text} {
	foreach tagName [$text tag names] {
		set color [$text tag cget $tagName -foreground]
		$text tag configure $tagName -background #dddddd
		if {$color != "#ff0000"} {
			$text tag configure $tagName -foreground #000000
		}
	}
}

# ClearSelection - end
# ----------------------------------------------------------------------
# XXRepository
# Display the meta content of a repository
# called from DisplayText

proc XXRepository {varName} {
#	global metadataArray
	global referRepository
	global ${referRepository}::conversionTable
	global repositoryProperties
	global referenceTable
	global col
	global homePath
#	global numberOfRep
	global keyRepositoryList
	global environmentArray
	global commonWords
	global citationKeyRepository
	upvar #0 $varName var
	set r $citationKeyRepository
# rep (name of the repository to display)
	if ![regexp {^(.*/.*/.*/.*) .*} $var m rep] {
		regexp {^.* (.*/.*/.*/.*)} $var m rep
	}
	set t .xxrepository.f.t	
	set font [lindex [lindex [$t configure -font] end] 0]
	TextStyles $t
# Repository
	Insert $t insert \
{Repository}
	TagAdd $t bold {Repository}
	$t insert insert \n
	if [info exists repositoryProperties($rep,history)] {
		$t insert insert "$rep " {fixed xxx blue indent}
		$t tag bind xxx <1> "Link $rep"
		$t tag bind xxx <Enter> "$t config -cursor hand2"
		$t tag bind xxx <Leave> "$t config -cursor double_arrow"
	} else {
# $rep is unknown in the srm.conf file
		$t insert insert "$rep " {fixed indent}
	}
	$t insert insert \n\n
# Metadata
	set metadataRepList {}
	foreach index [array names referenceTable *,$rep] {
		regsub {,.*} $index {} metadataRep
		if ![file isdirectory $col/$metadataRep] {
# The metadata repository doesn't exist
			UpdateVariables $metadataRep
#			set numberOfRep [llength $keyRepositoryList]
			regexp .. $varName xx	;# dd
			upvar #0 ${xx}SearchEntry xxSearchEntry
			set environmentArray(${xx}SearchEntry) {}
			set xxSearchEntry {}
			SetIndicator .$xx
#			DiscardRepository $metadataRep metadataArray
		} else {
# The metadata repository exists
			if {[info exists \
				repositoryProperties($metadataRep,targetfile)] && \
				$repositoryProperties($metadataRep,targetfile) == \
				"@metadata.refer"} {
				lappend metadataRepList $metadataRep
			}
		}
	}
#	set metadataRep ""	;# in case of no metatada repository
	foreach metadataRep $metadataRepList {
# >
# The data below are extracted from the "first" metadataRep
	if [catch {open $col/$metadataRep/doc/@metadata.refer r} fileId] {
		puts stderr $fileId
	} else {
		set entry [read $fileId]
		close $fileId
	}
	array set metadataArray [LoadMetadata 0 $entry $metadataRep]
# type
	set type [ReturnType metadataArray $metadataRep-0 1]
# author
	set author $metadataArray($metadataRep-0,$conversionTable($type,%A))
#	set author $metadataArray($metadataRep-0,$type,%A)
# year
	if [info exists metadataArray($metadataRep-0,year)] {
		set year $metadataArray($metadataRep-0,year)
#	if [info exists metadataArray($metadataRep-0,$type,%D)]
#		set year $metadataArray($metadataRep-0,$type,%D)
	} else {
		set year ""
	}
# title
	set title $metadataArray($metadataRep-0,title)
#	set title $metadataArray($metadataRep-0,$type,%T)
	Insert $t insert \
{Metadata}
	TagAdd $t bold {Metadata}
	$t insert insert \n
	foreach name $author {
		$t insert insert "$name" {times indent}
		$t insert insert \n
	}
	$t insert insert " :$year:" fixed
	$t insert insert \n
	$t insert insert "$title" {italic11 wrap indent gray}
	$t insert insert \n\n
# Identification Key
	Insert $t insert \
{Identification Key}
	TagAdd $t bold {Identification Key}
	$t insert insert \n
	$t insert insert " [${r}::CreateKey $author $year $title \
		$commonWords]" fixed
	$t insert insert \n\n
# Document Type
	Insert $t insert \
{Document Type}
	TagAdd $t bold {Document Type}
	$t insert insert \n
	$t insert insert " $metadataArray($metadataRep-0,referencetype)" \
		fixed
#	$t insert insert " $metadataArray($metadataRep-0,$type,%0)" \
		fixed
	$t insert insert \n\n
# Metadata Repository
	if {[llength $metadataRepList] == 1} {
		Insert $t insert \
{Metadata Repository}
		TagAdd $t bold {Metadata Repository}
	} else {
		Insert $t insert \
{Metadata Repositories}
		TagAdd $t bold {Metadata Repositories}
	}
	$t insert insert \n
	foreach metadataRep $metadataRepList {
		$t insert insert "$metadataRep " \
			"fixed9 $metadataRep blue indent"
		$t tag bind $metadataRep <1> "Link $metadataRep"
		$t tag bind $metadataRep <Enter> "$t config \
		-cursor hand2"
		$t tag bind $metadataRep <Leave> "$t config \
			-cursor double_arrow"
		$t insert insert \n
	}
	$t insert insert \n
	break
# <
	}
# History
	if [info exists repositoryProperties($rep,history)] {
		Insert $t insert \
{Version History}
		TagAdd $t bold {Version History}
		$t insert insert \n
		set i 0
		foreach version $repositoryProperties($rep,history) {
			$t mark set firstLine "insert -$i line"
			$t insert firstLine "$version\n" {indent wrap fixed9}
			incr i
		}
		$t insert insert \n
	}
# Cited Repository
	set indices [lsort [array names referenceTable $rep,*]]
	if {[llength $indices] != 0} {
		if {[llength $indices] == 1} {
			Insert $t insert \
{Cited Repository}
			TagAdd $t bold {Cited Repository}
		} else {
			Insert $t insert \
{Cited Repositories}
			TagAdd $t bold {Cited Repositories}
		}
		$t insert insert \n
		foreach index $indices {
			regsub {.*,} $index {} calledRep
			$t insert insert "$calledRep " \
				"fixed9 $calledRep blue indent"
			$t tag bind $calledRep <1> "Link $calledRep"
			$t tag bind $calledRep <Enter> "$t config \
				-cursor hand2"
			$t tag bind $calledRep <Leave> "$t config \
				-cursor double_arrow"
			$t insert insert \n
		}
		$t insert insert \n
	}
# File List
	set dir $homePath/col/$rep/doc
	set fileList {}
	DirectoryContent fileList $dir $dir
	Insert $t insert \
{File List}
	TagAdd $t bold {File List}
	$t configure -font {courier 11}
	$t insert insert \n
	foreach file [lsort -dictionary $fileList] {
		eval [list $t insert insert " $file " [list $file]]
#		eval [list $t tag bind $file <1> \
			"SelectTargetFile $t {$file} $rep"]
# /clear cannot be a file name
#		$t insert insert \n /clear
		$t insert insert \n
	}
#	$t tag bind /clear <1> "ClearTargetSelection $t"
# target file
	ClearTargetSelection $t
	if [info exists repositoryProperties($rep,targetfile)] {
		set targetFile $repositoryProperties($rep,targetfile)
		if [file exists $homePath/col/$rep/doc/$targetFile] {
			$t tag configure \
				$repositoryProperties($rep,targetfile) \
				-foreground #ff0000
		} else {
# target file has been deleted
#			unset repositoryProperties($rep,targetfile)
#			StartApacheServer
		}
	}
#	$t configure -state disabled
}

# XXRepository - end
# ----------------------------------------------------------------------
# Link
# examples:
# Link dpi.inpe.br/banon/1998/08.02.08.56
# Link {} banon-pc.dpi.inpe.br:1905

proc Link {rep {serverAddress {}}} {
	global environmentArray
#	global repositoryProperties
	global URLibServiceRepository
	if {$serverAddress == ""} {
		set hostName $environmentArray(hostName)
		set domainName $environmentArray(domainName)
		set portNumber $environmentArray(spPortEntry)
		set serverAddress $hostName.$domainName:$portNumber
		set path col/$URLibServiceRepository/doc/goto-/$rep
	} else {
		set path ""
	}
	if {$environmentArray(spBrowserEntry) == "Netscape"} {
		exec "$environmentArray(netscape)" http://$serverAddress/$path &
	}
	if {$environmentArray(spBrowserEntry) == "Internet Explorer"} {
		exec "$environmentArray(internetExplorer)" http://$serverAddress/$path &
	}
}

# XXRepository - end
# ----------------------------------------------------------------------
# FindTargetFile
# example:
# FindTargetFile .xxdirectory.f.t
# returns the target file name (the name in red)

proc FindTargetFile {text} {
	if [winfo exists $text] {
		foreach tagName [$text tag names] {
			set color [$text tag cget $tagName -foreground]
			if {$color == "#ff0000"} {
				return $tagName
			}
		}
	}
}

# FindTargetFile - end
# ----------------------------------------------------------------------
# SetInitialValue

proc SetInitialValue {varName default} {
	global environmentArray
	upvar #0 $varName var
	if [info exists environmentArray($varName)] {
		set var $environmentArray($varName)
	} else {
		set var $default
		set environmentArray($varName) $default
	}
}

# SetInitialValue - end
# ----------------------------------------------------------------------
# SetIndicator
# example: 2/12/24
# puts $win
# => .dd

proc SetIndicator {win {numberOfRep {0}}} {
	global environmentArray
	global keyRepositoryList
#	global metadataRepList
	global metadataArray
	if {$numberOfRep == 0} {
		set numberOfRep [llength $keyRepositoryList]
	}
	regexp {.(..)} $win m xx	;# dd
	upvar #0 ${xx}SearchResult xxSearchResult
	upvar #0 ${xx}SearchEntry xxSearchEntry
	upvar #0 ${xx}Choice2 xxChoice2
	if {[info exists xxSearchEntry] && $xxSearchEntry != ""} {
#	if [info exists xxSearchResult] doesn't work when cancels search
#		set numberOfmetadataRep [llength $metadataRepList]
		set numberOfmetadataRep [llength \
			[array names metadataArray *,repository]]
		set selectedRepList {}
		foreach metadataRep-i $xxSearchResult {
# puts ${metadataRep-i}
			if ![regexp -- {-0$} ${metadataRep-i}] {continue}
			regsub -- {-[^-]*$} ${metadataRep-i} {} metadataRep
			set rep [ReturnRepositoryName $metadataRep]
#			if [info exists metadataArray(${metadataRep-i},Repository)] {
#				set rep $metadataArray(${metadataRep-i},Repository)
				if {[lsearch -exact $selectedRepList $rep] == -1} {
					lappend selectedRepList $rep
				}
#			}
		}
		set numberOfSelectedRep [llength $selectedRepList]
		set indicator \
			$numberOfSelectedRep/$numberOfmetadataRep/
		if [winfo exists $win.rep.h1.h2.v2.entry.button5.5] {
			$win.rep.h1.h2.v2.entry.button5.5 configure \
				-state disabled
		}
	} else {
		set indicator ""
		if {[winfo exists $win.rep.h1.h2.v2.entry.button5.5] && \
			$xxChoice2 == "repository"} {
			$win.rep.h1.h2.v2.entry.button5.5 configure \
				-state normal
		}
	}
	$win.rep.h1.h1.lb configure -text $indicator$numberOfRep \
		-fg #000000
}

# SetIndicator - end
# ----------------------------------------------------------------------
# CancelSearch

proc CancelSearch {widget entryName varName} {
	regexp {.(..)} $widget win xx	;# .dd dd
	upvar #0 ${xx}Search search	;# ddSearch
	if ![info exists search] {return}
	if !$search {
		upvar #0 ${xx}SearchEntry xxSearchEntry
		if [info exists xxSearchEntry] {
			set xxSearchEntry {}
			SetIndicator $win
			UpdateMenu $widget $entryName $varName
		}
	}
}

# CancelSearch - end
# ----------------------------------------------------------------------