installjammer

[29 October 2010]

ANNOUNCE: InstallJammer Multiplatform Installer, version 1.2.15

The InstallJammer Team is pleased to announce the release of
InstallJammer 1.2.15!

This release contains minor bug fixes and enhancements.

~ What is it?

InstallJammer is a free, open source, multiplatform
GUI installer and builder designed to be completely
cross-platform and function on Windows and most all
version of UNIX with eventual support for Mac OS X.

InstallJammer Features:

* A full-featured install builder.
* Installs are packaged in single binary executables for
  each platform making web distribution easy.
* Support for multiple install themes.
* Default install themes that resemble popular, commercial
  installers.
* A high level of configurability.
* Built-in support for Windows and Linux conventions.
* Automatic creation of an uninstaller.
* Easily extended to new platforms.


~ What's New in 1.2.15

This release contains minor bug fixes and enhancements.
Please see the Release Notes in the documentation for
a full list of changes.  The complete ChangeLog is
also included with each release.

Release Notes:
http://www.installjammer.com/docs/ReleaseNotes.html


~ Availability:

Home page:
http://www.installjammer.com/

Downloads are available at:
http://www.installjammer.com/download/

Windows Download
http://downloads.installjammer.com/installjammer/1.2/InstallJammer-1.2.15-Setup.exe

Linux Download
http://downloads.installjammer.com/installjammer/1.2/InstallJammer-1.2.15-Linux-x86-Install

All Other Platform Downloads
http://downloads.installjammer.com/installjammer/1.2/installjammer-1.2.15.tar.gz


Feedback and bug reports are greatly appreciated.

-
The InstallJammer Team

/*
 * Conceptually based on Tk3 table widget by Roland King (rols@lehman.com)
 *
 * see ChangeLog file for details
 *
 * current maintainer: jeff at hobbs org
 *
 * Copyright 1997-2002, Jeffrey Hobbs (jeff@hobbs.org)
 */

		*************************************
		  The Tk Table Widget Version 2.0+
		*************************************

INTRODUCTION

TkTable is a table/matrix widget extension to tk/tcl.
The basic features of the widget are:

 * multi-line cells
 * support for embedded windows (one per cell)
 * row & column spanning
 * variable width columns / height rows (interactively resizable)
 * row and column titles
 * multiple data sources ((Tcl array || Tcl command) &| internal caching)
 * supports standard Tk reliefs, fonts, colors, etc.
 * x/y scrollbar support
 * 'tag' styles per row, column or cell to change visual appearance
 * in-cell editing - returns value back to data source
 * support for disabled (read-only) tables or cells (via tags)
 * multiple selection modes, with "active" cell
 * multiple drawing modes to get optimal performance for larger tables
 * optional 'flashes' when things update
 * cell validation support
 * Works everywhere Tk does (including Windows and Mac!)
 * Unicode support (Tk8.1+)

FINDING THE WIDGET

0. The newest version is most likely found at:
	http://tktable.sourceforge.net/
	http://www.purl.org/net/hobbs/tcl/capp/

BUILDING AND INSTALLING THE WIDGET

1. Uncompress and unpack the distribution

   ON UNIX:
	gzip -cd Tktable<version>.tar.gz | tar xf -

   ON WINDOWS:
	use something like WinZip to unpack the archive.

   ON MACINTOSH:
	use StuffIt Expander to unstuff the archive.
    
   This will create a subdirectory tkTable<version> with all the files in it.

2. Configure

   ON UNIX:
        cd Tktable<version>
	./configure

   tkTable uses information left in tkConfig.sh when you built tk.  This
   file will be found in $exec_prefix/lib/.  You might set the --prefix and
   --exec-prefix options of configure if you don't want the default
   (/usr/local).  If building on multiple unix platforms, the following is
   recommended to isolate build conflicts:
	mkdir <builddir>/<platform>
	cd !$
	/path/to/Tktable<version>/configure

   ON WINDOWS:

   Version 2.8 added support for building in the cygwin environment on
   Windows based on TEA (http://www.tcl.tk/doc/tea/).  You can retrieve
   cygwin from:
	http://sources.redhat.com/cygwin/

   Inside the cygwin environment, you build the same as on Unix.

   Otherwise, hack makefile.vc until it works and compile.  It has problems
   executing wish from a path with a space in it, but the DLL builds just
   fine.  A DLL should be available where you found this archive.

   ON MACINTOSH:
   
   Hack the CodeWarrior XML project mac_tkTable.mcp.xml until it works and
   compile.  The access path to the Tcl/Tk source tree will probably need
   adjusting.  A DLL should be available where you found this archive.

3. Make and Install

   ON UNIX or WINDOWS (with cygwin):
	make
	make test (OPTIONAL)
	make install

   ON WINDOWS (makefile.vc):
	nmake -f makefile.vc
	nmake -f makefile.vc test (OPTIONAL)
	nmake -f makefile.vc install

   ON MACINTOSH:
	Place Tktable.shlb in the Tool Command Language folder

   tkTable is built to comply to the latest tcl package conventions.
   There is also a specific "make static" for those who need it.

4. Use it

   Start a regular wish interpreter, 'load' the library, and use the table.
   Or use the "tablewish" interpreter that has the 'table' command built in.
   There are a few test scripts in the demos directory which you can source.

5. Read the documentation

   There is a Unix manpage and HTML translation provided in the doc/
   subdirectory.  These describe the table widget's features and commands
   in depth.  If something is confusing, just to try it out.


THINGS TO WATCH OUT FOR

Packing
  The table tries not to allocate huge chunks of screen real estate if
  you ask it for a lot of rows and columns.  You can always stretch out
  the frame or explicitly tell it how big it can be.  If you want to
  stretch the table, remember to pack it with fill both and expand on,
  or with grid, give it -sticky news and configure the grid row and column
  for some weighting.

Array   
  The array elements for the table are of the form array(2,3) etc.  Make
  sure there are no spaces around the ','.  Negative indices are allowed.

Editing
  If you can't edit, remember that the focus model in tk is explicit, so
  you need to click on the table or give it the focus command.  Just
  having a selected cell is not the same thing as being able to edit.
  You also need the editing cursor.  If you can't get the cursor, make
  sure that you actually have a variable assigned to the table, and that
  the "state" of the cell is not disabled.

COMMENTS, BUGS, etc.

* Please can you send comments and bug reports to the current maintainer
  and their best will be done to address them.  A mailing list for
  tktable discussion is tktable-users@lists.sourceforge.net.

* If you find a bug, a short piece of Tcl that exercises it would be very
  useful, or even better, compile with debugging and specify where it
  crashed in that short piece of Tcl.  Use the SourceForge site to check
  for known bugs or submit new ones.

		   * COPYRIGHT AND LICENSE TERMS *

(This file blatantly stolen from Tcl/Tk license and adapted - thus assume
it falls under similar license terms).

This software is copyrighted by Jeffrey Hobbs <jeff at hobbs org>.  The
following terms apply to all files associated with the software unless
explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute, and
license this software and its documentation for any purpose, provided that
existing copyright notices are retained in all copies and that this notice
is included verbatim in any distributions.  No written agreement, license,
or royalty fee is required for any of the authorized uses.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF,
EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE IS
PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO
OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

RESTRICTED RIGHTS: Use, duplication or disclosure by the U.S. government
is subject to the restrictions as set forth in subparagraph (c) (1) (ii)
of the Rights in Technical Data and Computer Software Clause as DFARS
252.227-7013 and FAR 52.227-19.

SPECIAL NOTES:

This software also falls under the bourbon_ware clause:

    Should you find this software useful in your daily work, you should
    feel obliged to take the author out for a drink if the opportunity
    presents itself.  The user may feel exempt from this clause if they
    are under 21 or think the author has already partaken of too many
    drinks.

if {[catch {package require Tcl 8.2}]} return
package ifneeded Tktable 2.9  [list load [file join $dir libTktable2.9.so] Tktable]

# table.tcl --
#
# Version align with tkTable 2.7, jeff at hobbs org
# This file defines the default bindings for Tk table widgets
# and provides procedures that help in implementing those bindings.
#
# RCS: @(#) $Id: tkTable.tcl,v 1.14 2005/07/12 23:26:28 hobbs Exp $

#--------------------------------------------------------------------------
# ::tk::table::Priv elements used in this file:
#
# x && y -		Coords in widget
# afterId -		Token returned by "after" for autoscanning.
# tablePrev -		The last element to be selected or deselected
#			during a selection operation.
# mouseMoved -		Boolean to indicate whether mouse moved while
#			the button was pressed.
# borderInfo -		Boolean to know if the user clicked on a border
# borderB1 -		Boolean that set whether B1 can be used for the
#			interactiving resizing
#--------------------------------------------------------------------------

namespace eval ::tk::table {
    # Ensure that a namespace is created for us
    variable Priv
    array set Priv [list x 0 y 0 afterId {} mouseMoved 0 \
	    borderInfo {} borderB1 1]
}

# ::tk::table::ClipboardKeysyms --
# This procedure is invoked to identify the keys that correspond to
# the "copy", "cut", and "paste" functions for the clipboard.
#
# Arguments:
# copy -	Name of the key (keysym name plus modifiers, if any,
#		such as "Meta-y") used for the copy operation.
# cut -		Name of the key used for the cut operation.
# paste -	Name of the key used for the paste operation.

proc ::tk::table::ClipboardKeysyms {copy cut paste} {
    bind Table <$copy>	{tk_tableCopy %W}
    bind Table <$cut>	{tk_tableCut %W}
    bind Table <$paste>	{tk_tablePaste %W}
}
::tk::table::ClipboardKeysyms <Copy> <Cut> <Paste>

##
## Interactive cell resizing, affected by -resizeborders option
##
bind Table <3>		{
    ## You might want to check for cell returned if you want to
    ## restrict the resizing of certain cells
    %W border mark %x %y
}
bind Table <B3-Motion>	{ %W border dragto %x %y }

## Button events

bind Table <1> { ::tk::table::Button1 %W %x %y }
bind Table <B1-Motion> { ::tk::table::B1Motion %W %x %y }

bind Table <ButtonRelease-1> {
    if {$::tk::table::Priv(borderInfo) == "" && [winfo exists %W]} {
	::tk::table::CancelRepeat
	%W activate @%x,%y
    }
}
bind Table <Double-1> {
    # empty
}

bind Table <Shift-1>	{::tk::table::BeginExtend %W [%W index @%x,%y]}
bind Table <Control-1>	{::tk::table::BeginToggle %W [%W index @%x,%y]}
bind Table <B1-Enter>	{::tk::table::CancelRepeat}
bind Table <B1-Leave>	{
    if {$::tk::table::Priv(borderInfo) == ""} {
	array set ::tk::table::Priv {x %x y %y}
	::tk::table::AutoScan %W
    }
}
bind Table <2> {
    %W scan mark %x %y
    array set ::tk::table::Priv {x %x y %y}
    set ::tk::table::Priv(mouseMoved) 0
}
bind Table <B2-Motion> {
    if {(%x != $::tk::table::Priv(x)) || (%y != $::tk::table::Priv(y))} {
	set ::tk::table::Priv(mouseMoved) 1
    }
    if {$::tk::table::Priv(mouseMoved)} { %W scan dragto %x %y }
}
bind Table <ButtonRelease-2> {
    if {!$::tk::table::Priv(mouseMoved)} { tk_tablePaste %W [%W index @%x,%y] }
}

## Key events

# This forces a cell commit if an active cell exists
bind Table <<Table_Commit>> {
    catch {%W activate active}
}
# Remove this if you don't want cell commit to occur on every Leave for
# the table (via mouse) or FocusOut (loss of focus by table).
event add <<Table_Commit>> <Leave> <FocusOut>

bind Table <Shift-Up>		{::tk::table::ExtendSelect %W -1  0}
bind Table <Shift-Down>		{::tk::table::ExtendSelect %W  1  0}
bind Table <Shift-Left>		{::tk::table::ExtendSelect %W  0 -1}
bind Table <Shift-Right>	{::tk::table::ExtendSelect %W  0  1}
bind Table <Prior>		{%W yview scroll -1 pages; %W activate topleft}
bind Table <Next>		{%W yview scroll  1 pages; %W activate topleft}
bind Table <Control-Prior>	{%W xview scroll -1 pages}
bind Table <Control-Next>	{%W xview scroll  1 pages}
bind Table <Home>		{%W see origin}
bind Table <End>		{%W see end}
bind Table <Control-Home> {
    %W selection clear all
    %W activate origin
    %W selection set active
    %W see active
}
bind Table <Control-End> {
    %W selection clear all
    %W activate end
    %W selection set active
    %W see active
}
bind Table <Shift-Control-Home>	{::tk::table::DataExtend %W origin}
bind Table <Shift-Control-End>	{::tk::table::DataExtend %W end}
bind Table <Select>		{::tk::table::BeginSelect %W [%W index active]}
bind Table <Shift-Select>	{::tk::table::BeginExtend %W [%W index active]}
bind Table <Control-slash>	{::tk::table::SelectAll %W}
bind Table <Control-backslash> {
    if {[string match browse [%W cget -selectmode]]} {%W selection clear all}
}
bind Table <Up>			{::tk::table::MoveCell %W -1  0}
bind Table <Down>		{::tk::table::MoveCell %W  1  0}
bind Table <Left>		{::tk::table::MoveCell %W  0 -1}
bind Table <Right>		{::tk::table::MoveCell %W  0  1}
bind Table <KeyPress>		{::tk::table::Insert %W %A}
bind Table <BackSpace>		{::tk::table::BackSpace %W}
bind Table <Delete>		{%W delete active insert}
bind Table <Escape>		{%W reread}

#bind Table <Return>		{::tk::table::MoveCell %W 1 0}
bind Table <Return>		{::tk::table::Insert %W "\n"}

bind Table <Control-Left>	{%W icursor [expr {[%W icursor]-1}]}
bind Table <Control-Right>	{%W icursor [expr {[%W icursor]+1}]}
bind Table <Control-e>		{%W icursor end}
bind Table <Control-a>		{%W icursor 0}
bind Table <Control-k>		{%W delete active insert end}
bind Table <Control-equal>	{::tk::table::ChangeWidth %W active  1}
bind Table <Control-minus>	{::tk::table::ChangeWidth %W active -1}

# Ignore all Alt, Meta, and Control keypresses unless explicitly bound.
# Otherwise, if a widget binding for one of these is defined, the
# <KeyPress> class binding will also fire and insert the character,
# which is wrong.  Ditto for Tab.

bind Table <Alt-KeyPress>	{# nothing}
bind Table <Meta-KeyPress>	{# nothing}
bind Table <Control-KeyPress>	{# nothing}
bind Table <Any-Tab>		{# nothing}
if {[string match "macintosh" $::tcl_platform(platform)]} {
    bind Table <Command-KeyPress> {# nothing}
}

# ::tk::table::GetSelection --
#   This tries to obtain the default selection.  On Unix, we first try
#   and get a UTF8_STRING, a type supported by modern Unix apps for
#   passing Unicode data safely.  We fall back on the default STRING
#   type otherwise.  On Windows, only the STRING type is necessary.
# Arguments:
#   w	The widget for which the selection will be retrieved.
#	Important for the -displayof property.
#   sel	The source of the selection (PRIMARY or CLIPBOARD)
# Results:
#   Returns the selection, or an error if none could be found
#
if {[string compare $::tcl_platform(platform) "unix"]} {
    proc ::tk::table::GetSelection {w {sel PRIMARY}} {
	if {[catch {selection get -displayof $w -selection $sel} txt]} {
	    return -code error "could not find default selection"
	} else {
	    return $txt
	}
    }
} else {
    proc ::tk::table::GetSelection {w {sel PRIMARY}} {
	if {[catch {selection get -displayof $w -selection $sel \
		-type UTF8_STRING} txt] \
		&& [catch {selection get -displayof $w -selection $sel} txt]} {
	    return -code error "could not find default selection"
	} else {
	    return $txt
	}
    }
}

# ::tk::table::CancelRepeat --
# A copy of tkCancelRepeat, just in case it's not available or changes.
# This procedure is invoked to cancel an auto-repeat action described
# by ::tk::table::Priv(afterId).  It's used by several widgets to auto-scroll
# the widget when the mouse is dragged out of the widget with a
# button pressed.
#
# Arguments:
# None.

proc ::tk::table::CancelRepeat {} {
    variable Priv
    after cancel $Priv(afterId)
    set Priv(afterId) {}
}

# ::tk::table::Insert --
#
#   Insert into the active cell
#
# Arguments:
#   w	- the table widget
#   s	- the string to insert
# Results:
#   Returns nothing
#
proc ::tk::table::Insert {w s} {
    if {[string compare $s {}]} {
	$w insert active insert $s
    }
}

# ::tk::table::BackSpace --
#
#   BackSpace in the current cell
#
# Arguments:
#   w	- the table widget
# Results:
#   Returns nothing
#
proc ::tk::table::BackSpace {w} {
    set cur [$w icursor]
    if {[string compare {} $cur] && $cur} {
	$w delete active [expr {$cur-1}]
    }
}

# ::tk::table::Button1 --
#
# This procedure is called to handle selecting with mouse button 1.
# It will distinguish whether to start selection or mark a border.
#
# Arguments:
#   w	- the table widget
#   x	- x coord
#   y	- y coord
# Results:
#   Returns nothing
#
proc ::tk::table::Button1 {w x y} {
    variable Priv
    #
    # $Priv(borderInfo) is null if the user did not click on a border
    #
    if {$Priv(borderB1) == 1} {
	set Priv(borderInfo) [$w border mark $x $y]
	# account for what resizeborders are set [Bug 876320] (ferenc)
	set rbd [$w cget -resizeborders]
	if {$rbd == "none" || ![llength $Priv(borderInfo)]
	    || ($rbd == "col" && [lindex $Priv(borderInfo) 1] == "")
	    || ($rbd == "row" && [lindex $Priv(borderInfo) 0] == "")} {
	    set Priv(borderInfo) ""
	}
    } else {
	set Priv(borderInfo) ""
    }
    if {$Priv(borderInfo) == ""} {
	#
	# Only do this when a border wasn't selected
	#
	if {[winfo exists $w]} {
	    ::tk::table::BeginSelect $w [$w index @$x,$y]
	    focus $w
	}
	array set Priv [list x $x y $y]
	set Priv(mouseMoved) 0
    }
}

# ::tk::table::B1Motion --
#
# This procedure is called to start processing mouse motion events while
# button 1 moves while pressed.  It will distinguish whether to change
# the selection or move a border.
#
# Arguments:
#   w	- the table widget
#   x	- x coord
#   y	- y coord
# Results:
#   Returns nothing
#
proc ::tk::table::B1Motion {w x y} {
    variable Priv

    # If we already had motion, or we moved more than 1 pixel,
    # then we start the Motion routine
    if {$Priv(borderInfo) != ""} {
	#
	# If the motion is on a border, drag it and skip the rest
	# of this binding.
	#
	$w border dragto $x $y
    } else {
	#
	# If we already had motion, or we moved more than 1 pixel,
	# then we start the Motion routine
	#
	if {
	    $::tk::table::Priv(mouseMoved)
	    || abs($x-$::tk::table::Priv(x)) > 1
	    || abs($y-$::tk::table::Priv(y)) > 1
	} {
	    set ::tk::table::Priv(mouseMoved) 1
	}
	if {$::tk::table::Priv(mouseMoved)} {
	    ::tk::table::Motion $w [$w index @$x,$y]
	}
    }
}

# ::tk::table::BeginSelect --
#
# This procedure is typically invoked on button-1 presses. It begins
# the process of making a selection in the table. Its exact behavior
# depends on the selection mode currently in effect for the table;
# see the Motif documentation for details.
#
# Arguments:
# w	- The table widget.
# el	- The element for the selection operation (typically the
#	one under the pointer).  Must be in row,col form.

proc ::tk::table::BeginSelect {w el} {
    variable Priv
    if {[scan $el %d,%d r c] != 2} return
    switch [$w cget -selectmode] {
	multiple {
	    if {[$w tag includes title $el]} {
		## in the title area
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			set inc topleft
			set el2 end
		    } else {
			set inc [$w index topleft row],$c
			set el2 [$w index end row],$c
		    }
		} else {
		    ## We're in a row header
		    set inc $r,[$w index topleft col]
		    set el2 $r,[$w index end col]
		}
	    } else {
		set inc $el
		set el2 $el
	    }
	    if {[$w selection includes $inc]} {
		$w selection clear $el $el2
	    } else {
		$w selection set $el $el2
	    }
	}
	extended {
	    $w selection clear all
	    if {[$w tag includes title $el]} {
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			$w selection set $el end
		    } else {
			$w selection set $el [$w index end row],$c
		    }
		} else {
		    ## We're in a row header
		    $w selection set $el $r,[$w index end col]
		}
	    } else {
		$w selection set $el
	    }
	    $w selection anchor $el
	    set Priv(tablePrev) $el
	}
	default {
	    if {![$w tag includes title $el]} {
		$w selection clear all
		$w selection set $el
		set Priv(tablePrev) $el
	    }
	    $w selection anchor $el
	}
    }
}

# ::tk::table::Motion --
#
# This procedure is called to process mouse motion events while
# button 1 is down. It may move or extend the selection, depending
# on the table's selection mode.
#
# Arguments:
# w	- The table widget.
# el	- The element under the pointer (must be in row,col form).

proc ::tk::table::Motion {w el} {
    variable Priv
    if {![info exists Priv(tablePrev)]} {
	set Priv(tablePrev) $el
	return
    }
    if {[string match $Priv(tablePrev) $el]} return
    switch [$w cget -selectmode] {
	browse {
	    $w selection clear all
	    $w selection set $el
	    set Priv(tablePrev) $el
	}
	extended {
	    # avoid tables that have no anchor index yet.
	    if {[catch {$w index anchor}]} { return }
	    scan $Priv(tablePrev) %d,%d r c
	    scan $el %d,%d elr elc
	    if {[$w tag includes title $el]} {
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			$w selection clear anchor end
		    } else {
			$w selection clear anchor [$w index end row],$c
		    }
		    $w selection set anchor [$w index end row],$elc
		} else {
		    ## We're in a row header
		    $w selection clear anchor $r,[$w index end col]
		    $w selection set anchor $elr,[$w index end col]
		}
	    } else {
		$w selection clear anchor $Priv(tablePrev)
		$w selection set anchor $el
	    }
	    set Priv(tablePrev) $el
	}
    }
}

# ::tk::table::BeginExtend --
#
# This procedure is typically invoked on shift-button-1 presses. It
# begins the process of extending a selection in the table. Its
# exact behavior depends on the selection mode currently in effect
# for the table; see the Motif documentation for details.
#
# Arguments:
# w - The table widget.
# el - The element for the selection operation (typically the
# one under the pointer). Must be in numerical form.

proc ::tk::table::BeginExtend {w el} {
    # avoid tables that have no anchor index yet.
    if {[catch {$w index anchor}]} { return }
    if {[string match extended [$w cget -selectmode]] &&
	[$w selection includes anchor]} {
	::tk::table::Motion $w $el
    }
}

# ::tk::table::BeginToggle --
#
# This procedure is typically invoked on control-button-1 presses. It
# begins the process of toggling a selection in the table. Its
# exact behavior depends on the selection mode currently in effect
# for the table; see the Motif documentation for details.
#
# Arguments:
# w - The table widget.
# el - The element for the selection operation (typically the
# one under the pointer). Must be in numerical form.

proc ::tk::table::BeginToggle {w el} {
    if {[string match extended [$w cget -selectmode]]} {
	variable Priv
	set Priv(tablePrev) $el
	$w selection anchor $el
	if {[$w tag includes title $el]} {
	    scan $el %d,%d r c
	    if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		## We're in a column header
		if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
		    ## We're in the topleft title area
		    set end end
		} else {
		    set end [$w index end row],$c
		}
	    } else {
		## We're in a row header
		set end $r,[$w index end col]
	    }
	} else {
	    ## We're in a non-title cell
	    set end $el
	}
	if {[$w selection includes  $end]} {
	    $w selection clear $el $end
	} else {
	    $w selection set   $el $end
        }
    }
}

# ::tk::table::AutoScan --
# This procedure is invoked when the mouse leaves an table window
# with button 1 down. It scrolls the window up, down, left, or
# right, depending on where the mouse left the window, and reschedules
# itself as an "after" command so that the window continues to scroll until
# the mouse moves back into the window or the mouse button is released.
#
# Arguments:
# w - The table window.

proc ::tk::table::AutoScan {w} {
    if {![winfo exists $w]} return
    variable Priv
    set x $Priv(x)
    set y $Priv(y)
    if {$y >= [winfo height $w]} {
	$w yview scroll 1 units
    } elseif {$y < 0} {
	$w yview scroll -1 units
    } elseif {$x >= [winfo width $w]} {
	$w xview scroll 1 units
    } elseif {$x < 0} {
	$w xview scroll -1 units
    } else {
	return
    }
    ::tk::table::Motion $w [$w index @$x,$y]
    set Priv(afterId) [after 50 ::tk::table::AutoScan $w]
}

# ::tk::table::MoveCell --
#
# Moves the location cursor (active element) by the specified number
# of cells and changes the selection if we're in browse or extended
# selection mode.  If the new cell is "hidden", we skip to the next
# visible cell if possible, otherwise just abort.
#
# Arguments:
# w - The table widget.
# x - +1 to move down one cell, -1 to move up one cell.
# y - +1 to move right one cell, -1 to move left one cell.

proc ::tk::table::MoveCell {w x y} {
    if {[catch {$w index active row} r]} return
    set c [$w index active col]
    set cell [$w index [incr r $x],[incr c $y]]
    while {[string compare [set true [$w hidden $cell]] {}]} {
	# The cell is in some way hidden
	if {[string compare $true [$w index active]]} {
	    # The span cell wasn't the previous cell, so go to that
	    set cell $true
	    break
	}
	if {$x > 0} {incr r} elseif {$x < 0} {incr r -1}
	if {$y > 0} {incr c} elseif {$y < 0} {incr c -1}
	if {[string compare $cell [$w index $r,$c]]} {
	    set cell [$w index $r,$c]
	} else {
	    # We couldn't find a non-hidden cell, just don't move
	    return
	}
    }
    $w activate $cell
    $w see active
    switch [$w cget -selectmode] {
	browse {
	    $w selection clear all
	    $w selection set active
	}
	extended {
	    variable Priv
	    $w selection clear all
	    $w selection set active
	    $w selection anchor active
	    set Priv(tablePrev) [$w index active]
	}
    }
}

# ::tk::table::ExtendSelect --
#
# Does nothing unless we're in extended selection mode; in this
# case it moves the location cursor (active element) by the specified
# number of cells, and extends the selection to that point.
#
# Arguments:
# w - The table widget.
# x - +1 to move down one cell, -1 to move up one cell.
# y - +1 to move right one cell, -1 to move left one cell.

