treeviewlib.tcl

#
# Name:		TreeView Library Functions
# Version:	1.0.3
# Date:		Oct 10, 2024
# Author:	Brian O'Hagan
# Email:	brian199@comcast.net
# Legal Notice:	(c) Copyright 2020 by Brian O'Hagan
#		Released under the BSD license. I would appreciate a copy of any modifications
#		made to this package for possible incorporation in a future release.
# Description:	Provides convenience functions for the treeview widget.
#

# Package dependencies
package require Tcl 8.6-
package require Tk 8.6-
catch {package require autoscroll}; # Tklib

# Library module
package provide treeviewlib 1.0.3


#
# Create namespace for package
#
namespace eval ::treeviewlib {
    variable column ""
    variable cursor ""
    variable moveColumn ""
    variable moveItem ""
    variable widgets
    variable fakeId 0

    # Movable column bindings
    bind Treeview <ButtonPress-1> +[list ::treeviewlib::MoveColumnPress %W %x %y]
    bind Treeview <B1-Motion> +[list ::treeviewlib::MoveColumnDrag %W %x %y]
    bind Treeview <ButtonRelease-1> +[list ::treeviewlib::MoveColumnRelease %W %x %y]

    # Font size bindings
    bind Treeview <<TkWorldChanged>> [list ::treeviewlib::FontChanged %W %d]
    variable fonts

    # Sort direction arrows from Tk demos
    # 3d arrows
    image create photo ::treeviewlib::arrowUp3d -data {
	R0lGODlhDgAOAJEAANnZ2YCAgPz8/P///yH5BAEAAAAALAAAAAAOAA4AAAImhI+
	py+1LIsJHiBAh+BgmiEAJQITgW6DgUQIAECH4JN8IPqYuNxUAOw==}
    image create photo ::treeviewlib::arrowDown3d -data {
	R0lGODlhDgAOAJEAANnZ2YCAgPz8/P///yH5BAEAAAAALAAAAAAOAA4AAAInhI+
	py+1I4ocQ/IgDEYIPgYJICUCE4F+YIBolEoKPEJKZmVJK6ZACADs=}
    image create photo ::treeviewlib::arrowBlank3d -height 14 -width 14

    # Solid triangle icons
    image create bitmap ::treeviewlib::arrowUp -data {
	#define arrowUp_width 9
	#define arrowUp_height 5
	static char arrowUp_bits[] = {
	    0x10, 0x00, 0x38, 0x00, 0x7c, 0x00, 0xfe, 0x00, 0xff, 0x01
	};
    }
    image create bitmap ::treeviewlib::arrowDown -data {
	#define arrowDown_width 9
	#define arrowDown_height 5
	static char arrowDown_bits[] = {
	    0xff, 0x01, 0xfe, 0x00, 0x7c, 0x00, 0x38, 0x00, 0x10, 0x00
	};
    }
    image create bitmap ::treeviewlib::arrowBlank -data {
	#define arrowBlank_width 9
	#define arrowBlank_height 5
	static char arrowBlank_bits[] = {
	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	};
    }

    # Caret icons
    image create bitmap ::treeviewlib::caretUp -data {
	#define caretUp_width 9
	#define caretUp_height 5
	static char caretUp_bits[] = {
	    0x10, 0x00, 0x28, 0x00, 0x44, 0x00, 0x82, 0x00, 0x01, 0x01
	};
    }
    image create bitmap ::treeviewlib::caretDown -data {
	#define caretDown_width 9
	#define caretDown_height 5
	static char caretDown_bits[] = {
	    0x01, 0x01, 0x82, 0x00, 0x44, 0x00, 0x28, 0x00, 0x10, 0x00
	};
    }

    # Outline triangle icons
    image create bitmap ::treeviewlib::triangleUp -data {
	#define triangleUp_width 9
	#define triangleUp_height 5
	static char triangleUp_bits[] = {
	    0x10, 0x00, 0x28, 0x00, 0x44, 0x00, 0x82, 0x00, 0xff, 0x01
	};
    }
    image create bitmap ::treeviewlib::triangleDown -data {
	#define triangleDown_width 9
	#define triangleDown_height 5
	static char triangleDown_bits[] = {
	    0xff, 0x01, 0x82, 0x00, 0x44, 0x00, 0x28, 0x00, 0x10, 0x00
	};
    }

    # Undo change in Tk 8.6.9 that prevents use of tag colors
    if {[info patchlevel] eq "8.6.9"} {
	ttk::style map Treeview -background [list disabled SystemButtonFace selected SystemHighlight] \
	    -foreground [list disabled SystemGrayText selected SystemHighlightText]
    }
}

###############################################################################
# Ttk Overrides
###############################################################################

if {[package vcompare [package require Tk] 8.6.9] < 0} {
#
# ActivateHeading -- track active heading element
#
# Args: w = Widget
#	heading = Heading column number
# Returns: nothing
#
proc ttk::treeview::ActivateHeading {w heading} {
    variable State

    if {$w != $State(activeWidget) || $heading != $State(activeHeading)} {
	if {[winfo exists $State(activeWidget)] && $State(activeHeading) != {}} {
	    $State(activeWidget) heading $State(activeHeading) state !active
	}
	if {$heading != {}} {
	    $w heading $heading state active
	}
	set State(activeHeading) $heading
	set State(activeWidget) $w
    }
}
}

###############################################################################
# Widget Setup
###############################################################################

