Eskil

Released 2.8.5

2023-04-23
 Added -printLineSpace. Corrected -printHeaderSize.

2021-09-23
 Allow revision control detect with -browse.

2021-03-29
 Support -context/-w/-b for -review.

2021-03-01
 Bumped revision to 2.8.5

2021-02-28
 Ballonhelp within frame.

2020-12-10
 Working towards runtime plugins.

2020-10-30
 Correct parent in dialogs.

2020-09-28
 Prune alone files dir diff.

2020-09-02
 Fixed bug where copy context menu used the wrong key.

2020-04-14
 Added gunzip plugin.

2020-01-15
 Do not traverse a unique side in dir diff.
 Support -norun for dir diff.
 Prune empty directories in dir diff.
 Added -includefile/dir command line, for dir diff.

2020-01-07
 Handle multiple screens better for balloon help 

2019-11-10
 More combinations allowed in edit mode. Including copy block of selected text.

2019-11-10
 Code cleanup to adhere a bit to some consistent standard.

2019-08-28
 Allow multiple pairs of files on the command line to open multiple windows.

2019-07-05
 Ctrl-E to enable Edit Mode.
 Do not ask about overwriting in Edit Mode. Hidden preference to turn it on.
 Added -subst command line, to acces PreProcess Subst function.

2019-06-12
 Better SVN commit, when added directories are included.

2019-03-12
 Auto-open prefix group dialog.

Released 2.8.4

2019-02-06
 Bumped revision to 2.8.4

2019-02-04
 Include a file selector when committing multiple files.
 Allow directory with -review.

2018-10-03
 Handle deleted files in GIT vcsvfs

2018-09-23
 Upgraded tablelist to 6.3

2018-06-20
 Added save-reload option in edit mode.
 Upgraded tablelist to 6.2

Released 2.8.3

2018-06-13
 Bumped revision to 2.8.3
 Better visibility that commit happened.

2018-06-05
 Working on shortcuts for preprocess dialog.

2018-05-14
 Added changeset tool to fourway,

2018-05-13
 Adjustments to fourway UI.

Released 2.8.2

2018-05-13
 Bumped revision to 2.8.2
 Fixed bug in Fossil handling. Rev -1 did not work.

2018-05-12
 Added fourway diff.

Released 2.8.1

2018-01-14
 Removed support for old RCS style -rREV command line.
 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.

2017-12-22
 Added -excludedir and -excludefile options for dir diff.

2017-12-16
 Make sure plugins are applied in the right order.
 Make sure Dir Diff can pick one out of many plugins.
 Dir Diff no longer shortcuts for files with same size&mtime.

2017-12-13
 Use same font in commit window as in diff window.
 Upgraded tablelist to 6.0

2017-12-07
 Support -nocase in dirdiff.
 Repaired plugins for dirdiff (broken by multi plugin).

2017-12-07
 Handle GIT revisions better for directory diff.
 
2017-12-05
 Bumped revision to 2.8.0

2017-12-04
 Support multiple plugins from command line.

2017-12-02
 Support multiple plugins.
 Changed default pivot to 10. Include GUI choice for 1.

2017-12-01
 Added GUI for multiple plugins. No function yet.

Released 2.7.4

2017-11-30
 Allow multi select in table diff.

2017-06-19
 Allow one side of directory diff to be protected from editing.
 Allow directories to be created in directory diff.

2017-03-18
 When needing an editor, try VISUAL and EDITOR plus a set of common ones.

2017-02-05
 Bumped revision to 2.7.4
 Handle multiple preprocess definitions that can be saved with preferences.

2017-02-04
 Support more areas for file drop.

2017-01-31
 Made --query work again; lost in option reorganisation.

2017-01-12
 Added -gz flag to compare compressed files.

2016-09-04
 Preserve line endings when saving during Edit Mode.

2016-08-30
 Bumped revision to 2.7.3

2016-08-21
 Auto-detect semicolon separator. Connect GUI separator with plugin.

2016-08-19
 GUI support for table and separator.

2016-08-15
 Bumped revision to 2.7.2

2016-07-29
 Include plugin command line options in command line help.
 Include plugin options in plugin dialog.

2016-07-29
 Corrected right side numbering when parsing patch. [288be8f321]

2016-07-06
 Support negative revisions with GIT. Added log view for GIT.

2016-07-01
 When displaying a patch, detect chunks marked with ##.
 E.g. svn diff lists changed properties like that.

2016-06-10
 Reorganised code for option descriptions.

2016-06-09
 Upgraded to DiffUtilTcl 0.3.9 to get consistent word parse behaviour.

2016-04-13
 Allow plugin to know file names. Use source file with pdftotext in PDF plugin
 since stdin is not reliable there.

2016-04-13
 When displaying a patch, detect a file with no changed chunks.
 E.g. svn diff lists changed binary files like that.

2016-04-08
 Allow GUI to set privilege for plugins.
 Better search for pdftotext in pdf plugin.

2015-11-22
 Bumped revision to 2.7.1
 Allow plugins to define command line options.

2015-11-20
 Rebuilt command line option handling.

2015-11-19
 Added binary plugin.

2015-11-17
 Compress printed PDF.

2015-10-14
 Page break between files when printing in patch mode.

2015-10-12
 Use tablelist 5.14 that includes -colorizecommand, for table diff.

2015-07-02
 Printing followed by redo diff closed Eskil. Fixed this.

2015-06-02
 Made a patched version of tablelist for table diff. Patch stored in src dir.
 Table diff works reasonable now

2015-04-19
 Started working on table diff.
 Added grep plugin.

2015-04-09
 Started working on a edit buttons shown between diffs.

2015-03-18
 Allow plugins to yield if Eskil is run in Tcl 8.6 or newer.
 Added swap plugin to exemplify this.

2015-03-18
 Added command line flag "-pluginallow" to allow a plugin to run in a standard
 interpreter instead of a safe one.
 Added pdf plugin.

2015-03-17
 Added command line flag "-sep" to set a separator for table-like files
 like CSV.

2015-03-16
 Added csv plugin.
 Pass ::argv to plugins.

2015-03-15
 Extended Mercurial support to commit, revert, log and directory diff.

2015-03-09
 Released 2.7

2015-03-06
 Generate release files for Mac, now when DiffUtil supports Mac.

2015-03-01
 Added more key bindings to scroll diff.

2015-02-25
 Allow saving prefs from dirdiff window.
 Put "nice" setting in preferences.

2015-02-24
 Bumped revision to 2.7

2015-02-23
 Version support in directory diff, for Fossil, GIT and Subversion.

2014-12-17
 Changed the included print font to a true type font.
 Allow -printFont to be "Courier" for fallback to PDF builtin.

2014-11-25
 Added command line -printFont to select a font file for PDF.

2014-11-16
 First working plugin in dirdiff.

2014-11-13
 Undid all dirdiff refactoring from August. Bad idea...

2014-11-12
 Bumped revision to 2.6.7

2014-11-12
 Added vcsvfs, to be used for revision aware dirdiff.

2014-11-07
 Fixed silly error from dirdiff refactoring. [da1ad24ee2]

2014-10-27
 Bumped revision to 2.6.6

2014-10-27
 Store default prefs as comment in rc file

2014-08-12
 Started to refactor dirdiff code.
 This prepares for making dirdiff revision aware.

2014-02-01
 Added a font fallback in psballon. [0ff6d72ab9]

2014-01-24
 Bumped revision to 2.6.5

2014-01-24
 Include tclkit.ico and tclkit.inf in kit, to get info on Windows.

2014-01-11
 Detect Subversion 1.7 working copy where .svn is just in the top.

2013-09-28
 Support direct print in patch mode. [6bce349e95]

2013-09-28
 Added hourglass cursor during prune equal in directory diff. [766b7a4695]

2013-09-26
 Fixed error printing patch with only deleted or inserted files. [2d89cee14d]

2013-08-22
 Bumped revision to 2.6.4

2013-08-22
 Include afm font for PDF printing.

2013-08-22
 Do not allow edit in text widget after startup. [51ad7323ff]

2013-02-18
 Add .pdf to print file by default [e093eb8eef]

2012-11-15
 No changes in scroll map when displaying a patch.

2012-09-17
 Avoid getting double .-files in dirdiff on Windows.
 Added "nice" option to control dirdiff speed.

2012-08-30
 Corrected display of ancestor lines in three-way merge.

2012-08-21
 Bumped revision to 2.6.3

2012-08-21
 Added Preferences menu for Pivot value.

2012-08-21
 Added Revert button in Revision mode

2012-07-12
 DiffUtilTcl is now 0.3.7.
 This added -pivot to exclude very common lines, and post processing of
 the excluded lines. This cuts down processing time for certain large files.

2012-07-11
 Detect and display error if commit fails.

2012-06-22
 Added -pivot command line flag to control C diff's -pivot.

2012-06-18   Release 2.6.2

2012-06-12
 DiffUtilTcl is now 0.3.5.

2012-06-12
 Added -nocdiff command line flag for debug.

2012-02-28
 Support negative revisions with Fossil.

2012-02-21
 Support branches in Subversion. [b71c8cf01b]

2012-02-19
 Support regsub preprocessing controlled per side.

2012-02-18
 Improved PDF print dialog.

2012-02-17
 Improved plugin viewer.

2012-02-14
 Include added files when using -review with Fossil.

2012-02-07
 Fixed bug where extra lines showed when displaying only diffs (no context).

Release 2.6.1

2011-11-01
  Fixed bug where copy button in directory diff picked the wrong file.
  Use a custom Toolbutton layout to get a small toolbutton in directory diff.

Release 2.6

2011-10-27
  Rebuilt rev-detection to handle any dir depth.
  Detect .fos as fossil indicator.

2011-10-15
  Added Show in plugin dialog. Added sort plugin. [FR 3735]

2011-10-15
 Added procedure editor to debug menu.

2011-10-15
 Corrected search of plugins to find them in VFS. [Bug 18395]

2011-10-05
 Respect block parse setting when showing a patch. [Bug 18147]

2011-10-04
 Fall back to Tcl-dialog when accessing a vfs. [Bug 18371]

2011-05-09
 Use mouse dragging to set alignment.

2011-05-09
 Rewritten directory diff to use tablelist.
 Redesigned appearance of directory diff.

2011-04-30
 Improved three-way merge.
 Highlight conflicts and navigate directly between conflicts.
 Include status for each merge chunk to see the decision made.
 Added Goto menu in merge window to get fewer toolbar buttons.
 Auto-detect line endings in ancestor file to select merge output.

2011-04-28
 Code cleanup to get clean Nagelfar run

2011-04-28
 Added three-way merge. Cmd line options -a and -fine.

2011-04-24
 Added basic GUI for plugin selection.

2011-04-22
 Merging did not work properly if alignment was used. [Bug 9925]

2011-04-11
 Support files and revisions with -review in Fossil.
 Support revisions with -review in Git.
 New DiffUtil has a fallback to pure Tcl LCS.

2011-04-05
 Added -pluginlist option.

2011-03-31
 Added support for Fossil revision control.

2010-11-07
 Added tkdnd support. [FR 5125]

2010-11-07
 Auto-detect line endings in conflict file.
 Allow line ending selection in merge save. [FR 5160]
 Added menu bar to merge window.

2010-06-23
 Support -noempty from DiffUtil, to try it out.

2010-04-27

 Better handling of negative Subversion revisions

2008-11-19
 Bug fix in Clip Diff Capture

2008-11-10
 Improved patch parsing.
 Include Twapi in windows executable

2008-11-06
 Added Capture in Clip Diff on Windows.
 Handle Rev and Plugin at the same time.

2008-09-23
 Added log button for version control.

 Kits are mounted readonly.

2007-01-29
 Finished dirdiff filters. [FR 3040]

2007-01-28
 Started on dirdiff filters.
 Added dirdiff preferences dialog.

2007-01-09
 Document --query flag. [FR 3027]
 Smarter save in merge. [FR 2957]

2007-01-07
 Added commit button for CVS. [FR 2780]

2004-06-30
 Full -r support for ClearCase.

2004-06-24
 Added simple -r support to ClearCase diff.
 Support ignore case in block matching.

Release 2.0.4

2004-06-17
 Added ignore case option.

2004-06-16
 Improved alignment handling a bit. Mark alignment row with an underline.

Release 2.0.1

2004-02-10
 Added preferences for width and height.
 Added Tools menu to directory diff window.
 Made it simpler to save a conflict in the same file.

2004-02-05
 Stopped Tk from interfering with the command line.

2004-01-30
 Release 2.0

#----------------------------------------------------------------------
# Make file for Eskil
#----------------------------------------------------------------------

# This string is used to generate release file names
VERSION = 285
# This string is used to tag the version shown in Eskil
DOTVERSION = 2.8.5

# Path to the TclKits used for creating StarPacks.
TCLKIT = /home/$(USER)/tclkit/v86
TCLKIT_LINUX   = $(TCLKIT)/tclkit-linux

TCLKIT_WIN     = $(TCLKIT)/tclkit-win32.upx.exe
TCLKIT_MAC     = $(TCLKIT)/tclkit-mac-867

# Paths to the libraries used.


# If you do not have access to all these, you can get them from an Eskil kit
# as explained below.
TEXTSEARCH = /home/$(USER)/src/textsearch
DIFFUTIL   = /home/$(USER)/src/DiffUtilTcl/lib.vfs/DiffUtil
WCB        = /home/$(USER)/src/packages/wcb3.5
PDF4TCL    = /home/$(USER)/src/pdf4tcl/pkg
SNIT       = /home/$(USER)/src/packages/tcllib/modules/snit


TABLELIST  = /home/$(USER)/src/packages/tablelist6.3
TWAPI      = /home/$(USER)/src/packages/twapi
TKDND      = /home/$(USER)/src/packages/tkdnd/lib/tkdnd2.4
EMBEDFONT  = /usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf

# Tools
NAGELFAR    = nagelfar

all: setup

SRCFILES = src/eskil.tcl src/clip.tcl src/dirdiff.tcl src/help.tcl src/map.tcl \
	   src/print.tcl src/registry.tcl src/rev.tcl src/debug.tcl \
	   src/compare.tcl src/merge.tcl src/printobj.tcl src/plugin.tcl \
           src/vcsvfs.tcl src/preprocess.tcl src/startup.tcl src/fourway.tcl

#----------------------------------------------------------------
# Build a dependency tree to other libs needed.
# This is made in a parallell VFS structure, mimicking Eskil's.
# Thus deps.vfs can also be created by downloading an Eskil kit,
# rename it to "deps" and unwrap it with sdx.
#----------------------------------------------------------------

deps.vfs/src/embedfont.ttf:
	@mkdir -p deps.vfs/src
	@cd deps.vfs/src ; ln -fs $(EMBEDFONT) embedfont.ttf
deps.vfs/lib/wcb:
	@mkdir -p deps.vfs/lib
	cd deps.vfs/lib ; ln -fns $(WCB) wcb
deps.vfs/lib/textsearch:
	@mkdir -p deps.vfs/lib
	cd deps.vfs/lib ; ln -fns $(TEXTSEARCH) textsearch
deps.vfs/lib/diffutil:
	@mkdir -p deps.vfs/lib
	cd deps.vfs/lib ; ln -fns $(DIFFUTIL) diffutil
deps.vfs/lib/pdf4tcl:
	@mkdir -p deps.vfs/lib
	cd deps.vfs/lib ; ln -fns $(PDF4TCL) pdf4tcl
deps.vfs/lib/tkdnd:
	@mkdir -p deps.vfs/lib
	cd deps.vfs/lib ; ln -fns $(TKDND) tkdnd
deps.vfs/lib/tablelist:
	@mkdir -p deps.vfs/lib
	cd deps.vfs/lib ; ln -fns $(TABLELIST) tablelist
deps.vfs/lib/snit:
	@mkdir -p deps.vfs/lib/snit
	cd deps.vfs/lib/snit ; ln -fs $(SNIT)/pkgIndex.tcl
	cd deps.vfs/lib/snit ; ln -fs $(SNIT)/snit.tcl
	cd deps.vfs/lib/snit ; ln -fs $(SNIT)/snit2.tcl
	cd deps.vfs/lib/snit ; ln -fs $(SNIT)/main2.tcl
	cd deps.vfs/lib/snit ; ln -fs $(SNIT)/main1.tcl
	cd deps.vfs/lib/snit ; ln -fs $(SNIT)/validate.tcl

#------------------------------------------------------------------
# Setup symbolic links from the VFS to the sources and dependencies
#------------------------------------------------------------------

eskil.vfs/src/eskil.tcl:
	@mkdir -p eskil.vfs/src
	@cd eskil.vfs/src ; for i in $(SRCFILES); do ln -fs ../../$$i ; done
eskil.vfs/src/images:
	@mkdir -p eskil.vfs/src
	@cd eskil.vfs/src ; ln -fs ../../src/images
eskil.vfs/src/embedfont.ttf: deps.vfs/src/embedfont.ttf
	@mkdir -p eskil.vfs/src
	@cd eskil.vfs/src ; ln -fs ../../deps.vfs/src/embedfont.ttf
	@cd src ; ln -fs ../deps.vfs/src/embedfont.ttf
eskil.vfs/examples:
	cd eskil.vfs ; ln -fs ../examples
eskil.vfs/doc:
	cd eskil.vfs ; ln -fs ../doc
eskil.vfs/plugins:
	cd eskil.vfs ; ln -fs ../plugins
eskil.vfs/COPYING:
	cd eskil.vfs ; ln -fs ../COPYING
eskil.vfs/lib/wcb: deps.vfs/lib/wcb
	cd eskil.vfs/lib ; ln -fs ../../deps.vfs/lib/wcb




eskil.vfs/lib/textsearch: deps.vfs/lib/textsearch
	cd eskil.vfs/lib ; ln -fs ../../deps.vfs/lib/textsearch
eskil.vfs/lib/diffutil: deps.vfs/lib/diffutil
	cd eskil.vfs/lib ; ln -fs ../../deps.vfs/lib/diffutil
eskil.vfs/lib/pdf4tcl: deps.vfs/lib/pdf4tcl
	cd eskil.vfs/lib ; ln -fs ../../deps.vfs/lib/pdf4tcl
eskil.vfs/lib/tkdnd: deps.vfs/lib/tkdnd
	cd eskil.vfs/lib ; ln -fs ../../deps.vfs/lib/tkdnd
eskil.vfs/lib/tablelist: deps.vfs/lib/tablelist


	cd eskil.vfs/lib ; ln -fs ../../deps.vfs/lib/tablelist






eskil.vfs/lib/snit: deps.vfs/lib/snit




	cd eskil.vfs/lib ; ln -fs ../../deps.vfs/lib/snit

links: eskil.vfs/src/eskil.tcl \
	eskil.vfs/src/images \
	eskil.vfs/src/embedfont.ttf \
	eskil.vfs/examples\
	eskil.vfs/doc\
	eskil.vfs/plugins\
	eskil.vfs/COPYING\


	eskil.vfs/lib/textsearch\
	eskil.vfs/lib/diffutil\
	eskil.vfs/lib/pdf4tcl\
	eskil.vfs/lib/snit\


	eskil.vfs/lib/tkdnd\
	eskil.vfs/lib/tablelist\
	eskil.vfs/lib/wcb

# Use this with -B to just update the source links when a new source file
# is present
newsrc: eskil.vfs/src/eskil.tcl