proc ::tk::table::ExtendSelect {w x y} {
    if {[string compare extended [$w cget -selectmode]] ||
	[catch {$w index active row} r]} return
    set c [$w index active col]
    $w activate [incr r $x],[incr c $y]
    $w see active
    ::tk::table::Motion $w [$w index active]
}

# ::tk::table::DataExtend
#
# This procedure is called for key-presses such as Shift-KEndData.
# If the selection mode isnt multiple or extend then it does nothing.
# Otherwise it moves the active element to el and, if we're in
# extended mode, extends the selection to that point.
#
# Arguments:
# w - The table widget.
# el - An integer cell number.

proc ::tk::table::DataExtend {w el} {
    set mode [$w cget -selectmode]
    if {[string match extended $mode]} {
	$w activate $el
	$w see $el
	if {[$w selection includes anchor]} {::tk::table::Motion $w $el}
    } elseif {[string match multiple $mode]} {
	$w activate $el
	$w see $el
    }
}

# ::tk::table::SelectAll
#
# This procedure is invoked to handle the "select all" operation.
# For single and browse mode, it just selects the active element.
# Otherwise it selects everything in the widget.
#
# Arguments:
# w - The table widget.

proc ::tk::table::SelectAll {w} {
    if {[regexp {^(single|browse)$} [$w cget -selectmode]]} {
	$w selection clear all
	catch {$w selection set active}
    } elseif {[$w cget -selecttitles]} {
	$w selection set [$w cget -roworigin],[$w cget -colorigin] end
    } else {
	$w selection set origin end
    }
}

# ::tk::table::ChangeWidth --
#
# Adjust the widget of the specified cell by $a.
#
# Arguments:
# w - The table widget.
# i - cell index
# a - amount to adjust by

proc ::tk::table::ChangeWidth {w i a} {
    set tmp [$w index $i col]
    if {[set width [$w width $tmp]] >= 0} {
	$w width $tmp [incr width $a]
    } else {
	$w width $tmp [incr width [expr {-$a}]]
    }
}

# tk_tableCopy --
#
# This procedure copies the selection from a table widget into the
# clipboard.
#
# Arguments:
# w -		Name of a table widget.

proc tk_tableCopy w {
    if {[selection own -displayof $w] == "$w"} {
	clipboard clear -displayof $w
	catch {clipboard append -displayof $w [::tk::table::GetSelection $w]}
    }
}

# tk_tableCut --
#
# This procedure copies the selection from a table widget into the
# clipboard, then deletes the selection (if it exists in the given
# widget).
#
# Arguments:
# w -		Name of a table widget.

proc tk_tableCut w {
    if {[selection own -displayof $w] == "$w"} {
	clipboard clear -displayof $w
	catch {
	    clipboard append -displayof $w [::tk::table::GetSelection $w]
	    $w cursel {}
	    $w selection clear all
	}
    }
}

# tk_tablePaste --
#
# This procedure pastes the contents of the clipboard to the specified
# cell (active by default) in a table widget.
#
# Arguments:
# w -		Name of a table widget.
# cell -	Cell to start pasting in.
#
proc tk_tablePaste {w {cell {}}} {
    if {[string compare {} $cell]} {
	if {[catch {::tk::table::GetSelection $w} data]} return
    } else {
	if {[catch {::tk::table::GetSelection $w CLIPBOARD} data]} {
	    return
	}
	set cell active
    }
    tk_tablePasteHandler $w [$w index $cell] $data
    if {[$w cget -state] == "normal"} {focus $w}
}

# tk_tablePasteHandler --
#
# This procedure handles how data is pasted into the table widget.
# This handles data in the default table selection form.
#
# NOTE: this allows pasting into all cells except title cells,
#       even those with -state disabled
#
# Arguments:
# w -		Name of a table widget.
# cell -	Cell to start pasting in.
#
proc tk_tablePasteHandler {w cell data} {
    #
    # Don't allow pasting into the title cells
    #
    if {[$w tag includes title $cell]} {
        return
    }

    set rows	[expr {[$w cget -rows]-[$w cget -roworigin]}]
    set cols	[expr {[$w cget -cols]-[$w cget -colorigin]}]
    set r	[$w index $cell row]
    set c	[$w index $cell col]
    set rsep	[$w cget -rowseparator]
    set csep	[$w cget -colseparator]
    ## Assume separate rows are split by row separator if specified
    ## If you were to want multi-character row separators, you would need:
    # regsub -all $rsep $data <newline> data
    # set data [join $data <newline>]
    if {[string compare {} $rsep]} { set data [split $data $rsep] }
    set row	$r
    foreach line $data {
	if {$row > $rows} break
	set col	$c
	## Assume separate cols are split by col separator if specified
	## Unless a -separator was specified
	if {[string compare {} $csep]} { set line [split $line $csep] }
	## If you were to want multi-character col separators, you would need:
	# regsub -all $csep $line <newline> line
	# set line [join $line <newline>]
	foreach item $line {
	    if {$col > $cols} break
	    $w set $row,$col $item
	    incr col
	}
	incr row
    }
}

# tk::table::Sort --
#
# This procedure handles how data is sorted in the table widget.
# This isn't currently used by tktable, but can be called by the user.
# It's behavior may change in the future.
#
# Arguments:
# w -		Name of a table widget.
# start -	start cell of rectangle to sort
# end -		end cell of rectangle to sort
# col -		column within rectangle to sort on
# args -	passed to lsort proc (ie: -integer -decreasing)

proc ::tk::table::Sort {w start end col args} {
    set start [$w index $start]
    set end   [$w index $end]
    scan $start %d,%d sr sc
    scan $end   %d,%d er ec
    if {($col < $sc) || ($col > $ec)} {
	return -code error "$col is not within sort range $sc to $ec"
    }
    set col [expr {$col - $sc}]

    set data {}
    for {set i $sr} {$i <= $er} {incr i} {
	lappend data [$w get $i,$sc $i,$ec]
    }

    set i $sr
    foreach row [eval [list lsort -index $col] $args [list $data]] {
	$w set row $i,$sc $row
	incr i
    }
}

#
# Tcl package index file
#
package ifneeded miniarc::crap::lzma 0.1 \
    [list load [file join $dir libcraplzma0.1.so] craplzma]

This software (tkdnd) is copyrighted by:
    George Petasis,
    Software and Knowledge Engineering Laboratory,
    Institute of Informatics and Telecommunications,
    National Centre for Scientific Research "Demokritos",
    Aghia Paraskevi, Athens, Greece.
    e-mail: petasis@iit.demokritos.gr
                 and 
    Laurent Riesterer, Rennes, France.
    e-mail: (laurent.riesterer@free.fr)

The following terms apply to all files associated
with the software unless explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute,
and license this software and its documentation for any purpose, provided
that existing copyright notices are retained in all copies and that this
notice is included verbatim in any distributions. No written agreement,
license, or royalty fee is required for any of the authorized uses.
Modifications to this software may be copyrighted by their authors
and need not follow the licensing terms described here, provided that
the new terms are clearly indicated on the first page of each file where
they apply.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

                  
	    tkdnd: Tk Drag & Drop extension
		     (Version 1.0.0)

This directory holds a collection of files that add native drag & drop
capabilities to the tk toolkit. It is designed for tk versions >= 8.3.3,
but with simple modifications can be applied to any tk version greater than
8.1.

Remember that this software is in development. Please report any bugs or
feature requests directly to the author (petasis@iit.demokritos.gr) or by
posting on the comp.lang.tcl newsgroup. In the latter case, please use
"tkdnd" in the title of the posting.

This software (tkdnd) is copyrighted by:
    George Petasis, National Centre for Scientific Research "Demokritos",
    Aghia Paraskevi, Athens, Greece.
    e-mail: petasis@iit.demokritos.gr
                 and
    Laurent Riesterer, Rennes, France.
    e-mail: (laurent.riesterer@free.fr)

and is under the same license that covers tcl. Free to use for anything :-)

For any questions and suggestions contact me at

  petasis@iit.demokritos.gr

or post a question at comp.lang.tcl (preferable)

namespace eval ::dnd {
    proc _load {dir} {
	set version 1.0
	load [file join $dir libtkdnd1.0.so] tkdnd
	source [file join $dir tkdnd.tcl]
	package provide tkdnd 1.0
	rename ::dnd::_load {}
    }
}

package ifneeded tkdnd 1.0  [list ::dnd::_load $dir]

#
# tkdnd.tcl --
# 
#    This file implements some utility procedures that are used by the tkDND
#    package.
#
# This software is copyrighted by:
# George Petasis, National Centre for Scientific Research "Demokritos",
# Aghia Paraskevi, Athens, Greece.
# e-mail: petasis@iit.demokritos.gr
#
# The following terms apply to all files associated
# with the software unless explicitly disclaimed in individual files.
#
# The authors hereby grant permission to use, copy, modify, distribute,
# and license this software and its documentation for any purpose, provided
# that existing copyright notices are retained in all copies and that this
# notice is included verbatim in any distributions. No written agreement,
# license, or royalty fee is required for any of the authorized uses.
# Modifications to this software may be copyrighted by their authors
# and need not follow the licensing terms described here, provided that
# the new terms are clearly indicated on the first page of each file where
# they apply.
# 
# IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
# FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
# ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
# DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# 
# THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
# IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
# NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
# MODIFICATIONS.
#

namespace eval ::dnd {
    variable AskSelectedAction
    
    # This procedure is used just to ensure that the object given as its
    # argument can be accessed as a binary object. Many thanks to Paul Duffin
    # for the idea :-)
    proc ConvertToBinary {object} {
	binary scan $object {}
	return $object
    }

    # This procedure handles the special case where we want items into a canvas
    # widget to be drop targets. It emulates this case as follows:
    #
    #  The tkDND extension is able to deliver events only to real windows
    #  (that means tk widgets). This procedure can be the binding script of all
    #  dnd events we are interested in being received by the canvas items.
    #  When this function is called, it tries to find the item that the mouse
    #  is over (if any). Then it examines its bindings, and if it finds the
    #  dnd related event that is processing it delivers this event to the
    #  particular item. Fianlly, it tries to emulate <DragEnter>/<DragLeave>
    #  on every canvas item...
    proc CanvasDeliverEvent {
	event actions action button source_codes curr_code data descriptions
	mods type source_types win X x Y y
    } {
	# This function will find the topmost item that the mouse is over, and
	# Deliver the event specified by the "event" arg to this item...
	global CanvasDeliverEventStatus
	switch $event {
	    <DragEnter>  -
	    <<DragEnter>> {set CanvasDeliverEventStatus(item) {}}
	    default {}
	}

	# Translate mouse coordinates to canvas coordinates...
	set cx [$win canvasx $x]
	set cy [$win canvasy $y]
	set cx_1 [expr {$cx+1}]
	set cy_1 [expr {$cy+1}]
	# Find all tags that are under the mouse...
	set tags [$win find overlapping $cx $cy $cx_1 $cy_1]
	# ... and select the topmost...
	set length [llength $tags]

	# If no tags under the mouse, return...
	if {!$length} {
	    #puts -->$CanvasDeliverEventStatus(item)
	    if {[string length $CanvasDeliverEventStatus(item)]} {
		# Send <<DragLeave>>...
		set _id $CanvasDeliverEventStatus(item)
		set _binding {}
		foreach _tag [concat $_id [$win gettags $_id]] {
		    set _binding [$win bind $_tag <<DragLeave>>]
		    if {[string length $_binding]} {break}
		}
		# puts "Sending <DragLeave> (1) to $_id ($_binding)"
		set script {}
		foreach element $_binding {
		    switch $element {
			%% {lappend script %}       
			%A {lappend script $action}
			%a {lappend script $actions}
			%b {lappend script $button}
			%C {lappend script $source_codes}
			%c {lappend script $curr_code}
			%D {lappend script $data}
			%d {lappend script $descriptions}
			%m {lappend script $mods}
			%T {lappend script $type}
			%t {lappend script $source_types}
			%W {lappend script $win}
			%X {lappend script $X}
			%x {lappend script $x}
			%Y {lappend script $Y}
			%y {lappend script $y}
			%I {lappend script $_id}
			default {lappend script $element}
		    }
		}
		if {[llength $script]} {uplevel 1 $script}
	    }
	    set CanvasDeliverEventStatus(item) {}
	    update
	    if {[string equal $event <<Drag>>]} {
		return -code break
	    }
	    return $action
	}
	if {$length == 1} {
	    set id $tags
	} else {
	    set id [$win find closest $cx $cy]
	}

	# Now in "id" we have the tag of the item below the mouse...
	# Has this item a binding?
	foreach tag [concat $id [$win gettags $id]] {
	    set binding [$win bind $tag $event]
	    if {[string length $binding]} {break}
	}
	
	# Is this tag the same as the last one? If is different, we
	# have to send a leave event to the previous item and an enter
	# event to this one...
	if {$CanvasDeliverEventStatus(item) != $id} {
	    if {[string length $CanvasDeliverEventStatus(item)]} {
		# Send <<DragLeave>>...
		set _id $CanvasDeliverEventStatus(item)
		set _binding {}
		foreach _tag [concat $_id [$win gettags $_id]] {
		    set _binding [$win bind $_tag <<DragLeave>>]
		    if {[string length $_binding]} {break}
		}
		# puts "Sending <DragLeave> (2) to $_id ($_binding)"
		set script {}
		foreach element $_binding {
		    switch $element {
			%% {lappend script %}       
			%A {lappend script $action}
			%a {lappend script $actions}
			%b {lappend script $button}
			%C {lappend script $source_codes}
			%c {lappend script $curr_code}
			%D {lappend script $data}
			%d {lappend script $descriptions}
			%m {lappend script $mods}
			%T {lappend script $type}
			%t {lappend script $source_types}
			%W {lappend script $win}
			%X {lappend script $X}
			%x {lappend script $x}
			%Y {lappend script $Y}
			%y {lappend script $y}
			%I {lappend script $_id}
			default {lappend script $element}
		    }
		}
		if {[llength $script]} {uplevel 1 $script}
	    }
	    # Send <<DndEnter>>...
	    set _id $id
	    set _binding {}
	    foreach _tag [concat $_id [$win gettags $_id]] {
		set _binding [$win bind $_tag <<DragEnter>>]
		if {[string length $_binding]} {break}
	    }
	    # puts "Sending <DragEnter> to $tag ($_binding)"
	    set script {}
	    foreach element $_binding {
		switch $element {
		    %% {lappend script %}       
		    %A {lappend script $action}
		    %a {lappend script $actions}
		    %b {lappend script $button}
		    %C {lappend script $source_codes}
		    %c {lappend script $curr_code}
		    %D {lappend script $data}
		    %d {lappend script $descriptions}
		    %m {lappend script $mods}
		    %T {lappend script $type}
		    %t {lappend script $source_types}
		    %W {lappend script $win}
		    %X {lappend script $X}
		    %x {lappend script $x}
		    %Y {lappend script $Y}
		    %y {lappend script $y}
		    %I {lappend script $_id}
		    default {lappend script $element}
		}
	    }
	    if {[llength $script]} {uplevel 1 $script}
	    set CanvasDeliverEventStatus(item) $id
	}

	set script {}
	foreach element $binding {
	    switch $element {
		%% {lappend script %}       
		%A {lappend script $action}
		%a {lappend script $actions}
		%b {lappend script $button}
		%C {lappend script $source_codes}
		%c {lappend script $curr_code}
		%D {lappend script $data}
		%d {lappend script $descriptions}
		%m {lappend script $mods}
		%T {lappend script $type}
		%t {lappend script $source_types}
		%W {lappend script $win}
		%X {lappend script $X}
		%x {lappend script $x}
		%Y {lappend script $Y}
		%y {lappend script $y}
		%I {lappend script $id}
		default {lappend script $element}
	    }
	}
	if {[llength $script]} {
	    return [uplevel 1 $script]
	}
	set CanvasDeliverEventStatus(item) {}
	update
	if {[string equal $event <<Drag>>]} {
	    return -code break
	}
	return $action
    }

    # ChooseAskAction --
    #   This procedure displays a dialog with the help of which the user can
    #   select one of the supported actions...
    proc ChooseAskAction {window x y actions descriptions args} {
	variable AskSelectedAction
	set title {Please Select Action:}
	foreach action $actions descr $descriptions {
	    if {[string equal $action ask]} {
		set title $descr
		break
	    }
	}

	set menu $window.__tk_dnd[pwd]__action_ask__Drop_window_[pid]
	catch {destroy $menu}
	menu $menu -title $title -tearoff 0 -disabledforeground darkgreen
	$menu add command -font {helvetica 12 bold} \
		-label $title -command "destroy $menu" -state disabled
	$menu add separator

	set items 0
	foreach action $actions descr $descriptions {
	    if {[string equal $action ask]} continue
	    $menu add command -label $descr -command \
		    "set ::dnd::AskSelectedAction $action; destroy $menu"
	    incr items
	}
	if {!$items} {
	    # The drag source accepts the ask action, but has no defined
	    # action list? Add copy action at least...
	    $menu add command -label Copy -command \
		    "set ::dnd::AskSelectedAction copy; destroy $menu"
	}
	
	$menu add separator
	$menu add command -label {Cancel Drop} -command \
		"set ::dnd::AskSelectedAction none; destroy $menu"

	set AskSelectedAction none
	tk_popup $menu $x $y
	update
	bind $menu <Unmap> {after idle {catch {destroy %W}}}
	tkwait window $menu
	
	return $AskSelectedAction
    }
};# namespace eval ::dnd

# EOF

/*
 * Conceptually based on Tk3 table widget by Roland King (rols@lehman.com)
 *
 * see ChangeLog file for details
 *
 * current maintainer: jeff at hobbs org
 *
 * Copyright 1997-2002, Jeffrey Hobbs (jeff@hobbs.org)
 */

		*************************************
		  The Tk Table Widget Version 2.0+
		*************************************

INTRODUCTION

TkTable is a table/matrix widget extension to tk/tcl.
The basic features of the widget are:

 * multi-line cells
 * support for embedded windows (one per cell)
 * row & column spanning
 * variable width columns / height rows (interactively resizable)
 * row and column titles
 * multiple data sources ((Tcl array || Tcl command) &| internal caching)
 * supports standard Tk reliefs, fonts, colors, etc.
 * x/y scrollbar support
 * 'tag' styles per row, column or cell to change visual appearance
 * in-cell editing - returns value back to data source
 * support for disabled (read-only) tables or cells (via tags)
 * multiple selection modes, with "active" cell
 * multiple drawing modes to get optimal performance for larger tables
 * optional 'flashes' when things update
 * cell validation support
 * Works everywhere Tk does (including Windows and Mac!)
 * Unicode support (Tk8.1+)

FINDING THE WIDGET

0. The newest version is most likely found at:
	http://tktable.sourceforge.net/
	http://www.purl.org/net/hobbs/tcl/capp/

BUILDING AND INSTALLING THE WIDGET

1. Uncompress and unpack the distribution

   ON UNIX:
	gzip -cd Tktable<version>.tar.gz | tar xf -

   ON WINDOWS:
	use something like WinZip to unpack the archive.

   ON MACINTOSH:
	use StuffIt Expander to unstuff the archive.
    
   This will create a subdirectory tkTable<version> with all the files in it.

