Eskil

2010-04-27



Handle an empty .eskilrc. [Bug 17113]
Moved packages pstools and psballoon into GIT repository.

2010-02-13
 Do git add after conflict merge of a git file.
 Select colors for PDF print.

2009-11-02
 Detect and display annotation in patches. E.g. when using -p with diff.

  -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 Eskil to be controllable from the outside.

  -print <file> : Generate postscript and exit.

  -plugin <name> : Preprocess files using plugin.

  -limit <lines> : Do not process more than <lines> lines.}

To list all options matching a prefix, run 'eskil --query prefix'.
In tcsh use this line to get option completion:

<b><ul>Commands</ul></b>

<b>File Menu</b>
  Redo Diff       \t: Run diff again on the same files.
  Open Both       \t: Select two files, run diff.
  Open Left File  \t: Select a file for left window, run diff
  Open Right File \t: Select a file for right window, run diff
  Open Conflict File\t: Select a file containing conflicts such as from
                    \t  a CVS merge.
  Open Patch File \t: Display a patch file created by diff -c or diff -u.
  Revision Diff   \t: Select one revision controlled file.
  Print           \t: Experimental print function.
                  \t  It currently creates a postscript file ~/eskil.ps
  Close           \t: Close this window.
  Quit            \t: Guess

<b>Options Menu</b>
  Font   \t: Select font and fontsize for the two main text windows
  Ignore \t: Diff options for ignoring e.g. whitespace
  Parse  \t: Additional parsing made by Eskil to improve the display.

    cleanupFiles $top
    if {$::diff($top,mode) eq "conflict"} {
        if {$::widgets($top,eqLabel) != "="} {
            makeMergeWin $top
        }
    }
    if {$::diff($top,printFile) ne ""} {
        if {$::diff($top,printMode) eq "PS"} {
            after idle "doPrint $top 1 ; cleanupAndExit all"
        } else {
            after idle "doPrint2 $top 1 ; cleanupAndExit all"
        }
    }
}

# This is the entrypoint to do a diff via DDE or Send
proc remoteDiff {file1 file2} {
    newDiff $file1 $file2
}

# Fill in default data for a diff window
proc initDiffData {top} {
    set ::diff($top,leftOK) 0
    set ::diff($top,rightOK) 0
    set ::diff($top,mode) ""
    set ::diff($top,printFile) ""
    set ::diff($top,printMode) "PDF"
    set ::diff($top,mergeFile) ""
    set ::diff($top,conflictFile) ""
    set ::diff($top,limitlines) 0
    set ::diff($top,plugin) ""
}

# Create a new diff window and diff two files

    $top.m.mf add command -label "Open Conflict File..." \
            -command [list openConflict $top]
    $top.m.mf add command -label "Open Patch File..." \
            -command [list openPatch $top]
    $top.m.mf add command -label "Revision Diff..." -underline 0 \
            -command [list openRev $top]
    $top.m.mf add separator
    $top.m.mf add command -label "Print Ps..." \
            -command [list doPrint $top]
    $top.m.mf add command -label "Print Pdf..." -underline 0 \
            -command [list doPrint2 $top]
    $top.m.mf add separator
    $top.m.mf add command -label "Close" -underline 0 \
            -command [list cleanupAndExit $top]
    $top.m.mf add separator
    $top.m.mf add command -label "Quit" -underline 0 \
            -command {cleanupAndExit all}

  -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 Eskil to be controllable from the outside.

  -printps <file>  : Generate postscript and exit.
  -printpdf <file> : Generate pdf and exit.

  -plugin <plugin>     : Use plugin
  -plugininfo <info>   : Pass info to plugin (plugin specific)
  -plugindump <plugin> : Dump plugin source to stdout

  -limit <lines> : Do not process more than <lines> lines.

        makeDiffWin
        return
    }

    set allOpts {
        -w --help -help -b -noignore -i -nocase -nodigit -nokeyword -prefix
        -noparse -line -smallblock -block -char -word -limit -nodiff -dir
        -clip -patch -browse -conflict -print -printps -printpdf
        -server -o -r -context -cvs -svn -review
        -foreach -preprocess -close -nonewline -plugin -plugininfo
        -plugindump
    }

    # If the first option is "--query", use it to ask about options.
    if {$::eskil(argc) == 2 && [lindex $::eskil(argv) 0] == "--query"} {

            set ::eskil(ignorenewline) 1
        } elseif {$arg eq "-nonewline+"} {
            set ::eskil(ignorenewline) 2
        } elseif {$arg eq "-close"} {
            set ::eskil(autoclose) 1
        } elseif {$arg eq "-conflict"} {
            set opts(mode) "conflict"
        } elseif {$arg eq "-print" || $arg eq "-printps"} {
            set nextArg printFile
        } elseif {$arg eq "-printpdf"} {
            set nextArg printFile
            set opts(printMode) "PDF"
        } elseif {$arg eq "-server"} {
            if {$::tcl_platform(platform) eq "windows"} {
                catch {
                    package require dde
                    dde servername Eskil
                }
            } else {

    set Pref(lines) 60
    set Pref(editor) ""
    set Pref(regsub) {}
    set Pref(toolbar) 0
    set Pref(wideMap) 0 ;# Not settable in GUI yet

    # Print options
    set Pref(grayLevel1) 0.6
    set Pref(grayLevel2) 0.8
    set Pref(wideLines) 0
    set Pref(printHeaderSize) 10
    set Pref(printCharsPerLine) 80
    set Pref(printPaper) a4
    set Pref(printColorChange) "1.0 0.7 0.7"
    set Pref(printColorNew1)   "0.7 1.0 0.7"
    set Pref(printColorNew2)   "0.8 0.8 1.0"

        if {$i == -1} break
        set n [expr {(- $i - $index - 1) % 8 + 1}]
        set text [string replace $text $i $i [format %*s $n ""]]
    }
    return $text
}