src/TAGS: $(SRCFILES)
	etags -o src/TAGS --regex="/proc[ \t]+\([^ \t]+\)/\1/" $(SRCFILES) \
	eskil.vfs/lib/*/*.tcl

setup: links src/TAGS

# Use this to rebuild the docs when command line changes or
# new wiki files are added.
docs:
	echo "<title>Usage</title>" > htdocs/usage.wiki
	echo "" >> htdocs/usage.wiki
	echo "<h1>Command Line Usage</h1>" >> htdocs/usage.wiki
	echo "" >> htdocs/usage.wiki
	echo "<verbatim>" >> htdocs/usage.wiki
	$(TCLKIT_LINUX) eskil.vfs/main.tcl -help | grep -v "  Version " >> htdocs/usage.wiki
	echo "</verbatim>" >> htdocs/usage.wiki
	echo "<title>Documentation</title>" > htdocs/toc.wiki
	echo "" >> htdocs/toc.wiki
	grep title htdocs/*.wiki | grep -v Documentation | \
	sed -e 's/htdocs/[./' -e 's/:<title>/|/' -e 's,</title>,],' | \
	awk '{print $0; print ""};' >> htdocs/toc.wiki
#----------------------------------------------------------------
# Testing
#----------------------------------------------------------------

spell:
	@cat doc/*.txt | ispell -d british -l | sort -u

CHKFILES = $(SRCFILES) $(wildcard plugins/*.tcl) \
	eskil.vfs/lib/psballoon/psballoon.tcl \
	eskil.vfs/lib/pstools/pstools.tcl
NAGELFARFLAGS = -s syntaxdb.tcl -pkgpicky -filter "*Non constant definition*" -quiet -plugin nfplugin.tcl

# Create a common "header" file for all source files.
eskil_h.syntax: $(SRCFILES) src/eskil.syntax nfplugin.tcl
	@echo Creating syntax header file...
	@$(NAGELFAR) $(NAGELFARFLAGS) -header eskil_h.syntax $(SRCFILES)

check: eskil_h.syntax
	@echo Checking...
	@for i in $(CHKFILES); do $(NAGELFAR)  $(NAGELFARFLAGS) eskil_h.syntax $$i ; done

test:
	@./tests/all.tcl $(TESTFLAGS)

run:
	$(TCLKIT_LINUX) eskil.vfs/main.tcl -debug

#----------------------------------------------------------------
# Coverage
#----------------------------------------------------------------

# Source files for code coverage
COVFILES = eskil.vfs/main.tcl eskil.vfs/src/rev.tcl eskil.vfs/src/eskil.tcl eskil.vfs/src/merge.tcl eskil.vfs/src/startup.tcl
IFILES   = $(COVFILES:.tcl=.tcl_i)
LOGFILES = $(COVFILES:.tcl=.tcl_log)
MFILES   = $(COVFILES:.tcl=.tcl_m)

# Instrument source file for code coverage
%.tcl_i: %.tcl eskil_h.syntax
	@$(NAGELFAR) -instrument eskil_h.syntax $<

# Target to prepare for code coverage run. Makes sure log file is clear.
instrument: $(IFILES)
	@rm -f $(LOGFILES)

# Run tests to create log file.
testcover $(LOGFILES): $(IFILES)

clean:
	@rm -f $(LOGFILES) $(IFILES) $(MFILES)

#----------------------------------------------------------------
# Packaging/Releasing
#----------------------------------------------------------------

tagversion:
	echo "Version $(DOTVERSION) `date --iso-8601`" > eskil.vfs/version.txt

wrap: tagversion
	sdx wrap eskil.kit

wrapexe: tagversion
	@\rm -f eskil.linux eskil.exe
	sdx wrap eskil.linux   -runtime $(TCLKIT_LINUX)
	sdx wrap eskil.mac     -runtime $(TCLKIT_MAC)
	cd eskil.vfs/lib ; ln -s $(TWAPI) twapi
	sdx wrap eskil.exe     -runtime $(TCLKIT_WIN)
	rm eskil.vfs/lib/twapi

release: setup wrap wrapexe
	@cp eskil.kit eskil`date +%Y%m%d`.kit
	@cp eskil.kit eskil$(VERSION).kit
	@gzip eskil.linux
	@mv eskil.linux.gz eskil$(VERSION).linux.gz
	@gzip eskil.mac
	@mv eskil.mac.gz eskil$(VERSION).mac.gz
	@zip eskil$(VERSION).win.zip eskil.exe
	@zip eskil`date +%Y%m%d`.win.zip eskil.exe

tofossil:
	fossil unversioned add eskil$(VERSION).kit      --as htdocs/download/eskil$(VERSION).kit
	fossil unversioned add eskil$(VERSION).linux.gz --as htdocs/download/eskil$(VERSION).linux.gz
	fossil unversioned add eskil$(VERSION).mac.gz   --as htdocs/download/eskil$(VERSION).mac.gz
	fossil unversioned add eskil$(VERSION).win.zip  --as htdocs/download/eskil$(VERSION).win.zip
	fossil unversioned list
	@echo 'Remember: fossil unversioned sync'

Dirdiff:
Funktion: preprocess filter på namnen så man kan jämföra bibliotek
med ändrade namn.


Print: utföra printkommando. Via dialog och -print? Klara t.ex. lp -n 2
Kanske generera pdf och pipea till lp?


Rev:
SVN: Vad göra med Log när -r är en branch?
Kan den fixas oom två -r är på samma branch?

Fossil: Kan man fixa Log om man använder -r -1?

These files need to be changed when bumping revisions:

Makefile (VERSION and DOTVERSION)
eskil.vfs/tclkit.inf (fileversion/productversion)

Also, mark it in:
Changes

------------
File Release

Make sure revision is bumped and everything is committed.
Clean run of make check / make test
make release
make tofossil

Update htdocs/download.html with info from above.
Update htdocs/changes.wiki
Update Changes

Commit, and do 'fossil unversioned sync'

---------------
New Source File

These changes are needed when adding a new source files:

Add source to e.g. src/apa.tcl  (plus add to fossil)
In src/startup.tcl, update InitReSource
In Makefile, update SRCFILES
Do make -B newsrc

  -clip       : Start in clip diff mode. Ignores other args.
  -patch      : View patch file.
  -           : Read patch file from standard input, to allow pipes.
  -review     : View revision control tree as a patch.
  -context <n>: Show only differences, with <n> lines of context.
  -foreach    : Open one diff window per file listed.
  -close      : Close windows with no changes.
  -sep <c>    : See char <c> as separator between columns in files.
  -gz         : Uncompress files.

  -noparse    : Eskil 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.

  -a <file>   : Give anscestor file for three way merge.
  -conflict   : Treat file as a merge conflict file and enter merge
                mode.
  -o <file>   : Specify merge result output file.
  -fine       : Use fine grained chunks. Useful for merging.

  -browse     : Bring up file dialog for missing files after starting
  -server     : Set up Eskil to be controllable from the outside.

  -print <file>          : Generate PDF and exit.
  -printCharsPerLine <n> : Adapt font size for this line length and wrap. (80)
  -printPaper <paper>    : Select paper size (a4)
  -printHeaderSize <n>   : Font size for page header (10)
  -printFont <fontfile>  : Select font to use in PDF, afm or ttf. If <fontfile>
                           is given as "Courier", PDF built in font is used.
  -printColorChange <RGB> : Color for change   (1.0 0.7 0.7)
  -printColorOld <RGB>    : Color for old text (0.7 1.0 0.7)
  -printColorNew <RGB>    : Color for new text (0.8 0.8 1.0)

  -plugin <name>       : Preprocess files using plugin.
  -plugininfo <info>   : Pass info to plugin (plugin specific)
  -pluginlist          : List known plugins
  -plugindump <plugin> : Dump plugin source to stdout
  -pluginallow         : Allow full access for a 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:
complete eskil 'C/-/`eskil --query -`/'

The files on display may be edited if you turn on Edit Mode.
This is done with the Tools->Edit Mode menu.
Onle real files may be edited. If you are comparing versions fetched from a
Revision Control system, it cannot be edited.

If an edited side has empty areas, i.e. lines that are not part of the file
and only there to line up with the other side, those will be gray.

Edit mode will not allow you to enter or remove newlines freely. Only by
copying blocks from other side lines may change.

By right clicking over a change's line numbers you get options to copy
lines and blocks between the two sides, as well as the options to save a file.

         \t           version do not parse big blocks to avoid long runs.
         \t  The Char and Word options selects if the line parsing should
         \t  highlight full words only, or check single characters.
         \t  Mark last  : Last change of a line is underlined
  Colours\t: Choose highlight colours.
  Context\t: You can select that only differing lines shall be displayed,
         \t  and how many surrounding lines are shown.
  Pivot  \t: If many lines in a file are equal, runtime may go up. By initially
         \t  disregarding such lines this can be kept at a more reasonable
         \t  level. The pivot sets how many lines must be equal to be ignored.
  Toolbar\t: Show/hide toolbar
  Save default\t: Save current option settings in ~/.eskilrc

<b>Search Menu</b>
  Find      \t: Search dialog
  Find next \t: Repeat search
  Find prev \t: Repeat search backwards

Eskil provides a plugin system where plugins can preprocess data
before being compared and displayed.

A plugin is a Tcl script that must follow a specific format.
Example plugins are included in the kit.
Dump one of the included plugins to see what it looks like.

When searching for a plugin "x", files "x" and "x.tcl" will
match. The search path is current directory, "plugins" directory,
the directory where Eskil is installed, "plugins" directory where
Eskil is installed, and also the internal "plugins" wrapped into Eskil.

The command line options for plugins are:
  -plugin plugin     : Use plugin
  -plugininfo info   : Pass info to plugin (plugin specific)
  -plugindump plugin : Dump plugin source to stdout
  -pluginlist        : List known plugins
  -pluginallow       : Allow full access privilege for a plugin.

A plugin may further define command line options that it accepts.
A way to see the plugin's options is to do:
eskil -plugin <plg> -help

Multiple -plugin may be given and they will be applied in the given
order. Any -plugininfo and -pluginallow belongs to the last -plugin
before them.

The plugin is executed in a safe interpreter and thus cannot do any
damage. You can turn this safety off with -pluginallow.

A plugin is set up with these global variables filled in:
::WhoAmI     : The name of the plugin
::WhoAmIFull : The full path to the plugin source
::Info       : The contents of -plugininfo parameter
::Pref       : A copy if Eskil's internal preferences array.
::File(left) : The name of the left file processed

::File(right): The name of the right file processed
::argv       : A copy of the command line from Eskil's invocation

A plugin may give a result that has a line-by-line correspondence to
the original, in which case the preprocessed data is used for comparing
while the original is used for displaying.  The main plugin procedure
should return 0 to signify this case.

If the plugin procedure returns 1, the processed data is used also for
displaying.


Directory diff only supports one plugin. The first plugin with FileCompare
defined will be used.

<pre>eskil -r rev file.txt</pre>
  Compare file.txt with the specified version.
<pre>eskil -r rev1 -r rev2 file.txt</pre>
  Compare the two revisions. This does not involve the local copy of file.txt.

The -r options are also available in the GUI in the "Rev 1" and "Rev 2" fields.

<ul>Directory Diff</ul>

Eskil can also browse and compare revisions for some systems directly in the
directory diff. It works just like for files, but give a directory on the
command line. Currently Git, Fossil and Subversion are supported.

<ul>Commit support</ul>

When comparing a file with the latest checked in version, some of the systems have support for committing directly from Eskil.  If supported, the Commit button will be enabled.
It is also possible to revert the local changes using the Revert button.

<ul>Priority between systems</ul>

If multiple systems are used within a directory Git/Hg/Bzr will be detected before CVS/SVN.  Command line options -cvs and -svn can be used to put preference on one of those systems.

<ul>Pipe a patch</ul>

Eskil can read a patch from standard input, thus allowing display from any patch generating command. Examples:
<pre>hg diff | eskil -</pre>
<pre>git diff -p --diff-filter=M master | eskil -</pre>

<ul>View all changes</ul>

If the command line option -review is used, Eskil will generate a patch
for the current tree and display it as in patch mode.
E.g. in a Mercurial directory, these show the same thing:
<pre>eskil -review</pre>
<pre>hg diff | eskil -</pre>

If file names are given after -review, only the listed files are included. If supported,
the Commit button will be enabled allowing the viewed differences to be committed.

<ul>RCS/CVS</ul>

For RCS and CVS the arguments to -r are standard version numbers just like to their -r options.
If a revision is an integer, it is added to the last number in the current version, thus giving relative versions.  E.g. -1 gives the second to last version.

<ul>Subversion</ul>

For Subversion the arguments to -r are standard version numbers just like its -r option.  If a revision is a negative integer, the log is searched backwards for earlier versions. E.g. -1 gives the second to last version.

<ul>Git</ul>

For Git -r <rev> is passed to show, as in "git show <rev>:<file>".

<pre>git config --global merge.tool eskil</pre>
<pre>git config --global mergetool.eskil.cmd 'eskil -fine -a $BASE -o $MERGED $REMOTE $LOCAL'</pre>
<pre>git config --global diff.tool eskil</pre>
<pre>git config --global difftool.eskil.cmd 'eskil $LOCAL $REMOTE'</pre>

<ul>Fossil</ul>

For Fossil -r <rev> is passed to finfo, as in "fossil finfo -p <file> -r <rev>".

Additionaly, if a revision is a negative integer, the log is searched backwards
for earlier versions. E.g. -1 gives the second to last version. The search
follows the current branch from the current version.

<pre>fossil settings gmerge-command 'eskil -fine -a "%baseline" "%merge" "%original" -o "%output"' -global</pre>

<ul>Mercurial</ul>

For Mercurial -r works as in "hg cat -r".
However, Eskil interprets zero or negative numbers as going back from the tip, i.e. -1 is one step back, corresponding to -2 in Mercurial.

Mercurial is supported in the Directory Diff, but needs the hglist extension to
display correct file sizes and dates. If not they are faked using the file's
sha1 and thus unique per file and gives a correct result in comparison.

To use Eskil for conflict resolution these config settings can be used.

[merge-tools]
eskil.args = -fine -a $base $other $local -o $output
eskil.priority = 1

<ul>Bazaar</ul>

For Bazaar -r works as in "bzr cat -r".

<ul>ClearCase</ul>

<b>Three way merge</b>
<bullet>
\u2022\tDouble click on merge.txt to bring up the diff.
\u2022\tSelect menu File->Open Ancestor File.
\u2022\tSelect file mergeanc.txt
</bullet>
The merge window will appear with most changes merged.  Conflicts are marked with gray, and a row of asterisks in the status bar.  Conflicts are resolved to the right initially.  Navigate between conflicts using ctrl-up/down keys. Select side with left/right keys. Hover over the status bar to see ancestor info.

<b>Regular expression preprocessing</b>

Sometimes there are things in files being compared that you want to highlight or disregard. This preprocessing step applies search/replace regular expressions on the files being compared before lines are matched. The result is only used for determining equality. The original is always used for display and if lines differ after preprocessing, all changes are shown for that line.

[add reference to re_syntax and regsub manuals]

Double click on enum.c to bring up the diff.
<bullet>
\u2022\tSelect menu Options->Preprocess.
\u2022\tIf there is no clear set, press "Add" to add a new preprocessing set.
\u2022\tPress "Edit" to edit that preprocessing set.
\u2022\tEnter the regular expression "^.*?\\m(Apa\\w+).*$" in the Regexp field.
\u2022\tEnter "\\1" in the substitution field.
\u2022\tEnter a word starting with "Apa" in one of the example fields and see that the result is just that word.
\u2022\tPress "Ok" and select menu File->Redo Diff.
</bullet>
A shortcut for the above is to use "-prefix Apa" on the command line, or to use the "Add Prefix" button and enter "Apa" as prefix.

<b>Changed filename in directory diff</b>
<bullet>
\u2022\tRight click on "namechange1" in Directory Diff's left window.
\u2022\tSelect "Mark File" in the menu.
\u2022\tRight click on "namechange2" in Directory Diff's right window.
\u2022\tSelect "Compare with..." in the menu.

# Tcl package index file, version 1.1
# This file is generated by the "pkg_mkIndex" command
# and sourced either when an application starts up or
# by a "package unknown" script.  It invokes the
# "package ifneeded" command to set up package-related
# information so that packages will be loaded automatically
# in response to "package require" commands.  When this
# script is sourced, the variable $dir must contain the
# full path name of this file's directory.

package ifneeded psballoon 1.2 [list source [file join $dir psballoon.tcl]]

#----------------------------------------------------------------------
#
#  psballoon.tcl,
#   Procedures to create help message balloons or display balloons for
#   listboxes and labels that can't display all of their contents.
#
#  Copyright (c) 2003, Peter Spjuth  (peter.spjuth@gmail.com)
#
#  Permission is granted to use this code under the same terms as
#  for the Tcl core code.
#
#----------------------------------------------------------------------
# $Revision: 1.1 $
#----------------------------------------------------------------------

package provide psballoon 1.2

namespace eval psballoon {
    variable balloon
    variable config

    set config(-useframe) 0
    set balloon(W) ""
    set balloon(pending) 0
    set balloon(created) 0
    set balloon(id) ""
    namespace export addBalloon
}

# -useframe <bool>
proc psballoon::configure {args} {
    variable config
    foreach {arg val} $args {
        set config($arg) $val
    }
}

# Do some simple formatting, to be able to have cleaner text in source
proc psballoon::Fmt {msg} {
    # Remove any newlines.
    set msg [regsub -all "\n" $msg " "]
    # Remove multiple whitespace
    set msg [regsub -all {\s+} $msg " "]
    set msg [string trim $msg]
    # Any explicitly requested newlines?
    set msg [regsub -all {\\n\s*} $msg "\n"]
    # Further line breaks by length?
    set lines {}
    foreach line [split $msg \n] {
        while {[string length $line] > 80} {
            # There should be no path through this loop that does not
            # shorten $line
            set ix [string last " " $line 80]
            if {$ix < 0} {
                set ix [string first " " $line]
                if {$ix < 0} {
                    # Just cut at 80
                    set ix 80
                }
            }

            if {$ix == 0} {
                set line [string trim $line]
            } else {
                lappend lines [string range $line 0 $ix-1]
                set line [string range $line $ix+1 end]
            }
        }
        lappend lines $line
    }
    set msg [join $lines \n]
    return $msg
}

# addBalloon widget ?widgets...? ?-fmt? ?msg?
# If message is not given, it is extracted from widget. This is used to show
# e.g. labels where text might not be fully visible.
# Message may contain callbacks in [] for dynamic text.
proc psballoon::addBalloon {W args} {
    variable balloon
    variable config

    set frame $config(-useframe)

    # Last argument is message
    set msg [lindex $args end]

    set Wlist [list $W]
    foreach arg [lrange $args 0 end-1] {
        switch $arg {
            -fmt {
                # Request for formatting
                if {$msg ne ""} {
                    set msg [Fmt $msg]
                }
            }
            -frame {
                set frame 1
            }
            -top {
                set frame 0
            }
            default {
                lappend Wlist $arg
            }
        }
    }

    foreach W $Wlist {
        AddBalloon2 $W $msg $frame
    }
}

proc psballoon::AddBalloon2 {W msg frame} {
    variable balloon

    set c [winfo class $W]
    if {$msg == "" && $c != "Listbox" && $c != "Label"} {
        error "Missing message to balloon for $W ($c)"
    }
    set balloon(msg,$W) $msg
    set balloon(frame,$W) $frame

    if {$msg eq "_"} {
        bind $W <Enter> ""
        bind $W <Button> ""
        bind $W <Leave> ""
        bind $W <Motion> ""
        return
    }

    bind $W <Enter> {
        set ::psballoon::balloon(pending) 1
        set ::psballoon::balloon(created) 0
        set ::psballoon::balloon(lastX) %X
        set ::psballoon::balloon(lastY) %Y
        set ::psballoon::balloon(id) [after 500 {psballoon::createBalloon %W %x %y}]
    }
    bind $W <Button> {
        psballoon::killBalloon
    }
    bind $W <Leave> {
        psballoon::killBalloon
    }
    bind $W <Motion> {
        psballoon::motionBalloon %W %X %Y %x %y
    }
}

proc psballoon::motionBalloon {W X Y x y} {
    if {$::psballoon::balloon(pending) == 1} {
        after cancel $::psballoon::balloon(id)
    }
    if {$::psballoon::balloon(created) == 1} {
        if {$::psballoon::balloon(lastX) == $X && \
                    $::psballoon::balloon(lastY) == $Y} {
            # Sometimes when the balloon is created, a motion event with
            # the same coordinates arrive. Ignore that to avoid killing the
            # new balloon.
            return
        }
        psballoon::killBalloon
    }
    set ::psballoon::balloon(lastX) $X
    set ::psballoon::balloon(lastY) $Y
    set ::psballoon::balloon(id) [after 500 "psballoon::createBalloon $W $x $y"]
    set ::psballoon::balloon(pending) 1

}

proc psballoon::killBalloon {} {
    variable balloon
    if {$balloon(pending) == 1} {
        after cancel $balloon(id)
    }
    if {[winfo exists $balloon(W)]} {
        destroy $balloon(W)
    }
    set balloon(created) 0
    set balloon(pending) 0
}

# Measure display width needed for a text with line breaks
proc psballoon::Measure {font txt} {
    set len 0
    foreach line [split $txt \n] {
        set lw [font measure $font $line]
        if {$lw > $len} {
            set len $lw
        }
    }
    return $len
}

# Returns a list of minX maxX for each screen.
# maxX are exclusive and normally equal to the next minX
proc psballoon::FigureOutScreenWidths {W} {
    set screens {}
    # Range of X over multiple windows
    set minX [winfo vrootx $W]
    set maxX [expr {$minX + [winfo vrootwidth $W]}]
    set sW [winfo screenwidth $W]

    # Guess: If minX is negative, there is a screen from minX to 0
    if {$minX < 0} {
	lappend screens $minX 0
    }
    # Guess: Main screen is in the middle if three

    # Main screen is 0 to screenWidth
    lappend screens 0 $sW

    # Guess: If maxX is larger than screen width (main screen), there
    # is one more screen to the right
    if {$maxX > $sW} {
	lappend screens $sW $maxX
    }
    return $screens
}

proc psballoon::createBalloon {W mouseX mouseY} {
    variable balloon
    variable config
    if { ! [winfo exists $W]} {
        return
    }
    if {$balloon(created)} {
        return
    }

    # Figure out widget's font
    if {[catch {set font [$W cget -font]}]} {
        set font [ttk::style lookup [winfo class $W] -font]
    }
    # Fallback to something reasonable if font fails.
    if {$font eq ""} {
        set font TkDefaultFont
    }

    # Widget Geometry
    set wWidth [winfo width $W]
    set wHeight [winfo height $W]
    if {[winfo class $W] in {TLabelframe Labelframe TNotebook}} {
        # Put it below the label, not the entire widget.
        # 1.5 font heights is a reasonable guess
        set fontHeight [font metrics $font -linespace]
        set wHeight [expr {$fontHeight * 3 /2 }]
        # Below cursor at least
        if {$wHeight <= $mouseY} {
            set wHeight [expr {$mouseY + 5}]
        }
    }

    # Item Geometry within Widget (if any)
    set itemX 0
    set itemY 0
    set create 1
    set msg $balloon(msg,$W)
    if {$msg == ""} {
        # Extract text from widget
        switch [winfo class $W] {
            Listbox {
                set i [$W index @$mouseX,$mouseY]
                set msg [$W get $i]
                foreach {itemX itemY itemWidth wHeight} [$W bbox $i] {break}
                set bWidth $itemWidth
            }
            Label {
                set msg [$W cget -text]
                set bWidth [Measure $font $msg]
            }
        }
        # Don't create a balloon if the text is fully visible.
        set create [expr {$bWidth > $wWidth - 8}]
    } else {
        if {[string index $msg 0] eq "\["} {
            set msg [subst -novariables -nobackslashes $msg]
        }
        set bWidth [Measure $font $msg]
    }

    if {!$create} return

    # Preferred position of the balloon
    set rootX [expr {[winfo rootx $W] + $itemX}]
    set rootY [expr {[winfo rooty $W] + $itemY + $wHeight + 2}]

    set useframe $balloon(frame,$W)

    if {$useframe} {
        set top [winfo toplevel $W]
        set posX [expr {$rootX - [winfo rootx $top]}]
        set posY [expr {$rootY - [winfo rooty $top]}]
        set minX 6
        set maxX [expr {[winfo width $top] - 6}]
    } else {
        set posX $rootX
        set posY $rootY

        # Limits of current screen.
        foreach {minX maxX} [FigureOutScreenWidths $W] {
            if {$minX <= $rootX && $rootX < $maxX} break
        }
    }
    # Move it to the left as needed to fit on screen
    if {$posX + $bWidth + 8 > $maxX} {
        set posX [expr {$maxX - $bWidth - 8}]
    }

    if {$useframe} {
        if {$top eq "."} {
            set B .balloon
        } else {
            set B $top.balloon
        }
        frame $B -borderwidth 1 -relief solid
    } else {
        set B .balloon
        toplevel $B -bg black
        wm overrideredirect $B 1
    }
    label $B.l \
            -text $msg -relief flat -font $font -justify left \
            -bg #ffffaa -fg black -padx 2 -pady 0 -anchor "w"
    pack $B.l -side left -padx 1 -pady 1
    if {$useframe} {
        place $B -x $posX -y $posY -anchor nw
    } else {
        wm geometry $B +${posX}+${posY}

    }

    set balloon(W) $B
    set balloon(created) 1
}

    interp alias {} _ipexists loadinterp info exists
    interp alias {} _ipset    loadinterp set
    interp alias {} _iparray  loadinterp array

    interp invokehidden loadinterp source $file

    foreach arg $args {
        ##nagelfar vartype arg varName
        upvar 1 $arg TheVar
        if {[_iparray exists $arg]} {
            foreach {key val} [_iparray get $arg] {
                if {[info exists TheVar($key)]} {
                    set TheVar($key) $val
                }
            }

        $w configure -yscrollcommand [list pstools::CommonYScroll_YScroll $sby]
    }
    set yscroll($sby) $args
}

# A simple window for displaying e.g. help.
# Returns the frame where things can be put.
proc pstools::helpWin {W title} {
    destroy $W

    toplevel $W -padx 2 -pady 2
    wm title $W $title
    bind $W <Key-Return> [list destroy $W]
    bind $W <Key-Escape> [list destroy $W]
    frame $W.f
    button $W.b -text "Close" -command [list destroy $W] -width 10 \
            -default active
    pack $W.b -side bottom -pady 2
    pack $W.f -side top -expand y -fill both -padx 2 -pady 2
    focus $W
    return $W.f
}

# Figure out a place to store temporary files.
proc pstools::locateTmp {globVar} {
    upvar "#0" $globVar var

    set candidates {}

# This is called when an editor is needed to display a file.
# It sets up the variable with the path, unless the var
# already exists.
proc pstools::locateEditor {globVar} {
    upvar "#0" $globVar var

    if {[info exists var]} return

    set candidates {}
    if {[info exists ::env(VISUAL)]} {
        lappend candidates $::env(VISUAL)
    }
    if {[info exists ::env(EDITOR)]} {
        lappend candidates $::env(EDITOR)
    }
    if {$::tcl_platform(platform) == "windows"} {
        # Try to locate some common installation points for Emacs
        set dirs [glob -nocomplain c:/apps/emacs*]


        lappend dirs {*}[glob -nocomplain "C:/Program Files/emacs*"]
        lappend dirs {*}[glob -nocomplain "C:/Program Files/emacs*/*"]
        foreach dir [lsort -decreasing -dictionary $dirs] {

            set em [file join $dir bin runemacs.exe]
            set em [file normalize $em]
            if {[file exists $em]} {
                lappend candidates $em
                break
            }
        }
        lappend candidates runemacs wordpad
    }
    # What is a good value on Mac?

    # Add some more for fallback
    lappend candidates emacs gvim gedit kate

    foreach cand $candidates {
        if {[auto_execok $cand] ne ""} {
            set var [list $cand]
            return
        }
    }
    # If we fall through here we are kind of lost...
    set var "could_not_find_editor"
}

package require starkit
starkit::startup
source $::starkit::topdir/src/startup.tcl

CompanyName "Peter Spjuth"
LegalCopyright "Copyright (c) 1998-2021 Peter Spjuth et al."
FileDescription "File difference viewer"
ProductName "Eskil"
ProductVersion "2.8.5"
FileVersion "2.8.5"