2. Configure

   ON UNIX:
        cd Tktable<version>
	./configure

   tkTable uses information left in tkConfig.sh when you built tk.  This
   file will be found in $exec_prefix/lib/.  You might set the --prefix and
   --exec-prefix options of configure if you don't want the default
   (/usr/local).  If building on multiple unix platforms, the following is
   recommended to isolate build conflicts:
	mkdir <builddir>/<platform>
	cd !$
	/path/to/Tktable<version>/configure

   ON WINDOWS:

   Version 2.8 added support for building in the cygwin environment on
   Windows based on TEA (http://www.tcl.tk/doc/tea/).  You can retrieve
   cygwin from:
	http://sources.redhat.com/cygwin/

   Inside the cygwin environment, you build the same as on Unix.

   Otherwise, hack makefile.vc until it works and compile.  It has problems
   executing wish from a path with a space in it, but the DLL builds just
   fine.  A DLL should be available where you found this archive.

   ON MACINTOSH:
   
   Hack the CodeWarrior XML project mac_tkTable.mcp.xml until it works and
   compile.  The access path to the Tcl/Tk source tree will probably need
   adjusting.  A DLL should be available where you found this archive.

3. Make and Install

   ON UNIX or WINDOWS (with cygwin):
	make
	make test (OPTIONAL)
	make install

   ON WINDOWS (makefile.vc):
	nmake -f makefile.vc
	nmake -f makefile.vc test (OPTIONAL)
	nmake -f makefile.vc install

   ON MACINTOSH:
	Place Tktable.shlb in the Tool Command Language folder

   tkTable is built to comply to the latest tcl package conventions.
   There is also a specific "make static" for those who need it.

4. Use it

   Start a regular wish interpreter, 'load' the library, and use the table.
   Or use the "tablewish" interpreter that has the 'table' command built in.
   There are a few test scripts in the demos directory which you can source.

5. Read the documentation

   There is a Unix manpage and HTML translation provided in the doc/
   subdirectory.  These describe the table widget's features and commands
   in depth.  If something is confusing, just to try it out.


THINGS TO WATCH OUT FOR

Packing
  The table tries not to allocate huge chunks of screen real estate if
  you ask it for a lot of rows and columns.  You can always stretch out
  the frame or explicitly tell it how big it can be.  If you want to
  stretch the table, remember to pack it with fill both and expand on,
  or with grid, give it -sticky news and configure the grid row and column
  for some weighting.

Array   
  The array elements for the table are of the form array(2,3) etc.  Make
  sure there are no spaces around the ','.  Negative indices are allowed.

Editing
  If you can't edit, remember that the focus model in tk is explicit, so
  you need to click on the table or give it the focus command.  Just
  having a selected cell is not the same thing as being able to edit.
  You also need the editing cursor.  If you can't get the cursor, make
  sure that you actually have a variable assigned to the table, and that
  the "state" of the cell is not disabled.

COMMENTS, BUGS, etc.

* Please can you send comments and bug reports to the current maintainer
  and their best will be done to address them.  A mailing list for
  tktable discussion is tktable-users@lists.sourceforge.net.

* If you find a bug, a short piece of Tcl that exercises it would be very
  useful, or even better, compile with debugging and specify where it
  crashed in that short piece of Tcl.  Use the SourceForge site to check
  for known bugs or submit new ones.

		   * COPYRIGHT AND LICENSE TERMS *

(This file blatantly stolen from Tcl/Tk license and adapted - thus assume
it falls under similar license terms).

This software is copyrighted by Jeffrey Hobbs <jeff at hobbs org>.  The
following terms apply to all files associated with the software unless
explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute, and
license this software and its documentation for any purpose, provided that
existing copyright notices are retained in all copies and that this notice
is included verbatim in any distributions.  No written agreement, license,
or royalty fee is required for any of the authorized uses.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF,
EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE IS
PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO
OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

RESTRICTED RIGHTS: Use, duplication or disclosure by the U.S. government
is subject to the restrictions as set forth in subparagraph (c) (1) (ii)
of the Rights in Technical Data and Computer Software Clause as DFARS
252.227-7013 and FAR 52.227-19.

SPECIAL NOTES:

This software also falls under the bourbon_ware clause:

    Should you find this software useful in your daily work, you should
    feel obliged to take the author out for a drink if the opportunity
    presents itself.  The user may feel exempt from this clause if they
    are under 21 or think the author has already partaken of too many
    drinks.

if {[catch {package require Tcl 8.2}]} return
package ifneeded Tktable 2.9 \
    [list load [file join $dir libTktable2.9.so] Tktable]

# table.tcl --
#
# Version align with tkTable 2.7, jeff at hobbs org
# This file defines the default bindings for Tk table widgets
# and provides procedures that help in implementing those bindings.
#
# RCS: @(#) $Id: tkTable.tcl,v 1.14 2005/07/12 23:26:28 hobbs Exp $

#--------------------------------------------------------------------------
# ::tk::table::Priv elements used in this file:
#
# x && y -		Coords in widget
# afterId -		Token returned by "after" for autoscanning.
# tablePrev -		The last element to be selected or deselected
#			during a selection operation.
# mouseMoved -		Boolean to indicate whether mouse moved while
#			the button was pressed.
# borderInfo -		Boolean to know if the user clicked on a border
# borderB1 -		Boolean that set whether B1 can be used for the
#			interactiving resizing
#--------------------------------------------------------------------------

namespace eval ::tk::table {
    # Ensure that a namespace is created for us
    variable Priv
    array set Priv [list x 0 y 0 afterId {} mouseMoved 0 \
	    borderInfo {} borderB1 1]
}

# ::tk::table::ClipboardKeysyms --
# This procedure is invoked to identify the keys that correspond to
# the "copy", "cut", and "paste" functions for the clipboard.
#
# Arguments:
# copy -	Name of the key (keysym name plus modifiers, if any,
#		such as "Meta-y") used for the copy operation.
# cut -		Name of the key used for the cut operation.
# paste -	Name of the key used for the paste operation.

proc ::tk::table::ClipboardKeysyms {copy cut paste} {
    bind Table <$copy>	{tk_tableCopy %W}
    bind Table <$cut>	{tk_tableCut %W}
    bind Table <$paste>	{tk_tablePaste %W}
}
::tk::table::ClipboardKeysyms <Copy> <Cut> <Paste>

##
## Interactive cell resizing, affected by -resizeborders option
##
bind Table <3>		{
    ## You might want to check for cell returned if you want to
    ## restrict the resizing of certain cells
    %W border mark %x %y
}
bind Table <B3-Motion>	{ %W border dragto %x %y }

## Button events

bind Table <1> { ::tk::table::Button1 %W %x %y }
bind Table <B1-Motion> { ::tk::table::B1Motion %W %x %y }

bind Table <ButtonRelease-1> {
    if {$::tk::table::Priv(borderInfo) == "" && [winfo exists %W]} {
	::tk::table::CancelRepeat
	%W activate @%x,%y
    }
}
bind Table <Double-1> {
    # empty
}

bind Table <Shift-1>	{::tk::table::BeginExtend %W [%W index @%x,%y]}
bind Table <Control-1>	{::tk::table::BeginToggle %W [%W index @%x,%y]}
bind Table <B1-Enter>	{::tk::table::CancelRepeat}
bind Table <B1-Leave>	{
    if {$::tk::table::Priv(borderInfo) == ""} {
	array set ::tk::table::Priv {x %x y %y}
	::tk::table::AutoScan %W
    }
}
bind Table <2> {
    %W scan mark %x %y
    array set ::tk::table::Priv {x %x y %y}
    set ::tk::table::Priv(mouseMoved) 0
}
bind Table <B2-Motion> {
    if {(%x != $::tk::table::Priv(x)) || (%y != $::tk::table::Priv(y))} {
	set ::tk::table::Priv(mouseMoved) 1
    }
    if {$::tk::table::Priv(mouseMoved)} { %W scan dragto %x %y }
}
bind Table <ButtonRelease-2> {
    if {!$::tk::table::Priv(mouseMoved)} { tk_tablePaste %W [%W index @%x,%y] }
}

## Key events

# This forces a cell commit if an active cell exists
bind Table <<Table_Commit>> {
    catch {%W activate active}
}
# Remove this if you don't want cell commit to occur on every Leave for
# the table (via mouse) or FocusOut (loss of focus by table).
event add <<Table_Commit>> <Leave> <FocusOut>

bind Table <Shift-Up>		{::tk::table::ExtendSelect %W -1  0}
bind Table <Shift-Down>		{::tk::table::ExtendSelect %W  1  0}
bind Table <Shift-Left>		{::tk::table::ExtendSelect %W  0 -1}
bind Table <Shift-Right>	{::tk::table::ExtendSelect %W  0  1}
bind Table <Prior>		{%W yview scroll -1 pages; %W activate topleft}
bind Table <Next>		{%W yview scroll  1 pages; %W activate topleft}
bind Table <Control-Prior>	{%W xview scroll -1 pages}
bind Table <Control-Next>	{%W xview scroll  1 pages}
bind Table <Home>		{%W see origin}
bind Table <End>		{%W see end}
bind Table <Control-Home> {
    %W selection clear all
    %W activate origin
    %W selection set active
    %W see active
}
bind Table <Control-End> {
    %W selection clear all
    %W activate end
    %W selection set active
    %W see active
}
bind Table <Shift-Control-Home>	{::tk::table::DataExtend %W origin}
bind Table <Shift-Control-End>	{::tk::table::DataExtend %W end}
bind Table <Select>		{::tk::table::BeginSelect %W [%W index active]}
bind Table <Shift-Select>	{::tk::table::BeginExtend %W [%W index active]}
bind Table <Control-slash>	{::tk::table::SelectAll %W}
bind Table <Control-backslash> {
    if {[string match browse [%W cget -selectmode]]} {%W selection clear all}
}
bind Table <Up>			{::tk::table::MoveCell %W -1  0}
bind Table <Down>		{::tk::table::MoveCell %W  1  0}
bind Table <Left>		{::tk::table::MoveCell %W  0 -1}
bind Table <Right>		{::tk::table::MoveCell %W  0  1}
bind Table <KeyPress>		{::tk::table::Insert %W %A}
bind Table <BackSpace>		{::tk::table::BackSpace %W}
bind Table <Delete>		{%W delete active insert}
bind Table <Escape>		{%W reread}

#bind Table <Return>		{::tk::table::MoveCell %W 1 0}
bind Table <Return>		{::tk::table::Insert %W "\n"}

bind Table <Control-Left>	{%W icursor [expr {[%W icursor]-1}]}
bind Table <Control-Right>	{%W icursor [expr {[%W icursor]+1}]}
bind Table <Control-e>		{%W icursor end}
bind Table <Control-a>		{%W icursor 0}
bind Table <Control-k>		{%W delete active insert end}
bind Table <Control-equal>	{::tk::table::ChangeWidth %W active  1}
bind Table <Control-minus>	{::tk::table::ChangeWidth %W active -1}

# Ignore all Alt, Meta, and Control keypresses unless explicitly bound.
# Otherwise, if a widget binding for one of these is defined, the
# <KeyPress> class binding will also fire and insert the character,
# which is wrong.  Ditto for Tab.

bind Table <Alt-KeyPress>	{# nothing}
bind Table <Meta-KeyPress>	{# nothing}
bind Table <Control-KeyPress>	{# nothing}
bind Table <Any-Tab>		{# nothing}
if {[string match "macintosh" $::tcl_platform(platform)]} {
    bind Table <Command-KeyPress> {# nothing}
}

# ::tk::table::GetSelection --
#   This tries to obtain the default selection.  On Unix, we first try
#   and get a UTF8_STRING, a type supported by modern Unix apps for
#   passing Unicode data safely.  We fall back on the default STRING
#   type otherwise.  On Windows, only the STRING type is necessary.
# Arguments:
#   w	The widget for which the selection will be retrieved.
#	Important for the -displayof property.
#   sel	The source of the selection (PRIMARY or CLIPBOARD)
# Results:
#   Returns the selection, or an error if none could be found
#
if {[string compare $::tcl_platform(platform) "unix"]} {
    proc ::tk::table::GetSelection {w {sel PRIMARY}} {
	if {[catch {selection get -displayof $w -selection $sel} txt]} {
	    return -code error "could not find default selection"
	} else {
	    return $txt
	}
    }
} else {
    proc ::tk::table::GetSelection {w {sel PRIMARY}} {
	if {[catch {selection get -displayof $w -selection $sel \
		-type UTF8_STRING} txt] \
		&& [catch {selection get -displayof $w -selection $sel} txt]} {
	    return -code error "could not find default selection"
	} else {
	    return $txt
	}
    }
}

# ::tk::table::CancelRepeat --
# A copy of tkCancelRepeat, just in case it's not available or changes.
# This procedure is invoked to cancel an auto-repeat action described
# by ::tk::table::Priv(afterId).  It's used by several widgets to auto-scroll
# the widget when the mouse is dragged out of the widget with a
# button pressed.
#
# Arguments:
# None.

proc ::tk::table::CancelRepeat {} {
    variable Priv
    after cancel $Priv(afterId)
    set Priv(afterId) {}
}

# ::tk::table::Insert --
#
#   Insert into the active cell
#
# Arguments:
#   w	- the table widget
#   s	- the string to insert
# Results:
#   Returns nothing
#
proc ::tk::table::Insert {w s} {
    if {[string compare $s {}]} {
	$w insert active insert $s
    }
}

# ::tk::table::BackSpace --
#
#   BackSpace in the current cell
#
# Arguments:
#   w	- the table widget
# Results:
#   Returns nothing
#
proc ::tk::table::BackSpace {w} {
    set cur [$w icursor]
    if {[string compare {} $cur] && $cur} {
	$w delete active [expr {$cur-1}]
    }
}

# ::tk::table::Button1 --
#
# This procedure is called to handle selecting with mouse button 1.
# It will distinguish whether to start selection or mark a border.
#
# Arguments:
#   w	- the table widget
#   x	- x coord
#   y	- y coord
# Results:
#   Returns nothing
#
proc ::tk::table::Button1 {w x y} {
    variable Priv
    #
    # $Priv(borderInfo) is null if the user did not click on a border
    #
    if {$Priv(borderB1) == 1} {
	set Priv(borderInfo) [$w border mark $x $y]
	# account for what resizeborders are set [Bug 876320] (ferenc)
	set rbd [$w cget -resizeborders]
	if {$rbd == "none" || ![llength $Priv(borderInfo)]
	    || ($rbd == "col" && [lindex $Priv(borderInfo) 1] == "")
	    || ($rbd == "row" && [lindex $Priv(borderInfo) 0] == "")} {
	    set Priv(borderInfo) ""
	}
    } else {
	set Priv(borderInfo) ""
    }
    if {$Priv(borderInfo) == ""} {
	#
	# Only do this when a border wasn't selected
	#
	if {[winfo exists $w]} {
	    ::tk::table::BeginSelect $w [$w index @$x,$y]
	    focus $w
	}
	array set Priv [list x $x y $y]
	set Priv(mouseMoved) 0
    }
}

# ::tk::table::B1Motion --
#
# This procedure is called to start processing mouse motion events while
# button 1 moves while pressed.  It will distinguish whether to change
# the selection or move a border.
#
# Arguments:
#   w	- the table widget
#   x	- x coord
#   y	- y coord
# Results:
#   Returns nothing
#
proc ::tk::table::B1Motion {w x y} {
    variable Priv

    # If we already had motion, or we moved more than 1 pixel,
    # then we start the Motion routine
    if {$Priv(borderInfo) != ""} {
	#
	# If the motion is on a border, drag it and skip the rest
	# of this binding.
	#
	$w border dragto $x $y
    } else {
	#
	# If we already had motion, or we moved more than 1 pixel,
	# then we start the Motion routine
	#
	if {
	    $::tk::table::Priv(mouseMoved)
	    || abs($x-$::tk::table::Priv(x)) > 1
	    || abs($y-$::tk::table::Priv(y)) > 1
	} {
	    set ::tk::table::Priv(mouseMoved) 1
	}
	if {$::tk::table::Priv(mouseMoved)} {
	    ::tk::table::Motion $w [$w index @$x,$y]
	}
    }
}

# ::tk::table::BeginSelect --
#
# This procedure is typically invoked on button-1 presses. It begins
# the process of making a selection in the table. Its exact behavior
# depends on the selection mode currently in effect for the table;
# see the Motif documentation for details.
#
# Arguments:
# w	- The table widget.
# el	- The element for the selection operation (typically the
#	one under the pointer).  Must be in row,col form.

proc ::tk::table::BeginSelect {w el} {
    variable Priv
    if {[scan $el %d,%d r c] != 2} return
    switch [$w cget -selectmode] {
	multiple {
	    if {[$w tag includes title $el]} {
		## in the title area
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			set inc topleft
			set el2 end
		    } else {
			set inc [$w index topleft row],$c
			set el2 [$w index end row],$c
		    }
		} else {
		    ## We're in a row header
		    set inc $r,[$w index topleft col]
		    set el2 $r,[$w index end col]
		}
	    } else {
		set inc $el
		set el2 $el
	    }
	    if {[$w selection includes $inc]} {
		$w selection clear $el $el2
	    } else {
		$w selection set $el $el2
	    }
	}
	extended {
	    $w selection clear all
	    if {[$w tag includes title $el]} {
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			$w selection set $el end
		    } else {
			$w selection set $el [$w index end row],$c
		    }
		} else {
		    ## We're in a row header
		    $w selection set $el $r,[$w index end col]
		}
	    } else {
		$w selection set $el
	    }
	    $w selection anchor $el
	    set Priv(tablePrev) $el
	}
	default {
	    if {![$w tag includes title $el]} {
		$w selection clear all
		$w selection set $el
		set Priv(tablePrev) $el
	    }
	    $w selection anchor $el
	}
    }
}

# ::tk::table::Motion --
#
# This procedure is called to process mouse motion events while
# button 1 is down. It may move or extend the selection, depending
# on the table's selection mode.
#
# Arguments:
# w	- The table widget.
# el	- The element under the pointer (must be in row,col form).

proc ::tk::table::Motion {w el} {
    variable Priv
    if {![info exists Priv(tablePrev)]} {
	set Priv(tablePrev) $el
	return
    }
    if {[string match $Priv(tablePrev) $el]} return
    switch [$w cget -selectmode] {
	browse {
	    $w selection clear all
	    $w selection set $el
	    set Priv(tablePrev) $el
	}
	extended {
	    # avoid tables that have no anchor index yet.
	    if {[catch {$w index anchor}]} { return }
	    scan $Priv(tablePrev) %d,%d r c
	    scan $el %d,%d elr elc
	    if {[$w tag includes title $el]} {
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			$w selection clear anchor end
		    } else {
			$w selection clear anchor [$w index end row],$c
		    }
		    $w selection set anchor [$w index end row],$elc
		} else {
		    ## We're in a row header
		    $w selection clear anchor $r,[$w index end col]
		    $w selection set anchor $elr,[$w index end col]
		}
	    } else {
		$w selection clear anchor $Priv(tablePrev)
		$w selection set anchor $el
	    }
	    set Priv(tablePrev) $el
	}
    }
}

# ::tk::table::BeginExtend --
#
# This procedure is typically invoked on shift-button-1 presses. It
# begins the process of extending a selection in the table. Its
# exact behavior depends on the selection mode currently in effect
# for the table; see the Motif documentation for details.
#
# Arguments:
# w - The table widget.
# el - The element for the selection operation (typically the
# one under the pointer). Must be in numerical form.

proc ::tk::table::BeginExtend {w el} {
    # avoid tables that have no anchor index yet.
    if {[catch {$w index anchor}]} { return }
    if {[string match extended [$w cget -selectmode]] &&
	[$w selection includes anchor]} {
	::tk::table::Motion $w $el
    }
}

# ::tk::table::BeginToggle --
#
# This procedure is typically invoked on control-button-1 presses. It
# begins the process of toggling a selection in the table. Its
# exact behavior depends on the selection mode currently in effect
# for the table; see the Motif documentation for details.
#
# Arguments:
# w - The table widget.
# el - The element for the selection operation (typically the
# one under the pointer). Must be in numerical form.

proc ::tk::table::BeginToggle {w el} {
    if {[string match extended [$w cget -selectmode]]} {
	variable Priv
	set Priv(tablePrev) $el
	$w selection anchor $el
	if {[$w tag includes title $el]} {
	    scan $el %d,%d r c
	    if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		## We're in a column header
		if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
		    ## We're in the topleft title area
		    set end end
		} else {
		    set end [$w index end row],$c
		}
	    } else {
		## We're in a row header
		set end $r,[$w index end col]
	    }
	} else {
	    ## We're in a non-title cell
	    set end $el
	}
	if {[$w selection includes  $end]} {
	    $w selection clear $el $end
	} else {
	    $w selection set   $el $end
        }
    }
}

# ::tk::table::AutoScan --
# This procedure is invoked when the mouse leaves an table window
# with button 1 down. It scrolls the window up, down, left, or
# right, depending on where the mouse left the window, and reschedules
# itself as an "after" command so that the window continues to scroll until
# the mouse moves back into the window or the mouse button is released.
#
# Arguments:
# w - The table window.

proc ::tk::table::AutoScan {w} {
    if {![winfo exists $w]} return
    variable Priv
    set x $Priv(x)
    set y $Priv(y)
    if {$y >= [winfo height $w]} {
	$w yview scroll 1 units
    } elseif {$y < 0} {
	$w yview scroll -1 units
    } elseif {$x >= [winfo width $w]} {
	$w xview scroll 1 units
    } elseif {$x < 0} {
	$w xview scroll -1 units
    } else {
	return
    }
    ::tk::table::Motion $w [$w index @$x,$y]
    set Priv(afterId) [after 50 ::tk::table::AutoScan $w]
}

# ::tk::table::MoveCell --
#
# Moves the location cursor (active element) by the specified number
# of cells and changes the selection if we're in browse or extended
# selection mode.  If the new cell is "hidden", we skip to the next
# visible cell if possible, otherwise just abort.
#
# Arguments:
# w - The table widget.
# x - +1 to move down one cell, -1 to move up one cell.
# y - +1 to move right one cell, -1 to move left one cell.

proc ::tk::table::MoveCell {w x y} {
    if {[catch {$w index active row} r]} return
    set c [$w index active col]
    set cell [$w index [incr r $x],[incr c $y]]
    while {[string compare [set true [$w hidden $cell]] {}]} {
	# The cell is in some way hidden
	if {[string compare $true [$w index active]]} {
	    # The span cell wasn't the previous cell, so go to that
	    set cell $true
	    break
	}
	if {$x > 0} {incr r} elseif {$x < 0} {incr r -1}
	if {$y > 0} {incr c} elseif {$y < 0} {incr c -1}
	if {[string compare $cell [$w index $r,$c]]} {
	    set cell [$w index $r,$c]
	} else {
	    # We couldn't find a non-hidden cell, just don't move
	    return
	}
    }
    $w activate $cell
    $w see active
    switch [$w cget -selectmode] {
	browse {
	    $w selection clear all
	    $w selection set active
	}
	extended {
	    variable Priv
	    $w selection clear all
	    $w selection set active
	    $w selection anchor active
	    set Priv(tablePrev) [$w index active]
	}
    }
}

# ::tk::table::ExtendSelect --
#
# Does nothing unless we're in extended selection mode; in this
# case it moves the location cursor (active element) by the specified
# number of cells, and extends the selection to that point.
#
# Arguments:
# w - The table widget.
# x - +1 to move down one cell, -1 to move up one cell.
# y - +1 to move right one cell, -1 to move left one cell.

proc ::tk::table::ExtendSelect {w x y} {
    if {[string compare extended [$w cget -selectmode]] ||
	[catch {$w index active row} r]} return
    set c [$w index active col]
    $w activate [incr r $x],[incr c $y]
    $w see active
    ::tk::table::Motion $w [$w index active]
}

# ::tk::table::DataExtend
#
# This procedure is called for key-presses such as Shift-KEndData.
# If the selection mode isnt multiple or extend then it does nothing.
# Otherwise it moves the active element to el and, if we're in
# extended mode, extends the selection to that point.
#
# Arguments:
# w - The table widget.
# el - An integer cell number.

proc ::tk::table::DataExtend {w el} {
    set mode [$w cget -selectmode]
    if {[string match extended $mode]} {
	$w activate $el
	$w see $el
	if {[$w selection includes anchor]} {::tk::table::Motion $w $el}
    } elseif {[string match multiple $mode]} {
	$w activate $el
	$w see $el
    }
}

# ::tk::table::SelectAll
#
# This procedure is invoked to handle the "select all" operation.
# For single and browse mode, it just selects the active element.
# Otherwise it selects everything in the widget.
#
# Arguments:
# w - The table widget.

proc ::tk::table::SelectAll {w} {
    if {[regexp {^(single|browse)$} [$w cget -selectmode]]} {
	$w selection clear all
	catch {$w selection set active}
    } elseif {[$w cget -selecttitles]} {
	$w selection set [$w cget -roworigin],[$w cget -colorigin] end
    } else {
	$w selection set origin end
    }
}

# ::tk::table::ChangeWidth --
#
# Adjust the widget of the specified cell by $a.
#
# Arguments:
# w - The table widget.
# i - cell index
# a - amount to adjust by

proc ::tk::table::ChangeWidth {w i a} {
    set tmp [$w index $i col]
    if {[set width [$w width $tmp]] >= 0} {
	$w width $tmp [incr width $a]
    } else {
	$w width $tmp [incr width [expr {-$a}]]
    }
}

# tk_tableCopy --
#
# This procedure copies the selection from a table widget into the
# clipboard.
#
# Arguments:
# w -		Name of a table widget.

proc tk_tableCopy w {
    if {[selection own -displayof $w] == "$w"} {
	clipboard clear -displayof $w
	catch {clipboard append -displayof $w [::tk::table::GetSelection $w]}
    }
}

# tk_tableCut --
#
# This procedure copies the selection from a table widget into the
# clipboard, then deletes the selection (if it exists in the given
# widget).
#
# Arguments:
# w -		Name of a table widget.

proc tk_tableCut w {
    if {[selection own -displayof $w] == "$w"} {
	clipboard clear -displayof $w
	catch {
	    clipboard append -displayof $w [::tk::table::GetSelection $w]
	    $w cursel {}
	    $w selection clear all
	}
    }
}

# tk_tablePaste --
#
# This procedure pastes the contents of the clipboard to the specified
# cell (active by default) in a table widget.
#
# Arguments:
# w -		Name of a table widget.
# cell -	Cell to start pasting in.
#
proc tk_tablePaste {w {cell {}}} {
    if {[string compare {} $cell]} {
	if {[catch {::tk::table::GetSelection $w} data]} return
    } else {
	if {[catch {::tk::table::GetSelection $w CLIPBOARD} data]} {
	    return
	}
	set cell active
    }
    tk_tablePasteHandler $w [$w index $cell] $data
    if {[$w cget -state] == "normal"} {focus $w}
}

# tk_tablePasteHandler --
#
# This procedure handles how data is pasted into the table widget.
# This handles data in the default table selection form.
#
# NOTE: this allows pasting into all cells except title cells,
#       even those with -state disabled
#
# Arguments:
# w -		Name of a table widget.
# cell -	Cell to start pasting in.
#
proc tk_tablePasteHandler {w cell data} {
    #
    # Don't allow pasting into the title cells
    #
    if {[$w tag includes title $cell]} {
        return
    }

    set rows	[expr {[$w cget -rows]-[$w cget -roworigin]}]
    set cols	[expr {[$w cget -cols]-[$w cget -colorigin]}]
    set r	[$w index $cell row]
    set c	[$w index $cell col]
    set rsep	[$w cget -rowseparator]
    set csep	[$w cget -colseparator]
    ## Assume separate rows are split by row separator if specified
    ## If you were to want multi-character row separators, you would need:
    # regsub -all $rsep $data <newline> data
    # set data [join $data <newline>]
    if {[string compare {} $rsep]} { set data [split $data $rsep] }
    set row	$r
    foreach line $data {
	if {$row > $rows} break
	set col	$c
	## Assume separate cols are split by col separator if specified
	## Unless a -separator was specified
	if {[string compare {} $csep]} { set line [split $line $csep] }
	## If you were to want multi-character col separators, you would need:
	# regsub -all $csep $line <newline> line
	# set line [join $line <newline>]
	foreach item $line {
	    if {$col > $cols} break
	    $w set $row,$col $item
	    incr col
	}
	incr row
    }
}

# tk::table::Sort --
#
# This procedure handles how data is sorted in the table widget.
# This isn't currently used by tktable, but can be called by the user.
# It's behavior may change in the future.
#
# Arguments:
# w -		Name of a table widget.
# start -	start cell of rectangle to sort
# end -		end cell of rectangle to sort
# col -		column within rectangle to sort on
# args -	passed to lsort proc (ie: -integer -decreasing)

proc ::tk::table::Sort {w start end col args} {
    set start [$w index $start]
    set end   [$w index $end]
    scan $start %d,%d sr sc
    scan $end   %d,%d er ec
    if {($col < $sc) || ($col > $ec)} {
	return -code error "$col is not within sort range $sc to $ec"
    }
    set col [expr {$col - $sc}]

    set data {}
    for {set i $sr} {$i <= $er} {incr i} {
	lappend data [$w get $i,$sc $i,$ec]
    }

    set i $sr
    foreach row [eval [list lsort -index $col] $args [list $data]] {
	$w set row $i,$sc $row
	incr i
    }
}

#
# Tcl package index file
#
package ifneeded miniarc::crap::lzma 0.1 \
    [list load [file join $dir libcraplzma0.1.so] craplzma]

This software (tkdnd) is copyrighted by:
    George Petasis,
    Software and Knowledge Engineering Laboratory,
    Institute of Informatics and Telecommunications,
    National Centre for Scientific Research "Demokritos",
    Aghia Paraskevi, Athens, Greece.
    e-mail: petasis@iit.demokritos.gr
                 and 
    Laurent Riesterer, Rennes, France.
    e-mail: (laurent.riesterer@free.fr)

The following terms apply to all files associated
with the software unless explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute,
and license this software and its documentation for any purpose, provided
that existing copyright notices are retained in all copies and that this
notice is included verbatim in any distributions. No written agreement,
license, or royalty fee is required for any of the authorized uses.
Modifications to this software may be copyrighted by their authors
and need not follow the licensing terms described here, provided that
the new terms are clearly indicated on the first page of each file where
they apply.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

                  
	    tkdnd: Tk Drag & Drop extension
		     (Version 1.0.0)

This directory holds a collection of files that add native drag & drop
capabilities to the tk toolkit. It is designed for tk versions >= 8.3.3,
but with simple modifications can be applied to any tk version greater than
8.1.

Remember that this software is in development. Please report any bugs or
feature requests directly to the author (petasis@iit.demokritos.gr) or by
posting on the comp.lang.tcl newsgroup. In the latter case, please use
"tkdnd" in the title of the posting.

This software (tkdnd) is copyrighted by:
    George Petasis, National Centre for Scientific Research "Demokritos",
    Aghia Paraskevi, Athens, Greece.
    e-mail: petasis@iit.demokritos.gr
                 and
    Laurent Riesterer, Rennes, France.
    e-mail: (laurent.riesterer@free.fr)

and is under the same license that covers tcl. Free to use for anything :-)

For any questions and suggestions contact me at

  petasis@iit.demokritos.gr

or post a question at comp.lang.tcl (preferable)

namespace eval ::dnd {
    proc _load {dir} {
	set version 1.0
	load [file join $dir libtkdnd1.0.so] tkdnd
	source [file join $dir tkdnd.tcl]
	package provide tkdnd 1.0
	rename ::dnd::_load {}
    }
}

package ifneeded tkdnd 1.0 \
	[list ::dnd::_load $dir]

#
# tkdnd.tcl --
# 
#    This file implements some utility procedures that are used by the tkDND
#    package.
#
# This software is copyrighted by:
# George Petasis, National Centre for Scientific Research "Demokritos",
# Aghia Paraskevi, Athens, Greece.
# e-mail: petasis@iit.demokritos.gr
#
# The following terms apply to all files associated
# with the software unless explicitly disclaimed in individual files.
#
# The authors hereby grant permission to use, copy, modify, distribute,
# and license this software and its documentation for any purpose, provided
# that existing copyright notices are retained in all copies and that this
# notice is included verbatim in any distributions. No written agreement,
# license, or royalty fee is required for any of the authorized uses.
# Modifications to this software may be copyrighted by their authors
# and need not follow the licensing terms described here, provided that
# the new terms are clearly indicated on the first page of each file where
# they apply.
# 
# IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
# FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
# ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
# DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# 
# THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
# IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
# NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
# MODIFICATIONS.
#

namespace eval ::dnd {
    variable AskSelectedAction
    
    # This procedure is used just to ensure that the object given as its
    # argument can be accessed as a binary object. Many thanks to Paul Duffin
    # for the idea :-)
    proc ConvertToBinary {object} {
	binary scan $object {}
	return $object
    }

