Tk Library Source Code

What is new in Tablelist 7.7?
-----------------------------

1. Added bindings that invoke "expand|collapse ... -fully" for the
   events <Control-Button-1> (over an expand/collapse control),
   <Control-Right|plus|KP_Add>, and <Control-Left|minus|KP_Subtract>
   (thanks to Torsten Berg for his proposal).

2. Added explicit support for the "droid" theme, which is the default in
   AndroWish.

3. Improvements related to the themes provided by the awthemes package
   and the ones that are not explicitly supported by Tablelist.

4. Improved the interactive cell editing with the aid of the
   toggleswitch widget.

5. The demo scripts "dirViewer.tcl" and "dirViewer_tile.tcl" now work
   around the fact that on Android the directory "/" is normally not
   readable.

What was new in Tablelist 7.6?
------------------------------

1. Added the "-button2window" configuration option, which makes it

        a tree widget, i.e., elides all their descendants.  The optional
        argument <code><b>-fully</b></code> (which is the default) indicates
        that the command will be performed recursively, i.e., all of the
        descendants of the nodes specified by <code><i>indexList</i></code>
        will be collapsed, so that a subsequent invocation of the non-recursive
        version of the <code><b><a href="#expand">expand(all)</a></b></code>
        subcommand will only display their children but no further descendants
        of them.&nbsp; The <code><b>-partly</b></code> option restricts the
        operation to just one hierarchy level, implying that by a subsequent
        invocation of the non-recursive version of the
        <code><b>expand(all)</b></code> subcommand exactly the same descendants
        will be displayed again that were visible prior to collapsing the
        rows.</dd>

        <dd class="tm">Before hiding the descendants of a row, the command
        specified as the value of the <code><b><a href=
        "#collapsecommand">-collapsecommand</a></b></code> option (if any) is
        automatically concatenated with the path name of the tablelist widget
        and the row index, and the resulting script is evaluated in the global
        scope.</dd>

        <i>indexList</i> ?<b>-fully</b>|<b>-partly</b>?</code></dt>

        <dd>This subcommand expands the specified rows of a tablelist used as a
        tree widget, i.e., makes all their children visible.&nbsp; The optional
        argument <code><b>-fully</b></code> (which is the default) indicates
        that the command will be performed recursively, i.e., all of the
        descendants of the nodes specified by <code><i>indexList</i></code>
        will be displayed.&nbsp; The <code><b>-partly</b></code> option
        restricts the operation to just one hierarchy level, indicating that
        only the children of the specified nodes will be displayed, without
        changing the expanded/collapsed state of the child nodes.</dd>


        <dd class="tm">Before displaying the children of a row, the command
        specified as the value of the <code><b><a href=
        "#expandcommand">-expandcommand</a></b></code> option (if any) is
        automatically concatenated with the path name of the tablelist widget
        and the row index, and the resulting script is evaluated in the global
        scope.&nbsp; This enables you to insert a tree node's children on

    <dd class="tm"><b>TREE WIDGET BINDINGS:</b>&nbsp; The following bindings
    associated with the binding tag <code><b>TablelistBody</b></code> apply to
    tablelists used as tree widgets:</dd>

    <dd>
      <ol>
        <li class="tm">Pressing mouse button 1 over an expand/collapse control
        toggles the expanded/collapsed state of the corresponding row by
        invoking the non-recursive version of the <code><b><a href=
        "#expand">expand</a></b></code> or <code><b><a href=
        "#collapse">collapse</a></b></code> subcommand (the one with the
        <code><b>-partly</b></code> argument).&nbsp; Pressing mouse button 1
        over an expand/collapse control with the <code>Control</code> key down
        toggles the expanded/collapsed state of the corresponding row with the
        aid of the <code><b>expand</b></code> or <code><b>collapse</b></code>
        subcommand's recursive version (the one with the
        <code><b>-fully</b></code> argument).</li>

        <li class="tm">If the current active row contains an expand/collapse
        control in collapsed state then the <code>Right</code>,
        <code>plus</code>, and <code>KP_Add</code> keys expand that row by
        invoking the non-recursive version of the <code><b>expand</b></code>
        subcommand, while <code>Control-Right</code>,
        <code>Control-plus</code>, and <code>Control-KP_Add</code> expand the
        row with the aid of the <code><b>expand</b></code> subcommand's
        recursive version.</li>

        <li class="tm">If the current active row contains an expand/collapse
        control in expanded state then the <code>Left</code>,
        <code>minus</code>, and <code>KP_Subtract</code> keys collapse that row
        by invoking the non-recursive version of the
        <code><b>collapse</b></code> subcommand, while
        <code>Control-Left</code>, <code>Control-minus</code>, and
        <code>Control-KP_Subtract</code> collapse the row with the aid of the
        <code><b>collapse</b></code> subcommand's recursive version.</li>
      </ol>
    </dd>

    <dt class="tm" id="header_bindings"><b>DEFAULT AND INDIVIDUAL BINDINGS FOR
    THE HEADER ITEMS</b></dt>

    <dd>The header items are contained in a text widget whose binding tag

	    set tablelist::priv(justClicked) 1
	    after 300 [list set tablelist::priv(justClicked) 0]
	    set tablelist::priv(clickedInEditWin) 0
	    if {[$tablelist::W cget -setfocus] &&
		[$tablelist::W cget -state] eq "normal"} {
		focus [$tablelist::W bodypath]
	    }
	    if {[tablelist::wasExpCollCtrlClicked %W %x %y <Button-1>]} {
		set tablelist::priv(clickedExpCollCtrl) 1
		tablelist::doFinishEditing $tablelist::W
	    } else {
		tablelist::condEditContainingCell $tablelist::W \
		    $tablelist::x $tablelist::y
		tablelist::condBeginMove $tablelist::W $tablelist::priv(row)
		tablelist::beginSelect $tablelist::W \

    bind TablelistBody <Control-Button-1> {
	foreach {tablelist::W tablelist::x tablelist::y} \
	    [tablelist::convEventFields %W %x %y] {}
	if {$tablelist::y < [winfo y [$tablelist::W bodypath]]} {
	    continue		;# on a vertical separator, outside the body
	}

	if {[tablelist::wasExpCollCtrlClicked %W %x %y <Control-Button-1>]} {
	    set tablelist::priv(clickedExpCollCtrl) 1
	    tablelist::condFinishEditing $tablelist::W \
		$tablelist::x $tablelist::y
	} else {
	    tablelist::beginToggle $tablelist::W \
		[$tablelist::W nearest       $tablelist::y] \
		[$tablelist::W nearestcolumn $tablelist::x]

	}
    }
    bind TablelistBody <Button-2> {
	tablelist::handleBtn2Event <Button-2> %W %x %y %X %Y
    }
    bind TablelistBody <B2-Motion> {
	tablelist::handleBtn2Event <B2-Motion> %W %x %y %X %Y
    }

    bind TablelistBody <Shift-Tab> {
	tablelist::nextPrevCell [tablelist::getTablelistPath %W] -1
    }
    bind TablelistBody <<PrevWindow>> {
	tablelist::nextPrevCell [tablelist::getTablelistPath %W] -1
    }
    bind TablelistBody <plus> {
	tablelist::plusMinus [tablelist::getTablelistPath %W] <plus>
    }
    bind TablelistBody <KP_Add> {
	tablelist::plusMinus [tablelist::getTablelistPath %W] <plus>
    }
    bind TablelistBody <minus> {
	tablelist::plusMinus [tablelist::getTablelistPath %W] <minus>
    }
    bind TablelistBody <KP_Subtract> {
	tablelist::plusMinus [tablelist::getTablelistPath %W] <minus>
    }
    bind TablelistBody <Control-plus> {
	tablelist::plusMinus [tablelist::getTablelistPath %W] <Control-plus>
    }
    bind TablelistBody <Control-KP_Add> {
	tablelist::plusMinus [tablelist::getTablelistPath %W] <Control-plus>
    }
    bind TablelistBody <Control-minus> {
	tablelist::plusMinus [tablelist::getTablelistPath %W] <Control-minus>
    }
    bind TablelistBody <Control-KP_Subtract> {
	tablelist::plusMinus [tablelist::getTablelistPath %W] <Control-minus>
    }

    foreach {virtual event} {
	PrevLine <Up>		 NextLine <Down>
	PrevChar <Left>		 NextChar <Right>
	LineStart <Home>	 LineEnd <End>
	PrevWord <Control-Left>	 NextWord <Control-Right>

    bind TablelistBody $eventArr(PrevLine) {
	tablelist::upDown [tablelist::getTablelistPath %W] -1
    }
    bind TablelistBody $eventArr(NextLine) {
	tablelist::upDown [tablelist::getTablelistPath %W] 1
    }
    bind TablelistBody $eventArr(PrevChar) {
	tablelist::leftRight [tablelist::getTablelistPath %W] <Left>
    }
    bind TablelistBody $eventArr(NextChar) {
	tablelist::leftRight [tablelist::getTablelistPath %W] <Right>
    }
    bind TablelistBody $eventArr(PrevWord) {
	tablelist::leftRight [tablelist::getTablelistPath %W] <Control-Left>
    }
    bind TablelistBody $eventArr(NextWord) {
	tablelist::leftRight [tablelist::getTablelistPath %W] <Control-Right>
    }
    bind TablelistBody <Prior> {
	tablelist::priorNext [tablelist::getTablelistPath %W] -1
    }
    bind TablelistBody <Next> {
	tablelist::priorNext [tablelist::getTablelistPath %W] 1
    }

		    $tablelist::W selection clear 0 end
		    tablelist::genTablelistSelectEvent $tablelist::W
		}
	    }
	}
    }


    foreach event {<Control-Prior> <Control-Next> <<Copy>>} {
	set script [string map {
	    "%W" "$tablelist::W"  "%x" "$tablelist::x"  "%y" "$tablelist::y"
	} [bind Listbox $event]]

	if {$script ne ""} {
	    ##nagelfar ignore
	    bind TablelistBody $event [format {

}

#------------------------------------------------------------------------------
# tablelist::wasExpCollCtrlClicked
#
# This procedure is invoked when mouse button 1 is pressed in the body of a
# tablelist widget or in one of its separators.  It checks whether the mouse
# click occurred inside an expand/collapse control, and if this was the case
# then it partially or fully expands or collapses the corresponding row.
#------------------------------------------------------------------------------
proc tablelist::wasExpCollCtrlClicked {w x y event} {
    foreach {win _x _y} [convEventFields $w $x $y] {}
    set row [containingRow $win $_y]
    set col [containingCol $win $_x]
    upvar ::tablelist::ns${win}::data data
    set key [lindex $data(keyList) $row]
    set indentLabel $data(body).ind_$key,$col
    if {![winfo exists $indentLabel]} {

    if {!$inExpCollCtrl || $data(isDisabled)} {
	return 0
    }

    #
    # Toggle the state of the expand/collapse control
    #
    set op  [expr {$mode eq "collapsed" ? "expand" : "collapse"}]
    set how [expr {$event eq "<Button-1>" ? "-partly" : "-fully"}]
    if {[::$win cget -showbusycursor]} { ::$win setbusycursor }

    ::$win $op $row $how				;# can take long



    ::$win restorecursor

    return 1
}

#------------------------------------------------------------------------------
# tablelist::condEditContainingCell

	doEditCell $win $row $col 0
    }
}

#------------------------------------------------------------------------------
# tablelist::plusMinus
#
# Partially or fully expands or collapses the active row if possible.
#------------------------------------------------------------------------------
proc tablelist::plusMinus {win event} {
    upvar ::tablelist::ns${win}::data data
    if {$data(isDisabled)} {
	return ""
    }

    set row $data(activeRow)
    set col $data(treeCol)
    set key [lindex $data(keyList) $row]
    set op ""

    if {[info exists data($key,$col-indent)]} {
	set indentLabel $data(body).ind_$key,$col
	set imgName [$indentLabel cget -image]
	if {[regexp {^tablelist_(.+)_(collapsed|expanded).*Img$} \
		     $imgName dummy treeStyle mode]} {
	    if {[string match "*plus>" $event] && $mode eq "collapsed"} {
		set op "expand"
	    } elseif {[string match "*minus>" $event] && $mode eq "expanded"} {
		set op "collapse"
	    }
	}
    }

    if {$op ne ""} {
	#
	# Toggle the state of the expand/collapse control
	#
	set how [expr {[string match "<Control-*>" $event] ?
		       "-fully" : "-partly"}]
	if {[::$win cget -showbusycursor]} { ::$win setbusycursor }
	::$win $op $row $how				;# can take long
	::$win restorecursor
    }
}

#------------------------------------------------------------------------------
# tablelist::nextPrevCell
#

	}
    }
}