head1,head2,head3,head4,head5,head6,head7,head8,head9,head10
MCPM,JFPC,FJ9S9,J1J,CC3,72<C,;P>HJ,RN?I,O48,BH<<
RKBO,@P:,GGG0,=8FNP,P6K,I@4,44H,48RG,1ODB:,SN:O?
CM7,M75,PML7@,I1:,EMRL,KHK,J3IQ,N4:CJ,2H:F=,L;9I
a,b,c,d,e,f,g,h,i,j
9R6,MQPJA,BL1,0NCR,6BEH0,DC=,D@F,I9J19,L8M99,DQHEE
GGK,OB?PM,I9S;K,060,AHO=8,JC46O,J>=,11?,QNEP,I1Q
:9E<C,P1S,R=PG?,SI=,<P0L5,6<C5<,=P?5E,E5HE?,@L=,N=P=1
0>A,3LPO,>27,BHA6,A3<,ODLH,01?L5,HL<D,SPR>J,KF>S=
601,QK<26,1H>,PAQ,H2P,C@=,J?59<,;MG,E>8KF,BD6I
M>SR,KA3L,PJG,HMF=G,<79I,B3;4<,1>D,JOPM,K:R7,HK<
CK9NB,G;10O,<M6=,>K2;,S6>7,O12KG,@RM,QN>,=<1<,D?CJ
PM2;K,JPQR?,<;7C3,H5SO,6M9,OL;@D,?4H>I,Q3F,E8ODJ,2P;<Q
7O94,?LFG,R=4M,<RLO7,0MHF,3K:?,ENG,8@@HG,?>2O,C7QN=
F036,>FOG0,EI<91,2H5P1,AAPP?,N58HI,RRRN;,J?A6B,;:;C,19KL
SG?H2,:<7,NLS@0,=7GA,5IJ,MLQO,4N0>=,9SRJ,7<?F:,N?9NF
;0I,J8;1:,O>?PM,>P9E5,1O9,=5?,JCGB,A940,D;8MB,B2L
E8Q2F,D12L,JL7ME,P0QPN,6@B,FEHI,QAF69,PIK,4KO,:C?
G8:,J19EL,?2L,6EOBA,D:B,6N>,2G2,F6<,@B8,@BNC?
ERG0J,:7R,DCD,QBBNQ,OBB1,G8@,9QNE,D3S,306,HCM?S
4MJ,;C4,:72BJ,=M;5,64@,:73:3,3SO,?SRJO,59<L9,@N63
63N,1RG,HS9,7AR=,2G8P,SGS,5IH1H,7QD0,=15Q,NC5
FBH;;,H@2S?,21N?,;NMCG,D4S<,<>R,73HHF,4=2,?J?7,C0;
KPG64,QI442,3OCQ,50C2K,M>9C,>9<,CNA1J,>9Q,@RJ4S,899
3;RS,H3;@5,<:C,1OAL,J=85K,PI6,OIA,FQ4S,H?53P,;SBD4
?==,<0A;,:3;Q,3FH,<3N,=D0,ASSH,>E1M,E44I,5S:
RRHBE,0A1M:,DKLIA,NSN,KA:@,BG3,=193,6G;6E,H92,<J4B
:72,6DH6O,OBI,5GOB,0R39:,<<C,6H:,<297,2E;MO,0MCR
A6LN,RD2S,AD20,F7:9,7PJ4@,O@4:9,O92,60I,1AE<,LBN
<NOC,;;9,DAI,C;@<<,?1P1,P?LEM,2GC,::IC,S=DO,?<GIS
;MS,K5HM,8HEP,<0=N,5HJC,15P@O,MSORD,9;NF,R;>@,MS?BR
KPFLI,A>LCB,Q:?C,<?H,8<JH,<@LM8,A06GB,?=R:>,72P,EME

head1	head2	head3	head4	head5	head6	head7	head8	head9	head10
MCPM	JFPC	FJ9S9	J1J	CC3	72<C	;P>HJ	RN?I	O48	BH<<
RKBO	@P:	GGG0	=8FNP	P6K	I@4	44H	48RG	1ODB:	SN:O?
CM7	M75	PML7@	I1:	EMRL	KHK	J3IQ	N4:CJ	2H:F=	L;9I
a	b	c	d	e	f	g	h	i	j
9R6	MQPJA	BL1	0NCR	6BEH0	DC=	D@F	I9J19	L8M99	DQHEE
GGK	OB?PM	I9S;K	060	AHO=8	JC46O	J>=	11?	QNEP	I1Q
:9E<C	P1S	R=PG?	SI=	<P0L5	6<C5<	=P?5E	E5HE?	@L=	N=P=1
0>A	3LPO	>27	BHA6	A3<	ODLH	01?L5	HL<D	SPR>J	KF>S=
601	QK<26	1H>	PAQ	H2P	C@=	J?59<	;MG	E>8KF	BD6I
M>SR	KA3L	PJG	HMF=G	<79I	B3;4<	1>D	JOPM	K:R7	HK<
CK9NB	G;10O	<M6=	>K2;	S6>7	O12KG	@RM	QN>	=<1<	D?CJ
PM2;K	JPQR?	<;7C3	H5SO	6M9	OL;@D	?4H>I	Q3F	E8ODJ	2P;<Q
7O94	?LFG	R=4M	<RLO7	0MHF	3K:?	ENG	8@@HG	?>2O	C7QN=
F036	>FOG0	EI<91	2H5P1	AAPP?	N58HI	RRRN;	J?A6B	;:;C	19KL
SG?H2	:<7	NLS@0	=7GA	5IJ	MLQO	4N0>=	9SRJ	7<?F:	N?9NF
;0I	J8;1:	O>?PM	>P9E5	1O9	=5?	JCGB	A940	D;8MB	B2L
E8Q2F	D12L	JL7ME	P0QPN	6@B	FEHI	QAF69	PIK	4KO	:C?
G8:	J19EL	?2L	6EOBA	D:B	6N>	2G2	F6<	@B8	@BNC?
ERG0J	:7R	DCD	QBBNQ	OBB1	G8@	9QNE	D3S	306	HCM?S
4MJ	;C4	:72BJ	=M;5	64@	:73:3	3SO	?SRJO	59<L9	@N63
63N	1RG	HS9	7AR=	2G8P	SGS	5IH1H	7QD0	=15Q	NC5
FBH;;	H@2S?	21N?	;NMCG	D4S<	<>R	73HHF	4=2	?J?7	C0;
KPG64	QI442	3OCQ	50C2K	M>9C	>9<	CNA1J	>9Q	@RJ4S	899
3;RS	H3;@5	<:C	1OAL	J=85K	PI6	OIA	FQ4S	H?53P	;SBD4
?==	<0A;	:3;Q	3FH	<3N	=D0	ASSH	>E1M	E44I	5S:
RRHBE	0A1M:	DKLIA	NSN	KA:@	BG3	=193	6G;6E	H92	<J4B
:72	6DH6O	OBI	5GOB	0R39:	<<C	6H:	<297	2E;MO	0MCR
A6LN	RD2S	AD20	F7:9	7PJ4@	O@4:9	O92	60I	1AE<	LBN
<NOC	;;9	DAI	C;@<<	?1P1	P?LEM	2GC	::IC	S=DO	?<GIS
;MS	K5HM	8HEP	<0=N	5HJC	15P@O	MSORD	9;NF	R;>@	MS?BR
KPFLI	A>LCB	Q:?C	<?H	8<JH	<@LM8	A06GB	?=R:>	72P	EME

A file with a keyword in it.
$Revision:abc$

abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäö
hopp
abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdef

Misc examples of diffs.
A line with some inline changes.
1
11
111
One line against many.
2
22
222
Apa 1
Bepa 1
Cepa 1
3
33
333
The following is a real-life tricky case that currently do not show up well.
  WrImmediate16 TME_TmEnCfg0 0563
  WrImmediate16 TME_TmEnCfg1 0212
  WrImmediate16 TME_TmIdCfg 0200
  WrImmediate32 TME_Bat0 21323130
  WrImmediate32 TME_Bat1 21323130
  WrImmediate32 TME_Bat2 21323130
  WrImmediate32 TME_Bat3 21323130
  WrImmediate32 TME_VcCfgA 00400FCA
  WrImmediate32 TME_VcCfgB 004007C1
  WrImmediate32 TME_VcCfgC 004007C1
4
44
444
Apa 1
Bepa 1
Cepa 1
5
55
555
Apa 1
Bepa 1
Cepa 1
Depa 1
6
66
666

head1,head2,head3,head4,head5,head6,head7,head8,head9,head10
MCPM,JFPC,FJ9S9,J1J,CC3,72<C,;P>HJ,RN?I,O48,BH<<
RKBO,@P:,GGG0,=8FNP,P6K,O@GJ>,44H,48RG,1ODB:,SN:O?
CM7,M75,PML7@,I1:,EMRL,KHK,J3IQ,N4:CJ,2H:F=,L;9I
9R6,MQPJA,BL1,0NCR,6BEH0,DC=,D@F,I9J19,L8M99,DQHEE
GGK,OB?PM,I9S;K,060,AHO=8,JC46O,J>=,11?,QNEP,I1Q
:9E<C,P1S,R=PG?,SI=,<P0L5,6<C5<,G012D,E5HE?,@L=,=?=
0>A,3LPO,>27,BHA6,A3<,ODLH,01?L5,PN:R,SPR>J,KF>S=
601,QK<26,1H>,PAQ,H2P,C@=,J?59<,;MG,E>8KF,BD6I
M>SR,KA3L,PJG,HMF=G,<79I,B3;4<,1>D,JOPM,=AR,HK<
CK9NB,G;10O,:4JG9,>K2;,S6>7,O12KG,@RM,QN>,=<1<,D?CJ
PM2;K,JPQR?,7DI,H5SO,6SJA,OL;@D,?4H>I,Q3F,E8ODJ,2P;<Q
7O94,?LFG,R=4M,<RLO7,0MHF,3K:?,ENG,8@@HG,EM>,C7QN=
F036,>FOG0,EI<91,2H5P1,AAPP?,N58HI,RRRN;,J?A6B,;:;C,19KL
0PPF@,:<7,NLS@0,=7GA,5IJ,MLQO,4N0>=,9SRJ,7<?F:,N?9NF
;0I,J8;1:,O>?PM,>P9E5,72K5,=5?,JCGB,03I<,D;8MB,B2L
E8Q2F,D12L,JL7ME,PH01C,:A21,FEHI,QAF69,PIK,4KO,SFPI
G8:,F51,?2L,6EOBA,D:B,6N>,2G2,F6<,Q=7K,@BNC?
ERG0J,:7R,DCD,QBBNQ,OBB1,G8@,9QNE,=4M:,306,HCM?S
4MJ,;C4,:72BJ,=M;5,64@,?1A0D,3SO,A2C7,59<L9,?5B<
63N,1RG,HS9,7AR=,2G8P,SGS,5IH1H,7QD0,=15Q,NC5
FBH;;,H@2S?,21N?,;NMCG,D4S<,<>R,73HHF,4=2,?J?7,C0;
KPG64,QI442,3OCQ,50C2K,M>9C,>9<,CNA1J,>9Q,@RJ4S,899
3;RS,H3;@5,<73,1OAL,J=85K,PI6,OIA,FQ4S,H?53P,;SBD4
?==,<0A;,:3;Q,3FH,<3N,=D0,ASSH,:>M,E44I,5S:
RRHBE,0A1M:,DKLIA,=DM,KA:@,66S6,=193,6G;6E,H92,<J4B
:72,6DH6O,OBI,5GOB,0R39:,<<C,LFQ<,<297,2E;MO,<S9AI
a,b,c,d,e,f,g,h,i,j
A6LN,RD2S,AD20,F7:9,7PJ4@,O@4:9,O92,60I,1AE<,LBN
<NOC,;;9,DAI,C;@<<,?1P1,P?LEM,2GC,::IC,S=DO,?<GIS
;MS,K5HM,8HEP,<0=N,5HJC,15P@O,MSORD,9;NF,R;>@,MS?BR
KPFLI,A>LCB,Q:?C,D49J?,KKCI,<@LM8,A06GB,?=R:>,72P,EME

head1	head2	head3	head4	head5	head6	head7	head8	head9	head10
MCPM	JFPC	FJ9S9	J1J	CC3	72<C	;P>HJ	RN?I	O48	BH<<
RKBO	@P:	GGG0	=8FNP	P6K	O@GJ>	44H	48RG	1ODB:	SN:O?
CM7	M75	PML7@	I1:	EMRL	KHK	J3IQ	N4:CJ	2H:F=	L;9I
9R6	MQPJA	BL1	0NCR	6BEH0	DC=	D@F	I9J19	L8M99	DQHEE
GGK	OB?PM	I9S;K	060	AHO=8	JC46O	J>=	11?	QNEP	I1Q
:9E<C	P1S	R=PG?	SI=	<P0L5	6<C5<	G012D	E5HE?	@L=	=?=
0>A	3LPO	>27	BHA6	A3<	ODLH	01?L5	PN:R	SPR>J	KF>S=
601	QK<26	1H>	PAQ	H2P	C@=	J?59<	;MG	E>8KF	BD6I
M>SR	KA3L	PJG	HMF=G	<79I	B3;4<	1>D	JOPM	=AR	HK<
CK9NB	G;10O	:4JG9	>K2;	S6>7	O12KG	@RM	QN>	=<1<	D?CJ
PM2;K	JPQR?	7DI	H5SO	6SJA	OL;@D	?4H>I	Q3F	E8ODJ	2P;<Q
7O94	?LFG	R=4M	<RLO7	0MHF	3K:?	ENG	8@@HG	EM>	C7QN=
F036	>FOG0	EI<91	2H5P1	AAPP?	N58HI	RRRN;	J?A6B	;:;C	19KL
0PPF@	:<7	NLS@0	=7GA	5IJ	MLQO	4N0>=	9SRJ	7<?F:	N?9NF
;0I	J8;1:	O>?PM	>P9E5	72K5	=5?	JCGB	03I<	D;8MB	B2L
E8Q2F	D12L	JL7ME	PH01C	:A21	FEHI	QAF69	PIK	4KO	SFPI
G8:	F51	?2L	6EOBA	D:B	6N>	2G2	F6<	Q=7K	@BNC?
ERG0J	:7R	DCD	QBBNQ	OBB1	G8@	9QNE	=4M:	306	HCM?S
4MJ	;C4	:72BJ	=M;5	64@	?1A0D	3SO	A2C7	59<L9	?5B<
63N	1RG	HS9	7AR=	2G8P	SGS	5IH1H	7QD0	=15Q	NC5
FBH;;	H@2S?	21N?	;NMCG	D4S<	<>R	73HHF	4=2	?J?7	C0;
KPG64	QI442	3OCQ	50C2K	M>9C	>9<	CNA1J	>9Q	@RJ4S	899
3;RS	H3;@5	<73	1OAL	J=85K	PI6	OIA	FQ4S	H?53P	;SBD4
?==	<0A;	:3;Q	3FH	<3N	=D0	ASSH	:>M	E44I	5S:
RRHBE	0A1M:	DKLIA	=DM	KA:@	66S6	=193	6G;6E	H92	<J4B
:72	6DH6O	OBI	5GOB	0R39:	<<C	LFQ<	<297	2E;MO	<S9AI
a	b	c	d	e	f	g	h	i	j
A6LN	RD2S	AD20	F7:9	7PJ4@	O@4:9	O92	60I	1AE<	LBN
<NOC	;;9	DAI	C;@<<	?1P1	P?LEM	2GC	::IC	S=DO	?<GIS
;MS	K5HM	8HEP	<0=N	5HJC	15P@O	MSORD	9;NF	R;>@	MS?BR
KPFLI	A>LCB	Q:?C	D49J?	KKCI	<@LM8	A06GB	?=R:>	72P	EME

A file with a keyword in it.
$Revision:b$

abcdefghijklmnop
abcdefxhijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrs1uvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklm2opqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäö
hej
hopp
abcdefghi2klmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzåäöabcdefghijklmnopqrstuvwxyza4cdef

Misc examples of diffs.
A line 1 with sume line changes.
1
11
111
Surrounding line1
One line against many others.
Surrounding line2
Surrounding line3
2
22
222
Bepa 2
Gurka
Cepa 2
3
33
333
The following is a real-life tricky case that currently do not show up well.
  WrImmediate16 TME_TmIdCfg 0204
  WrImmediate16 TME_VcCfgA 0FC7
  WrImmediate32 TME_VcCfgB 00400FC1
  WrImmediate32 TME_VcCfgC 00400FC1
4
44
444
Cepa 2
Gurka
5
55
555
Bepa 2
Apa 2
Cepa 2
6
66
666

<title>Changes</title>

Upcoming changes (not yet released):

  *  TBW

Changes in v2.8.5 (2023-04-27):

  *  Added -printLineSpace.
  *  Support -context/-w/-b for -review.
  *  Added gunzip plugin.
  *  Added -includedir and -includefile options for directory diff.
  *  Allow multiple pairs of files on the command line to open multiple windows.
  *  Added -subst command line, to access PreProcess Subst function.
  *  Better SVN commit, handling added directories.
  *  Ctrl-E to enable Edit Mode.
  *  Allow copying selected lines in Edit Mode.
  *  Allow deleting any line in Edit Mode.

Changes in v2.8.4 (2019-02-06):

  *  Commit dialog includes a selection of files, for partial commit.
  *  Better support for multiple files and directories with -review.
  *  Added save-reload option in edit mode.
  *  Bug-fix with deleted files in GIT directory diff.

Changes in v2.8.3 (2018-06-13):

  *  More features in Four-way diff.
  *  Better visibility that commit happened.
  *  Shortcuts in preprocess dialog for common patterns.

Changes in v2.8.2 (2018-05-13):

  *  Added Four-way diff, for comparing changes.
  *  Bug-fix in revision handling for Fossil.

Changes in v2.8.1 (2018-01-14):

  *  Repaired plugins for directory diff (broken by multi plugin in 2.8.0).
  *  Added -excludedir and -excludefile options for directory diff.
  *  Handle GIT revisions better for directory diff.
  *  Support -nocase in directory diff.
  *  Directory diff no longer shortcuts for files with same size&mtime.
  *  Removed support for old RCS style -rREV command line.
  *  Corrected detected of Emacs for Registry. (Broken in 2.7.4)

Changes in v2.8.0 (2017-12-05):

  *  Handle multiple plugins.
  *  Upgraded DiffUtil to 0.4.0 which is significantly faster for large files.
  *  Default pivot is now 10. Added GUI choice for pivot 1.

Changes in v2.7.4 (2017-11-30):

  *  Handle multiple preprocess definitions that can be saved with preferences.
  *  Preserve line endings when saving during Edit Mode.
  *  Added -gz flag to compare compressed files.
  *  Allow multi select in table diff.
  *  Allow one side of directory diff to be protected from editing.
  *  Allow directories to be created in directory diff.
  *  When needing an editor, try VISUAL and EDITOR plus a set of common ones.

Changes in v2.7.3 (2016-08-30):

  *  Requires Tcl 8.6
  *  GUI support for table and separator.

Changes in v2.7.2 (2016-08-15):

  *  Corrected right side numbering when parsing patch.
  *  Word parse now consistently uses non-space as word char.
  *  New [./table.wiki | table] view, activated by -table, when comparing tables.
  *  Mercurial support for Directory Diff, Commit, Revert and Log.
  *  GIT support for negative revisions and log view.
  *  Printed PDF is now compressed.
  *  Printed PDF from patch view adds page break between files.
  *  Plugins can define command line options they accept.
  *  Plugins can read ::argv to know the given command line.
  *  New plugin for binary files
  *  New plugin for CSV files
  *  Added option -sep, to set a separator that makes input be interpreted
     in a table like manner.
  *  New plugin for PDF files
  *  Added option -pluginallow to run plugins in a standard interpreter instead
     of a safe one. Thus a plugin could use e.g. exec.
  *  Allow plugins to yield if Eskil is run in Tcl 8.6 or newer.
     Added swap plugin to exemplify this.

Changes in v2.7 (2015-03-09):

  *  Directory Diff support for GIT, Fossil and Subversion.
     Directly browse and compare two revisions.
  *  Plugins in Directory Diff.
  *  Added option -printFont to select font for PDF generation.
     Default font changed to a True Type font.
     Use "-printFont Courier" to fall back on PDF built-in.
  *  Mac supported

Changes in v2.6.7 (2014-11-13):

  *  Fixed Directory Diff that stopped working in 2.6.6

Changes in v2.6.6 (2014-10-27):

  *  Avoid font error with balloon help.
  *  Store default preferences as comment in rc file.

Changes in v2.6.5 (2014-01-24):

  *  Fixed error printing patch with only deleted or inserted files.
  *  Support direct print in patch mode.
  *  Detect Subversion 1.7 working copy

Changes in v2.6.4 (2013-08-22):

  *  Include afm font for consistent PDF printing.
  *  Add .pdf to print file by default
  *  Fixed bug that marked extra changes in scroll map when displaying a patch.
  *  Avoid getting double .-files in dirdiff on Windows.
  *  Corrected display of ancestor lines in three-way merge.

Changes in v2.6.3 (2012-08-21):

  *  Added Revert button in Revision mode 
  *  Added -pivot flag to control diff algorithm. This cuts down processing time for certain large files.

Changes in v2.6.2 (2012-06-18):

  *  Fixed bug where extra lines showed when displaying only diffs (no context).
  *  Include added files when using -review with Fossil.
  *  Improved plugin viewer and PDF print dialog.
  *  Support regsub preprocessing controlled per side.
  *  Support branches in Subversion.
  *  Support negative revisions with Fossil.
  *  Added -nocdiff command line flag for debug.
  *  Fixed a bug where alignment was not properly shown in output.
  *  Fixed out-of-stack crash.

