Changeset 13

trunk/gui/apps/driver

-                      r12
+                      r13
 package require Rappture
 option add *MainWin.mode desktop startupFile
+option add *MainWin.mode web startupFile
 option add *MainWin.borderWidth 0 startupFile
 option add *MainWin.anchor center startupFile
+option add *MainWin.anchor nw startupFile
 # "web site" look
 …
 option add *Gauge.textBackground white
 option add *TemperatureGauge.textBackground white
+option add *Switch.textBackground white
+#

trunk/gui/scripts/analyzer.tcl

-                      r12
+                      r13
+            }
+        }
+        set label [$xmlobj get output.$item.about.label]
+        set label [$xmlobj get output.$item.about.group]
+        if {"" == $label} {
+            set label [$xmlobj get output.$item.about.label]
+        }
         if {"" != $label} {
 …
     if {$haveresults} {
         set size [$itk_component(resultset) size]
         set op [$itk_component(resultset) add $xmlobj]
+        set index [$itk_component(resultset) add $xmlobj]
         # add each result to a result viewer
         foreach item [_reorder [$xmlobj children output]] {
+            set label [$xmlobj get output.$item.about.label]
+            set label [$xmlobj get output.$item.about.group]
+            if {"" == $label} {
+                set label [$xmlobj get output.$item.about.label]
+            }
             if {"" != $label} {
 …
                     $itk_component(resultselector) choices insert end \
                         $name $label
+                    #
-                    # NOTE:
+                    #
-                    # If this result is showing up late in the game, then
-                    # we must fill the resultviewer with a series of blank
-                    # entries, so the latest result will align with (have
-                    # the same index as) results in all other viewers.
+                    #
-                    for {set i 0} {$i < $size} {incr i} {
-                        $page.rviewer add $xmlobj ""
+                    }
+                }
                 # add/replace the latest result into this viewer
                 set page $_label2page($label)
+                eval $page.rviewer $op [list $xmlobj output.$item]
+                if {![info exists reset($page)]} {
+                    $page.rviewer clear $index
+                    set reset($page) 1
+                }
+                $page.rviewer add $index $xmlobj output.$item
+            }
+        }
 …
     set first [$itk_component(resultselector) choices get -label 0]
     if {$first != ""} {
+        $itk_component(resultpages) current page1
+        set page [$itk_component(resultselector) choices get -value 0]
+        $itk_component(resultpages) current $page
         $itk_component(resultselector) value $first
+    }
 …
     set _runs ""
+    $itk_component(resultset) clear
+    $itk_component(results) fraction end 0.1
     foreach label [array names _label2page] {
         set page $_label2page($label)
         $page.rviewer clear
+    }
+    $itk_component(resultset) clear
+    $itk_component(results) fraction end 0.1
+    $itk_component(resultselector) value ""
+    $itk_component(resultselector) choices delete 0 end
+    catch {unset _label2page}
+    set _plotlist ""
+    #
+    # HACK ALERT!!
+    # The following statement should be in place, but it causes
+    # vtk to dump core.  Leave it out until we can fix the core dump.
+    # In the mean time, we leak memory...
+    #
+    #$itk_component(resultpages) delete -all
+    #set _pages 0
     _simState on
 …
 # ----------------------------------------------------------------------
 # USAGE: _reorder
+# USAGE: _reorder <compList>
+#
 # Used internally to change the order of a series of output components
 …
     upvar $cntVar counters
+    set group [$xmlobj get $path.about.group]
     set label [$xmlobj get $path.about.label]
     if {"" == $label} {
         # no label -- make one up using the title specified
         if {![info exists counters($title)]} {
             set counters($title) 1
+        if {![info exists counters($group-$title)]} {
+            set counters($group-$title) 1
             set label $title
         } else {
             set label "$title #[incr counters($title)]"
+            set label "$title (#[incr counters($group-$title)])"
+        }
         $xmlobj put $path.about.label $label
     } else {
         # handle the case of two identical labels in <output>
         if {![info exists counters($label)]} {
             set counters($label) 1
+        if {![info exists counters($group-$label)]} {
+            set counters($group-$label) 1
         } else {
             set label "$label #[incr counters($label)]"
+            set label "$label (#[incr counters($group-$label)])"
             $xmlobj put $path.about.label $label
+        }
 …
     set page [$itk_component(resultselector) value]
     set page [$itk_component(resultselector) translate $page]
+    $itk_component(resultpages) current $page
+    set f [$itk_component(resultpages) page $page]
+    $f.rviewer plot clear
+    eval $f.rviewer plot add $_plotlist
+    if {$page != ""} {
+        $itk_component(resultpages) current $page
+        set f [$itk_component(resultpages) page $page]
+        $f.rviewer plot clear
+        eval $f.rviewer plot add $_plotlist
+    }
+}

trunk/gui/scripts/contourresult.tcl

-                      r11
+                      r13
     public method add {dataobj {settings ""}}
+    public method get {}
     public method delete {args}
     public method scale {args}
 …
             -command [itcl::code $this _zoom reset]
     } {
+        usual
         ignore -borderwidth
         rename -highlightbackground -controlbackground controlBackground Background
 …
             -command [itcl::code $this _zoom in]
     } {
+        usual
         ignore -borderwidth
         rename -highlightbackground -controlbackground controlBackground Background
 …
             -command [itcl::code $this _zoom out]
     } {
+        usual
         ignore -borderwidth
         rename -highlightbackground -controlbackground controlBackground Background
 …
 # Clients use this to add a data object to the plot.  The optional
 # <settings> are used to configure the plot.  Allowed settings are
 # -color, -width, and -raise.
+# -color, -brightness, -width, -linestyle, and -raise.
 # ----------------------------------------------------------------------
 itcl::body Rappture::ContourResult::add {dataobj {settings ""}} {
 …
         -color black
         -width 1
+        -linestyle solid
+        -brightness 0
         -raise 0
+    }
 …
         after idle [itcl::code $this _rebuild]
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: get
+#
+# Clients use this to query the list of objects being plotted, in
+# order from bottom to top of this result.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ContourResult::get {} {
+    # put the dataobj list in order according to -raise options
+    set dlist $_dlist
+    foreach obj $dlist {
+        if {[info exists _obj2raise($obj)] && $_obj2raise($obj)} {
+            set i [lsearch -exact $dlist $obj]
+            if {$i >= 0} {
+                set dlist [lreplace $dlist $i $i]
+                lappend dlist $obj
+            }
+        }
+    }
+    return $dlist
+}
 …
+    }
-    # put the dataobj list in order according to -raise options
-    set dlist $_dlist
-    foreach obj $dlist {
-        if {[info exists _obj2raise($obj)] && $_obj2raise($obj)} {
-            set i [lsearch -exact $dlist $obj]
-            if {$i >= 0} {
-                set dlist [lreplace $dlist $i $i]
-                lappend dlist $obj
+            }
+        }
+    }
     # scan through all data objects and build the contours
     set _counter 0
     foreach dataobj $dlist {
+    foreach dataobj [get] {
         foreach comp [$dataobj components] {
             set pd $this-polydata$_counter
 …
+        }
         drag {
+            set w [winfo width $itk_component(plot)]
+            set h [winfo height $itk_component(plot)]
+            set dx [expr {double($x-$_click(x))/$w}]
+            set dy [expr {double($y-$_click(y))/$h}]
+            foreach actor $_actors($this-ren) {
+                foreach {ax ay az} [$actor GetPosition] break
+                $actor SetPosition [expr {$ax+$dx}] [expr {$ay-$dy}] 0
+            if {[array size _click] == 0} {
+                _move click $x $y
+            } else {
+                set w [winfo width $itk_component(plot)]
+                set h [winfo height $itk_component(plot)]
+                set dx [expr {double($x-$_click(x))/$w}]
+                set dy [expr {double($y-$_click(y))/$h}]
+                foreach actor $_actors($this-ren) {
+                    foreach {ax ay az} [$actor GetPosition] break
+                    $actor SetPosition [expr {$ax+$dx}] [expr {$ay-$dy}] 0
+                }
+                $this-renWin Render
+                set _click(x) $x
+                set _click(y) $y
+            }
-            $this-renWin Render
-            set _click(x) $x
-            set _click(y) $y
+        }
         release {
             _move drag $x $y
             blt::busy configure $itk_component(area) -cursor left_ptr
+            catch {unset _click}
+        }
         default {

trunk/gui/scripts/controls.tcl

-                      r11
+                      r13
     itk_option define -padding padding Padding 0
     constructor {tool args} { # defined below }
+    constructor {owner args} { # defined below }
     public method insert {pos xmlobj path}
 …
     protected method _formatLabel {str}
     private variable _tool ""        ;# controls belong to this tool
+    private variable _owner ""       ;# controls belong to this owner
     private variable _counter 0      ;# counter for control names
     private variable _dispatcher ""  ;# dispatcher for !events
 …
 # CONSTRUCTOR
 # ----------------------------------------------------------------------
 itcl::body Rappture::Controls::constructor {tool args} {
+itcl::body Rappture::Controls::constructor {owner args} {
     Rappture::dispatcher _dispatcher
     $_dispatcher register !layout
     $_dispatcher dispatch $this !layout "[itcl::code $this _layout]; list"
     set _tool $tool
+    set _owner $owner
     eval itk_initialize $args
 …
+        }
         loader {
             Rappture::Loader $w $xmlobj $path -tool $_tool
+            Rappture::Loader $w $xmlobj $path -tool [$_owner tool]
             bind $w <<Value>> [itcl::code $this _controlChanged $path]
+        }
 …
             bind $w <<Value>> [itcl::code $this _controlChanged $path]
+        }
+        boolean {
+            Rappture::BooleanEntry $w $xmlobj $path
+            bind $w <<Value>> [itcl::code $this _controlChanged $path]
+        }
         string {
             Rappture::TextEntry $w $xmlobj $path
 …
+        }
+    }
     $_tool widgetfor $path $w
+    $_owner widgetfor $path $w
     # make a label for this control
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Controls::_controlChanged {path} {
     if {"" != $_tool} {
         $_tool changed $path
+    if {"" != $_owner} {
+        $_owner changed $path
+    }
+}

trunk/gui/scripts/curve.tcl

-                      r11
+                      r13
 itcl::body Rappture::Curve::hints {{keyword ""}} {
     foreach {key path} {
+        label   label
+        color   color
+        color   style
+        group   about.group
+        label   about.label
+        color   about.color
+        style   about.style
         xlabel  xaxis.label
         xunits  xaxis.units
 …
+    }
+    if {[info exists hints(group)] && [info exists hints(label)]} {
+        # pop-up help for each curve
+        set hints(tooltip) $hints(label)
+    }
     if {$keyword != ""} {
         if {[info exists hints($keyword)]} {

trunk/gui/scripts/deviceEditor.tcl

-                      r11
+                      r13
     inherit itk::Widget
     constructor {tool args} { # defined below }
+    constructor {owner args} { # defined below }
     public method value {args}
+    # used for syncing embedded widgets
+    public method widgetfor {path {widget ""}}
+    public method changed {path}
+    public method sync {}
+    public method tool {}
     protected method _redraw {}
     protected method _type {xmlobj}
     private variable _tool ""        ;# tool containing this editor
+    private variable _owner ""       ;# owner containing this editor
     private variable _xmlobj ""      ;# XML <structure> object
+    private variable _path2widget    ;# maps path => widget in this editor
+}
 …
 # CONSTRUCTOR
 # ----------------------------------------------------------------------
 itcl::body Rappture::DeviceEditor::constructor {tool args} {
     set _tool $tool
+itcl::body Rappture::DeviceEditor::constructor {owner args} {
+    set _owner $owner
     itk_option add hull.width hull.height
 …
         event generate $itk_component(hull) <<Value>>
+    } elseif {[llength $args] != 0} {
+    } elseif {[llength $args] == 0} {
+        sync  ;# querying -- must sync controls with the value
+    } else {
         error "wrong # args: should be \"value ?-check? ?newval?\""
+    }
     return $_xmlobj
+}
+# ----------------------------------------------------------------------
+# USAGE: widgetfor <path> ?<widget>?
+#
+# Used by embedded widgets such as a Controls panel to register the
+# various controls associated with this page.  That way, this editor
+# knows what widgets to look at when syncing itself to the underlying
+# XML data.
+# ----------------------------------------------------------------------
+itcl::body Rappture::DeviceEditor::widgetfor {path {widget ""}} {
+    # if this is a query operation, then look for the path
+    if {"" == $widget} {
+        if {[info exists _path2widget($path)]} {
+            return $_path2widget($path)
+        }
+        return ""
+    }
+    # otherwise, associate the path with the given widget
+    if {[info exists _path2widget($path)]} {
+        error "$path already associated with widget $_path2widget($path)"
+    }
+    set _path2widget($path) $widget
+}
+# ----------------------------------------------------------------------
+# USAGE: changed <path>
+#
+# Invoked automatically by the various widgets associated with this
+# editor whenever their value changes.  If this tool has a -analyzer,
+# then it is notified that input has changed, so it can reset itself
+# for a new analysis.
+# ----------------------------------------------------------------------
+itcl::body Rappture::DeviceEditor::changed {path} {
+    if {"" != $_owner} {
+        $_owner changed $path
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: sync
+#
+# Used by descendents such as a Controls panel to register the
+# various controls associated with this page.  That way, this Tool
+# knows what widgets to look at when syncing itself to the underlying
+# XML data.
+# ----------------------------------------------------------------------
+itcl::body Rappture::DeviceEditor::sync {} {
+    foreach path [array names _path2widget] {
+        $_xmlobj put $path.current [$_path2widget($path) value]
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: tool
+#
+# Clients use this to figure out which tool is associated with
+# this object.  Returns the tool containing this editor.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Tool::tool {} {
+    return [$_owner tool]
+}
 …
             if {[catch {$itk_component(editors) page molecule} p]} {
                 set p [$itk_component(editors) insert end molecule]
                 Rappture::MoleculeViewer $p.mol $_tool
+                Rappture::MoleculeViewer $p.mol $this
                 pack $p.mol -expand yes -fill both
+            }
 …
             if {[catch {$itk_component(editors) page device1D} p]} {
                 set p [$itk_component(editors) insert end device1D]
                 Rappture::DeviceViewer1D $p.dev $_tool
+                Rappture::DeviceViewer1D $p.dev $this
                 pack $p.dev -expand yes -fill both
+            }

trunk/gui/scripts/energyLevels.tcl

-                      r11
+                      r13
 option add *EnergyLevels.width 4i widgetDefault
 option add *EnergyLevels.height 4i widgetDefault
+option add *EnergyLevels.levelColor blue widgetDefault
+option add *EnergyLevels.levelTextForeground blue widgetDefault
+option add *EnergyLevels.levelTextBackground #d9d9d9 widgetDefault
+option add *EnergyLevels.padding 4 widgetDefault
+option add *EnergyLevels.controlBackground gray widgetDefault
+option add *EnergyLevels.shadeColor gray widgetDefault
+option add *EnergyLevels.levelColor black widgetDefault
+option add *EnergyLevels.levelTextForeground black widgetDefault
+option add *EnergyLevels.levelTextBackground white widgetDefault
 option add *EnergyLevels.font \
     -*-helvetica-medium-r-normal-*-*-120-* widgetDefault
+option add *EnergyLevels.detailFont \
+    -*-helvetica-medium-r-normal-*-*-100-* widgetDefault
+blt::bitmap define EnergyLevels-reset {
+#define reset_width 12
+#define reset_height 12
+static unsigned char reset_bits[] = {
+x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x04, 0x02, 0x04, 0x02, 0x04, 0x02,
+x04, 0x02, 0x04, 0x02, 0x04, 0x02, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00};
+}
+blt::bitmap define EnergyLevels-zoomin {
+#define zoomin_width 12
+#define zoomin_height 12
+static unsigned char zoomin_bits[] = {
+x7c, 0x00, 0x82, 0x00, 0x11, 0x01, 0x11, 0x01, 0x7d, 0x01, 0x11, 0x01,
+x11, 0x01, 0x82, 0x03, 0xfc, 0x07, 0x80, 0x0f, 0x00, 0x0f, 0x00, 0x06};
+}
+blt::bitmap define EnergyLevels-zoomout {
+#define zoomout_width 12
+#define zoomout_height 12
+static unsigned char zoomout_bits[] = {
+x7c, 0x00, 0x82, 0x00, 0x01, 0x01, 0x01, 0x01, 0x7d, 0x01, 0x01, 0x01,
+x01, 0x01, 0x82, 0x03, 0xfc, 0x07, 0x80, 0x0f, 0x00, 0x0f, 0x00, 0x06};
+}
+blt::bitmap define EnergyLevels-rdiag {
+#define rdiag_width 8
+#define rdiag_height 8
+static unsigned char rdiag_bits[] = {
+x66, 0x33, 0x99, 0xcc, 0x66, 0x33, 0x99, 0xcc};
+}
 itcl::class Rappture::EnergyLevels {
     inherit itk::Widget
     itk_option define -layout layout Layout ""
     itk_option define -output output Output ""
+    itk_option define -padding padding Padding 0
+    itk_option define -shadecolor shadeColor ShadeColor ""
     itk_option define -levelcolor levelColor LevelColor ""
     itk_option define -leveltextforeground levelTextForeground Foreground ""
 …
     constructor {args} { # defined below }
+    destructor { # defined below }
+    protected method _render {}
+    protected method _adjust {what val}
+    protected method _getColumn {name}
+    protected method _getUnits {name}
+    protected method _getMidPt {elist pos}
+    public proc columns {table}
+    public method add {table {settings ""}}
+    public method delete {args}
+    public method scale {args}
+    protected method _redraw {{what all}}
+    protected method _zoom {option args}
+    protected method _view {midE delE}
+    protected method _hilite {option args}
+    protected method _getLayout {}
+    private variable _dispatcher "" ;# dispatcher for !events
+    private variable _dlist ""     ;# list of data objects
+    private variable _dobj2color   ;# maps data obj => color option
+    private variable _dobj2raise   ;# maps data obj => raise option
+    private variable _dobj2cols    ;# maps data obj => column names
+    private variable _emin ""      ;# autoscale min for energy
+    private variable _emax ""      ;# autoscale max for energy
+    private variable _eviewmin ""  ;# min for "zoom" view
+    private variable _eviewmax ""  ;# max for "zoom" view
+    private variable _edefmin ""   ;# min for default "zoom" view
+    private variable _edefmax ""   ;# max for default "zoom" view
+    private variable _ehomo ""     ;# energy of HOMO level in topmost dataset
+    private variable _elumo ""     ;# energy of LUMO level in topmost dataset
+    private variable _hilite ""    ;# item currently highlighted
+}
 itk::usual EnergyLevels {
+    keep -background -foreground -cursor -font
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::EnergyLevels::constructor {args} {
+    Rappture::dispatcher _dispatcher
+    $_dispatcher register !redraw
+    $_dispatcher dispatch $this !redraw "[itcl::code $this _redraw all]; list"
+    $_dispatcher register !zoom
+    $_dispatcher dispatch $this !zoom "[itcl::code $this _redraw zoom]; list"
     itk_option add hull.width hull.height
     pack propagate $itk_component(hull) no
+    itk_component add controls {
+        frame $itk_interior.cntls
+    } {
+        usual
+        rename -background -controlbackground controlBackground Background
+    }
+    pack $itk_component(controls) -side right -fill y
+    itk_component add reset {
+        button $itk_component(controls).reset \
+            -borderwidth 1 -padx 1 -pady 1 \
+            -bitmap EnergyLevels-reset \
+            -command [itcl::code $this _zoom reset]
+    } {
+        usual
+        ignore -borderwidth
+        rename -highlightbackground -controlbackground controlBackground Background }
+    pack $itk_component(reset) -padx 4 -pady 4
+    Rappture::Tooltip::for $itk_component(reset) "Reset the view to the default zoom level"
+    itk_component add zoomin {
+        button $itk_component(controls).zin \
+            -borderwidth 1 -padx 1 -pady 1 \
+            -bitmap EnergyLevels-zoomin \
+            -command [itcl::code $this _zoom in]
+    } {
+        usual
+        ignore -borderwidth
+        rename -highlightbackground -controlbackground controlBackground Background
+    }
+    pack $itk_component(zoomin) -padx 4 -pady 4
+    Rappture::Tooltip::for $itk_component(zoomin) "Zoom in"
+    itk_component add zoomout {
+        button $itk_component(controls).zout \
+            -borderwidth 1 -padx 1 -pady 1 \
+            -bitmap EnergyLevels-zoomout \
+            -command [itcl::code $this _zoom out]
+    } {
+        usual
+        ignore -borderwidth
+        rename -highlightbackground -controlbackground controlBackground Background
+    }
+    pack $itk_component(zoomout) -padx 4 -pady 4
+    Rappture::Tooltip::for $itk_component(zoomout) "Zoom out"
+    #
     # Add label for the title.
 …
     pack $itk_component(title) -side top
+    itk_component add cntls {
+        frame $itk_interior.cntls
+    }
+    pack $itk_component(cntls) -side right -fill y
+    grid rowconfigure $itk_component(cntls) 0 -weight 1
+    grid rowconfigure $itk_component(cntls) 1 -minsize 10
+    grid rowconfigure $itk_component(cntls) 2 -weight 1
+    #
+    # Add MORE/FEWER levels control for TOP of graph
+    #
+    itk_component add upperE {
+        frame $itk_component(cntls).upperE
+    }
+    itk_component add upperEmore {
+        label $itk_component(upperE).morel -text "More"
+    #
+    # Add graph showing levels
+    #
+    itk_component add graph {
+        canvas $itk_interior.graph -highlightthickness 0
     } {
         usual
+        rename -font -detailfont detailFont Font
+    }
+    pack $itk_component(upperEmore) -side top
+    itk_component add upperEfewer {
+        label $itk_component(upperE).fewerl -text "Fewer"
+    } {
+        usual
+        rename -font -detailfont detailFont Font
+    }
+    pack $itk_component(upperEfewer) -side bottom
+    itk_component add upperEcntl {
+        scale $itk_component(upperE).cntl -orient vertical -showvalue 0 \
+            -command [itcl::code $this _adjust upper]
+    }
+    pack $itk_component(upperEcntl) -side top -fill y
+    #
+    # Add MORE/FEWER levels control for BOTTOM of graph
+    #
+    itk_component add lowerE {
+        frame $itk_component(cntls).lowerE
+    }
+    itk_component add lowerEmore {
+        label $itk_component(lowerE).morel -text "More"
+    } {
+        usual
+        rename -font -detailfont detailFont Font
+    }
+    pack $itk_component(lowerEmore) -side bottom
+    itk_component add lowerEfewer {
+        label $itk_component(lowerE).fewerl -text "Fewer"
+    } {
+        usual
+        rename -font -detailfont detailFont Font
+    }
+    pack $itk_component(lowerEfewer) -side top
+    itk_component add lowerEcntl {
+        scale $itk_component(lowerE).cntl -orient vertical -showvalue 0 \
+            -command [itcl::code $this _adjust lower]
+    }
+    pack $itk_component(lowerEcntl) -side top -fill y
+    #
+    # Add graph showing levels
+    #
+    itk_component add graph {
+        blt::graph $itk_interior.graph \
+            -highlightthickness 0 -plotpadx 0 -plotpady 0 \
+            -width 3i -height 3i
+    } {
+        keep -background -foreground -cursor -font
+        ignore -highlightthickness
+    }
     pack $itk_component(graph) -expand yes -fill both
+    $itk_component(graph) legend configure -hide yes
+    bind $itk_component(graph) <Configure> \
+        [list $_dispatcher event -idle !redraw]
+    bind $itk_component(graph) <ButtonPress-1> \
+        [itcl::code $this _zoom at %x %y]
+    bind $itk_component(graph) <B1-Motion> \
+        [itcl::code $this _zoom at %x %y]
+    bind $itk_component(graph) <Motion> \
+        [itcl::code $this _hilite brush %x %y]
+    bind $itk_component(graph) <Leave> \
+        [itcl::code $this _hilite hide]
+    bind $itk_component(graph) <KeyPress-Up> \
+        [itcl::code $this _zoom nudge 1]
+    bind $itk_component(graph) <KeyPress-Right> \
+        [itcl::code $this _zoom nudge 1]
+    bind $itk_component(graph) <KeyPress-plus> \
+        [itcl::code $this _zoom nudge 1]
+    bind $itk_component(graph) <KeyPress-Down> \
+        [itcl::code $this _zoom nudge -1]
+    bind $itk_component(graph) <KeyPress-Left> \
+        [itcl::code $this _zoom nudge -1]
+    bind $itk_component(graph) <KeyPress-minus> \
+        [itcl::code $this _zoom nudge -1]
     eval itk_initialize $args
 …
 # ----------------------------------------------------------------------
+# DESTRUCTOR
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::destructor {} {
+}
+# ----------------------------------------------------------------------
+# USAGE: _render
+# USAGE: columns <table>
+#
+# Clients use this to scan a <table> XML object and see if it contains
+# columns for energy levels.  If so, it returns a list of two column
+# names: {labels energies}.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::columns {dataobj} {
+    set names [$dataobj columns -component]
+    set epos [lsearch -exact $names column(levels)]
+    if {$epos >= 0} {
+        set units [$dataobj columns -units $epos]
+        if {![string match energy* [Rappture::Units::description $units]]} {
+            set epos -1
+        }
+    }
+    # can't find column named "levels"? then look for column with energies
+    if {$epos < 0} {
+        set index 0
+        foreach units [$dataobj columns -units] {
+            if {[string match energy* [Rappture::Units::description $units]]} {
+                if {$epos >= 0} {
+                    # more than one energy column -- bail out
+                    set epos -1
+                    break
+                }
+                set epos $index
+            }
+            incr index
+        }
+    }
+    # look for a column with labels
+    set lpos -1
+    set index 0
+    foreach units [$dataobj columns -units] {
+        if {"" == $units} {
+            set vals [$dataobj values -column $index]
+            if {[regexp {(^|[[:space:]])HOMO([[:space:]]|$)} $vals]} {
+                if {$lpos >= 0} {
+                    # more than one labels column -- bail out
+                    set lpos -1
+                    break
+                }
+                set lpos $index
+            }
+        }
+        incr index
+    }
+    if {$epos >= 0 || $lpos >= 0} {
+        return [list [lindex $names $lpos] [lindex $names $epos]]
+    }
+    return ""
+}
+# ----------------------------------------------------------------------
+# USAGE: add <dataobj> ?<settings>?
+#
+# Clients use this to add a data object to the plot.  The optional
+# <settings> are used to configure the plot.  Allowed settings are
+# -color, -brightness, -width, -linestyle and -raise.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::add {dataobj {settings ""}} {
+    #
+    # Make sure this table contains energy levels.
+    #
+    set cols [Rappture::EnergyLevels::columns $dataobj]
+    if {"" == $cols} {
+        error "table \"$dataobj\" does not contain energy levels"
+    }
+    #
+    # Scan through the settings and resolve all values.
+    #
+    array set params {
+        -color black
+        -brightness 0
+        -width 1
+        -raise 0
+        -linestyle solid
+    }
+    foreach {opt val} $settings {
+        if {![info exists params($opt)]} {
+            error "bad setting \"$opt\": should be [join [lsort [array names params]] {, }]"
+        }
+        set params($opt) $val
+    }
+    # convert -linestyle to BLT -dashes
+    switch -- $params(-linestyle) {
+        dashed { set params(-linestyle) {4 4} }
+        dotted { set params(-linestyle) {2 4} }
+        default { set params(-linestyle) {} }
+    }
+    # if -brightness is set, then update the color
+    if {$params(-brightness) != 0} {
+        set params(-color) [Rappture::color::brightness \
+            $params(-color) $params(-brightness)]
+    }
+    set pos [lsearch -exact $dataobj $_dlist]
+    if {$pos < 0} {
+        lappend _dlist $dataobj
+        set _dobj2color($dataobj) $params(-color)
+        set _dobj2raise($dataobj) $params(-raise)
+        foreach {lcol ecol} $cols break
+        set _dobj2cols($dataobj-label) $lcol
+        set _dobj2cols($dataobj-energy) $ecol
+        $_dispatcher event -idle !redraw
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: delete ?<dataobj1> <dataobj2> ...?
+#
+# Clients use this to delete a dataobj from the plot.  If no dataobjs
+# are specified, then all dataobjs are deleted.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::delete {args} {
+    if {[llength $args] == 0} {
+        set args $_dlist
+        set _eviewmin ""
+        set _eviewmax ""
+    }
+    # delete all specified data objs
+    set changed 0
+    foreach dataobj $args {
+        set pos [lsearch -exact $_dlist $dataobj]
+        if {$pos >= 0} {
+            set _dlist [lreplace $_dlist $pos $pos]
+            catch {unset _dobj2color($dataobj)}
+            catch {unset _dobj2raise($dataobj)}
+            catch {unset _dobj2cols($dataobj-label)}
+            catch {unset _dobj2cols($dataobj-energy)}
+            set changed 1
+        }
+    }
+    # if anything changed, then rebuild the plot
+    if {$changed} {
+        $_dispatcher event -idle !redraw
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: scale ?<dataobj1> <dataobj2> ...?
+#
+# Sets the default limits for the overall plot according to the
+# limits of the data for all of the given <dataobj> objects.  This
+# accounts for all dataobjs--even those not showing on the screen.
+# Because of this, the limits are appropriate for all data as
+# the user scans through data in the ResultSet viewer.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::scale {args} {
+    set _emin ""
+    set _emax ""
+    foreach obj $args {
+        if {![info exists _dobj2cols($obj-energy)]} {
+            # don't recognize this object? then ignore it
+            continue
+        }
+        foreach {min max} [$obj limits $_dobj2cols($obj-energy)] break
+        if {"" != $min && "" != $max} {
+            if {"" == $_emin} {
+                set _emin $min
+                set _emax $max
+            } else {
+                if {$min < $_emin} { set _emin $min }
+                if {$max > $_emax} { set _emax $max }
+            }
+        }
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: _redraw
+#
 # Used internally to load a list of energy levels from a <table> within
+# the -output XML object.  The -layout object indicates how information
+# should be extracted from the table.  The <layout> should have an
+# <energies> tag and perhaps a <labels> tag, which indicates the table
+# and the column within the table containing the energies.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::_render {} {
+    #
+    # Clear any information shown in the graph.
+    #
+    set graph $itk_component(graph)
+    eval $graph element delete [$graph element names]
+    eval $graph marker delete [$graph marker names]
+    #
+    # Plug in the title from the layout
+    #
+    set title ""
+    if {$itk_option(-layout) != ""} {
+        set title [$itk_option(-layout) get label]
+    }
+    if {"" != $title} {
+        pack $itk_component(title) -side top -before $graph
+        $itk_component(title) configure -text $title
+# the data objects.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::_redraw {{what all}} {
+    # scale data now, if we haven't already
+    if {"" == $_emin || "" == $_emax} {
+        eval scale $_dlist
+    }
+    # put the dataobj list in order according to -raise options
+    set dlist $_dlist
+    foreach obj $dlist {
+        if {[info exists _dobj2raise($obj)] && $_dobj2raise($obj)} {
+            set i [lsearch -exact $dlist $obj]
+            if {$i >= 0} {
+                set dlist [lreplace $dlist $i $i]
+                lappend dlist $obj
+            }
+        }
+    }
+    set topdobj [lindex $dlist end]
+    _getLayout
+    #
+    # Redraw the overall layout
+    #
+    if {$what == "all"} {
+        $c delete all
+        if {[llength $dlist] == 0} {
+            return
+        }
+        #
+        # Scan through all data objects and plot them in order from
+        # the bottom up.
+        #
+        set e2y [expr {($y1-$y0)/($_emax-$_emin)}]
+        set title ""
+        set dataobj ""
+        foreach dataobj $dlist {
+            if {"" == $title} {
+                set title [$dataobj hints label]
+            }
+            set ecol $_dobj2cols($dataobj-energy)
+            set color $_dobj2color($dataobj)
+            if {"" == $color} {
+                set color $itk_option(-levelcolor)
+            }
+            set color [Rappture::color::brightness $color 0.7]
+            foreach eval [$dataobj values -column $ecol] {
+                set y [expr {($eval-$_emin)*$e2y + $y0}]
+                $c create line $xx0 $y $xx1 $y -fill $color -width 1
+            }
+        }
+        #
+        # Scan through the data and look for HOMO/LUMO levels.
+        # Set the default view to the energy just above and
+        # just below the HOMO/LUMO levels.
+        #
+        set _edefmin [expr {0.4*($_emax-$_emin) + $_emin}]
+        set _edefmax [expr {0.6*($_emax-$_emin) + $_emin}]
+        set nlumo -1
+        set nhomo -1
+        set dataobj [lindex $dlist end]
+        if {"" != $dataobj} {
+            set lcol $_dobj2cols($dataobj-label)
+            set ecol $_dobj2cols($dataobj-energy)
+            set units [$dataobj columns -units $ecol]
+            set n 0
+            foreach eval [$dataobj values -column $ecol] \
+                    lval [$dataobj values -column $lcol] {
+                if {$lval == "HOMO"} {
+                    set nhomo $n
+                    set nlumo [expr {$n+1}]
+                } elseif {$lval == "LUMO"} {
+                    set nlumo $n
+                }
+                incr n
+            }
+            if {$nhomo >= 0 && $nlumo >= 0} {
+                set elist [$dataobj values -column $ecol]
+                set _ehomo [lindex $elist $nhomo]
+                set _elumo [lindex $elist $nlumo]
+                set gap [expr {$_elumo - $_ehomo}]
+                set _edefmin [expr {$_ehomo - 0.3*$gap}]
+                set _edefmax [expr {$_elumo + 0.3*$gap}]
+                set y [expr {($_ehomo-$_emin)*$e2y + $y0}]
+                set id [$c create rectangle $xx0 $y $xx1 $y0 \
+                    -stipple EnergyLevels-rdiag \
+                    -outline "" -fill $itk_option(-shadecolor)]
+                $c lower $id
+            }
+        }
+        if {"" == $_eviewmin || "" == $_eviewmax} {
+            set _eviewmin $_edefmin
+            set _eviewmax $_edefmax
+        }
+        if {"" != $title} {
+            pack $itk_component(title) -side top -before $c
+            $itk_component(title) configure -text $title
+        } else {
+            pack forget $itk_component(title)
+        }
+        # draw the lines for the "zoom" view (fixed up below)
+        set color $itk_option(-foreground)
+        $c create line $x0 $y0 $x1 $y0 -fill $color -tags zmin
+        $c create line $x0 $y0 $x1 $y0 -fill $color -tags zmax
+        $c create line $x1 $y0 $x2 $y0 -fill $color -tags zoomup
+        $c create line $x1 $y0 $x2 $y1 -fill $color -tags zoomdn
+        $c create line $x2 $y0 $x3 $y0 -fill $color
+        $c create line $x2 $y1 $x3 $y1 -fill $color
+    }
+    #
+    # Redraw the "zoom" area on the right side
+    #
+    if {$what == "zoom" || $what == "all"} {
+        set e2y [expr {($y1-$y0)/($_emax-$_emin)}]
+        set y [expr {($_eviewmin-$_emin)*$e2y + $y0}]
+        $c coords zmin $x0 $y $x1 $y
+        $c coords zoomup $x1 $y $x2 $y0
+        set y [expr {($_eviewmax-$_emin)*$e2y + $y0}]
+        $c coords zmax $x0 $y $x1 $y
+        $c coords zoomdn $x1 $y $x2 $y1
+        # redraw all levels in the current view
+        $c delete zlevels zlabels
+        set e2y [expr {($y1-$y0)/($_eviewmax-$_eviewmin)}]
+        foreach dataobj $dlist {
+            set ecol $_dobj2cols($dataobj-energy)
+            set color $_dobj2color($dataobj)
+            if {"" == $color} {
+                set color $itk_option(-levelcolor)
+            }
+            set n 0
+            foreach eval [$dataobj values -column $ecol] {
+                if {$eval >= $_eviewmin && $eval <= $_eviewmax} {
+                    set y [expr {($eval-$_eviewmin)*$e2y + $y0}]
+                    set id [$c create line $xx2 $y $xx3 $y \
+                        -fill $color -width 1 \
+                        -tags [list zlevels $dataobj-$n]]
+                }
+                incr n
+            }
+        }
+        if {"" != $_ehomo && "" != $_elumo} {
+            set ecol $_dobj2cols($topdobj-energy)
+            set units [$topdobj columns -units $ecol]
+            set yy0 [expr {($_ehomo-$_eviewmin)*$e2y + $y0}]
+            set yy1 [expr {($_elumo-$_eviewmin)*$e2y + $y0}]
+            $c create line [expr {$x3-10}] $yy0 [expr {$x3-10}] $yy1 \
+                -arrow both -fill $itk_option(-foreground) \
+                -tags zlabels
+            $c create text [expr {$x3-15}] [expr {0.5*($yy0+$yy1)}] \
+                -anchor e -text "Eg = [expr {$_elumo-$_ehomo}] $units" \
+                -tags zlabels
+            # label the HOMO level
+            set tid [$c create text [expr {0.5*($x2+$x3)}] $yy0 -anchor c \
+                -text "HOMO = $_ehomo $units" \
+                -fill $itk_option(-leveltextforeground) \
+                -tags zlabels]
+            foreach {xb0 yb0 xb1 yb1} [$c bbox $tid] break
+            set tid2 [$c create rectangle \
+                [expr {$xb0-1}] [expr {$yb0-1}] \
+                [expr {$xb1+1}] [expr {$yb1+1}] \
+                -outline $itk_option(-leveltextforeground) \
+                -fill $itk_option(-leveltextbackground) \
+                -tags zlabels]
+            $c lower $tid2 $tid
+            # label the LUMO level
+            set tid [$c create text [expr {0.5*($x2+$x3)}] $yy1 -anchor c \
+                -text "LUMO = $_elumo $units" \
+                -fill $itk_option(-leveltextforeground) \
+                -tags zlabels]
+            foreach {xb0 yb0 xb1 yb1} [$c bbox $tid] break
+            set tid2 [$c create rectangle \
+                [expr {$xb0-1}] [expr {$yb0-1}] \
+                [expr {$xb1+1}] [expr {$yb1+1}] \
+                -outline $itk_option(-leveltextforeground) \
+                -fill $itk_option(-leveltextbackground) \
+                -tags zlabels]
+            $c lower $tid2 $tid
+            set id [$c create rectangle $xx2 $yy0 $xx3 $y0 \
+                -stipple EnergyLevels-rdiag \
+                -outline "" -fill $itk_option(-shadecolor) \
+                -tags zlabels]
+            $c lower $id
+        }
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: _zoom in
+# USAGE: _zoom out
+# USAGE: _zoom reset
+# USAGE: _zoom at <x> <y>
+# USAGE: _zoom nudge <dir>
+#
+# Called automatically when the user clicks on one of the zoom
+# controls for this widget.  Changes the zoom for the current view.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::_zoom {option args} {
+    switch -- $option {
+        in {
+            set midE [expr {0.5*($_eviewmax + $_eviewmin)}]
+            set delE [expr {0.8*($_eviewmax - $_eviewmin)}]
+            _view $midE $delE
+        }
+        out {
+            set midE [expr {0.5*($_eviewmax + $_eviewmin)}]
+            set delE [expr {1.25*($_eviewmax - $_eviewmin)}]
+            _view $midE $delE
+        }
+        reset {
+            set _eviewmin $_edefmin
+            set _eviewmax $_edefmax
+            $_dispatcher event -idle !zoom
+        }
+        at {
+            if {[llength $args] != 2} {
+                error "wrong # args: should be \"_zoom at x y\""
+            }
+            set x [lindex $args 0]
+            set y [lindex $args 1]
+            _getLayout
+            set y2e [expr {($_emax-$_emin)/($y1-$y0)}]
+            if {$x > $x1} {
+                return
+            }
+            set midE [expr {($y-$y0)*$y2e + $_emin}]
+            set delE [expr {$_eviewmax - $_eviewmin}]
+            _view $midE $delE
+        }
+        nudge {
+            if {[llength $args] != 1} {
+                error "wrong # args: should be \"_zoom nudge dir\""
+            }
+            set dir [lindex $args 0]
+            set midE [expr {0.5*($_eviewmax + $_eviewmin)}]
+            set delE [expr {$_eviewmax - $_eviewmin}]
+            set midE [expr {$midE + $dir*0.25*$delE}]
+            _view $midE $delE
+        }
+    }
+    focus $itk_component(graph)
+}
+# ----------------------------------------------------------------------
+# USAGE: _view <midE> <delE>
+#
+# Called automatically when the user clicks/drags on the left side
+# of the widget where energy levels are displayed.  Sets the zoom
+# view so that it's centered on the <y> coordinate.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::_view {midE delE} {
+    if {$delE > $_emax-$_emin} {
+        set delE [expr {$_emax - $_emin}]
+    }
+    if {$midE - 0.5*$delE < $_emin} {
+        set _eviewmin $_emin
+        set _eviewmax [expr {$_eviewmin+$delE}]
+    } elseif {$midE + 0.5*$delE > $_emax} {
+        set _eviewmax $_emax
+        set _eviewmin [expr {$_eviewmax-$delE}]
     } else {
+        pack forget $itk_component(title)
+    }
+    #
+    # Look through the layout and figure out what to extract
+    # from the table.
+    #
+    set elist [_getColumn energies]
+    if {[llength $elist] == 0} {
+        return
+    }
+    set units [_getUnits energies]
+    set llist [_getColumn names]
+    if {[llength $llist] == 0} {
+        # no labels? then invent some
+        set i 0
+        foreach name $elist {
+            lappend llist "E$i"
+            incr i
+        }
+    }
+    #
+    # Update the graph to show the current set of levels.
+    #
+    set n 0
+    set nlumo -1
+    set emax ""
+    set emin ""
+    set ehomo ""
+    set elumo ""
+    foreach eval $elist lval $llist {
+        if {$lval == "HOMO"} {
+            set ehomo $eval
+            set lval "HOMO = $eval $units"
+            set nlumo [expr {$n+1}]
+        } elseif {$lval == "LUMO" || $n == $nlumo} {
+            set elumo $eval
+            set lval "LUMO = $eval $units"
+        } else {
+            set lval ""
+        }
+        set elem "elem[incr n]"
+        $graph element create $elem \
+            -xdata {0 1} -ydata [list $eval $eval] \
+            -color $itk_option(-levelcolor) -symbol "" -linewidth 1
+        if {$lval != ""} {
+            $graph marker create text -coords [list 0.5 $eval] \
+                -text $lval -anchor c \
+                -foreground $itk_option(-leveltextforeground) \
+                -background $itk_option(-leveltextbackground)
+        }
+        if {$emax == ""} {
+            set emax $eval
+            set emin $eval
+        } else {
+            if {$eval > $emax} {set emax $eval}
+            if {$eval < $emin} {set emin $eval}
+        }
+    }
+    $graph xaxis configure -min 0 -max 1 -showticks off -linewidth 0
+    if {$units != ""} {
+        $graph yaxis configure -title "Energy ($units)"
+    } else {
+        $graph yaxis configure -title "Energy"
+    }
+    # bump the limits so they are big enough to show labels
+    set fnt $itk_option(-font)
+    set h [expr {0.5*([font metrics $fnt -linespace] + 5)}]
+    set emin [expr {$emin-($emax-$emin)*$h/150.0}]
+    set emax [expr {$emax+($emax-$emin)*$h/150.0}]
+    $graph yaxis configure -min $emin -max $emax
+    #
+    # If we found HOMO/LUMO levels, then add the band gap at
+    # that point.  Also, fix the controls for energy range.
+    #
+    if {$ehomo != "" && $elumo != ""} {
+        set id [$graph marker create line \
+            -coords [list 0.2 $elumo 0.2 $ehomo]]
+        $graph marker after $id
+        set egap [expr {$elumo-$ehomo}]
+        set emid [expr {0.5*($ehomo+$elumo)}]
+        $graph marker create text \
+            -coords [list 0.21 $emid] -background "" \
+            -text "Eg = [format %.2g $egap] $units" -anchor w
+        # fix the limits for the lower scale
+        set elim [_getMidPt $elist [expr {$nlumo-1}]]
+        if {"" != $elim} {
+            $itk_component(lowerEcntl) configure -from $elim -to $emin \
+                -resolution [expr {0.02*($elim-$emin)}]
+            grid $itk_component(lowerE) -row 2 -column 0 -sticky ns
+            set e0 [_getMidPt $elist [expr {$nlumo-3}]]
+            if {"" != $e0} {
+                $itk_component(lowerEcntl) set $e0
+        set _eviewmin [expr {$midE - 0.5*$delE}]
+        set _eviewmax [expr {$midE + 0.5*$delE}]
+    }
+    $_dispatcher event -idle !zoom
+}
+# ----------------------------------------------------------------------
+# USAGE: _hilite brush <x> <y>
+# USAGE: _hilite show <dataobj> <level>
+# USAGE: _hilite hide
+#
+# Used internally to highlight energy levels in the zoom view and
+# show their associated energy.  The "brush" operation is called
+# as the mouse moves in the zoom view, to see if the <x>,<y>
+# coordinate is touching a level.  The show/hide operations are
+# then used to show/hide level info.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::_hilite {option args} {
+    switch -- $option {
+        brush {
+            if {[llength $args] != 2} {
+                error "wrong # args: should be \"_hilite brush x y\""
+            }
+            set x [lindex $args 0]
+            set y [lindex $args 1]
+            _getLayout
+            if {$x < $x2 || $x > $x3} {
+                return   ;# pointer must be in "zoom" area
+            }
+            set c $itk_component(graph)
+            set id [$c find withtag current]
+            # touching a line? then find the level and show its info
+            if {"" != $id} {
+                set e2y [expr {($y1-$y0)/($_eviewmax-$_eviewmin)}]
+                # put the dataobj list in order according to -raise options
+                set dlist $_dlist
+                foreach obj $dlist {
+                    if {[info exists _dobj2raise($obj)] && $_dobj2raise($obj)} {
+                        set i [lsearch -exact $dlist $obj]
+                        if {$i >= 0} {
+                            set dlist [lreplace $dlist $i $i]
+                            lappend dlist $obj
+                        }
+                    }
+                }
+                set found 0
+                foreach dataobj $dlist {
+                    set ecol $_dobj2cols($dataobj-energy)
+                    set n 0
+                    foreach eval [$dataobj values -column $ecol] {
+                        set ylevel [expr {($eval-$_eviewmin)*$e2y + $y0}]
+                        if {$y >= $ylevel-3 && $y <= $ylevel+3} {
+                            set found 1
+                            break
+                        }
+                        incr n
+                    }
+                    if {$found} break
+                }
+                if {$found} {
+                    _hilite show $dataobj $n
+                } else {
+                    _hilite hide
+                }
             } else {
+                $itk_component(lowerEcntl) set $elim
+            }
+        } else {
+            grid forget $itk_component(lowerE)
+        }
+        # fix the limits for the upper scale
+        set elim [_getMidPt $elist [expr {$nlumo+1}]]
+        if {"" != $elim} {
+            $itk_component(upperEcntl) configure -from $emax -to $elim \
+                -resolution [expr {0.02*($emax-$elim)}]
+            grid $itk_component(upperE) -row 0 -column 0 -sticky ns
+            set e0 [_getMidPt $elist [expr {$nlumo+3}]]
+            if {"" != $e0} {
+                $itk_component(upperEcntl) set $e0
+            } else {
+                $itk_component(upperEcntl) set $elim
+            }
+        } else {
+            grid forget $itk_component(upperE)
+        }
+    } else {
+        grid forget $itk_component(upperE)
+        grid forget $itk_component(lowerE)
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: _adjust <what> <val>
+                _hilite hide
+            }
+        }
+        show {
+            if {[llength $args] != 2} {
+                error "wrong # args: should be \"_hilite show dataobj level\""
+            }
+            set dataobj [lindex $args 0]
+            set level [lindex $args 1]
+            if {$_hilite == "$dataobj $level"} {
+                return
+            }
+            _hilite hide
+            set lcol $_dobj2cols($dataobj-label)
+            set lval [lindex [$dataobj values -column $lcol] $level]
+            set ecol $_dobj2cols($dataobj-energy)
+            set eval [lindex [$dataobj values -column $ecol] $level]
+            set units [$dataobj columns -units $ecol]
+            if {$eval == $_ehomo || $eval == $_elumo} {
+                # don't pop up info for the HOMO/LUMO levels
+                return
+            }
+            _getLayout
+            set e2y [expr {($y1-$y0)/($_eviewmax-$_eviewmin)}]
+            set y [expr {($eval-$_eviewmin)*$e2y + $y0}]
+            set tid [$c create text [expr {0.5*($x2+$x3)}] $y -anchor c \
+                -text "$lval = $eval $units" \
+                -fill $itk_option(-leveltextforeground) \
+                -tags hilite]
+            foreach {x0 y0 x1 y1} [$c bbox $tid] break
+            set tid2 [$c create rectangle \
+                [expr {$x0-1}] [expr {$y0-1}] \
+                [expr {$x1+1}] [expr {$y1+1}] \
+                -outline $itk_option(-leveltextforeground) \
+                -fill $itk_option(-leveltextbackground) \
+                -tags hilite]
+            $c lower $tid2 $tid
+            $c itemconfigure $dataobj-$level -width 2
+            set _hilite "$dataobj $level"
+        }
+        hide {
+            if {"" != $_hilite} {
+                $itk_component(graph) delete hilite
+                $itk_component(graph) itemconfigure zlevels -width 1
+                set _hilite ""
+            }
+        }
+        default {
+            error "bad option \"$option\": should be brush, show, hide"
+        }
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: _getLayout
+#
+# Used internally to adjust the upper/lower limits of the graph
+# as the user drags the slider from "More" to "Fewer".  Sets
+# the specified limit to the given value.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::_adjust {what val} {
+    switch -- $what {
+        upper {
+            $itk_component(graph) yaxis configure -max $val
+        }
+        lower {
+            $itk_component(graph) yaxis configure -min $val
+        }
+        default {
+            error "bad limit \"$what\": should be upper or lower"
+        }
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: _getColumn <name>
+#
+# Used internally to load a list of energy levels from a <table> within
+# the -output XML object.  The -layout object indicates how information
+# should be extracted from the table.  The <layout> should have an
+# <energies> tag and perhaps a <labels> tag, which indicates the table
+# and the column within the table containing the energies.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::_getColumn {name} {
+puts "_getColumn $name"
+    if {$itk_option(-output) == ""} {
+        return
+    }
+    #
+    # Figure out which column in which table contains the data.
+    # Then, find that table and extract the column.  Figure out
+    # the position of the column from the list of all column names.
+    #
+    if {$itk_option(-layout) != ""} {
+        set table [$itk_option(-layout) get $name.table]
+        set col [$itk_option(-layout) get $name.column]
+        set clist ""
+        foreach c [$itk_option(-output) children -type column $table] {
+            lappend clist [$itk_option(-output) get $table.$c.label]
+        }
+        set ipos [lsearch $clist $col]
+        if {$ipos < 0} {
+            return  ;# can't find data -- bail out!
+        }
+        set units [$itk_option(-output) get $table.column$ipos.units]
+        set path "$table.data"
+    } else {
+        set clist ""
+        foreach c [$itk_option(-output) children -type column] {
+            lappend clist [$itk_option(-output) get $c.units]
+        }
+        if {$name == "energies"} {
+            set units "eV"
+        } else {
+            set units ""
+        }
+        set ipos [lsearch -exact $clist $units]
+        if {$ipos < 0} {
+            return  ;# can't find data -- bail out!
+        }
+        set path "data"
+    }
+    set rlist ""
+    foreach line [split [$itk_option(-output) get $path] "\n"] {
+        if {"" != [string trim $line]} {
+            set val [lindex $line $ipos]
+            if {$units != ""} {
+                set val [Rappture::Units::convert $val \
+                    -context $units -to $units -units off]
+            }
+            lappend rlist $val
+        }
+    }
+    return $rlist
+}
+# ----------------------------------------------------------------------
+# USAGE: _getUnits <name>
+#
+# Used internally to extract the units from a <table> within the
+# -output XML object.  The -layout object indicates how information
+# should be extracted from the table.  The <layout> should have an
+# <energies> tag and perhaps a <labels> tag, which indicates the table
+# and the column within the table containing the units.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::_getUnits {name} {
+    if {$itk_option(-output) == ""} {
+        return
+    }
+    #
+    # Figure out which column in which table contains the data.
+    # Then, find that table and extract the column.  Figure out
+    # the position of the column from the list of all column names.
+    #
+    if {$itk_option(-layout) != ""} {
+        set table [$itk_option(-layout) get $name.table]
+        set col [$itk_option(-layout) get $name.column]
+        set clist ""
+        foreach c [$itk_option(-output) children -type column $table] {
+            lappend clist [$itk_option(-output) get $table.$c.label]
+        }
+        set ipos [lsearch $clist $col]
+        if {$ipos < 0} {
+            return  ;# can't find data -- bail out!
+        }
+        set units [$itk_option(-output) get $table.column$ipos.units]
+    } else {
+        if {$name == "energies"} {
+            set units "eV"
+        } else {
+            set units ""
+        }
+    }
+    return $units
+}
+# ----------------------------------------------------------------------
+# USAGE: _getMidPt <elist> <pos>
+#
+# Used internally to compute the midpoint between two energy levels
+# at <pos> and <pos-1> in the <elist>.  Returns a number representing
+# the mid-point (average value) or "" if the levels involved do
+# no exist in <elist>.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::_getMidPt {elist pos} {
+    if {$pos < [llength $elist] && $pos > 1} {
+        set e1 [lindex $elist $pos]
+        set e0 [lindex $elist [expr {$pos-1}]]
+        return [expr {0.5*($e0+$e1)}]
+    }
+    return ""
+}
+# ----------------------------------------------------------------------
+# OPTION: -layout
+# ----------------------------------------------------------------------
+itcl::configbody Rappture::EnergyLevels::layout {
+    if {$itk_option(-layout) != ""
+          && ![Rappture::library isvalid $itk_option(-layout)]} {
+        error "bad value \"$itk_option(-layout)\": should be Rappture::library object"
+    }
+    after idle [itcl::code $this _render]
+}
+# ----------------------------------------------------------------------
+# OPTION: -output
+# ----------------------------------------------------------------------
+itcl::configbody Rappture::EnergyLevels::output {
+    if {$itk_option(-output) != ""
+          && ![Rappture::library isvalid $itk_option(-output)]} {
+        error "bad value \"$itk_option(-output)\": should be Rappture::library object"
+    }
+    after cancel [itcl::code $this _render]
+    after idle [itcl::code $this _render]
+# Used internally to compute a series of variables used when redrawing
+# the widget.  Creates the variables with the proper values in the
+# calling context.
+# ----------------------------------------------------------------------
+itcl::body Rappture::EnergyLevels::_getLayout {} {
+    upvar c c
+    set c $itk_component(graph)
+    upvar w w
+    set w [winfo width $c]
+    upvar h h
+    set h [winfo height $c]
+    #
+    # Measure the size of a typical label and use that to size
+    # the left/right portions.  If the label is too big, leave
+    # at least a little room for the labels.
+    #
+    set size [font measure $itk_option(-font) "HOMO = X.XXXXXXe-XX eV"]
+    set size [expr {$size + 6*$itk_option(-padding)}]
+    if {$size > $w-20} {
+        set size [expr {$w-20}]
+    } elseif {$size < 0.66*$w} {
+        set size [expr {0.66*$w}]
+    }
+    set xm [expr {$w - $size}]
+    upvar x0 x0
+    set x0 $itk_option(-padding)
+    upvar x1 x1
+    set x1 [expr {$xm - $itk_option(-padding)}]
+    upvar x2 x2
+    set x2 [expr {$xm + $itk_option(-padding)}]
+    upvar x3 x3
+    set x3 [expr {$w - $itk_option(-padding)}]
+    upvar xx0 xx0
+    set xx0 [expr {$x0 + $itk_option(-padding)}]
+    upvar xx1 xx1
+    set xx1 [expr {$x1 - $itk_option(-padding)}]
+    upvar xx2 xx2
+    set xx2 [expr {$x2 + $itk_option(-padding)}]
+    upvar xx3 xx3
+    set xx3 [expr {$x3 - $itk_option(-padding)}]
+    upvar y0 y0
+    set y0 [expr {$h - $itk_option(-padding)}]
+    upvar y1 y1
+    set y1 $itk_option(-padding)
+}
 …
 # ----------------------------------------------------------------------
 itcl::configbody Rappture::EnergyLevels::levelcolor {
+    after cancel [itcl::code $this _render]
+    after idle [itcl::code $this _render]
+    $_dispatcher event -idle !redraw
+}
 …
 # ----------------------------------------------------------------------
 itcl::configbody Rappture::EnergyLevels::leveltextforeground {
+    after cancel [itcl::code $this _render]
+    after idle [itcl::code $this _render]
+    $_dispatcher event -idle !redraw
+}
 …
 # ----------------------------------------------------------------------
 itcl::configbody Rappture::EnergyLevels::leveltextbackground {
+    after cancel [itcl::code $this _render]
+    after idle [itcl::code $this _render]
+}
+    $_dispatcher event -idle !redraw
+}

trunk/gui/scripts/field.tcl

-                      r11
+                      r13
 # ----------------------------------------------------------------------
 itcl::body Rappture::Field::hints {{keyword ""}} {
+    foreach key {label scale color units} {
+        set str [$_field get $key]
+    foreach {key path} {
+        group   about.group
+        label   about.label
+        color   about.color
+        style   about.style
+        scale   about.scale
+        units   units
+    } {
+        set str [$_field get $path]
         if {"" != $str} {
             set hints($key) $str
+        }
+    }
+    if {[info exists hints(group)] && [info exists hints(label)]} {
+        # pop-up help for each curve
+        set hints(tooltip) $hints(label)
+    }
 …
             if {$xv != "" && $yv != ""} {
+                # sort x-coords in increasing order
+                $xv sort $yv
                 set _comp2dims($cname) "1D"
                 set _comp2xy($cname) [list $xv $yv]
 …
             if {[$_xmlobj element $path] != ""} {
                 set cobj [Rappture::Cloud::fetch $_xmlobj $path]
+                set values [$_field get $cname.values]
+                set farray [vtkFloatArray ::vals$_counter]
+                foreach v $values {
+                    if {"" != $_units} {
+                        set v [Rappture::Units::convert $v \
+                            -context $_units -to $_units -units off]
+                if {[$cobj dimensions] > 1} {
+                    #
+                    # 2D/3D data
+                    # Store cloud/field as components
+                    #
+                    set values [$_field get $cname.values]
+                    set farray [vtkFloatArray ::vals$_counter]
+                    foreach v $values {
+                        if {"" != $_units} {
+                            set v [Rappture::Units::convert $v \
+                                -context $_units -to $_units -units off]
+                        }
+                        $farray InsertNextValue $v
+                    }
+                    $farray InsertNextValue $v
+                    set _comp2dims($cname) "[$cobj dimensions]D"
+                    set _comp2vtk($cname) [list $cobj $farray]
+                    incr _counter
+                } else {
+                    #
+                    # OOPS!  This is 1D data
+                    # Forget the cloud/field -- store BLT vectors
+                    #
+                    set xv [blt::vector create x$_counter]
+                    set yv [blt::vector create y$_counter]
+                    set vtkpts [$cobj points]
+                    set max [$vtkpts GetNumberOfPoints]
+                    for {set i 0} {$i < $max} {incr i} {
+                        set xval [lindex [$vtkpts GetPoint $i] 0]
+                        $xv append $xval
+                    }
+                    Rappture::Cloud::release $cobj
+                    set values [$_field get $cname.values]
+                    foreach yval $values {
+                        if {"" != $_units} {
+                            set yval [Rappture::Units::convert $yval \
+                                -context $_units -to $_units -units off]
+                        }
+                        $yv append $yval
+                    }
+                    # sort x-coords in increasing order
+                    $xv sort $yv
+                    set _comp2dims($cname) "1D"
+                    set _comp2xy($cname) [list $xv $yv]
+                    incr _counter
+                }
-                set _comp2dims($cname) "[$cobj dimensions]D"
-                set _comp2vtk($cname) [list $cobj $farray]
-                incr _counter
             } else {
                 puts "WARNING: can't find mesh $path for field component"

trunk/gui/scripts/loader.tcl

-                      r11
+                      r13
     set defval [$xmlobj get $path.default]
+    set flist ""
+    foreach comp [$xmlobj children -type example $path] {
+        lappend flist [$xmlobj get $path.$comp]
+    }
+    # if there are no examples, then look for *.xml
+    if {[llength $flist] == 0} {
+        set flist *.xml
+    }
+    if {$itk_option(-tool) != ""} {
+        set fdir [$itk_option(-tool) installdir]
+    } else {
+        set fdir "."
+    }
     set _counter 1
+    foreach comp [$xmlobj children -type example $path] {
+        if {$itk_option(-tool) != ""} {
+            set fdir [$itk_option(-tool) installdir]
+        } else {
+            set fdir "."
+        }
+        set ftail [$xmlobj get $path.$comp]
+        if {"" != $ftail} {
+            set fname [file join $fdir examples $ftail]
+    foreach ftail $flist {
+        set fpath [file join $fdir examples $ftail]
+        foreach fname [glob -nocomplain $fpath] {
             if {[file exists $fname]} {
                 if {[catch {set obj [Rappture::library $fname]} result]} {
 …
                     $itk_component(combo) choices insert end $obj $label
                     if {[string equal $defval $ftail]} {
+                    if {[string equal $defval [file tail $fname]]} {
                         $xmlobj put $path.default $label
+                    }

trunk/gui/scripts/mainwin.tcl

-                      r11
+                      r13
+        }
-        set titleh 0
-        set fnt [option get $itk_component(hull) titleFont Font]
-        if {$itk_option(-title) != "" && $fnt != ""} {
-            set titleh [expr {[font metrics $fnt -linespace]+2}]
+        }
-        if {$h+$titleh > $sh} {
-            set $h [expr {$sh-$titleh}]
-            set clip 1
+        }
         switch -- $itk_option(-anchor) {
             n {
                 set x [expr {$sw/2}]
+                set y $titleh
+                set tx [expr {$x-$w/2}]
+                set ty $titleh
+                set y 0
+            }
             s {
                 set x [expr {$sw/2}]
                 set y $sh
-                set tx [expr {$x-$w/2}]
-                set ty [expr {$sh-$h}]
+            }
             center {
                 set x [expr {$sw/2}]
                 set y [expr {$sh/2}]
-                set tx [expr {$x-$w/2}]
-                set ty [expr {$y-$h/2}]
+            }
             w {
                 set x 0
                 set y [expr {$sh/2}]
-                set tx 0
-                set ty [expr {$y-$h/2}]
+            }
             e {
                 set x $sw
                 set y [expr {$sh/2}]
-                set tx [expr {$sw-$w}]
-                set ty [expr {$y-$h/2}]
+            }
             nw {
                 set x 0
+                set y $titleh
+                set tx 0
+                set ty $titleh
+                set y 0
+            }
             ne {
                 set x $sw
+                set y $titleh
+                set tx [expr {$sw-$w}]
+                set ty $titleh
+                set y 0
+            }
             sw {
                 set x 0
                 set y $sh
-                set tx 0
-                set ty [expr {$sh-$h}]
+            }
             se {
                 set x $sw
                 set y $sh
-                set tx [expr {$sw-$w}]
-                set ty [expr {$sh-$h}]
+            }
+        }
 …
             -anchor $itk_option(-anchor) -window $itk_component(app) \
             -width $w -height $h
-        if {$itk_option(-title) != "" && $fnt != ""} {
-            $itk_component(area) create text $tx [expr {$ty-2}] \
-                -anchor sw -text $itk_option(-title) -font $fnt
+        }
+    }
+}

trunk/gui/scripts/resultset.tcl

-                      r11
+                      r13
 option add *ResultSet.width 4i widgetDefault
 option add *ResultSet.height 4i widgetDefault
 option add *ResultSet.colors {blue #000066} widgetDefault
+option add *ResultSet.colors {blue magenta} widgetDefault
 option add *ResultSet.toggleBackground gray widgetDefault
 option add *ResultSet.toggleForeground white widgetDefault
 …
 # Adds a new result to this result set.  Scans through all existing
 # results to look for a difference compared to previous results.
 # Returns an instruction to the caller, indicating how the various
+# Returns the index of this new result to the caller.  The various
 # data objects for this result set should be added to their result
 # viewers.
+# viewers at the same index.
 # ----------------------------------------------------------------------
 itcl::body Rappture::ResultSet::add {xmlobj} {
 …
         $itk_component(status) configure -text "1 result"
         $itk_component(clear) configure -state normal
         return "add"
+        return 0
+    }
 …
     # build a tuple for this new object
-    set op "add"
     set cols ""
     set tuple ""
 …
         # overwrite the first matching entry
         set i [lindex $ilist 0]
         $_results put $i $tuple
+        set index [lindex $ilist 0]
+        $_results put $index $tuple
         set _recent $xmlobj
-        set op "replace $i"
     } else {
+        set index [$_results size]
         $_results insert end $tuple
         set _recent $xmlobj
 …
     $itk_component(clear) configure -state normal
     return $op
+    return $index
+}
 …
+    }
     catch {unset _col2widget}
+    set _plotall ""
     set _counter 0

trunk/gui/scripts/resultviewer.tcl

-                      r11
+                      r13
     destructor { # defined below }
+    public method add {xmlobj path}
+    public method replace {index xmlobj path}
+    public method clear {}
+    public method add {index xmlobj path}
+    public method clear {{index ""}}
     public method plot {option args}
 …
     private variable _mode ""        ;# current plotting mode (xy, etc.)
     private variable _mode2widget    ;# maps plotting mode => widget
     private variable _dataobjs ""    ;# list of all data objects in this widget
     private variable _plotlist ""    ;# list of indices plotted in _dataobjs
+    private variable _dataslots ""   ;# list of all data objects in this widget
+    private variable _plotlist ""    ;# list of indices plotted in _dataslots
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::ResultViewer::destructor {} {
+    foreach obj $_dataobjs {
+        itcl::delete object $obj
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: add <xmlobj> <path>
+#
+# Adds a new result to this result viewer.  Scans through all existing
+# results to look for a difference compared to previous results.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultViewer::add {xmlobj path} {
+    foreach slot $_dataslots {
+        foreach obj $slot {
+            itcl::delete object $obj
+        }
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: add <index> <xmlobj> <path>
+#
+# Adds a new result to this result viewer at the specified <index>.
+# Data is taken from the <xmlobj> object at the <path>.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultViewer::add {index xmlobj path} {
     if {$path != ""} {
         set dobj [_xml2data $xmlobj $path]
 …
         set dobj ""
+    }
+    lappend _dataobjs $dobj
+    #
+    # If the index doesn't exist, then fill in empty slots and
+    # make it exist.
+    #
+    for {set i [llength $_dataslots]} {$i <= $index} {incr i} {
+        lappend _dataslots ""
+    }
+    set slot [lindex $_dataslots $index]
+    lappend slot $dobj
+    set _dataslots [lreplace $_dataslots $index $index $slot]
     $_dispatcher event -idle !scale
 …
 # ----------------------------------------------------------------------
+# USAGE: replace <index> <xmlobj> <path>
+#
+# Stores a new result to this result viewer, overwriting the previous
+# result at position <index>.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultViewer::replace {index xmlobj path} {
+    set dobj [lindex $_dataobjs $index]
+    if {"" != $dobj} {
+        itcl::delete object $dobj
+    }
+    set dobj [_xml2data $xmlobj $path]
+    set _dataobjs [lreplace $_dataobjs $index $index $dobj]
+    $_dispatcher event -idle !scale
+}
+# ----------------------------------------------------------------------
+# USAGE: clear
+#
+# Clears all results in this result viewer.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultViewer::clear {} {
+    plot clear
+    foreach obj $_dataobjs {
+        itcl::delete object $obj
+    }
+    set _dataobjs ""
+# USAGE: clear ?<index>?
+#
+# Clears one or all results in this result viewer.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultViewer::clear {{index ""}} {
+    if {"" != $index} {
+        # clear one result
+        if {$index >= 0 && $index < [llength $_dataslots]} {
+            set slot [lindex $_dataslots $index]
+            foreach dobj $slot {
+                itcl::delete object $dobj
+            }
+            set _dataslots [lreplace $_dataslots $index $index ""]
+        }
+    } else {
+        # clear all results
+        plot clear
+        foreach slot $_dataslots {
+            foreach dobj $slot {
+                itcl::delete object $dobj
+            }
+        }
+        set _dataslots ""
+    }
+}
 …
         add {
             foreach {index opts} $args {
+                set dobj [lindex $_dataobjs $index]
+                if {"" != $dobj} {
+                    _plotAdd $dobj $opts
+                set slot [lindex $_dataslots $index]
+                foreach dobj $slot {
+                    # start with default settings from data object
+                    if {[catch {$dobj hints style} settings]} {
+                        set settings ""
+                    }
+                    # add override settings passed in here
+                    eval lappend settings $opts
+                    _plotAdd $dobj $settings
+                }
+            }
 …
                     set mode "contour"
                     if {![info exists _mode2widget($mode)]} {
                         set w $itk_interior.xy
+                        set w $itk_interior.contour
                         Rappture::ContourResult $w
                         set _mode2widget($mode) $w
 …
                 default {
                     error "can't handle [$dataobj components -dimensions] field"
+                }
+            }
+        }
+        ::Rappture::Table {
+            set cols [Rappture::EnergyLevels::columns $dataobj]
+            if {"" != $cols} {
+                set mode "energies"
+                if {![info exists _mode2widget($mode)]} {
+                    set w $itk_interior.energies
+                    Rappture::EnergyLevels $w
+                    set _mode2widget($mode) $w
+                }
+            }
 …
+                    }
+                }
-                table {
-                    # table for now -- should have a Table object!
-                    set mode "energies"
-                    if {![info exists _mode2widget($mode)]} {
-                        set w $itk_interior.energies
-                        Rappture::EnergyLevels $w
-                        set _mode2widget($mode) $w
+                    }
+                }
+            }
+        }
 …
     if {$mode != $_mode && $_mode != ""} {
+        return  ;# mixing data that doesn't mix -- ignore it!
+        set nactive [llength [$_mode2widget($_mode) get]]
+        if {$nactive > 0} {
+            return  ;# mixing data that doesn't mix -- ignore it!
+        }
+    }
 …
 itcl::body Rappture::ResultViewer::_fixScale {args} {
     if {"" != $_mode} {
+        eval $_mode2widget($_mode) scale $_dataobjs
+        set dlist ""
+        foreach slot $_dataslots {
+            foreach dobj $slot {
+                lappend dlist $dobj
+            }
+        }
+        eval $_mode2widget($_mode) scale $dlist
+    }
+}
 …
+        }
         table {
             return [$xmlobj element -as object $path]
+            return [Rappture::Table ::#auto $xmlobj $path]
+        }
         log {

trunk/gui/scripts/table.tcl

-                      r11
+                      r13
 #  COMPONENT: table - extracts data from an XML description of a table
+#
 #  This object represents one table in an XML description of a device.
+#  This object represents one table in an XML description of a table.
 #  It simplifies the process of extracting data representing columns
 #  in the table.
 …
 # ======================================================================
 package require Itcl
-package require BLT
 namespace eval Rappture { # forward declaration }
 itcl::class Rappture::Table {
     constructor {libobj path} { # defined below }
+    constructor {xmlobj path} { # defined below }
     destructor { # defined below }
     public method rows {}
+    public method columns {{pattern *}}
+    public method vectors {{what -overall}}
+    public method columns {args}
+    public method values {args}
+    public method limits {col}
     public method hints {{key ""}}
+    protected method _build {}
+    private variable _units ""   ;# system of units for this table
+    private variable _limits     ;# maps slab name => {z0 z1} limits
+    private variable _zmax 0     ;# length of the device
+    private variable _xmlobj ""  ;# ref to lib obj with curve data
     private variable _table ""   ;# lib obj representing this table
+    private variable _tree ""    ;# BLT tree used to contain table data
+    private common _counter 0    ;# counter for unique vector names
+    private variable _tuples ""  ;# list of tuples with table data
+}
 …
 # CONSTRUCTOR
 # ----------------------------------------------------------------------
+itcl::body Rappture::Table::constructor {libobj path} {
+    if {![Rappture::library isvalid $libobj]} {
+        error "bad value \"$libobj\": should be LibraryObj"
+    }
+    set _table [$libobj element -as object $path]
+    set _units [$_table get units]
+    # determine the overall size of the device
+    set z0 [set z1 0]
+    foreach elem [$_device children recipe] {
+        switch -glob -- $elem {
+            slab* - molecule* {
+                if {![regexp {[0-9]$} $elem]} {
+                    set elem "${elem}0"
+                }
+                set tval [$_device get recipe.$elem.thickness]
+                set tval [Rappture::Units::convert $tval \
+                    -context um -to um -units off]
+                set z1 [expr {$z0+$tval}]
+                set _limits($elem) [list $z0 $z1]
+                set z0 $z1
+            }
+        }
+    }
+    set _zmax $z1
+    # build up vectors for various components of the table
+    _build
+itcl::body Rappture::Table::constructor {xmlobj path} {
+    if {![Rappture::library isvalid $xmlobj]} {
+        error "bad value \"$xmlobj\": should be Rappture::library"
+    }
+    set _table [$xmlobj element -as object $path]
+    #
+    # Load data from the table and store in the tuples.
+    #
+    set _tuples [Rappture::Tuples ::#auto]
+    foreach cname [$_table children -type column] {
+        set label [$_table get $cname.label]
+        $_tuples column insert end -name $cname -label $label
+    }
+    set cols [llength [$_tuples column names]]
+    set nline 1
+    foreach line [split [$_table get data] \n] {
+        if {[llength $line] == 0} {
+            continue
+        }
+        if {[llength $line] != $cols} {
+            error "bad data at line $nline: expected $cols columns but got \"[string trim $line]\""
+        }
+        $_tuples insert end $line
+        incr nline
+    }
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Table::destructor {} {
+    itcl::delete object $_tuples
     itcl::delete object $_table
+    # don't destroy the _device! we don't own it!
+    foreach name [array names _comp2vecs] {
+        eval blt::vector destroy $_comp2vecs($name)
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: components ?<pattern>?
+#
+# Returns a list of names for the various components of this table.
+# If the optional glob-style <pattern> is specified, then it returns
+# only the component names matching the pattern.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Table::components {{pattern *}} {
+    # don't destroy the _xmlobj! we don't own it!
+}
+# ----------------------------------------------------------------------
+# USAGE: rows
+#
+# Returns the number of rows of information in this table.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Table::rows {} {
+    return [$_tuples size]
+}
+# ----------------------------------------------------------------------
+# USAGE: columns ?-component|-label|-units? ?<pos>?
+#
+# Returns information about the columns associated with this table.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Table::columns {args} {
+    Rappture::getopts args params {
+        flag switch -component
+        flag switch -label default
+        flag switch -units
+    }
+    if {[llength $args] == 0} {
+        set cols [llength [$_tuples column names]]
+        set plist ""
+        for {set i 0} {$i < $cols} {incr i} {
+            lappend plist $i
+        }
+    } elseif {[llength $args] == 1} {
+        set p [lindex $args 0]
+        if {[string is integer $p]} {
+            lappend plist $p
+        } else {
+            set pos [lsearch -exact [$_tuples column names] $p]
+            if {$pos < 0} {
+                error "bad column \"$p\": should be column name or integer index"
+            }
+            lappend plist $pos
+        }
+    } else {
+        error "wrong # args: should be \"columns ?-component|-label|-units? ?pos?\""
+    }
     set rlist ""
+    foreach name [array names _comp2vecs] {
+        if {[string match $pattern $name]} {
+            lappend rlist $name
+    switch -- $params(switch) {
+        -component {
+            set names [$_tuples column names]
+            foreach p $plist {
+                lappend rlist [lindex $names $p]
+            }
+        }
+        -label {
+            set names [$_tuples column names]
+            foreach p $plist {
+                set name [lindex $names $p]
+                catch {unset opts}
+                array set opts [$_tuples column info $name]
+                lappend rlist $opts(-label)
+            }
+        }
+        -units {
+            set names [$_tuples column names]
+            foreach p $plist {
+                set comp [lindex $names $p]
+                lappend rlist [$_table get $comp.units]
+            }
+        }
+    }
 …
 # ----------------------------------------------------------------------
+# USAGE: vectors ?<name>?
+#
+# Returns a list {xvec yvec} for the specified table component <name>.
+# If the name is not specified, then it returns the vectors for the
+# overall table (sum of all components).
+# ----------------------------------------------------------------------
+itcl::body Rappture::Table::vectors {{what -overall}} {
+    if {[info exists _comp2vecs($what)]} {
+        return $_comp2vecs($what)
+    }
+    error "bad option \"$what\": should be [join [lsort [array names _comp2vecs]] {, }]"
+# USAGE: values ?-row <index>? ?-column <index>?
+#
+# Returns a single value or a list of values for data in this table.
+# If a particular -row and -column is specified, then it returns
+# a single value for that row/column.  If either the -row or the
+# -column is specified, then it returns a list of values in that
+# row or column.  With no args, it returns all values in the table.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Table::values {args} {
+    Rappture::getopts args params {
+        value -row ""
+        value -column ""
+    }
+    if {[llength $args] > 0} {
+        error "wrong # args: should be \"values ?-row r? ?-column c?\""
+    }
+    if {"" == $params(-row) && "" == $params(-column)} {
+        return [$_tuples get]
+    } elseif {"" == $params(-column)} {
+        return [lindex [$_tuples get $params(-row)] 0]
+    }
+    if {[string is integer $params(-column)]} {
+        set col [lindex [$_tuples column names] $params(-column)]
+    } else {
+        set col $params(-column)
+        if {"" == [$_tuples column names $col]} {
+            error "bad column name \"$col\": should be [join [$_tuples column names] {, }]"
+        }
+    }
+    if {"" == $params(-row)} {
+        # return entire column
+        return [$_tuples get -format $col]
+    }
+    # return a particular cell
+    return [$_tuples get -format $col $params(-row)]
+}
+# ----------------------------------------------------------------------
+# USAGE: limits <column>
+#
+# Returns the {min max} limits of the numerical values in the
+# specified <column>, which can be either an integer index to
+# a column or a column name.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Table::limits {column} {
+    set min ""
+    set max ""
+    foreach v [values -column $column] {
+        if {"" == $min} {
+            set min $v
+            set max $v
+        } else {
+            if {$v < $min} { set min $v }
+            if {$v > $max} { set max $v }
+        }
+    }
+    return [list $min $max]
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Table::hints {{keyword ""}} {
+    foreach key {label scale color units restrict} {
+        set str [$_table get $key]
+    foreach {key path} {
+        label   about.label
+        color   about.color
+        style   about.style
+    } {
+        set str [$_table get $path]
         if {"" != $str} {
             set hints($key) $str
 …
     return [array get hints]
+}
-# ----------------------------------------------------------------------
-# USAGE: _build
+#
-# Used internally to build up the vector representation for the
-# table when the object is first constructed, or whenever the table
-# data changes.  Discards any existing vectors and builds everything
-# from scratch.
-# ----------------------------------------------------------------------
-itcl::body Rappture::Table::_build {} {
-    # discard any existing data
-    foreach name [array names _comp2vecs] {
-        eval blt::vector destroy $_comp2vecs($name)
+    }
-    catch {unset _comp2vecs}
+    #
-    # Scan through the components of the table and create
-    # vectors for each part.
+    #
-    foreach cname [$_table children -type component] {
-        set xv ""
-        set yv ""
-        set val [$_table get $cname.constant]
-        if {$val != ""} {
-            set domain [$_table get $cname.domain]
-            if {$domain == "" || ![info exists _limits($domain)]} {
-                set z0 0
-                set z1 $_zmax
-            } else {
-                foreach {z0 z1} $_limits($domain) { break }
+            }
-            set xv [blt::vector create x$_counter]
-            $xv append $z0 $z1
-            if {$_units != ""} {
-                set val [Rappture::Units::convert $val \
-                    -context $_units -to $_units -units off]
+            }
-            set yv [blt::vector create y$_counter]
-            $yv append $val $val
-            set zm [expr {0.5*($z0+$z1)}]
-        } else {
-            set xydata [$_table get $cname.xy]
-            if {"" != $xydata} {
-                set xv [blt::vector create x$_counter]
-                set yv [blt::vector create y$_counter]
-                foreach line [split $xydata \n] {
-                    if {[scan $line {%g %g} xval yval] == 2} {
-                        $xv append $xval
-                        $yv append $yval
+                    }
+                }
+            }
+        }
-        if {$xv != "" && $yv != ""} {
-            set _comp2vecs($cname) [list $xv $yv]
-            incr _counter
+        }
+    }
+}

trunk/gui/scripts/textresult.tcl

-                      r11
+                      r13
     public method add {dataobj {settings ""}}
+    public method get {}
     public method delete {args}
     public method scale {args}
+    set _dataobj ""  ;# data object currently being displayed
+}
 …
 # Clients use this to add a data object to the plot.  If the optional
 # <settings> are specified, then the are applied to the data.  Allowed
+# settings are -color and -width/-raise (ignored).
+# settings are -color and -brightness, -width, -linestyle and -raise.
+# (Many of these are ignored.)
 # ----------------------------------------------------------------------
 itcl::body Rappture::TextResult::add {dataobj {settings ""}} {
     array set params {
         -color ""
+        -brightness ""
         -width ""
+        -linestyle ""
         -raise ""
+    }
 …
     $itk_component(text) configure -state disabled
+    set _dataobj $dataobj
+}
+# ----------------------------------------------------------------------
+# USAGE: get
+#
+# Clients use this to query the list of objects being plotted, in
+# order from bottom to top of this result.
+# ----------------------------------------------------------------------
+itcl::body Rappture::TextResult::get {} {
+    return $_dataobj
+}
 …
     $itk_component(text) delete 1.0 end
     $itk_component(text) configure -state disabled
+    set _dataobj ""
+}

trunk/gui/scripts/tool.tcl

-                      r11
+                      r13
     public method load {xmlobj}
-    public method changed {path}
     public method run {args}
     public method abort {}
     public method widgetfor {path {widget ""}}
+    public method changed {path}
     public method sync {}
+    public method tool {}
     private variable _xmlobj ""      ;# XML overall <run> object
 …
 # USAGE: widgetfor <path> ?<widget>?
+#
 # Used by descendents such as a Controls panel to register the
+# Used by embedded widgets such as a Controls panel to register the
 # various controls associated with this page.  That way, this Tool
 # knows what widgets to look at when syncing itself to the underlying
 …
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: tool
+#
+# Clients use this to figure out which tool is associated with
+# this object.  Since this is a tool, it returns itself.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Tool::tool {} {
+    return $this
+}

trunk/gui/scripts/xyresult.tcl

-                      r12
+                      r13
 option add *XyResult.height 4i widgetDefault
 option add *XyResult.gridColor #d9d9d9 widgetDefault
+option add *XyResult.hiliteColor black widgetDefault
+option add *XyResult.controlBackground gray widgetDefault
 option add *XyResult.font \
     -*-helvetica-medium-r-normal-*-*-120-* widgetDefault
+blt::bitmap define ContourResult-reset {
+#define reset_width 12
+#define reset_height 12
+static unsigned char reset_bits[] = {
+x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x04, 0x02, 0x04, 0x02, 0x04, 0x02,
+x04, 0x02, 0x04, 0x02, 0x04, 0x02, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00};
+}
 itcl::class Rappture::XyResult {
     inherit itk::Widget
     itk_option define -gridcolor gridColor GridColor ""
+    itk_option define -hilitecolor hiliteColor HiliteColor ""
     constructor {args} { # defined below }
 …
     public method add {curve {settings ""}}
+    public method get {}
     public method delete {args}
     public method scale {args}
 …
     protected method _rebuild {}
     protected method _fixLimits {}
+    protected method _zoom {option args}
+    protected method _hilite {state x y}
     private variable _clist ""     ;# list of curve objects
     private variable _curve2color  ;# maps curve => plotting color
     private variable _curve2width  ;# maps curve => line width
+    private variable _curve2dashes ;# maps curve => BLT -dashes list
     private variable _curve2raise  ;# maps curve => raise flag 0/1
     private variable _curve2elems  ;# maps curve => elements on graph
+    private variable _elem2curve   ;# maps graph element => curve
     private variable _xmin ""      ;# autoscale min for x-axis
     private variable _xmax ""      ;# autoscale max for x-axis
     private variable _ymin ""      ;# autoscale min for y-axis
     private variable _ymax ""      ;# autoscale max for y-axis
+    private variable _hilite ""    ;# info from last _hilite operation
+}
 …
     option add hull.width hull.height
     pack propagate $itk_component(hull) no
+    itk_component add controls {
+        frame $itk_interior.cntls
+    } {
+        usual
+        rename -background -controlbackground controlBackground Background
+    }
+    pack $itk_component(controls) -side right -fill y
+    itk_component add reset {
+        button $itk_component(controls).reset \
+            -borderwidth 1 -padx 1 -pady 1 \
+            -bitmap ContourResult-reset \
+            -command [itcl::code $this _zoom reset]
+    } {
+        usual
+        ignore -borderwidth
+        rename -highlightbackground -controlbackground controlBackground Background
+    }
+    pack $itk_component(reset) -padx 4 -pady 4
+    Rappture::Tooltip::for $itk_component(reset) "Reset the view to the default zoom level"
     itk_component add plot {
 …
     pack $itk_component(plot) -expand yes -fill both
+    # special pen for highlighting active traces
+    $itk_component(plot) element bind all <Enter> \
+        [itcl::code $this _hilite on %x %y]
+    $itk_component(plot) element bind all <Leave> \
+        [itcl::code $this _hilite off %x %y]
     Blt_ZoomStack $itk_component(plot)
     $itk_component(plot) legend configure -hide yes
 …
+#
 # Clients use this to add a curve to the plot.  The optional <settings>
 # are used to configure the plot.  Allowed settings are -color, -width,
 # and -raise.
+# are used to configure the plot.  Allowed settings are -color,
+# -brightness, -width, -linestyle and -raise.
 # ----------------------------------------------------------------------
 itcl::body Rappture::XyResult::add {curve {settings ""}} {
     array set params {
         -color black
+        -brightness 0
         -width 1
         -raise 0
+        -linestyle solid
+    }
     foreach {opt val} $settings {
 …
+        }
         set params($opt) $val
+    }
+    # convert -linestyle to BLT -dashes
+    switch -- $params(-linestyle) {
+        dashed { set params(-linestyle) {4 4} }
+        dotted { set params(-linestyle) {2 4} }
+        default { set params(-linestyle) {} }
+    }
+    # if -brightness is set, then update the color
+    if {$params(-brightness) != 0} {
+        set params(-color) [Rappture::color::brightness \
+            $params(-color) $params(-brightness)]
+    }
 …
         set _curve2color($curve) $params(-color)
         set _curve2width($curve) $params(-width)
+        set _curve2dashes($curve) $params(-linestyle)
         set _curve2raise($curve) $params(-raise)
 …
         after idle [itcl::code $this _rebuild]
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: get
+#
+# Clients use this to query the list of objects being plotted, in
+# order from bottom to top of this result.
+# ----------------------------------------------------------------------
+itcl::body Rappture::XyResult::get {} {
+    # put the dataobj list in order according to -raise options
+    set clist $_clist
+    foreach obj $clist {
+        if {[info exists _curve2raise($obj)] && $_curve2raise($obj)} {
+            set i [lsearch -exact $clist $obj]
+            if {$i >= 0} {
+                set clist [lreplace $clist $i $i]
+                lappend clist $obj
+            }
+        }
+    }
+    return $clist
+}
 …
             catch {unset _curve2color($curve)}
             catch {unset _curve2width($curve)}
+            catch {unset _curve2dashes($curve)}
             catch {unset _curve2raise($curve)}
+            catch {unset _curve2elems($curve)}
+            foreach elem [array names _elem2curve] {
+                if {$_elem2curve($elem) == $curve} {
+                    unset _elem2curve($elem)
+                }
+            }
             set changed 1
+        }
 …
     # extract axis information from the first curve
+    set xydata [lindex $_clist 0]
+    set clist [get]
+    set xydata [lindex $clist 0]
     if {$xydata != ""} {
         set legend [$xydata hints legend]
 …
     # plot all of the curves
     set count 0
+    foreach xydata $_clist {
+        set _curve2elems($xydata) ""
+    foreach xydata $clist {
         foreach comp [$xydata components] {
             set xv [$xydata mesh $comp]
 …
+            }
+            if {[info exists _curve2dashes($xydata)]} {
+                set dashes $_curve2dashes($xydata)
+            } else {
+                set dashes ""
+            }
+            if {[$xv length] <= 1} {
+                set sym square
+            } else {
+                set sym ""
+            }
             set elem "elem[incr count]"
             lappend _curve2elems($xydata) $elem
+            set _elem2curve($elem) $xydata
             set label [$xydata hints label]
             $g element create $elem -x $xv -y $yv \
+                -symbol "" -linewidth $lwidth -label $label -color $color
+            set style [$xydata hints style]
+            if {$style != ""} {
+                eval $g element configure $elem $style
+            }
+        }
+    }
+    # raise those tagged to be on top
+    set dlist [$g element show]
+    foreach xydata $_clist {
+        if {[info exists _curve2raise($xydata)] && $_curve2raise($xydata)} {
+            foreach elem $_curve2elems($xydata) {
+                set i [lsearch -exact $dlist $elem]
+                if {$i >= 0} {
+                    # move element to end of display list
+                    set dlist [lreplace $dlist $i $i]
+                    lappend dlist $elem
+                }
+            }
+        }
+    }
+    $g element show $dlist
+                -symbol $sym -pixels 6 -linewidth $lwidth -label $label \
+                -color $color -dashes $dashes
+        }
+    }
     _fixLimits
 …
     # limits.
+    #
+    $g axis configure x -min $_xmin -max $_xmax
+    if {$_xmin != $_xmax} {
+        $g axis configure x -min $_xmin -max $_xmax
+    } else {
+        $g axis configure x -min "" -max ""
+    }
     if {"" != $_ymin && "" != $_ymax} {
 …
+            }
+        }
+        $g axis configure y -min $min -max $max
+        if {$min != $max} {
+            $g axis configure y -min $min -max $max
+        } else {
+            $g axis configure y -min "" -max ""
+        }
     } else {
         $g axis configure y -min "" -max ""
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: _zoom reset
+#
+# Called automatically when the user clicks on one of the zoom
+# controls for this widget.  Changes the zoom for the current view.
+# ----------------------------------------------------------------------
+itcl::body Rappture::XyResult::_zoom {option args} {
+    switch -- $option {
+        reset {
+            _fixLimits
+        }
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: _hilite <state> <x> <y>
+#
+# Called automatically when the user brushes one of the elements
+# on the plot.  Causes the element to highlight and a tooltip to
+# pop up with element info.
+# ----------------------------------------------------------------------
+itcl::body Rappture::XyResult::_hilite {state x y} {
+    set elem [$itk_component(plot) element get current]
+    if {$state} {
+        #
+        # Highlight ON:
+        # - fatten line
+        # - change color
+        # - pop up tooltip about data
+        #
+        set t [$itk_component(plot) element cget $elem -linewidth]
+        $itk_component(plot) element configure $elem -linewidth [expr {$t+2}]
+        set _hilite [$itk_component(plot) element cget $elem -color]
+        $itk_component(plot) element configure $elem \
+            -color $itk_option(-hilitecolor)
+        set tip ""
+        if {[info exists _elem2curve($elem)]} {
+            set curve $_elem2curve($elem)
+            set tip [$curve hints tooltip]
+        }
+        if {"" != $tip} {
+            set x [expr {$x+4}]  ;# move the tooltip over a bit
+            set y [expr {$y+4}]
+            Rappture::Tooltip::text $itk_component(plot) $tip
+            Rappture::Tooltip::tooltip show $itk_component(plot) +$x,$y
+        }
+    } else {
+        #
+        # Highlight OFF:
+        # - put line width back to normal
+        # - put color back to normal
+        # - take down tooltip
+        #
+        set t [$itk_component(plot) element cget $elem -linewidth]
+        $itk_component(plot) element configure $elem -linewidth [expr {$t-2}]
+        if {"" != $_hilite} {
+            $itk_component(plot) element configure $elem -color $_hilite
+        }
+        Rappture::Tooltip::tooltip cancel
+    }
+}

trunk/tcl/install.tcl

-                      r12
+                      r13
-#!/bin/sh
 # ----------------------------------------------------------------------
 #  USAGE: tclsh install
+#  USAGE: tclsh install.tcl
+#
 #  Use this script to install the Rappture toolkit into an existing
 …
 #  Copyright (c) 2004  Purdue Research Foundation, West Lafayette, IN
 # ======================================================================
-#\
-exec tclsh "$0" "$*"
-# ----------------------------------------------------------------------
-# tclsh executes everything from here on...
 # run this script from directory containing it
 …
+}
+proc fixperms {target perms} {
+    global tcl_platform
+    if {$tcl_platform(platform) == "unix"} {
+        file attributes $target -permissions $perms
+    }
+}
 set dir [file dirname [info library]]
 …
             puts "making directory $target..."
             catch {file mkdir $target}
             file attributes $target -permissions ugo+rx
+            fixperms $target ugo+rx
         } else {
             puts "installing $target..."
             file copy -force $file $target
             file attributes $target -permissions ugo+r
+            fixperms $target ugo+r
+        }
+    }
 …
         puts "making directory $target..."
         catch {file mkdir $target}
         file attributes $target -permissions ugo+rx
+        fixperms $target ugo+rx
     } else {
         puts "installing $target..."
         file copy -force $file $target
         file attributes $target -permissions ugo+r
+        fixperms $target ugo+r
+    }
+}
 …
 puts $fid "package ifneeded $package $version \""
 puts $fid "  \[list lappend auto_path \[file join \$dir scripts\]\]"
 puts $fid "  namespace eval Rappture \[list variable installdir \$dir\]"
+puts $fid "  namespace eval \[list Rappture \[list variable installdir \$dir\]\]"
 puts $fid "  package provide $package $version"
 puts $fid "\""
 …
 mkindex [file join $targetdir scripts]
+puts "== $package-$version INSTALLED"
+if {[catch {package require Tk}] == 0} {
+    wm withdraw .
+    tk_messageBox -icon info -message "$package-$version INSTALLED"
+} else {
+    puts "== $package-$version INSTALLED"
+}
+exit 0

trunk/tcl/scripts/library.tcl

-                      r11
+                      r13
         foreach cpath [$xmlobj children -as path $path] {
             switch -- [$xmlobj element -as type $cpath] {
                 group {
+                group - phase {
                     lappend queue $cpath
+                }
 …
                     # if this element has embedded groups, add them to the queue
                     foreach ccpath [$xmlobj children -as path $cpath] {
+                        if {[$xmlobj element -as type $ccpath] == "group"} {
+                        set cctype [$xmlobj element -as type $ccpath]
+                        if {$cctype == "group" || $cctype == "phase"} {
                             lappend queue $ccpath
+                        }

Context Navigation

Legend:

trunk/gui/apps/driver

trunk/gui/scripts/analyzer.tcl

trunk/gui/scripts/contourresult.tcl

trunk/gui/scripts/controls.tcl

trunk/gui/scripts/curve.tcl

trunk/gui/scripts/deviceEditor.tcl

trunk/gui/scripts/energyLevels.tcl

trunk/gui/scripts/field.tcl

trunk/gui/scripts/loader.tcl

trunk/gui/scripts/mainwin.tcl

trunk/gui/scripts/resultset.tcl

trunk/gui/scripts/resultviewer.tcl

trunk/gui/scripts/table.tcl

trunk/gui/scripts/textresult.tcl

trunk/gui/scripts/tool.tcl

trunk/gui/scripts/xyresult.tcl

trunk/tcl/install.tcl

trunk/tcl/scripts/library.tcl

Download in other formats: