Eskil

            close $ch1
            close $ch2
        }
    }
    return $eq
}

# Returns the contents of a directory as a sorted list of full file paths.
proc DirContents {dir} {
# Returns the contents of a directory as a sorted list of file dicts
# By collecting as much as possible in one place, this prepares for a
# future expansion into revision control support in dirdiff.
proc DirContentsDRaw {dir} {
    if {$::tcl_platform(platform) eq "windows"} {
        # .-files are not treated specially on windows. * is enough to get all
        set files [glob -directory $dir -nocomplain *]
    } else {
        set files [glob -directory $dir -nocomplain * {.[a-zA-Z]*}]
    }
    set result {}
    foreach file [lsort -dictionary $files] {
        set fD [dict create "full" $file]
        dict set fD tail [file tail $file]
        dict set fD dir [FileIsDirectory $file]
        if {[catch {file stat $file stat}]} {
            dict set fD size ""
            dict set fD mtime ""
            dict set fD type ""
        } else {
            dict set fD size $stat(size)
            dict set fD mtime $stat(mtime)
            dict set fD type $stat(type)
        }
        lappend result $fD
    }
    return $result
}

# Returns the contents of a directory as a sorted list of dicts, after applying
# filter preferences.
proc DirContentsD {dir} {
    set filesD [DirContentsDRaw $dir]

    if {$::Pref(dir,onlyrev)} {
        # FIXA: move to rev and make general for other systems
        # FIXA: obsolete, not updated since before dictinaries were used
        set entries [file join $dir CVS Entries]
        if {[file exists $entries]} {
            set ch [open $entries r]
            set data [read $ch]
            close $ch
            foreach line [split $data \n] {
                set name [lindex [split $line /] 1]
                set controlled($name) 1
        #set entries [file join $dir CVS Entries]
        #if {[file exists $entries]} {
        #    set ch [open $entries r]
        #    set data [read $ch]
        #    close $ch
        #    foreach line [split $data \n] {
        #        set name [lindex [split $line /] 1]
        #        set controlled($name) 1
            }
            set files2 {}
            foreach file $files {
                if {[info exists controlled($file)]} {
                    lappend files2 $file
        #    }
        #    set files2 {}
        #    foreach file $files {
        #        if {[info exists controlled($file)]} {
        #            lappend files2 $file
                }
            }
            set files $files2
        }
    }
        #        }
        #    }
        #    set files $files2
        #}
    }


    set files2 {}
    foreach file $files {
        set full $file
        set tail [file tail $file]
    set filesD2 {}
    foreach fileD $filesD {
        set full [dict get $fileD full]
        set tail [dict get $fileD tail]
        set isDir [dict get $fileD "dir"]
        # Apply filters
        if {[FileIsDirectory $full]} {
        if {$isDir} {
            if {[llength $::Pref(dir,incdirs)] == 0} {
                set allowed 1
            } else {
                set allowed 0
                foreach pat $::Pref(dir,incdirs) {
                    if {[string match $pat $tail]} {
                        set allowed 1

                        set allowed 0
                        break
                    }
                }
            }
            if {!$allowed} continue
        }
        lappend files2 $full
        lappend filesD2 $fileD
    }

    return [Fsort $files2]
    return $filesD2
}

# Bring up an editor to display a file.
proc EditFile {file} {
    locateEditor ::util(editor)
    exec $::util(editor) $file &
}

            $w.bl configure -state disabled
        }
    }

    # Compare two directories.
    method CompareDirs {dir1 dir2 node} {
        if {$dir1 eq ""} {
            set files1 {}
            set filesD1 {}
        } else {
            set files1 [DirContents $dir1]
            set filesD1 [DirContentsD $dir1]
        }
        if {$dir2 eq ""} {
            set files2 {}
            set filesD2 {}
        } else {
            set files2 [DirContents $dir2]
            set filesD2 [DirContentsD $dir2]
        }

        set len1 [llength $files1]
        set len2 [llength $files2]
        set len1 [llength $filesD1]
        set len2 [llength $filesD2]

        set p1 0
        set p2 0
        set status_change 0
        set status_unknown 0
        while 1 {
            if {$p1 < $len1 && $p2 < $len2} {
                set df1 [lindex $files1 $p1]
                set f1 [file tail $df1]
                set df2 [lindex $files2 $p2]
                set f2 [file tail $df2]
                set fD1 [lindex $filesD1 $p1]
                set df1 [dict get $fD1 full]
                set f1  [dict get $fD1 tail]
                set fD2 [lindex $filesD2 $p1]
                set df2 [dict get $fD2 full]
                set f2  [dict get $fD1 tail]
                set apa [FStrCmp $f1 $f2]
                if {$apa == 0} {
                    # Equal names, separate them if not the same type
                    set apa [expr {- [FileIsDirectory $df1] \
                                   + [FileIsDirectory $df2]}]
                    set apa [expr {- [dict get $fD1 dir] \
                                   + [dict get $fD2 dir]}]
                }

                switch -- $apa {
                    0 {
                        set sts [$self ListFiles $df1 $df2 $node]
                        incr p1
                        incr p2

                    1 {
                        $self ListFiles "" $df2 $node
                        incr p2
                        set status_change 1
                    }
                }
            } elseif {$p1 < $len1 && $p2 >= $len2} {
                set df1 [lindex $files1 $p1]
                set fD1 [lindex $filesD1 $p1]
                set df1 [dict get $fD1 full]
                $self ListFiles $df1 "" $node
                incr p1
                set status_change 1
            } elseif {$p1 >= $len1 && $p2 < $len2} {
                set df2 [lindex $files2 $p2]
                set fD2 [lindex $filesD2 $p1]
                set df2 [dict get $fD2 full]
                $self ListFiles "" $df2 $node
                incr p2
                set status_change 1
            } else {
                break
            }
        }