Eskil

2018-01-14
 Process directory diff in a nicer order.

2018-01-11
 Bumped revision to 2.8.1
 Corrected detected of Emacs for Registry. (Broken in 2.7.4)

2017-12-28
 Pause before a large file in dirdiff processing to make it clear where it is
 slowed down.

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

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

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

        # Directory Diff only supports one plugin.

            if {[winfo exists $w]} {
                $w configure -state disabled
            }
        }
        dict set widgets $side {}
    }

    method AddNodeToIdle {node {first 0}} {
        if {[info exists IdleQueueArr($node)]} { return }
        if {$first} {
            # Items are popped from the end, so last is first
            lappend IdleQueue $node
        } else {
            # Avoid compiled linsert by having index in a variable
            set c0 0
            set IdleQueue [linsert $IdleQueue[set IdleQueue {}] $c0 $node]
        }

        set IdleQueueArr($node) 1

        if {$AfterId eq ""} {
            set AfterId [after $AfterTime [mymethod UpdateIdle]]
        }
    }
    # Debug logging
    method Dlog {args} {
        if {$DebugCh ne ""} {
            set msg [join $args]
            set now [clock clicks -milliseconds]
            set suffix ""
            if {[dict exists $DebugTime $msg]} {
                set delta [expr {$now - [dict get $DebugTime $msg]}]
                set suffix " (+$delta)"
            }
            dict set DebugTime $msg $now
            puts $DebugCh "$now $msg$suffix"
            flush $DebugCh
        }
    }
    method DlogTablelist {} {
        puts DlogTablelist
        foreach cmd [info commands ::tablelist::*] {
            set tail [namespace tail $cmd]
            #if {[string match *SubCmd $tail]} continue
            if {$tail in {
                synchronize
                tablelistWidgetCmd cleanupWindow getTablelistPath
                handleMotion handleMotionDelayed
                rowIndex isInteger keyToRow colIndex
            }} continue
            
            trace add execution $cmd enter [mymethod Dlog]
            puts "Traced $cmd"
        }
    }
    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 end]
            # 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[set IdleQueue {}] 0 end-1]
            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 200 ms to keep things efficient
            set post [clock clicks -milliseconds]
            if {($post - $pre) > 200} 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 end]
            set leftfull [$tree rowattrib $node leftfull]
            set rightfull [$tree rowattrib $node rightfull]
            if {$leftfull ne ""} {
                set statusvar "$leftfull  ($count)"
            } else {
                set statusvar "$rightfull  ($count)"
            }

            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 \
                    "" \

                $tree cellconfigure $id,command -window [mymethod addCmdCol]
            }
        }

        if {$type eq "directory"} {
            ## Make it so that this node is openable
            $tree collapse $id


            $self SetNodeStatus $id empty
            $self AddNodeToIdle $id 1

        } elseif {$size1 == ""} {
            $self SetNodeStatus $id new
        } elseif {$size2 == ""} {
            $self SetNodeStatus $id old
        } else {
            $self SetNodeStatus $id unknown
            $self AddNodeToIdle $id