Eskil

    variable leftDir ""
    variable rightDir ""

    constructor {args} {
        variable color
        install tree using tablelist::tablelist $win.tree -height 20 \
                -movablecolumns no -setgrid no -showseparators yes \
                -columns {0 "Structure" 0 "" 0 "" 0 "" 0 Name 0 Size 0 Date 0 "" 0 Name 0 Size 0 Date}
        install vsb using scrollbar $win.vsb -orient vertical \
                -command "$tree yview"
        install hsb using scrollbar $win.hsb -orient horizontal \
                -command "$tree xview"

        set AfterId ""
        set IdleQueue {}

        $tree configure -yscrollcommand "$vsb set" -xscrollcommand "$hsb set"

        $tree columnconfigure 0 -name structure
        $tree columnconfigure 1 -name type -hide 1
        $tree columnconfigure 2 -name status -hide 1
        $tree columnconfigure 3 -name leftfull -hide 1
        $tree columnconfigure 4 -name leftname -hide 1
        $tree columnconfigure 5 -name leftsize -align right
        $tree columnconfigure 6 -name leftdate
        $tree columnconfigure 7 -name rightfull -hide 1
        $tree columnconfigure 8 -name rightname -hide 1
        $tree columnconfigure 9 -name rightsize -align right
        $tree columnconfigure 10 -name rightdate

        set color(unknown) grey
        set color(empty) grey
        set color(equal) {}
        set color(new) green
        set color(old) blue
        set color(change) red

        set d1 [file tail $leftDir]
        set d2 [file tail $rightDir]
        if {$d1 eq $d2} {
            $tree cellconfigure $topIndex,structure -text $d1
        } else {
            $tree cellconfigure $topIndex,structure -text "$d1 vs $d2"
        }
        $tree cellconfigure $topIndex,type -text directory
        $self SetNodeStatus $topIndex empty
        $tree cellconfigure $topIndex,leftfull  -text $leftDir             
        $tree cellconfigure $topIndex,leftname  -text [file tail $leftDir] 
        $tree cellconfigure $topIndex,rightfull -text $rightDir            
        $tree cellconfigure $topIndex,rightname -text [file tail $rightDir]

        $self UpdateDirNode $topIndex
    }

    # Format a time stamp for display
    proc FormatDate {date} {
        clock format $date -format "%Y-%m-%d %H:%M:%S"
    }

    # Remove all equal nodes from tree
    method PruneEqual {} {
        set todo [$tree childkeys root]
        while {[llength $todo] > 0} {
            set todoNow $todo
            set todo {}
            foreach node $todoNow {
                set status [$tree cellcget $node,status -text]
                if {$status eq "equal"} {
                    $tree delete $node
                } else {
                    lappend todo {*}[$tree childkeys $node]
                }
            }
        }

        }
    }

    # Copy a file from one directory to the other
    method CopyFile {node from} {
        global dirdiff Pref

        set lf [$tree cellcget $node,leftfull -text]
        set rf [$tree cellcget $node,rightfull -text]
        set parent [$tree parent $node]
        set lp [$tree cellcget $parent,leftfull -text]
        set rp [$tree cellcget $parent,rightfull -text]

        if {$from eq "left"} {
            set src $lf
            if {$rf ne ""} {
                set dst $rf
            } elseif {$rp ne ""} {
                set dst [file join $rp [file tail $src]]

    }

    # React on double-click
    method DoubleClick {W x y} {
        foreach {W x y} [tablelist::convEventFields $W $x $y] break
        set node [$tree index @$x,$y]

        set lf [$tree cellcget $node,leftfull -text]
        set rf [$tree cellcget $node,rightfull -text]
        set type [$tree cellcget $node,type -text]

        # On a file that exists on both sides, start a file diff
        if {$type eq "file" && $lf ne "" && $rf ne ""} {
            set PauseBgProcessing 1
            newDiff $lf $rf
            set PauseBgProcessing 0
            # Stop the default bindings from running
            return -code break
        }
    }
    # React on Return key
    method KeyReturn {} {
        set node [$tree focus]
        if {$node eq ""} return

        set lf [$tree cellcget $node,leftfull -text]
        set rf [$tree cellcget $node,rightfull -text]
        set type [$tree cellcget $node,type -text]

        # On a file that exists on both sides, start a file diff
        if {$type eq "file" && $lf ne "" && $rf ne ""} {
            set PauseBgProcessing 1
            newDiff $lf $rf
            set PauseBgProcessing 0
            # Stop the default bindings from running
            return -code break
        }
    }

    # Bring up a context menu on a file.
    method ContextMenu {W x y X Y} {
        foreach {W x y} [tablelist::convEventFields $W $x $y] break

        set node [$tree index @$x,$y]
        set col [$tree columnindex @$x,$y]
        set colname [$tree columncget $col -name]

        set lf [$tree cellcget $node,leftfull -text]
        set rf [$tree cellcget $node,rightfull -text]
        set type [$tree cellcget $node,type -text]
        set oneside [expr {($lf ne "") ^ ($rf ne "")}]

        set m $win.popup
        destroy $m
        menu $m
        
        if {$colname eq "structure"} {

        set pre [clock clicks -milliseconds]
        set errors {}
        while {[llength $IdleQueue] > 0} {
            set node [lindex $IdleQueue 0]
            set IdleQueue [lrange $IdleQueue 1 end]
            unset IdleQueueArr($node)

            if {[$tree cellcget $node,type -text] ne "directory"} {
                set sts [catch {$self UpdateFileNode $node} err]
            } else {
                set sts [catch {$self UpdateDirNode $node} err]
            }
            if {$sts} {
                lappend errors $err
            }

                set statusvar ""
                set AfterId ""
                return
            }
        }

        if {[llength $IdleQueue] > 0} {
            set leftfull [$tree cellcget $node,leftfull -text]
            set rightfull [$tree cellcget $node,rightfull -text]
            if {$leftfull ne ""} {
                set statusvar $leftfull
            } else {
                set statusvar $rightfull
            }

            set AfterId [after 1 [mymethod UpdateIdle]]
        } else {
            set statusvar ""
            set AfterId ""
        }
    }

    method SetNodeStatus {node status} {
        variable color
        $tree cellconfigure $node,status -text $status
        $tree rowconfigure $node -foreground $color($status) \
                -selectforeground $color($status)
        #puts "Set [$tree item $node -text] to $status"

        # Loop through children to update parent
        set parent [$tree parentkey $node]
        if {$parent eq "" || $parent eq "root"} { return }

        # If this is only present on one side, there is no need to update
        set lf [$tree cellcget $parent,leftfull -text]
        set rf [$tree cellcget $parent,rightfull -text]
        if {$lf eq "" || $rf eq ""} { return }

        set pstatus equal
        foreach child [$tree childkeys $parent] {
            set status [$tree cellcget $child,status -text]
            switch $status {
                unknown {
                    set pstatus unknown
                    break
                }
                new - old - change {
                    set pstatus change

                }
            }
        }
        #puts "Setting parent [$tree set $parent leftname] to $pstatus"
        $self SetNodeStatus $parent $pstatus
    }

    method UpdateDirNode {node} {
        if {[$tree cellcget $node,type -text] ne "directory"} {
            return
        }
        if {[$tree cellcget $node,status -text] ne "empty"} {
            #puts "Dir [$tree set $node leftfull] already done"
            return
        }
        $tree delete [$tree childkeys $node]

        set leftfull [$tree cellcget $node,leftfull -text]
        set rightfull [$tree cellcget $node,rightfull -text]
        $self CompareDirs $leftfull $rightfull $node
    }

    method UpdateFileNode {node} {
        set leftfull [$tree cellcget $node,leftfull -text]
        set rightfull [$tree cellcget $node,rightfull -text]
        set equal [CompareFiles $leftfull $rightfull]
        if {$equal} {
            $self SetNodeStatus $node equal
        } else {
            $self SetNodeStatus $node change
        }
            

            set showleft ""
            set showright ""
            if {$df1 eq ""} {
                set showright $name/
            } elseif {$df2 eq ""} {
                set showleft $name/
            } 
            set values [list $name $type unknown \
                    $df1 $showleft "" "" \
                    $df2 $showright "" ""]
        } else {
            set name1 [file tail $df1]
            set name2 [file tail $df2]
            set values [list $name $type unknown \
                    $df1 $name1 $size1 $time1 \
                    $df2 $name2 $size2 $time2]
        }
        set id [$tree insertchild $node end $values]





        if {$type eq "directory"} {
            ## Make it so that this node is openable
            $tree collapse $id
            #$tree insertchild $id end dummy ;# a dummy
            $tree cellconfigure $id,structure -text $name/
            $self SetNodeStatus $id empty
            $self AddNodeToIdle $id
        } elseif {$size1 == $size2 && \
                $time1 == $time2} {
            $self SetNodeStatus $id equal
        } elseif {$size1 == ""} {
            $self SetNodeStatus $id new
        } elseif {$size2 == ""} {
            $self SetNodeStatus $id old
        } else {
            $self SetNodeStatus $id unknown
            $self AddNodeToIdle $id
        }
        return [$tree cellcget $id,status -text]
    }

    # Compare two directories.
    method CompareDirs {dir1 dir2 node} {
        global Pref
        if {$dir1 eq ""} {
            set files1 {}