Eskil

#-----------------------------------------------
# $Revision$
#-----------------------------------------------
# the next line restarts using wish \
exec wish "$0" "$@"

set debug 1
set diffver "Version 1.9.4b  2002-05-14"
set tmpcnt 0
set tmpfiles {}
set thisscript [file join [pwd] [info script]]
set thisdir [file dirname $thisscript]
set ::diff(cvsExists) [expr {![string equal [auto_execok cvs] ""]}]
set ::diff(diffexe) diff
set ::diff(diffutil) [expr {![catch {package require DiffUtil}]}]

if {[info exists env(TEMP)]} {
    set ::diff(tmpdir) $env(TEMP)
} elseif {[info exists env(TMP)]} {
    set ::diff(tmpdir) $env(TMP)
} else {
    if {$tcl_platform(platform) == "windows"} {

        auto_reset
        set ::diff(cvsExists) [expr {![string equal [auto_execok cvs] ""]}]
    }
}

proc cleanupAndExit {} {
    if {$::diff(diffexe) != "diff"} {
        catch {file delete $::diff(diffexe)}
    }
    cleartmp
    exit
}

# Format a line number
proc myforml {lineNo} {

    set name [file join $::diff(tmpdir) "tmpd[pid]a$::tmpcnt"]
    lappend ::tmpfiles $name
    return $name
}

proc cleartmp {} {
    foreach f $::tmpfiles {
        catch {file delete $f}
    }
    set ::tmpfiles {}
}

# 2nd stage line parsing
# Recursively look for common substrings in strings s1 and s2
##syntax compareMidString x x n n x?

        compareMidString $left1 $left2 left1 left2 $test
        compareMidString $right1 $right2 right1 right2 $test

        set res1 [concat $left1 [list $mid1] $right1]
        set res2 [concat $left2 [list $mid2] $right2]
    }
}

proc compareLinesX {line1 line2 res1Name res2Name {test 0}} {
    global Pref
    upvar $res1Name res1
    upvar $res2Name res2

    set args "$Pref(ignore)\
            [expr {($Pref(lineparsewords) && !$test) ? "-word" : ""}]"
    eval DiffUtil::compareLines $args \$line1 \$line2 res1 res2
}

# Compare two lines to find inequalities to highlight.
# The return value is, for each line, a list where the first, third etc.
# element is equal between the lines. The second, fourth etc. will be
# highlighted.
##syntax compareLines x x n n x?
proc compareLines {line1 line2 res1Name res2Name {test 0}} {

            }
            set t1 $s1
            set t2 $s2
        }
    }

    # Make the result
    if {$leftp1 > $t1 && $leftp2 > $t2} {
        set res1 [list $line1]
        set res2 [list $line2]
    } else {
        set right1 [string range $line1 [expr {$t1 + 1}] end]
        set mid1 [string range $line1 $leftp1 $t1]
        set left1 [string range $line1 0 [expr {$leftp1 - 1}]]
        set res1 [list $left1 $mid1 $right1]




        set right2 [string range $line2 [expr {$t2 + 1}] end]
        set mid2 [string range $line2 $leftp2 $t2]
        set left2 [string range $line2 0 [expr {$leftp2 - 1}]]
        set res2 [list $left2 $mid2 $right2]

        if {$Pref(extralineparse) != 0 && $mid1 != "" && $mid2 != ""} {
            compareMidString $mid1 $mid2 mid1 mid2 $test
            # Replace middle element in res* with list elements from mid*
            #set res1 [eval lreplace \$res1 1 1 $mid1]
            #set res2 [eval lreplace \$res2 1 1 $mid2]
            # This makes use of pure-list optimisation in eval
            set res1 [eval [linsert $mid1 0 lreplace $res1 1 1]]
            set res2 [eval [linsert $mid2 0 lreplace $res2 1 1]]
        }
    }
}