# Format a line of text/tag pairs to enscript code
proc FormatLine {line} {
    set result ""
    foreach {text tag} $line {
        if {$tag eq ""} {
            append result $text
        } else {
            if {$tag eq "change"} {
                set gray $::Pref(grayLevel1)
            } elseif {[string match "new*" $tag]} {
                set gray $::Pref(grayLevel2)
            } else {
                # Should not happen
                set gray 1.0
                puts stderr "Bad tag in FormatLine: '$tag'"
            }
            append result "\0bggray\{$gray\}$text\0bggray\{1.0\}"
        }
    }
    return $result
}

# Find the lastnumber in a text widget
proc FindLastNumber {w} {
    set index [$w search -backwards -regexp {\d} end]
    set line [$w get "$index linestart" "$index lineend"]
    #puts "X '$line' '$index'"
    regexp {\d+} $line number
    return $number
}

# Main print function
proc PrintDiffs {top {quiet 0} {pdfprint 0}} {
    busyCursor $top
    update idletasks

    set tmpFile [file nativename ~/eskil.enscript]
    if {$::diff($top,printFile) != ""} {
        set tmpFile2 [file nativename $::diff($top,printFile)]
    } else {
        set tmpFile2 [file nativename ~/eskil.ps]
    }

    set lines1 {}
    set lines2 {}
    if {$pdfprint && [info exists ::Pref(printCharsPerLine)]} {
        set wraplength $::Pref(printCharsPerLine)
    } elseif {$::Pref(wideLines)} {
        set wraplength 100
        set linesPerPage 74
    } else {
        set wraplength 85
        set linesPerPage 66
    }

    set tdump1 [$::widgets($top,wDiff1) dump -tag -text 1.0 end]
    set tdump2 [$::widgets($top,wDiff2) dump -tag -text 1.0 end]

    # Figure out how many chars are needed for line numbers
    set len1 [string length [FindLastNumber $::widgets($top,wLine1)]]

        } elseif {$w2 > $w1} {
            for {set t $w1} {$t < $w2} {incr t} {
                lappend wraplines1 {}
            }
        }
    }

    if {$pdfprint} {
        PdfPrint $top $wraplength $maxlen $wraplines1 $wraplines2
    } else {
        # Write all lines to a file, taking one page at a time from each
        # side.

        set ch [open $tmpFile "w"]
        fconfigure $ch -encoding binary

        set len1 [llength $wraplines1]
        set len2 [llength $wraplines2]

        set i1 0
        set i2 0

        while {$i1 < $len1 && $i2 < $len2} {
            for {set i 0} {$i < $linesPerPage && $i1 < $len1} {incr i ; incr i1} {
                puts $ch [FormatLine [lindex $wraplines1 $i1]]
            }
            if {$i < $linesPerPage} {puts -nonewline $ch "\f"}
            for {set i 0} {$i < $linesPerPage && $i2 < $len2} {incr i ; incr i2} {
                puts $ch [FormatLine [lindex $wraplines2 $i2]]
            }
            if {$i < $linesPerPage} {puts -nonewline $ch "\f"}
        }

        close $ch

        # Run enscript to generate postscript

        if {$::tcl_platform(platform) eq "windows" &&\
                    ![info exists ::env(ENSCRIPT_LIBRARY)]} {
            set ::env(ENSCRIPT_LIBRARY) [pwd]
        }
        if {[auto_execok enscript.bin] ne ""} {
            set enscriptCmd [list enscript.bin]
        } else {
            set enscriptCmd [list enscript]
        }

        lappend enscriptCmd -2jcre -L $linesPerPage -M A4

        if {$::Pref(wideLines)} {
            lappend enscriptCmd  -f Courier6
        }
        if {![regexp {^(.*)( \(.*?\))$} $::diff($top,leftLabel) -> lfile lrest]} {
            set lfile $::diff($top,leftLabel)
            set lrest ""
        }
        set lfile [file tail $lfile]$lrest
        if {![regexp {^(.*)( \(.*?\))$} $::diff($top,rightLabel) -> rfile rrest]} {
            set rfile $::diff($top,rightLabel)
            set rrest ""
        }
        set rfile [file tail $rfile]$rrest

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

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

    # Finished

    normalCursor $top
    if {!$pdfprint && !$quiet} {
        destroy .dp
        toplevel .dp
        wm title .dp "Eskil Print"
        ttk::button .dp.b -text "Close" -command {destroy .dp}
        ttk::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"
    }
}