    # This procedure handles the special case where we want items into a canvas
    # widget to be drop targets. It emulates this case as follows:
    #
    #  The tkDND extension is able to deliver events only to real windows
    #  (that means tk widgets). This procedure can be the binding script of all
    #  dnd events we are interested in being received by the canvas items.
    #  When this function is called, it tries to find the item that the mouse
    #  is over (if any). Then it examines its bindings, and if it finds the
    #  dnd related event that is processing it delivers this event to the
    #  particular item. Fianlly, it tries to emulate <DragEnter>/<DragLeave>
    #  on every canvas item...
    proc CanvasDeliverEvent {
	event actions action button source_codes curr_code data descriptions
	mods type source_types win X x Y y
    } {
	# This function will find the topmost item that the mouse is over, and
	# Deliver the event specified by the "event" arg to this item...
	global CanvasDeliverEventStatus
	switch $event {
	    <DragEnter>  -
	    <<DragEnter>> {set CanvasDeliverEventStatus(item) {}}
	    default {}
	}

	# Translate mouse coordinates to canvas coordinates...
	set cx [$win canvasx $x]
	set cy [$win canvasy $y]
	set cx_1 [expr {$cx+1}]
	set cy_1 [expr {$cy+1}]
	# Find all tags that are under the mouse...
	set tags [$win find overlapping $cx $cy $cx_1 $cy_1]
	# ... and select the topmost...
	set length [llength $tags]

	# If no tags under the mouse, return...
	if {!$length} {
	    #puts -->$CanvasDeliverEventStatus(item)
	    if {[string length $CanvasDeliverEventStatus(item)]} {
		# Send <<DragLeave>>...
		set _id $CanvasDeliverEventStatus(item)
		set _binding {}
		foreach _tag [concat $_id [$win gettags $_id]] {
		    set _binding [$win bind $_tag <<DragLeave>>]
		    if {[string length $_binding]} {break}
		}
		# puts "Sending <DragLeave> (1) to $_id ($_binding)"
		set script {}
		foreach element $_binding {
		    switch $element {
			%% {lappend script %}       
			%A {lappend script $action}
			%a {lappend script $actions}
			%b {lappend script $button}
			%C {lappend script $source_codes}
			%c {lappend script $curr_code}
			%D {lappend script $data}
			%d {lappend script $descriptions}
			%m {lappend script $mods}
			%T {lappend script $type}
			%t {lappend script $source_types}
			%W {lappend script $win}
			%X {lappend script $X}
			%x {lappend script $x}
			%Y {lappend script $Y}
			%y {lappend script $y}
			%I {lappend script $_id}
			default {lappend script $element}
		    }
		}
		if {[llength $script]} {uplevel 1 $script}
	    }
	    set CanvasDeliverEventStatus(item) {}
	    update
	    if {[string equal $event <<Drag>>]} {
		return -code break
	    }
	    return $action
	}
	if {$length == 1} {
	    set id $tags
	} else {
	    set id [$win find closest $cx $cy]
	}

	# Now in "id" we have the tag of the item below the mouse...
	# Has this item a binding?
	foreach tag [concat $id [$win gettags $id]] {
	    set binding [$win bind $tag $event]
	    if {[string length $binding]} {break}
	}
	
	# Is this tag the same as the last one? If is different, we
	# have to send a leave event to the previous item and an enter
	# event to this one...
	if {$CanvasDeliverEventStatus(item) != $id} {
	    if {[string length $CanvasDeliverEventStatus(item)]} {
		# Send <<DragLeave>>...
		set _id $CanvasDeliverEventStatus(item)
		set _binding {}
		foreach _tag [concat $_id [$win gettags $_id]] {
		    set _binding [$win bind $_tag <<DragLeave>>]
		    if {[string length $_binding]} {break}
		}
		# puts "Sending <DragLeave> (2) to $_id ($_binding)"
		set script {}
		foreach element $_binding {
		    switch $element {
			%% {lappend script %}       
			%A {lappend script $action}
			%a {lappend script $actions}
			%b {lappend script $button}
			%C {lappend script $source_codes}
			%c {lappend script $curr_code}
			%D {lappend script $data}
			%d {lappend script $descriptions}
			%m {lappend script $mods}
			%T {lappend script $type}
			%t {lappend script $source_types}
			%W {lappend script $win}
			%X {lappend script $X}
			%x {lappend script $x}
			%Y {lappend script $Y}
			%y {lappend script $y}
			%I {lappend script $_id}
			default {lappend script $element}
		    }
		}
		if {[llength $script]} {uplevel 1 $script}
	    }
	    # Send <<DndEnter>>...
	    set _id $id
	    set _binding {}
	    foreach _tag [concat $_id [$win gettags $_id]] {
		set _binding [$win bind $_tag <<DragEnter>>]
		if {[string length $_binding]} {break}
	    }
	    # puts "Sending <DragEnter> to $tag ($_binding)"
	    set script {}
	    foreach element $_binding {
		switch $element {
		    %% {lappend script %}       
		    %A {lappend script $action}
		    %a {lappend script $actions}
		    %b {lappend script $button}
		    %C {lappend script $source_codes}
		    %c {lappend script $curr_code}
		    %D {lappend script $data}
		    %d {lappend script $descriptions}
		    %m {lappend script $mods}
		    %T {lappend script $type}
		    %t {lappend script $source_types}
		    %W {lappend script $win}
		    %X {lappend script $X}
		    %x {lappend script $x}
		    %Y {lappend script $Y}
		    %y {lappend script $y}
		    %I {lappend script $_id}
		    default {lappend script $element}
		}
	    }
	    if {[llength $script]} {uplevel 1 $script}
	    set CanvasDeliverEventStatus(item) $id
	}

	set script {}
	foreach element $binding {
	    switch $element {
		%% {lappend script %}       
		%A {lappend script $action}
		%a {lappend script $actions}
		%b {lappend script $button}
		%C {lappend script $source_codes}
		%c {lappend script $curr_code}
		%D {lappend script $data}
		%d {lappend script $descriptions}
		%m {lappend script $mods}
		%T {lappend script $type}
		%t {lappend script $source_types}
		%W {lappend script $win}
		%X {lappend script $X}
		%x {lappend script $x}
		%Y {lappend script $Y}
		%y {lappend script $y}
		%I {lappend script $id}
		default {lappend script $element}
	    }
	}
	if {[llength $script]} {
	    return [uplevel 1 $script]
	}
	set CanvasDeliverEventStatus(item) {}
	update
	if {[string equal $event <<Drag>>]} {
	    return -code break
	}
	return $action
    }

    # ChooseAskAction --
    #   This procedure displays a dialog with the help of which the user can
    #   select one of the supported actions...
    proc ChooseAskAction {window x y actions descriptions args} {
	variable AskSelectedAction
	set title {Please Select Action:}
	foreach action $actions descr $descriptions {
	    if {[string equal $action ask]} {
		set title $descr
		break
	    }
	}

	set menu $window.__tk_dnd[pwd]__action_ask__Drop_window_[pid]
	catch {destroy $menu}
	menu $menu -title $title -tearoff 0 -disabledforeground darkgreen
	$menu add command -font {helvetica 12 bold} \
		-label $title -command "destroy $menu" -state disabled
	$menu add separator

	set items 0
	foreach action $actions descr $descriptions {
	    if {[string equal $action ask]} continue
	    $menu add command -label $descr -command \
		    "set ::dnd::AskSelectedAction $action; destroy $menu"
	    incr items
	}
	if {!$items} {
	    # The drag source accepts the ask action, but has no defined
	    # action list? Add copy action at least...
	    $menu add command -label Copy -command \
		    "set ::dnd::AskSelectedAction copy; destroy $menu"
	}
	
	$menu add separator
	$menu add command -label {Cancel Drop} -command \
		"set ::dnd::AskSelectedAction none; destroy $menu"

	set AskSelectedAction none
	tk_popup $menu $x $y
	update
	bind $menu <Unmap> {after idle {catch {destroy %W}}}
	tkwait window $menu
	
	return $AskSelectedAction
    }
};# namespace eval ::dnd

# EOF

/*
 * Conceptually based on Tk3 table widget by Roland King (rols@lehman.com)
 *
 * see ChangeLog file for details
 *
 * current maintainer: jeff at hobbs org
 *
 * Copyright 1997-2002, Jeffrey Hobbs (jeff@hobbs.org)
 */

		*************************************
		  The Tk Table Widget Version 2.0+
		*************************************

INTRODUCTION

TkTable is a table/matrix widget extension to tk/tcl.
The basic features of the widget are:

 * multi-line cells
 * support for embedded windows (one per cell)
 * row & column spanning
 * variable width columns / height rows (interactively resizable)
 * row and column titles
 * multiple data sources ((Tcl array || Tcl command) &| internal caching)
 * supports standard Tk reliefs, fonts, colors, etc.
 * x/y scrollbar support
 * 'tag' styles per row, column or cell to change visual appearance
 * in-cell editing - returns value back to data source
 * support for disabled (read-only) tables or cells (via tags)
 * multiple selection modes, with "active" cell
 * multiple drawing modes to get optimal performance for larger tables
 * optional 'flashes' when things update
 * cell validation support
 * Works everywhere Tk does (including Windows and Mac!)
 * Unicode support (Tk8.1+)

FINDING THE WIDGET

0. The newest version is most likely found at:
	http://tktable.sourceforge.net/
	http://www.purl.org/net/hobbs/tcl/capp/

BUILDING AND INSTALLING THE WIDGET

1. Uncompress and unpack the distribution

   ON UNIX:
	gzip -cd Tktable<version>.tar.gz | tar xf -

   ON WINDOWS:
	use something like WinZip to unpack the archive.

   ON MACINTOSH:
	use StuffIt Expander to unstuff the archive.
    
   This will create a subdirectory tkTable<version> with all the files in it.

2. Configure

   ON UNIX:
        cd Tktable<version>
	./configure

   tkTable uses information left in tkConfig.sh when you built tk.  This
   file will be found in $exec_prefix/lib/.  You might set the --prefix and
   --exec-prefix options of configure if you don't want the default
   (/usr/local).  If building on multiple unix platforms, the following is
   recommended to isolate build conflicts:
	mkdir <builddir>/<platform>
	cd !$
	/path/to/Tktable<version>/configure

   ON WINDOWS:

   Version 2.8 added support for building in the cygwin environment on
   Windows based on TEA (http://www.tcl.tk/doc/tea/).  You can retrieve
   cygwin from:
	http://sources.redhat.com/cygwin/

   Inside the cygwin environment, you build the same as on Unix.

   Otherwise, hack makefile.vc until it works and compile.  It has problems
   executing wish from a path with a space in it, but the DLL builds just
   fine.  A DLL should be available where you found this archive.

   ON MACINTOSH:
   
   Hack the CodeWarrior XML project mac_tkTable.mcp.xml until it works and
   compile.  The access path to the Tcl/Tk source tree will probably need
   adjusting.  A DLL should be available where you found this archive.

3. Make and Install

   ON UNIX or WINDOWS (with cygwin):
	make
	make test (OPTIONAL)
	make install

   ON WINDOWS (makefile.vc):
	nmake -f makefile.vc
	nmake -f makefile.vc test (OPTIONAL)
	nmake -f makefile.vc install

   ON MACINTOSH:
	Place Tktable.shlb in the Tool Command Language folder

   tkTable is built to comply to the latest tcl package conventions.
   There is also a specific "make static" for those who need it.

4. Use it

   Start a regular wish interpreter, 'load' the library, and use the table.
   Or use the "tablewish" interpreter that has the 'table' command built in.
   There are a few test scripts in the demos directory which you can source.

5. Read the documentation

   There is a Unix manpage and HTML translation provided in the doc/
   subdirectory.  These describe the table widget's features and commands
   in depth.  If something is confusing, just to try it out.


THINGS TO WATCH OUT FOR

Packing
  The table tries not to allocate huge chunks of screen real estate if
  you ask it for a lot of rows and columns.  You can always stretch out
  the frame or explicitly tell it how big it can be.  If you want to
  stretch the table, remember to pack it with fill both and expand on,
  or with grid, give it -sticky news and configure the grid row and column
  for some weighting.

Array   
  The array elements for the table are of the form array(2,3) etc.  Make
  sure there are no spaces around the ','.  Negative indices are allowed.

Editing
  If you can't edit, remember that the focus model in tk is explicit, so
  you need to click on the table or give it the focus command.  Just
  having a selected cell is not the same thing as being able to edit.
  You also need the editing cursor.  If you can't get the cursor, make
  sure that you actually have a variable assigned to the table, and that
  the "state" of the cell is not disabled.

COMMENTS, BUGS, etc.

* Please can you send comments and bug reports to the current maintainer
  and their best will be done to address them.  A mailing list for
  tktable discussion is tktable-users@lists.sourceforge.net.

* If you find a bug, a short piece of Tcl that exercises it would be very
  useful, or even better, compile with debugging and specify where it
  crashed in that short piece of Tcl.  Use the SourceForge site to check
  for known bugs or submit new ones.

		   * COPYRIGHT AND LICENSE TERMS *

(This file blatantly stolen from Tcl/Tk license and adapted - thus assume
it falls under similar license terms).

This software is copyrighted by Jeffrey Hobbs <jeff at hobbs org>.  The
following terms apply to all files associated with the software unless
explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute, and
license this software and its documentation for any purpose, provided that
existing copyright notices are retained in all copies and that this notice
is included verbatim in any distributions.  No written agreement, license,
or royalty fee is required for any of the authorized uses.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF,
EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE IS
PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO
OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

RESTRICTED RIGHTS: Use, duplication or disclosure by the U.S. government
is subject to the restrictions as set forth in subparagraph (c) (1) (ii)
of the Rights in Technical Data and Computer Software Clause as DFARS
252.227-7013 and FAR 52.227-19.

SPECIAL NOTES:

This software also falls under the bourbon_ware clause:

    Should you find this software useful in your daily work, you should
    feel obliged to take the author out for a drink if the opportunity
    presents itself.  The user may feel exempt from this clause if they
    are under 21 or think the author has already partaken of too many
    drinks.

if {[catch {package require Tcl 8.2}]} return
package ifneeded Tktable 2.9  [list load [file join $dir libTktable2.9.so] Tktable]

# table.tcl --
#
# Version align with tkTable 2.7, jeff at hobbs org
# This file defines the default bindings for Tk table widgets
# and provides procedures that help in implementing those bindings.
#
# RCS: @(#) $Id: tkTable.tcl,v 1.14 2005/07/12 23:26:28 hobbs Exp $

#--------------------------------------------------------------------------
# ::tk::table::Priv elements used in this file:
#
# x && y -		Coords in widget
# afterId -		Token returned by "after" for autoscanning.
# tablePrev -		The last element to be selected or deselected
#			during a selection operation.
# mouseMoved -		Boolean to indicate whether mouse moved while
#			the button was pressed.
# borderInfo -		Boolean to know if the user clicked on a border
# borderB1 -		Boolean that set whether B1 can be used for the
#			interactiving resizing
#--------------------------------------------------------------------------

namespace eval ::tk::table {
    # Ensure that a namespace is created for us
    variable Priv
    array set Priv [list x 0 y 0 afterId {} mouseMoved 0 \
	    borderInfo {} borderB1 1]
}

# ::tk::table::ClipboardKeysyms --
# This procedure is invoked to identify the keys that correspond to
# the "copy", "cut", and "paste" functions for the clipboard.
#
# Arguments:
# copy -	Name of the key (keysym name plus modifiers, if any,
#		such as "Meta-y") used for the copy operation.
# cut -		Name of the key used for the cut operation.
# paste -	Name of the key used for the paste operation.

proc ::tk::table::ClipboardKeysyms {copy cut paste} {
    bind Table <$copy>	{tk_tableCopy %W}
    bind Table <$cut>	{tk_tableCut %W}
    bind Table <$paste>	{tk_tablePaste %W}
}
::tk::table::ClipboardKeysyms <Copy> <Cut> <Paste>

##
## Interactive cell resizing, affected by -resizeborders option
##
bind Table <3>		{
    ## You might want to check for cell returned if you want to
    ## restrict the resizing of certain cells
    %W border mark %x %y
}
bind Table <B3-Motion>	{ %W border dragto %x %y }

## Button events

bind Table <1> { ::tk::table::Button1 %W %x %y }
bind Table <B1-Motion> { ::tk::table::B1Motion %W %x %y }

bind Table <ButtonRelease-1> {
    if {$::tk::table::Priv(borderInfo) == "" && [winfo exists %W]} {
	::tk::table::CancelRepeat
	%W activate @%x,%y
    }
}
bind Table <Double-1> {
    # empty
}

bind Table <Shift-1>	{::tk::table::BeginExtend %W [%W index @%x,%y]}
bind Table <Control-1>	{::tk::table::BeginToggle %W [%W index @%x,%y]}
bind Table <B1-Enter>	{::tk::table::CancelRepeat}
bind Table <B1-Leave>	{
    if {$::tk::table::Priv(borderInfo) == ""} {
	array set ::tk::table::Priv {x %x y %y}
	::tk::table::AutoScan %W
    }
}
bind Table <2> {
    %W scan mark %x %y
    array set ::tk::table::Priv {x %x y %y}
    set ::tk::table::Priv(mouseMoved) 0
}
bind Table <B2-Motion> {
    if {(%x != $::tk::table::Priv(x)) || (%y != $::tk::table::Priv(y))} {
	set ::tk::table::Priv(mouseMoved) 1
    }
    if {$::tk::table::Priv(mouseMoved)} { %W scan dragto %x %y }
}
bind Table <ButtonRelease-2> {
    if {!$::tk::table::Priv(mouseMoved)} { tk_tablePaste %W [%W index @%x,%y] }
}

## Key events

# This forces a cell commit if an active cell exists
bind Table <<Table_Commit>> {
    catch {%W activate active}
}
# Remove this if you don't want cell commit to occur on every Leave for
# the table (via mouse) or FocusOut (loss of focus by table).
event add <<Table_Commit>> <Leave> <FocusOut>

bind Table <Shift-Up>		{::tk::table::ExtendSelect %W -1  0}
bind Table <Shift-Down>		{::tk::table::ExtendSelect %W  1  0}
bind Table <Shift-Left>		{::tk::table::ExtendSelect %W  0 -1}
bind Table <Shift-Right>	{::tk::table::ExtendSelect %W  0  1}
bind Table <Prior>		{%W yview scroll -1 pages; %W activate topleft}
bind Table <Next>		{%W yview scroll  1 pages; %W activate topleft}
bind Table <Control-Prior>	{%W xview scroll -1 pages}
bind Table <Control-Next>	{%W xview scroll  1 pages}
bind Table <Home>		{%W see origin}
bind Table <End>		{%W see end}
bind Table <Control-Home> {
    %W selection clear all
    %W activate origin
    %W selection set active
    %W see active
}
bind Table <Control-End> {
    %W selection clear all
    %W activate end
    %W selection set active
    %W see active
}
bind Table <Shift-Control-Home>	{::tk::table::DataExtend %W origin}
bind Table <Shift-Control-End>	{::tk::table::DataExtend %W end}
bind Table <Select>		{::tk::table::BeginSelect %W [%W index active]}
bind Table <Shift-Select>	{::tk::table::BeginExtend %W [%W index active]}
bind Table <Control-slash>	{::tk::table::SelectAll %W}
bind Table <Control-backslash> {
    if {[string match browse [%W cget -selectmode]]} {%W selection clear all}
}
bind Table <Up>			{::tk::table::MoveCell %W -1  0}
bind Table <Down>		{::tk::table::MoveCell %W  1  0}
bind Table <Left>		{::tk::table::MoveCell %W  0 -1}
bind Table <Right>		{::tk::table::MoveCell %W  0  1}
bind Table <KeyPress>		{::tk::table::Insert %W %A}
bind Table <BackSpace>		{::tk::table::BackSpace %W}
bind Table <Delete>		{%W delete active insert}
bind Table <Escape>		{%W reread}

#bind Table <Return>		{::tk::table::MoveCell %W 1 0}
bind Table <Return>		{::tk::table::Insert %W "\n"}

bind Table <Control-Left>	{%W icursor [expr {[%W icursor]-1}]}
bind Table <Control-Right>	{%W icursor [expr {[%W icursor]+1}]}
bind Table <Control-e>		{%W icursor end}
bind Table <Control-a>		{%W icursor 0}
bind Table <Control-k>		{%W delete active insert end}
bind Table <Control-equal>	{::tk::table::ChangeWidth %W active  1}
bind Table <Control-minus>	{::tk::table::ChangeWidth %W active -1}

# Ignore all Alt, Meta, and Control keypresses unless explicitly bound.
# Otherwise, if a widget binding for one of these is defined, the
# <KeyPress> class binding will also fire and insert the character,
# which is wrong.  Ditto for Tab.

bind Table <Alt-KeyPress>	{# nothing}
bind Table <Meta-KeyPress>	{# nothing}
bind Table <Control-KeyPress>	{# nothing}
bind Table <Any-Tab>		{# nothing}
if {[string match "macintosh" $::tcl_platform(platform)]} {
    bind Table <Command-KeyPress> {# nothing}
}

# ::tk::table::GetSelection --
#   This tries to obtain the default selection.  On Unix, we first try
#   and get a UTF8_STRING, a type supported by modern Unix apps for
#   passing Unicode data safely.  We fall back on the default STRING
#   type otherwise.  On Windows, only the STRING type is necessary.
# Arguments:
#   w	The widget for which the selection will be retrieved.
#	Important for the -displayof property.
#   sel	The source of the selection (PRIMARY or CLIPBOARD)
# Results:
#   Returns the selection, or an error if none could be found
#
if {[string compare $::tcl_platform(platform) "unix"]} {
    proc ::tk::table::GetSelection {w {sel PRIMARY}} {
	if {[catch {selection get -displayof $w -selection $sel} txt]} {
	    return -code error "could not find default selection"
	} else {
	    return $txt
	}
    }
} else {
    proc ::tk::table::GetSelection {w {sel PRIMARY}} {
	if {[catch {selection get -displayof $w -selection $sel \
		-type UTF8_STRING} txt] \
		&& [catch {selection get -displayof $w -selection $sel} txt]} {
	    return -code error "could not find default selection"
	} else {
	    return $txt
	}
    }
}

# ::tk::table::CancelRepeat --
# A copy of tkCancelRepeat, just in case it's not available or changes.
# This procedure is invoked to cancel an auto-repeat action described
# by ::tk::table::Priv(afterId).  It's used by several widgets to auto-scroll
# the widget when the mouse is dragged out of the widget with a
# button pressed.
#
# Arguments:
# None.

proc ::tk::table::CancelRepeat {} {
    variable Priv
    after cancel $Priv(afterId)
    set Priv(afterId) {}
}

# ::tk::table::Insert --
#
#   Insert into the active cell
#
# Arguments:
#   w	- the table widget
#   s	- the string to insert
# Results:
#   Returns nothing
#
proc ::tk::table::Insert {w s} {
    if {[string compare $s {}]} {
	$w insert active insert $s
    }
}

# ::tk::table::BackSpace --
#
#   BackSpace in the current cell
#
# Arguments:
#   w	- the table widget
# Results:
#   Returns nothing
#
proc ::tk::table::BackSpace {w} {
    set cur [$w icursor]
    if {[string compare {} $cur] && $cur} {
	$w delete active [expr {$cur-1}]
    }
}

# ::tk::table::Button1 --
#
# This procedure is called to handle selecting with mouse button 1.
# It will distinguish whether to start selection or mark a border.
#
# Arguments:
#   w	- the table widget
#   x	- x coord
#   y	- y coord
# Results:
#   Returns nothing
#
proc ::tk::table::Button1 {w x y} {
    variable Priv
    #
    # $Priv(borderInfo) is null if the user did not click on a border
    #
    if {$Priv(borderB1) == 1} {
	set Priv(borderInfo) [$w border mark $x $y]
	# account for what resizeborders are set [Bug 876320] (ferenc)
	set rbd [$w cget -resizeborders]
	if {$rbd == "none" || ![llength $Priv(borderInfo)]
	    || ($rbd == "col" && [lindex $Priv(borderInfo) 1] == "")
	    || ($rbd == "row" && [lindex $Priv(borderInfo) 0] == "")} {
	    set Priv(borderInfo) ""
	}
    } else {
	set Priv(borderInfo) ""
    }
    if {$Priv(borderInfo) == ""} {
	#
	# Only do this when a border wasn't selected
	#
	if {[winfo exists $w]} {
	    ::tk::table::BeginSelect $w [$w index @$x,$y]
	    focus $w
	}
	array set Priv [list x $x y $y]
	set Priv(mouseMoved) 0
    }
}

# ::tk::table::B1Motion --
#
# This procedure is called to start processing mouse motion events while
# button 1 moves while pressed.  It will distinguish whether to change
# the selection or move a border.
#
# Arguments:
#   w	- the table widget
#   x	- x coord
#   y	- y coord
# Results:
#   Returns nothing
#
proc ::tk::table::B1Motion {w x y} {
    variable Priv

    # If we already had motion, or we moved more than 1 pixel,
    # then we start the Motion routine
    if {$Priv(borderInfo) != ""} {
	#
	# If the motion is on a border, drag it and skip the rest
	# of this binding.
	#
	$w border dragto $x $y
    } else {
	#
	# If we already had motion, or we moved more than 1 pixel,
	# then we start the Motion routine
	#
	if {
	    $::tk::table::Priv(mouseMoved)
	    || abs($x-$::tk::table::Priv(x)) > 1
	    || abs($y-$::tk::table::Priv(y)) > 1
	} {
	    set ::tk::table::Priv(mouseMoved) 1
	}
	if {$::tk::table::Priv(mouseMoved)} {
	    ::tk::table::Motion $w [$w index @$x,$y]
	}
    }
}

# ::tk::table::BeginSelect --
#
# This procedure is typically invoked on button-1 presses. It begins
# the process of making a selection in the table. Its exact behavior
# depends on the selection mode currently in effect for the table;
# see the Motif documentation for details.
#
# Arguments:
# w	- The table widget.
# el	- The element for the selection operation (typically the
#	one under the pointer).  Must be in row,col form.

proc ::tk::table::BeginSelect {w el} {
    variable Priv
    if {[scan $el %d,%d r c] != 2} return
    switch [$w cget -selectmode] {
	multiple {
	    if {[$w tag includes title $el]} {
		## in the title area
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			set inc topleft
			set el2 end
		    } else {
			set inc [$w index topleft row],$c
			set el2 [$w index end row],$c
		    }
		} else {
		    ## We're in a row header
		    set inc $r,[$w index topleft col]
		    set el2 $r,[$w index end col]
		}
	    } else {
		set inc $el
		set el2 $el
	    }
	    if {[$w selection includes $inc]} {
		$w selection clear $el $el2
	    } else {
		$w selection set $el $el2
	    }
	}
	extended {
	    $w selection clear all
	    if {[$w tag includes title $el]} {
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			$w selection set $el end
		    } else {
			$w selection set $el [$w index end row],$c
		    }
		} else {
		    ## We're in a row header
		    $w selection set $el $r,[$w index end col]
		}
	    } else {
		$w selection set $el
	    }
	    $w selection anchor $el
	    set Priv(tablePrev) $el
	}
	default {
	    if {![$w tag includes title $el]} {
		$w selection clear all
		$w selection set $el
		set Priv(tablePrev) $el
	    }
	    $w selection anchor $el
	}
    }
}

# ::tk::table::Motion --
#
# This procedure is called to process mouse motion events while
# button 1 is down. It may move or extend the selection, depending
# on the table's selection mode.
#
# Arguments:
# w	- The table widget.
# el	- The element under the pointer (must be in row,col form).

proc ::tk::table::Motion {w el} {
    variable Priv
    if {![info exists Priv(tablePrev)]} {
	set Priv(tablePrev) $el
	return
    }
    if {[string match $Priv(tablePrev) $el]} return
    switch [$w cget -selectmode] {
	browse {
	    $w selection clear all
	    $w selection set $el
	    set Priv(tablePrev) $el
	}
	extended {
	    # avoid tables that have no anchor index yet.
	    if {[catch {$w index anchor}]} { return }
	    scan $Priv(tablePrev) %d,%d r c
	    scan $el %d,%d elr elc
	    if {[$w tag includes title $el]} {
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			$w selection clear anchor end
		    } else {
			$w selection clear anchor [$w index end row],$c
		    }
		    $w selection set anchor [$w index end row],$elc
		} else {
		    ## We're in a row header
		    $w selection clear anchor $r,[$w index end col]
		    $w selection set anchor $elr,[$w index end col]
		}
	    } else {
		$w selection clear anchor $Priv(tablePrev)
		$w selection set anchor $el
	    }
	    set Priv(tablePrev) $el
	}
    }
}