Changes in v2.6.1 (2011-11-01):

  *  Eskil [http://eskil.tcl.tk|re-hosted] and changed to use [http://www.fossil-scm.org|Fossil].
  *  Fixed directory diff appearance on Windows.
  *  Fixed bug where copy button in directory diff picked the wrong file.
  *  Fixed bug where plugins were not found in VFS.

Changes in v2.6 (2011-10-30):

  *  Support commit in Git and Fossil.
  *  Support commit, list of files and revisions with -review.
  *  Added Paste Patch command.
  *  New -pluginlist option. New GUI for plugin selection.
  *  Added three-way merge.
  *  Auto-detect line endings in ancestor file to select merge output.
  *  Fully rewritten directory diff with new design.
  *  Set alignment with drag & drop.

Changes in v2.5 (2011-04-01):

  *  Requires Tcl 8.5.
  *  Plugins: Added dump, better documentation.
  *  Dir diff: Added step down.
  *  Dir diff: Redesigned to display less.
  *  Support for Perforce and Fossil.
  *  Allow zero lines of context.
  *  Detect and display annotation in patch view.
  *  Select colors for PDF print. Command line options for PDF.
  *  Removed support for Postscript output.
  *  Support File Drop with TkDnd.
  *  Handle line endings in conflict and merge.

Changes in v2.4 (2009-01-08):

  *  Completely redesigned directory diff.
  *  Added a log viewer in revision mode.
  *  Added color option for unchanged text.
  *  Plugins support. 
  *  Support for Subversion, Mercurial and Bazaar.
  *  Support commit in Subversion.
  *  Added -review for displaying all changes in a tree.
  *  Support command line "-" to read a patch from std input.

Changes in v2.3 (2007-12-05):

  *  Added -printpdf command line option.
  *  Fixed line numbering in PDF with big line numbers.
  *  Started on GIT support.
  *  Anything on the command line is checked for a starkit.
     Kits are mounted and treated as directories.

Changes in v2.2 (2007-04-05):

  *  Added experimental -nonewline command option.
  *  Added -close command option.
  *  Added experimental PDF print.
  *  Added dirdiff preferences and filters.
  *  Smarter save in merge. FR 2957
  *  Added commit button for CVS. FR 2780
  *  Bug fixes include: Kits are mounted read-only, fixed dir diff window menu,
     improved patch file parsing.

Changes in v2.1 (2006-06-02):

  *  Added -preprocess command line option.
  *  Added -foreach command line option.
  *  Added -context command line option.
  *  Handle starkits as directories in dir diff.
  *  Support relative -r with CVS.

Changes in v2.0.7 (2004-12-14):

  *  Added regsub preprocessing option.
  *  Added -prefix command line option.
  *  Improved merge window.
  *  Added ignore keyword option to directory diff.

Changes in v2.0.6 (2004-10-19):

  *  Added Ignore Digit option.
  *  Fixed bug in -r for ClearCase.
  *  Edit Mode made more robust.

Changes in v2.0.5 (2004-08-20):

  *  Option -r can now be used with ClearCase diff.
  *  Edit Mode allows simple editing in the diff display and saving.

Changes in v2.0.4 (2004-06-17):

  *  Added ignore case option.
  *  Improved alignment function.

Changes in v2.0.3 (2004-05-26):

  *  Added context options for "Diffs only" mode.
  *  Rewrote how "Separate Diff" and "Align" works.  The latter now only happens after a "Redo Diff".
  *  Added scroll map and some more context menu options in Directory Diff.

Changes in v2.0.2 (2004-05-03):

  *  Fixed a bug in ClearCase support.
  *  Improved enscript usage in print command.
  *  Added "mark file" in dirdiff context menu.

Changes in v2.0.1 (2004-02-10):

  *  Added preference for width and height.
  *  Added Tools menu to directory diff window.
  *  Made it simpler to save a conflict in the same file.

First public release v2.0 (2004-01-30):

<div class='fossil-doc' data-title='Download'>

Downloads are available both as a <a href="http://wiki.tcl.tk/starkit">Starkit</a>
and as <a href="http://wiki.tcl.tk/starpack">Starpacks</a> for some platforms.
If you need a Starpack for some other platform, you can
<a href="starpack.wiki">generate it yourself</a>.
<p>
Eskil's application source is licensed under GPL, but the bundled packages
included in the starkit are under the same license as Tcl.

<h2>Version 2.8.5 (2023-04-27)</h2><ul>
<li><a href="../../../uv/htdocs/download/eskil285.kit">eskil285.kit</a>
&nbsp;&nbsp;&nbsp;<small>(1387506 bytes)</small> (<a href="http://wiki.tcl.tk/starkit">Starkit</a>)
<li><a href="../../../uv/htdocs/download/eskil285.linux.gz">eskil285.linux.gz</a>
&nbsp;&nbsp;&nbsp;<small>(4623432 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Linux)
<li><a href="../../../uv/htdocs/download/eskil285.win.zip">eskil285.win.zip</a>
&nbsp;&nbsp;&nbsp;<small>(4485745 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Windows)
<li><a href="../../../uv/htdocs/download/eskil285.mac.gz">eskil285.mac.gz</a>
&nbsp;&nbsp;&nbsp;<small>(3320736 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Mac)
</ul>

<h2>Version 2.8.4 (2019-02-06)</h2><ul>
<li><a href="../../../uv/htdocs/download/eskil284.kit">eskil284.kit</a>
&nbsp;&nbsp;&nbsp;<small>(1378090 bytes)</small> (<a href="http://wiki.tcl.tk/starkit">Starkit</a>)
<li><a href="../../../uv/htdocs/download/eskil284.linux.gz">eskil284.linux.gz</a>
&nbsp;&nbsp;&nbsp;<small>(4613039 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Linux)
<li><a href="../../../uv/htdocs/download/eskil284.win.zip">eskil284.win.zip</a>
&nbsp;&nbsp;&nbsp;<small>(3082883 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Windows)
<li><a href="../../../uv/htdocs/download/eskil284.mac.gz">eskil284.mac.gz</a>
&nbsp;&nbsp;&nbsp;<small>(3310490 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Mac)
</ul>

<h2>Version 2.8.3</h2><ul>
<li><a href="../../../uv/htdocs/download/eskil283.kit">eskil283.kit</a>
&nbsp;&nbsp;&nbsp;<small>(1448552 bytes)</small> (<a href="http://wiki.tcl.tk/starkit">Starkit</a>)
<li><a href="../../../uv/htdocs/download/eskil283.linux.gz">eskil283.linux.gz</a>
&nbsp;&nbsp;&nbsp;<small>(4684368 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Linux)
<li><a href="../../../uv/htdocs/download/eskil283.win.zip">eskil283.win.zip</a>
&nbsp;&nbsp;&nbsp;<small>(4588178 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Windows)
<li><a href="../../../uv/htdocs/download/eskil283.mac.gz">eskil283.mac.gz</a>
&nbsp;&nbsp;&nbsp;<small>(3375574 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Mac)
</ul>

<h2>Version 2.8.2</h2><ul>
<li><a href="../../../uv/htdocs/download/eskil282.kit">eskil282.kit</a>
&nbsp;&nbsp;&nbsp;<small>(1364710 bytes)</small> (<a href="http://wiki.tcl.tk/starkit">Starkit</a>)
<li><a href="../../../uv/htdocs/download/eskil282.linux.gz">eskil282.linux.gz</a>
&nbsp;&nbsp;&nbsp;<small>(4600691 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Linux)
<li><a href="../../../uv/htdocs/download/eskil282.win.zip">eskil282.win.zip</a>
&nbsp;&nbsp;&nbsp;<small>(4504351 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Windows)
<li><a href="../../../uv/htdocs/download/eskil282.mac.gz">eskil282.mac.gz</a>
&nbsp;&nbsp;&nbsp;<small>(3291778 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Mac)
</ul>

<h2>Version 2.8.1</h2><ul>
<li><a href="../../../uv/htdocs/download/eskil281.kit">eskil281.kit</a>
&nbsp;&nbsp;&nbsp;<small>(1361190 bytes)</small> (<a href="http://wiki.tcl.tk/starkit">Starkit</a>)
<li><a href="../../../uv/htdocs/download/eskil281.linux.gz">eskil281.linux.gz</a>
&nbsp;&nbsp;&nbsp;<small>(4596746 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Linux)
<li><a href="../../../uv/htdocs/download/eskil281.win.zip">eskil281.win.zip</a>
&nbsp;&nbsp;&nbsp;<small>(4500468 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Windows)
<li><a href="../../../uv/htdocs/download/eskil281.mac.gz">eskil281.mac.gz</a>
&nbsp;&nbsp;&nbsp;<small>(3287876 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Mac)
</ul>

<h2>Version 2.8.0</h2><ul>
<li><a href="../../../uv/htdocs/download/eskil280.kit">eskil280.kit</a>
&nbsp;&nbsp;&nbsp;<small>(1343683 bytes)</small> (<a href="http://wiki.tcl.tk/starkit">Starkit</a>)
<li><a href="../../../uv/htdocs/download/eskil280.linux.gz">eskil280.linux.gz</a>
&nbsp;&nbsp;&nbsp;<small>(4579524 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Linux)
<li><a href="../../../uv/htdocs/download/eskil280.win.zip">eskil280.win.zip</a>
&nbsp;&nbsp;&nbsp;<small>(4483374 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Windows)
<li><a href="../../../uv/htdocs/download/eskil280.mac.gz">eskil280.mac.gz</a>
&nbsp;&nbsp;&nbsp;<small>(3270590 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Mac)
</ul>

<h2>Version 2.7.4</h2><ul>
<li><a href="../../../uv/htdocs/download/eskil274.kit">eskil274.kit</a>
&nbsp;&nbsp;&nbsp;<small>(1277570 bytes)</small> (<a href="http://wiki.tcl.tk/starkit">Starkit</a>)
<li><a href="../../../uv/htdocs/download/eskil274.linux.gz">eskil274.linux.gz</a>
&nbsp;&nbsp;&nbsp;<small>(4516336 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Linux)
<li><a href="../../../uv/htdocs/download/eskil274.win.zip">eskil274.win.zip</a>
&nbsp;&nbsp;&nbsp;<small>(4419956 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Windows)
<li><a href="../../../uv/htdocs/download/eskil274.mac.gz">eskil274.mac.gz</a>
&nbsp;&nbsp;&nbsp;<small>(3207473 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Mac)
</ul>

<h2>Version 2.7.3</h2><ul>
<li><a href="../../../uv/htdocs/download/eskil273.kit">eskil273.kit</a>
&nbsp;&nbsp;&nbsp;<small>(1271818 bytes)</small> (<a href="http://wiki.tcl.tk/starkit">Starkit</a>)
<li><a href="../../../uv/htdocs/download/eskil273.linux.gz">eskil273.linux.gz</a>
&nbsp;&nbsp;&nbsp;<small>(4510733 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Linux)
<li><a href="../../../uv/htdocs/download/eskil273.win.zip">eskil273.win.zip</a>
&nbsp;&nbsp;&nbsp;<small>(4414313 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Windows)
<li><a href="../../../uv/htdocs/download/eskil273.mac.gz">eskil273.mac.gz</a>
&nbsp;&nbsp;&nbsp;<small>(3201758 bytes)</small> (<a href="http://wiki.tcl.tk/starpack">Starpack</a> for Mac)
</ul>

</div>

<title>Edit Mode</title>
<h1>Edit Mode</h1>

The files on display may be edited if you turn on Edit Mode.
This is done with the Tools->Edit Mode menu.
Only real files may be edited. If you are comparing versions fetched from a
[./revision.wiki|Revision Control] system, it cannot be edited.

If an edited side has empty areas, i.e. lines that are not part of the file
and only there to line up with the other side, those will be gray.

Edit mode will not allow you to enter or remove newlines freely. Only by
copying blocks from other side lines may change.

By right clicking over a change's line numbers you get options to copy
lines and blocks between the two sides, as well as the options to save a file.

See also [./merge.wiki|Merge].

<title>Fossil Support</title>
<h1>Fossil Support</h1>

<h2>Introduction</h2>

Eskil can compare versions in many revision control systems including
[http://www.fossil-scm.org | Fossil].

If you specify only one file on the command line to Eskil, it will
automatically detect if the file is under revision control and enter revision
control mode.

By default the local file is compared against the latest checked in version.
This is for the common case when you just want to know what you have changed
before checking in.

You can use the -r option to select which versions to compare.
The -r option works as in fossil finfo. If a revision is zero or a negative
integer,
the log is searched backwards for earlier versions. E.g. -1 gives the second
to last version. The search follows the current branch from the current version.


Examples:

Compare file.txt with the latest checked in version:
<pre>eskil file.txt</pre>

Compare file.txt with the specified version:
<pre>eskil -r rev file.txt</pre>

Compare the two revisions. This does not involve the local copy of file.txt.
<pre>eskil -r rev1 -r rev2 file.txt</pre>

The -r options are also available in the GUI in the "Rev 1" and "Rev 2" fields.

<h2>Directory Diff</h2>

Eskil can also browse and compare Fossil revisions in the directory diff.
It works just like for files, but give a directory on the command line.

<h2>Commit support</h2>

When comparing a file with the latest checked in version, Eskil can commit
directly to Fossil.

<h2>View all changes</h2>

If the command line option -review is used, Eskil will generate a patch
for the current tree and display it as in patch mode.

<verbatim>eskil -review [files] </verbatim>

If file names are given after -review, only the listed files are included.
The Commit button will be enabled allowing the viewed differences to be
committed directly from Eskil.

<h2>Conflict merging</h2>
Eskil can be used as the conflict resolution tool for Fossil by configuring
the gmerge-command setting like this:

<pre>fossil settings gmerge-command 'eskil -fine -a "%baseline" "%merge" "%original" -o "%output"' -global</pre>

<div class='fossil-doc' data-title='A graphical view of file and directory differences'>

<div class="submenu">
<a class="label" href="changes.wiki">Changes</a>
</div>

<h3>About Eskil</h3>
Eskil is a graphical tool to view the differences between files and directories. It supports version management and patch files and has various preprocessing and alignment options to improve the display of tricky diffs.
<p>
Pronunciation: The E is short, like in "set", the rest is like "skill".
<p>
Any feedback, good or bad, can be sent to
&lt;peter <i>dot</i> spjuth <i>at</i> gmail <i>dot</i> com&gt; or added as a <a href='../../../ticket'>Ticket</a>.
<p>
It is similar but unrelated to <a href="http://wiki.tcl.tk/tkdiff">TkDiff</a>.

<a name="EskilFeatures"></a><h3>Features</h3>

<ul>
<li>Highlights changes within a line.</li>
<li>Matches similar lines within a changed block to better show changed
lines that are adjacent to added/removed lines.</li>
<li>Recursive directory diff.</li>
<li><a href="fossil.wiki">Fossil</a>/<a href="revision.wiki">CVS/RCS/ClearCase/GIT/SVN/BZR/HG/Perforce</a> diff.</li>
<li>Conflict <a href="merge.wiki">merge</a> and three-way merge.</li>
<li>Commit changes directly from Eskil.</li>
<li>View patch, from file or clipboard.</li>
<li><a href="print.wiki">Print</a> to PDF.</li>
<li>"Clip diff"</li>
<li><a href="plugins.wiki">Plugins</a> for preprocessing files.</li> 
<li>Alignment and block diff functions for tricky diffs.</li>
<li><a href="editmode.wiki">Edit</a> and Save file from diff window.</li>
<li><a href="starkit.wiki">Starkit</a> compare and browsing.</li>
</ul>

<a name="EskilScreenshots"></a><h3>Screenshots</h3>

<img src="eskil1.png">
<p>
A "zoom" feature for long lines.<p>
<img src="eskil2.png"><br>
<p>Directory Diff.<p>
<img src="eskil3.png"><br>

</div>

<title>Merge</title>
<h1>Merge</h1>

The files on display may be merged and saved via the Tools->Merge menu.
The Merge window will also appear if you open an Ancestor File (for three-way
merge) or a Conflict File, via the File menu or command line.

In the Merge window you can navigate between differences with up/down keys
and select between left and right side with left/right keys. See the Goto
menu for other navigation keys.

With the toolbar buttons and menus you can also choose to keep both sides.
There is All Left/Right commands in the menu to select for all differences.

The text can be freely edited. Use escape key to get focus out of the text
window to allow navigating as described above.

The status bar show basic info about the selected difference. A conflict
is marked with ***. Hover over the status line to get more info.

When saving, if no output file has been previously been selected, you get the
choice to overwrite either side or browse for another file.

The following command line parameters are merge related:

  -a <file> : Ancestor file for three-way merge.

  -o <file> : Output file for merge result.

  -fine     : Use fine grained chunks. Left/right choice is made per line instead of per chunk.

  -conflict : Treat input file as a file with merge conflict markers.

See also [./editmode.wiki|Edit Mode], and [./revision.wiki|Revision Control Support].

<title>Plugins</title>

<h1>Introduction</h1>

Eskil provides a plugin system where a plugin can preprocess data
before being compared and displayed.

A plugin is a Tcl script that must follow a specific format.
Example plugins are included in the kit.
Dump one of the included plugins to see what it looks like.

When searching for a plugin "x", files "x" and "x.tcl" will
match. The search path is current directory, "plugins" directory,
the directory where Eskil is installed, "plugins" directory where
Eskil is installed, and also the internal "plugins" wrapped into Eskil.

<h1>Usage</h1>

The command line options for plugins are:
  *  -plugin plugin     : Use plugin
  *  -plugininfo info   : Pass info to plugin (plugin specific)
  *  -plugindump plugin : Dump plugin source to stdout
  *  -pluginlist        : List known plugins
  *  -pluginallow       : Allow full access privilege for a plugin.

A plugin may further define command line options that it accepts.
A way to see the plugin's options is to do:
<pre>eskil -plugin &lt;plg&gt; -help</pre>

Multiple -plugin may be given and they will be applied in the given
order. Any -plugininfo and -pluginallow belongs to the last -plugin
before them.

<h1>General Format</h1>

A plugin is a Tcl script file that must start with the verbatim sequence
"##Eskil Plugin :". A plugin is sourced and used in its own safe
interpreter and thus have free access to its own global space. Hookup
points are defined by declaring specifically named procedures as specified
below, and apart from those, a plugin can define and do whatever within
the limits of a safe interpreter.

In addition to the standard safe interpreter environment, a plugin has
access to stdout as well. By using the command line option -pluginallow,
the plugin is run in a standard interpreter and may e.g. do exec to utilize
external tools.

A plugin is set up with these global variables filled in:
  *  ::WhoAmI     : The name of the plugin
  *  ::WhoAmIFull : The full path to the plugin source
  *  ::Info       : The contents of -plugininfo parameter
  *  ::Pref       : A copy if Eskil's internal preferences array.
  *  ::File(left) : The name of the left file processed
  *  ::File(right): The name of the right file processed
  *  ::argv       : A copy of the command line from Eskil's invocation

<h2>Additional options</h2>
A plugin can declare command line options that should be accepted by Eskil.
They will be passed on to the plugin through the ::argv list.
If the initial "##Eskil" line is followed by comments formatted as below,
it adds options. Any empty line will end parsing for such lines.

A line like "## Option -<option>" declares an option that takes a value and
a line like "## Flag -<option>" declares an option without value. The rest of
the line after the option name is functionally ignored and can be used for
comments. It is included in command line help, so the rest should preferably
be formatted as " : Explanation" if used.

<h1>File plugin</h1>

To process the files being compared, the following procedure should be
defined in the plugin file:

<pre>proc PreProcess {side chi cho} {...}</pre>

The arguments given to PreProcess are:

  *  side : left or right, indicating which file is being handled
  *  chi : An input channel for reading the original file
  *  cho : An output channel for writing the processed file

A plugin may give a result that has a line-by-line correspondence to
the original, in which case the preprocessed data is used for comparing
while the original is used for displaying.  The PreProcess procedure
should return 0 to signify this case.

If the PreProcess procedure returns 1, the processed data is used also for
displaying.

If Eskil is run with Tcl 8.6 or newer, PreProcess is run as a coroutine
and may yield. The left and right side will then be called alternately
until they return. This allows a plugin to take both sides into account
for decisions if needed.

<h1>Directory plugin</h1>

To be used for file comparison in a directory diff, the following procedure
should be defined in the plugin file:

<pre>proc FileCompare {ch1 ch2 info1 info2} {...}</pre>

The arguments given to FileCompare are:

  *  ch1:  An input channel for reading the first file.
  *  ch2:  An input channel for reading the second file.
  *  info1: A dictionary with info about the first file.
  *  info2: A dictionary with info about the second file.

Info dictionaries contain at least elements "name" and "size".

The FileCompare procedure can give the following return values:

  *  0 : Files are not equal
  *  1 : Files are equal
  *  2 : Files are equal as far as the channels have been read.
         Let the normal comparison finish the job.

Directory diff only supports one plugin. The first plugin with FileCompare
defined will be used.

<title>Print</title>
<h1>Print to PDF</h1>

A PDF of the differences can be generated from the File->Print Pdf menu.

The PDF will be generated from the current screens, so make sure any
settings like context and ignore are done and you have regenerated the diff.

The following choices are available (command line flag in parens):

  *  Header Size. Font size to use for page header. (-printHeaderSize, default 10)
  *  Paper size. Landscape  will always be used. (-printPaper, default a4)
  *  Chars per line. See below. (-printCharsPerLine, default 80)
  *  RGB background values for diff display. Text is always black.  (-printColor*)

From the command line you can also give -printFont <ttffile/afmfile>.
See [./usage.wiki|Usage] for all command line flags.

The font size is automatically scaled to fit the given characters per line.
The GUI will give you choices that fit all or most lines in that line length.
Longer lines will be wrapped.

<title>Revision Control Support</title>

<h1>Introduction</h1>

Eskil can compare versions in many revision control systems.
Currently RCS, CVS, Git, Fossil, Mercurial, Bazaar, Subversion, Perforce and ClearCase are supported (some features are not implemented for all systems).

If you specify only one file on the command line to Eskil, it will
automatically detect if the file is under revision control and enter revision
control mode.

By default the local file is compared against the latest checked in version.
This is for the common case when you just want to know what you have changed
before checking in.

You can use the -r option to select which versions to compare.
The valid values for the -r option depends on the tools used. See below for
details on each one.

Examples:

Compare file.txt with the latest checked in version:

<pre>eskil file.txt</pre>

Compare file.txt with the specified version:

<pre>eskil -r rev file.txt</pre>

Compare the two revisions. This does not involve the local copy of file.txt.

<pre>eskil -r rev1 -r rev2 file.txt</pre>

The -r options are also available in the GUI in the "Rev 1" and "Rev 2" fields.

<h1>Directory Diff</h1>

Eskil can also browse and compare revisions for some systems directly in the
directory diff. It works just like for files, but give a directory on the
command line. Currently Git, Fossil and Subversion are supported.

<h1>Commit support</h1>

When comparing a file with the latest checked in version, some of the systems
have support for committing directly from Eskil.
If supported, the Commit button will be enabled.
It is also possible to revert the local changes using the Revert button.

<h1>Priority between systems</h1>

If multiple systems are used within a directory Git/Hg/Bzr will be detected before CVS/SVN.  Command line options -cvs and -svn can be used to put preference on one of those systems.

<h1>Pipe a patch</h1>

Eskil can read a patch from standard input, thus allowing display from any
patch generating command. Examples:

<pre>hg diff | eskil -</pre>
<pre>git diff -p --diff-filter=M master | eskil -</pre>

<h1>View all changes</h1>

If the command line option -review is used, Eskil will generate a patch
for the current tree and display it as in patch mode.

<verbatim>eskil -review [files] </verbatim>

E.g. in a Mercurial directory, these show the same thing:

<pre>eskil -review</pre>
<pre>hg diff | eskil -</pre>

If file names are given after -review, only the listed files are included.
If supported, the Commit button will be enabled allowing the viewed differences
to be committed directly from Eskil.

<h1>Conflict merging</h1>

Eskil can be used as a conflict resolution tool. See examples below for settings. See also [./merge.wiki|Merge].

<h1>Tools Details</h1>

<h2>RCS/CVS</h2>

For RCS and CVS the arguments to -r are standard version numbers just like to their -r options.
If a revision is an integer, it is added to the last number in the current version, thus giving relative versions.  E.g. -1 gives the second to last version.

<h2>Subversion</h2>

For Subversion the arguments to -r are standard version numbers just like its -r option.
If a revision is zero or a negative integer, the log is searched backwards for earlier versions.
E.g. -1 gives the second to last version.

<h2>Git</h2>

For Git -r <rev> is passed to show, as in "git show <rev>:<file>".
If a revision is zero or a negative integer, the log is searched backwards for earlier versions.

To use Eskil for conflict resolution these settings can be used.

<pre>git config --global merge.tool eskil</pre>
<pre>git config --global mergetool.eskil.cmd 'eskil -fine -a $BASE -o $MERGED $REMOTE $LOCAL'</pre>
<pre>git config --global diff.tool eskil</pre>
<pre>git config --global difftool.eskil.cmd 'eskil $LOCAL $REMOTE'</pre>

<h2>Fossil</h2>

See [./fossil.wiki|Fossil].

<h2>Mercurial</h2>

For Mercurial -r mostly works as in "hg cat -r".
However, Eskil interprets zero or negative numbers as going back from the tip, i.e. -1 is one step back, corresponding to -2 in Mercurial.

Mercurial is supported in the Directory Diff, but needs the hglist extension to
display correct file sizes and dates. If not they are faked using the file's
sha1 and thus unique per file and gives a correct result in comparison.

To use Eskil for conflict resolution these config settings can be used.

<verbatim>
[merge-tools]
eskil.args = -fine -a $base $other $local -o $output
eskil.priority = 1
</verbatim>

<h2>Bazaar</h2>

For Bazaar -r works as in "bzr cat -r".

<h2>ClearCase</h2>

ClearCase has more complex version "numbers".
ClearCase stream names are built like file paths and in -r you can access the streams
similar to how you find files.
Your current stream is the "current directory".
A negative version number is offset from latest.

  <tt>-r 5                    </tt>: Version 5 in current stream.<br>
  <tt>-r .                    </tt>: Latest version in current stream.<br>
  <tt>-r -1                   </tt>: Second to last version in current stream.<br>
  <tt>-r /full/path/stream/4  </tt>: The identified version.<br>
  <tt>-r /full/path/stream    </tt>: Latest version in that stream.<br>
  <tt>-r ../5                 </tt>: Version in parent stream.<br>
  <tt>-r ..                   </tt>: Latest in parent stream.<br>
  <tt>-r stream/5             </tt>: Version in stream, anywhere in tree.<br>
  <tt>-r stream               </tt>: Latest in stream, anywhere in tree.

<title>Starkit compare</title>

Eskil is [http://wiki.tcl.tk/starkit | Starkit] aware and will allow you
to compare starkits/starpacks.

If you compare one against itself, it becomes a way to browse a starkit.

The kit needs to be either mentioned on the command line or called *.kit for it to work.

<title>Starpack generation</title>
<h1>Starpack generation</h1>

Eskil is normally distributed as a [http://wiki.tcl.tk/starkit | Starkit] which
needs a [http://wiki.tcl.tk/tclkit | Tclkit] to run. If you have ActiveTcl
installed, tclsh can also run a Starkit.

To generate a stand-alone executable,
a [http://wiki.tcl.tk/starpack | Starpack], of Eskil you need the following:
  *  A [http://wiki.tcl.tk/tclkit | Tclkit] for your platform. (tclkit)
  *  The [http://wiki.tcl.tk/sdx | Sdx] utility. (sdx)
  *  Eskil's Starkit. (eskil.kit)

<verbatim>
./tclkit sdx unwrap eskil.kit
cp tclkit tclkit2
./tclkit sdx wrap eskil -runtime tclkit2
</verbatim>

Note that this could be generated on any platform, not just the target. Then tclkit should be for the current platform and tclkit2 should be for the target platform.

<title>Table diff</title>
<h1>Table diff</h1>

Eskil can compare tables in comma/tab separated text files and display
them like a table.

<verbatim>
eskil -table apa1.csv apa2.csv
</verbatim>

Eskil will try to auto-detect the separator but you can also give it
using -sep. Example for tab separation:

<verbatim>
eskil -table -sep '\t' apa1.csv apa2.csv
</verbatim>

Eskil has a built in plugin, csv, than can preprocess table files. This example clears the "Short" and "Long" columns before comparison:

<verbatim>
eskil -table apa1.csv apa2.csv -block -sep '\t' -plugin csv -csvignore "Short Long"
</verbatim>

<title>Documentation</title>

[./changes.wiki|Changes]

[./editmode.wiki|Edit Mode]

[./fossil.wiki|Fossil Support]

[./merge.wiki|Merge]

[./plugins.wiki|Plugins]

[./print.wiki|Print]

[./revision.wiki|Revision Control Support]

[./starkit.wiki|Starkit compare]

[./starpack.wiki|Starpack generation]

[./table.wiki|Table diff]

[./usage.wiki|Usage]

<title>Usage</title>

<h1>Command Line Usage</h1>

<verbatim>
Usage: eskil [options] [files...]
  [options]  See below.
  [files...] 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 version
  control of the file, and if found, runs in version control mode.
  If directories are given, Eskil starts in directory diff.

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

  Options:
-            : Read patch file from standard input, to allow pipes
-a <file>    : Give ancestor <file> for three way merge
-b           : Ignore space changes (default)
-block       : Full block analysis. This can be slow if there are large change
               blocks
-browse      : Bring up file dialog for missing files after starting
-char        : Character based change view (default)
-clip        : Start in clip diff mode. Ignores other args
-close       : Close any window with no changes
-conflict    : Treat file as a merge conflict file and enter merge mode
-context <n> : Show only differences, with <n> lines of context
-cvs         : Detect CVS first, if multiple version systems are used
-debug       : Start in debug mode
-dir         : Start in directory diff mode. Ignores other args
-excludedir <v> : Exclude from directory diff
-excludefile <v> : Exclude from directory diff
-fine        : Use fine grained chunks. Useful for merging
-foreach     : Open one diff window per file listed
-fourway     : Start in fourway diff mode. Ignores other args
-gz          : Uncompress input files with gunzip
-i           : Ignore case changes
-includedir <v> : Include in directory diff
-includefile <v> : Include in directory diff
-limit <lines> : Do not process more than <lines> lines
-line        : Line based block analysis
-maxwidth <v> : Limit column width in table mode
-nocase      : Ignore case changes
-nocdiff     : Disable C version of DiffUtil. For debug
-nodiff      : Do not run diff after startup
-nodigit     : Ignore digit changes
-noempty     : Ignore empty lines initially for matching
-noignore    : Don't ignore any whitespace
-nokeyword   : In directory diff, ignore $ Keywords: $
-nonewline   : Try to ignore newline changes
-nonewline+  : Try to ignore newline changes, and don't display
-noparse     : No block analysis
-o <file>    : Specify merge result output <file>
-patch       : View patch file
-pivot <v>   : Pivot setting for diff algorithm (10)
-plugin <v>  : Preprocess files using plugin
-pluginallow : Allow full access privilege for plugin
-plugindump <v> : Dump plugin source to stdout
-plugininfo <v> : Pass info to plugin (plugin specific)
-pluginlist  : List known plugins
-prefix <str> : Care mainly about words starting with <str>
-preprocess <pair> : The <pair> is a list of RE+Subst applied to each line
                     before compare
-preprocessleft <pair> : Use <pair> only on left side
-preprocessright <pair> : Use <pair> only on right side
-print <v>   : Generate PDF and exit
-printCharsPerLine <v> : Adapt font size for this line length and wrap (80)
-printColorChange <v> : Color for change (1.0 0.7 0.7)
-printColorNew <v> : Color for new text (0.8 0.8 1.0)
-printColorOld <v> : Color for old text (0.7 1.0 0.7)
-printFont <fontfile> : Select font to use in PDF, afm or ttf. If <fontfile> is
                        given as "Courier", PDF built in font is used
-printHeaderSize <v> : Font size for page header (10)
-printPaper <v> : Select paper size (a4)
-r <v>       : Version info for version control mode
-review      : View revision control tree as a patch
-sep <c>     : See char <c> as separator between columns in files
-server      : Set up Eskil to be controllable from the outside
-smallblock  : Do block analysis on small blocks (default)
-subst <pair> : The <pair> is a list of Left+Right, used for subst preprocessing
-svn         : Detect SVN first, if multiple version systems are used
-table       : Run in table mode
-w           : Ignore all spaces
-word        : Word based change view
</verbatim>

#!/bin/bash

# Icon sizes in tclkit at present:
# 64x64x32 48x48x32 32x32x32 24x24x32 16x16x32
# 48x48x24 32x32x24 24x24x24 16x16x24
# 48x48x8  32x32x8  24x24x8  16x16x8 

# Create 64 from 48
pngtopam -alphapam dragon_48x48x32.png | pamscale -width 64 | pamrgbatopng > apa.png

# The 256 file is a "vista" file, and could be stored raw in the ico file.
# However, the tclkit has it stored as the others
icotool -c -o tclkit.ico apa.png dragon_48x48x32.png dragon_32x32x32.png dragon_24x24x32.png dragon_16x16x32.png dragon_256x256x32.png

cp tclkit.ico ../eskil.vfs/

#!/bin/sh
# Build up a merge conflict in fossil
fossil init apa.fossil
mkdir apa_fossil
cd apa_fossil
fossil open ../apa.fossil
fossil settings gmerge-command 'eskil -fine -a "%baseline" "%merge" "%original" -o "%output"'
cp ../tests/ancestor.txt a.txt
fossil add a.txt
fossil commit -m a
fossil branch new b trunk
fossil update b
cp ../tests/right.txt a.txt
fossil commit -m r
fossil update trunk
cp ../tests/left.txt  a.txt
fossil commit -m l
fossil update b
#fossil merge trunk
#fossil commit -m "Merge from trunk"

#!/bin/sh
# Build up a merge conflict in git
mkdir apa_git
cd apa_git
git init
cp ../tests/ancestor.txt a.txt
git add a.txt
git commit -m a
git checkout -b b
cp ../tests/right.txt a.txt
git commit -am r
git checkout master
cp ../tests/left.txt  a.txt
git commit -am l
git checkout b
#git merge master
#git mergetool
#git commit -am m

##Nagelfar Plugin : Check of Eskil's sources

proc statementWords {words info} {
    set caller [dict get $info caller]
    set callee [lindex $words 0]
    set res {}

    # Rule: Space around initial "!" in expr.
    # Reason: I find it more readable
    if {$callee eq "if"} {
        set e [lindex $words 1]
        if {[regexp {\{(\s*)!(\s*)[\[$]} $e -> pre post]} {
            if {$pre ne " " || $post ne " "} {
                lappend res warning
                lappend res "Not (!) should be surrounded by one space"
            }
        }
    }
    # Rule: Do not allow single letter variables as arguments.
    # Reason: A lot of old unreadable code had them.
    # Exception: Upper-case "W","x" and "y".
    if {$callee eq "proc"} {
        set argList [lindex $words 2]
        foreach arg [lindex $argList 0] {
            set arg [lindex $arg 0]

            set lcArg [string tolower $arg]
            if {[string length $arg] == 1 && $lcArg eq $arg} {
                if {$arg ni {x y}} {
                    lappend res warning
                    lappend res "Single letter argument '$arg' is not allowed '$argList'"
                }
            }
        }
    }

    
    return $res
}

##Eskil Plugin : Compare with backslash-newline removed
#
# This plugin replaces any backslash-newline with space, thus
# ignoring restructured lines.

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line




# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    set trim 0
    while {[gets $chi line] >= 0} {

##Eskil Plugin : Compare binary files, in hex
## Option -binsep : A set of chars to be used as "newline"
#
# This plugin converts files to hex to be able to compare binary files.
# A set of chars can be defined to be used as "newline". Default "0 10 13".
# Example usage:
# eskil -plugin binary -binsep "0 10 13 32" f1 f2

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line

# A plugin may declare command line options that should be allowed through
# to ::argv

# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    set delimitL [list 0 10 13]
    if {[llength $::Info] > 0} {
        set delimitL $::Info
    }
    set i [lsearch -exact $::argv -binsep]
    if {$i >= 0} {
        incr i
        set delimitL [lindex $::argv $i]
    }
    if {[catch {llength $delimitL}]} {
        puts $cho "Binary plugin needs parameter to be a list"
        return 1
    }

    # Build an RE that matches the given chars
    set REm "\["
    set REi "\[^"
    foreach code $delimitL {
        set c [format %c $code]
        if {[string is wordchar $c]} {
            append REm $c
            append REi $c
        } else {
            # Just in case it is a special char for RE
            append REm \\ $c
            append REi \\ $c
        }
    }
    append REm "\]"
    append REi "\]"

    set RE $REi*$REm*

    fconfigure $chi -translation binary
    # Assume small enough for memory.
    # A file too large to read would be virtually impossible to display anyway.
    set data [read $chi]
    foreach line [regexp -all -inline $RE $data] {
        puts $cho [strToHex $line]
    }

    # Signal that the file after processing should be used both
    # for comparison and for displaying.
    return 1
}

# Note: With 8.6 there is "binary encode hex" that might be faster

# Build a string to hex mapper for speed
set ::hexCharMap {}
for {set i 0} {$i < 256} {incr i} {
    lappend ::hexCharMap [format %c $i] [format "%02X " $i]
}
proc strToHex {str} {
    string map $::hexCharMap $str
}

##Eskil Plugin : Compare comma separated value (CSV) files
## Option -csvignore : A list of columns to ignore
## Option -csvkey    : A list of columns to sort on before comparison
## Flag   -csvheader : First line is a header line defining names of columns
#
# This plugin compares CSV files with some preprocessing available
# Example usage:
# eskil -plugin csv -csvignore "head3 head5" -csvkey head2 -sep , \
#       examples/dir*/csv1.txt

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line

# A plugin may declare command line options that should be allowed through
# to ::argv

# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    # Look for parameters in command line
    set opts(-sep) ","
    set opts(-csvignore) ""
    set opts(-csvkey) ""
    set opts(-csvheader) 0
    foreach opt {-sep -csvignore -csvkey} {
        set i [lsearch -exact $::argv $opt]
        if {$i >= 0} {
            incr i
            set opts($opt) [lindex $::argv $i]
        }
    }
    set i [lsearch -exact $::argv "-csvheader"]
    if {$i >= 0} {
        set opts(-csvheader) 1
    }

    # Also allow options via info
    foreach {opt val} $::Info {
        set opts($opt) $val
    }
    # Allow backslash for easy access to \t
    set opts(-sep) [subst -nocommands -novariables $opts(-sep)]

    # If any column is given by name, assume the file starts with
    # a header line of column names
    foreach col [concat $opts(-csvignore) $opts(-csvkey)] {
        if { ! [string is integer $col]} {
            set opts(-csvheader) 1
        }
    }
    if {$opts(-csvheader)} {
        set nameLine [gets $chi]
        # Keep it first in file
        puts $cho $nameLine
        set nameList [split $nameLine $opts(-sep)]
    }

    set icol {}
    foreach col $opts(-csvignore) {
        if {[string is integer $col]} {
            lappend icol $col
        } else {
            set i [lsearch $nameList $col]
            if {$i < 0} {
                return -code error "CSV Plugin Error: No such heading '$col'"
            }
            lappend icol $i
        }
    }
    set icol [lsort -integer $icol]

    set kcol {}
    foreach col $opts(-csvkey) {
        if {[string is integer $col]} {
            lappend kcol $col
        } else {
            set i [lsearch $nameList $col]
            if {$i < 0} {
                return -code error "CSV Plugin Error: No such heading '$col'"
            }
            lappend kcol $i
        }
    }

    set olines {}
    while {[gets $chi line] >= 0} {
        set items [split $line $opts(-sep)]
        foreach i $icol {
            lset items $i ""
        }
        lappend olines $items
    }
    # Sort on keys
    foreach i [lreverse $kcol] {
        set olines [lsort -index $i $olines]
    }
    foreach items $olines {
        puts $cho [join $items $opts(-sep)]
    }

    # Signal that the file after processing should be used both
    # for comparison and for displaying.
    return 1
}

##Eskil Plugin : Compare after filtering lines
## Option -grepre : Regexp to filter on
#
# This plugin only compares lines that match a regexp pattern.
# Example usage:
# eskil -plugin grep -grepre "<t>" f1 f2

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line

# A plugin may declare command line options that should be allowed through
# to ::argv

# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    if {[catch {llength $::Info}]} {
        puts $cho "Grep plugin needs -plugininfo parameter to be a list"
        return 1
    }
    # Look for parameters in info string
    set opts(-re) "."
    foreach {opt val} $::Info {
        set opts($opt) $val
    }
    # And on command line
    set i [lsearch -exact $::argv -grepre]
    if {$i >= 0} {
        incr i
        set opts(-re) [lindex $::argv $i]
    }
    while {[gets $chi line] >= 0} {
        if {[regexp -- $opts(-re) $line]} {
            puts $cho $line
        }
    }
    # Signal that the file after processing should be used both
    # for comparison and for displaying.
    return 1
}

##Eskil Plugin : Compare gzip file
#
# This plugin unpacks input gzip file before comparing.

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line

# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    zlib push gunzip $chi
    chan copy $chi $cho

    # Signal that the file after processing should be used both
    # for comparison and for displaying.
    return 1
}

##Eskil Plugin : Ignore $Keywords$
#
# This plugin ignores keywords like $Revision$, both in file diff
# and in directory diff

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line

# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    while {1} {
        # Read data in large chunks for speed
        set data [read $chi 100000]
        if {$data eq ""} break
        # Replace keywords with nothing
        # Use line mode to be sure not to affect newlines
        regsub -all -line {\$\w+:[^\$]*\$} $data {} data
        puts -nonewline $cho $data
    }
    # Signal that the file after processing should be used only for
    # comparison, not for displaying.
    # The processed file must match the original line-wise.
    return 0
}

# To be used in directory diff, a plugin must define this procedure.
# ch1:  An input channel for reading the first file.
# ch2:  An input channel for reading the second file.
# info1: A dictionary with info about the first file.
# info2: A dictionary with info about the second file.
# Info dictionaries contain at least elements "name" and "size".
proc FileCompare {ch1 ch2 info1 info2} {
    set bufsz 65536
    # Assume that all keywords are in the first block
    set f1 [read $ch1 $bufsz]
    set f2 [read $ch2 $bufsz]
    regsub -all {\$\w+:[^\$]*\$} $f1 {} f1
    regsub -all {\$\w+:[^\$]*\$} $f2 {} f2
    # Compensate for any change in length
    if {[string length $f1] < [string length $f2]} {
        append f1 [read $ch1 [expr {[string length $f2] - [string length $f1]}]]
    }
    if {[string length $f2] < [string length $f1]} {
        append f2 [read $ch2 [expr {[string length $f1] - [string length $f2]}]]
    }
    if { ! [string equal $f1 $f2]} {
        # Returning 0 signals "not equal"
        return 0
    }
    # Return 1 means "equal"
    # Return 2 means "equal this far", and lets normal compare take over
    return 2
}

##Eskil Plugin : Case insensitive matching
#
# This plugin implements case insensitive matching, similar to the
# -nocase flag.

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line




# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    while {1} {
        # Read data in large chunks for speed
        set data [read $chi 100000]
        if {$data eq ""} break
        # Use lower case for comparison, thus getting case insensitive
        puts -nonewline $cho [string tolower $data]
    }
    # Signal that the file after processing should be used only for
    # comparison, not for displaying.
    # The processed file must match the original line-wise.
    return 0
}

# To be used in directory diff, a plugin must define this procedure.
# ch1:  An input channel for reading the first file.
# ch2:  An input channel for reading the second file.
# info1: A dictionary with info about the first file.
# info2: A dictionary with info about the second file.
# Info dictionaries contain at least elements "name" and "size".
proc FileCompare {ch1 ch2 info1 info2} {
    set bufsz 65536
    while 1 {
        set f1 [read $ch1 $bufsz]
        set f2 [read $ch2 $bufsz]
        if {$f1 eq "" && $f2 eq ""} break
        if { ! [string equal -nocase $f1 $f2]} {
            # Returning 0 signals "not equal"
            return 0
        }
    }

    # Return 1 means "equal"
    # Return 2 means "equal this far", and lets normal compare take over
    return 1
}

##Eskil Plugin : Compare text from PDF files. (needs pdftotext 4+)
## Option -marginl : Left margin to pass to pdftotext
## Option -marginr : Right margin to pass to pdftotext
## Option -margint : Top margin to pass to pdftotext
## Option -marginb : Bottom margin to pass to pdftotext
## Option -pdftotext : Extra options to pass to pdftotext
#
# This plugin runs input through the external tool pdftotext.
# Thus it must be run together with the -pluginallow flag.

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line

# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    if {[info commands exec] eq ""} {
        puts $cho "PDF plugin must be run with privilege to be able\
                   to execute pdftotext"
        return 1
    }
    set opts(-marginl) ""
    set opts(-marginr) ""
    set opts(-margint) ""
    set opts(-marginb) ""
    set opts(-pdftotext) ""
    foreach opt {-marginl -marginr -margint -marginb -pdftotext} {
        set i [lsearch -exact $::argv $opt]
        if {$i >= 0} {
            incr i
            set opts($opt) [lindex $::argv $i]
        }
    }
     set cands [auto_execok pdftotext]
    lappend cands [file join $::WhoAmIFull pdftotext]
    lappend cands [file join $::WhoAmIFull .. pdftotext]
    lappend cands [file join $::WhoAmIFull .. .. pdftotext]
    set found 0
    foreach cand $cands {
        if {[file exists $cand]} {
            set found 1
            break
        }
        if {[file exists $cand.exe]} {
            set cand $cand.exe
            set found 1
            break
        }
    }

    if { ! $found} {
        puts $cho "PDF plugin needs external tool 'pdftotext' to run"
        return 1
    }
    if {[catch {llength $::Info}]} {
        puts $cho "PDF plugin needs -plugininfo parameter to be a list"
        return 1
    }
    if {[catch {llength $opts(-pdftotext)}]} {
        puts $cho "PDF plugin needs -pdftotext parameter to be a list"
        return 1
    }
    # Pass options from -plugininfo as well.
    set options [concat $::Info $opts(-pdftotext)]
    foreach opt {-marginl -marginr -margint -marginb} {
        if {$opts($opt) ne ""} {
            lappend options $opt $opts($opt)
        }
    }
    # Use source file with pdftotext since stdin is not reliable on e.g Windows
    if {[catch {exec $cand {*}$options $::File($side) - >&@ $cho}]} {
        puts $cho "**************************************"
        puts $cho "PDF plugin got an error from pdftotext"
    }

    # Signal that the file after processing should be used both
    # for comparison and for displaying.
    return 1
}