proc PdfPrint {top cpl cpln wraplines1 wraplines2} {

    if {$::diff($top,printFile) != ""} {
        set pdfFile $::diff($top,printFile)
    } else {

            $pdf drawTextLine [lindex $wraplines2 $i2]
            $pdf newLine
        }
    }
    $pdf endPrint
}

# Create a print dialog.
proc doPrint {top {quiet 0}} {
    if {![info exists ::diff(prettyPrint)]} {
        set ::diff(prettyPrint) ""
    }
    if {$quiet} {
        PrintDiffs $top 1
        return
    }

    destroy .pr
    toplevel .pr
    wm title .pr "Print diffs"

    ttk::label .pr.l1 -justify left -anchor w \
            -text "The print function is just on an\
            experimental level. It will use 'enscript' to write a postcript\
            file \"eskil.ps\" in your home directory."
    ttk::label .pr.l2 -justify left -anchor w \
            -text "Below you can adjust the gray scale\
            levels that are used on the background to mark changes.\
            The first value is used for changed text. The second for\
            new/deleted text."
    .pr.l1 configure -wraplength 400
    .pr.l2 configure -wraplength 400

    ttk::scale .pr.s1 -orient horizontal -from 0.0 \
            -to 1.0 -variable Pref(grayLevel1)
    ttk::scale .pr.s2 -orient horizontal -from 0.0 \
            -to 1.0 -variable Pref(grayLevel2)
    ttk::frame .pr.f
    ttk::radiobutton .pr.r1 -text "No Syntax" -variable diff(prettyPrint) \
            -value ""
    ttk::radiobutton .pr.r2 -text "VHDL" -variable diff(prettyPrint) \
            -value "vhdl"
    ttk::radiobutton .pr.r3 -text "Tcl"  -variable diff(prettyPrint) \
            -value "tcl"
    ttk::radiobutton .pr.r4 -text "C"    -variable diff(prettyPrint) \
            -value "c"

    ttk::frame .pr.fs
    ttk::radiobutton .pr.fs.r1 -text "80 char" -variable Pref(wideLines) \
            -value 0
    ttk::radiobutton .pr.fs.r2 -text "95 char" -variable Pref(wideLines) \
            -value 1
    pack .pr.fs.r1 .pr.fs.r2 -side left -padx 10

    ttk::button .pr.b1 -text "Print to File" \
            -command "destroy .pr; update; PrintDiffs $top"
    ttk::button .pr.b2 -text "Cancel" -command {destroy .pr}

    grid .pr.l1 - - -sticky we
    grid .pr.l2 - - -sticky we
    grid .pr.s1 - - -sticky we
    grid .pr.s2 - - -sticky we
    grid .pr.f  - - -sticky we
    grid .pr.fs - - -sticky we
    grid .pr.b1 x .pr.b2 -sticky we -padx 5 -pady 5 -ipadx 5
    grid columnconfigure .pr {0 2} -uniform a
    grid columnconfigure .pr 1 -weight 1
    pack .pr.r1 .pr.r2 .pr.r3 .pr.r4 -in .pr.f -side left -fill x -expand 1

}

# Count the length of a line during a text dump
proc AccumulateMax {key value index} {
    set index [lindex [split $index "."] 1]
    set len [expr {[string length $value] + $index - 1}]
    if {$len > $::diff(currentCharsPerLine)} {
        set ::diff(currentCharsPerLine) $len
    }

    if {$apa ne ""} {
        set ::diff($top,printFile) $apa
        $entry xview end
    }
}

# Create a print dialog for PDF.
proc doPrint2 {top {quiet 0}} {
    if {$quiet} {
        PrintDiffs $top 1 1
        return
    }

    destroy .pr
    toplevel .pr -padx 3 -pady 3
    wm title .pr "Print diffs to PDF"

    if {$::diff($top,printFile) eq ""} {
        set ::diff($top,printFile) "~/eskil.pdf"
    }

    ttk::frame .pr.fb
    ttk::button .pr.b1 -text "Print to File" \
            -command "destroy .pr; update; PrintDiffs $top 0 1"
    ttk::button .pr.b2 -text "Cancel" -command {destroy .pr}
    pack .pr.b1 -in .pr.fb -side left  -padx 3 -pady 3 -ipadx 5
    pack .pr.b2 -in .pr.fb -side right -padx 3 -pady 3 -ipadx 5

    grid .pr.hsl .pr.hss         -sticky we -padx 3 -pady 3
    grid .pr.psl .pr.psc         -sticky we -padx 3 -pady 3
    grid .pr.cll .pr.cle .pr.clf -sticky we -padx 3 -pady 3