# ::tk::table::BeginExtend --
#
# This procedure is typically invoked on shift-button-1 presses. It
# begins the process of extending a selection in the table. Its
# exact behavior depends on the selection mode currently in effect
# for the table; see the Motif documentation for details.
#
# Arguments:
# w - The table widget.
# el - The element for the selection operation (typically the
# one under the pointer). Must be in numerical form.

proc ::tk::table::BeginExtend {w el} {
    # avoid tables that have no anchor index yet.
    if {[catch {$w index anchor}]} { return }
    if {[string match extended [$w cget -selectmode]] &&
	[$w selection includes anchor]} {
	::tk::table::Motion $w $el
    }
}

# ::tk::table::BeginToggle --
#
# This procedure is typically invoked on control-button-1 presses. It
# begins the process of toggling a selection in the table. Its
# exact behavior depends on the selection mode currently in effect
# for the table; see the Motif documentation for details.
#
# Arguments:
# w - The table widget.
# el - The element for the selection operation (typically the
# one under the pointer). Must be in numerical form.

proc ::tk::table::BeginToggle {w el} {
    if {[string match extended [$w cget -selectmode]]} {
	variable Priv
	set Priv(tablePrev) $el
	$w selection anchor $el
	if {[$w tag includes title $el]} {
	    scan $el %d,%d r c
	    if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		## We're in a column header
		if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
		    ## We're in the topleft title area
		    set end end
		} else {
		    set end [$w index end row],$c
		}
	    } else {
		## We're in a row header
		set end $r,[$w index end col]
	    }
	} else {
	    ## We're in a non-title cell
	    set end $el
	}
	if {[$w selection includes  $end]} {
	    $w selection clear $el $end
	} else {
	    $w selection set   $el $end
        }
    }
}

# ::tk::table::AutoScan --
# This procedure is invoked when the mouse leaves an table window
# with button 1 down. It scrolls the window up, down, left, or
# right, depending on where the mouse left the window, and reschedules
# itself as an "after" command so that the window continues to scroll until
# the mouse moves back into the window or the mouse button is released.
#
# Arguments:
# w - The table window.

proc ::tk::table::AutoScan {w} {
    if {![winfo exists $w]} return
    variable Priv
    set x $Priv(x)
    set y $Priv(y)
    if {$y >= [winfo height $w]} {
	$w yview scroll 1 units
    } elseif {$y < 0} {
	$w yview scroll -1 units
    } elseif {$x >= [winfo width $w]} {
	$w xview scroll 1 units
    } elseif {$x < 0} {
	$w xview scroll -1 units
    } else {
	return
    }
    ::tk::table::Motion $w [$w index @$x,$y]
    set Priv(afterId) [after 50 ::tk::table::AutoScan $w]
}

# ::tk::table::MoveCell --
#
# Moves the location cursor (active element) by the specified number
# of cells and changes the selection if we're in browse or extended
# selection mode.  If the new cell is "hidden", we skip to the next
# visible cell if possible, otherwise just abort.
#
# Arguments:
# w - The table widget.
# x - +1 to move down one cell, -1 to move up one cell.
# y - +1 to move right one cell, -1 to move left one cell.

proc ::tk::table::MoveCell {w x y} {
    if {[catch {$w index active row} r]} return
    set c [$w index active col]
    set cell [$w index [incr r $x],[incr c $y]]
    while {[string compare [set true [$w hidden $cell]] {}]} {
	# The cell is in some way hidden
	if {[string compare $true [$w index active]]} {
	    # The span cell wasn't the previous cell, so go to that
	    set cell $true
	    break
	}
	if {$x > 0} {incr r} elseif {$x < 0} {incr r -1}
	if {$y > 0} {incr c} elseif {$y < 0} {incr c -1}
	if {[string compare $cell [$w index $r,$c]]} {
	    set cell [$w index $r,$c]
	} else {
	    # We couldn't find a non-hidden cell, just don't move
	    return
	}
    }
    $w activate $cell
    $w see active
    switch [$w cget -selectmode] {
	browse {
	    $w selection clear all
	    $w selection set active
	}
	extended {
	    variable Priv
	    $w selection clear all
	    $w selection set active
	    $w selection anchor active
	    set Priv(tablePrev) [$w index active]
	}
    }
}

# ::tk::table::ExtendSelect --
#
# Does nothing unless we're in extended selection mode; in this
# case it moves the location cursor (active element) by the specified
# number of cells, and extends the selection to that point.
#
# Arguments:
# w - The table widget.
# x - +1 to move down one cell, -1 to move up one cell.
# y - +1 to move right one cell, -1 to move left one cell.

proc ::tk::table::ExtendSelect {w x y} {
    if {[string compare extended [$w cget -selectmode]] ||
	[catch {$w index active row} r]} return
    set c [$w index active col]
    $w activate [incr r $x],[incr c $y]
    $w see active
    ::tk::table::Motion $w [$w index active]
}

# ::tk::table::DataExtend
#
# This procedure is called for key-presses such as Shift-KEndData.
# If the selection mode isnt multiple or extend then it does nothing.
# Otherwise it moves the active element to el and, if we're in
# extended mode, extends the selection to that point.
#
# Arguments:
# w - The table widget.
# el - An integer cell number.

proc ::tk::table::DataExtend {w el} {
    set mode [$w cget -selectmode]
    if {[string match extended $mode]} {
	$w activate $el
	$w see $el
	if {[$w selection includes anchor]} {::tk::table::Motion $w $el}
    } elseif {[string match multiple $mode]} {
	$w activate $el
	$w see $el
    }
}

# ::tk::table::SelectAll
#
# This procedure is invoked to handle the "select all" operation.
# For single and browse mode, it just selects the active element.
# Otherwise it selects everything in the widget.
#
# Arguments:
# w - The table widget.

proc ::tk::table::SelectAll {w} {
    if {[regexp {^(single|browse)$} [$w cget -selectmode]]} {
	$w selection clear all
	catch {$w selection set active}
    } elseif {[$w cget -selecttitles]} {
	$w selection set [$w cget -roworigin],[$w cget -colorigin] end
    } else {
	$w selection set origin end
    }
}

# ::tk::table::ChangeWidth --
#
# Adjust the widget of the specified cell by $a.
#
# Arguments:
# w - The table widget.
# i - cell index
# a - amount to adjust by

proc ::tk::table::ChangeWidth {w i a} {
    set tmp [$w index $i col]
    if {[set width [$w width $tmp]] >= 0} {
	$w width $tmp [incr width $a]
    } else {
	$w width $tmp [incr width [expr {-$a}]]
    }
}

# tk_tableCopy --
#
# This procedure copies the selection from a table widget into the
# clipboard.
#
# Arguments:
# w -		Name of a table widget.

proc tk_tableCopy w {
    if {[selection own -displayof $w] == "$w"} {
	clipboard clear -displayof $w
	catch {clipboard append -displayof $w [::tk::table::GetSelection $w]}
    }
}

# tk_tableCut --
#
# This procedure copies the selection from a table widget into the
# clipboard, then deletes the selection (if it exists in the given
# widget).
#
# Arguments:
# w -		Name of a table widget.

proc tk_tableCut w {
    if {[selection own -displayof $w] == "$w"} {
	clipboard clear -displayof $w
	catch {
	    clipboard append -displayof $w [::tk::table::GetSelection $w]
	    $w cursel {}
	    $w selection clear all
	}
    }
}

# tk_tablePaste --
#
# This procedure pastes the contents of the clipboard to the specified
# cell (active by default) in a table widget.
#
# Arguments:
# w -		Name of a table widget.
# cell -	Cell to start pasting in.
#
proc tk_tablePaste {w {cell {}}} {
    if {[string compare {} $cell]} {
	if {[catch {::tk::table::GetSelection $w} data]} return
    } else {
	if {[catch {::tk::table::GetSelection $w CLIPBOARD} data]} {
	    return
	}
	set cell active
    }
    tk_tablePasteHandler $w [$w index $cell] $data
    if {[$w cget -state] == "normal"} {focus $w}
}

# tk_tablePasteHandler --
#
# This procedure handles how data is pasted into the table widget.
# This handles data in the default table selection form.
#
# NOTE: this allows pasting into all cells except title cells,
#       even those with -state disabled
#
# Arguments:
# w -		Name of a table widget.
# cell -	Cell to start pasting in.
#
proc tk_tablePasteHandler {w cell data} {
    #
    # Don't allow pasting into the title cells
    #
    if {[$w tag includes title $cell]} {
        return
    }

    set rows	[expr {[$w cget -rows]-[$w cget -roworigin]}]
    set cols	[expr {[$w cget -cols]-[$w cget -colorigin]}]
    set r	[$w index $cell row]
    set c	[$w index $cell col]
    set rsep	[$w cget -rowseparator]
    set csep	[$w cget -colseparator]
    ## Assume separate rows are split by row separator if specified
    ## If you were to want multi-character row separators, you would need:
    # regsub -all $rsep $data <newline> data
    # set data [join $data <newline>]
    if {[string compare {} $rsep]} { set data [split $data $rsep] }
    set row	$r
    foreach line $data {
	if {$row > $rows} break
	set col	$c
	## Assume separate cols are split by col separator if specified
	## Unless a -separator was specified
	if {[string compare {} $csep]} { set line [split $line $csep] }
	## If you were to want multi-character col separators, you would need:
	# regsub -all $csep $line <newline> line
	# set line [join $line <newline>]
	foreach item $line {
	    if {$col > $cols} break
	    $w set $row,$col $item
	    incr col
	}
	incr row
    }
}

# tk::table::Sort --
#
# This procedure handles how data is sorted in the table widget.
# This isn't currently used by tktable, but can be called by the user.
# It's behavior may change in the future.
#
# Arguments:
# w -		Name of a table widget.
# start -	start cell of rectangle to sort
# end -		end cell of rectangle to sort
# col -		column within rectangle to sort on
# args -	passed to lsort proc (ie: -integer -decreasing)

proc ::tk::table::Sort {w start end col args} {
    set start [$w index $start]
    set end   [$w index $end]
    scan $start %d,%d sr sc
    scan $end   %d,%d er ec
    if {($col < $sc) || ($col > $ec)} {
	return -code error "$col is not within sort range $sc to $ec"
    }
    set col [expr {$col - $sc}]

    set data {}
    for {set i $sr} {$i <= $er} {incr i} {
	lappend data [$w get $i,$sc $i,$ec]
    }

    set i $sr
    foreach row [eval [list lsort -index $col] $args [list $data]] {
	$w set row $i,$sc $row
	incr i
    }
}

#
# Tcl package index file
#
package ifneeded miniarc::crap::lzma 0.1 \
    [list load [file join $dir libcraplzma0.1.so] craplzma]

This software (tkdnd) is copyrighted by:
    George Petasis,
    Software and Knowledge Engineering Laboratory,
    Institute of Informatics and Telecommunications,
    National Centre for Scientific Research "Demokritos",
    Aghia Paraskevi, Athens, Greece.
    e-mail: petasis@iit.demokritos.gr
                 and 
    Laurent Riesterer, Rennes, France.
    e-mail: (laurent.riesterer@free.fr)

The following terms apply to all files associated
with the software unless explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute,
and license this software and its documentation for any purpose, provided
that existing copyright notices are retained in all copies and that this
notice is included verbatim in any distributions. No written agreement,
license, or royalty fee is required for any of the authorized uses.
Modifications to this software may be copyrighted by their authors
and need not follow the licensing terms described here, provided that
the new terms are clearly indicated on the first page of each file where
they apply.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

                  
	    tkdnd: Tk Drag & Drop extension
		     (Version 1.0.0)

This directory holds a collection of files that add native drag & drop
capabilities to the tk toolkit. It is designed for tk versions >= 8.3.3,
but with simple modifications can be applied to any tk version greater than
8.1.

Remember that this software is in development. Please report any bugs or
feature requests directly to the author (petasis@iit.demokritos.gr) or by
posting on the comp.lang.tcl newsgroup. In the latter case, please use
"tkdnd" in the title of the posting.

This software (tkdnd) is copyrighted by:
    George Petasis, National Centre for Scientific Research "Demokritos",
    Aghia Paraskevi, Athens, Greece.
    e-mail: petasis@iit.demokritos.gr
                 and
    Laurent Riesterer, Rennes, France.
    e-mail: (laurent.riesterer@free.fr)

and is under the same license that covers tcl. Free to use for anything :-)

For any questions and suggestions contact me at

  petasis@iit.demokritos.gr

or post a question at comp.lang.tcl (preferable)

namespace eval ::dnd {
    proc _load {dir} {
	set version 1.0
	load [file join $dir libtkdnd1.0.so] tkdnd
	source [file join $dir tkdnd.tcl]
	package provide tkdnd 1.0
	rename ::dnd::_load {}
    }
}

package ifneeded tkdnd 1.0  [list ::dnd::_load $dir]

#
# tkdnd.tcl --
# 
#    This file implements some utility procedures that are used by the tkDND
#    package.
#
# This software is copyrighted by:
# George Petasis, National Centre for Scientific Research "Demokritos",
# Aghia Paraskevi, Athens, Greece.
# e-mail: petasis@iit.demokritos.gr
#
# The following terms apply to all files associated
# with the software unless explicitly disclaimed in individual files.
#
# The authors hereby grant permission to use, copy, modify, distribute,
# and license this software and its documentation for any purpose, provided
# that existing copyright notices are retained in all copies and that this
# notice is included verbatim in any distributions. No written agreement,
# license, or royalty fee is required for any of the authorized uses.
# Modifications to this software may be copyrighted by their authors
# and need not follow the licensing terms described here, provided that
# the new terms are clearly indicated on the first page of each file where
# they apply.
# 
# IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
# FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
# ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
# DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# 
# THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
# IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
# NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
# MODIFICATIONS.
#

namespace eval ::dnd {
    variable AskSelectedAction
    
    # This procedure is used just to ensure that the object given as its
    # argument can be accessed as a binary object. Many thanks to Paul Duffin
    # for the idea :-)
    proc ConvertToBinary {object} {
	binary scan $object {}
	return $object
    }

    # This procedure handles the special case where we want items into a canvas
    # widget to be drop targets. It emulates this case as follows:
    #
    #  The tkDND extension is able to deliver events only to real windows
    #  (that means tk widgets). This procedure can be the binding script of all
    #  dnd events we are interested in being received by the canvas items.
    #  When this function is called, it tries to find the item that the mouse
    #  is over (if any). Then it examines its bindings, and if it finds the
    #  dnd related event that is processing it delivers this event to the
    #  particular item. Fianlly, it tries to emulate <DragEnter>/<DragLeave>
    #  on every canvas item...
    proc CanvasDeliverEvent {
	event actions action button source_codes curr_code data descriptions
	mods type source_types win X x Y y
    } {
	# This function will find the topmost item that the mouse is over, and
	# Deliver the event specified by the "event" arg to this item...
	global CanvasDeliverEventStatus
	switch $event {
	    <DragEnter>  -
	    <<DragEnter>> {set CanvasDeliverEventStatus(item) {}}
	    default {}
	}

	# Translate mouse coordinates to canvas coordinates...
	set cx [$win canvasx $x]
	set cy [$win canvasy $y]
	set cx_1 [expr {$cx+1}]
	set cy_1 [expr {$cy+1}]
	# Find all tags that are under the mouse...
	set tags [$win find overlapping $cx $cy $cx_1 $cy_1]
	# ... and select the topmost...
	set length [llength $tags]

	# If no tags under the mouse, return...
	if {!$length} {
	    #puts -->$CanvasDeliverEventStatus(item)
	    if {[string length $CanvasDeliverEventStatus(item)]} {
		# Send <<DragLeave>>...
		set _id $CanvasDeliverEventStatus(item)
		set _binding {}
		foreach _tag [concat $_id [$win gettags $_id]] {
		    set _binding [$win bind $_tag <<DragLeave>>]
		    if {[string length $_binding]} {break}
		}
		# puts "Sending <DragLeave> (1) to $_id ($_binding)"
		set script {}
		foreach element $_binding {
		    switch $element {
			%% {lappend script %}       
			%A {lappend script $action}
			%a {lappend script $actions}
			%b {lappend script $button}
			%C {lappend script $source_codes}
			%c {lappend script $curr_code}
			%D {lappend script $data}
			%d {lappend script $descriptions}
			%m {lappend script $mods}
			%T {lappend script $type}
			%t {lappend script $source_types}
			%W {lappend script $win}
			%X {lappend script $X}
			%x {lappend script $x}
			%Y {lappend script $Y}
			%y {lappend script $y}
			%I {lappend script $_id}
			default {lappend script $element}
		    }
		}
		if {[llength $script]} {uplevel 1 $script}
	    }
	    set CanvasDeliverEventStatus(item) {}
	    update
	    if {[string equal $event <<Drag>>]} {
		return -code break
	    }
	    return $action
	}
	if {$length == 1} {
	    set id $tags
	} else {
	    set id [$win find closest $cx $cy]
	}

	# Now in "id" we have the tag of the item below the mouse...
	# Has this item a binding?
	foreach tag [concat $id [$win gettags $id]] {
	    set binding [$win bind $tag $event]
	    if {[string length $binding]} {break}
	}
	
	# Is this tag the same as the last one? If is different, we
	# have to send a leave event to the previous item and an enter
	# event to this one...
	if {$CanvasDeliverEventStatus(item) != $id} {
	    if {[string length $CanvasDeliverEventStatus(item)]} {
		# Send <<DragLeave>>...
		set _id $CanvasDeliverEventStatus(item)
		set _binding {}
		foreach _tag [concat $_id [$win gettags $_id]] {
		    set _binding [$win bind $_tag <<DragLeave>>]
		    if {[string length $_binding]} {break}
		}
		# puts "Sending <DragLeave> (2) to $_id ($_binding)"
		set script {}
		foreach element $_binding {
		    switch $element {
			%% {lappend script %}       
			%A {lappend script $action}
			%a {lappend script $actions}
			%b {lappend script $button}
			%C {lappend script $source_codes}
			%c {lappend script $curr_code}
			%D {lappend script $data}
			%d {lappend script $descriptions}
			%m {lappend script $mods}
			%T {lappend script $type}
			%t {lappend script $source_types}
			%W {lappend script $win}
			%X {lappend script $X}
			%x {lappend script $x}
			%Y {lappend script $Y}
			%y {lappend script $y}
			%I {lappend script $_id}
			default {lappend script $element}
		    }
		}
		if {[llength $script]} {uplevel 1 $script}
	    }
	    # Send <<DndEnter>>...
	    set _id $id
	    set _binding {}
	    foreach _tag [concat $_id [$win gettags $_id]] {
		set _binding [$win bind $_tag <<DragEnter>>]
		if {[string length $_binding]} {break}
	    }
	    # puts "Sending <DragEnter> to $tag ($_binding)"
	    set script {}
	    foreach element $_binding {
		switch $element {
		    %% {lappend script %}       
		    %A {lappend script $action}
		    %a {lappend script $actions}
		    %b {lappend script $button}
		    %C {lappend script $source_codes}
		    %c {lappend script $curr_code}
		    %D {lappend script $data}
		    %d {lappend script $descriptions}
		    %m {lappend script $mods}
		    %T {lappend script $type}
		    %t {lappend script $source_types}
		    %W {lappend script $win}
		    %X {lappend script $X}
		    %x {lappend script $x}
		    %Y {lappend script $Y}
		    %y {lappend script $y}
		    %I {lappend script $_id}
		    default {lappend script $element}
		}
	    }
	    if {[llength $script]} {uplevel 1 $script}
	    set CanvasDeliverEventStatus(item) $id
	}

	set script {}
	foreach element $binding {
	    switch $element {
		%% {lappend script %}       
		%A {lappend script $action}
		%a {lappend script $actions}
		%b {lappend script $button}
		%C {lappend script $source_codes}
		%c {lappend script $curr_code}
		%D {lappend script $data}
		%d {lappend script $descriptions}
		%m {lappend script $mods}
		%T {lappend script $type}
		%t {lappend script $source_types}
		%W {lappend script $win}
		%X {lappend script $X}
		%x {lappend script $x}
		%Y {lappend script $Y}
		%y {lappend script $y}
		%I {lappend script $id}
		default {lappend script $element}
	    }
	}
	if {[llength $script]} {
	    return [uplevel 1 $script]
	}
	set CanvasDeliverEventStatus(item) {}
	update
	if {[string equal $event <<Drag>>]} {
	    return -code break
	}
	return $action
    }

    # ChooseAskAction --
    #   This procedure displays a dialog with the help of which the user can
    #   select one of the supported actions...
    proc ChooseAskAction {window x y actions descriptions args} {
	variable AskSelectedAction
	set title {Please Select Action:}
	foreach action $actions descr $descriptions {
	    if {[string equal $action ask]} {
		set title $descr
		break
	    }
	}

	set menu $window.__tk_dnd[pwd]__action_ask__Drop_window_[pid]
	catch {destroy $menu}
	menu $menu -title $title -tearoff 0 -disabledforeground darkgreen
	$menu add command -font {helvetica 12 bold} \
		-label $title -command "destroy $menu" -state disabled
	$menu add separator

	set items 0
	foreach action $actions descr $descriptions {
	    if {[string equal $action ask]} continue
	    $menu add command -label $descr -command \
		    "set ::dnd::AskSelectedAction $action; destroy $menu"
	    incr items
	}
	if {!$items} {
	    # The drag source accepts the ask action, but has no defined
	    # action list? Add copy action at least...
	    $menu add command -label Copy -command \
		    "set ::dnd::AskSelectedAction copy; destroy $menu"
	}
	
	$menu add separator
	$menu add command -label {Cancel Drop} -command \
		"set ::dnd::AskSelectedAction none; destroy $menu"

	set AskSelectedAction none
	tk_popup $menu $x $y
	update
	bind $menu <Unmap> {after idle {catch {destroy %W}}}
	tkwait window $menu
	
	return $AskSelectedAction
    }
};# namespace eval ::dnd

# EOF

/*
 * Conceptually based on Tk3 table widget by Roland King (rols@lehman.com)
 *
 * see ChangeLog file for details
 *
 * current maintainer: jeff at hobbs org
 *
 * Copyright 1997-2002, Jeffrey Hobbs (jeff@hobbs.org)
 */

		*************************************
		  The Tk Table Widget Version 2.0+
		*************************************

INTRODUCTION

TkTable is a table/matrix widget extension to tk/tcl.
The basic features of the widget are:

 * multi-line cells
 * support for embedded windows (one per cell)
 * row & column spanning
 * variable width columns / height rows (interactively resizable)
 * row and column titles
 * multiple data sources ((Tcl array || Tcl command) &| internal caching)
 * supports standard Tk reliefs, fonts, colors, etc.
 * x/y scrollbar support
 * 'tag' styles per row, column or cell to change visual appearance
 * in-cell editing - returns value back to data source
 * support for disabled (read-only) tables or cells (via tags)
 * multiple selection modes, with "active" cell
 * multiple drawing modes to get optimal performance for larger tables
 * optional 'flashes' when things update
 * cell validation support
 * Works everywhere Tk does (including Windows and Mac!)
 * Unicode support (Tk8.1+)

FINDING THE WIDGET

0. The newest version is most likely found at:
	http://tktable.sourceforge.net/
	http://www.purl.org/net/hobbs/tcl/capp/

BUILDING AND INSTALLING THE WIDGET

1. Uncompress and unpack the distribution

   ON UNIX:
	gzip -cd Tktable<version>.tar.gz | tar xf -

   ON WINDOWS:
	use something like WinZip to unpack the archive.

   ON MACINTOSH:
	use StuffIt Expander to unstuff the archive.
    
   This will create a subdirectory tkTable<version> with all the files in it.

