diff options
Diffstat (limited to 'libgui/library/panedwindow.tcl')
| -rw-r--r-- | libgui/library/panedwindow.tcl | 851 |
1 files changed, 851 insertions, 0 deletions
diff --git a/libgui/library/panedwindow.tcl b/libgui/library/panedwindow.tcl new file mode 100644 index 00000000000..9593432c243 --- /dev/null +++ b/libgui/library/panedwindow.tcl @@ -0,0 +1,851 @@ +# +# Panedwindow +# ---------------------------------------------------------------------- +# Implements a very general panedwindow which allows for mixing resizable +# and non-resizable panes. It also allows limits to be set on individual +# pane sizes, both minimum and maximum. +# +# The look of this widget is much like Window, instead of the Motif-like +# iwidget panedwindow. +# ---------------------------------------------------------------------- + +# Portions of this code are originally from the iwidget panedwindow which +# is Copyright (c) 1995 DSC Technologies Corporation + +itk::usual PanedWindow { + keep -background -cursor +} + +# ------------------------------------------------------------------ +# PANEDWINDOW +# ------------------------------------------------------------------ +class cyg::PanedWindow { + inherit itk::Widget + + constructor {args} {} + + itk_option define -orient orient Orient horizontal + itk_option define -sashwidth sashWidth SashWidth 10 + itk_option define -sashcolor sashColor SashColor gray + + public { + method index {index} + method childsite {args} + method fraction {percentage1 percentage2 args} + method add {tag args} + method insert {index tag args} + method delete {index} + method hide {index} + method replace {pane1 pane2} + method show {index} + method paneconfigure {index args} + method reset {} + } + + private { + method _eventHandler {width height} + method _startDrag {num} + method _endDrag {where num} + method _configDrag {where num} + method _handleDrag {where num} + method _moveSash {where num} + + method _resizeArray {} + method _setActivePanes {} + method _caclPos {where num} + method _makeSashes {} + method _placeSash {i} + method _placePanes {{start 0} {end end} {forget 0}} + + variable _initialized 0 ;# flag set when widget is first configured + variable _sashes {} ;# List of sashes. + + # Pane information + variable _panes {} ;# List of panes. + variable _activePanes {} ;# List of active panes. + variable _where ;# Array of relative positions + variable _ploc ;# Array of pixel positions + variable _frac ;# Array of relative pane sizes + variable _pixels ;# Array of sizes in pixels for non-resizable panes + variable _max ;# Array of pane maximum locations + variable _min ;# Array of pane minimum locations + variable _pmin ;# Array of pane minimum size + variable _pmax ;# Array of pane maximum size + + variable _dimension 0 ;# width or height of window + variable _dir "height" ;# resizable direction, "height" or "width" + variable _rPixels + + variable _sashloc ;# Array of dist of sash from above/left. + + variable _minsashmoved ;# Lowest sash moved during dragging. + variable _maxsashmoved ;# Highest sash moved during dragging. + + variable _width 0 ;# hull's width. + variable _height 0 ;# hull's height. + variable _unique -1 ;# Unique number for pane names. + } +} + +# +# Provide a lowercased access method for the PanedWindow class. +# +proc ::cyg::panedwindow {pathName args} { + uplevel ::cyg::PanedWindow $pathName $args +} + +# +# Use option database to override default resources of base classes. +# +option add *PanedWindow.width 10 widgetDefault +option add *PanedWindow.height 10 widgetDefault + +# ------------------------------------------------------------------ +# CONSTRUCTOR +# ------------------------------------------------------------------ +body cyg::PanedWindow::constructor {args} { + itk_option add hull.width hull.height + + pack propagate $itk_component(hull) no + + bind pw-config-$this <Configure> [code $this _eventHandler %w %h] + bindtags $itk_component(hull) \ + [linsert [bindtags $itk_component(hull)] 0 pw-config-$this] + + eval itk_initialize $args +} + +# ------------------------------------------------------------------ +# OPTIONS +# ------------------------------------------------------------------ + +# ------------------------------------------------------------------ +# OPTION: -orient +# +# Specifies the orientation of the sashes. Once the paned window +# has been mapped, set the sash bindings and place the panes. +# ------------------------------------------------------------------ +configbody cyg::PanedWindow::orient { + #puts "orient $_initialized" + if {$_initialized} { + set orient $itk_option(-orient) + if {$orient != "vertical" && $orient != "horizontal"} { + error "bad orientation option \"$itk_option(-orient)\":\ + should be horizontal or vertical" + } + if {[string compare $orient "vertical"]} { + set _dimension $_height + set _dir "height" + } else { + set _dimension $_width + set _dir "width" + } + _resizeArray + _makeSashes + _placePanes 0 end 1 + } +} + +# ------------------------------------------------------------------ +# OPTION: -sashwidth +# +# Specifies the width of the sash. +# ------------------------------------------------------------------ +configbody cyg::PanedWindow::sashwidth { + set pixels [winfo pixels $itk_component(hull) $itk_option(-sashwidth)] + set itk_option(-sashwidth) $pixels + + if {$_initialized} { + # FIXME + for {set i 1} {$i < [llength $_panes]} {incr i} { + $itk_component(sash$i) configure \ + -width $itk_option(-sashwidth) -height $itk_option(-sashwidth) \ + -borderwidth 2 + } + for {set i 1} {$i < [llength $_panes]} {incr i} { + _placeSash $i + } + } +} + +# ------------------------------------------------------------------ +# OPTION: -sashcolor +# +# Specifies the color of the sash. +# ------------------------------------------------------------------ +configbody cyg::PanedWindow::sashcolor { + if {$_initialized} { + for {set i 1} {$i < [llength $_panes]} {incr i} { + $itk_component(sash$i) configure -background $itk_option(-sashcolor) + } + } +} + +# ------------------------------------------------------------------ +# METHODS +# ------------------------------------------------------------------ + +# ------------------------------------------------------------------ +# METHOD: index index +# +# Searches the panes in the paned window for the one with the +# requested tag, numerical index, or keyword "end". Returns the pane's +# numerical index if found, otherwise error. +# ------------------------------------------------------------------ +body cyg::PanedWindow::index {index} { + if {[llength $_panes] > 0} { + if {[regexp {(^[0-9]+$)} $index]} { + if {$index < [llength $_panes]} { + return $index + } else { + error "PanedWindow index \"$index\" is out of range" + } + } elseif {$index == "end"} { + return [expr [llength $_panes] - 1] + } else { + if {[set idx [lsearch $_panes $index]] != -1} { + return $idx + } + error "bad PanedWindow index \"$index\": must be number, end,\ + or pattern" + } + } else { + error "PanedWindow \"$itk_component(hull)\" has no panes" + } +} + +# ------------------------------------------------------------------ +# METHOD: childsite ?index? +# +# Given an index return the specifc childsite path name. Invoked +# without an index return a list of all the child site panes. The +# list is ordered from the near side (left/top). +# ------------------------------------------------------------------ +body cyg::PanedWindow::childsite {args} { + #puts "childsite $args ($_initialized)" + + if {[llength $args] == 0} { + set children {} + foreach pane $_panes { + lappend children [$itk_component($pane) childSite] + } + return $children + } else { + set index [index [lindex $args 0]] + return [$itk_component([lindex $_panes $index]) childSite] + } +} + + +# ------------------------------------------------------------------ +# METHOD: add tag ?option value option value ...? +# +# Add a new pane to the paned window to the far (right/bottom) side. +# The method takes additional options which are passed on to the +# pane constructor. These include -margin, and -minimum. The path +# of the pane is returned. +# ------------------------------------------------------------------ +body cyg::PanedWindow::add {tag args} { + itk_component add $tag { + eval cyg::Pane $itk_interior.pane[incr _unique] $args + } { + keep -background -cursor + } + + lappend _panes $tag + lappend _activePanes $tag + reset + return $itk_component($tag) +} + +# ------------------------------------------------------------------ +# METHOD: insert index tag ?option value option value ...? +# +# Insert the specified pane in the paned window just before the one +# given by index. Any additional options which are passed on to the +# pane constructor. These include -margin, -minimum. The path of +# the pane is returned. +# ------------------------------------------------------------------ +body cyg::PanedWindow::insert {index tag args} { + itk_component add $tag { + eval cyg::Pane $itk_interior.pane[incr _unique] $args + } { + keep -background -cursor + } + + set index [index $index] + set _panes [linsert $_panes $index $tag] + lappend _activePanes $tag + reset + return $itk_component($tag) +} + +# ------------------------------------------------------------------ +# METHOD: delete index +# +# Delete the specified pane. +# ------------------------------------------------------------------ +body cyg::PanedWindow::delete {index} { + set index [index $index] + set tag [lindex $_panes $index] + + # remove the itk component + destroy $itk_component($tag) + # remove it from panes list + set _panes [lreplace $_panes $index $index] + + # remove its _frac value + set ind [lsearch -exact $_activePanes $tag] + if {$ind != -1 && [info exists _frac($ind)]} { + unset _frac($ind) + } + + # this will reset _activePane and resize things + reset +} + +# ------------------------------------------------------------------ +# METHOD: hide index +# +# Remove the specified pane from the paned window. +# ------------------------------------------------------------------ +body cyg::PanedWindow::hide {index} { + set index [index $index] + set tag [lindex $_panes $index] + + if {[set idx [lsearch -exact $_activePanes $tag]] != -1} { + set _activePanes [lreplace $_activePanes $idx $idx] + if {[info exists _frac($idx)]} {unset _frac($idx)} + } + + reset +} + +body cyg::PanedWindow::replace {pane1 pane2} { + set ind1 [lsearch -exact $_activePanes $pane1] + if {$ind1 == -1} { + error "$pane1 is not an active pane name." + } + set ind2 [lsearch -exact $_panes $pane2] + if {$ind2 == -1} { + error "Pane $pane2 does not exist." + } + set _activePanes [lreplace $_activePanes $ind1 $ind1 $pane2] + _placePanes 0 $ind1 1 +} + +# ------------------------------------------------------------------ +# METHOD: show index +# +# Display the specified pane in the paned window. +# ------------------------------------------------------------------ +body cyg::PanedWindow::show {index} { + set index [index $index] + set tag [lindex $_panes $index] + + if {[lsearch -exact $_activePanes $tag] == -1} { + lappend _activePanes $tag + } + + reset +} + +# ------------------------------------------------------------------ +# METHOD: paneconfigure index ?option? ?value option value ...? +# +# Configure a specified pane. This method allows configuration of +# panes from the PanedWindow level. The options may have any of the +# values accepted by the add method. +# ------------------------------------------------------------------ +body cyg::PanedWindow::paneconfigure {index args} { + set index [index $index] + set tag [lindex $_panes $index] + return [uplevel $itk_component($tag) configure $args] +} + +# ------------------------------------------------------------------ +# METHOD: reset +# +# Redisplay the panes based on the default percentages of the panes. +# ------------------------------------------------------------------ +body cyg::PanedWindow::reset {} { + if {$_initialized && [llength $_panes]} { + #puts RESET + _setActivePanes + _resizeArray + _makeSashes + _placePanes 0 end 1 + } +} + +# ------------------------------------------------------------------ +# PRIVATE METHOD: _setActivePanes +# +# Resets the active pane list. +# ------------------------------------------------------------------ +body cyg::PanedWindow::_setActivePanes {} { + set _prevActivePanes $_activePanes + set _activePanes {} + + foreach pane $_panes { + if {[lsearch -exact $_prevActivePanes $pane] != -1} { + lappend _activePanes $pane + } + } +} + +# ------------------------------------------------------------------ +# PROTECTED METHOD: _eventHandler +# +# Performs operations necessary following a configure event. This +# includes placing the panes. +# ------------------------------------------------------------------ +body cyg::PanedWindow::_eventHandler {width height} { + #puts "Event $width $height" + set _width $width + set _height $height + if {[string compare $itk_option(-orient) "vertical"]} { + set _dimension $_height + set _dir "height" + } else { + set _dimension $_width + set _dir "width" + } + + if {$_initialized} { + _resizeArray + _placePanes + } else { + set _initialized 1 + reset + } +} + +# ------------------------------------------------------------------ +# PRIVATE METHOD: _resizeArray +# +# Recalculates the sizes and positions of all the panes. +# This is only done at startup, when the window size changes, when +# a new pane is added, or the orientation is changed. +# +# _frac($i) contains: +# % of resizable space when pane$i is resizable +# _pixels($i) contains +# pixels when pane$i is not resizable +# +# _where($i) contains the relative position of the top of pane$i +# ------------------------------------------------------------------ +body cyg::PanedWindow::_resizeArray {} { + set numpanes 0 + set _rPixels 0 + set totalFrac 0.0 + set numfreepanes 0 + + #puts "sresizeArray dim=$_dimension dir=$_dir" + + # first pass. Count the number of resizable panes and + # the pixels reserved for non-resizable panes. + set i 0 + foreach p $_activePanes { + set _resizable($i) [$itk_component($p) cget -resizable] + if {$_resizable($i)} { + # remember pane min and max + set _pmin($i) [$itk_component($p) cget -minimum] + set _pmax($i) [$itk_component($p) cget -maximum] + + incr numpanes + if {[info exists _frac($i)]} { + # sum up all the percents + set totalFrac [expr $totalFrac + $_frac($i)] + } else { + # number of new windows not yet sized + incr numfreepanes + } + } else { + set _pixels($i) [winfo req$_dir $itk_component($p)] + set _pmin($i) $_pixels($i) + set _pmax($i) $_pixels($i) + incr _rPixels $_pixels($i) + } + incr i + } + set totalpanes $i + + #puts "numpanes=$numpanes nfp=$numfreepanes _rPixels=$_rPixels totalFrac=$totalFrac" + + if {$numfreepanes} { + # set size for the new window(s) to average size + if {$totalFrac > 0.0} { + set freepanesize [expr $totalFrac / ($numpanes - $numfreepanes)] + } else { + set freepanesize [expr 1.0 / $numpanes.0] + } + for {set i 0} {$i < $totalpanes} {incr i} { + if {$_resizable($i) && ![info exists _frac($i)]} { + set _frac($i) $freepanesize + set totalFrac [expr $totalFrac + $_frac($i)] + } + } + } + + set done 0 + + while {!$done} { + # force to a reasonable value + if {$totalFrac <= 0.0} { set totalFrac 1.0 } + + # scale the _frac array + if {$totalFrac > 1.01 || $totalFrac < 0.99} { + set cor [expr 1.0 / $totalFrac] + set totalFrac 0.0 + for {set i 0} {$i < $totalpanes} {incr i} { + if {$_resizable($i)} { + set _frac($i) [expr $_frac($i) * $cor] + set totalFrac [expr $totalFrac + $_frac($i)] + } + } + } + + # bounds checking; look for panes that are too small or too large + # if one is found, fix its size at the min or max and mark the + # window non-resizable. Adjust percents and try again. + set done 1 + for {set i 0} {$i < $totalpanes} {incr i} { + if {$_resizable($i)} { + set _pixels($i) [expr int($_frac($i) * ($_dimension - $_rPixels.0))] + if {$_pixels($i) < $_pmin($i)} { + set _resizable($i) 0 + set totalFrac [expr $totalFrac - $_frac($i)] + set _pixels($i) $_pmin($i) + incr _rPixels $_pixels($i) + set done 0 + break + } elseif {$_pmax($i) && $_pixels($i) > $_pmax($i)} { + set _resizable($i) 0 + set totalFrac [expr $totalFrac - $_frac($i)] + set _pixels($i) $_pmax($i) + incr _rPixels $_pixels($i) + set done 0 + break + } + } + } + } + + # Done adjusting. Now build pane position arrays. These are designed + # to minimize calculations while resizing. + # Note: position of sash $i = position of top of pane $i + # _where($i): relative (0.0 - 1.0) position of sash $i + # _ploc($i): position in pixels of sash $i + # _max($i): maximum position in pixels of sash $i (0 = no max) + set _where(0) 0.0 + set _ploc(0) 0 + set _max(0) 0 + set _min(0) 0 + # calculate the percentage of resizable space + set resizePerc [expr 1.0 - ($_rPixels.0 / $_dimension)] + for {set i 1; set n 0} {$i < $totalpanes} {incr i; incr n} { + if {$_resizable($n)} { + set _where($i) [expr $_where($n) + ($_frac($n) * $resizePerc)] + } else { + set _where($i) [expr $_where($n) + [expr $_pixels($n).0 / $_dimension]] + } + set _ploc($i) [expr $_ploc($n) + $_pixels($n)] + if {$_pmax($n)} { + set _max($i) [expr $_max($n) + $_pmax($n)] + } else { + set _max($i) 0 + } + set _min($i) [expr $_min($n) + $_pmin($n)] + #puts "where($i)=$_where($i)" + #puts "ploc($i)=$_ploc($i)" + #puts "max($i)=$_max($i)" + #puts "min($i)=$_min($i)" + } + set _ploc($i) $_dimension + set _where($i) 1.0 +} + +# ------------------------------------------------------------------ +# PROTECTED METHOD: _startDrag num +# +# Starts the sash drag and drop operation. At the start of the drag +# operation all the information is known as for the upper and lower +# limits for sash movement. The calculation is made at this time and +# stored in protected variables for later access during the drag +# handling routines. +# ------------------------------------------------------------------ +body cyg::PanedWindow::_startDrag {num} { + #puts "startDrag $num" + + set _minsashmoved $num + set _maxsashmoved $num + + grab $itk_component(sash$num) +} + +# ------------------------------------------------------------------ +# PROTECTED METHOD: _endDrag where num +# +# Ends the sash drag and drop operation. +# ------------------------------------------------------------------ +body cyg::PanedWindow::_endDrag {where num} { + #puts "endDrag $where $num" + + grab release $itk_component(sash$num) + + # set new _frac values + for {set i [expr $_minsashmoved-1]} {$i <= $_maxsashmoved} {incr i} { + set _frac($i) \ + [expr ($_ploc([expr $i+1]).0 - $_ploc($i)) / ($_dimension - $_rPixels)] + } +} + +# ------------------------------------------------------------------ +# PROTECTED METHOD: _configDrag where num +# +# Configure action for sash. +# ------------------------------------------------------------------ +body cyg::PanedWindow::_configDrag {where num} { + set _sashloc($num) $where +} + +# ------------------------------------------------------------------ +# PROTECTED METHOD: _handleDrag where num +# +# Motion action for sash. +# ------------------------------------------------------------------ +body cyg::PanedWindow::_handleDrag {where num} { + #puts "handleDrag $where $num" + _moveSash [expr $where + $_sashloc($num)] $num + _placePanes [expr $_minsashmoved - 1] $_maxsashmoved +} + +# ------------------------------------------------------------------ +# PROTECTED METHOD: _moveSash where num +# +# Move the sash to the absolute pixel location +# ------------------------------------------------------------------ +body cyg::PanedWindow::_moveSash {where num} { + #puts "moveSash $where $num" + set _minsashmoved [expr ($_minsashmoved<$num)?$_minsashmoved:$num] + set _maxsashmoved [expr ($_maxsashmoved>$num)?$_maxsashmoved:$num] + _caclPos $where $num +} + + +# ------------------------------------------------------------------ +# PRIVATE METHOD: _caclPos where num +# +# Determines the new position for the sash. Make sure theposition does +# not go past the minimum for the pane on each side of the sash. +# ------------------------------------------------------------------ +body cyg::PanedWindow::_caclPos {where num} { + #puts "calcPos $num $where" + set dir [expr $where - $_ploc($num)] + if {$dir == 0} { return } + + # simplify expressions by computing these now + set m [expr $num-1] + set p [expr $num+1] + + # we have squeezed the pane below us to the limit + set lower1 [expr $_ploc($m) + $_pmin($m)] + set lower2 0 + if {$_pmax($num)} { + # we have stretched the pane above us to the limit + set lower2 [expr $_ploc($p) - $_pmax($num)] + } + + set upper1 9999 ;# just a large number + if {$_pmax($m)} { + # we have stretched the pane above us to the limit + set upper1 [expr $_ploc($m) + $_pmax($m)] + } + # we have squeezed the pane below us to the limit + set upper2 [expr $_ploc($p) - $_pmin($num)] + + set done 0 + + #puts "lower1=$lower1 lower2=$lower2 _min($num)=$_min($num)" + #puts "upper1=$upper1 upper2=$upper2 _max($num)=$_max($num)" + if {$dir < 0 && $where > $_min($num)} { + if {$where < $lower2} { + set done 1 + if {$p == [llength $_activePanes]} { + set _ploc($num) $upper2 + } else { + _moveSash [expr $where + $_pmax($num)] $p + set _ploc($num) [expr $_ploc($p) - $_pmax($num)] + } + } + if {$where < $lower1} { + set done 1 + if {$num == 1} { + set _ploc($num) $lower1 + } else { + _moveSash [expr $where - $_pmin($m)] $m + set _ploc($num) [expr $_ploc($m) + $_pmin($m)] + } + } + } elseif {$dir > 0 && ($_max($num) == 0 || $where < $_max($num))} { + if {$where > $upper1} { + set done 1 + if {$num == 1} { + set _ploc($num) $upper1 + } else { + _moveSash [expr $where - $_pmax($m)] $m + set _ploc($num) [expr $_ploc($m) + $_pmax($m)] + } + } + if {$where > $upper2} { + set done 1 + if {$p == [llength $_activePanes]} { + set _ploc($num) $upper2 + } else { + _moveSash [expr $where + $_pmin($num)] $p + set _ploc($num) [expr $_ploc($p) - $_pmin($num)] + } + } + } + + if {!$done} { + if {!($_max($num) > 0 && $where > $_max($num)) && $where >= $_min($num)} { + #puts "ploc($num)=$where" + set _ploc($num) $where + } + } + set _where($num) [expr $_ploc($num).0 / $_dimension] +} + +# ------------------------------------------------------------------ +# PRIVATE METHOD: _makeSashes +# +# Removes any previous sashes and creates new ones. +# ------------------------------------------------------------------ +body cyg::PanedWindow::_makeSashes {} { + # + # Remove any existing sashes. + # + foreach sash $_sashes { + destroy $itk_component($sash) + } + + set _sashes {} + set skipped_first 0 + # + # Create necessary number of sashes + # + for {set id 0} {$id < [llength $_activePanes]} {incr id} { + set p [lindex $_activePanes $id] + if {[$itk_component($p) cget -resizable]} { + if {$skipped_first == 0} { + # create the first sash when we see the 2nd resizable pane + incr skipped_first + } else { + # create sash + + itk_component add sash$id { + frame $itk_interior.sash$id -relief raised \ + -height $itk_option(-sashwidth) \ + -width $itk_option(-sashwidth) \ + -borderwidth 2 + } { + keep -background + } + lappend _sashes sash$id + + set com $itk_component(sash$id) + $com configure -background $itk_option(-sashcolor) + bind $com <Button-1> [code $this _startDrag $id] + + switch $itk_option(-orient) { + vertical { + bind $com <B1-Motion> \ + [code $this _handleDrag %x $id] + bind $com <B1-ButtonRelease-1> \ + [code $this _endDrag %x $id] + bind $com <Configure> \ + [code $this _configDrag %x $id] + # FIXME Windows should have a different cirsor + $com configure -cursor sb_h_double_arrow + } + + horizontal { + bind $com <B1-Motion> \ + [code $this _handleDrag %y $id] + bind $com <B1-ButtonRelease-1> \ + [code $this _endDrag %y $id] + bind $com <Configure> \ + [code $this _configDrag %y $id] + # FIXME Windows should have a different cirsor + $com configure -cursor sb_v_double_arrow + } + } + } + } + } +} + +# ------------------------------------------------------------------ +# PRIVATE METHOD: _placeSash i +# +# Places the position of the sash +# ------------------------------------------------------------------ +body cyg::PanedWindow::_placeSash {i} { + if {[string compare $itk_option(-orient) "vertical"]} { + place $itk_component(sash$i) -in $itk_component(hull) \ + -x 0 -relwidth 1 -rely $_where($i) -anchor w \ + -height $itk_option(-sashwidth) + } else { + place $itk_component(sash$i) -in $itk_component(hull) \ + -y 0 -relheight 1 -relx $_where($i) -anchor n \ + -width $itk_option(-sashwidth) + } +} + +# ------------------------------------------------------------------ +# PRIVATE METHOD: _placePanes +# +# Resets the panes of the window following movement of the sash. +# ------------------------------------------------------------------ +body cyg::PanedWindow::_placePanes {{start 0} {end end} {forget 0}} { + #puts "placeplanes $start $end" + if {$end=="end"} { set end [expr [llength $_activePanes] - 1] } + set _updatePanes [lrange $_activePanes $start $end] + + if {$forget} { + if {$_updatePanes == $_activePanes} { + set _forgetPanes $_panes + } else { + set _forgetPanes $_updatePanes + } + foreach pane $_forgetPanes { + place forget $itk_component($pane) + } + } + + if {[string compare $itk_option(-orient) "vertical"]} { + set i $start + foreach pane $_updatePanes { + place $itk_component($pane) -in $itk_component(hull) \ + -x 0 -rely $_where($i) -relwidth 1 \ + -relheight [expr $_where([expr $i + 1]) - $_where($i)] + incr i + } + } else { + set i $start + foreach pane $_updatePanes { + place $itk_component($pane) -in $itk_component(hull) \ + -y 0 -relx $_where($i) -relheight 1 \ + -relwidth [expr $_where([expr $i + 1]) - $_where($i)] + incr i + } + } + + for {set i [expr $start+1]} {$i <= $end} {incr i} { + if {[lsearch -exact $_sashes sash$i] != -1} { + _placeSash $i + } + } +} |