#
# Create treeview widget with scrollbars
#
# Args: w = Window frame containing treeview to create
#	id = Context id for this widget
#	titles = Column titles in width, title, alignment pairs
#	ids = Field or column ids for each column
#	is_tree = Show tree column boolean
# Returns: Treeview widget name
#
proc ::treeviewlib::create {w id {titles {}} {ids {}} {is_tree 0}} {
    variable widgets

    # Create frame
    set w [::ttk::frame $w -padding 1 -relief sunken -borderwidth 0]

    # Create widget and scrollbars
    set tree [ttk::treeview $w.tree -selectmode extended -takefocus 1 \
	-xscrollcommand [list $w.sx set] -yscrollcommand [list $w.sy set]]
    ttk::scrollbar $w.sy -orient vertical -command [list $tree yview]
    ttk::scrollbar $w.sx -orient horizontal -command [list $tree xview]
    grid $w.tree $w.sy -sticky nsew
    grid $w.sx -sticky nsew
    grid columnconfigure $w 0 -weight 1
    grid rowconfigure $w 0 -weight 1
    set widgets($id) $tree

    # Only display scrollbars when needed
    catch {::autoscroll::autoscroll $w.sx}
    catch {::autoscroll::autoscroll $w.sy}

    # Configure tree
    reconfigure $tree $titles $ids $is_tree

    # Selection bindings
    if {[tk windowingsystem] ne "aqua"} {set key "Control"} else {set key "Command"}
    foreach {seq fn} [list <$key-a> all <$key-i> invert <$key-u> unselect \
	<$key-space> toggle <<SelectAll>> all <<SelectNone>> clear] {
	bind $tree $seq +[list ::treeviewlib::select %W $fn]
    }

    # Edit bindings
    foreach {seq fn} [list <$key-c> Copy <<Copy>> Copy] {
	bind $tree $seq +[list ::treeviewlib::$fn %W]
    }

    # Stripe tag
    $tree tag configure stripe -background #f4f1e8

    # Create pop-up menu
    set menu [menu $tree.column_menu]
    set proc ::treeviewlib::menu_callback
    $menu add command -label "Hide Column" -command [list $proc $tree hide]
    $menu add command -label "Show Column" -command [list $proc $tree show]
    $menu add separator
    $menu add command -label "Move Column Left" -command [list $proc $tree move_left]
    $menu add command -label "Move Column Right" -command [list $proc $tree move_right]
    $menu add separator
    $menu add command -label "Size Column to Fit Data" -command [list $proc $tree autosize]
    $menu add command -label "Size All Columns to Fit" -command [list $proc $tree autosize_all]

    # Add binding for popup menu
    bind $tree <<ContextMenu>> [list ::treeviewlib::post_menu $tree $menu %X %Y %x %y]
    return $tree
}

#
# Update treeview columns
#
# Args: w = Treeview widget
#	titles = Column titles in width, title, alignment pairs
#	ids = Field or column ids for each column
#	is_tree = Show tree column boolean
# Returns: Treeview widget name
#
proc ::treeviewlib::reconfigure {w {titles {}} {ids {}} {is_tree 0}} {
    variable fonts

    # Get column ids
    set i [expr {!$is_tree + 0}]
    set columns [list]
    foreach id $ids {width title align mode} $titles {
	if {$i > 0} {
	    lappend columns [expr {$id ne "" ? $id : $title}]
	}
	incr i
    }

    # Show treeview components
    set show [list]
    foreach {name boolean} [list tree $is_tree headings [llength $titles]] {
	if {$boolean} {
	    lappend show $name
	}
    }

    # Set column ids
    $w configure -columns $columns -show $show

    # Cell font
    #set font [ttk::style configure Treeview -font]
    set font [ttk::style lookup Treeview -font]
    if {$font eq ""} {set font TkDefaultFont}
    set cwidth [font measure $font -displayof $w "n"]
    set fonts($w-$font) $cwidth

    # Set column titles
    set i [expr {!$is_tree + 0}]
    foreach id $ids {width title align mode} $titles {
	set column [expr {$i == 0 ? "#0" : ($id ne "" ? $id : $title)}]
	set stretch [expr {$width == 0}]
	set anchor [string map [list left w right e] [string tolower $align]]
	set width [expr {$width * $cwidth}]

	$w heading $column -anchor center -text $title -image ::treeviewlib::arrowBlank \
	    -command [list ::treeviewlib::SortByColumn $w {} $column increasing $mode] \
	    state [list !selected !alternate !user1]
	$w column $column -anchor $anchor -minwidth 25 -stretch $stretch -width $width
	incr i
    }
}