##Eskil Plugin : Compare files after sorting lines
## Flag -sortwords : Sort words within each line first.
## Flag -nospace : Ignore space
#
# This plugin compares files after sorting the lines in each side

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line

# A plugin may declare command line options that should be allowed through
# to ::argv

# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    # Look for parameters in command line
    set opts(-sortwords) 0
    set opts(-nospace) 0
    set i [lsearch -exact $::argv "-sortwords"]
    if {$i >= 0} {
        set opts(-sortwords) 1
    }
    set i [lsearch -exact $::argv "-nospace"]
    if {$i >= 0} {
        set opts(-nospace) 1
    }

    set data [read $chi]
    set endingNewLine 0
    if {[string index $data end] eq "\n"} {
        set data [string range $data 0 end-1]
        set endingNewLine 1
    }
    set lines [split $data \n]

    if {$opts(-sortwords)} {
        set newlines {}
        foreach line $lines {
            # Extract words
            set words [regexp -all -inline {\w+} $line]
            set words [lsort -dictionary $words]
            lappend newlines [join $words]
        }
        set lines $newlines
    }

    if {$opts(-nospace)} {
        set sortlines {}
        foreach line $lines {
            set nospace [regsub -all {\s+} $line ""]
            lappend sortlines [list $nospace $line]
        }
        set sortlines [lsort -dictionary {*}$::Info  -index 0 $sortlines]
        set lines {}
        foreach line $sortlines {
            lappend lines [lindex $line 1]
        }
    } else {
        # Allow sort parameters in info
        set lines [lsort -dictionary {*}$::Info $lines]
    }

    puts -nonewline $cho [join $lines \n]
    if {$endingNewLine} {
        puts $cho ""
    }
    # Signal that the file after processing should be used both
    # for comparison and for displaying.
    return 1
}

##Eskil Plugin : Swap sides of contents
#
# This plugin swaps data between files. A fairly useless thing.
# This is to test and exemplify how to use yield in a plugin.

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line

# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    if {[info commands yield] eq ""} {
        puts $cho "Swap plugin must be run with Tcl 8.6 or newer"
        return 1
    }
    # Read all data from both sides
    set ::data($side) [read $chi]
    yield

    # Output data from other side
    if {$side eq "left"} {
        puts $cho $::data(right)
    } else {
        puts $cho $::data(left)
    }

    # Signal that the file after processing should be used both
    # for comparison and for displaying.
    return 1
}

##Eskil Plugin : Compare set of words
#
# This plugin compares the set of words in files.

# Example file for a plugin.
# A plugin's first line must start exactly like this one.
# The text after : is the summary you can get at the command line