2. Configure

   ON UNIX:
        cd Tktable<version>
	./configure

   tkTable uses information left in tkConfig.sh when you built tk.  This
   file will be found in $exec_prefix/lib/.  You might set the --prefix and
   --exec-prefix options of configure if you don't want the default
   (/usr/local).  If building on multiple unix platforms, the following is
   recommended to isolate build conflicts:
	mkdir <builddir>/<platform>
	cd !$
	/path/to/Tktable<version>/configure

   ON WINDOWS:

   Version 2.8 added support for building in the cygwin environment on
   Windows based on TEA (http://www.tcl.tk/doc/tea/).  You can retrieve
   cygwin from:
	http://sources.redhat.com/cygwin/

   Inside the cygwin environment, you build the same as on Unix.

   Otherwise, hack makefile.vc until it works and compile.  It has problems
   executing wish from a path with a space in it, but the DLL builds just
   fine.  A DLL should be available where you found this archive.

   ON MACINTOSH:
   
   Hack the CodeWarrior XML project mac_tkTable.mcp.xml until it works and
   compile.  The access path to the Tcl/Tk source tree will probably need
   adjusting.  A DLL should be available where you found this archive.

3. Make and Install

   ON UNIX or WINDOWS (with cygwin):
	make
	make test (OPTIONAL)
	make install

   ON WINDOWS (makefile.vc):
	nmake -f makefile.vc
	nmake -f makefile.vc test (OPTIONAL)
	nmake -f makefile.vc install

   ON MACINTOSH:
	Place Tktable.shlb in the Tool Command Language folder

   tkTable is built to comply to the latest tcl package conventions.
   There is also a specific "make static" for those who need it.

4. Use it

   Start a regular wish interpreter, 'load' the library, and use the table.
   Or use the "tablewish" interpreter that has the 'table' command built in.
   There are a few test scripts in the demos directory which you can source.

5. Read the documentation

   There is a Unix manpage and HTML translation provided in the doc/
   subdirectory.  These describe the table widget's features and commands
   in depth.  If something is confusing, just to try it out.


THINGS TO WATCH OUT FOR

Packing
  The table tries not to allocate huge chunks of screen real estate if
  you ask it for a lot of rows and columns.  You can always stretch out
  the frame or explicitly tell it how big it can be.  If you want to
  stretch the table, remember to pack it with fill both and expand on,
  or with grid, give it -sticky news and configure the grid row and column
  for some weighting.

Array   
  The array elements for the table are of the form array(2,3) etc.  Make
  sure there are no spaces around the ','.  Negative indices are allowed.

Editing
  If you can't edit, remember that the focus model in tk is explicit, so
  you need to click on the table or give it the focus command.  Just
  having a selected cell is not the same thing as being able to edit.
  You also need the editing cursor.  If you can't get the cursor, make
  sure that you actually have a variable assigned to the table, and that
  the "state" of the cell is not disabled.

COMMENTS, BUGS, etc.

* Please can you send comments and bug reports to the current maintainer
  and their best will be done to address them.  A mailing list for
  tktable discussion is tktable-users@lists.sourceforge.net.

* If you find a bug, a short piece of Tcl that exercises it would be very
  useful, or even better, compile with debugging and specify where it
  crashed in that short piece of Tcl.  Use the SourceForge site to check
  for known bugs or submit new ones.

		   * COPYRIGHT AND LICENSE TERMS *

(This file blatantly stolen from Tcl/Tk license and adapted - thus assume
it falls under similar license terms).

This software is copyrighted by Jeffrey Hobbs <jeff at hobbs org>.  The
following terms apply to all files associated with the software unless
explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute, and
license this software and its documentation for any purpose, provided that
existing copyright notices are retained in all copies and that this notice
is included verbatim in any distributions.  No written agreement, license,
or royalty fee is required for any of the authorized uses.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF,
EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE IS
PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO
OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

RESTRICTED RIGHTS: Use, duplication or disclosure by the U.S. government
is subject to the restrictions as set forth in subparagraph (c) (1) (ii)
of the Rights in Technical Data and Computer Software Clause as DFARS
252.227-7013 and FAR 52.227-19.

SPECIAL NOTES:

This software also falls under the bourbon_ware clause:

    Should you find this software useful in your daily work, you should
    feel obliged to take the author out for a drink if the opportunity
    presents itself.  The user may feel exempt from this clause if they
    are under 21 or think the author has already partaken of too many
    drinks.

if {[catch {package require Tcl 8.2}]} return
package ifneeded Tktable 2.9  [list load [file join $dir libTktable2.9.so] Tktable]

# table.tcl --
#
# Version align with tkTable 2.7, jeff at hobbs org
# This file defines the default bindings for Tk table widgets
# and provides procedures that help in implementing those bindings.
#
# RCS: @(#) $Id: tkTable.tcl,v 1.14 2005/07/12 23:26:28 hobbs Exp $

#--------------------------------------------------------------------------
# ::tk::table::Priv elements used in this file:
#
# x && y -		Coords in widget
# afterId -		Token returned by "after" for autoscanning.
# tablePrev -		The last element to be selected or deselected
#			during a selection operation.
# mouseMoved -		Boolean to indicate whether mouse moved while
#			the button was pressed.
# borderInfo -		Boolean to know if the user clicked on a border
# borderB1 -		Boolean that set whether B1 can be used for the
#			interactiving resizing
#--------------------------------------------------------------------------

namespace eval ::tk::table {
    # Ensure that a namespace is created for us
    variable Priv
    array set Priv [list x 0 y 0 afterId {} mouseMoved 0 \
	    borderInfo {} borderB1 1]
}

# ::tk::table::ClipboardKeysyms --
# This procedure is invoked to identify the keys that correspond to
# the "copy", "cut", and "paste" functions for the clipboard.
#
# Arguments:
# copy -	Name of the key (keysym name plus modifiers, if any,
#		such as "Meta-y") used for the copy operation.
# cut -		Name of the key used for the cut operation.
# paste -	Name of the key used for the paste operation.

proc ::tk::table::ClipboardKeysyms {copy cut paste} {
    bind Table <$copy>	{tk_tableCopy %W}
    bind Table <$cut>	{tk_tableCut %W}
    bind Table <$paste>	{tk_tablePaste %W}
}
::tk::table::ClipboardKeysyms <Copy> <Cut> <Paste>

##
## Interactive cell resizing, affected by -resizeborders option
##
bind Table <3>		{
    ## You might want to check for cell returned if you want to
    ## restrict the resizing of certain cells
    %W border mark %x %y
}
bind Table <B3-Motion>	{ %W border dragto %x %y }

## Button events

bind Table <1> { ::tk::table::Button1 %W %x %y }
bind Table <B1-Motion> { ::tk::table::B1Motion %W %x %y }

bind Table <ButtonRelease-1> {
    if {$::tk::table::Priv(borderInfo) == "" && [winfo exists %W]} {
	::tk::table::CancelRepeat
	%W activate @%x,%y
    }
}
bind Table <Double-1> {
    # empty
}

bind Table <Shift-1>	{::tk::table::BeginExtend %W [%W index @%x,%y]}
bind Table <Control-1>	{::tk::table::BeginToggle %W [%W index @%x,%y]}
bind Table <B1-Enter>	{::tk::table::CancelRepeat}
bind Table <B1-Leave>	{
    if {$::tk::table::Priv(borderInfo) == ""} {
	array set ::tk::table::Priv {x %x y %y}
	::tk::table::AutoScan %W
    }
}
bind Table <2> {
    %W scan mark %x %y
    array set ::tk::table::Priv {x %x y %y}
    set ::tk::table::Priv(mouseMoved) 0
}
bind Table <B2-Motion> {
    if {(%x != $::tk::table::Priv(x)) || (%y != $::tk::table::Priv(y))} {
	set ::tk::table::Priv(mouseMoved) 1
    }
    if {$::tk::table::Priv(mouseMoved)} { %W scan dragto %x %y }
}
bind Table <ButtonRelease-2> {
    if {!$::tk::table::Priv(mouseMoved)} { tk_tablePaste %W [%W index @%x,%y] }
}

## Key events

# This forces a cell commit if an active cell exists
bind Table <<Table_Commit>> {
    catch {%W activate active}
}
# Remove this if you don't want cell commit to occur on every Leave for
# the table (via mouse) or FocusOut (loss of focus by table).
event add <<Table_Commit>> <Leave> <FocusOut>

bind Table <Shift-Up>		{::tk::table::ExtendSelect %W -1  0}
bind Table <Shift-Down>		{::tk::table::ExtendSelect %W  1  0}
bind Table <Shift-Left>		{::tk::table::ExtendSelect %W  0 -1}
bind Table <Shift-Right>	{::tk::table::ExtendSelect %W  0  1}
bind Table <Prior>		{%W yview scroll -1 pages; %W activate topleft}
bind Table <Next>		{%W yview scroll  1 pages; %W activate topleft}
bind Table <Control-Prior>	{%W xview scroll -1 pages}
bind Table <Control-Next>	{%W xview scroll  1 pages}
bind Table <Home>		{%W see origin}
bind Table <End>		{%W see end}
bind Table <Control-Home> {
    %W selection clear all
    %W activate origin
    %W selection set active
    %W see active
}
bind Table <Control-End> {
    %W selection clear all
    %W activate end
    %W selection set active
    %W see active
}
bind Table <Shift-Control-Home>	{::tk::table::DataExtend %W origin}
bind Table <Shift-Control-End>	{::tk::table::DataExtend %W end}
bind Table <Select>		{::tk::table::BeginSelect %W [%W index active]}
bind Table <Shift-Select>	{::tk::table::BeginExtend %W [%W index active]}
bind Table <Control-slash>	{::tk::table::SelectAll %W}
bind Table <Control-backslash> {
    if {[string match browse [%W cget -selectmode]]} {%W selection clear all}
}
bind Table <Up>			{::tk::table::MoveCell %W -1  0}
bind Table <Down>		{::tk::table::MoveCell %W  1  0}
bind Table <Left>		{::tk::table::MoveCell %W  0 -1}
bind Table <Right>		{::tk::table::MoveCell %W  0  1}
bind Table <KeyPress>		{::tk::table::Insert %W %A}
bind Table <BackSpace>		{::tk::table::BackSpace %W}
bind Table <Delete>		{%W delete active insert}
bind Table <Escape>		{%W reread}

#bind Table <Return>		{::tk::table::MoveCell %W 1 0}
bind Table <Return>		{::tk::table::Insert %W "\n"}

bind Table <Control-Left>	{%W icursor [expr {[%W icursor]-1}]}
bind Table <Control-Right>	{%W icursor [expr {[%W icursor]+1}]}
bind Table <Control-e>		{%W icursor end}
bind Table <Control-a>		{%W icursor 0}
bind Table <Control-k>		{%W delete active insert end}
bind Table <Control-equal>	{::tk::table::ChangeWidth %W active  1}
bind Table <Control-minus>	{::tk::table::ChangeWidth %W active -1}

# Ignore all Alt, Meta, and Control keypresses unless explicitly bound.
# Otherwise, if a widget binding for one of these is defined, the
# <KeyPress> class binding will also fire and insert the character,
# which is wrong.  Ditto for Tab.

bind Table <Alt-KeyPress>	{# nothing}
bind Table <Meta-KeyPress>	{# nothing}
bind Table <Control-KeyPress>	{# nothing}
bind Table <Any-Tab>		{# nothing}
if {[string match "macintosh" $::tcl_platform(platform)]} {
    bind Table <Command-KeyPress> {# nothing}
}

# ::tk::table::GetSelection --
#   This tries to obtain the default selection.  On Unix, we first try
#   and get a UTF8_STRING, a type supported by modern Unix apps for
#   passing Unicode data safely.  We fall back on the default STRING
#   type otherwise.  On Windows, only the STRING type is necessary.
# Arguments:
#   w	The widget for which the selection will be retrieved.
#	Important for the -displayof property.
#   sel	The source of the selection (PRIMARY or CLIPBOARD)
# Results:
#   Returns the selection, or an error if none could be found
#
if {[string compare $::tcl_platform(platform) "unix"]} {
    proc ::tk::table::GetSelection {w {sel PRIMARY}} {
	if {[catch {selection get -displayof $w -selection $sel} txt]} {
	    return -code error "could not find default selection"
	} else {
	    return $txt
	}
    }
} else {
    proc ::tk::table::GetSelection {w {sel PRIMARY}} {
	if {[catch {selection get -displayof $w -selection $sel \
		-type UTF8_STRING} txt] \
		&& [catch {selection get -displayof $w -selection $sel} txt]} {
	    return -code error "could not find default selection"
	} else {
	    return $txt
	}
    }
}

# ::tk::table::CancelRepeat --
# A copy of tkCancelRepeat, just in case it's not available or changes.
# This procedure is invoked to cancel an auto-repeat action described
# by ::tk::table::Priv(afterId).  It's used by several widgets to auto-scroll
# the widget when the mouse is dragged out of the widget with a
# button pressed.
#
# Arguments:
# None.

proc ::tk::table::CancelRepeat {} {
    variable Priv
    after cancel $Priv(afterId)
    set Priv(afterId) {}
}

# ::tk::table::Insert --
#
#   Insert into the active cell
#
# Arguments:
#   w	- the table widget
#   s	- the string to insert
# Results:
#   Returns nothing
#
proc ::tk::table::Insert {w s} {
    if {[string compare $s {}]} {
	$w insert active insert $s
    }
}

# ::tk::table::BackSpace --
#
#   BackSpace in the current cell
#
# Arguments:
#   w	- the table widget
# Results:
#   Returns nothing
#
proc ::tk::table::BackSpace {w} {
    set cur [$w icursor]
    if {[string compare {} $cur] && $cur} {
	$w delete active [expr {$cur-1}]
    }
}

# ::tk::table::Button1 --
#
# This procedure is called to handle selecting with mouse button 1.
# It will distinguish whether to start selection or mark a border.
#
# Arguments:
#   w	- the table widget
#   x	- x coord
#   y	- y coord
# Results:
#   Returns nothing
#
proc ::tk::table::Button1 {w x y} {
    variable Priv
    #
    # $Priv(borderInfo) is null if the user did not click on a border
    #
    if {$Priv(borderB1) == 1} {
	set Priv(borderInfo) [$w border mark $x $y]
	# account for what resizeborders are set [Bug 876320] (ferenc)
	set rbd [$w cget -resizeborders]
	if {$rbd == "none" || ![llength $Priv(borderInfo)]
	    || ($rbd == "col" && [lindex $Priv(borderInfo) 1] == "")
	    || ($rbd == "row" && [lindex $Priv(borderInfo) 0] == "")} {
	    set Priv(borderInfo) ""
	}
    } else {
	set Priv(borderInfo) ""
    }
    if {$Priv(borderInfo) == ""} {
	#
	# Only do this when a border wasn't selected
	#
	if {[winfo exists $w]} {
	    ::tk::table::BeginSelect $w [$w index @$x,$y]
	    focus $w
	}
	array set Priv [list x $x y $y]
	set Priv(mouseMoved) 0
    }
}

# ::tk::table::B1Motion --
#
# This procedure is called to start processing mouse motion events while
# button 1 moves while pressed.  It will distinguish whether to change
# the selection or move a border.
#
# Arguments:
#   w	- the table widget
#   x	- x coord
#   y	- y coord
# Results:
#   Returns nothing
#
proc ::tk::table::B1Motion {w x y} {
    variable Priv

    # If we already had motion, or we moved more than 1 pixel,
    # then we start the Motion routine
    if {$Priv(borderInfo) != ""} {
	#
	# If the motion is on a border, drag it and skip the rest
	# of this binding.
	#
	$w border dragto $x $y
    } else {
	#
	# If we already had motion, or we moved more than 1 pixel,
	# then we start the Motion routine
	#
	if {
	    $::tk::table::Priv(mouseMoved)
	    || abs($x-$::tk::table::Priv(x)) > 1
	    || abs($y-$::tk::table::Priv(y)) > 1
	} {
	    set ::tk::table::Priv(mouseMoved) 1
	}
	if {$::tk::table::Priv(mouseMoved)} {
	    ::tk::table::Motion $w [$w index @$x,$y]
	}
    }
}

# ::tk::table::BeginSelect --
#
# This procedure is typically invoked on button-1 presses. It begins
# the process of making a selection in the table. Its exact behavior
# depends on the selection mode currently in effect for the table;
# see the Motif documentation for details.
#
# Arguments:
# w	- The table widget.
# el	- The element for the selection operation (typically the
#	one under the pointer).  Must be in row,col form.

proc ::tk::table::BeginSelect {w el} {
    variable Priv
    if {[scan $el %d,%d r c] != 2} return
    switch [$w cget -selectmode] {
	multiple {
	    if {[$w tag includes title $el]} {
		## in the title area
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			set inc topleft
			set el2 end
		    } else {
			set inc [$w index topleft row],$c
			set el2 [$w index end row],$c
		    }
		} else {
		    ## We're in a row header
		    set inc $r,[$w index topleft col]
		    set el2 $r,[$w index end col]
		}
	    } else {
		set inc $el
		set el2 $el
	    }
	    if {[$w selection includes $inc]} {
		$w selection clear $el $el2
	    } else {
		$w selection set $el $el2
	    }
	}
	extended {
	    $w selection clear all
	    if {[$w tag includes title $el]} {
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			$w selection set $el end
		    } else {
			$w selection set $el [$w index end row],$c
		    }
		} else {
		    ## We're in a row header
		    $w selection set $el $r,[$w index end col]
		}
	    } else {
		$w selection set $el
	    }
	    $w selection anchor $el
	    set Priv(tablePrev) $el
	}
	default {
	    if {![$w tag includes title $el]} {
		$w selection clear all
		$w selection set $el
		set Priv(tablePrev) $el
	    }
	    $w selection anchor $el
	}
    }
}

# ::tk::table::Motion --
#
# This procedure is called to process mouse motion events while
# button 1 is down. It may move or extend the selection, depending
# on the table's selection mode.
#
# Arguments:
# w	- The table widget.
# el	- The element under the pointer (must be in row,col form).

proc ::tk::table::Motion {w el} {
    variable Priv
    if {![info exists Priv(tablePrev)]} {
	set Priv(tablePrev) $el
	return
    }
    if {[string match $Priv(tablePrev) $el]} return
    switch [$w cget -selectmode] {
	browse {
	    $w selection clear all
	    $w selection set $el
	    set Priv(tablePrev) $el
	}
	extended {
	    # avoid tables that have no anchor index yet.
	    if {[catch {$w index anchor}]} { return }
	    scan $Priv(tablePrev) %d,%d r c
	    scan $el %d,%d elr elc
	    if {[$w tag includes title $el]} {
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			$w selection clear anchor end
		    } else {
			$w selection clear anchor [$w index end row],$c
		    }
		    $w selection set anchor [$w index end row],$elc
		} else {
		    ## We're in a row header
		    $w selection clear anchor $r,[$w index end col]
		    $w selection set anchor $elr,[$w index end col]
		}
	    } else {
		$w selection clear anchor $Priv(tablePrev)
		$w selection set anchor $el
	    }
	    set Priv(tablePrev) $el
	}
    }
}

# ::tk::table::BeginExtend --
#
# This procedure is typically invoked on shift-button-1 presses. It
# begins the process of extending a selection in the table. Its
# exact behavior depends on the selection mode currently in effect
# for the table; see the Motif documentation for details.
#
# Arguments:
# w - The table widget.
# el - The element for the selection operation (typically the
# one under the pointer). Must be in numerical form.

proc ::tk::table::BeginExtend {w el} {
    # avoid tables that have no anchor index yet.
    if {[catch {$w index anchor}]} { return }
    if {[string match extended [$w cget -selectmode]] &&
	[$w selection includes anchor]} {
	::tk::table::Motion $w $el
    }
}

# ::tk::table::BeginToggle --
#
# This procedure is typically invoked on control-button-1 presses. It
# begins the process of toggling a selection in the table. Its
# exact behavior depends on the selection mode currently in effect
# for the table; see the Motif documentation for details.
#
# Arguments:
# w - The table widget.
# el - The element for the selection operation (typically the
# one under the pointer). Must be in numerical form.

proc ::tk::table::BeginToggle {w el} {
    if {[string match extended [$w cget -selectmode]]} {
	variable Priv
	set Priv(tablePrev) $el
	$w selection anchor $el
	if {[$w tag includes title $el]} {
	    scan $el %d,%d r c
	    if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		## We're in a column header
		if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
		    ## We're in the topleft title area
		    set end end
		} else {
		    set end [$w index end row],$c
		}
	    } else {
		## We're in a row header
		set end $r,[$w index end col]
	    }
	} else {
	    ## We're in a non-title cell
	    set end $el
	}
	if {[$w selection includes  $end]} {
	    $w selection clear $el $end
	} else {
	    $w selection set   $el $end
        }
    }
}

# ::tk::table::AutoScan --
# This procedure is invoked when the mouse leaves an table window
# with button 1 down. It scrolls the window up, down, left, or
# right, depending on where the mouse left the window, and reschedules
# itself as an "after" command so that the window continues to scroll until
# the mouse moves back into the window or the mouse button is released.
#
# Arguments:
# w - The table window.

proc ::tk::table::AutoScan {w} {
    if {![winfo exists $w]} return
    variable Priv
    set x $Priv(x)
    set y $Priv(y)
    if {$y >= [winfo height $w]} {
	$w yview scroll 1 units
    } elseif {$y < 0} {
	$w yview scroll -1 units
    } elseif {$x >= [winfo width $w]} {
	$w xview scroll 1 units
    } elseif {$x < 0} {
	$w xview scroll -1 units
    } else {
	return
    }
    ::tk::table::Motion $w [$w index @$x,$y]
    set Priv(afterId) [after 50 ::tk::table::AutoScan $w]
}

# ::tk::table::MoveCell --
#
# Moves the location cursor (active element) by the specified number
# of cells and changes the selection if we're in browse or extended
# selection mode.  If the new cell is "hidden", we skip to the next
# visible cell if possible, otherwise just abort.
#
# Arguments:
# w - The table widget.
# x - +1 to move down one cell, -1 to move up one cell.
# y - +1 to move right one cell, -1 to move left one cell.

proc ::tk::table::MoveCell {w x y} {
    if {[catch {$w index active row} r]} return
    set c [$w index active col]
    set cell [$w index [incr r $x],[incr c $y]]
    while {[string compare [set true [$w hidden $cell]] {}]} {
	# The cell is in some way hidden
	if {[string compare $true [$w index active]]} {
	    # The span cell wasn't the previous cell, so go to that
	    set cell $true
	    break
	}
	if {$x > 0} {incr r} elseif {$x < 0} {incr r -1}
	if {$y > 0} {incr c} elseif {$y < 0} {incr c -1}
	if {[string compare $cell [$w index $r,$c]]} {
	    set cell [$w index $r,$c]
	} else {
	    # We couldn't find a non-hidden cell, just don't move
	    return
	}
    }
    $w activate $cell
    $w see active
    switch [$w cget -selectmode] {
	browse {
	    $w selection clear all
	    $w selection set active
	}
	extended {
	    variable Priv
	    $w selection clear all
	    $w selection set active
	    $w selection anchor active
	    set Priv(tablePrev) [$w index active]
	}
    }
}

# ::tk::table::ExtendSelect --
#
# Does nothing unless we're in extended selection mode; in this
# case it moves the location cursor (active element) by the specified
# number of cells, and extends the selection to that point.
#
# Arguments:
# w - The table widget.
# x - +1 to move down one cell, -1 to move up one cell.
# y - +1 to move right one cell, -1 to move left one cell.

proc ::tk::table::ExtendSelect {w x y} {
    if {[string compare extended [$w cget -selectmode]] ||
	[catch {$w index active row} r]} return
    set c [$w index active col]
    $w activate [incr r $x],[incr c $y]
    $w see active
    ::tk::table::Motion $w [$w index active]
}

# ::tk::table::DataExtend
#
# This procedure is called for key-presses such as Shift-KEndData.
# If the selection mode isnt multiple or extend then it does nothing.
# Otherwise it moves the active element to el and, if we're in
# extended mode, extends the selection to that point.
#
# Arguments:
# w - The table widget.
# el - An integer cell number.

proc ::tk::table::DataExtend {w el} {
    set mode [$w cget -selectmode]
    if {[string match extended $mode]} {
	$w activate $el
	$w see $el
	if {[$w selection includes anchor]} {::tk::table::Motion $w $el}
    } elseif {[string match multiple $mode]} {
	$w activate $el
	$w see $el
    }
}

# ::tk::table::SelectAll
#
# This procedure is invoked to handle the "select all" operation.
# For single and browse mode, it just selects the active element.
# Otherwise it selects everything in the widget.
#
# Arguments:
# w - The table widget.

proc ::tk::table::SelectAll {w} {
    if {[regexp {^(single|browse)$} [$w cget -selectmode]]} {
	$w selection clear all
	catch {$w selection set active}
    } elseif {[$w cget -selecttitles]} {
	$w selection set [$w cget -roworigin],[$w cget -colorigin] end
    } else {
	$w selection set origin end
    }
}

# ::tk::table::ChangeWidth --
#
# Adjust the widget of the specified cell by $a.
#
# Arguments:
# w - The table widget.
# i - cell index
# a - amount to adjust by

proc ::tk::table::ChangeWidth {w i a} {
    set tmp [$w index $i col]
    if {[set width [$w width $tmp]] >= 0} {
	$w width $tmp [incr width $a]
    } else {
	$w width $tmp [incr width [expr {-$a}]]
    }
}

# tk_tableCopy --
#
# This procedure copies the selection from a table widget into the
# clipboard.
#
# Arguments:
# w -		Name of a table widget.

proc tk_tableCopy w {
    if {[selection own -displayof $w] == "$w"} {
	clipboard clear -displayof $w
	catch {clipboard append -displayof $w [::tk::table::GetSelection $w]}
    }
}

# tk_tableCut --
#
# This procedure copies the selection from a table widget into the
# clipboard, then deletes the selection (if it exists in the given
# widget).
#
# Arguments:
# w -		Name of a table widget.

proc tk_tableCut w {
    if {[selection own -displayof $w] == "$w"} {
	clipboard clear -displayof $w
	catch {
	    clipboard append -displayof $w [::tk::table::GetSelection $w]
	    $w cursel {}
	    $w selection clear all
	}
    }
}

# tk_tablePaste --
#
# This procedure pastes the contents of the clipboard to the specified
# cell (active by default) in a table widget.
#
# Arguments:
# w -		Name of a table widget.
# cell -	Cell to start pasting in.
#
proc tk_tablePaste {w {cell {}}} {
    if {[string compare {} $cell]} {
	if {[catch {::tk::table::GetSelection $w} data]} return
    } else {
	if {[catch {::tk::table::GetSelection $w CLIPBOARD} data]} {
	    return
	}
	set cell active
    }
    tk_tablePasteHandler $w [$w index $cell] $data
    if {[$w cget -state] == "normal"} {focus $w}
}

# tk_tablePasteHandler --
#
# This procedure handles how data is pasted into the table widget.
# This handles data in the default table selection form.
#
# NOTE: this allows pasting into all cells except title cells,
#       even those with -state disabled
#
# Arguments:
# w -		Name of a table widget.
# cell -	Cell to start pasting in.
#
proc tk_tablePasteHandler {w cell data} {
    #
    # Don't allow pasting into the title cells
    #
    if {[$w tag includes title $cell]} {
        return
    }

    set rows	[expr {[$w cget -rows]-[$w cget -roworigin]}]
    set cols	[expr {[$w cget -cols]-[$w cget -colorigin]}]
    set r	[$w index $cell row]
    set c	[$w index $cell col]
    set rsep	[$w cget -rowseparator]
    set csep	[$w cget -colseparator]
    ## Assume separate rows are split by row separator if specified
    ## If you were to want multi-character row separators, you would need:
    # regsub -all $rsep $data <newline> data
    # set data [join $data <newline>]
    if {[string compare {} $rsep]} { set data [split $data $rsep] }
    set row	$r
    foreach line $data {
	if {$row > $rows} break
	set col	$c
	## Assume separate cols are split by col separator if specified
	## Unless a -separator was specified
	if {[string compare {} $csep]} { set line [split $line $csep] }
	## If you were to want multi-character col separators, you would need:
	# regsub -all $csep $line <newline> line
	# set line [join $line <newline>]
	foreach item $line {
	    if {$col > $cols} break
	    $w set $row,$col $item
	    incr col
	}
	incr row
    }
}

# tk::table::Sort --
#
# This procedure handles how data is sorted in the table widget.
# This isn't currently used by tktable, but can be called by the user.
# It's behavior may change in the future.
#
# Arguments:
# w -		Name of a table widget.
# start -	start cell of rectangle to sort
# end -		end cell of rectangle to sort
# col -		column within rectangle to sort on
# args -	passed to lsort proc (ie: -integer -decreasing)

proc ::tk::table::Sort {w start end col args} {
    set start [$w index $start]
    set end   [$w index $end]
    scan $start %d,%d sr sc
    scan $end   %d,%d er ec
    if {($col < $sc) || ($col > $ec)} {
	return -code error "$col is not within sort range $sc to $ec"
    }
    set col [expr {$col - $sc}]

    set data {}
    for {set i $sr} {$i <= $er} {incr i} {
	lappend data [$w get $i,$sc $i,$ec]
    }

    set i $sr
    foreach row [eval [list lsort -index $col] $args [list $data]] {
	$w set row $i,$sc $row
	incr i
    }
}

#
# Tcl package index file
#
package ifneeded miniarc::crap::lzma 0.1 \
    [list load [file join $dir libcraplzma0.1.so] craplzma]

This software (tkdnd) is copyrighted by:
    George Petasis,
    Software and Knowledge Engineering Laboratory,
    Institute of Informatics and Telecommunications,
    National Centre for Scientific Research "Demokritos",
    Aghia Paraskevi, Athens, Greece.
    e-mail: petasis@iit.demokritos.gr
                 and 
    Laurent Riesterer, Rennes, France.
    e-mail: (laurent.riesterer@free.fr)

