Eskil

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

set debug 1
set diffver "Version 1.8.5  2001-10-25"
set tmpcnt 0
set tmpfiles {}
set thisscript [file join [pwd] [info script]]
set thisdir [file dirname $thisscript]

if {$tcl_platform(platform) == "windows"} {
    cd $thisdir

                displayOnePatch $leftLines $rightLines $leftLine $rightLine
            }
            set leftLines {}
            set rightLines {}
            set state none
            continue
        }
        # Detect the first line in a -c style diff
        if {$state == "none" && [regexp {^\*\*\*} $line]} {
            set state newfile
            set style c
            set leftRE {^\*\*\*\s+(.*)$}
            set rightRE {^---\s+(.*)$}
        }
        # Detect the first line in a -u style diff
        if {$state == "none" && [regexp {^---} $line]} {
            set state newfile
            set style u
            set leftRE {^---\s+(.*)$}
            set rightRE {^\+\+\+\s+(.*)$}
        }
        if {$state == "newfile" && [regexp $leftRE $line -> sub]} {
            emptyline 1
            insert 1 "" $divider
            insert 1 "" $sub
            insert 1 "" $divider
            continue
        }
        if {$state == "newfile" && [regexp $rightRE $line -> sub]} {
            emptyline 2
            insert 2 "" $divider
            insert 2 "" $sub
            insert 2 "" $divider
            continue
        }
        # A new section in a -u style diff
        if {[regexp {^@@\s+-(\d+),\d+\s+\+(\d+),} $line -> sub1 sub2]} {
            if {$state == "both"} {
                displayOnePatch $leftLines $rightLines $leftLine $rightLine
            }
            set state both
            set leftLine $sub1
            set rightLine $sub2
            set leftLines {}
            set rightLines {}
            continue
        }
        # A new section in a -c style diff
        if {[regexp {^\*\*\*\*\*} $line]} {
            if {$state == "right"} {
                displayOnePatch $leftLines $rightLines $leftLine $rightLine
            }
            set leftLines {}
            set rightLines {}
            set state left
            continue
        }
        # We are in the left part of a -c style diff
        if {$state == "left"} {
            if {[regexp {^\*\*\*\s*(\d*)} $line -> sub]} {
                if {$sub != ""} {
                    set leftLine $sub
                }
                continue
            }

            if {![regexp {^[\s!+-]} $line]} continue
            lappend leftLines [list $leftLine \
                    [string trim [string range $line 0 1]] \
                    [string range $line 2 end]]
            incr leftLine
            continue
        }
        # We are in the right part of a -c style diff
        if {$state == "right"} {
            if {![regexp {^[\s!+-]} $line]} continue
            lappend rightLines [list $rightLine \
                    [string trim [string range $line 0 1]] \
                    [string range $line 2 end]]
            incr rightLine
            continue
        }
        # We are in a -u style diff
        if {$state == "both"} {
            if {![regexp {^[\s+-]} $line]} continue
            set sig [string trim [string index $line 0]]
            set str [string range $line 1 end]
            if {$sig == ""} {
                lappend leftLines [list $leftLine "" $str]
                lappend rightLines [list $leftLine "" $str]

    grid $w.sbx x      -sticky we
    grid columnconfigure $w 0 -weight 1
    grid rowconfigure $w 1 -weight 1

    collectMergeData
    fillMergeWindow
}

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

proc startIncrementalSearch {w} {

    if {![info exists ::diff(isearch)]} {
        set ::diff(isearch) ""
        set ::diff(isearchlast) ""
    }

    # This shouldn't happen
    if {$::diff(isearch) != ""} {
        endIncrementalSearch $w
    }

    set ::diff(isearch) $w
    
    bind MyText <Control-Key-s> "isearchAgain %W ; break"
    bind MyText <FocusOut> "endIncrementalSearch %W"
    bind MyText <Key> "isearchKey %W %A ; break"
    bind MyText <Key-Escape> "endIncrementalSearch %W ; break"
    bind MyText <Control-Key-g> "endIncrementalSearch %W ; break"
    bind MyText <Key-Delete> "isearchBack %W ; break"
    bind MyText <Key-BackSpace> "isearchBack %W ; break"
    
    set ::diff(isearchstring) ""
    set ::diff(isearchhistory) {}
    set ::diff(isearchindex) [$w index insert]

}

proc isearchShow {w index string} {
    if {$index != $::diff(isearchindex)} {
        $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 ::diff(isearchindex) $index
    set ::diff(isearchstring) $string
    set ::diff(isearchlast) $string
}

proc isearchAgain {w} {
    if {$w != $::diff(isearch)} {
        bell
        endIncrementalSearch $::diff(isearch)
        return
    }

    set str $::diff(isearchstring)
    if {$str == ""} {
        set str $::diff(isearchlast)
    }
    set found [$w search $str "$::diff(isearchindex) + 1 char"]
    if {$found == ""} {
        bell
        return
    }
    lappend ::diff(isearchhistory) $::diff(isearchindex) \
            $::diff(isearchstring)
    isearchShow $w $found $str
}

proc isearchKey {w key} {

    if {$w != $::diff(isearch)} {
        bell
        endIncrementalSearch $::diff(isearch)
        return
    }

    if {$key == ""} return

    set str $::diff(isearchstring)
    append str $key

    set found [$w search $str $::diff(isearchindex)]
    if {$found == ""} {
        bell
        return
    }
    lappend ::diff(isearchhistory) $::diff(isearchindex) \
            $::diff(isearchstring)
    isearchShow $w $found $str
}

proc isearchBack {w} {
    if {$w != $::diff(isearch)} {
        bell
        endIncrementalSearch $::diff(isearch)
        return
    }
    if {[llength $::diff(isearchhistory)] < 2} {
        bell
        return
    }
    
    set str [lindex $::diff(isearchhistory) end]
    set found [lindex $::diff(isearchhistory) end-1]
    set ::diff(isearchhistory) [lrange $::diff(isearchhistory) 0 end-2]
    
    isearchShow $w $found $str
}

proc endIncrementalSearch {w} {

    set ::diff(isearch) ""

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

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

# Format a line number for printing
proc formatLineno {lineno gray} {

            -font myfont -borderwidth 0 -padx 0 -highlightthickness 0
    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"

    bind MyText <Control-Key-s> "startIncrementalSearch %W"
    bindtags .ft1.tt "MyText [bindtags .ft1.tt]"
    bindtags .ft2.tt "MyText [bindtags .ft2.tt]"

    label .le -textvariable eqLabel -width 1
    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} {

    chFont
}

# Update example font
proc exampleFont {} {
    global TmpPref
    set i [lindex [.fo.lb curselection] 0]
    if {$i == ""} return
    set TmpPref(fontfamily) [.fo.lb get $i]

    font configure tmpfont -family $TmpPref(fontfamily)
    if {[string is integer -strict $TmpPref(fontsize)]} {
        font configure tmpfont -size $TmpPref(fontsize)
    }
}

# Font dialog
proc makeFontWin {} {
    global Pref TmpPref FontCache

File Menu
  Redo Diff         : Run diff again on the same files.
  Open Both         : Select two files, run diff.
  Open Left File    : Select a file for left window, run diff
  Open Right File   : Select a file for right window, run diff
  Open Conflict File: Select a file containing conflicts such as from
                      a CVS merge.
  Open Patch File   : Display a patch file created by diff -c or diff -u.
  RCSDiff           : (UNIX only) Select one file and diff like rcsdiff.
  CVSDiff           : (UNIX only) Select one file and diff like cvs diff.
  Print             : (UNIX only) Experimental print function.
                      It currently creates a postscript file ~/tcldiff.ps
  Quit              : Guess

Options Menu

                  if there are no more diffs.
Next Diff Button: Scrolls to the next differing block, or to the bottom
                  if there are no more diffs.

Equal sign: Above the vertical scrollbar, a "=" will appear if the files
            are equal.

} "" {Bindings} ul {

Up, Down, Page Up and Page Down scrolls main windows.

Escape takes focus out of text windows.

Right mouse button "zooms" a line of text.

Ctrl-s starts incremental search. Incremental search is stopped by Escape
  or Ctrl-g.

Ctrl-f brings up search dialog. F3 is "search again".

} "" {Merge Window (Appears in conflict mode)} ul {

You can, for each difference, select which version you want to appear
in the output file. The buttons "LR", "L", "R" and "RL" select the
lines from the left file, right file or both files.
"Prev" and "Next" buttons moves between differences.
"All L" and "All R" buttons select "L" or "R" for all differences.

                         are passed to diff.
  [file1],[file2]        Files to be compared
                         If no files are given, the program is
                         started anyway and you can select files
                         from within.
                         If only one file is given, the program
                         looks for an RCS/CVS directory next to the
                         file, and if found, runs in RCS/CVS mode.
  Options:

  -nodiff     : Normally, if there are enough information on the
                command line to run diff, diff.tcl will do so unless
                this option is specified.

  -noparse    : Diff.tcl can perform analysis of changed blocks to
  -line       : improve display. See online help for details.
  -smallblock : The default. Do block analysis on small blocks.
  -block      : Full block analysis. This can be slow if there
                are large change blocks.

  -char       : The analysis of changes can be done on either
  -word       : character or word basis. -char is the default.

  -2nd        : Turn on or off second stage parsing.
  -no2nd      : It is on by default.

  -noignore   : Don't ignore any whitespace.
  -b          : Ignore space changes. Default.
  -w          : Ignore all spaces.

  -conflict   : Treat file as a merge conflict file and enter merge
                mode.
  -o <file>   : Specify merge result output file. 

  -browse     : Automatically bring up file dialog after starting.
  -server     : Set up diff to be controllable from the outside.

  -print <file> : Generate postscript and exit.
}
}

proc parseCommandLine {} {
    global diff Pref

            set Pref(ignore) "-b"
        } elseif {$arg == "-noignore"} {
            set Pref(ignore) " "
        } elseif {$arg == "-noparse"} {
            set Pref(parse) 0
        } elseif {$arg == "-line"} {
            set Pref(parse) 1
        } elseif {$arg == "-smallblock"} {
            set Pref(parse) 2
        } elseif {$arg == "-block"} {
            set Pref(parse) 3
        } elseif {$arg == "-char"} {
            set Pref(lineparsewords) 0
        } elseif {$arg == "-word"} {
            set Pref(lineparsewords) 1
        } elseif {$arg == "-2nd"} {