# A plugin must define this procedure to do the job.
# side: left or right
# chi:  An input channel for reading the original file.
# cho:  An output channel for writing the processed file.
proc PreProcess {side chi cho} {
    while {[gets $chi line] >= 0} {
        foreach word [regexp -all -inline {\w+} $line] {

}

proc DoClipDiff {} {
    set f1 [tmpFile]
    set f2 [tmpFile]

    set ch [open $f1 w]
    set data1 [$::eskil(wClip1) get 1.0 end]
    set data1 [ClipClean $data1]
    puts $ch $data1
    close $ch

    set ch [open $f2 w]
    set data2 [$::eskil(wClip2) get 1.0 end]
    set data2 [ClipClean $data2]
    puts $ch $data2
    close $ch

    #set line1 [split $data1 \n]
    #set len1  [llength $line1]
    #set line2 [split $data2 \n]

        $::widgets($top,wLine1) configure -height 1
        $t2 configure -height $lines2
        $::widgets($top,wLine2) configure -height 1
    }
}

proc ArmCatch {} {
    if {$::eskil(armcatch)} {
        bind .clipdiff <FocusOut> {
            if {[string equal %W .clipdiff]} {
                after 50 CatchFromWin
            }
        }
    } else {
        bind .clipdiff <FocusOut> {}
    }
}

proc CatchFromWin {} {
    set ::eskil(armcatch) 0
    ArmCatch
    set win [twapi::get_foreground_window]
    if {$win eq ""} {
        #puts "No fg window"
        return
    }
    #puts "Locating windows"

        twapi::send_keys ^(ac)
        after 50 "set ::CatchFromWinWait 1" ; vwait ::CatchFromWinWait
        lassign [twapi::get_window_coordinates $win] x1 y1 x2 y2
        if {[catch {clipboard get} text]} continue
        if {$text eq ""} continue
        lappend capturedData [list $x1 $text]
    }
    $::eskil(wClip1) delete 1.0 end
    $::eskil(wClip2) delete 1.0 end
    if {[llength $capturedData] == 0} return
    # Set it up left-to-right
    set capturedData [lsort -index 0 -integer $capturedData]
    if {[llength $capturedData] >= 1} {
        set text [lindex $capturedData 0 1]
        $::eskil(wClip1) insert end $text
    }
    if {[llength $capturedData] >= 2} {
        set text [lindex $capturedData 1 1]
        $::eskil(wClip2) insert end $text
        after idle DoClipDiff
    }
}