The following terms apply to all files associated
with the software unless explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute,
and license this software and its documentation for any purpose, provided
that existing copyright notices are retained in all copies and that this
notice is included verbatim in any distributions. No written agreement,
license, or royalty fee is required for any of the authorized uses.
Modifications to this software may be copyrighted by their authors
and need not follow the licensing terms described here, provided that
the new terms are clearly indicated on the first page of each file where
they apply.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

                  
	    tkdnd: Tk Drag & Drop extension
		     (Version 1.0.0)

This directory holds a collection of files that add native drag & drop
capabilities to the tk toolkit. It is designed for tk versions >= 8.3.3,
but with simple modifications can be applied to any tk version greater than
8.1.

Remember that this software is in development. Please report any bugs or
feature requests directly to the author (petasis@iit.demokritos.gr) or by
posting on the comp.lang.tcl newsgroup. In the latter case, please use
"tkdnd" in the title of the posting.

This software (tkdnd) is copyrighted by:
    George Petasis, National Centre for Scientific Research "Demokritos",
    Aghia Paraskevi, Athens, Greece.
    e-mail: petasis@iit.demokritos.gr
                 and
    Laurent Riesterer, Rennes, France.
    e-mail: (laurent.riesterer@free.fr)

and is under the same license that covers tcl. Free to use for anything :-)

For any questions and suggestions contact me at

  petasis@iit.demokritos.gr

or post a question at comp.lang.tcl (preferable)

namespace eval ::dnd {
    proc _load {dir} {
	set version 1.0
	load [file join $dir libtkdnd1.0.so] tkdnd
	source [file join $dir tkdnd.tcl]
	package provide tkdnd 1.0
	rename ::dnd::_load {}
    }
}

package ifneeded tkdnd 1.0  [list ::dnd::_load $dir]

#
# tkdnd.tcl --
# 
#    This file implements some utility procedures that are used by the tkDND
#    package.
#
# This software is copyrighted by:
# George Petasis, National Centre for Scientific Research "Demokritos",
# Aghia Paraskevi, Athens, Greece.
# e-mail: petasis@iit.demokritos.gr
#
# The following terms apply to all files associated
# with the software unless explicitly disclaimed in individual files.
#
# The authors hereby grant permission to use, copy, modify, distribute,
# and license this software and its documentation for any purpose, provided
# that existing copyright notices are retained in all copies and that this
# notice is included verbatim in any distributions. No written agreement,
# license, or royalty fee is required for any of the authorized uses.
# Modifications to this software may be copyrighted by their authors
# and need not follow the licensing terms described here, provided that
# the new terms are clearly indicated on the first page of each file where
# they apply.
# 
# IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
# FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
# ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
# DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# 
# THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
# IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
# NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
# MODIFICATIONS.
#

namespace eval ::dnd {
    variable AskSelectedAction
    
    # This procedure is used just to ensure that the object given as its
    # argument can be accessed as a binary object. Many thanks to Paul Duffin
    # for the idea :-)
    proc ConvertToBinary {object} {
	binary scan $object {}
	return $object
    }

    # This procedure handles the special case where we want items into a canvas
    # widget to be drop targets. It emulates this case as follows:
    #
    #  The tkDND extension is able to deliver events only to real windows
    #  (that means tk widgets). This procedure can be the binding script of all
    #  dnd events we are interested in being received by the canvas items.
    #  When this function is called, it tries to find the item that the mouse
    #  is over (if any). Then it examines its bindings, and if it finds the
    #  dnd related event that is processing it delivers this event to the
    #  particular item. Fianlly, it tries to emulate <DragEnter>/<DragLeave>
    #  on every canvas item...
    proc CanvasDeliverEvent {
	event actions action button source_codes curr_code data descriptions
	mods type source_types win X x Y y
    } {
	# This function will find the topmost item that the mouse is over, and
	# Deliver the event specified by the "event" arg to this item...
	global CanvasDeliverEventStatus
	switch $event {
	    <DragEnter>  -
	    <<DragEnter>> {set CanvasDeliverEventStatus(item) {}}
	    default {}
	}

	# Translate mouse coordinates to canvas coordinates...
	set cx [$win canvasx $x]
	set cy [$win canvasy $y]
	set cx_1 [expr {$cx+1}]
	set cy_1 [expr {$cy+1}]
	# Find all tags that are under the mouse...
	set tags [$win find overlapping $cx $cy $cx_1 $cy_1]
	# ... and select the topmost...
	set length [llength $tags]

	# If no tags under the mouse, return...
	if {!$length} {
	    #puts -->$CanvasDeliverEventStatus(item)
	    if {[string length $CanvasDeliverEventStatus(item)]} {
		# Send <<DragLeave>>...
		set _id $CanvasDeliverEventStatus(item)
		set _binding {}
		foreach _tag [concat $_id [$win gettags $_id]] {
		    set _binding [$win bind $_tag <<DragLeave>>]
		    if {[string length $_binding]} {break}
		}
		# puts "Sending <DragLeave> (1) to $_id ($_binding)"
		set script {}
		foreach element $_binding {
		    switch $element {
			%% {lappend script %}       
			%A {lappend script $action}
			%a {lappend script $actions}
			%b {lappend script $button}
			%C {lappend script $source_codes}
			%c {lappend script $curr_code}
			%D {lappend script $data}
			%d {lappend script $descriptions}
			%m {lappend script $mods}
			%T {lappend script $type}
			%t {lappend script $source_types}
			%W {lappend script $win}
			%X {lappend script $X}
			%x {lappend script $x}
			%Y {lappend script $Y}
			%y {lappend script $y}
			%I {lappend script $_id}
			default {lappend script $element}
		    }
		}
		if {[llength $script]} {uplevel 1 $script}
	    }
	    set CanvasDeliverEventStatus(item) {}
	    update
	    if {[string equal $event <<Drag>>]} {
		return -code break
	    }
	    return $action
	}
	if {$length == 1} {
	    set id $tags
	} else {
	    set id [$win find closest $cx $cy]
	}

	# Now in "id" we have the tag of the item below the mouse...
	# Has this item a binding?
	foreach tag [concat $id [$win gettags $id]] {
	    set binding [$win bind $tag $event]
	    if {[string length $binding]} {break}
	}
	
	# Is this tag the same as the last one? If is different, we
	# have to send a leave event to the previous item and an enter
	# event to this one...
	if {$CanvasDeliverEventStatus(item) != $id} {
	    if {[string length $CanvasDeliverEventStatus(item)]} {
		# Send <<DragLeave>>...
		set _id $CanvasDeliverEventStatus(item)
		set _binding {}
		foreach _tag [concat $_id [$win gettags $_id]] {
		    set _binding [$win bind $_tag <<DragLeave>>]
		    if {[string length $_binding]} {break}
		}
		# puts "Sending <DragLeave> (2) to $_id ($_binding)"
		set script {}
		foreach element $_binding {
		    switch $element {
			%% {lappend script %}       
			%A {lappend script $action}
			%a {lappend script $actions}
			%b {lappend script $button}
			%C {lappend script $source_codes}
			%c {lappend script $curr_code}
			%D {lappend script $data}
			%d {lappend script $descriptions}
			%m {lappend script $mods}
			%T {lappend script $type}
			%t {lappend script $source_types}
			%W {lappend script $win}
			%X {lappend script $X}
			%x {lappend script $x}
			%Y {lappend script $Y}
			%y {lappend script $y}
			%I {lappend script $_id}
			default {lappend script $element}
		    }
		}
		if {[llength $script]} {uplevel 1 $script}
	    }
	    # Send <<DndEnter>>...
	    set _id $id
	    set _binding {}
	    foreach _tag [concat $_id [$win gettags $_id]] {
		set _binding [$win bind $_tag <<DragEnter>>]
		if {[string length $_binding]} {break}
	    }
	    # puts "Sending <DragEnter> to $tag ($_binding)"
	    set script {}
	    foreach element $_binding {
		switch $element {
		    %% {lappend script %}       
		    %A {lappend script $action}
		    %a {lappend script $actions}
		    %b {lappend script $button}
		    %C {lappend script $source_codes}
		    %c {lappend script $curr_code}
		    %D {lappend script $data}
		    %d {lappend script $descriptions}
		    %m {lappend script $mods}
		    %T {lappend script $type}
		    %t {lappend script $source_types}
		    %W {lappend script $win}
		    %X {lappend script $X}
		    %x {lappend script $x}
		    %Y {lappend script $Y}
		    %y {lappend script $y}
		    %I {lappend script $_id}
		    default {lappend script $element}
		}
	    }
	    if {[llength $script]} {uplevel 1 $script}
	    set CanvasDeliverEventStatus(item) $id
	}

	set script {}
	foreach element $binding {
	    switch $element {
		%% {lappend script %}       
		%A {lappend script $action}
		%a {lappend script $actions}
		%b {lappend script $button}
		%C {lappend script $source_codes}
		%c {lappend script $curr_code}
		%D {lappend script $data}
		%d {lappend script $descriptions}
		%m {lappend script $mods}
		%T {lappend script $type}
		%t {lappend script $source_types}
		%W {lappend script $win}
		%X {lappend script $X}
		%x {lappend script $x}
		%Y {lappend script $Y}
		%y {lappend script $y}
		%I {lappend script $id}
		default {lappend script $element}
	    }
	}
	if {[llength $script]} {
	    return [uplevel 1 $script]
	}
	set CanvasDeliverEventStatus(item) {}
	update
	if {[string equal $event <<Drag>>]} {
	    return -code break
	}
	return $action
    }

    # ChooseAskAction --
    #   This procedure displays a dialog with the help of which the user can
    #   select one of the supported actions...
    proc ChooseAskAction {window x y actions descriptions args} {
	variable AskSelectedAction
	set title {Please Select Action:}
	foreach action $actions descr $descriptions {
	    if {[string equal $action ask]} {
		set title $descr
		break
	    }
	}

	set menu $window.__tk_dnd[pwd]__action_ask__Drop_window_[pid]
	catch {destroy $menu}
	menu $menu -title $title -tearoff 0 -disabledforeground darkgreen
	$menu add command -font {helvetica 12 bold} \
		-label $title -command "destroy $menu" -state disabled
	$menu add separator

	set items 0
	foreach action $actions descr $descriptions {
	    if {[string equal $action ask]} continue
	    $menu add command -label $descr -command \
		    "set ::dnd::AskSelectedAction $action; destroy $menu"
	    incr items
	}
	if {!$items} {
	    # The drag source accepts the ask action, but has no defined
	    # action list? Add copy action at least...
	    $menu add command -label Copy -command \
		    "set ::dnd::AskSelectedAction copy; destroy $menu"
	}
	
	$menu add separator
	$menu add command -label {Cancel Drop} -command \
		"set ::dnd::AskSelectedAction none; destroy $menu"

	set AskSelectedAction none
	tk_popup $menu $x $y
	update
	bind $menu <Unmap> {after idle {catch {destroy %W}}}
	tkwait window $menu
	
	return $AskSelectedAction
    }
};# namespace eval ::dnd

# EOF

/*
 * Conceptually based on Tk3 table widget by Roland King (rols@lehman.com)
 *
 * see ChangeLog file for details
 *
 * current maintainer: jeff at hobbs org
 *
 * Copyright 1997-2002, Jeffrey Hobbs (jeff@hobbs.org)
 */

		*************************************
		  The Tk Table Widget Version 2.0+
		*************************************

INTRODUCTION

TkTable is a table/matrix widget extension to tk/tcl.
The basic features of the widget are:

 * multi-line cells
 * support for embedded windows (one per cell)
 * row & column spanning
 * variable width columns / height rows (interactively resizable)
 * row and column titles
 * multiple data sources ((Tcl array || Tcl command) &| internal caching)
 * supports standard Tk reliefs, fonts, colors, etc.
 * x/y scrollbar support
 * 'tag' styles per row, column or cell to change visual appearance
 * in-cell editing - returns value back to data source
 * support for disabled (read-only) tables or cells (via tags)
 * multiple selection modes, with "active" cell
 * multiple drawing modes to get optimal performance for larger tables
 * optional 'flashes' when things update
 * cell validation support
 * Works everywhere Tk does (including Windows and Mac!)
 * Unicode support (Tk8.1+)

FINDING THE WIDGET

0. The newest version is most likely found at:
	http://tktable.sourceforge.net/
	http://www.purl.org/net/hobbs/tcl/capp/

BUILDING AND INSTALLING THE WIDGET

1. Uncompress and unpack the distribution

   ON UNIX:
	gzip -cd Tktable<version>.tar.gz | tar xf -

   ON WINDOWS:
	use something like WinZip to unpack the archive.

   ON MACINTOSH:
	use StuffIt Expander to unstuff the archive.
    
   This will create a subdirectory tkTable<version> with all the files in it.

2. Configure

   ON UNIX:
        cd Tktable<version>
	./configure

   tkTable uses information left in tkConfig.sh when you built tk.  This
   file will be found in $exec_prefix/lib/.  You might set the --prefix and
   --exec-prefix options of configure if you don't want the default
   (/usr/local).  If building on multiple unix platforms, the following is
   recommended to isolate build conflicts:
	mkdir <builddir>/<platform>
	cd !$
	/path/to/Tktable<version>/configure

   ON WINDOWS:

   Version 2.8 added support for building in the cygwin environment on
   Windows based on TEA (http://www.tcl.tk/doc/tea/).  You can retrieve
   cygwin from:
	http://sources.redhat.com/cygwin/

   Inside the cygwin environment, you build the same as on Unix.

   Otherwise, hack makefile.vc until it works and compile.  It has problems
   executing wish from a path with a space in it, but the DLL builds just
   fine.  A DLL should be available where you found this archive.

   ON MACINTOSH:
   
   Hack the CodeWarrior XML project mac_tkTable.mcp.xml until it works and
   compile.  The access path to the Tcl/Tk source tree will probably need
   adjusting.  A DLL should be available where you found this archive.

3. Make and Install

   ON UNIX or WINDOWS (with cygwin):
	make
	make test (OPTIONAL)
	make install

   ON WINDOWS (makefile.vc):
	nmake -f makefile.vc
	nmake -f makefile.vc test (OPTIONAL)
	nmake -f makefile.vc install

   ON MACINTOSH:
	Place Tktable.shlb in the Tool Command Language folder

   tkTable is built to comply to the latest tcl package conventions.
   There is also a specific "make static" for those who need it.

4. Use it

   Start a regular wish interpreter, 'load' the library, and use the table.
   Or use the "tablewish" interpreter that has the 'table' command built in.
   There are a few test scripts in the demos directory which you can source.

5. Read the documentation

   There is a Unix manpage and HTML translation provided in the doc/
   subdirectory.  These describe the table widget's features and commands
   in depth.  If something is confusing, just to try it out.


THINGS TO WATCH OUT FOR

Packing
  The table tries not to allocate huge chunks of screen real estate if
  you ask it for a lot of rows and columns.  You can always stretch out
  the frame or explicitly tell it how big it can be.  If you want to
  stretch the table, remember to pack it with fill both and expand on,
  or with grid, give it -sticky news and configure the grid row and column
  for some weighting.

Array   
  The array elements for the table are of the form array(2,3) etc.  Make
  sure there are no spaces around the ','.  Negative indices are allowed.

Editing
  If you can't edit, remember that the focus model in tk is explicit, so
  you need to click on the table or give it the focus command.  Just
  having a selected cell is not the same thing as being able to edit.
  You also need the editing cursor.  If you can't get the cursor, make
  sure that you actually have a variable assigned to the table, and that
  the "state" of the cell is not disabled.

COMMENTS, BUGS, etc.

* Please can you send comments and bug reports to the current maintainer
  and their best will be done to address them.  A mailing list for
  tktable discussion is tktable-users@lists.sourceforge.net.

* If you find a bug, a short piece of Tcl that exercises it would be very
  useful, or even better, compile with debugging and specify where it
  crashed in that short piece of Tcl.  Use the SourceForge site to check
  for known bugs or submit new ones.

		   * COPYRIGHT AND LICENSE TERMS *

(This file blatantly stolen from Tcl/Tk license and adapted - thus assume
it falls under similar license terms).

This software is copyrighted by Jeffrey Hobbs <jeff at hobbs org>.  The
following terms apply to all files associated with the software unless
explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute, and
license this software and its documentation for any purpose, provided that
existing copyright notices are retained in all copies and that this notice
is included verbatim in any distributions.  No written agreement, license,
or royalty fee is required for any of the authorized uses.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF,
EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE IS
PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO
OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

RESTRICTED RIGHTS: Use, duplication or disclosure by the U.S. government
is subject to the restrictions as set forth in subparagraph (c) (1) (ii)
of the Rights in Technical Data and Computer Software Clause as DFARS
252.227-7013 and FAR 52.227-19.

SPECIAL NOTES:

This software also falls under the bourbon_ware clause:

    Should you find this software useful in your daily work, you should
    feel obliged to take the author out for a drink if the opportunity
    presents itself.  The user may feel exempt from this clause if they
    are under 21 or think the author has already partaken of too many
    drinks.

if {[catch {package require Tcl 8.2}]} return
package ifneeded Tktable 2.9 \
    [list load [file join $dir libTktable2.9.so] Tktable]

# table.tcl --
#
# Version align with tkTable 2.7, jeff at hobbs org
# This file defines the default bindings for Tk table widgets
# and provides procedures that help in implementing those bindings.
#
# RCS: @(#) $Id: tkTable.tcl,v 1.14 2005/07/12 23:26:28 hobbs Exp $

#--------------------------------------------------------------------------
# ::tk::table::Priv elements used in this file:
#
# x && y -		Coords in widget
# afterId -		Token returned by "after" for autoscanning.
# tablePrev -		The last element to be selected or deselected
#			during a selection operation.
# mouseMoved -		Boolean to indicate whether mouse moved while
#			the button was pressed.
# borderInfo -		Boolean to know if the user clicked on a border
# borderB1 -		Boolean that set whether B1 can be used for the
#			interactiving resizing
#--------------------------------------------------------------------------

namespace eval ::tk::table {
    # Ensure that a namespace is created for us
    variable Priv
    array set Priv [list x 0 y 0 afterId {} mouseMoved 0 \
	    borderInfo {} borderB1 1]
}

# ::tk::table::ClipboardKeysyms --
# This procedure is invoked to identify the keys that correspond to
# the "copy", "cut", and "paste" functions for the clipboard.
#
# Arguments:
# copy -	Name of the key (keysym name plus modifiers, if any,
#		such as "Meta-y") used for the copy operation.
# cut -		Name of the key used for the cut operation.
# paste -	Name of the key used for the paste operation.

proc ::tk::table::ClipboardKeysyms {copy cut paste} {
    bind Table <$copy>	{tk_tableCopy %W}
    bind Table <$cut>	{tk_tableCut %W}
    bind Table <$paste>	{tk_tablePaste %W}
}
::tk::table::ClipboardKeysyms <Copy> <Cut> <Paste>

##
## Interactive cell resizing, affected by -resizeborders option
##
bind Table <3>		{
    ## You might want to check for cell returned if you want to
    ## restrict the resizing of certain cells
    %W border mark %x %y
}
bind Table <B3-Motion>	{ %W border dragto %x %y }

## Button events

bind Table <1> { ::tk::table::Button1 %W %x %y }
bind Table <B1-Motion> { ::tk::table::B1Motion %W %x %y }

bind Table <ButtonRelease-1> {
    if {$::tk::table::Priv(borderInfo) == "" && [winfo exists %W]} {
	::tk::table::CancelRepeat
	%W activate @%x,%y
    }
}
bind Table <Double-1> {
    # empty
}

bind Table <Shift-1>	{::tk::table::BeginExtend %W [%W index @%x,%y]}
bind Table <Control-1>	{::tk::table::BeginToggle %W [%W index @%x,%y]}
bind Table <B1-Enter>	{::tk::table::CancelRepeat}
bind Table <B1-Leave>	{
    if {$::tk::table::Priv(borderInfo) == ""} {
	array set ::tk::table::Priv {x %x y %y}
	::tk::table::AutoScan %W
    }
}
bind Table <2> {
    %W scan mark %x %y
    array set ::tk::table::Priv {x %x y %y}
    set ::tk::table::Priv(mouseMoved) 0
}
bind Table <B2-Motion> {
    if {(%x != $::tk::table::Priv(x)) || (%y != $::tk::table::Priv(y))} {
	set ::tk::table::Priv(mouseMoved) 1
    }
    if {$::tk::table::Priv(mouseMoved)} { %W scan dragto %x %y }
}
bind Table <ButtonRelease-2> {
    if {!$::tk::table::Priv(mouseMoved)} { tk_tablePaste %W [%W index @%x,%y] }
}

## Key events

# This forces a cell commit if an active cell exists
bind Table <<Table_Commit>> {
    catch {%W activate active}
}
# Remove this if you don't want cell commit to occur on every Leave for
# the table (via mouse) or FocusOut (loss of focus by table).
event add <<Table_Commit>> <Leave> <FocusOut>

bind Table <Shift-Up>		{::tk::table::ExtendSelect %W -1  0}
bind Table <Shift-Down>		{::tk::table::ExtendSelect %W  1  0}
bind Table <Shift-Left>		{::tk::table::ExtendSelect %W  0 -1}
bind Table <Shift-Right>	{::tk::table::ExtendSelect %W  0  1}
bind Table <Prior>		{%W yview scroll -1 pages; %W activate topleft}
bind Table <Next>		{%W yview scroll  1 pages; %W activate topleft}
bind Table <Control-Prior>	{%W xview scroll -1 pages}
bind Table <Control-Next>	{%W xview scroll  1 pages}
bind Table <Home>		{%W see origin}
bind Table <End>		{%W see end}
bind Table <Control-Home> {
    %W selection clear all
    %W activate origin
    %W selection set active
    %W see active
}
bind Table <Control-End> {
    %W selection clear all
    %W activate end
    %W selection set active
    %W see active
}
bind Table <Shift-Control-Home>	{::tk::table::DataExtend %W origin}
bind Table <Shift-Control-End>	{::tk::table::DataExtend %W end}
bind Table <Select>		{::tk::table::BeginSelect %W [%W index active]}
bind Table <Shift-Select>	{::tk::table::BeginExtend %W [%W index active]}
bind Table <Control-slash>	{::tk::table::SelectAll %W}
bind Table <Control-backslash> {
    if {[string match browse [%W cget -selectmode]]} {%W selection clear all}
}
bind Table <Up>			{::tk::table::MoveCell %W -1  0}
bind Table <Down>		{::tk::table::MoveCell %W  1  0}
bind Table <Left>		{::tk::table::MoveCell %W  0 -1}
bind Table <Right>		{::tk::table::MoveCell %W  0  1}
bind Table <KeyPress>		{::tk::table::Insert %W %A}
bind Table <BackSpace>		{::tk::table::BackSpace %W}
bind Table <Delete>		{%W delete active insert}
bind Table <Escape>		{%W reread}

#bind Table <Return>		{::tk::table::MoveCell %W 1 0}
bind Table <Return>		{::tk::table::Insert %W "\n"}

bind Table <Control-Left>	{%W icursor [expr {[%W icursor]-1}]}
bind Table <Control-Right>	{%W icursor [expr {[%W icursor]+1}]}
bind Table <Control-e>		{%W icursor end}
bind Table <Control-a>		{%W icursor 0}
bind Table <Control-k>		{%W delete active insert end}
bind Table <Control-equal>	{::tk::table::ChangeWidth %W active  1}
bind Table <Control-minus>	{::tk::table::ChangeWidth %W active -1}

# Ignore all Alt, Meta, and Control keypresses unless explicitly bound.
# Otherwise, if a widget binding for one of these is defined, the
# <KeyPress> class binding will also fire and insert the character,
# which is wrong.  Ditto for Tab.

bind Table <Alt-KeyPress>	{# nothing}
bind Table <Meta-KeyPress>	{# nothing}
bind Table <Control-KeyPress>	{# nothing}
bind Table <Any-Tab>		{# nothing}
if {[string match "macintosh" $::tcl_platform(platform)]} {
    bind Table <Command-KeyPress> {# nothing}
}

# ::tk::table::GetSelection --
#   This tries to obtain the default selection.  On Unix, we first try
#   and get a UTF8_STRING, a type supported by modern Unix apps for
#   passing Unicode data safely.  We fall back on the default STRING
#   type otherwise.  On Windows, only the STRING type is necessary.
# Arguments:
#   w	The widget for which the selection will be retrieved.
#	Important for the -displayof property.
#   sel	The source of the selection (PRIMARY or CLIPBOARD)
# Results:
#   Returns the selection, or an error if none could be found
#
if {[string compare $::tcl_platform(platform) "unix"]} {
    proc ::tk::table::GetSelection {w {sel PRIMARY}} {
	if {[catch {selection get -displayof $w -selection $sel} txt]} {
	    return -code error "could not find default selection"
	} else {
	    return $txt
	}
    }
} else {
    proc ::tk::table::GetSelection {w {sel PRIMARY}} {
	if {[catch {selection get -displayof $w -selection $sel \
		-type UTF8_STRING} txt] \
		&& [catch {selection get -displayof $w -selection $sel} txt]} {
	    return -code error "could not find default selection"
	} else {
	    return $txt
	}
    }
}

# ::tk::table::CancelRepeat --
# A copy of tkCancelRepeat, just in case it's not available or changes.
# This procedure is invoked to cancel an auto-repeat action described
# by ::tk::table::Priv(afterId).  It's used by several widgets to auto-scroll
# the widget when the mouse is dragged out of the widget with a
# button pressed.
#
# Arguments:
# None.

proc ::tk::table::CancelRepeat {} {
    variable Priv
    after cancel $Priv(afterId)
    set Priv(afterId) {}
}

# ::tk::table::Insert --
#
#   Insert into the active cell
#
# Arguments:
#   w	- the table widget
#   s	- the string to insert
# Results:
#   Returns nothing
#
proc ::tk::table::Insert {w s} {
    if {[string compare $s {}]} {
	$w insert active insert $s
    }
}

# ::tk::table::BackSpace --
#
#   BackSpace in the current cell
#
# Arguments:
#   w	- the table widget
# Results:
#   Returns nothing
#
proc ::tk::table::BackSpace {w} {
    set cur [$w icursor]
    if {[string compare {} $cur] && $cur} {
	$w delete active [expr {$cur-1}]
    }
}

# ::tk::table::Button1 --
#
# This procedure is called to handle selecting with mouse button 1.
# It will distinguish whether to start selection or mark a border.
#
# Arguments:
#   w	- the table widget
#   x	- x coord
#   y	- y coord
# Results:
#   Returns nothing
#
proc ::tk::table::Button1 {w x y} {
    variable Priv
    #
    # $Priv(borderInfo) is null if the user did not click on a border
    #
    if {$Priv(borderB1) == 1} {
	set Priv(borderInfo) [$w border mark $x $y]
	# account for what resizeborders are set [Bug 876320] (ferenc)
	set rbd [$w cget -resizeborders]
	if {$rbd == "none" || ![llength $Priv(borderInfo)]
	    || ($rbd == "col" && [lindex $Priv(borderInfo) 1] == "")
	    || ($rbd == "row" && [lindex $Priv(borderInfo) 0] == "")} {
	    set Priv(borderInfo) ""
	}
    } else {
	set Priv(borderInfo) ""
    }
    if {$Priv(borderInfo) == ""} {
	#
	# Only do this when a border wasn't selected
	#
	if {[winfo exists $w]} {
	    ::tk::table::BeginSelect $w [$w index @$x,$y]
	    focus $w
	}
	array set Priv [list x $x y $y]
	set Priv(mouseMoved) 0
    }
}

# ::tk::table::B1Motion --
#
# This procedure is called to start processing mouse motion events while
# button 1 moves while pressed.  It will distinguish whether to change
# the selection or move a border.
#
# Arguments:
#   w	- the table widget
#   x	- x coord
#   y	- y coord
# Results:
#   Returns nothing
#
proc ::tk::table::B1Motion {w x y} {
    variable Priv

    # If we already had motion, or we moved more than 1 pixel,
    # then we start the Motion routine
    if {$Priv(borderInfo) != ""} {
	#
	# If the motion is on a border, drag it and skip the rest
	# of this binding.
	#
	$w border dragto $x $y
    } else {
	#
	# If we already had motion, or we moved more than 1 pixel,
	# then we start the Motion routine
	#
	if {
	    $::tk::table::Priv(mouseMoved)
	    || abs($x-$::tk::table::Priv(x)) > 1
	    || abs($y-$::tk::table::Priv(y)) > 1
	} {
	    set ::tk::table::Priv(mouseMoved) 1
	}
	if {$::tk::table::Priv(mouseMoved)} {
	    ::tk::table::Motion $w [$w index @$x,$y]
	}
    }
}

# ::tk::table::BeginSelect --
#
# This procedure is typically invoked on button-1 presses. It begins
# the process of making a selection in the table. Its exact behavior
# depends on the selection mode currently in effect for the table;
# see the Motif documentation for details.
#
# Arguments:
# w	- The table widget.
# el	- The element for the selection operation (typically the
#	one under the pointer).  Must be in row,col form.

proc ::tk::table::BeginSelect {w el} {
    variable Priv
    if {[scan $el %d,%d r c] != 2} return
    switch [$w cget -selectmode] {
	multiple {
	    if {[$w tag includes title $el]} {
		## in the title area
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			set inc topleft
			set el2 end
		    } else {
			set inc [$w index topleft row],$c
			set el2 [$w index end row],$c
		    }
		} else {
		    ## We're in a row header
		    set inc $r,[$w index topleft col]
		    set el2 $r,[$w index end col]
		}
	    } else {
		set inc $el
		set el2 $el
	    }
	    if {[$w selection includes $inc]} {
		$w selection clear $el $el2
	    } else {
		$w selection set $el $el2
	    }
	}
	extended {
	    $w selection clear all
	    if {[$w tag includes title $el]} {
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			$w selection set $el end
		    } else {
			$w selection set $el [$w index end row],$c
		    }
		} else {
		    ## We're in a row header
		    $w selection set $el $r,[$w index end col]
		}
	    } else {
		$w selection set $el
	    }
	    $w selection anchor $el
	    set Priv(tablePrev) $el
	}
	default {
	    if {![$w tag includes title $el]} {
		$w selection clear all
		$w selection set $el
		set Priv(tablePrev) $el
	    }
	    $w selection anchor $el
	}
    }
}

# ::tk::table::Motion --
#
# This procedure is called to process mouse motion events while
# button 1 is down. It may move or extend the selection, depending
# on the table's selection mode.
#
# Arguments:
# w	- The table widget.
# el	- The element under the pointer (must be in row,col form).

proc ::tk::table::Motion {w el} {
    variable Priv
    if {![info exists Priv(tablePrev)]} {
	set Priv(tablePrev) $el
	return
    }
    if {[string match $Priv(tablePrev) $el]} return
    switch [$w cget -selectmode] {
	browse {
	    $w selection clear all
	    $w selection set $el
	    set Priv(tablePrev) $el
	}
	extended {
	    # avoid tables that have no anchor index yet.
	    if {[catch {$w index anchor}]} { return }
	    scan $Priv(tablePrev) %d,%d r c
	    scan $el %d,%d elr elc
	    if {[$w tag includes title $el]} {
		if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		    ## We're in a column header
		    if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
			## We're in the topleft title area
			$w selection clear anchor end
		    } else {
			$w selection clear anchor [$w index end row],$c
		    }
		    $w selection set anchor [$w index end row],$elc
		} else {
		    ## We're in a row header
		    $w selection clear anchor $r,[$w index end col]
		    $w selection set anchor $elr,[$w index end col]
		}
	    } else {
		$w selection clear anchor $Priv(tablePrev)
		$w selection set anchor $el
	    }
	    set Priv(tablePrev) $el
	}
    }
}