#
# Resize columns and rows after font change
#
# Args: w = Treeview widget
#	detail = Trigger for event
# Returns: nothing
#
proc ::treeviewlib::FontChanged {w detail} {
    set top [winfo toplevel $w]
    variable fonts

    # Only valid for font updates
    if {$detail ne "FontChanged"} {
	return
    }

    # Get class font
    #set font [ttk::style configure Treeview -font]
    set font [ttk::style lookup Treeview -font]
    if {$font eq ""} {set font TkDefaultFont}
    set new [font measure $font -displayof $top "n"]

    # Get previous size
    set old $fonts($w-$font)
    set fonts($w-$font) $new

    # Resize columns
    foreach column [concat [list #0] [$w cget -columns]] {
	$w column $column -width [expr {int([$w column $column -width] / $old) * $new}]
    }

    # Resize tags
    foreach tag [$w tag names] {
	# Get font
	set font [$w tag configure $tag -font]
	if {$font eq ""} continue
	set cwidth [font measure $font -displayof $top "n"]

	# Resize rows
	set h [font metrics $font -displayof $top -linespace]
    }
}

###############################################################################
# Widget Functions
###############################################################################

#
# Select treeview functions handler for keyboard and menu events
#
# Args: id = Widget id
#	fn = Function to perform
#	args = Arguments to fn
# Returns: Function dependent
#
proc ::treeviewlib::handler {id fn args} {
    variable widgets
    perform_fn $widgets($id) $fn {*}$args
}

#
# Perform select treeview functions
#
# Args: w = Treeview widget
#	fn = Function to perform
#	args = Tree item ids or function dependent
# Returns: Function dependent
#
proc ::treeviewlib::perform_fn {w fn args} {
    # Default to selected item(s), if not specified
    if {[llength $args] == 0 && $fn in [list collapse copy cut delete detach expand get lower raise]} {
	set args [list [$w selection]]
    }

    switch -exact -- $fn {
	"append" {
	    # Append rows
	    Insert $w {} end {*}$args
	}

	"attach" - "paste" {
	    # Reattach items
	    set index [$w focus]
	    if {$index eq ""} {
		set index [lindex [$w selection] 0]
	    }
	    if {$index eq ""} {
		set index "end"
	    }
	    MoveRow $w {} $index {*}$args
	}

	"autosizecolumns" {
	    # Auto size columns
	    ColumnAutoSize $w $args
	}

	"clear" {
	    # Delete all tree items
	    FilterClear $w
	    $w delete [$w children {}]
	}

	"collapse" - "expand" {
	    # Close or open items
	    ExpandCollapse $w [string match "expand" $fn] {*}$args
	}

	"collapse_all" - "expand_all" {
	    # Close or expand all items
	    ExpandCollapse $w [string match "expand*" $fn] [$w children {}]
	}

	"copy" {
	    # Copy items
	    Copy $w {*}$args
	}

	"cut" - "detach" {
	    # Cut items, but don't delete
	    $w detach {*}$args
	    return $args
	}

	"delete" {
	    # Delete items
	    if {![catch {$w delete {*}$args}]} {
		Restripe $w {}
		upvar #0 ::treeviewlib::data$w cache
		if {[info exists cache]} {
		    foreach item $args {
			if {[set index [lsearch $cache $item]] > -1} {
			    set cache [lreplace $cache $index $index]
			}
		    }
		}
	    }
	}

	"get" {
	    # Get item
	    return [Get $w {*}$args]
	}

	"hide" {
	    # Hide column
	    ColumnHide $w {*}$args
	}

	"insert" {
	    # Insert rows
	    Insert $w {} {*}$args
	}

	"lower" - "raise" {
	    # Lower (move down) or raise (move up) items
	    RaiseLower $w $fn {*}$args
	}

	"move" {
	    # MoveRow item under parent at position index
	    MoveRow $w {*}$args
	}

	"movecolumn" {
	    # Move column
	    MoveColumn $w {*}$args
	}

	"set" - "update" {
	    # Update items
	    Update $w {*}$args
	}

	"show" - "unhide" {
	    # Show column
	    ColumnShow $w {*}$args
	}

	"size" {
	    # Total number items
	    return [Size $w]
	}

	"sort" {
	    # Sort using current sort column and direction
	    Sort $w
	}

	"sortbycolumn" {
	    # Sort by column
	    SortByColumn $w {} {*}$args
	}

	"sortcolumn" {
	    # Return current sort column
	    return [lindex [SortInfo $w] 0]
	}

	"sortinfo" {
	    # Return current sort column, order, and mode
	    return [SortInfo $w]
	}

	"sortorder" {
	    # Return current sort order
	    return [lindex [SortInfo $w] 1]
	}
    }
}

#
# Copy treeview items to Clipboard
#
# Args: w = Treeview widget
#	items = Items to copy to clipboard or {} to use current selection
# Returns: nothing
#
proc ::treeviewlib::Copy {w {items {}}} {
    set data ""
    if {[llength $items] == 0} {
	set items [$w selection]
    }
    if {"tree" in [$w cget -show]} {
	foreach item $items {
	    append data [join [concat [list [$w item $item -text]] [$w item $item -values]] \t] \n
	}
    } else {
	foreach item $items {
	    append data [join [$w item $item -values] \t] \n
	}
    }
    clipboard clear -displayof $w
    clipboard append -displayof $w -- $data
}

#
# Collapse/expand treeview items
#
# Args: w = Treeview widget
#	boolean = Open state boolean
#	items = Items to open/close
#	depth = Depth to recursively open/close. Default is 1.
# Returns: nothing
#
proc ::treeviewlib::ExpandCollapse {w boolean items {depth 1}} {
    incr depth -1
    foreach item $items {
	$w item $item -open $boolean
	if {$depth > 0} {
	    set children [$w children $item]
	    if {[llength $children] > 0} {
		ExpandCollapse $w $boolean $children $depth
	    }
	}
    }
}

#
# Get treeview items
#
# Args: w = Treeview widget
#	items = Items to retrieve
#	display = Use display column order boolean. Default is false.
# Returns: Data from widget in list of lists format
#
proc ::treeviewlib::Get {w items {display 0}} {
    set is_tree [expr {"tree" in [$w cget -show]}]
    set result [list]

    # If data and display column order is the same, use faster method
    if {$display} {
	set columns [$w cget -displaycolumns]
	if {$columns eq "#all"} {
	    set display 0
	}
    }

    # Get data
    if {!$display} {
	# Stored order
	if {!$is_tree} {
	    foreach item $items {
		lappend result [$w item $item -values]
	    }
	} else {
	    foreach item $items {
		lappend result [concat [list [$w item $item -text]] [$w item $item -values]]
	    }
	}
    } else {
	# Display order
	foreach item $items {
	    set list [list]
	    if {$is_tree} {
		lappend list [$w item $item -text]
	    }
	    foreach column $columns {
		lappend list [$w set $item $column]
	    }
	    lappend result $list
	}
    }
    if {[llength $items] > 1} {
	return $result
    } else {
	return [lindex $result 0]
    }
}

#
# Insert items into treeview widget
#
# Args: w = Treeview widget
#	parent = Parent item
#	index = Index to insert at
#	data = Data to insert in repeating id and data elements format
# Returns: nothing
#
proc ::treeviewlib::Insert {w parent index data} {
    set is_tree [expr {"tree" in [$w cget -show]}]
    lassign [$w yview] start end
    upvar #0 ::treeviewlib::data$w cache
    set add [info exists cache]
    variable fakeId

    # Insert data
    foreach {id record} $data {
	if {[$w exists $id]} {
	    set id [format "fakeId%05d" [incr fakeId]]
	}
	if {!$is_tree} {
	    $w insert $parent $index -id $id -values $record
	} else {
	    $w insert $parent $index -id $id -text [lindex $record 0] -values [lrange $record 1 end]
	}
	if {$add} {
	    lappend cache $id
	}
	if {[string is integer $index]} {
	    incr index
	}
    }

    # Restripe
    if {$parent eq ""} {
	Restripe $w $parent [lindex $data 0]
    }

    # Scroll to end
    if {$index eq "end" && $start > 0.0 && $end == 1.0} {
	$w yview moveto 1.0
    }
}

#
# Insert items into treeview widget without record ids
#
# Args: w = Treeview widget
#	parent = Parent item
#	index = Index to insert at
#	data = Data to insert in list of lists format
# Returns: list of item ids for inserted data
#
proc ::treeviewlib::Insert_No_Id {w parent index data} {
    set result [list]
    set is_tree [expr {"tree" in [$w cget -show]}]
    lassign [$w yview] start end
    upvar #0 ::treeviewlib::data$w cache
    set add [info exists cache]

    # Insert data
    foreach {record} $data {
	if {!$is_tree} {
	    lappend result [$w insert $parent $index -values $record]
	} else {
	    lappend result [$w insert $parent $index -text [lindex $record 0] -values [lrange $record 1 end]]
	}
	if {$add} {
	    lappend cache [lindex $result end]
	}
	if {[string is integer $index]} {
	    incr index
	}
    }

    # Restripe
    if {$parent eq ""} {
	Restripe $w $parent [lindex $result 0]
    }

    # Scroll to end
    if {$index eq "end" && $start > 0.0 && $end == 1.0} {
	$w yview moveto 1.0
    }
    return $result
}

#
# Lower (move down) or raise (move up) items in treeview widget
#
# Args: w = Treeview widget
#	fn = Function to perform: raise or lower
#	items = Items to raise or lower
# Returns: nothing
#
proc ::treeviewlib::RaiseLower {w fn items} {
    set incr [expr {$fn eq "lower" ? 1 : -1}]
    set list [list]
    foreach item $items {
	set index [expr {[$w index $item] + $incr}]
	if {$index < 0} return
	lappend list $item [$w parent $item] $index
    }
    $w detach $items
    foreach {item parent index} $list {
	$w move $item $parent $index
    }
}

#
# Treeview size (count of items)
#
# Args: w = Treeview widget
#	parent = Parent item
#	recursive = Count child elements boolean
#	only_open = Only count children of open elements boolean
# Returns: Count of widget items
#
proc ::treeviewlib::Size {w {parent {}} {recursive 1} {only_open 1}} {
    set items [$w children $parent]
    set count [llength $items]
    if {$recursive} {
	foreach item $items {
	    if {!$only_open || ($only_open && [$w item $item -open])} {
		incr count [Size $w $item $recursive $only_open]
	    }
	}
    }
    return $count
}

#
# Update/insert items in treeview widget
#
# Args: w = Treeview widget
#	data = Data to update in repeating id and data elements format
# Returns: nothing
#
proc ::treeviewlib::Update {w data} {
    set is_tree [expr {"tree" in [$w cget -show]}]
    set do_sort 0
    upvar #0 ::treeviewlib::data$w cache
    set add [info exists cache]

    foreach {id record} $data {
	if {[$w exists $id]} {
	    # Update item
	    if {!$is_tree} {
		$w item $id -values $record
	    } else {
		$w item $id -text [lindex $record 0] -values [lrange $record 1 end]
	    }

	} else {
	    # Insert item
	    if {!$is_tree} {
		$w insert {} end -id $id -values $record
	    } else {
		$w insert {} end -id $id -text [lindex $record 0] -values [lrange $record 1 end]
	    }
	    if {$add} {
		lappend cache $id
	    }
	    set do_sort 1
	}
    }

    # Do sort
    if {$do_sort} {
	SortUpdate $w {} {*}[SortInfo $w]
    }
}

###############################################################################
# Selection Functions
###############################################################################

#
# Selection functions handler for menu & keyboard events
#
# Args: id = Widget id
#	fn = Function to perform
#	args = Arguments to fn
# Returns: Nothing
#
proc ::treeviewlib::select_handler {id fn args} {
    variable widgets
    select $widgets($id) $fn {*}$args
}

#
# Perform selection functions
#
# Args: w = Treeview widget
#	fn = Function to perform
#	args = Tree item ids or function dependent
# Returns: Nothing except get where data is returned
# Effects: Updated tree
#
proc ::treeviewlib::select {w fn args} {
    switch -exact -- $fn {
	"all" {
	    # Select all items
	    #SelectAllRecursive $w {}
	    $w selection set [$w children {}]
	}

	"clear" {
	    # Unselect all items
	    $w selection set {}
	}

	"goto" - "see" {
	    # See items, use current selection as default
	    if {[llength $args] == 0} {
		set args [$w selection]
	    }
	    foreach item $args {
		$w see $item
		break
	    }
	}

	"invert" {
	    # Invert selection
	    set sel [$w selection]
	    #SelectAllRecursive $w {}
	    $w selection set [$w children {}]
	    $w selection remove $sel
	}

	"select" {
	    # Select current active item or a list of items
	    if {[llength $args] == 0 && [$w focus] ne ""} {
		set args [list [$w focus]]
	    }
	    if {[llength $args] > 0} {
		$w selection [expr {[$w cget -selectmode] eq "browse" ? "set" : "add"}] $args
		$w see [lindex $args 0]
	    }
	}

	"size" {
	    # Number of selected items
	    return [llength [$w selection]]
	}

	"toggle" {
	    # Toggle selection state of current item
	    if {[llength $args] == 0 && [$w focus] ne ""} {
		set args [list [$w focus]]
	    }
	    $w selection toggle $args
	    $w see [lindex $args 0]
	}

	"unselect" {
	    # Unselect current active item or list of items
	    if {[llength $args] == 0 && [$w focus] ne ""} {
		set args [list [$w focus]]
	    }
	    if {[llength $args] > 0} {
		$w selection remove $args
		$w see [lindex $args 0]
	    }
	}
    }
}

#
# Select all tree items
#
# Args: w = Treeview widget
#	parent = Parent of items to recursively select
# Returns: nothing
#
proc ::treeviewlib::SelectAllRecursive {w parent} {
    set items [$w children $parent]
    $w selection add $items
    foreach item $items {
	set sublist [$w children $item]
	if {[llength $sublist] > 0} {
	    SelectAllRecursive $w $item
	}
    }
}

###############################################################################
# Column Hide Functions
###############################################################################

#
# Hide columns
#
# Args: w = Treeview widget
#	args = Column ids to hide
# Returns: nothing
#
proc ::treeviewlib::ColumnHide {w args} {
    # Get current columns
    set columns [$w cget -displaycolumns]
    if {[lindex $columns 0] eq "#all"} {
	set columns [$w cget -columns]
    }

    # Remove from displayed columns list
    foreach column $args {
	if {$column eq "#0"} continue
	if {[set index [lsearch $columns [$w column $column -id]]] > -1} {
	    set columns [lreplace $columns $index $index]
	}
    }
    $w configure -displaycolumns $columns
}

#
# Show columns
#
# Args: w = Treeview widget
#	args = Column ids to show
# Returns: nothing
#
proc ::treeviewlib::ColumnShow {w args} {
    # Get current columns
    set columns [$w cget -columns]
    set displaycolumns [$w cget -displaycolumns]
    if {[lindex $displaycolumns 0] eq "#all"} {
	return
    }

    # Add to displayed columns list
    foreach column $args {
	if {$column eq "#0"} continue
	set column [$w column $column -id]
	if {$column in $columns && $column ni $displaycolumns} {
	    set index end
	    foreach temp [lrange $columns [expr {[lsearch $columns $column] + 1}] end] {
		if {$temp in $displaycolumns} {
		    set index [lsearch $displaycolumns $temp]
		    break
		}
	    }
	    set displaycolumns [linsert $displaycolumns $index $column]
	}
    }
    $w configure -displaycolumns $displaycolumns
}

###############################################################################
# Column Menu Functions
###############################################################################

#
# Handler for pop-up menus to store selected column
#
# Args: w = Treeview widget
#	m = Menu widget
#	X = Root window x coord for popup menu position
#	Y = Root window y coord for popup menu position
#	x = X coord of mouse pointer in widget
#	y = Y coord of mouse pointer in widget
# Returns: nothing
#
proc ::treeviewlib::post_menu {w m X Y x y} {
    if {[$w identify region $x $y] ne "heading"} return
    variable column [$w column [$w identify column $x $y] -id]

    # Post menu
    tk_popup $m $X $Y
    return -code break
}

#
# Callback for pop-up menu items
#
# Args: w = Treeview widget
#	fn = Function to perform
# Returns: nothing
#
proc ::treeviewlib::menu_callback {w fn} {
    variable column

    switch -- $fn {
	"autosize" {
	    # Auto size column to fit data
	    ColumnAutoSize $w [list $column]
	}

	"autosize_all" {
	    # Auto size all columns to fit data
	    ColumnAutoSize $w
	}

	"hide" {
	    # Hide current column
	    ColumnHide $w $column
	}

	"move_left" - "move_right" {
	    # Move column left or right
	    set incr [expr {$fn eq "move_left" ? -1 : 1}]
	    set columns [$w cget -displaycolumns]
	    if {$columns eq "#all"} {
		set columns [$w cget -columns]
	    }
	    set index [lsearch $columns $column]
	    set new [lindex $columns [incr index $incr]]
	    if {$new ne "" && $column ne $new} {
		MoveColumn $w $column $new
	    }
	}

	"show" {
	    # Show hidden column
	    # Get list of hidden columns
	    set display [$w cget -displaycolumns]
	    if {$display eq "#all"} {
		return
	    }

	    # Create menu
	    set m $w.column_show
	    if {![winfo exists $m]} {
		set m [menu $m -tearoff 0]
	    } else {
		$m delete 0 end
	    }

	    # Add columns to menu
	    set count 0
	    foreach col [$w cget -columns] {
		if {$col ni $display} {
		    $m add command -background white -label [$w heading $col -text] -command [list ::treeviewlib::ColumnShow $w $col]
		    incr count
		}
	    }

	    # Post menu
	    if {$count > 0} {
		tk_popup $m [winfo pointerx $w] [winfo pointery $w]
	    }
	}
    }
}

###############################################################################
# Column Move Functions
###############################################################################

#
# Start potential column move
#
# Args: w = Treeview widget
#	x = X coord of mouse pointer in widget
#	y = Y coord of mouse pointer in widget
# Returns: nothing
#
proc ::treeviewlib::MoveColumnPress {w x y} {
    variable moveColumn

    if {[$w identify region $x $y] eq "heading"} {
	set moveColumn [$w column [$w identify column $x $y] -id]
    }
}

#
# Column move in progress
#
# Args: w = Treeview widget
#	x = X coord of mouse pointer in widget
#	y = Y coord of mouse pointer in widget
# Returns: nothing
#
proc ::treeviewlib::MoveColumnDrag {w x y} {
    variable moveColumn
    variable cursor

    if {$moveColumn ne "" && $cursor eq "" && [$w identify region $x $y] eq "heading"} {
	if {$moveColumn ne [$w column [$w identify column $x $y] -id]} {
	    set cursor [$w cget -cursor]
	    if {$cursor eq ""} {set cursor " "}
	    if {[tk windowingsystem] ne "aqua"} {
		$w configure -cursor fleur
	    } else {
		$w configure -cursor closedhand
	    }
	}
    }
}

#
# Column move finished
#
# Args: w = Treeview widget
#	x = X coord of mouse pointer in widget
#	y = Y coord of mouse pointer in widget
# Returns: nothing
#
proc ::treeviewlib::MoveColumnRelease {w x y} {
    variable moveColumn
    variable cursor

    # Move column
    if {$moveColumn ne "" && [$w identify region $x $y] eq "heading"} {
	set column [$w column [$w identify column $x $y] -id]
	if {$column ne "" && $moveColumn ne $column} {
	    MoveColumn $w $moveColumn $column
	    $w heading $column state !active
	}
    }
    set moveColumn ""

    # Restore cursor
    if {$cursor ne ""} {
	$w configure -cursor [string trim $cursor]
	set cursor ""
    }
}

#
# Move column
#
# Args: w = Treeview widget
#	sourceColumn = Id if column to move
#	targetColumn = Id of column to insert before
# Returns: nothing
#
proc ::treeviewlib::MoveColumn {w sourceColumn targetColumn} {
    # Get column order
    set columns [$w cget -displaycolumns]
    if {$columns eq "#all"} {
	set columns [$w cget -columns]
    }

    # Reorder columns
    set from [lsearch $columns $sourceColumn]
    set to [lsearch $columns $targetColumn]
    if {$from > -1 && $to > -1} {
	$w configure -displaycolumns [linsert [lreplace $columns $from $from] $to $sourceColumn]
    } else {
	return -code error "Invalid column specified"
    }
}

###############################################################################
# Column Resize Functions
###############################################################################

#
# Auto size columns based on the data
#
# Args: w = Treeview widget
# Returns: nothing
# Effects: Updates column sizes
#
proc ::treeviewlib::ColumnAutoSize {w {columns {}}} {
    # Default is all columns
    if {[llength $columns] == 0} {
	set columns [concat [list #0] [$w cget -columns]]
    }

    # Normalize column names
    set names [list]
    foreach column $columns {
	if {$column ne "#0"} {
	    lappend names [$w column $column -id]
	} else {
	    lappend names $column
	}
    }
    set columns $names

    # Heading font
    #set font [ttk::style configure Heading -font]
    set font [ttk::style lookup Heading -font]
    if {$font eq ""} {set font TkHeadingFont}

    # Heading pad
    lassign [ttk::style configure Heading -padding] left top right bottom
    if {$left == ""} {set left 5}
    if {$right == 0 || $right eq ""} {set right $left}
    foreach var [list left top right bottom] {
	if {[set $var] eq ""} {set $var 0}
	set $var [winfo pixels $w [set $var]]
    }

    # Get heading widths (text, image, and pad)
    foreach column $columns {
	set width [font measure $font -displayof $w [$w heading $column -text]]
	if {[set img [$w heading $column -image]] ne ""} {
	    incr width [image width $img]
	}
	dict set hwidths $column [expr {$width + $left + $right}]
    }

    # Cell font
    #set font [ttk::style configure Treeview -font]
    set font [ttk::style lookup Treeview -font]
    if {$font eq ""} {set font TkDefaultFont}

    # Cell pad
    lassign [ttk::style configure Item -padding] left top right bottom
    if {$left == ""} {set left 4}
    if {$right == 0 || $right eq ""} {set right $left}
    foreach var [list left top right bottom] {
	if {[set $var] eq ""} {set $var 0}
	set $var [winfo pixels $w [set $var]]
    }

    # Column #0 indent and indicator size
    set indent [ttk::style configure Treeview -indent]
    if {$indent eq ""} {set indent 20}
    set indent [winfo pixels $w $indent]
    set indicator 18

    # Get data widths and set column to max width
    dict for {column width} [ColumnAutoSizeRecursive $w {} $columns 1 $indent $font] {
	# Apply padding
	    set width [expr {$width + $left + $right}]
	if {$column eq "#0"} {
	    incr width $indicator
	}

	# Honnor min column width, if any
	set min [$w column $column -minwidth]
	if {$min > $width} {
	    set width $min
	}

	# Resize to fit column header  
	set hdr [dict get $hwidths $column]
	if {$hdr > $width} {
	    set width $hdr
	}
	$w column $column -width $width
    }
}

#
# Recursively get column widths
#
# Args: w = Treeview widget
#	parent = Parent of items to use to calculate column sizes
#	columns = Columns to size
#	depth = Depth of child items for indent size
#	indent = Indent size of child items
#	font = Child item default font
# Returns: Column widths
#
proc ::treeviewlib::ColumnAutoSizeRecursive {w parent columns depth indent font} {
    foreach column $columns {
	dict set result $column 0
    }

    # Get widths
    foreach item [$w children $parent] {
	set cfont $font

	# Get font from tags
	foreach tag [$w item $item -tags] {
	    set f [$w tag configure $tag -font]
	    if {$f ne ""} {
		set cfont $f
	    }
	}

	# Measure column widths
	set values [$w set $item]
	foreach column $columns {
	    set width 0

	    # Get column value
	    if {$column ne "#0"} {
		set value [dict get $values $column]
	    } else {
		set value [$w item $item -text]
		incr width [expr {$depth * $indent}]
	    }
	    incr width [font measure $cfont -displayof $w $value]

	    # Store
	    if {$width > [dict get $result $column]} {
		dict set result $column $width
	    }
	}

	# Check child elements
	if {[llength [$w children $item]] > 0} {
	    dict for {column width} [ColumnAutoSizeRecursive $w $item $columns [expr {$depth + 1}] $indent $font] {
		if {$width > [dict get $result $column]} {
		    dict set result $column $width
		}
	    }
	}
    }
    return $result
}

###############################################################################
# Column Sort Functions
###############################################################################

#
# Sort widget using default column, order, and mode
#
# Args: w = Treeview widget
# Returns: nothing
#
proc ::treeviewlib::Sort {w} {
    SortByColumn $w {} {*}[SortInfo $w]
}

#
# Get sort info
#
# Args: w = Treeview widget
# Returns: sort column id, order, and mode
#
proc ::treeviewlib::SortInfo {w} {
    foreach column [concat [list #0] [$w cget -columns]] {
	set states [$w heading $column state]

	# Check if current sort column
	if {"alternate" in $states} {
	    return [list $column "decreasing" [lindex [$w heading $column -command] end]]
	} elseif {"selected" in $states} {
	    return [list $column "increasing" [lindex [$w heading $column -command] end]]
	}
    }
}

#
# Sort widget by column, order, and mode
#
# Args: w = Treeview widget
#	parent = Parent of items to sort. Defaults to root.
#	column = Sort column. Defaults to #0.
#	order = Sort order: increasing (default) or decreasing
#	mode = Sort mode type: ascii (default), dictionary, float, real
# Returns: nothing
#
proc ::treeviewlib::SortByColumn {w {parent {}} {column #0} {order increasing} {mode ascii}} {
    set columns [$w cget -columns]
    if {$column eq ""} return

    # Validate parent
    if {$parent ne "" && ![$w exists $parent]} {
	return -code error "Invalid parent node $parent"
    }

    # Get column id
    if {$column ne "#0" && [string is integer $column]} {
	set column [$w column $column -id]
    }

    # Validate order
    if {$order ni [list decreasing increasing]} {
	return -code error "Invalid order $order"
    }

    # Validate mode
    if {$mode ni [list ascii dictionary integer real]} {
	return -code error "Invalid mode $mode"
    }

    # Sort items
    SortRecursive $w $parent $column $order $mode

    # Show sort direction arrow in sort column
    SortDirection $w $parent $column $order $mode

    # Restripe
    Restripe $w $parent

    # Restore view to selection
    set sel [$w selection]
    if {[llength $sel] > 0} {
	$w see [lindex $sel 0]
    }
}

#
# Set column header sort direction arrow
#
# Args: w = Treeview widget
#	parent = Parent of items to sort
#	columnId = Sort column id (not index)
#	order = Sort order: increasing or decreasing
#	mode = Sort mode type: ascii, dictionary, float, real
# Returns: nothing
#
proc ::treeviewlib::SortDirection {w parent columnId order mode} {
    foreach column [concat [list #0] [$w cget -columns]] {
	set states [$w heading $column state]

	# Check if new or current sort column
	if {$column eq $columnId} {
	    # New sort column
	    if {$order eq "increasing"} {
		set img arrowUp
		set neworder "decreasing"
		set state [list selected !alternate]
	    } else {
		set img arrowDown
		set neworder "increasing"
		set state [list !selected alternate]
	    }

	    # Use user1 state for native sort arrows in Aqua theme displays
	    if {[ttk::style theme use] eq "aqua"} {
		set img arrowBlank
		lappend state user1
	    }

	    # Update column heading
	    $w heading $column -image ::treeviewlib::$img state $state \
		-command [list ::treeviewlib::SortByColumn $w $parent $column $neworder $mode]

	} elseif {"selected" in $states || "alternate" in $states} {
	    # Current sort column
	    set img arrowBlank
	    set neworder "increasing"
	    set state [list !selected !alternate !user1]

	    # Update column heading
	    $w heading $column -image ::treeviewlib::$img state $state \
		-command [lreplace [$w heading $column -command] 4 4 $neworder]
	}
    }
}

#
# Recursively sort data in tree
#
# Args: w = Treeview widget
#	parent = Parent of items to sort
#	columnId = Sort column id (not index)
#	order = Sort order: increasing or decreasing
#	mode = Sort mode type: ascii, dictionary, float, real
# Returns: nothing
#
proc ::treeviewlib::SortRecursive {w parent columnId order mode} {
    set data [list]
    set items [$w children $parent]
    if {[llength $items] == 0} return

    # Get data
    if {$columnId ne "#0"} {
	# Data column
	foreach item $items {
	    lappend data [list [$w set $item $columnId] $item]
	}
    } else {
	# Tree column
	foreach item $items {
	    lappend data [list [$w item $item -text] $item]
	}
    }

    # Sort data
    if {![catch {lsort -nocase -$mode -$order -index 0 $data} result]} {
	set data $result
    } else {
	# lsort can't handle empty or text elements for integer and real sorts, so use a
	# dictionary sort instead.
	set data [lsort -nocase -dictionary -$order -index 0 $data]
    }

    # Get new element order
    set new [list]
    foreach list $data {
        set item [lindex $list 1]
	lappend new $item

	# Sort child items
	SortRecursive $w $item $columnId $order $mode
	# Can do same as tablelist refreshsorting, and sort only when node is opened
    }

    # Update widget
    $w children $parent $new
}

#
# Sort data in tree for minor updates
#
# Args: w = Treeview widget
#	parent = Parent of items to sort. Defaults to root.
#	columnId = Sort column id (not index). Defaults to #0.
#	order = Sort order: increasing (default) or decreasing
#	mode = Sort mode type: ascii (default), dictionary, float, real
# Returns: nothing
#
proc ::treeviewlib::SortUpdate {w {parent {}} {columnId #0} {order increasing} {mode ascii}} {
    set data [list]
    set items [$w children $parent]
    if {[llength $items] == 0} return

    # Get data
    if {$columnId ne "#0"} {
	# Data column
	set colIndex [lsearch [$w cget -columns] $columnId]
	foreach item $items {
	    lappend data [list [lindex [$w item $item -values] $colIndex] $item]
	}
    } else {
	# Tree column
	foreach item $items {
	    lappend data [list [$w item $item -text] $item]
	}
    }
    set node [lindex [lindex $data 0] 1]

    # Sort data
    set i 0
    if {[catch {lsort -nocase -$mode -$order -index 0 $data} sdata]} {
	# Lsort can't handle empty elements for -integer and -real sorts
	set sdata [lsort -nocase -dictionary -$order -index 0 $data]
    }

    # Get new element order
    foreach list $sdata {
        set item [lindex $list 1]

	# Move item if its not next, otherwise get the next node
	if {$item ne $node} {
	    $w move $item $parent $i
	} else {
	    set node [$w next $node]
	    if {$node eq ""} break
	}
	incr i
    }

    # Restripe
    Restripe $w $parent
}

###############################################################################
# Row Filter Functions
###############################################################################

#
# Filter tree contents
#
# Args: w = Treeview widget
#	args = Filter criteria in column, operator, and value pairs
# Returns: Count of visible items after filter and total items
#
proc ::treeviewlib::Filter {w args} {
    upvar #0 ::treeviewlib::data$w cache
    set flist [list]

    # Cache selected items
    set sel [$w selection]

    # Cache ids
    if {![info exists cache]} {
	set cache [$w children {}]
    }
    set total [llength $cache]

    # Convert columns to index numbers
    set filters [list]
    set columns [$w cget -columns]
    foreach {column op value} $args {
	lappend filters [expr {$column ne "#0" ? [lsearch $columns [$w column $column -id]] : $column}] $op $value
    }

    # Loop through items and apply filters
    foreach item $cache {
	set values [$w item $item -values]
	set match 1

	# Apply filter criteria
	foreach {column op value} $filters {
	    set data [expr {$column ne "#0" ? [lindex $values $column] : [$w cget $item -text]}]
	    if {$op in [list "!=" "<" "<=" "==" ">" ">="]} {
		if {![string is double $value]} {
		    set match [string compare -nocase $data $value]
		    set match [expr [subst -novariables {$match [set op] 0}]]
		} else {
		    set match [expr [subst -novariables {$data [set op] $value}]]
		}

	    } elseif {$op eq "in"} {
		# In list
		set match [expr {$data in $value}]

	    } elseif {$op eq "ni"} {
		# Not in list
		set match [expr {$data ni $value}]

	    } else {
		# Begins with, ends with, contains, or their inverse (not)
		if {$op in [list "!start" "start"]} {
		    set pattern [string cat $value *]
		} elseif {$op in [list "!end" "end"]} {
		    set pattern [string cat * $value]
		} else {
		    set pattern [string cat * $value *]
		}
		set pattern [string map [list {[} {\[} {]} {\]}] $pattern]
		set match [string match -nocase $pattern $data]
		if {[string index $op 0] eq "!"} {
		    set match [expr {!$match}]
		}
	    }
	    if {!$match} break
	}

	# Store matches
	if {$match} {
	    lappend flist $item
	}
    }

    # Show filtered items
    $w children {} $flist

    # Add trace to clean-up on widget deletion
    trace add command $w delete [list ::treeviewlib::FilterDeleteHandler $w]

    # Resort
    Sort $w

    # Restripe
    Restripe $w {}

    # See first selected item
    foreach item $sel {
	if {$item in $flist} {
	    $w see $item
	    break
	}
    }
    return [list [llength $flist] $total]
}

#
# Handler for widget deletions to cleanup stored data
#
# Args: w = Treeview widget
#	oldName = Old command name
#	newName = New command name
#	op = Operation that triggered this callback
# Returns: nothing
#
proc ::treeviewlib::FilterDeleteHandler {w oldName newName op} {
    if {$op eq "delete"} {
	unset -nocomplain ::treeviewlib::data$w
    } else {
	set ::treeviewlib::data$newName [set ::treeviewlib::data$w]
	unset ::treeviewlib::data$w
    }
}

#
# Clear filters and show all data
#
# Args: w = Treeview widget
# Returns: nothing
# Effects: Removes any filters
#
proc ::treeviewlib::FilterClear {w} {
    upvar #0 ::treeviewlib::data$w cache
    if {![info exists cache]} return

    # Cache selected items
    set sel [$w selection]

    # Restore all items
    $w children {} $cache

    # Remove trace to clean-up on widget deletion
    trace remove command $w delete [list ::treeviewlib::FilterDeleteHandler $w]
    unset -nocomplain ::treeviewlib::data$w

    # Resort
    Sort $w

    # Restripe
    Restripe $w {}

    # See first selected item
    foreach item $sel {
	$w see $item
	break
    }
}

#
# To do: Apply filter to append, clear, delete, and insert operations
#

###############################################################################
# Row Move Functions
###############################################################################

#
# Start potential row move
#
# Args: w = Treeview widget
#	x = X coord of mouse pointer in widget
#	y = Y coord of mouse pointer in widget
# Returns: nothing
#
proc ::treeviewlib::MoveRowPress {w x y} {
    variable moveItem

    if {[$w identify region $x $y] eq [list "cell" "tree"]} {
	set moveItem [$w identify item $x $y]
    }
}

#
# Change cursor for row move
#
# Args: w = Treeview widget
#	x = X coord of mouse pointer in widget
#	y = Y coord of mouse pointer in widget
# Returns: nothing
#
proc ::treeviewlib::MoveRowDrag {w x y} {
    variable moveItem
    variable cursor

    if {$moveItem ne "" && $cursor eq "" && [$w identify region $x $y] in [list "cell" "tree"]} {
	if {$moveItem ne [$w column [$w identify column $x $y] -id]} {
	    set cursor [$w cget -cursor]
	    if {$cursor eq ""} {set cursor " "}
	    if {[tk windowingsystem] ne "aqua"} {
		$w configure -cursor fleur
	    } else {
		$w configure -cursor closedhand
	    }
	}
    }
}

#
# Complete row move
#
# Args: w = Treeview widget
#	x = X coord of mouse pointer in widget
#	y = Y coord of mouse pointer in widget
# Returns: nothing
#
proc ::treeviewlib::MoveRowRelease {w x y} {
    variable moveItem
    variable cursor

    # Move row
    if {$moveItem ne "" && [$w identify region $x $y] in [list "cell" "tree"]} {
	set item [$w identify item $x $y]
	if {$item ne "" && $moveItem ne $item} {
	    MoveRow $w [$w parent $item] [$w index $item] [list $item]
	}
    }
    set moveItem ""

    # Restore cursor
    if {$cursor ne ""} {
	$w configure -cursor [string trim $cursor]
	set cursor ""
    }
}

#
# Move row
#
# Args: w = Treeview widget
#	parent = Parent item to move items to
#	index = Index in parent to moves items to
#	items = Item ids to move
# Returns: nothing
#
proc ::treeviewlib::MoveRow {w parent index items} {
    foreach item $items {
	set idx [$w index $item]
	$w move $item $parent $index
	if {[string is integer $index] && $index < $idx} {
	    incr index
	}
    }

    # Restripe
    if {$parent eq ""} {
	Restripe $w $parent
    }
}

###############################################################################
# Row Resize Functions
###############################################################################

#
# Resize row to fit contents. WARNING: This affects all treeview widgets.
#
# Args: w = Treeview widget
# Returns: nothing
# Effects: Resizes rows in all treeview widgets
#
proc ::treeviewlib::RowAutoSize {w} {
    set top [winfo toplevel $w]
    set pad 8; # Row pad

    # Get widget font
    #set font [ttk::style configure Treeview -font]
    set font [ttk::style lookup Treeview -font]
    if {$font eq ""} {set font TkDefaultFont}

    # Get current row height
    set height [ttk::style configure Treeview -rowheight]
    if {$height eq ""} {
	set height [expr {[font metrics TkDefaultFont -linespace] + 4}]
    }

    # Check tags for fonts and get their height
    foreach tag [$w tag names] {
	set f [$w tag configure $tag -font]
	if {$f ne ""} {
	    set h [font metrics $f -displayof $top -linespace]
	    incr h $pad
	    if {$h > $height} {
		set height $h
	    }
	}
    }

    # Check data for newlines

    # Adjust height
    ttk::style configure Treeview -rowheight $height
}

###############################################################################
# Row Stripe Functions
###############################################################################

#
# Restripe tree
#
# Args: w = Treeview widget
#	parent = Parent of items to restripe
#	start = Starting index
# Returns: nothing
#
proc ::treeviewlib::Restripe {w {parent {}} {start {}}} {
    set alist [list]
    set rlist [list]
    set index 0
    set prev ""
    lassign [SortInfo $w] column order mode

    # Get items starting at index
    set items [$w children $parent]
    if {$start ne ""} {
	set index [$w index $start]
	set items [lrange $items $index end]
    }

    # Determine tag changes
    foreach item $items {
	set tags [$w item $item -tags]
	if {$column ne "" && $column ne "#0"} {
	    set value [$w set $item $column]
	    if {$prev eq $value} {
		incr index -1
	    } else {
		set prev $value
	    }
	}
	if {$index % 2} {
	    if {"stripe" ni $tags} {
		lappend alist $item
	    }
	} else {
	    if {"stripe" in $tags} {
		lappend rlist $item
	    }
	}
	incr index
    }

    # Update tags
    $w tag add stripe $alist
    $w tag remove stripe $rlist
}

#
# Cleanup Tags
#
# Args: w = Treeview widget
# Returns: nothing
#
proc ::treeviewlib::CleanupTags {w} {
    $w tag delete stripe
}

###############################################################################
# Cell Edit Functions
###############################################################################
# http://wiki.tcl.tk/23475