Eskil

    option -leftdirvariable  -default "" -configuremethod SetDirOption
    option -rightdirvariable -default "" -configuremethod SetDirOption
    option -statusvar -default ""
    option -changelist -default ""

    variable AfterId ""
    variable DebugCh ""
    variable PauseBgProcessing 0
    variable ScheduledRestart 0
    variable AfterTime 1
    variable IdleQueue {}
    variable IdleQueueArr
    variable leftMark ""
    variable rightMark ""

    }

    method ReStart {} {
        # Delete all idle processing
        if {$AfterId ne ""} {
            after cancel $AfterId
        }
        if {$DebugCh ne ""} {
            close $DebugCh
            set DebugCh ""
        }
        # Uncomment to activate debug logging
        #set DebugCh [open ~/dirdiff.log a]
        set AfterId ""
        set IdleQueue {}
        set ScheduledRestart 0
        array unset IdleQueueArr
        set protect {left 0 right 0}

        # Directory Diff only supports one plugin.

        if {[info exists IdleQueueArr($node)]} { return }
        lappend IdleQueue $node
        set IdleQueueArr($node) 1

        if {$AfterId eq ""} {
            set AfterId [after $AfterTime [mymethod UpdateIdle]]
        }
    }
    # Debug logging
    method Dlog {msg} {
        if {$DebugCh ne ""} {
            puts $DebugCh "[clock clicks -milliseconds] $msg"
            flush $DebugCh
        }
    }
    method UpdateIdle {} {
        $self Dlog UpdateIdle
        set AfterId "X"

        if {$PauseBgProcessing} {
            $self Dlog Pause
            set AfterId [after 200 [mymethod UpdateIdle]]
            return
        }

        set pre [clock clicks -milliseconds]
        set errors {}
        set count 0
        while {[llength $IdleQueue] > 0} {
            set node [lindex $IdleQueue 0]
            # Always make a pause before a large file
            if {[$tree rowattrib $node type] ne "directory"} {
                if {[$tree rowattrib $node largefile]} {
                    if {$count > 0} {
                        $self Dlog "New Lap for large file"
                        break
                    }
                }
            }
            incr count
            set IdleQueue [lrange $IdleQueue 1 end]
            unset IdleQueueArr($node)

            if {[$tree rowattrib $node type] ne "directory"} {
                set sts [catch {$self UpdateFileNode $node} err]
            } else {
                set sts [catch {$self UpdateDirNode $node} err]
            }
            if {$sts} {
                lappend errors $node $err
                break
            }
            # Work for at least 50 ms to keep things efficient
            set post [clock clicks -milliseconds]
            if {($post - $pre) > 50} break
        }
        #if {($post - $pre) > 1000} {
            #puts "[expr $post - $pre] ms for [$tree set $node leftfull]"
        #}

        # Update the status variable to track progress
        if {$options(-statusvar) ne ""} {

                set statusvar ""
                set AfterId ""
                return
            }
        }

        if {[llength $IdleQueue] > 0} {
            set node [lindex $IdleQueue 0]
            set leftfull [$tree rowattrib $node leftfull]
            set rightfull [$tree rowattrib $node rightfull]
            if {$leftfull ne ""} {
                set statusvar "$leftfull  ($count)"
            } else {
                set statusvar "$rightfull  ($count)"
            }

            $self Dlog Reschedule
            set AfterId [after $AfterTime [mymethod UpdateIdle]]
        } else {
            $self Dlog DONE
            set statusvar ""
            set AfterId ""
        }
    }

    method SetNodeStatus {node status} {
        variable color

            #puts "Dir [$tree set $node leftfull] already done"
            return
        }
        $tree delete [$tree childkeys $node]

        set leftfull [$tree rowattrib $node leftfull]
        set rightfull [$tree rowattrib $node rightfull]
        #$self Dlog "UpdateDirNode $leftfull"
        $self CompareDirs $leftfull $rightfull $node
    }

    method UpdateFileNode {node} {
        set leftfull [$tree rowattrib $node leftfull]
        set rightfull [$tree rowattrib $node rightfull]
        #$self Dlog "UpdateFileNode $leftfull"
        # If a -changelist is given, some higher level optimisation has already
        # figured out what has changed, so the processing time can be cut down.
        if {[llength $options(-changelist)]} {
            if {$rightfull ni $options(-changelist)} {
                #puts "$rightfull equal since not in change list"
                $self SetNodeStatus $node equal
                return

        if {$df1 ne ""} {
            set type $type1
            set name [file tail $df1]
        } else {
            set type $type2
            set name [file tail $df2]
        }
        set largeFile 0
        if {$type eq "directory"} {
            set values [list $name \
                    "" "" \
                    "" \
                    "" ""]
        } else {
            set values [list $name \
                    $size1 $time1 \
                    "" \
                    $size2 $time2]
            # TODO: Configurable large file value?
            if {$size1 > 1000000 && $size2 > 1000000} {
                set largeFile 1
            }
        }
        set id [$tree insertchild $node end $values]
        $tree rowattrib $id type $type
        $tree rowattrib $id status unknown
        $tree rowattrib $id leftfull $df1
        $tree rowattrib $id rightfull $df2
        $tree rowattrib $id largefile $largeFile
        if {$type ne "directory"} {
            if {$type eq "link"} {
                $tree cellconfigure $id,structure -image $::img(link)
            } else {
                $tree cellconfigure $id,structure -image $::img(file)
                $tree cellconfigure $id,command -window [mymethod addCmdCol]
            }