# ::tk::table::BeginExtend --
#
# This procedure is typically invoked on shift-button-1 presses. It
# begins the process of extending a selection in the table. Its
# exact behavior depends on the selection mode currently in effect
# for the table; see the Motif documentation for details.
#
# Arguments:
# w - The table widget.
# el - The element for the selection operation (typically the
# one under the pointer). Must be in numerical form.

proc ::tk::table::BeginExtend {w el} {
    # avoid tables that have no anchor index yet.
    if {[catch {$w index anchor}]} { return }
    if {[string match extended [$w cget -selectmode]] &&
	[$w selection includes anchor]} {
	::tk::table::Motion $w $el
    }
}

# ::tk::table::BeginToggle --
#
# This procedure is typically invoked on control-button-1 presses. It
# begins the process of toggling a selection in the table. Its
# exact behavior depends on the selection mode currently in effect
# for the table; see the Motif documentation for details.
#
# Arguments:
# w - The table widget.
# el - The element for the selection operation (typically the
# one under the pointer). Must be in numerical form.

proc ::tk::table::BeginToggle {w el} {
    if {[string match extended [$w cget -selectmode]]} {
	variable Priv
	set Priv(tablePrev) $el
	$w selection anchor $el
	if {[$w tag includes title $el]} {
	    scan $el %d,%d r c
	    if {$r < [$w cget -titlerows]+[$w cget -roworigin]} {
		## We're in a column header
		if {$c < [$w cget -titlecols]+[$w cget -colorigin]} {
		    ## We're in the topleft title area
		    set end end
		} else {
		    set end [$w index end row],$c
		}
	    } else {
		## We're in a row header
		set end $r,[$w index end col]
	    }
	} else {
	    ## We're in a non-title cell
	    set end $el
	}
	if {[$w selection includes  $end]} {
	    $w selection clear $el $end
	} else {
	    $w selection set   $el $end
        }
    }
}

# ::tk::table::AutoScan --
# This procedure is invoked when the mouse leaves an table window
# with button 1 down. It scrolls the window up, down, left, or
# right, depending on where the mouse left the window, and reschedules
# itself as an "after" command so that the window continues to scroll until
# the mouse moves back into the window or the mouse button is released.
#
# Arguments:
# w - The table window.

proc ::tk::table::AutoScan {w} {
    if {![winfo exists $w]} return
    variable Priv
    set x $Priv(x)
    set y $Priv(y)
    if {$y >= [winfo height $w]} {
	$w yview scroll 1 units
    } elseif {$y < 0} {
	$w yview scroll -1 units
    } elseif {$x >= [winfo width $w]} {
	$w xview scroll 1 units
    } elseif {$x < 0} {
	$w xview scroll -1 units
    } else {
	return
    }
    ::tk::table::Motion $w [$w index @$x,$y]
    set Priv(afterId) [after 50 ::tk::table::AutoScan $w]
}

# ::tk::table::MoveCell --
#
# Moves the location cursor (active element) by the specified number
# of cells and changes the selection if we're in browse or extended
# selection mode.  If the new cell is "hidden", we skip to the next
# visible cell if possible, otherwise just abort.
#
# Arguments:
# w - The table widget.
# x - +1 to move down one cell, -1 to move up one cell.
# y - +1 to move right one cell, -1 to move left one cell.

proc ::tk::table::MoveCell {w x y} {
    if {[catch {$w index active row} r]} return
    set c [$w index active col]
    set cell [$w index [incr r $x],[incr c $y]]
    while {[string compare [set true [$w hidden $cell]] {}]} {
	# The cell is in some way hidden
	if {[string compare $true [$w index active]]} {
	    # The span cell wasn't the previous cell, so go to that
	    set cell $true
	    break
	}
	if {$x > 0} {incr r} elseif {$x < 0} {incr r -1}
	if {$y > 0} {incr c} elseif {$y < 0} {incr c -1}
	if {[string compare $cell [$w index $r,$c]]} {
	    set cell [$w index $r,$c]
	} else {
	    # We couldn't find a non-hidden cell, just don't move
	    return
	}
    }
    $w activate $cell
    $w see active
    switch [$w cget -selectmode] {
	browse {
	    $w selection clear all
	    $w selection set active
	}
	extended {
	    variable Priv
	    $w selection clear all
	    $w selection set active
	    $w selection anchor active
	    set Priv(tablePrev) [$w index active]
	}
    }
}

# ::tk::table::ExtendSelect --
#
# Does nothing unless we're in extended selection mode; in this
# case it moves the location cursor (active element) by the specified
# number of cells, and extends the selection to that point.
#
# Arguments:
# w - The table widget.
# x - +1 to move down one cell, -1 to move up one cell.
# y - +1 to move right one cell, -1 to move left one cell.

proc ::tk::table::ExtendSelect {w x y} {
    if {[string compare extended [$w cget -selectmode]] ||
	[catch {$w index active row} r]} return
    set c [$w index active col]
    $w activate [incr r $x],[incr c $y]
    $w see active
    ::tk::table::Motion $w [$w index active]
}

# ::tk::table::DataExtend
#
# This procedure is called for key-presses such as Shift-KEndData.
# If the selection mode isnt multiple or extend then it does nothing.
# Otherwise it moves the active element to el and, if we're in
# extended mode, extends the selection to that point.
#
# Arguments:
# w - The table widget.
# el - An integer cell number.

proc ::tk::table::DataExtend {w el} {
    set mode [$w cget -selectmode]
    if {[string match extended $mode]} {
	$w activate $el
	$w see $el
	if {[$w selection includes anchor]} {::tk::table::Motion $w $el}
    } elseif {[string match multiple $mode]} {
	$w activate $el
	$w see $el
    }
}

# ::tk::table::SelectAll
#
# This procedure is invoked to handle the "select all" operation.
# For single and browse mode, it just selects the active element.
# Otherwise it selects everything in the widget.
#
# Arguments:
# w - The table widget.

proc ::tk::table::SelectAll {w} {
    if {[regexp {^(single|browse)$} [$w cget -selectmode]]} {
	$w selection clear all
	catch {$w selection set active}
    } elseif {[$w cget -selecttitles]} {
	$w selection set [$w cget -roworigin],[$w cget -colorigin] end
    } else {
	$w selection set origin end
    }
}

# ::tk::table::ChangeWidth --
#
# Adjust the widget of the specified cell by $a.
#
# Arguments:
# w - The table widget.
# i - cell index
# a - amount to adjust by

proc ::tk::table::ChangeWidth {w i a} {
    set tmp [$w index $i col]
    if {[set width [$w width $tmp]] >= 0} {
	$w width $tmp [incr width $a]
    } else {
	$w width $tmp [incr width [expr {-$a}]]
    }
}

# tk_tableCopy --
#
# This procedure copies the selection from a table widget into the
# clipboard.
#
# Arguments:
# w -		Name of a table widget.

proc tk_tableCopy w {
    if {[selection own -displayof $w] == "$w"} {
	clipboard clear -displayof $w
	catch {clipboard append -displayof $w [::tk::table::GetSelection $w]}
    }
}

# tk_tableCut --
#
# This procedure copies the selection from a table widget into the
# clipboard, then deletes the selection (if it exists in the given
# widget).
#
# Arguments:
# w -		Name of a table widget.

proc tk_tableCut w {
    if {[selection own -displayof $w] == "$w"} {
	clipboard clear -displayof $w
	catch {
	    clipboard append -displayof $w [::tk::table::GetSelection $w]
	    $w cursel {}
	    $w selection clear all
	}
    }
}

# tk_tablePaste --
#
# This procedure pastes the contents of the clipboard to the specified
# cell (active by default) in a table widget.
#
# Arguments:
# w -		Name of a table widget.
# cell -	Cell to start pasting in.
#
proc tk_tablePaste {w {cell {}}} {
    if {[string compare {} $cell]} {
	if {[catch {::tk::table::GetSelection $w} data]} return
    } else {
	if {[catch {::tk::table::GetSelection $w CLIPBOARD} data]} {
	    return
	}
	set cell active
    }
    tk_tablePasteHandler $w [$w index $cell] $data
    if {[$w cget -state] == "normal"} {focus $w}
}

# tk_tablePasteHandler --
#
# This procedure handles how data is pasted into the table widget.
# This handles data in the default table selection form.
#
# NOTE: this allows pasting into all cells except title cells,
#       even those with -state disabled
#
# Arguments:
# w -		Name of a table widget.
# cell -	Cell to start pasting in.
#
proc tk_tablePasteHandler {w cell data} {
    #
    # Don't allow pasting into the title cells
    #
    if {[$w tag includes title $cell]} {
        return
    }

    set rows	[expr {[$w cget -rows]-[$w cget -roworigin]}]
    set cols	[expr {[$w cget -cols]-[$w cget -colorigin]}]
    set r	[$w index $cell row]
    set c	[$w index $cell col]
    set rsep	[$w cget -rowseparator]
    set csep	[$w cget -colseparator]
    ## Assume separate rows are split by row separator if specified
    ## If you were to want multi-character row separators, you would need:
    # regsub -all $rsep $data <newline> data
    # set data [join $data <newline>]
    if {[string compare {} $rsep]} { set data [split $data $rsep] }
    set row	$r
    foreach line $data {
	if {$row > $rows} break
	set col	$c
	## Assume separate cols are split by col separator if specified
	## Unless a -separator was specified
	if {[string compare {} $csep]} { set line [split $line $csep] }
	## If you were to want multi-character col separators, you would need:
	# regsub -all $csep $line <newline> line
	# set line [join $line <newline>]
	foreach item $line {
	    if {$col > $cols} break
	    $w set $row,$col $item
	    incr col
	}
	incr row
    }
}

# tk::table::Sort --
#
# This procedure handles how data is sorted in the table widget.
# This isn't currently used by tktable, but can be called by the user.
# It's behavior may change in the future.
#
# Arguments:
# w -		Name of a table widget.
# start -	start cell of rectangle to sort
# end -		end cell of rectangle to sort
# col -		column within rectangle to sort on
# args -	passed to lsort proc (ie: -integer -decreasing)

proc ::tk::table::Sort {w start end col args} {
    set start [$w index $start]
    set end   [$w index $end]
    scan $start %d,%d sr sc
    scan $end   %d,%d er ec
    if {($col < $sc) || ($col > $ec)} {
	return -code error "$col is not within sort range $sc to $ec"
    }
    set col [expr {$col - $sc}]

    set data {}
    for {set i $sr} {$i <= $er} {incr i} {
	lappend data [$w get $i,$sc $i,$ec]
    }

    set i $sr
    foreach row [eval [list lsort -index $col] $args [list $data]] {
	$w set row $i,$sc $row
	incr i
    }
}

#
# Tcl package index file
#
package ifneeded miniarc::crap::lzma 0.1 \
    [list load [file join $dir libcraplzma0.1.so] craplzma]

This software (tkdnd) is copyrighted by:
    George Petasis,
    Software and Knowledge Engineering Laboratory,
    Institute of Informatics and Telecommunications,
    National Centre for Scientific Research "Demokritos",
    Aghia Paraskevi, Athens, Greece.
    e-mail: petasis@iit.demokritos.gr
                 and 
    Laurent Riesterer, Rennes, France.
    e-mail: (laurent.riesterer@free.fr)

The following terms apply to all files associated
with the software unless explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute,
and license this software and its documentation for any purpose, provided
that existing copyright notices are retained in all copies and that this
notice is included verbatim in any distributions. No written agreement,
license, or royalty fee is required for any of the authorized uses.
Modifications to this software may be copyrighted by their authors
and need not follow the licensing terms described here, provided that
the new terms are clearly indicated on the first page of each file where
they apply.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

                  
	    tkdnd: Tk Drag & Drop extension
		     (Version 1.0.0)

This directory holds a collection of files that add native drag & drop
capabilities to the tk toolkit. It is designed for tk versions >= 8.3.3,
but with simple modifications can be applied to any tk version greater than
8.1.

Remember that this software is in development. Please report any bugs or
feature requests directly to the author (petasis@iit.demokritos.gr) or by
posting on the comp.lang.tcl newsgroup. In the latter case, please use
"tkdnd" in the title of the posting.

This software (tkdnd) is copyrighted by:
    George Petasis, National Centre for Scientific Research "Demokritos",
    Aghia Paraskevi, Athens, Greece.
    e-mail: petasis@iit.demokritos.gr
                 and
    Laurent Riesterer, Rennes, France.
    e-mail: (laurent.riesterer@free.fr)

and is under the same license that covers tcl. Free to use for anything :-)

For any questions and suggestions contact me at

  petasis@iit.demokritos.gr

or post a question at comp.lang.tcl (preferable)

namespace eval ::dnd {
    proc _load {dir} {
	set version 1.0
	load [file join $dir libtkdnd1.0.so] tkdnd
	source [file join $dir tkdnd.tcl]
	package provide tkdnd 1.0
	rename ::dnd::_load {}
    }
}

package ifneeded tkdnd 1.0 \
	[list ::dnd::_load $dir]

#
# tkdnd.tcl --
# 
#    This file implements some utility procedures that are used by the tkDND
#    package.
#
# This software is copyrighted by:
# George Petasis, National Centre for Scientific Research "Demokritos",
# Aghia Paraskevi, Athens, Greece.
# e-mail: petasis@iit.demokritos.gr
#
# The following terms apply to all files associated
# with the software unless explicitly disclaimed in individual files.
#
# The authors hereby grant permission to use, copy, modify, distribute,
# and license this software and its documentation for any purpose, provided
# that existing copyright notices are retained in all copies and that this
# notice is included verbatim in any distributions. No written agreement,
# license, or royalty fee is required for any of the authorized uses.
# Modifications to this software may be copyrighted by their authors
# and need not follow the licensing terms described here, provided that
# the new terms are clearly indicated on the first page of each file where
# they apply.
# 
# IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
# FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
# ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
# DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# 
# THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
# IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
# NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
# MODIFICATIONS.
#

namespace eval ::dnd {
    variable AskSelectedAction
    
    # This procedure is used just to ensure that the object given as its
    # argument can be accessed as a binary object. Many thanks to Paul Duffin
    # for the idea :-)
    proc ConvertToBinary {object} {
	binary scan $object {}
	return $object
    }

    # This procedure handles the special case where we want items into a canvas
    # widget to be drop targets. It emulates this case as follows:
    #
    #  The tkDND extension is able to deliver events only to real windows
    #  (that means tk widgets). This procedure can be the binding script of all
    #  dnd events we are interested in being received by the canvas items.
    #  When this function is called, it tries to find the item that the mouse
    #  is over (if any). Then it examines its bindings, and if it finds the
    #  dnd related event that is processing it delivers this event to the
    #  particular item. Fianlly, it tries to emulate <DragEnter>/<DragLeave>
    #  on every canvas item...
    proc CanvasDeliverEvent {
	event actions action button source_codes curr_code data descriptions
	mods type source_types win X x Y y
    } {
	# This function will find the topmost item that the mouse is over, and
	# Deliver the event specified by the "event" arg to this item...
	global CanvasDeliverEventStatus
	switch $event {
	    <DragEnter>  -
	    <<DragEnter>> {set CanvasDeliverEventStatus(item) {}}
	    default {}
	}

	# Translate mouse coordinates to canvas coordinates...
	set cx [$win canvasx $x]
	set cy [$win canvasy $y]
	set cx_1 [expr {$cx+1}]
	set cy_1 [expr {$cy+1}]
	# Find all tags that are under the mouse...
	set tags [$win find overlapping $cx $cy $cx_1 $cy_1]
	# ... and select the topmost...
	set length [llength $tags]

	# If no tags under the mouse, return...
	if {!$length} {
	    #puts -->$CanvasDeliverEventStatus(item)
	    if {[string length $CanvasDeliverEventStatus(item)]} {
		# Send <<DragLeave>>...
		set _id $CanvasDeliverEventStatus(item)
		set _binding {}
		foreach _tag [concat $_id [$win gettags $_id]] {
		    set _binding [$win bind $_tag <<DragLeave>>]
		    if {[string length $_binding]} {break}
		}
		# puts "Sending <DragLeave> (1) to $_id ($_binding)"
		set script {}
		foreach element $_binding {
		    switch $element {
			%% {lappend script %}       
			%A {lappend script $action}
			%a {lappend script $actions}
			%b {lappend script $button}
			%C {lappend script $source_codes}
			%c {lappend script $curr_code}
			%D {lappend script $data}
			%d {lappend script $descriptions}
			%m {lappend script $mods}
			%T {lappend script $type}
			%t {lappend script $source_types}
			%W {lappend script $win}
			%X {lappend script $X}
			%x {lappend script $x}
			%Y {lappend script $Y}
			%y {lappend script $y}
			%I {lappend script $_id}
			default {lappend script $element}
		    }
		}
		if {[llength $script]} {uplevel 1 $script}
	    }
	    set CanvasDeliverEventStatus(item) {}
	    update
	    if {[string equal $event <<Drag>>]} {
		return -code break
	    }
	    return $action
	}
	if {$length == 1} {
	    set id $tags
	} else {
	    set id [$win find closest $cx $cy]
	}

	# Now in "id" we have the tag of the item below the mouse...
	# Has this item a binding?
	foreach tag [concat $id [$win gettags $id]] {
	    set binding [$win bind $tag $event]
	    if {[string length $binding]} {break}
	}
	
	# Is this tag the same as the last one? If is different, we
	# have to send a leave event to the previous item and an enter
	# event to this one...
	if {$CanvasDeliverEventStatus(item) != $id} {
	    if {[string length $CanvasDeliverEventStatus(item)]} {
		# Send <<DragLeave>>...
		set _id $CanvasDeliverEventStatus(item)
		set _binding {}
		foreach _tag [concat $_id [$win gettags $_id]] {
		    set _binding [$win bind $_tag <<DragLeave>>]
		    if {[string length $_binding]} {break}
		}
		# puts "Sending <DragLeave> (2) to $_id ($_binding)"
		set script {}
		foreach element $_binding {
		    switch $element {
			%% {lappend script %}       
			%A {lappend script $action}
			%a {lappend script $actions}
			%b {lappend script $button}
			%C {lappend script $source_codes}
			%c {lappend script $curr_code}
			%D {lappend script $data}
			%d {lappend script $descriptions}
			%m {lappend script $mods}
			%T {lappend script $type}
			%t {lappend script $source_types}
			%W {lappend script $win}
			%X {lappend script $X}
			%x {lappend script $x}
			%Y {lappend script $Y}
			%y {lappend script $y}
			%I {lappend script $_id}
			default {lappend script $element}
		    }
		}
		if {[llength $script]} {uplevel 1 $script}
	    }
	    # Send <<DndEnter>>...
	    set _id $id
	    set _binding {}
	    foreach _tag [concat $_id [$win gettags $_id]] {
		set _binding [$win bind $_tag <<DragEnter>>]
		if {[string length $_binding]} {break}
	    }
	    # puts "Sending <DragEnter> to $tag ($_binding)"
	    set script {}
	    foreach element $_binding {
		switch $element {
		    %% {lappend script %}       
		    %A {lappend script $action}
		    %a {lappend script $actions}
		    %b {lappend script $button}
		    %C {lappend script $source_codes}
		    %c {lappend script $curr_code}
		    %D {lappend script $data}
		    %d {lappend script $descriptions}
		    %m {lappend script $mods}
		    %T {lappend script $type}
		    %t {lappend script $source_types}
		    %W {lappend script $win}
		    %X {lappend script $X}
		    %x {lappend script $x}
		    %Y {lappend script $Y}
		    %y {lappend script $y}
		    %I {lappend script $_id}
		    default {lappend script $element}
		}
	    }
	    if {[llength $script]} {uplevel 1 $script}
	    set CanvasDeliverEventStatus(item) $id
	}

	set script {}
	foreach element $binding {
	    switch $element {
		%% {lappend script %}       
		%A {lappend script $action}
		%a {lappend script $actions}
		%b {lappend script $button}
		%C {lappend script $source_codes}
		%c {lappend script $curr_code}
		%D {lappend script $data}
		%d {lappend script $descriptions}
		%m {lappend script $mods}
		%T {lappend script $type}
		%t {lappend script $source_types}
		%W {lappend script $win}
		%X {lappend script $X}
		%x {lappend script $x}
		%Y {lappend script $Y}
		%y {lappend script $y}
		%I {lappend script $id}
		default {lappend script $element}
	    }
	}
	if {[llength $script]} {
	    return [uplevel 1 $script]
	}
	set CanvasDeliverEventStatus(item) {}
	update
	if {[string equal $event <<Drag>>]} {
	    return -code break
	}
	return $action
    }

    # ChooseAskAction --
    #   This procedure displays a dialog with the help of which the user can
    #   select one of the supported actions...
    proc ChooseAskAction {window x y actions descriptions args} {
	variable AskSelectedAction
	set title {Please Select Action:}
	foreach action $actions descr $descriptions {
	    if {[string equal $action ask]} {
		set title $descr
		break
	    }
	}

	set menu $window.__tk_dnd[pwd]__action_ask__Drop_window_[pid]
	catch {destroy $menu}
	menu $menu -title $title -tearoff 0 -disabledforeground darkgreen
	$menu add command -font {helvetica 12 bold} \
		-label $title -command "destroy $menu" -state disabled
	$menu add separator

	set items 0
	foreach action $actions descr $descriptions {
	    if {[string equal $action ask]} continue
	    $menu add command -label $descr -command \
		    "set ::dnd::AskSelectedAction $action; destroy $menu"
	    incr items
	}
	if {!$items} {
	    # The drag source accepts the ask action, but has no defined
	    # action list? Add copy action at least...
	    $menu add command -label Copy -command \
		    "set ::dnd::AskSelectedAction copy; destroy $menu"
	}
	
	$menu add separator
	$menu add command -label {Cancel Drop} -command \
		"set ::dnd::AskSelectedAction none; destroy $menu"

	set AskSelectedAction none
	tk_popup $menu $x $y
	update
	bind $menu <Unmap> {after idle {catch {destroy %W}}}
	tkwait window $menu
	
	return $AskSelectedAction
    }
};# namespace eval ::dnd

# EOF