proc makeClipDiffWin {} {
    set top .clipdiff
    if {[winfo exists $top] && [winfo toplevel $top] eq $top} {

    wm title $top "Clip Diff"
    wm protocol $top WM_DELETE_WINDOW "cleanupAndExit $top"
    set t1 [Scroll both \
            text $top.t1 -width 60 -height 35 -font myfont]
    set t2 [Scroll both \
            text $top.t2 -width 60 -height 35 -font myfont]

    set ::eskil(wClip1) $t1
    set ::eskil(wClip2) $t2

    bind $t1 <Control-o> [list focus $t2]
    bind $t2 <Control-o> [list focus $t1]

    ttk::frame $top.f
    menubutton $top.f.mf -menu $top.f.mf.m -text "File" -underline 0
    menu $top.f.mf.m

    #}
    grid $top.f.mf $top.f.b2 $top.f.b4 x $top.f.b x $top.f.b3 $top.f.b5 x \
            -padx 4 -pady 2 -sticky "w"
    grid $top.f.mf -sticky nw -pady 0 -padx 0
    grid columnconfigure $top.f {0 3 5 8} -weight 1
    grid columnconfigure $top.f 8 -minsize [winfo reqwidth $top.f.mf]

    if { ! [catch {package require twapi}]} {
        ttk::checkbutton $top.f.b6 -text "Capture" -command ArmCatch \
                -underline 0 -variable ::eskil(armcatch)
        bind $top <Alt-c> [list $top.f.b6 invoke]
        #raise $top.f.b6
        place $top.f.b6 -anchor e -relx 1.0 -rely 0.5
    }

    grid $top.f    -       -sticky we
    grid $top.t1   $top.t2 -sticky news
    grid $top.t2 -padx {2 0}
    grid rowconfigure    $top 1     -weight 1
    grid columnconfigure $top {0 1} -weight 1
    return $top
}

#  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
#  Boston, MA 02111-1307, USA.
#
#----------------------------------------------------------------------
# $Revision$
#----------------------------------------------------------------------

proc maxAbs {v1 v2} {
    return [expr {abs($v1) > abs($v2) ? $v1 : $v2}]
}

# 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 CompareLines {line1 line2} {
    set opts $::Pref(ignore)

# debug.tcl
#
#    Helpers for debugging.
#
#

namespace eval ::_Debug {

}

#-----------------------------------------------------------------------------
# Misc useful stuff
#-----------------------------------------------------------------------------

proc ::_Debug::dumpMyMemUsage {str} {
    try {
        set xx [exec ps --pid [pid] --format vsize]
        set mem 0
        regexp {\d+} $xx mem
        puts "$str : memory usage $mem"
    } on error {} {
        puts "$str : memory usage unknown, call to ps failed"
    }
}

#-----------------------------------------------------------------------------
# Tracing
#-----------------------------------------------------------------------------

proc ::_Debug::TRenter {cmd op} {
    set fr [info frame -2]
    set line X
    if {[dict exists $fr line]} {
        set line [dict get $fr line]
    }
    puts "Line $line Enter: '$cmd'"
}
proc ::_Debug::TRenterstep {cmd op} {
    set fr [info frame -2]
    set line X
    if {[dict exists $fr line]} {
        set line [dict get $fr line]
    }
    puts "Line $line  Enterstep: '$cmd'"
}
proc ::_Debug::TRleave {cmd code res op} {
    puts "Leave: '$res'"
}
proc ::_Debug::TRleavestep {cmd code res op} {
    puts "Leavestep: '$res'"
}
proc ::_Debug::TR {cmd {step 0}} {
    TRoff $cmd
    trace add execution $cmd enter ::_Debug::TRenter
    trace add execution $cmd leave ::_Debug::TRleave
    if {$step} {
        trace add execution $cmd enterstep ::_Debug::TRenterstep
        trace add execution $cmd leavestep ::_Debug::TRleavestep
    }
}
proc ::_Debug::TRoff {cmd} {
    trace remove execution $cmd enter ::_Debug::TRenter
    trace remove execution $cmd leave ::_Debug::TRleave
    trace remove execution $cmd enterstep ::_Debug::TRenterstep
    trace remove execution $cmd leavestep ::_Debug::TRleavestep
}

#-----------------------------------------------------------------------------
# GUI
#-----------------------------------------------------------------------------

proc debugMenu {mW} {
    $mW add cascade -label "Debug" -menu $mW.debug -underline 0
    menu $mW.debug

    if {$::tcl_platform(platform) eq "windows"} {
        $mW.debug add checkbutton -label "Console" -variable ::consoleState \
                -onvalue show -offvalue hide -command {console $::consoleState} \
                -underline 0
        $mW.debug add separator
    }

    $mW.debug add command -label "Edit" -command ::_Debug::ProcEditor \
            -underline 0
    $mW.debug add command -label "Windows" -command ::_Debug::WindowBrowser \
            -underline 0
    #after 500 ::_Debug::DumpStuff
    #after 500 ::_Debug::ProcEditor
    return $mW.debug
}

#-----------------------------------------------------------------------------
# Window structure browser
#-----------------------------------------------------------------------------
proc ::_Debug::WindowBrowser {} {
    set top .windowbrowser
    destroy $top
    ttk::toplevel $top -padx 3 -pady 3
    wm title $top "Window Browser"

    ttk::frame $top.ftree
    set tree $top.ftree.tree
    ttk::treeview $tree -height 20 -selectmode browse -show "tree" \
            -yscrollcommand "$top.ftree.sby set"
    ttk::scrollbar $top.ftree.sby -orient vertical -command "$tree yview"
    $tree column "#0" -minwidth 50 -width 200

    pack $top.ftree.sby -side right -fill y -pady 3 -padx {0 3}
    pack $tree -fill both -expand 1 -pady 3 -padx {3 0}

    text $top.t -width 80 -wrap word

    set ::_Debug::WindowBrowser(treeW) $tree
    set ::_Debug::WindowBrowser(textW) $top.t
    bind $tree <<TreeviewSelect>> ::_Debug::WindowBrowserSelected

    grid $top.ftree $top.t -sticky news
    grid rowconfigure    $top 0 -weight 1
    grid columnconfigure $top 0 -weight 1
    grid columnconfigure $top 1 -weight 2

    set ::_Debug::WindowBrowser(deselect) ""
    PopWindowBrowser $tree
}

# An item was selected. Show info
proc ::_Debug::WindowBrowserSelected {} {
    $::_Debug::WindowBrowser(textW) delete 1.0 end
    if {$::_Debug::WindowBrowser(deselect) ne ""} {
        #puts "DESEL: $::_Debug::WindowBrowser(deselect)"
        {*}$::_Debug::WindowBrowser(deselect)
        set ::_Debug::WindowBrowser(deselect) ""
    }
    set tree $::_Debug::WindowBrowser(treeW)
    set items [$tree selection]
    if {[llength $items] < 1} return
    set item [lindex $items 0]
    set values [$tree item $item -values]
    set d [lindex $values 0]
    set txt [dict get $d out]
    $::_Debug::WindowBrowser(textW) insert end $txt

    set interp [dict get $d interp]
    set i [list interp eval $interp]
    set w [dict get $d w]

    # A few experiments to highlight selection.
    try {
        # Overlaid frame seems to work best
        set tl [{*}$i winfo toplevel $w]
        set wx [expr [{*}$i winfo rootx $w] - [{*}$i winfo rootx $tl]]
        set wy [expr [{*}$i winfo rooty $w] - [{*}$i winfo rooty $tl]]
        set ww [{*}$i winfo width $w]
        set wh [{*}$i winfo height $w]
        set cleancmd ""
        if {$tl eq "."} {
            set tl ""
        }
        for {set t 1} {$t <= 4} {incr t} {
            set whl($t) $tl._debug_hl_$t
            destroy $whl($t)
            append cleancmd [list destroy $whl($t)]\;
            frame $whl($t) -background red
        }
        place $whl(1) -x $wx -y $wy -width $ww -height 3
        place $whl(2) -x $wx -y $wy -width 3   -height $wh
        place $whl(3) -x [+ $wx $ww] -y $wy -width 3 -height $wh
        place $whl(4) -x $wx -y [+ $wy $wh] -width $ww   -height 3
        set ::_Debug::WindowBrowser(deselect) \
                [list eval $cleancmd]
        return
    } on error {err info} {
        #puts "In $interp"
        #puts "$err"
        #puts "$info"
    }

    try {
        # Reconfiguring class. Does not work with disabled buttons e.g.
        set class [{*}$i winfo class $w]
        set oldstyle [{*}$i $w cget -style]
        if {$oldstyle eq ""} {
            set basestyle $class
        } else {
            set basestyle $oldstyle
        }
        set style HighLightRed.$basestyle
        {*}$i ttk::style configure $style -background red -fieldbackground red
        {*}$i $w configure -style $style
        set ::_Debug::WindowBrowser(deselect) \
                [list {*}$i [list $w configure -style $oldstyle]]
        #puts "CLASS $class STYLE $style"
        #puts [{*}$i ttk::style configure $basestyle]
        #puts [{*}$i ttk::style configure $style]
        return
    } on error {err info} {
        #puts "In $interp"
        #puts "$err"
        #puts "$info"
    }
    try {
        # Tk style background change. Only works with Tk.
        set bg [{*}$i $w cget -background]
        {*}$i $w configure -background red
        set ::_Debug::WindowBrowser(deselect) \
                [list {*}$i [list $w configure -background $bg]]
        return
    } on error {err info} {
        #puts "In $interp"
        #puts "$err"
        #puts "$info"
    }
    #puts "MOO $w"
}

# Populate
proc ::_Debug::PopWindowBrowser {tree} {
    $tree delete [$tree children {}]
    set todo [list . {}]
    # Outer loop for subinterps TBD
    while {[llength $todo] > 0} {
        set containers {}
        while {[llength $todo] > 0} {
            # POP
            set w [lindex $todo 0]
            set interp [lindex $todo 1]
            set i [list interp eval $interp]
            set todo [lrange $todo 2 end]
            set long $interp$w
            if {$w in {.windowbrowser}} continue

            foreach child [lsort -dictionary [{*}$i winfo children $w]] {
                lappend todo $child $interp
            }
            set id($long) "N$long"
            if {[info exists parents($long)]} {
                # Parent passed from other interp
                set parentId $id($parents($long))
            } else {
                set parent [{*}$i winfo parent $w]
                if {$parent eq ""} {
                    set parentId ""
                } else {
                    set parentId $id($interp$parent)
                }
            }

            set class [{*}$i winfo class $w]
            set out "$w  ($class)\n"
            set delayed ""
            foreach param [{*}$i $w configure] {
                lassign $param flag _ _ def value
                if {$value ne $def} {
                    append out "[list $flag $value] "
                } else {
                    append delayed "[list $flag $value] "
                }
                if {$flag eq "-container" && $value == 1} {
                    lappend containers $w $interp
                }
            }
            if {$delayed ne ""} {
                append out \n $delayed
            }
            try {
                set ix [{*}$i grid info $w]
                if {$ix ne ""} {
                    append out "\n\ngrid\n$ix"
                }
            } on error {} {}
            try {
                set ix [{*}$i pack info $w]
                if {$ix ne ""} {
                    append out "\n\npack\n$ix"
                }
            } on error {} {}

            set name $w
            regexp {\.[^.]+$} $w name

            set open 1
            if {[string match "*#*" $w]} {
                set open 0
            }

            set d {}
            dict set d w $w
            dict set d interp $interp
            dict set d id $id($long)
            dict set d out $out

            $tree insert $parentId end -id $id($long) -open $open \
                    -text $name -values [list $d]
        }
        # TODO: Handle -container and subinterp? How?
        foreach {w interp} $containers {
            set wid [winfo id $w]
            foreach sub [interp slaves $interp] {
                try {
                    set subId [interp eval $sub . cget -use]
                    if {$subId == $wid} {
                        #puts "Found interp $sub for $w"
                        set parents($sub.) $interp$w
                        lappend todo . $sub
                    }
                } on error {} {}

            }
        }
        #break
    }
}

#-----------------------------------------------------------------------------
# Procedure/method editor
#-----------------------------------------------------------------------------

# An item was selected. Show it and make it editable.
proc ::_Debug::ProcEditorSelected {} {
    variable allcmds

    set ::_Debug::ProcEditor(current) ""
    set ::_Debug::ProcEditor(parent) ""
    set ::_Debug::ProcEditor(proc) ""
    set ::_Debug::ProcEditor(args) ""
    $::_Debug::ProcEditor(bodyW) delete 1.0 end

    set tree $::_Debug::ProcEditor(treeW)
    set items [$tree selection]
    if {[llength $items] < 1} return
    set item [lindex $items 0]
    set d $allcmds($item)
    set type [dict get $d type]
    set parent [dict get $d parent]
    set name [dict get $d name]

    set ::_Debug::ProcEditor(current) $item
    set ::_Debug::ProcEditor(parent) $parent
    set ::_Debug::ProcEditor(proc) $name
    set ::_Debug::ProcEditor(args) ""
    $::_Debug::ProcEditor(bodyW) delete 1.0 end

    set traceState normal
    if {$type eq "proc"} {
        set arglist {}
        foreach i [info args $item] {
            if {[info default $item $i value]} {
                lappend arglist [list $i $value]
            } else {
                lappend arglist [list $i]
            }
        }
        set body [info body $item]
        set ::_Debug::ProcEditor(args) $arglist
        $::_Debug::ProcEditor(bodyW) insert end $body
    } elseif {$type eq "method"} {
        lassign [info class definition $parent $name] arglist body
        set traceState disabled
        set ::_Debug::ProcEditor(args) $arglist
        $::_Debug::ProcEditor(bodyW) insert end $body
    } else {
        set traceState disabled
    }
    foreach w $::_Debug::ProcEditor(traceWs) {
        $w configure -state $traceState
    }

}

# Redefine currently edited proc/method
proc ::_Debug::ProcEditorRedefine {} {
    variable allcmds
    set body [$::_Debug::ProcEditor(bodyW) get 1.0 end]
    set body [string trimright $body]

    set item $::_Debug::ProcEditor(current)
    set d $allcmds($item)
    set type [dict get $d type]
    set parent [dict get $d parent]
    set name [dict get $d name]

    if {$type eq "proc"} {
        set todo [list proc $item \
                          $::_Debug::ProcEditor(args) $body]
        set ::_Debug::redefines($item) $todo
        uplevel \#0 $todo
    } elseif {$type eq "method"} {
        set todo [list oo::define $parent method $name \
                          $::_Debug::ProcEditor(args) $body]
        set ::_Debug::redefines($parent..$name) $todo
        uplevel \#0 $todo
    }
}

proc ::_Debug::ProcEditorCopy {} {
    clipboard clear
    foreach item [array names ::_Debug::redefines] {
        clipboard append $::_Debug::redefines($item)\n
    }
}

# Tracing of commands
proc ::_Debug::ProcEditorTrace {level} {
    variable allcmds
    set item $::_Debug::ProcEditor(current)
    set d $allcmds($item)
    set type [dict get $d type]
    set parent [dict get $d parent]
    set name [dict get $d name]
    if {$type ni "proc method"} return

    # TODO: methods
    if {$type eq "proc"} {
        if {$level == 1} {
            TR $item
        } elseif {$level == 2} {
            TR $item 1
        } else {
            TRoff $item
        }
    }
}

# Disassemble of current
proc ::_Debug::ProcEditorDisas {} {
    variable allcmds
    set item $::_Debug::ProcEditor(current)
    set d $allcmds($item)
    set type [dict get $d type]
    set parent [dict get $d parent]
    set name [dict get $d name]
    if {$type ni "proc method"} return

    if {$type eq "proc"} {
        set da [tcl::unsupported::disassemble proc $item]
    } else {
        set da [tcl::unsupported::disassemble method $parent $name]
    }

    set top .proceditor.disas
    destroy $top
    ttk::toplevel $top
    wm title $top "Proc Editor Disassemble"

    text $top.t -yscrollcommand "$top.sby set"
    ttk::scrollbar $top.sby -orient vertical -command "$top.t yview"

    grid $top.t $top.sby -padx 3 -pady 3 -sticky news

    grid columnconfigure $top 0 -weight 1
    grid rowconfigure    $top 0 -weight 1

    $top.t insert end $da
}

# Treeview filtering. React on keystroke
proc ::_Debug::ProcEditorFilter {aVal kVal} {
    set f $::_Debug::ProcEditor(filter)
    set fx $::_Debug::ProcEditor(filterx)
    # Do not react unless changed.
    if {$f eq $fx} {
        return
    }
    set tree $::_Debug::ProcEditor(treeW)

    # Recreate the tree.
    # This is easier since the treeview does not have an item hide attribute.
    set pat *$f*
    TreePopulate $tree $pat
    set ::_Debug::ProcEditor(filterx) $f
}

# Make sure the hierarchy for a leaf exist, creating if needed.
proc ::_Debug::TreeCreatePath {tree path} {
    if {[$tree exists $path]} return
    set d $::_Debug::allcmds($path)
    set parent [dict get $d parent]
    if {$path ni {"" ::}} {
        TreeCreatePath $tree $parent
    }
    set text [dict get $d name]
    if {$parent eq "::"} {
        set parent ""
    }

    $tree insert $parent end -id $path -text $text -open 1 \
            -values [list $parent]
}

# Populate the treeview with all known procs and methods
proc ::_Debug::TreePopulate {tree {filter *}} {
    $tree delete [$tree children {}]
    foreach cmd [lsort -dictionary [array names ::_Debug::allcmds]] {
        set d $::_Debug::allcmds($cmd)
        set type [dict get $d type]
        if {$type ni "proc method"} continue
        if { ! [string match -nocase $filter [dict get $d name]]} continue

        set path [dict get $d parent]
        if {$path ne ""} {
            TreeCreatePath $tree $path
        }
        $tree insert $path end -id $cmd \
                -text [dict get $d name] -values [list $path]
    }
}

# Main Proc Editor window
proc ::_Debug::ProcEditor {} {
    ::_Debug::CollectInfo

    set top .proceditor
    destroy $top
    ttk::toplevel $top -padx 3 -pady 3
    wm title $top "Proc Editor"

    ttk::frame $top.ftree
    set ::_Debug::ProcEditor(filter) ""
    set ::_Debug::ProcEditor(filterx) ""
    ttk::entry $top.ftree.ef -textvariable ::_Debug::ProcEditor(filter)
    addBalloon $top.ftree.ef "Filter"
    bind $top.ftree.ef <KeyRelease> {::_Debug::ProcEditorFilter %A %K}
    set tree $top.ftree.tree
    set ::_Debug::ProcEditor(treeW) $tree
    ttk::treeview $tree -height 20 -selectmode browse -show "tree" \
            -yscrollcommand "$top.ftree.sby set"
    ttk::scrollbar $top.ftree.sby -orient vertical -command "$tree yview"
    $tree tag configure highlight -background pink
    $tree column "#0" -minwidth 50 -width 200
    pack $top.ftree.ef -side "top" -fill x -padx 3 -pady 3
    pack $top.ftree.sby -side right -fill y -pady 3 -padx {0 3}
    pack $tree -fill both -expand 1 -pady 3 -padx {3 0}
    TreePopulate $tree
    bind $tree <<TreeviewSelect>> ::_Debug::ProcEditorSelected

    ttk::label $top.l1a -text "Parent" -anchor w
    ttk::label $top.l1b -textvariable ::_Debug::ProcEditor(parent) -anchor w
    ttk::label $top.l2a -text "Proc/Method" -anchor w
    ttk::label $top.l2b -textvariable ::_Debug::ProcEditor(proc) -anchor w
    ttk::label $top.l3a -text "Args" -anchor w
    ttk::label $top.l3b -textvariable ::_Debug::ProcEditor(args) -anchor w
    ttk::button $top.bc -text "Copy" -command ::_Debug::ProcEditorCopy
    addBalloon $top.bc "Put all redefines on clipboard"

    set ::_Debug::ProcEditor(bodyW) [text $top.t -yscrollcommand "$top.sby set" \
                                             -width 90]
    ttk::scrollbar $top.sby -orient vertical -command "$top.t yview"

    ttk::frame  $top.fb
    ttk::button $top.b1 -text "Redefine" -command ::_Debug::ProcEditorRedefine
    addBalloon $top.b1 "Redefine for this session"
    ttk::button $top.b2 -text "Disas"    -command ::_Debug::ProcEditorDisas
    addBalloon $top.b2 "Show byte code"
    ttk::button $top.b3 -text "Trace"    -command "::_Debug::ProcEditorTrace 1"
    addBalloon $top.b3 "Enable execution trace"
    ttk::button $top.b4 -text "Tr Step"  -command "::_Debug::ProcEditorTrace 2"
    addBalloon $top.b4 "Enable detailed execution trace"
    ttk::button $top.b5 -text "Tr Off"   -command "::_Debug::ProcEditorTrace 0"
    addBalloon $top.b5 "Disable execution trace"
    set ::_Debug::ProcEditor(traceWs) [list $top.b3 $top.b4 $top.b5]
    grid $top.b1 $top.b2 $top.b3 $top.b4 $top.b5 -in $top.fb
    grid columnconfigure $top.fb all -weight 1 -uniform a

    grid $top.ftree $top.l1a $top.l1b - $top.bc - -padx 3 -pady 3 -sticky news
    grid ^          $top.l2a $top.l2b - -       - -padx 3 -pady 3 -sticky we
    grid ^          $top.l3a $top.l3b - -       - -padx 3 -pady 3 -sticky we
    grid ^          $top.t  -         - -  $top.sby -padx 3 -pady 3 -sticky news
    grid ^          $top.fb -         - -  -        -padx 3 -pady 3 -sticky we

    grid columnconfigure $top 2 -weight 1
    grid rowconfigure    $top $top.t -weight 1
}

#-----------------------------------------------------------------------------
# Procedure/method information collection
#-----------------------------------------------------------------------------
#
# There is nuances to namespace handling that needs awareness.
#
# "parent" operates on just existing namespaces and cannot be used on
# procedures. It returns a normalized name, with a slight gotcha that
# top namespace is "::", thus ending in colons. Thus this cannot be used
# directly for joining without care.
# % namespace parent ::eskil::rev
# ::eskil
# % namespace parent eskil::rev
# ::eskil
# % namespace parent ::eskil
# ::
# % namespace parent ::
#
# "qualifier" pairs with "tail"
# It just parses the string and does not need to make sense.
# Thus this can be used on qualified procedure names.
# % namespace qualifier ::eskil::rev
# ::eskil
# % namespace qualifier eskil::rev
# eskil
# % namespace qualifier ::eskil
#
# Ditto with "tail"
# % namespace tail ::eskil::rev
# rev
# % namespace tail ::eskil
# eskil
# % namespace tail ::
#
# "children", like "parent", operates on real namespace and normalizes.
# % namespace children ::eskil
# ::eskil::rev
# % namespace children ::eskil::
# ::eskil::rev
# % namespace children ""
# ::eskil ::zlib ::pkg ::oo ::tcl
#
# Conclusion:
# If a namespace is always kept with "::" at the end things are mostly easy.
# "parent" and "children" will work, as well as joining with $parent$tail.
# This cannot be used with "qualifiers", so extra care is needed there.
# The helpers below handles this.

# Parent namespace. Always ends with ::
proc ::_Debug::Qualifiers {ns} {
    set ns [string trimright $ns ":"]
    set q [namespace qualifiers $ns]
    if { ! [string match *:: $q]} {
        append q ::
    }
    return $q
}
# Parent namespace. Always ends with ::
proc ::_Debug::Parent {ns} {
    set p [namespace parent $ns]
    if { ! [string match *:: $p]} {
        append p ::
    }
    return $p
}

# allcmds structure:
# fullId for different things:
#   proc: Its qualified namespace path. Name = leaf
#   namespace: Its qualified namespace path ending in ::. Name = leaf::
#   class: Its qualified namespace path. Name = leaf
#   method: A list of class id + method. Name = method
# allcmds(fullId) = dict:
#   type = proc/namespace/class/method/import
#   parent = fullId of parent/class
#   name = leaf name
#   origin = for import

# Collect all info about procedures/method/whatever.
# This is work in progress...
proc ::_Debug::CollectInfo {} {
    variable allcmds
    array set allcmds {}

    # Only do this once
    if {[array size allcmds] > 0} return

    # Find all commands in all namespaces
    set todoNs [list ::]
    while {[llength $todoNs] != 0} {
        set nsId [lindex $todoNs 0]
        set todoNs [lrange $todoNs 1 end]

        if {$nsId eq "::_Debug::"} continue

        set tail [namespace tail [string trimright $nsId ":"]]
        dict set allcmds($nsId) type   namespace
        dict set allcmds($nsId) parent [Parent $nsId]
        dict set allcmds($nsId) name   ${tail}::

        foreach child [namespace children $nsId] {
            lappend todoNs ${child}::
        }
        array unset thisround
        array set thisround {}
        # First collect commands, since we want to override with detail later
        foreach cmd [info commands $nsId*] {
            dict set allcmds($cmd) type "cmd"
            dict set allcmds($cmd) parent [Qualifiers $cmd]
            dict set allcmds($cmd) name [namespace tail $cmd]
            set thisround($cmd) 1
        }
        # Which ones are procs?
        foreach cmd [info procs $nsId*] {
            dict set allcmds($cmd) type "proc"
            dict set allcmds($cmd) parent [Qualifiers $cmd]
            dict set allcmds($cmd) name [namespace tail $cmd]
            set thisround($cmd) 0
        }
        # Which ones are imports?
        if { ! [catch {namespace eval $nsId {namespace import}} imports]} {
            foreach cmd $imports  {
                dict set allcmds($nsId$cmd) type "import"
                dict set allcmds($nsId$cmd) origin \
                        [namespace origin $nsId$cmd]
                set thisround($nsId$cmd) 0
            }
        }

        # Look through and command that is not something identified
        foreach cmd [array names thisround] {
            if { ! $thisround($cmd)} continue

            # Is it an ensemble?
            if {[namespace ensemble exists $cmd]} {
                #puts "ENSEMBLE $cmd"
                dict set allcmds($cmd) type ensemble
                foreach {key val} [namespace ensemble configure $cmd] {
                    #lappend allcmds($cmd) $key $val
                    if {$key eq "-map"} {
                        #puts "$cmd $val"
                        dict lappend allcmds($cmd) maps {*}$val
                    }
                    # Recognise a snit class
                    if {$key eq "-unknown" && [string match ::snit::* $val]} {
                        #puts "SNIT? $cmd"
                        #lset allcmds($cmd) 0 snit
                    }
                }
                set thisround($cmd) 0
                continue
            }
        }
        # Namespace ensembles?
    }

    # Go through tcloo classes
    set todoObj [list ::oo::object]
    while {[llength $todoObj] != 0} {
        set obj [lindex $todoObj 0]
        set todoObj [lrange $todoObj 1 end]

        dict set allcmds($obj) type class
        dict set allcmds($obj) parent [Qualifiers $obj]
        dict set allcmds($obj) name   [namespace tail $obj]

        foreach child [info class subclasses $obj] {
            lappend todoObj $child
        }
        foreach m [info class methods $obj -private] {
            set id [list $obj $m]
            dict set allcmds($id) type method
            dict set allcmds($id) parent $obj
            dict set allcmds($id) name $m
        }
    }
}

# Debug of debug
proc ::_Debug::DumpStuff {} {
    try {
        ::_Debug::CollectInfo
    } on error {res i} {
        puts $res
        puts $i
        after 1000
    }

    # Proc
    parray ::_Debug::allcmds *updateColors*
    parray ::_Debug::allcmds *cleanupAndExit
    # Cmd
    parray ::_Debug::allcmds *ttk::paned
    parray ::_Debug::allcmds *llength
    # OO class
    parray ::_Debug::allcmds *Account*
    # Snit class
    parray ::_Debug::allcmds *eskilprint*
    #
    parray ::_Debug::allcmds *indexEntry*
    exit
}

#-----------------------------------------------------------------------------
# Test just to include an OO object in the code
#-----------------------------------------------------------------------------
catch {Account destroy}
oo::class create Account {
    constructor {{ownerName undisclosed}} {
        my variable total overdrawLimit owner
        set total 0
        set overdrawLimit 10
        set owner $ownerName
    }
    method deposit amount {
        my variable total
        set total [expr {$total + $amount}]
    }
    method withdraw amount {
        my variable total overdrawLimit
        if {($amount - $total) > $overdrawLimit} {
            error "Can't overdraw - total: $total, limit: $overdrawLimit"
        }
        set total [expr {$total - $amount}]
    }
    method transfer {amount targetAccount} {
        my variable total
        my withdraw $amount
        $targetAccount deposit $amount
        set total
    }
    method dump {} {
        #HoHA
    }
    destructor {
        my variable total
        if {$total} {puts "remaining $total will be given to charity"}
    }
}

#  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
#  Boston, MA 02111-1307, USA.
#
#----------------------------------------------------------------------
# $Revision$
#----------------------------------------------------------------------



# Compare file names
proc FStrCmp {s1 s2} {
    # Equality is based on platform's standard
    # Order is dictionary order

    # Exact equal is equal regardless of platform.
    if {$s1 eq $s2} {
        return 0
    }
    # Accept case insensitive equality on windows
    if {$::tcl_platform(platform) eq "windows"} {
        if {[string equal -nocase $s1 $s2]} {
            return 0
        }
    }
    # FIXA: What's the case on Mac?

    if {[lindex [lsort -dictionary [list $s1 $s2]] 0] eq $s1} {
        return -1
    }
    return 1
}

# Sort file names
proc Fsort {lst} {
    lsort -dictionary $lst
}

# Compare two files or dirs
# Return true if equal
proc CompareFiles {file1 file2} {

    if {[catch {file lstat $file1 stat1}]} {
        return 0
    }
    if {[catch {file lstat $file2 stat2}]} {
        return 0
    }

    # Same type?
    set isdir1 [FileIsDirectory $file1]
    set isdir2 [FileIsDirectory $file2]
    if {$isdir1 != $isdir2} {
        return 0
    }
    # Handle links
    if {$stat1(type) eq "link" && $stat2(type) eq "link"} {
        set l1 [file link $file1]
        set l2 [file link $file2]
        # Equal links are considered equal, otherwise check contents
        if {$l1 eq $l2} {
            return 1
        }
        file stat $file1 stat1
        file stat $file2 stat2
    }
    # If contents is not checked, same size is enough to be equal
    if {$stat1(size) == $stat2(size) && $::Pref(dir,comparelevel) == 0} {
        return 1
    }
    set anyPlugin $::eskil(.dirdiff,dirPlugin)

    set ignorekey $::Pref(dir,ignorekey)
    set nocase    $::Pref(nocase)
    # Different size is enough when doing binary compare
    if {$stat1(size) != $stat2(size) && $::Pref(dir,comparelevel) == 2 \
        && !$ignorekey && !$anyPlugin} {
        return 0
    }




    # Don't check further if contents should not be checked
    if {$::Pref(dir,comparelevel) == 0} {
        return 0
    }
    # Don't check further if any is a directory
    if {$isdir1 || $isdir2} {
        # Consider dirs equal until we implement something recursive
        return 1
    }

    switch $::Pref(dir,comparelevel) {
        2 -
        1 { # Check contents internally
            set bufsz 65536
            set eq 2 ;# 2 = equal this far, 1 = equal, 0 = not equal
            set ch1 [open $file1 r]
            set ch2 [open $file2 r]
            if {$::Pref(dir,comparelevel) == 2} {
                fconfigure $ch1 -translation binary
                fconfigure $ch2 -translation binary
            }
            # Allow a plugin to do its thing
            if {$anyPlugin} {
                #puts "PLUGIN!"
                $::eskil(.dirdiff,plugin,$anyPlugin) eval \
                        [list array set ::Pref [array get ::Pref]]
                $::eskil(.dirdiff,plugin,$anyPlugin) eval \
                        [list set ::argv $::eskil(argv)]
                interp share {} $ch1 $::eskil(.dirdiff,plugin,$anyPlugin)
                interp share {} $ch2 $::eskil(.dirdiff,plugin,$anyPlugin)
                set info1 [dict create name $file1 size $stat1(size)]
                set info2 [dict create name $file2 size $stat2(size)]
                set eq [$::eskil(.dirdiff,plugin,$anyPlugin) eval \
                                [list FileCompare $ch1 $ch2 $info1 $info2]]
                set allow [dict get $::eskil(.dirdiff,pluginpinfo,$anyPlugin) allow]
                if {$allow} {
                    $::eskil(.dirdiff,plugin,$anyPlugin) eval close $ch1
                    $::eskil(.dirdiff,plugin,$anyPlugin) eval close $ch2
                } else {
                    $::eskil(.dirdiff,plugin,$anyPlugin) invokehidden close $ch1
                    $::eskil(.dirdiff,plugin,$anyPlugin) invokehidden close $ch2
                }
            }

            if {$ignorekey} {
                # Assume that all keywords are in the first block
                set f1 [read $ch1 $bufsz]
                set f2 [read $ch2 $bufsz]
                regsub -all {\$\w+:[^\$]*\$} $f1 {} f1
                regsub -all {\$\w+:[^\$]*\$} $f2 {} f2
                # Compensate for any change in length
                if {[string length $f1] < [string length $f2]} {
                    append f1 [read $ch1 [expr {[string length $f2] - [string length $f1]}]]
                }
                if {[string length $f2] < [string length $f1]} {
                    append f2 [read $ch2 [expr {[string length $f1] - [string length $f2]}]]
                }
                if {$nocase} {
                    if { ! [string equal -nocase $f1 $f2]} {
                        set eq 0
                    }
                } else {
                    if { ! [string equal $f1 $f2]} {
                        set eq 0
                    }
                }
            }
            while {$eq == 2 && ![eof $ch1] && ![eof $ch2]} {
                set f1 [read $ch1 $bufsz]
                set f2 [read $ch2 $bufsz]
                if {$nocase} {
                    if { ! [string equal -nocase $f1 $f2]} {
                        set eq 0
                    }
                } else {
                    if { ! [string equal $f1 $f2]} {
                        set eq 0
                    }
                }
                # It has been observered that sometimes channels fail to
                # signal eof. Maybe when they come from a pipe?
                # Protect by noticing empty strings.
                if {[string equal $f1 ""] || [string equal $f2 ""]} {
                    break
                }
            }
            if {$eq == 2 && (![eof $ch1] || ![eof $ch2])} {
                set eq 0
            }
            # Errors during close are not interesting
            catch {close $ch1}
            catch {close $ch2}
        }
    }
    return [expr {$eq != 0}]
}

# Returns the contents of a directory as a sorted list of full file paths.
proc DirContents {dir} {
    if {$::tcl_platform(platform) eq "windows"} {
        # .-files are not treated specially on windows. * is enough to get all
        set files [glob -directory $dir -nocomplain *]
    } else {
        set files [glob -directory $dir -nocomplain *]
        # Handle .-files and make sure no duplicates are generated
        set files2 [glob -directory $dir -nocomplain {.[a-zA-Z]*}]
        foreach file $files2 {
            if {$file ni $files} {
                lappend files $file
            }
        }
    }

    if {$::Pref(dir,onlyrev)} {
        # FIXA: move to rev and make general for other systems
        set entries [file join $dir CVS Entries]
        if {[file exists $entries]} {
            set ch [open $entries r]
            set data [read $ch]
            close $ch
            foreach line [split $data \n] {

            }
            set files $files2
        }
    }

    set files2 {}
    foreach file $files {
        set full $file
        set tail [file tail $file]
        # Apply filters
        if {[FileIsDirectory $full]} {
            if {[llength $::Pref(dir,incdirs)] == 0} {
                set allowed 1
            } else {
                set allowed 0
                foreach pat $::Pref(dir,incdirs) {
                    if {[string match $pat $tail]} {
                        set allowed 1
                        break
                    }
                }
            }
            if {$allowed} {
                foreach pat $::Pref(dir,exdirs) {
                    if {[string match $pat $tail]} {
                        set allowed 0
                        break
                    }
                }
            }
            if { ! $allowed} continue
        } else {
            if {[llength $::Pref(dir,incfiles)] == 0} {
                set allowed 1
            } else {
                set allowed 0
                foreach pat $::Pref(dir,incfiles) {
                    if {[string match $pat $tail]} {
                        set allowed 1
                        break
                    }
                }
            }
            if {$allowed} {
                foreach pat $::Pref(dir,exfiles) {
                    if {[string match $pat $tail]} {
                        set allowed 0
                        break
                    }
                }
            }
            if { ! $allowed} continue
        }
        lappend files2 $full
    }

    return [Fsort $files2]
}

# Bring up an editor to display a file.
proc EditFile {file} {
    locateEditor ::util(editor)
    # util(editor) may contain options, and is treated as a pre-command
    exec {*}$::util(editor) $file &
}

# Pick a directory for compare
proc BrowseDir {dirVar entryW} {

    upvar "#0" $dirVar dir

    set newdir $dir
    while {$newdir != "." && ![FileIsDirectory $newdir]} {
        set newdir [file dirname $newdir]
    }
    set newdir [tk_chooseDirectory -initialdir $newdir -title "Select Directory"]

    component tree
    component hsb
    component vsb

    option -leftdirvariable  -default "" -configuremethod SetDirOption
    option -rightdirvariable -default "" -configuremethod SetDirOption
    option -statusvar -default ""
    option -changelist -default ""
    option -norun -default 0
    # TODO: better name for experimental parameter
    option -bepa -default 0

    variable AfterId ""
    variable DebugCh ""
    variable DebugTime {}
    variable PauseBgProcessing 0
    variable ScheduledRestart 0
    variable AfterTime 1
    variable WorkTime 200
    variable IdleQueue {}
    variable IdleQueueArr
    variable NodeStatus
    variable leftMark ""
    variable rightMark ""
    variable leftDir ""
    variable rightDir ""
    variable protect {left 0 right 0}

    constructor {args} {
        variable color
        install tree using tablelist::tablelist $win.tree -height 20 \
                -movablecolumns no -setgrid no -showseparators yes \
                -expandcommand [mymethod expandCmd] \
                -collapsecommand [mymethod collapseCmd] \
                -fullseparators yes -selectmode none \
                -columns {0 "Structure" 0 Size 0 Date 0 Copy 0 Size 0 Date}
        install vsb using ttk::scrollbar $win.vsb -orient vertical \
                -command "$tree yview"
        install hsb using ttk::scrollbar $win.hsb -orient horizontal \
                -command "$tree xview"












        set AfterId ""
        set IdleQueue {}

        $tree configure -yscrollcommand "$vsb set" -xscrollcommand "$hsb set"

        $tree columnconfigure 0 -name structure
        $tree columnconfigure 1 -name leftsize -align right
        $tree columnconfigure 2 -name leftdate
        $tree columnconfigure 3 -name command
        $tree columnconfigure 4 -name rightsize -align right
        $tree columnconfigure 5 -name rightdate

        destroy [$tree separatorpath 1] [$tree separatorpath 4]

        set color(unknown) grey
        set color(unknown2) grey
        set color(empty) grey
        set color(equal) {}
        set color(new) green
        set color(old) blue
        set color(change) red

        #-expandcommand expandCmd

    }

    method SetDirOption {option value} {
        set options($option) $value

        if {$options(-leftdirvariable) eq ""} return
        upvar \#0 $options(-leftdirvariable) left
        if { ! [info exists left]} return
        if { ! [file isdirectory $left]} return

        if {$options(-rightdirvariable) eq ""} return
        upvar \#0 $options(-rightdirvariable) right
        if { ! [info exists right]} return
        if { ! [file isdirectory $right]} return

        set leftDir $left
        set rightDir $right
        if { ! $ScheduledRestart} {
            set ScheduledRestart 1
            after idle [mymethod ReStart]
        }
    }
    method newTopDir {newLeft newRight} {
        if {$newLeft ne "" && [file isdirectory $newLeft]} {
            upvar \#0 $options(-leftdirvariable) left
            set left $newLeft
            set leftDir $left
        }
        if {$newRight ne "" && [file isdirectory $newRight]} {
            upvar \#0 $options(-rightdirvariable) right
            set right $newRight
            set rightDir $right
        }
        if { ! $ScheduledRestart} {
            set ScheduledRestart 1
            after idle [mymethod ReStart]
        }
    }

    method nice {ms} {
        # Sanity check
        if {$ms < 1} { set ms 1 }
        if {$ms > 1000} {set ms 1000 }
        set AfterTime $ms
    }

    method ReStart {} {
        # 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}

        if {$options(-norun)} {
            set options(-norun) 0
            return
        }

        # Directory Diff only supports one plugin.
        # Find if any configured plugin supports dir diff and choose it.
        set ::eskil(.dirdiff,dirPlugin) 0
        foreach item [lsort -dictionary [array names ::eskil .dirdiff,pluginname,*]] {
            set n [lindex [split $item ","] end]
            if {$::eskil(.dirdiff,plugin,$n) ne "" && \
                        [dict get $::eskil(.dirdiff,pluginpinfo,$n) dir]} {
                set ::eskil(.dirdiff,dirPlugin) $n
                break
            }
        }

        # Fill in clean root data
        $tree delete 0 end
        set topIndex [$tree insertchild root end {}]
        set d1 [file tail $leftDir]
        set d2 [file tail $rightDir]
        if {$d1 eq $d2} {
            $tree cellconfigure $topIndex,structure -text $d1
        } else {
            $tree cellconfigure $topIndex,structure -text "$d1 vs $d2"
        }
        $tree cellconfigure $topIndex,structure -image $::img(open)
        $tree rowattrib $topIndex type directory
        set NodeStatus($topIndex) ""
        $self SetNodeStatus $topIndex empty
        $tree rowattrib $topIndex leftfull $leftDir
        $tree rowattrib $topIndex rightfull $rightDir

        $self UpdateDirNode $topIndex
    }

    method expandCmd {tbl row} {
        if {[$tree childcount $row] != 0} {
            $tree cellconfigure $row,0 -image $::img(open)
        }
    }

    method collapseCmd {tbl row} {
        $tree cellconfigure $row,0 -image $::img(clsd)
    }

    # Format a time stamp for display
    proc FormatDate {date} {
        clock format $date -format "%Y-%m-%d %H:%M:%S"
    }

    method busyCursor {} {
        variable oldcursor
        if { ! [info exists oldcursor]} {
            set oldcursor(hull) [$hull cget -cursor]
            set oldcursor(tree) [$tree cget -cursor]
        }
        $hull configure -cursor watch
        $tree configure -cursor watch
    }

    method normalCursor {} {
        variable oldcursor
        $hull configure -cursor $oldcursor(hull)
        $tree configure -cursor $oldcursor(tree)
    }

    # Remove all equal nodes from tree
    method PruneEqual {} {
        $self busyCursor
        set todo [$tree childkeys root]
        while {[llength $todo] > 0} {
            set todoNow $todo
            set todo {}
            foreach node $todoNow {
                set status $NodeStatus($node)
                if {$status eq "equal"} {
                    $tree delete $node
                } else {
                    lappend todo {*}[$tree childkeys $node]
                }
            }
        }
        $self normalCursor
    }
    # Remove all empty dir nodes from tree
    method PruneEmpty {} {
        $self busyCursor
        set redo 1
        while {$redo} {
            set redo 0
            set todo [$tree childkeys root]
            while {[llength $todo] > 0} {
                set todoNow $todo
                set todo {}
                foreach node $todoNow {
                    set status $NodeStatus($node)
                    set children [$tree childkeys $node]
                    if {[llength $children] == 0} {
                        set type [$tree rowattrib $node type]
                        if {$type eq "directory"} {
                            $tree delete $node
                            set redo 1
                        }
                    } else {
                        lappend todo {*}$children
                    }
                }
            }
        }
        $self normalCursor
    }

    # Remove all nodes that are just on one side
    method PruneAlone {} {
       $self busyCursor
        set todo [$tree childkeys root]
        while {[llength $todo] > 0} {
            set todoNow $todo
            set todo {}
            foreach node $todoNow {
                set status $NodeStatus($node)
                if {$status in {new old}} {
                    $tree delete $node
                } else {
                    lappend todo {*}[$tree childkeys $node]
                }
            }
        }
        $self normalCursor
    }

    # Open or close all directories in the tree view
    method OpenAll {{state 1}} {
        if {$state} {
            $tree expandall
        } else {
            $tree collapseall
        }
    }

    # Create a directory missing on one side


    method CreateDir {node to} {
        set lf [$tree rowattrib $node leftfull]
        set rf [$tree rowattrib $node rightfull]
        set parent [$tree parent $node]
        set lp [$tree rowattrib $parent leftfull]
        set rp [$tree rowattrib $parent rightfull]

        if {$to eq "right"} {
            set src $lf


            if {$rp ne ""} {
                set dst [file join $rp [file tail $src]]
            } else {
                return
            }
        } elseif {$to eq "left"} {
            set src $rf


            if {$lp ne ""} {
                set dst [file join $lp [file tail $src]]
            } else {
                return
            }
        } else {
            error "Bad from argument to CreateDir: $to"
        }
        if {[tk_messageBox -icon question -title "Create dir?" -message \
                    "Create\n$dst ?" -type yesno] eq "yes"} {
            file mkdir $dst
            # FIXA: update file info in tree too
            #$self SetNodeStatus $node equal
        }
    }

    # Copy a file from one directory to the other
    method CopyFile {node from} {
        ##nagelfar vartype tree _obj,tablelist
        if {$from eq "left"} {
            set to right
        } elseif {$from eq "right"} {
            set to left
        } else {
            error "Bad from argument to CopyFile: $from"
        }


        set fromf  [$tree rowattrib $node ${from}full]
        set tof    [$tree rowattrib $node ${to}full]
        set parent [$tree parent $node]
        set fromp  [$tree rowattrib $parent ${from}full]
        set top    [$tree rowattrib $parent ${to}full]

        set src $fromf
        if {$tof ne ""} {
            set dst $tof
        } else {
            # Go up until we find a common parent
            set dst [file tail $src]
            set Count 0 ;# Safety check while debugging
            while {$Count < 1000} {
                if {[incr Count] > 999} {
                    error "Internal error in CopyFile $from"
                }
                if {$top ne ""} {
                    set dst [file join $top $dst]
                    break
                }
                # Continue up to a commmon parent
                set dst [file join [file tail $fromp] $dst]
                set parent [$tree parent $parent]
                set fromp [$tree rowattrib $parent ${from}full]
                set top   [$tree rowattrib $parent ${to}full]
            }
        }

        if {[file exists $dst]} {
            if {[tk_messageBox -icon question -title "Overwrite file?" -message \
                    "Copy\n$src\n\noverwriting\n$dst ?" -type yesno] eq "yes"} {
                file copy -force $src $dst
                # FIXA: update file info in tree too
                $self SetNodeStatus $node equal
            }
        } else {
            set msg "Copy\n$src\nto\n$dst ?"
            set dstdir [file dirname $dst]
            if { ! [file isdirectory $dstdir]} {
                append msg "\nCreating Directory\n$dstdir ?"
            }

            if {[tk_messageBox -icon question -title "Copy file?" -message \
                         $msg -type yesno] eq "yes"} {
                if { ! [file isdirectory $dstdir]} {
                    file mkdir $dstdir
                }
                file copy $src $dst
                # FIXA: update file info in tree too
                $self SetNodeStatus $node equal
            }
        }
    }

    # React on double-click
    method DoubleClick {W x y} {
        foreach {W x y} [tablelist::convEventFields $W $x $y] break
        set index [$tree index @$x,$y]
        set node [$tree getfullkeys $index]

        set lf [$tree rowattrib $node leftfull]
        set rf [$tree rowattrib $node rightfull]
        set type [$tree rowattrib $node type]

        # On a file that exists on both sides, start a file diff
        if {$type eq "file" && $lf ne "" && $rf ne ""} {

        }
    }

    # Bring up a context menu on a file.
    method ContextMenu {W x y X Y} {
        foreach {W x y} [tablelist::convEventFields $W $x $y] break

        set index [$tree index @$x,$y]
        set node [$tree getfullkeys $index]
        set col [$tree columnindex @$x,$y]
        set colname [$tree columncget $col -name]

        set lf [$tree rowattrib $node leftfull]
        set rf [$tree rowattrib $node rightfull]
        set type [$tree rowattrib $node type]
        set oneside [expr {($lf ne "") ^ ($rf ne "")}]

        set m $win.popup
        destroy $m
        menu $m

        if {$colname eq "structure"} {
            $m add command -label "Prune equal" -command [mymethod PruneEqual]
            $m add command -label "Prune empty" -command [mymethod PruneEmpty]
            $m add command -label "Prune alone" -command [mymethod PruneAlone]
            $m add command -label "Expand all" -command [mymethod OpenAll]
            $m add command -label "Collapse all" -command [mymethod OpenAll 0]
        }

        if {$type eq "file" && $lf ne "" && $rf ne ""} {
            # Files, both exist
            $m add command -label "Compare Files" -command [list \
                    newDiff $lf $rf]
        }
        if {$type eq "directory"} {
            if {$lf ne "" && $rf ne ""} {
                # Directory, both exist
                $m add command -label "Go down" -command [mymethod \
                        newTopDir $lf $rf]
            }
            if {$lf ne ""} {
                # Directory, left exist
                $m add command -label "Go down left" -command \
                        [mymethod newTopDir $lf ""]
                if {$rf eq ""} {
                    # Only left exist
                    $m add command -label "Create Dir right" -command \
                            [mymethod CreateDir $node right]
                }
            }
            if {$rf ne ""} {
                # Directory, right exist
                $m add command -label "Go down right" -command \
                        [mymethod newTopDir "" $rf]
                if {$lf eq ""} {
                    # Only right exist
                    $m add command -label "Create Dir left" -command \
                            [mymethod CreateDir $node left]
                }
            }
        }
        if {$type eq "file"} {
            if {([string match left* $colname] || $oneside) && $lf ne ""} {
                if { ! [dict get $protect right]} {
                    $m add command -label "Copy File to Right" \
                            -command [mymethod CopyFile $node left]
                }
                $m add command -label "Edit Left File" \
                        -command [list EditFile $lf]
                $m add command -label "Mark Left File" \
                        -command [list set [myvar leftMark] $lf]
                if {$rightMark != ""} {
                    $m add command -label "Compare Left with $rightMark" \
                            -command [list newDiff $lf $rightMark]
                }
            } elseif {([string match right* $colname] || $oneside) && $rf ne ""} {
                if { ! [dict get $protect left]} {
                    $m add command -label "Copy File to Left" \
                            -command [mymethod CopyFile $node right]
                }
                $m add command -label "Edit Right File" \
                        -command [list EditFile $rf]
                $m add command -label "Mark Right File" \
                        -command [list set [myvar rightMark] $rf]
                if {$leftMark != ""} {
                    $m add command -label "Compare Right with $leftMark" \
                            -command [list newDiff $leftMark $rf]
                }
            }
        }
        if {[string match left* $colname] && ![dict get $protect left]} {
            $m add command -label "Protect Left Side" \
                    -command [mymethod ProtectSide left]
        } elseif {[string match right* $colname] && ![dict get $protect right]} {
            $m add command -label "Protect Right Side" \
                    -command [mymethod ProtectSide right]
        }

        tk_popup $m $X $Y
    }

    # Mark one side as protected and disable all copy buttons
    method ProtectSide {side} {
        variable widgets
        dict set protect $side 1
        foreach w [dict get $widgets $side] {
            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 {} {
        ##nagelfar vartype tree _obj,tablelist
        $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]
            #puts "$pre $post [expr {$post - $pre}]"
            if {($post - $pre) > $WorkTime} 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 ""} {
            upvar \#0 $options(-statusvar) statusvar
        }

        if {[llength $errors] > 0} {
            lassign $errors node err
            set leftfull [$tree rowattrib $node leftfull]
            set rightfull [$tree rowattrib $node rightfull]
            set answer [tk_messageBox -icon error -type abortretryignore \
                    -message \
                    "Error comparing\n$leftfull\nvs\n$rightfull:\n$err"]
            if {$answer eq "retry"} {
                $self AddNodeToIdle $node
            } elseif {$answer eq "ignore"} {
                # Do nothing, just continue
            } else {
                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)"
            }

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

    method SetNodeStatus {node status} {
        variable color
        set old $NodeStatus($node)
        if {$old eq $status} return
        set NodeStatus($node) $status
        $tree rowconfigure $node -foreground $color($status) \
                -selectforeground $color($status)
        #puts "Set [$tree item $node -text] to $status"

        # Loop through children to update parent
        set parent [$tree parentkey $node]
        if {$parent eq "" || $parent eq "root"} { return }

        # If this is only present on one side, there is no need to update
        set lf [$tree rowattrib $parent leftfull]
        set rf [$tree rowattrib $parent rightfull]
        if {$lf eq "" || $rf eq ""} { return }

        # If parent is being filled, do not update yet
        if {$NodeStatus($parent) eq "unknown2"} {
            return
        }
        set pstatus equal
        foreach child [$tree childkeys $parent] {
            set status $NodeStatus($child)
            switch $status {
                unknown - unknown2 {
                    set pstatus unknown
                }
                new - old - change {
                    set pstatus change
                    break
                }
            }
        }
        $self SetNodeStatus $parent $pstatus
    }

    method UpdateDirNode {node} {
        if {[$tree rowattrib $node type] ne "directory"} {
            return
        }
        if {$NodeStatus($node) ne "empty"} {
            #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"
	if {$options(-bepa)} {
	    if {$leftfull eq ""} {
		$self SetNodeStatus $node new
		return
	    }
	    if {$rightfull eq ""} {
		$self SetNodeStatus $node old
		return
	    }
	}
        $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
            }
            #puts "$rightfull checked since in change list"
        }
        set equal [CompareFiles $leftfull $rightfull]
        if {$equal} {
            $self SetNodeStatus $node "equal"
        } else {
            $self SetNodeStatus $node change
        }
    }

    # List files under a directory node
    # Returns status for the new node
    method ListFiles {df1 df2 node} {







        if {[catch {file lstat $df1 stat1}]} {
            set size1 ""
            set time1 ""
            set type1 ""
        } else {
            set size1 $stat1(size)
            set time1 [FormatDate $stat1(mtime)]
            set type1 $stat1(type)
        }
        if {[catch {file lstat $df2 stat2}]} {
            set size2 ""
            set time2 ""
            set type2 ""
        } else {
            set size2 $stat2(size)
            set time2 [FormatDate $stat2(mtime)]
            set type2 $stat2(type)
        }
        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
        set NodeStatus($id) 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]
            }
        }

        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
        }
        return $NodeStatus($id)
    }

    method addCmdCol {tbl row col w} {
        variable widgets
        set key [$tree getfullkeys $row]
        set status $NodeStatus($key)
        set type   [$tree rowattrib $row type]
        set lf [$tree rowattrib $row leftfull]
        set rf [$tree rowattrib $row rightfull]
        set bg [$tbl cget -background]
        ttk::style configure Apa.TFrame -background $bg
        ttk::style configure Apa.My.Toolbutton -background $bg
        ttk::frame $w -style Apa.TFrame
        ttk::button $w.bl -image $::img(left) -style Apa.My.Toolbutton \
                -command [mymethod CopyFile $key right]
        ttk::button $w.br -image $::img(right) -style Apa.My.Toolbutton \
                -command [mymethod CopyFile $key left]
        pack $w.bl $w.br -side left -fill y
        # Store widgets names
        dict lappend widgets left $w.bl
        dict lappend widgets right $w.br
        if {$lf eq ""} {
            $w.br configure -state disabled
        }
        if {$rf eq ""} {
            $w.bl configure -state disabled
        }
    }

    # Compare two directories.
    method CompareDirs {dir1 dir2 node} {

        if {$dir1 eq ""} {
            set files1 {}
        } else {
            set files1 [DirContents $dir1]
        }
        if {$dir2 eq ""} {
            set files2 {}
        } else {
            set files2 [DirContents $dir2]
        }

        set len1 [llength $files1]
        set len2 [llength $files2]

        # Unknown2 is used to mark a directory filling up
        $self SetNodeStatus $node unknown2

        set p1 0
        set p2 0
        set status_change 0
        set status_unknown 0
        while 1 {
            if {$p1 < $len1 && $p2 < $len2} {
                set df1 [lindex $files1 $p1]
                set f1 [file tail $df1]
                set df2 [lindex $files2 $p2]
                set f2 [file tail $df2]
                set apa [FStrCmp $f1 $f2]
                if {$apa == 0} {
                    # Equal names, separate them if not the same type
                    set apa [expr {- [FileIsDirectory $df1] \
                                   + [FileIsDirectory $df2]}]
                }

                    1 {
                        $self ListFiles "" $df2 $node
                        incr p2
                        set status_change 1
                    }
                }
            } elseif {$p1 < $len1 && $p2 >= $len2} {
                set df1 [lindex $files1 $p1]
                $self ListFiles $df1 "" $node
                incr p1
                set status_change 1
            } elseif {$p1 >= $len1 && $p2 < $len2} {
                set df2 [lindex $files2 $p2]
                $self ListFiles "" $df2 $node
                incr p2
                set status_change 1
            } else {
                break
            }
        }
        if {$dir1 eq ""} {

}