#------------------------------------------------------------------------------
# tablelist::leftRight
#
# Partially or fully expands or collapses the active row if possible.
# Otherwise, the procedure scrolls the widget horizontally by one unit or page,

# or moves the active element left or right by one column and changes the
# selection if we are in browse or extended selection mode.
#------------------------------------------------------------------------------
proc tablelist::leftRight {win event} {
    upvar ::tablelist::ns${win}::data data
    set row $data(activeRow)
    set col $data(treeCol)
    set key [lindex $data(keyList) $row]
    set op ""

    if {[info exists data($key,$col-indent)] && !$data(isDisabled)} {
	set indentLabel $data(body).ind_$key,$col
	set imgName [$indentLabel cget -image]
	if {[regexp {^tablelist_(.+)_(collapsed|expanded).*Img$} \
		     $imgName dummy treeStyle mode]} {
	    if {[string match "*Right>" $event] && $mode eq "collapsed"} {
		set op "expand"
	    } elseif {[string match "*Left>" $event] && $mode eq "expanded"} {
		set op "collapse"
	    }
	}
    }

    if {$op eq ""} {
	set amount [expr {[string match "*Right>" $event] ? 1 : -1}]

	if {[string match "<Control-*>" $event]} {
	    ::$win xview scroll $amount pages
	} else {
	    switch $data(-selecttype) {
		row {
		    ::$win xview scroll $amount units
		}

		cell {
		    if {$data(editRow) >= 0} {
			return ""
		    }

		    set col $data(activeCol)
		    while 1 {
			incr col $amount
			if {$col < 0 || $col > $data(lastCol)} {
			    return ""
			} elseif {!$data($col-hide)} {
			    condChangeSelection $win $row $col
			    return ""
			}
		    }
		}
	    }
	}
    } else {
	#
	# Toggle the state of the expand/collapse control
	#
	set how [expr {[string match "<Control-*>" $event] ?
		       "-fully" : "-partly"}]
	if {[::$win cget -showbusycursor]} { ::$win setbusycursor }
	::$win $op $row $how				;# can take long
	::$win restorecursor
    }
}

#------------------------------------------------------------------------------
# tablelist::priorNext
#