# Compare two lines and rate how much they resemble each other.
# This has never worked well. Some day I'll sit down, think this through,
# and come up with a better algorithm.
proc compareLines2 {line1 line2} {
    compareLines $line1 $line2 res1 res2 1
    if {$::diff(diffutil)} {
        compareLinesX $line1 $line2 xres1 xres2 1
        if {$res1 != $xres1 || $res2 != $xres2} {
            tk_messageBox -title "Rate Mismatch!" \
                    -message ":$res1:\n:$res2:\n:$xres1:\n:$xres2:"
        }
    }
    # Collect identical pieces and different pieces
    set sames {}
    set diffs1 {}
    set diffs2 {}
    foreach {same diff} $res1 {
        lappend sames $same
        if {$diff != ""} {

# Insert one line in each text widget.
# Mark them as changed, and optionally parse them.
proc insertMatchingLines {line1 line2} {
    global doingLine1 doingLine2 Pref

    if {$Pref(parse) != 0} {
        compareLines $line1 $line2 res1 res2
        if {$::diff(diffutil)} {
            compareLinesX $line1 $line2 xres1 xres2
            if {$res1 != $xres1 || $res2 != $xres2} {
                tk_messageBox -title Mismatch! \
                        -message ":$res1:\n:$res2:\n:$xres1:\n:$xres2:"
            }
        }
        set dotag 0
        set n [maxabs [llength $res1] [llength $res2]]
        .ft1.tl insert end [myforml $doingLine1] "hl$::HighLightCount change"
        .ft2.tl insert end [myforml $doingLine2] "hl$::HighLightCount change"
        set new1 new1
        set new2 new2
        set change change

        .ft1.tl insert end "\n"
        .ft2.tl insert end "\n"
    }

    # Process the block

    if {$n1 == $n2 && ($n1 == 1 || $Pref(parse) < 2)} {
        # Never do block parsing for one line blocks.
        # If block parsing is turned off, only do line parsing for
        # blocks of equal size.
        for {set t 0} {$t < $n1} {incr t} {
            gets $ch1 textline1
            gets $ch2 textline2
            insertMatchingLines $textline1 $textline2
        }
        lappend changesList $mapMax $n1 change $line1 $n1 $line2 $n2
        incr mapMax $n1
    } else {
        if {$n1 != 0 && $n2 != 0 && $Pref(parse) >= 2 && \
                ($n1 * $n2 < 1000 || $Pref(parse) == 3)} {
            # Full block parsing
            set block1 {}
            for {set t 0} {$t < $n1} {incr t} {
                gets $ch1 apa
                lappend block1 $apa
            }
            set block2 {}
            for {set t 0} {$t < $n2} {incr t} {
                gets $ch2 apa
                lappend block2 $apa
            }
            set apa [insertMatchingBlocks $block1 $block2]

            lappend changesList $mapMax $apa change \
                    $line1 $n1 $line2 $n2
            incr mapMax $apa
        } else {
            # No extra parsing at all.
            for {set t 0} {$t < $n1} {incr t} {
                gets $ch1 apa
                insert 1 $doingLine1 $apa $tag1
                incr doingLine1
            }
            for {set t 0} {$t < $n2} {incr t} {
                gets $ch2 apa

    global diff Pref

    cleartmp
    set diff(rightFile) $diff(conflictFile)
    set diff(leftFile) $diff(conflictFile)
}

# Display one chunk from a patch file
proc displayOnePatch {leftLines rightLines leftLine rightLine} {
    emptyline 1
    emptyline 2

    set leftlen [llength $leftLines]
    set rightlen [llength $rightLines]

        return
    } else {
        enableRedo
    }

    busyCursor

    # Clear up everything before starting processing
    foreach w {.ft1.tl .ft1.tt .ft2.tl .ft2.tt} {
        $w configure -state normal
        $w delete 1.0 end
    }
    set changesList {}
    set mapMax 0
    set ::HighLightCount 0
    highLightChange -1
    drawMap -1
    # Display a star during diff execution, to know when the internal
    # processing starts, and when the label is "valid".
    set ::diff(eqLabel) "*"

    update idletasks

    if {$diff(mode) == "patch"} {
        displayPatch
        drawMap -1

    } elseif {$diff(mode) == "RCS" || $diff(mode) == "CVS"} {
        prepareRCS
    } elseif {[string match "conflict*" $diff(mode)]} {
        prepareConflict
    }

    # Run diff and parse the result.
    if {$::diff(diffutil)} {
        set differr [catch {eval DiffUtil::diffFiles $Pref(ignore) \
                \$diff(leftFile) \$diff(rightFile)} diffres]
    } else {
        set differr [catch {eval exec \$::diff(diffexe) \
                $Pref(dopt) $Pref(ignore) \
                \$diff(leftFile) \$diff(rightFile)} diffres]
    }

    set apa [split $diffres "\n"]
    set result {}
    foreach i $apa {
        if {[string match {[0-9]*} $i]} {
            lappend result $i
        }

            return
        } else {
            set ::diff(eqLabel) "="
        }
    } else {
        set ::diff(eqLabel) " "
    }
    # Update the equal label immediately for better feedback
    update idletasks

    set ch1 [open $diff(leftFile)]
    set ch2 [open $diff(rightFile)]
    if {$::tcl_platform(platform) == "windows" && $Pref(crlf)} {
        fconfigure $ch1 -translation crlf
        fconfigure $ch2 -translation crlf

    set max 0.0
    foreach w {.ft1.tl .ft1.tt .ft2.tl .ft2.tt} {
        if {[$w index end] > $max} {
            set max [$w index end]
        }
    }
    foreach w {.ft1.tl .ft1.tt .ft2.tl .ft2.tt} {
        set d [expr {int($max) - int([$w index end])}]
        for {set t 0} {$t < $d} {incr t} {
            $w insert end \n
        }
    }

    close $ch1
    close $ch2

    radiobutton $w.f.rb4 -text "RL" -value 21 -variable curMergeSel \
            -command selectMerge
    bind $w <Key-Left>  {focus .merge ; set curMergeSel 1 ; selectMerge}
    bind $w <Key-Right> {focus .merge ; set curMergeSel 2 ; selectMerge}

    button $w.f.bl -text "All L" -command {selectMergeAll 1}
    button $w.f.br -text "All R" -command {selectMergeAll 2}



    button $w.f.b1 -text "Prev" -command {nextMerge -1}
    button $w.f.b2 -text "Next" -command {nextMerge 1}
    bind $w <Key-Down> {focus .merge ; nextMerge 1}
    bind $w <Key-Up>   {focus .merge ; nextMerge -1}

    button $w.f.bs -text "Save" -command saveMerge
    button $w.f.bq -text "Close" -command closeMerge
    wm protocol $w WM_CLOSE_WINDOW closeMerge

    grid $w.f.rb1 $w.f.rb2 $w.f.rb3 $w.f.rb4 x $w.f.b1 $w.f.b2 x \
            $w.f.bl $w.f.br x x x $w.f.bs $w.f.bq
    grid columnconfigure $w.f {4 7 10 12} -minsize 10
    grid columnconfigure $w.f 10 -weight 1

    if {[string match conflict* $::diff(mode)]} {
        checkbutton $w.f.bm -text "Pure" -variable diff(mode) \
                -onvalue "conflictPure" -offvalue "conflict" -command {doDiff}
        grid $w.f.bm -row 0 -column 11
    }

    text $w.t -width 80 -height 20 -xscrollcommand "$w.sbx set" \
            -yscrollcommand "$w.sby set" -font myfont
    scrollbar $w.sbx -orient horizontal -command "$w.t xview"
    scrollbar $w.sby -orient vertical   -command "$w.t yview"

    grid $w.f   -      -sticky news -row 0
    grid $w.t   $w.sby -sticky news
    grid $w.sbx x      -sticky we
    grid columnconfigure $w 0 -weight 1
    grid rowconfigure $w 1 -weight 1

    collectMergeData
    fillMergeWindow
}

#####################################
# Searching
#####################################

namespace eval textSearch {
    if {![info exists ::textSearch::widgets]} {
        variable widgets {}
    }
    variable isearchW ""
    variable isearchLast ""
    variable searchCase 0
    variable searchIndex 1.0
    variable searchString ""
}

# Setup a text widget for searching
proc textSearch::enableSearch {w} {
    variable widgets

    if {[winfo class $w] != "Text"} {
        error "Only text widgets can be searched!"
    }

    bind ISearch <Control-Key-s> "textSearch::startIncrementalSearch %W"
    bindtags $w "ISearch [bindtags $w]"

    if {[lsearch $widgets $w] < 0} {
        lappend widgets $w
    }

    set top [winfo toplevel $w]
    bind $top <Control-Key-f>  textSearch::search
    bind $top <Key-F3>         textSearch::searchNext
    bind $top <Control-Key-F3> textSearch::searchPrev
}

# Add searching to a menu
proc textSearch::searchMenu {menu} {
    $menu add command -label "Find"      -accelerator "Ctrl+f" \
            -command ::textSearch::search
    $menu add command -label "Find Next" -accelerator "F3" \
            -command ::textSearch::searchNext
    $menu add command -label "Find Prev" -accelerator "Ctrl+F3" \
            -command ::textSearch::searchPrev
}

# Start an incremental search
proc textSearch::startIncrementalSearch {w} {
    variable isearchW

    # This shouldn't happen
    if {$isearchW != ""} {
        endIncrementalSearch
    }

    set isearchW $w
    
    # Setup all bindings for incremental search
    bind ISearch <Control-Key-s> "textSearch::isearchAgain %W ; break"
    bind ISearch <Key-Delete>    "textSearch::isearchBack %W ; break"
    bind ISearch <Key-BackSpace> "textSearch::isearchBack %W ; break"
    bind ISearch <Key>           "textSearch::isearchKey %W %A %s %K"
    bind ISearch <Key-Escape>    "textSearch::endIncrementalSearch ; break"
    bind ISearch <Control-Key-g> "textSearch::endIncrementalSearch ; break"


    bind ISearch <FocusOut>      "textSearch::endIncrementalSearch"
    
    # Initialise variables
    set ::textSearch::isearchString ""
    set ::textSearch::isearchHistory {}
    set ::textSearch::isearchIndex [$w index insert]
    set ::textSearch::statusLabel "i"
}

# Highlight a match
proc textSearch::isearchShow {w index string} {
    $w tag remove sel 1.0 end
    $w tag add sel $index "$index + [string length $string] chars"
    $w mark set insert $index
    $w see $index

    set ::textSearch::isearchIndex $index
    set ::textSearch::isearchString $string
    set ::textSearch::isearchLast $string
}

# Search the widget
proc textSearch::isearchSearch {w str ix} {
    # If the search string is all lower case, search case insensitive
    if {[string equal [string tolower $str] $str]} {
        set found [$w search -nocase $str $ix]
    } else {
        set found [$w search $str $ix]
    }
    return $found
}

# Search for next match
proc textSearch::isearchAgain {w} {
    variable isearchW
    if {$w != $isearchW} {
        bell
        endIncrementalSearch
        return
    }

    set str $::textSearch::isearchString
    if {$str == ""} {
        set str $::textSearch::isearchLast
    }
    set found [isearchSearch $w $str "$::textSearch::isearchIndex + 1 char"]
    if {$found == ""} {
        bell
        return
    }
    lappend ::textSearch::isearchHistory $::textSearch::isearchIndex \
            $::textSearch::isearchString
    isearchShow $w $found $str
}

# A key has been pressed during incremental search
proc textSearch::isearchKey {w key state sym} {
    variable isearchW
    if {$w != $isearchW} {
        bell
        endIncrementalSearch
        return -code break
    }

    if {$key == ""} {
        # Ignore the Control and Shift keys
        if {[string match Contr* $sym]} {return -code break}
        if {[string match Shift* $sym]} {return -code break}
        # Ignore any Control-ed key
        if {$state == 4} {return -code break}
        # Break isearch on other non-ascii keys, and let it through
        bell
        endIncrementalSearch
        return
    }

    set str $::textSearch::isearchString
    append str $key

    set found [isearchSearch $w $str $::textSearch::isearchIndex]
    if {$found == ""} {
        bell
        return -code break
    }
    lappend ::textSearch::isearchHistory $::textSearch::isearchIndex \
            $::textSearch::isearchString
    isearchShow $w $found $str
    return -code break
}

# Go backwards in the isearch stack
proc textSearch::isearchBack {w} {
    variable isearchW
    if {$w != $isearchW} {
        bell
        endIncrementalSearch
        return
    }
    if {[llength $::textSearch::isearchHistory] < 2} {
        bell
        return
    }
    
    set str [lindex $::textSearch::isearchHistory end]
    set found [lindex $::textSearch::isearchHistory end-1]
    set ::textSearch::isearchHistory \
            [lrange $::textSearch::isearchHistory 0 end-2]
    
    isearchShow $w $found $str
}

# End an incremental search
proc textSearch::endIncrementalSearch {} {

    set ::textSearch::isearchW ""
    set ::textSearch::statusLabel ""

    # Remove all bindings from ISearch
    foreach b [bind ISearch] {
        bind ISearch $b ""
    }
    
    bind ISearch <Control-Key-s> "textSearch::startIncrementalSearch %W"
}

# Dialog functions from "Practical Programming in Tcl And Tk" by Welch.
proc textSearch::DialogCreate {top title args} {
    variable dialog
    if {[winfo exists $top]} {
        switch -- [wm state $top] {
            normal {
                # Raise a buried window
                raise $top
            }
            withdrawn -
            iconified {
                # Open and restore geometry
                wm deiconify $top
                catch {wm geometry $top $dialog(geo,$top)}
            }
        }
        return 0
    } else {
        eval {toplevel $top} $args
        wm title $top $title
        return 1
    }
}

proc textSearch::DialogWait {top varName {focus {}}} {
    upvar $varName var
    
    # Poke the variable if the user nukes the window
    bind $top <Destroy> [list set $varName $var]
    
    # Grab focus for the dialog
    if {[string length $focus] == 0} {
        set focus $top
    }
    set old [focus -displayof $top]
    focus $focus
    catch {tkwait visibility $top}
    catch {grab $top}
    
    # Wait for the dialog to complete
    tkwait variable $varName
    catch {grab release $top}
    focus $old
}

proc textSearch::DialogDismiss {top} {
    variable dialog
    # Save current size and position
    catch {
        # window may have been deleted
        set dialog(geo,$top) [wm geometry $top]
        wm withdraw $top
    }
}

# Ask for a search string
proc textSearch::FindDialog {string} {
    variable prompt
    set f .prompt
    if {[DialogCreate $f "Find" -borderwidth 10]} {
        message $f.msg -text $string -aspect 1000
        entry $f.entry -textvariable ::textSearch::prompt(result)
        
        checkbutton $f.case -text "Match Case" -anchor w\
                -variable ::textSearch::searchCase
        
        button $f.ok     -text OK     -width 7 \
                -command {set ::textSearch::prompt(ok) 1}
        button $f.cancel -text Cancel -width 7 \
                -command {set ::textSearch::prompt(ok) 0}

        grid $f.msg   - - -sticky w
        grid $f.entry - - -sticky we
        grid $f.case  - - -sticky w
        grid $f.ok x $f.cancel -sticky wes
        grid columnconfigure $f {0 2} -weight 1
        grid columnconfigure $f 1 -minsize 10 -weight 2
        grid rowconfigure $f 3 -weight 1

        bind $f.entry <Key-Return> {set ::textSearch::prompt(ok) 1 ; break}
        bind $f.entry <Key-Escape> {set ::textSearch::prompt(ok) 0 ; break}
    }

    set prompt(ok) 0
    DialogWait $f ::textSearch::prompt(ok) $f.entry
    DialogDismiss $f
    if {$prompt(ok)} {
        return $prompt(result)
    } else {
        return {}
    }
}

# "Normal" search
proc textSearch::search {} {
    variable searchString
    variable searchWin
    variable widgets
    variable searchCase
    variable searchIndex

    set searchWin [lindex $widgets 0]
    set foc [focus -displayof .]
    if {[lsearch $widgets $foc] >= 0} {
        set searchWin $foc
    }
    set searchString [FindDialog "Please enter string to find"]

    if {$searchString == ""} return

    if {$searchCase} {
        set searchPos [$searchWin search -count cnt $searchString @0,0]
    } else {
        set searchPos [$searchWin search -count cnt -nocase $searchString @0,0]
    }
    if {$searchPos == ""} {
        tk_messageBox -message "Search string not found!" -type ok \
                -title Search
        return
    }

    $searchWin see $searchPos
    $searchWin tag remove sel 1.0 end
    $searchWin tag add sel $searchPos "$searchPos + $cnt chars"
    set searchIndex $searchPos
}      

# Search again
proc textSearch::searchNext {} {
    variable searchString
    variable searchWin
    variable searchCase
    variable searchIndex

    if {$searchString == ""} return

    if {$searchCase} {
        set searchPos [$searchWin search -count cnt \
                $searchString "$searchIndex + 1 chars"]
    } else {
        set searchPos [$searchWin search -count cnt -nocase \
                $searchString "$searchIndex + 1 chars"]
    }
    
    if {$searchPos == "" || $searchPos == $searchIndex} {
        tk_messageBox -message "String not found!" -type ok -title Search
        return
    }

    $searchWin see $searchPos
    $searchWin tag remove sel 1.0 end
    $searchWin tag add sel $searchPos "$searchPos + $cnt chars"
    set searchIndex $searchPos
}

# Search backwards
proc textSearch::searchPrev {} {
    variable searchString
    variable searchWin
    variable searchCase
    variable searchIndex

    if {$searchString == ""} return

    if {$searchCase} {
        set searchPos [$searchWin search -count cnt -backwards \
                $searchString "$searchIndex - 1 chars"]
    } else {
        set searchPos [$searchWin search -count cnt -backwards \
                -nocase \
                $searchString "$searchIndex - 1 chars"]
    }
    
    if {$searchPos == "" || $searchPos == $searchIndex} {
        tk_messageBox -message "String not found!" -type ok -title Search
        return
    }

    $searchWin see $searchPos
    $searchWin tag remove sel 1.0 end
    $searchWin tag add sel $searchPos "$searchPos + $cnt chars"
    set searchIndex $searchPos
}

#####################################
# Printing stuff
#####################################

# Format a line number for printing

}

# Main print function
proc printDiffs {{quiet 0}} {
    busyCursor
    update idletasks
    set tmpFile [file nativename ~/tcldiff.enscript]

    if {$::diff(printFile) != ""} {
        set tmpFile2 [file nativename $::diff(printFile)]
    } else {
        set tmpFile2 [file nativename ~/tcldiff.ps]
    }

    set lines1 {}
    set lines2 {}

    set tdump1 [.ft1.tt dump -tag -text 1.0 end]
    set tdump2 [.ft2.tt dump -tag -text 1.0 end]

    }
    set rfile [file tail $rfile]$rrest

    lappend enscriptCmd "--header=$lfile|Page \$% of \$=|$rfile"
    if {$::prettyPrint != ""} {
        lappend enscriptCmd -E$::prettyPrint
    }
    lappend enscriptCmd -p $tmpFile2 $tmpFile

    if {[catch {eval exec $enscriptCmd} result]} {
        if {[string index $result 0] != "\["} {
            tk_messageBox -message "Enscript error: $result"
            return
        }
    }

    normalCursor
    if {!$quiet} {
        destroy .dp
        toplevel .dp
        wm title .dp "Diff Print"
        button .dp.b -text Close -command {destroy .dp}
        label .dp.l -anchor w -justify left -text "The following files have\
                been created:\n\n$tmpFile\nInput file to enscript.\
                \n\n$tmpFile2\nCreated with\
                '[lrange $enscriptCmd 0 end-3] \\\n             \
                [lrange $enscriptCmd end-2 end]'" \
                -font "Courier 8"
        pack .dp.b -side bottom
        pack .dp.l -side top
    }
}

    .mo.mp add separator
    .mo.mp add checkbutton -label "Use 2nd stage" \
            -variable Pref(extralineparse)
    .mo.mp add checkbutton -label "Mark last" -variable Pref(marklast)

    menubutton .ms -text Search -underline 0 -menu .ms.m 
    menu .ms.m


    textSearch::searchMenu .ms.m



    menubutton .mh -text Help -underline 0 -menu .mh.m
    menu .mh.m
    .mh.m add command -label "Help" -command makeHelpWin
    .mh.m add command -label "About" -command makeAboutWin

    button .bfn -text "Next Diff" -relief raised -command {findDiff 1}

    text .ft2.tt -height 60 -width 80 -wrap none -yscrollcommand my_yscroll \
            -xscrollcommand ".sbx2 set" -font myfont -borderwidth 0 -padx 0 \
            -highlightthickness 0
    pack .ft2.tl -side left -fill y
    pack .ft2.tt -side right -fill both -expand 1
    scrollbar .sbx2 -orient horizontal -command ".ft2.tt xview"

    # Set up a tag for incremental search bindings
    textSearch::enableSearch .ft1.tt
    textSearch::enableSearch .ft2.tt

    label .le -textvariable ::diff(eqLabel) -width 1
    label .ls -textvariable ::textSearch::statusLabel -width 1 -pady 0 -padx 0
    canvas .c -width 6 -bd 0 -selectborderwidth 0 -highlightthickness 0

    applyColor
    .ft1.tt tag configure last -underline 1
    .ft2.tt tag configure last -underline 1
    foreach w {.ft1.tt .ft1.tl .ft2.tt .ft2.tl} {
        bind $w <ButtonPress-3> "zoomRow %W %X %Y %x %y"

    bind .c <Configure> {drawMap %h}

    bind . <Key-Up> {scroll -1 u}
    bind . <Key-Down> {scroll 1 u}
    bind . <Key-Prior> {scroll -1 p}
    bind . <Key-Next> {scroll 1 p}
    bind . <Key-Escape> {focus .}




    pack .mf .mo .ms .mh -in .f -side left
    pack .bfn .bfp .eo .lo -in .f -side right
    if {$debug == 1} {
        menubutton .md -text Debug -menu .md.m -relief ridge
        menu .md.m
        if {$tcl_platform(platform) == "windows"} {

if {![winfo exists .f]} {
    getOptions
    makeDiffWin
    update idletasks
    parseCommandLine
}