snit::widget DirDiff {
    hulltype toplevel
    widgetclass Toplevel
    component tree
    variable statusVar
    delegate option -norun to tree
    delegate option -bepa  to tree

    constructor {args} {
        eskilRegisterToplevel $win
        wm title $win "Eskil Dir"
        wm protocol $win WM_DELETE_WINDOW [list cleanupAndExit $win]









        install tree using DirCompareTree $win.dc \
                -leftdirvariable ::dirdiff(leftDir) \
                -rightdirvariable ::dirdiff(rightDir) \
                -statusvar [myvar statusVar]
	$self configurelist $args

        if {[info exists ::dirdiff(localChanges)]} {
            $tree configure -changelist $::dirdiff(localChanges)
        }

        ttk::frame $win.fe1
        ttk::frame $win.fe2

        menu $win.m
        $hull configure -menu $win.m

        $win.m add cascade -menu $win.m.mo -label "Preferences" -underline 0
        menu $win.m.mo
        $win.m.mo add command -label "Prefs..." -command makeDirDiffPrefWin
        $win.m.mo add cascade -label "Check" -menu $win.m.mo.mc

        menu $win.m.mo.mc
        $win.m.mo.mc add radiobutton -variable ::Pref(dir,comparelevel) -value 0 \
                -label "Do not check contents"
        $win.m.mo.mc add radiobutton -variable ::Pref(dir,comparelevel) -value 1 \
                -label "Normal compare"
        $win.m.mo.mc add radiobutton -variable ::Pref(dir,comparelevel) -value 2 \
                -label "Exact compare"
        $win.m.mo.mc add checkbutton -variable ::Pref(dir,ignorekey) \
                -label "Ignore \$Keyword:\$"

        $win.m.mo add command -label "Plugins..." -underline 1 \
                -command [list editPrefPlugins $win 1]
        $win.m.mo add cascade -label "Nice" -menu $win.m.mo.mn
        menu $win.m.mo.mn
        $win.m.mo.mn add radiobutton -variable ::Pref(dir,nice) -value 1 \
                -command [mymethod DoNice] -label 1
        $win.m.mo.mn add radiobutton -variable ::Pref(dir,nice) -value 50 \
                -command [mymethod DoNice] -label 50
        $win.m.mo.mn add radiobutton -variable ::Pref(dir,nice) -value 100 \
                -command [mymethod DoNice] -label 100
        $win.m.mo.mn add radiobutton -variable ::Pref(dir,nice) -value 1000 \
                -command [mymethod DoNice] -label 1000
        $win.m.mo add separator
        $win.m.mo add command -label "Save default" \
                -command [list saveOptions $win]

        $win.m add cascade -label "Tools" -underline 0 -menu $win.m.mt
        menu $win.m.mt
        $win.m.mt add command -label "New Diff Window" -underline 0 \
                -command makeDiffWin
        $win.m.mt add command -label "Clip Diff" -underline 0 \
                -command makeClipDiffWin
        if {$::tcl_platform(platform) eq "windows"} {
            if { ! [catch {package require registry}]} {
                $win.m.mt add separator
                $win.m.mt add command -label "Setup Registry" -underline 6 \
                        -command makeRegistryWin
            }
        }

        $win.m add cascade -label "Help" -underline 0 -menu $win.m.help
        menu $win.m.help
        $win.m.help add command -label "Tutorial" -command makeTutorialWin \
                -underline 0
        $win.m.help add command -label "About" -command makeAboutWin -underline 0

        if {$::eskil(debug)} {
            $win.m add cascade -label "Debug" -menu $win.m.md -underline 0
            menu $win.m.md
            if {$::tcl_platform(platform) eq "windows"} {
                $win.m.md add checkbutton -label "Console" -variable consolestate \
                        -onvalue show -offvalue hide -command {console $consolestate}
                $win.m.md add separator
            }
            $win.m.md add command -label "Reread Source" -underline 0 \
                    -command {EskilRereadSource}
            $win.m.md add separator
            $win.m.md add command -label "Redraw Window" -command {makeDirDiffWin}
        }

        ttk::button $win.bu -image $::img(upup) -command [mymethod UpDir] \
                -underline 0
        addBalloon $win.bu "Up in both."
        bind $win <Alt-u> "$win.bu invoke"

        #catch {font delete myfont}
        #font create myfont -family $::Pref(fontfamily) -size $::Pref(fontsize)

        ttk::entryX $win.e1 -textvariable dirdiff(leftDir) -width 30
        ttk::button $win.bu1 -image $::img(up) -command [mymethod UpDir 1]
        addBalloon $win.bu1 "Up in left."
        ttk::button $win.bb1 -image $::img(browse) \
                -command "[list BrowseDir "dirdiff(leftDir)" $win.e1]
                          [mymethod DoDirCompare]"
        addBalloon $win.bb1 "Browse left."
        after 50 [list after idle [list $win.e1 xview end]]
        ttk::entryX $win.e2 -textvariable dirdiff(rightDir) -width 30
        ttk::button $win.bu2 -image $::img(up) -command [mymethod UpDir 2]
        addBalloon $win.bu2 "Up in right."
        ttk::button $win.bb2 -image $::img(browse) \
                -command "[list BrowseDir "dirdiff(rightDir)" $win.e2]
                          [mymethod DoDirCompare]"
        addBalloon $win.bb2 "Browse right."
        after 50 [list after idle [list $win.e2 xview end]]
        bind $win.e1 <Return> [mymethod DoDirCompare]
        bind $win.e2 <Return> [mymethod DoDirCompare]

        ttk::label $win.sl -anchor w -textvariable [myvar statusVar]

        pack $win.bb1 $win.bu1 -in $win.fe1 -side left -pady 1 -ipadx 10
        pack $win.bu1 -padx 6
        pack $win.e1 -in $win.fe1 -side left -fill x -expand 1
        pack $win.bb2 $win.bu2 -in $win.fe2 -side right -pady 1 -ipadx 10
        pack $win.bu2 -padx 6
        pack $win.e2 -in $win.fe2 -side left -fill x -expand 1

        grid $win.fe1  $win.bu $win.fe2  -sticky we
        grid $tree     -       -         -sticky news
        grid $win.sl   -       -         -sticky we
        grid $win.bu -padx 6 -ipadx 15

        grid rowconfigure    $win  1    -weight 1
        grid columnconfigure $win {0 2} -weight 1
    }

    method DoDirCompare {} {
        # Reconfiguring the dirdiff widget triggers a rerun
        $tree configure -leftdirvariable ::dirdiff(leftDir) \
                -rightdirvariable ::dirdiff(rightDir)
    }

    method DoNice {} {
        ##nagelfar vartype tree _obj,tablelist
        $tree nice $::Pref(dir,nice)
    }

    # Go up one level in directory hierarchy.
    # 0 = both
    method UpDir {{n 0}} {
        global dirdiff
        switch $n {
            0 {
                set dirdiff(leftDir) [file dirname $dirdiff(leftDir)]
                set dirdiff(rightDir) [file dirname $dirdiff(rightDir)]
                $win.e1 xview end
                $win.e2 xview end
            }

            set ::TmpPref($item) $::Pref($item)
        }
    }

    wm title $top "Eskil Directory Preferences"

    set check [ttk::labelframe $top.check -text "Check" -padding 3]
    ttk::radiobutton $check.rb1 -variable ::TmpPref(dir,comparelevel) -value 0 \
            -text "Do not check contents"
    ttk::radiobutton $check.rb2 -variable ::TmpPref(dir,comparelevel) -value 1 \
            -text "Normal compare"
    ttk::radiobutton $check.rb3 -variable ::TmpPref(dir,comparelevel) -value 2 \
            -text "Exact compare"
    grid $check.rb1 -sticky w -padx 3 -pady 3
    grid $check.rb2 -sticky w -padx 3 -pady 3
    grid $check.rb3 -sticky w -padx 3 -pady 3
    grid columnconfigure $check {0 1 2} -uniform a -weight 1

    set opts [ttk::labelframe $top.opts -text "Options" -padding 3]
    ttk::checkbutton $opts.cb1 -variable ::TmpPref(dir,ignorekey) \
            -text "Ignore \$Keyword:\$"
    pack {*}[winfo children $opts] -side "top" -anchor w

    set filter [ttk::labelframe $top.filter -text "Filter" -padding 3]
    ttk::label $filter.l1 -text "Include Files" -anchor w
    ttk::entryX $filter.e1 -width 20 -textvariable ::TmpPref(dir,incfiles)
    ttk::label $filter.l2 -text "Exclude Files" -anchor w
    ttk::entryX $filter.e2 -width 20 -textvariable ::TmpPref(dir,exfiles)
    ttk::label $filter.l3 -text "Include Dirs" -anchor w
    ttk::entryX $filter.e3 -width 20 -textvariable ::TmpPref(dir,incdirs)
    ttk::label $filter.l4 -text "Exclude Dirs" -anchor w
    ttk::entryX $filter.e4 -width 20 -textvariable ::TmpPref(dir,exdirs)
    ttk::checkbutton $filter.cb1 -text "Only revision controlled" \
            -variable ::TmpPref(dir,onlyrev)
    grid $filter.l1 $filter.e1 -sticky we -padx 3 -pady 3
    grid $filter.l2 $filter.e2 -sticky we -padx 3 -pady 3
    grid $filter.l3 $filter.e3 -sticky we -padx 3 -pady 3
    grid $filter.l4 $filter.e4 -sticky we -padx 3 -pady 3
    grid $filter.cb1 - -sticky w -padx 3 -pady 3
    grid columnconfigure $filter 1 -weight 1

    wm title $top "Eskil Dir Preprocess"

    ttk::entryX $top.e1 -textvariable ::dirdiff(pattern) -width 15
    ttk::entryX $top.e2 -textvariable ::dirdiff(replace) -width 15

    ttk::label $top.l1 -text "Pattern" -anchor w
    ttk::label $top.l2 -text "Subst"   -anchor w

    grid $top.l1 $top.e1 -sticky we
    grid $top.l2 $top.e2 -sticky we
    grid columnconfigure $top 1 -weight 1
    grid rowconfigure    $top 2 -weight 1

}

proc makeDirDiffWin {{noautodiff 0}} {
    if { ! [info exists ::dirdiff(leftDir)]} {
        set ::dirdiff(leftDir) ""
    }
    if { ! [info exists ::dirdiff(rightDir)]} {
        set ::dirdiff(rightDir) ""
    }
    # TODO, multi plugin for dirdiff?
    set ::eskil(.dirdiff,plugin,1) ""
    foreach {item val} $::eskil(defaultopts) {
        set ::eskil(.dirdiff,$item) $val
    }

    # Support -r for directory diff
    set revs {}
    array set opts $::eskil(defaultopts)
    if {[info exists opts(doptrev1)] && $opts(doptrev1) ne ""} {
        lappend revs $opts(doptrev1)
    }
    if {[info exists opts(doptrev2)] && $opts(doptrev2) ne ""} {
        lappend revs $opts(doptrev2)
    }

    # TODO: Trigger this on DirDiff, so a rerun can do it, and maybe have rev
    # GUI fields
    if {$::dirdiff(leftDir) eq $::dirdiff(rightDir) &&
        $::dirdiff(leftDir) ne "" && ![string match *.kit $::dirdiff(leftDir)]} {
        set fullname $::dirdiff(leftDir)
        set type [detectRevSystem $fullname]
        # Is this a revision system with dirdiff support?
        if {[info commands eskil::rev::${type}::mount] ne ""} {
            # No -r given; fall back on current.
            if {[llength $revs] == 0} {
                # Optimisation attempt for checkout vs latest, see if there
                # is a command to detect local changes
                if {[info commands eskil::rev::${type}::localChanges] ne ""} {
                    set ::dirdiff(localChanges) \
                            [eskil::rev::${type}::localChanges $fullname]
                }
                # Any vcs with dirdiff support should know that _ means current
                set revs _
            }
            set revs [eskil::rev::${type}::ParseRevs $fullname $revs]
            set rev1 [lindex $revs 0]
            set rev2 [lindex $revs 1]

            # A little "splash-screen" to show progress
            destroy .dirdiffX
            toplevel .dirdiffX
            wm title .dirdiffX "Eskil Dir Diff"
            label .dirdiffX.l1 -text "Collecting $type info for rev $rev1..."
            label .dirdiffX.l2 -text ""
            pack .dirdiffX.l1 .dirdiffX.l2 -side top -fill x
            update

            if {[catch {eskil::rev::${type}::mount $fullname $rev1} d1]} {
                destroy .dirdiffX
                tk_messageBox -icon error -message $d1 -type ok
                # Can ony reach this from command line, so safe to exit
                exit
            }
            set ::dirdiff(leftDir) $d1
            if {$rev2 ne ""} {
                .dirdiffX.l2 configure -text "and rev $rev2..."
                update
                set d2 [eskil::rev::${type}::mount $fullname $rev2]
                set ::dirdiff(rightDir) $d2
            }
            destroy .dirdiffX
        }
    }

    destroy .dirdiff
    # TODO: better name for experimental parameter, propagate to cmd line
    DirDiff .dirdiff -norun $noautodiff -bepa 1
    return .dirdiff
}