Changeset 2966

branches/blt4/Makefile.in

-                      r2692
+                      r2966
 ENABLE_GUI      = @ENABLE_GUI@
+HAVE_FFMPEG     = @HAVE_FFMPEG_LIBS@
 TARGETS         = src lang lib
 ifneq ($(ENABLE_GUI),)
   TARGETS += gui builder tester examples
+endif
+ifeq ($(HAVE_FFMEG),)
+  TARGETS += video
 endif
 …
           $(MAKE) -C $$i all || exit 1 ;\
         done
 test:
+test:
         $(MAKE) -C test all

branches/blt4/gui/scripts/balloon.tcl

-                      r1923
+                      r2966
     inherit itk::Toplevel
+    itk_option define -background background Background ""
     itk_option define -deactivatecommand deactivateCommand DeactivateCommand ""
     itk_option define -dismissbutton dismissButton DismissButton "on"
 …
             set dark [Rappture::color::brightness $bg -0.4]
             set rgb [winfo rgb . $bg]
+            set bg [format "#%03x%03x%03x" [lindex $rgb 0] [lindex $rgb 1] [lindex $rgb 2]]
+            set flatbg [format "#%04x%04x%04x" [lindex $rgb 0] [lindex $rgb 1] [lindex $rgb 2]]
+            switch -- $itk_option(-relief) {
+                raised {
+                    set light [Rappture::color::brightness $bg 0.4]
+                    set dark [Rappture::color::brightness $bg -0.4]
+                    set bg $flatbg
+                }
+                flat - solid {
+                    set light $flatbg
+                    set dark $flatbg
+                    set bg $flatbg
+                }
+                sunken {
+                    set light [Rappture::color::brightness $bg -0.4]
+                    set dark [Rappture::color::brightness $bg 0.4]
+                    set bg $flatbg
+                }
+            }
+            set bg [format "#%04x%04x%04x" [lindex $rgb 0] [lindex $rgb 1] [lindex $rgb 2]]
             $_fills($dir) put $bg -to 0 0 $sw $sh
 …
 # ----------------------------------------------------------------------
+# CONFIGURATION OPTION: -background
+# ----------------------------------------------------------------------
+itcl::configbody Rappture::Balloon::background {
+    _createStems
+}
+# ----------------------------------------------------------------------
 # CONFIGURATION OPTION: -stemlength
+#

branches/blt4/gui/scripts/controlOwner.tcl

-                      r1923
+                      r2966
     # in coordination with loaders inside the load function
     array set _type2curpath {
+        drawing components
         choice current
         boolean current
 …
         note contents
         number current
+        periodicelement current
         string current
+    }

branches/blt4/gui/scripts/drawingentry.tcl

-                      r1923
+                      r2966
 itcl::class Rappture::DrawingEntry {
     inherit itk::Widget
     itk_option define -state state State "normal"
+    private variable _owner
+    private variable _path
+    private variable _cname2id
+    private variable _worldX 0
+    private variable _worldY 0
+    private variable _worldWidth 0
+    private variable _worldHeight 0
     constructor {owner path args} { # defined below }
 …
     public method label {}
     public method tooltip {}
+    private method ParseDescription {}
+    private method ParseLineDescription { cname }
+    private method ParseGridDescription { cname }
+    private method ParseTextDescription { cname }
+    private method ParseStringDescription { cname }
+    private method ParseNumberDescription { cname }
+    private method GetCanvasHeight { }
+    private method GetCanvasWidth { }
+    private method ScreenX { x }
+    private method ScreenY { y }
+    private method ScreenCoords { coords }
+    private method Highlight { tag }
+    private method Unhighlight { tag }
+}
 …
+    }
     set _path $path
+    set _owner $owner
+    #
     # Display the current drawing.
+    #
     itk_component add drawing {
+        Rappture::Drawing $itk_interior.drawing $owner $path
+        canvas $itk_interior.canvas -background white -relief sunken -bd 1
+    } {
+        ignore -background
+    }
     pack $itk_component(drawing) -expand yes -fill both
+    ParseDescription
     eval itk_initialize $args
+}
 …
+    }
+}
+itcl::body Rappture::DrawingEntry::ParseLineDescription { cname } {
+    array set attr2option {
+        "linewidth"     "-width"
+        "arrow"         "-arrow"
+        "dash"          "-dash"
+        "color"         "-fill"
+    }
+    # Set default options first and then let tool.xml override them.
+    array set options {
+        -arrow          none
+        -width          0
+        -fill           black
+        -dash           ""
+    }
+    # Coords
+    set coords {}
+    set coords [$_owner xml get $_path.components.$cname.coords]
+    set coords [string trim $coords]
+    if { $coords == "" } {
+        set coords "0 0"
+    } else {
+        set coords [ScreenCoords $coords]
+    }
+    puts stderr "ParseLineDescrption description owner=$_owner path=$_path coords=$coords"
+    set list {}
+    foreach attr [$_owner xml children $_path.components.$cname] {
+        if { [info exists attr2option($attr)] } {
+            set option $attr2option($attr)
+            set value [$_owner xml get $_path.components.$cname.$attr]
+            set options($option) $value
+        }
+    }
+    puts stderr "$itk_component(drawing) create line $coords"
+    set id [eval $itk_component(drawing) create line $coords]
+    set _cname2id($cname) $id
+    eval $itk_component(drawing) itemconfigure $id [array get options]
+}
+#
+# ParseGridDescription --
+#
+itcl::body Rappture::DrawingEntry::ParseGridDescription { cname } {
+    puts stderr "ParseGridDescrption description owner=$_owner path=$_path"
+    foreach attr [$_owner xml children $_path.components.$cname] {
+        puts stderr attr=$attr
+    }
+    array set attr2option {
+        "linewidth"     "-width"
+        "arrow"         "-arrow"
+        "dash"          "-dash"
+        "color"         "-fill"
+    }
+    # Set default options first and then let tool.xml override them.
+    array set options {
+        -arrow          none
+        -width          0
+        -fill           black
+        -dash           ""
+    }
+    # Coords
+    set xcoords [$_owner xml get $_path.components.$cname.xcoords]
+    set xcoords [string trim $xcoords]
+    set ycoords [$_owner xml get $_path.components.$cname.ycoords]
+    set ycoords [string trim $ycoords]
+    if { $ycoords == "" } {
+        set ycoords "0 1"
+        set ymax 1
+        set ymin 0
+    } else {
+        set list {}
+        set ymax -10000
+        set ymin 10000
+        foreach c $ycoords {
+            set y [ScreenY $c]
+            if { $y > $ymax } {
+                set ymax $y
+            }
+            if { $y < $ymin } {
+                set ymin $y
+            }
+            lappend list $y
+        }
+        set ycoords $list
+    }
+    if { $xcoords == "" } {
+        set xcoords "0 1"
+        set xmax 1
+        set xmin 0
+    } else {
+        set list {}
+        set xmax -10000
+        set xmin 10000
+        foreach c $xcoords {
+            set x [ScreenX $c]
+            if { $x > $xmax } {
+                set xmax $x
+            }
+            if { $x < $xmin } {
+                set xmin $x
+            }
+            lappend list $x
+        }
+        set xcoords $list
+    }
+    puts stderr "ParseLineDescrption description owner=$_owner path=$_path xcoords=$xcoords ycoords=$ycoords"
+    set list {}
+    foreach attr [$_owner xml children $_path.components.$cname] {
+        if { [info exists attr2option($attr)] } {
+            set option $attr2option($attr)
+            set value [$_owner xml get $_path.components.$cname.$attr]
+            set options($option) $value
+        }
+    }
+    foreach y $ycoords {
+        lappend ids \
+            [eval $itk_component(drawing) create line $xmin $y $xmax $y \
+                 [array get options]]
+    }
+    foreach x $xcoords {
+        lappend ids \
+            [eval $itk_component(drawing) create line $x $ymin $x $ymax \
+                 [array get options]]
+    }
+    set _cname2id($cname) $ids
+}
+itcl::body Rappture::DrawingEntry::ParseTextDescription { cname } {
+    array set attr2option {
+        "font"          "-font"
+        "default"       "-text"
+        "color"         "-fill"
+        "text"          "-text"
+        "anchor"        "-anchor"
+    }
+    puts stderr "ParseStringDescrption description owner=$_owner path=$_path"
+    # Set default options first and then let tool.xml override them.
+    array set options {
+        -font {Arial 12}
+        -text {}
+        -fill black
+        -anchor c
+    }
+    foreach attr [$_owner xml children $_path.components.$cname] {
+        if { [info exists attr2option($attr)] } {
+            set option $attr2option($attr)
+            set value [$_owner xml get $_path.components.$cname.$attr]
+            set options($option) $value
+        }
+    }
+    # Coords
+    set coords {}
+    set coords [$_owner xml get $_path.components.$cname.coords]
+    set coords [string trim $coords]
+    if { $coords == "" } {
+        set coords "0 0"
+    } else {
+        set coords [ScreenCoords $coords]
+    }
+    puts stderr "$itk_component(drawing) create text $coords"
+    set id [eval $itk_component(drawing) create text $coords]
+    set _cname2id($cname) $id
+    puts stderr "$itk_component(drawing) itemconfigure $id [array get options]"
+    eval $itk_component(drawing) itemconfigure $id [array get options]
+}
+itcl::body Rappture::DrawingEntry::ParseStringDescription { cname } {
+    array set attr2option {
+        "font"          "-font"
+        "default"       "-text"
+        "color"         "-fill"
+    }
+    puts stderr "ParseStringDescrption description owner=$_owner path=$_path"
+    # Set default options first and then let tool.xml override them.
+    array set options {
+        -font {Arial 12}
+        -text {}
+        -fill black
+    }
+    foreach attr [$_owner xml children $_path.components.$cname] {
+        if { [info exists attr2option($attr)] } {
+            set option $attr2option($attr)
+            set value [$_owner xml get $_path.components.$cname.$attr]
+            set options($option) $value
+        }
+    }
+    # Coords
+    set coords {}
+    set coords [$_owner xml get $_path.components.$cname.coords]
+    set coords [string trim $coords]
+    if { $coords == "" } {
+        set coords "0 0"
+    }
+    # Is there a label?
+    set label [$_owner xml get $_path.components.$cname.about.label]
+    set labelWidth 0
+    if { $label != "" } {
+        set labelId [$itk_component(drawing) create text -1000 -1000 \
+                         -text $label -font $options(-font)]
+        set labelWidth [font measure $options(-font) $label]
+    }
+    set id [$itk_component(drawing) create text -1000 -1000  -tag $cname]
+    set entryWidth [font measure $options(-font) $options(-text) ]
+    foreach { x y } [ScreenCoords $coords] break
+    set lx $x
+    set ly $y
+    set tx [expr $x + $labelWidth]
+    set ty $y
+    eval $itk_component(drawing) coords $id $tx $ty
+    if { $labelWidth > 0 } {
+        puts stderr "LABEL($labelWidth):$itk_component(drawing) coords $labelId $lx $ly"
+        eval $itk_component(drawing) coords $labelId $lx $ly
+    }
+    set _cname2id($cname) $id
+    puts stderr "$itk_component(drawing) itemconfigure $id [array get options]"
+    eval $itk_component(drawing) itemconfigure $id [array get options]
+    set bbox [$itk_component(drawing) bbox $id]
+    puts stderr "cname=$cname bbox=$bbox"
+    set sid [eval $itk_component(drawing) create rectangle $bbox]
+    $itk_component(drawing) itemconfigure $sid -fill "" -outline "" \
+        -tag $cname-bg
+    set sid [eval $itk_component(drawing) create rectangle $bbox]
+    $itk_component(drawing) itemconfigure $sid -fill "" -outline "" \
+        -tag $cname-sensor
+    $itk_component(drawing) bind $cname-sensor <Enter> \
+        [itcl::code $this Highlight $cname]
+    $itk_component(drawing) bind $cname-sensor <Leave> \
+        [itcl::code $this Unhighlight $cname]
+    $itk_component(drawing) lower $cname-bg
+    $itk_component(drawing) raise $cname-sensor
+}
+itcl::body Rappture::DrawingEntry::ParseNumberDescription { cname } {
+    puts stderr "ParseNumberDescrption description owner=$_owner path=$_path"
+    foreach attr [$_owner xml children $_path.components.$cname] {
+        puts stderr attr=$attr
+    }
+}
+itcl::body Rappture::DrawingEntry::ScreenX { x } {
+    set norm [expr ($x - $_worldX) / double($_worldWidth)]
+    puts stderr "ScreenX x=$x, norm=$norm wx=$_worldX ww=$_worldWidth"
+    set x [expr int($norm * [GetCanvasWidth])]
+    puts stderr "ScreenX after x=$x cw=[GetCanvasWidth]"
+    return $x
+}
+itcl::body Rappture::DrawingEntry::ScreenY { y } {
+    set norm [expr ($y - $_worldY) / double($_worldWidth)]
+    set y [expr int($norm * [GetCanvasHeight])]
+    return $y
+}
+itcl::body Rappture::DrawingEntry::ScreenCoords { coords } {
+    set list {}
+    foreach {x y} $coords {
+        lappend list [ScreenX $x] [ScreenY $y]
+    }
+    return $list
+}
+itcl::body Rappture::DrawingEntry::GetCanvasWidth { } {
+    set w [winfo width $itk_component(drawing)]
+    if { $w < 2 } {
+        set w [winfo reqwidth $itk_component(drawing)]
+    }
+    return $w
+}
+itcl::body Rappture::DrawingEntry::GetCanvasHeight { } {
+    set h [winfo height $itk_component(drawing)]
+    if { $h < 2 } {
+        set h [winfo reqheight $itk_component(drawing)]
+    }
+    return $h
+}
+itcl::body Rappture::DrawingEntry::ParseDescription {} {
+    puts stderr "ParseDescrption description owner=$_owner path=$_path"
+    set bbox [$_owner xml get $_path.about.bbox]
+    puts stderr bbox=$bbox
+    if { [llength $bbox] != 4 } {
+        set bbox "0 0 [GetCanvasWidth] [GetCanvasHeight]"
+    }
+    foreach { x1 y1 x2 y2 } $bbox break
+    set _worldWidth [expr $x2 - $x1]
+    set _worldHeight [expr $y2 - $y1]
+    set _worldX $x1
+    set _worldY $y1
+    foreach cname [$_owner xml children $_path.components] {
+        switch -glob -- $cname {
+            "line*" {
+                ParseLineDescription $cname
+            }
+            "grid*" {
+                ParseGridDescription $cname
+            }
+            "text*" {
+                ParseTextDescription $cname
+            }
+            "string*" {
+                ParseStringDescription $cname
+            }
+            "number*" {
+                ParseNumberDescription $cname
+            }
+        }
+    }
+}
+itcl::body Rappture::DrawingEntry::Highlight { tag } {
+    $itk_component(drawing) itemconfigure $tag-bg -outline black \
+        -fill lightblue
+}
+itcl::body Rappture::DrawingEntry::Unhighlight { tag } {
+    $itk_component(drawing) itemconfigure $tag-bg -outline "" \
+        -fill ""
+}

branches/blt4/gui/scripts/icons.tcl

-                      r2745
+                      r2966
     variable iconpath [list [file join $RapptureGUI::library scripts images]]
     variable icons
+}
+# ----------------------------------------------------------------------
+# USAGE: Rappture::icon::searchpath ?<dirname> <dirname>...?
+#
+# Adds one or more directories onto the icon path searched when
+# locating icons in Rappture::icon.  You can do the same thing by
+# lappend'ing onto the "iconpath" variable, but this call avoids
+# duplicates and makes it easier
+# ----------------------------------------------------------------------
+proc Rappture::icon::searchpath {args} {
+    variable iconpath
+    foreach dir $args {
+        if {[file isdirectory $dir]} {
+            if {[lsearch $iconpath $dir] < 0} {
+                lappend iconpath $dir
+            }
+        }
+    }
+}

branches/blt4/gui/scripts/page.tcl

r2327	r2966
79	79	continue
80	80	}
81
82	81	if {$type == "loader"} {
83	82	#
…	…
139	138	#
140	139	set w "$frame.drawing[incr num]"
141		Rappture::DrawingEntry ::$w $_owner $path.$cname~~.current~~
	140	Rappture::DrawingEntry ::$w $_owner $path.$cname
142	141	pack $w -expand yes -fill both
143	142	$_owner widgetfor $path.$cname $w

branches/blt4/gui/scripts/periodictable.tcl

-                      r2745
+                      r2966
     set elem [FindElement $name]
     if { $elem == "" || $_state($elem) == "disabled" } {
+        if { $elem != "" } {
+            puts stderr "element $elem is disabled"
+        }
         return ""
+    }
 …
 # ----------------------------------------------------------------------
 # USAGE: select <name>
+# USAGE: FindElement
+#
 # Used to manipulate the selection in the table.
 …
 itcl::body Rappture::PeriodicTable::FindElement { what } {
     foreach name [array names _table] {
+        array unset info
         array set info $_table($name)
         if { $what == $info(name) || $what == $info(number) ||
              $what == $info(symbol) } {
+            break
+        }
+        array unset info
+    }
+    if { [info exists info] } {
+        return $info(name)
+            return $info(name)
+        }
+    }
     return ""

branches/blt4/gui/scripts/resultset.tcl

-                      r2791
+                      r2966
     itk_option define -boldfont boldFont Font ""
     itk_option define -foreground foreground Foreground ""
-    itk_option define -missingdata missingData MissingData ""
     itk_option define -clearcommand clearCommand ClearCommand ""
     itk_option define -settingscommand settingsCommand SettingsCommand ""
 …
     public method add {xmlobj}
     public method clear {}
+    public method clear {{xmlobj ""}}
     public method activate {column}
     public method contains {xmlobj}
     public method size {{what -results}}
     protected method _doClear {}
+    protected method _doClear {what}
     protected method _doSettings {{cmd ""}}
-    protected method _doPrompt {state}
     protected method _control {option args}
     protected method _fixControls {args}
     protected method _fixLayout {args}
+    protected method _fixNumResults {}
     protected method _fixSettings {args}
-    protected method _fixExplore {}
     protected method _fixValue {column why}
     protected method _drawValue {column widget wmax}
 …
     protected method _getTooltip {role column}
     protected method _getParamDesc {which {index "current"}}
+    protected method _addOneResult {tuples xmlobj {simnum ""}}
     private variable _dispatcher ""  ;# dispatchers for !events
     private variable _results ""     ;# tuple of known results
+    private variable _resultnum 0    ;# counter for result #1, #2, etc.
     private variable _recent ""      ;# most recent result in _results
     private variable _active ""      ;# column with active control
 …
     private variable _counter 0      ;# counter for unique control names
     private variable _settings 0     ;# non-zero => _fixSettings in progress
-    private variable _explore 0      ;# non-zero => explore all parameters
     private common _cntlInfo         ;# maps column name => control info
 …
 itk::usual ResultSet {
     keep -background -foreground -cursor -font
+}
-itk::usual Scrollset {
+}
 …
     set _results [Rappture::Tuples ::#auto]
     $_results column insert end -name xmlobj -label "top-level XML object"
+    $_results column insert end -name simnum -label "simulation number"
 …
     pack $itk_component(cntls) -fill x -pady {0 2}
     itk_component add clear {
         button $itk_component(cntls).clear -text "Clear" -state disabled \
+    itk_component add clearall {
+        button $itk_component(cntls).clearall -text "Clear" -state disabled \
             -padx 1 -pady 1 \
             -relief flat -overrelief raised \
             -command [itcl::code $this _doClear]
+            -command [itcl::code $this _doClear all]
     } {
         usual
 …
         rename -highlightbackground -controlbarbackground controlbarBackground Background
+    }
+    pack $itk_component(clearall) -side right -padx 2 -pady 1
+    Rappture::Tooltip::for $itk_component(clearall) \
+        "Clears all results collected so far."
+    itk_component add clear {
+        button $itk_component(cntls).clear -text "Clear One" -state disabled \
+            -padx 1 -pady 1 \
+            -relief flat -overrelief raised \
+            -command [itcl::code $this _doClear current]
+    } {
+        usual
+        rename -background -controlbarbackground controlbarBackground Background
+        rename -foreground -controlbarforeground controlbarForeground Foreground
+        rename -highlightbackground -controlbarbackground controlbarBackground Background
+    }
     pack $itk_component(clear) -side right -padx 2 -pady 1
     Rappture::Tooltip::for $itk_component(clear) \
         "Clears all results collected so far."
+        "Clears the result that is currently selected."
     itk_component add status {
 …
     pack $itk_component(status) -side left -padx 2 -pady {2 0}
-    itk_component add parameters {
-        button $itk_component(cntls).params -text "Parameters..." \
-            -state disabled -padx 1 -pady 1 \
-            -relief flat -overrelief raised \
-            -command [list $itk_component(hull).popup activate $itk_component(cntls).params above]
-    } {
-        usual
-        rename -background -controlbarbackground controlbarBackground Background
-        rename -foreground -controlbarforeground controlbarForeground Foreground
-        rename -highlightbackground -controlbarbackground controlbarBackground Background
+    }
-    pack $itk_component(parameters) -side left -padx 8 -pady 1
-    Rappture::Tooltip::for $itk_component(parameters) \
-        "Click to access all parameters."
     itk_component add dials {
         frame $itk_interior.dials
 …
     label $dials.labelmore.arrow -bitmap [Rappture::icon empty] -borderwidth 0
     pack $dials.labelmore.arrow -side left -fill y
-    _control bind $dials.labelmore.arrow @more
     label $dials.labelmore.name -text "more parameters..." -font $fn \
         -borderwidth 0 -padx 0 -pady 1
 …
     label $dials.labelmore.value
     pack $dials.labelmore.value -side left
-    _control bind $dials.labelmore.name @more
-    Rappture::Tooltip::for $dials.labelmore \
-        "@[itcl::code $this _getTooltip more more]"
-    # use this pop-up for access to all controls
-    Rappture::Balloon $itk_component(hull).popup \
-        -title "Change Parameters" -padx 0 -pady 0
-    set inner [$itk_component(hull).popup component inner]
-    frame $inner.cntls
-    pack $inner.cntls -side bottom -fill x
-    frame $inner.cntls.sep -height 2 -borderwidth 1 -relief sunken
-    pack $inner.cntls.sep -side top -fill x -padx 4 -pady 4
-    checkbutton $inner.cntls.explore -font $fn \
-        -text "Explore combinations with no results" \
-        -variable [itcl::scope _explore] \
-        -command [itcl::code $this _fixExplore]
-    pack $inner.cntls.explore -side top -anchor w
-    Rappture::Tooltip::for $inner.cntls.explore \
-        "When this option is turned on, you can set parameters to various combinations that have not yet been simulated.  The Simulate button will light up, and you can simulate these missing combinations.\n\nWhen turned off, controls will avoid missing combinations, and automatically snap to the closest available dataset."
-    itk_component add options {
-        blt::scrollset $inner.scrl \
-            -xscrollbar $inner.scrl.xs \
-            -yscrollbar $inner.scrl.ys \
-            -window $inner.scrl.frame
+    }
-    pack $itk_component(options) -expand yes -fill both
-    blt::tk::scrollbar $inner.scrl.xs
-    blt::tk::scrollbar $inner.scrl.ys
-    itk_component add popup {
-        frame $inner.scrl.frame
+    }
-    frame $itk_component(popup).bg
     eval itk_initialize $args
 …
 # Adds a new result to this result set.  Scans through all existing
 # results to look for a difference compared to previous results.
 # 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 at the same index.
+# Returns the simulation number (#1, #2, #3, etc.) of this new result
+# to the caller.  The various data objects for this result set should
+# be added to their result viewers at the same index.
 # ----------------------------------------------------------------------
 itcl::body Rappture::ResultSet::add {xmlobj} {
 …
     if {"" == $xmlobj0} {
         # first element -- always add
+        $_results insert end [list $xmlobj]
+        set simnum "#[incr _resultnum]"
+        $_results insert end [list $xmlobj $simnum]
+        _fixNumResults
         set _recent $xmlobj
+        $itk_component(status) configure -text "1 result"
+        $itk_component(clear) configure -state normal
+        if {[$_results size] >= 2} {
+            $itk_component(parameters) configure -state normal
+        } else {
+            $itk_component(parameters) configure -state disabled
+        }
+        return $simnum
+    }
+    #
+    # For all later results, find the diffs and add any new columns
+    # into the results tuple.  The latest result is the most recent.
+    #
+    set simnum [_addOneResult $_results $xmlobj]
+    set _recent $xmlobj
+    _fixNumResults
+    return $simnum
+}
+# ----------------------------------------------------------------------
+# USAGE: clear ?<xmlobj>?
+#
+# Clears one or all results in this result set.  If no specific
+# result object is specified, then all results are cleared.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultSet::clear {{xmlobj ""}} {
+    set shortlist $itk_component(dials)
+    set controlsChanged 0
+    # clear any currently highlighted result
+    _doSettings
+    if {$xmlobj ne ""} {
+        #
+        # Delete just one result.  Look for the result among the
+        # tuples and remove it.  Then, rebuild all of the tuples
+        # by scanning back through them and building them back up.
+        # This will rebuild the columns/controls as they should
+        # be now, removing anything that is no longer necessary.
+        #
+        set irun [$_results find -format xmlobj $xmlobj]
+        if {[llength $irun] == 1} {
+            # figure out where we are in the active control, and
+            # what value we should display after this one is deleted
+            set vlist ""
+            foreach {label val} [_getValues $_active all] {
+                lappend vlist $label
+            }
+            set ipos [lsearch $vlist $_cntlInfo($this-$_active-value)]
+            set vcurr ""
+            set vnext ""
+            if {$ipos >= 0} {
+                # try to stay at this value, if we can
+                set vcurr [lindex $vlist $ipos]
+                # fall back to this value, if we have to
+                if {$ipos > 0} { incr ipos -1 } else { incr ipos }
+                set vnext [lindex $vlist $ipos]
+            }
+            # delete the value from the tuples of all results
+            $_results delete $irun
+            set new [Rappture::Tuples ::#auto]
+            $new column insert end -name xmlobj -label "top-level XML object"
+            $new column insert end -name simnum -label "simulation number"
+            for {set n 0} {$n < [$_results size]} {incr n} {
+                set rec [lindex [$_results get -format {xmlobj simnum} $n] 0]
+                foreach {obj num} $rec break
+                if {$n == 0} {
+                    $new insert end [list $obj $num]
+                } else {
+                    _addOneResult $new $obj $num
+                }
+            }
+            # plug in the new set of rebuilt tuples
+            itcl::delete object $_results
+            set _results $new
+            # delete any adjuster controls that disappeared
+            foreach col $_cntlInfo($this-all) {
+                if {[$_results column names $col] eq ""} {
+                    set id $_cntlInfo($this-$col-id)
+                    destroy $shortlist.label$id
+                    array unset _cntlInfo $this-$col*
+                    set i [lsearch -exact $_cntlInfo($this-all) $col]
+                    if {$i >= 0} {
+                        set _cntlInfo($this-all) [lreplace $_cntlInfo($this-all) $i $i]
+                    }
+                    if {$col == $_active} {
+                        # control is going away -- switch to sim # control
+                        set simnum0 [$_results get -format simnum 0]
+                        set _cntlInfo($this-simnum-value) $simnum0
+                        activate simnum
+                    }
+                    set controlsChanged 1
+                }
+            }
+            # can we find a tuple with the desired value for the active col?
+            if {$_active ne "" && $vcurr ne ""} {
+                set found ""
+                if {[$_results find -format $_active $vcurr] ne ""} {
+                    set found $vcurr
+                } elseif {$vnext ne "" && [$_results find -format $_active $vnext] ne ""} {
+                    set found $vnext
+                }
+                if {$found ne ""} {
+                    # set the control to a value we were able to find
+                    # this will trigger !settings and other adjustments
+                    set _cntlInfo($this-$_active-value) $found
+                } else {
+                    # if all else fails, show solution #1
+                    set simnum0 [$_results get -format simnum 0]
+                    set _cntlInfo($this-simnum-value) $simnum0
+                    activate simnum
+                }
+            }
+        }
+    } else {
+        #
+        # Delete all results.
+        #
+        $_results delete 0 end
+        # delete all adjuster controls
+        foreach col $_cntlInfo($this-all) {
+            set id $_cntlInfo($this-$col-id)
+            destroy $shortlist.label$id
+        }
+        set controlsChanged 1
+    }
+    if {[$_results size] == 0} {
+        #
+        # No results left?  Then clean everything up.
+        #
+        array unset _cntlInfo $this-*
+        # clean up control info
+        foreach key [array names _cntlInfo $this-*] {
+            catch {unset _cntlInfo($key)}
+        }
+        set _cntlInfo($this-all) ""
+        set _counter 0
+        set _resultnum 0
+        # clear out all results
+        eval $_results column delete [lrange [$_results column names] 2 end]
+        set _recent ""
+        set _active ""
+        set _plotall 0
+        $itk_component(dials).all configure -relief raised \
+            -background $itk_option(-background) \
+            -foreground $itk_option(-foreground)
+    }
+    # update status and Clear button
+    _fixNumResults
+    $_dispatcher event -idle !fixcntls
+    # let clients know that the number of controls has changed
+    if {$controlsChanged} {
+        event generate $itk_component(hull) <<Control>>
+    }
+    # if there's a callback for clearing, invoke it now...
+    if {[string length $itk_option(-clearcommand)] > 0} {
+        uplevel #0 $itk_option(-clearcommand) $xmlobj
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: activate <column>
+#
+# Clients use this to activate a particular column in the set of
+# controls.  When a column is active, its label is bold and its
+# value has a radiodial in the "short list" area.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultSet::activate {column} {
+    set allowed [$_results column names]
+    if {[lsearch $allowed $column] < 0} {
+        error "bad value \"$column\": should be one of [join $allowed {, }]"
+    }
+    # column is now active
+    set _active $column
+    # keep track of usage, so we know which controls are popular
+    incr _cntlInfo($this-$column-usage)
+    # fix controls at next idle point
+    $_dispatcher event -idle !layout why data
+    $_dispatcher event -idle !settings column $_active
+}
+# ----------------------------------------------------------------------
+# USAGE: contains <xmlobj>
+#
+# Checks to see if the given <xmlobj> is already represented by
+# some result in this result set.  This comes in handy when checking
+# to see if an input case is already covered.
+#
+# Returns 1 if the result set already contains this result, and
+# 0 otherwise.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultSet::contains {xmlobj} {
+    # no results? then this must be new
+    if {[$_results size] == 0} {
         return 0
+    }
 …
     # is a column to represent the quantity with the difference.
+    #
+    set xmlobj0 [$_results get -format xmlobj end]
     foreach {op vpath oldval newval} [$xmlobj0 diff $xmlobj] {
         if {[$xmlobj get $vpath.about.diffs] == "ignore"} {
 …
             continue
+        }
-        # make sure that these values really are different
-        set oldval [lindex [Rappture::LibraryObj::value $xmlobj0 $vpath] 0]
-        set newval [lindex [Rappture::LibraryObj::value $xmlobj $vpath] 0]
-        if {$oldval != $newval && [$_results column names $vpath] == ""} {
-            # no column for this quantity yet
-            $_results column insert end -name $vpath -default $oldval
+        }
+    }
-    # build a tuple for this new object
-    set cols ""
-    set tuple ""
-    foreach col [lrange [$_results column names] 1 end] {
-        lappend cols $col
-        set raw [lindex [Rappture::LibraryObj::value $xmlobj $col] 0]
-        lappend tuple $raw  ;# use the "raw" (user-readable) label
+    }
-    # find a matching tuple? then replace it -- only need one
-    if {[llength $cols] > 0} {
-        set ilist [$_results find -format $cols -- $tuple]
-    } else {
-        set ilist 0  ;# no diffs -- must match first entry
+    }
-    # add all remaining columns for this new entry
-    set tuple [linsert $tuple 0 $xmlobj]
-    if {[llength $ilist] > 0} {
-        if {[llength $ilist] > 1} {
-            error "why so many matching results?"
+        }
-        # overwrite the first matching entry
-        set index [lindex $ilist 0]
-        $_results put $index $tuple
-        set _recent $xmlobj
-    } else {
-        set index [$_results size]
-        $_results insert end $tuple
-        set _recent $xmlobj
+    }
-    if {[$_results size] == 1} {
-        $itk_component(status) configure -text "1 result"
-    } else {
-        $itk_component(status) configure -text "[$_results size] results"
-        $itk_component(parameters) configure -state normal
+    }
-    $itk_component(clear) configure -state normal
-    return $index
+}
-# ----------------------------------------------------------------------
-# USAGE: clear
+#
-# Clears all results in this result set.
-# ----------------------------------------------------------------------
-itcl::body Rappture::ResultSet::clear {} {
-    _doSettings
-    # delete all adjuster controls
-    set popup $itk_component(popup)
-    set shortlist $itk_component(dials)
-    foreach col $_cntlInfo($this-all) {
-        set id $_cntlInfo($this-$col-id)
-        destroy $popup.label$id $popup.dial$id $popup.all$id
-        destroy $shortlist.label$id
+    }
-    array unset _cntlInfo $this-*
-    # clean up control info
-    foreach key [array names _cntlInfo $this-*] {
-        catch {unset _cntlInfo($key)}
+    }
-    set _cntlInfo($this-all) ""
-    set _counter 0
-    # clear out all results
-    $_results delete 0 end
-    eval $_results column delete [lrange [$_results column names] 1 end]
-    set _recent ""
-    set _active ""
-    set _plotall 0
-    $itk_component(dials).all configure -relief raised \
-        -background $itk_option(-background) \
-        -foreground $itk_option(-foreground)
-    # update status and Clear button
-    $itk_component(status) configure -text "No results"
-    $itk_component(parameters) configure -state disabled
-    $itk_component(clear) configure -state disabled
-    $_dispatcher event -idle !fixcntls
-    # let clients know that the number of controls has changed
-    event generate $itk_component(hull) <<Control>>
+}
-# ----------------------------------------------------------------------
-# USAGE: activate <column>
+#
-# Clients use this to activate a particular column in the set of
-# controls.  When a column is active, its label is bold and its
-# value has a radiodial in the "short list" area.
-# ----------------------------------------------------------------------
-itcl::body Rappture::ResultSet::activate {column} {
-    if {$column == "@more"} {
-        $itk_component(hull).popup activate \
-            $itk_component(dials).labelmore.name above
-        return
+    }
-    set allowed [$_results column names]
-    if {[lsearch $allowed $column] < 0} {
-        error "bad value \"$column\": should be one of [join $allowed {, }]"
+    }
-    # column is now active
-    set _active $column
-    # keep track of usage, so we know which controls are popular
-    incr _cntlInfo($this-$column-usage)
-    # fix controls at next idle point
-    $_dispatcher event -idle !layout why data
-    $_dispatcher event -idle !settings column $_active
+}
-# ----------------------------------------------------------------------
-# USAGE: contains <xmlobj>
+#
-# Checks to see if the given <xmlobj> is already represented by
-# some result in this result set.  This comes in handy when checking
-# to see if an input case is already covered.
+#
-# Returns 1 if the result set already contains this result, and
-# 0 otherwise.
-# ----------------------------------------------------------------------
-itcl::body Rappture::ResultSet::contains {xmlobj} {
-    # no results? then this must be new
-    if {[$_results size] == 0} {
-        return 0
+    }
+    #
-    # Compare this new object against the last XML object in the
-    # results set.  If it has a difference, make sure that there
-    # is a column to represent the quantity with the difference.
+    #
-    set xmlobj0 [$_results get -format xmlobj end]
-    foreach {op vpath oldval newval} [$xmlobj0 diff $xmlobj] {
-        if {[$xmlobj get $vpath.about.diffs] == "ignore"} {
-            continue
+        }
-        if {$op == "+" || $op == "-"} {
-            # ignore differences where parameters come and go
-            # such differences make it hard to work controls
-            continue
+        }
         if {[$_results column names $vpath] == ""} {
             # no column for this quantity yet
 …
     set format ""
     set tuple ""
     foreach col [lrange [$_results column names] 1 end] {
+    foreach col [lrange [$_results column names] 2 end] {
         lappend format $col
         set raw [lindex [Rappture::LibraryObj::value $xmlobj $col] 0]
 …
 # ----------------------------------------------------------------------
+# USAGE: _doClear
+#
+# Invoked automatically when the user presses the Clear button.
+# Invokes the -clearcommand to clear all data from this resultset
+# and all other resultsets in an Analyzer.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultSet::_doClear {} {
+    if {[string length $itk_option(-clearcommand)] > 0} {
+        uplevel #0 $itk_option(-clearcommand)
+# USAGE: _doClear all|current
+#
+# Invoked automatically when the user presses the "Clear One" or
+# "Clear All" buttons.  Invokes the -clearcommand to clear all data
+# from this resultset and all other resultsets in an Analyzer.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultSet::_doClear {what} {
+    switch -- $what {
+        current {
+            set xmlobj ""
+            # value of xmlobj control is something like "#1" or "#2"
+            set irun [$_results find -format simnum $_cntlInfo($this-simnum-value)]
+            if {$irun ne ""} {
+                # convert index to a real xmlobj object
+                set xmlobj [$_results get -format xmlobj $irun]
+            }
+            clear $xmlobj
+        }
+        all {
+            clear
+        }
+        default { error "bad option \"$what\": should be current or all" }
+    }
+}
 …
     if {[string length $itk_option(-settingscommand)] > 0} {
         uplevel #0 $itk_option(-settingscommand) $cmd
+    }
+}
-# ----------------------------------------------------------------------
-# USAGE: _doPrompt <state>
+#
-# Used internally whenever the current settings represent a point
-# with no data.  Invokes the -promptcommand with an explanation of
-# the missing data, prompting the user to simulate it.
-# ----------------------------------------------------------------------
-itcl::body Rappture::ResultSet::_doPrompt {state} {
-    if {[string length $itk_option(-promptcommand)] > 0} {
-        if {$state} {
-            set message "No data for these settings"
-            set settings ""
-            foreach col [lrange [$_results column names] 1 end] {
-                set val $_cntlInfo($this-$col-value)
-                lappend settings $col $val
+            }
-            uplevel #0 $itk_option(-promptcommand) [list on $message $settings]
-        } else {
-            uplevel #0 $itk_option(-promptcommand) off
+        }
+    }
+}
 …
+    }
-    set popup $itk_component(popup)
-    grid columnconfigure $popup 0 -minsize 16
-    grid columnconfigure $popup 1 -weight 1
     set shortlist $itk_component(dials)
     grid columnconfigure $shortlist 1 -weight 1
 …
+        #
         if {![info exists _cntlInfo($this-$col-id)]} {
-            set row [lindex [grid size $popup] 1]
-            set row2 [expr {$row+1}]
             set tip ""
+            if {$col == "xmlobj"} {
+            if {$col eq "xmlobj"} {
+                continue
+            } elseif {$col eq "simnum"} {
                 set quantity "Simulation"
                 set tip "List of all simulations that you have performed so far."
 …
+            }
+            #
+            # Build the main control in the pop-up panel.
+            #
+            # Create the controls for the "short list" area.
             set fn $itk_option(-textfont)
+            set w $popup.label$_counter
+            set w $shortlist.label$_counter
+            set row [lindex [grid size $shortlist] 1]
             frame $w
             grid $w -row $row -column 2 -sticky ew -padx 4 -pady {4 0}
+            grid $w -row $row -column 1 -sticky ew
             label $w.arrow -bitmap [Rappture::icon empty] -borderwidth 0
             pack $w.arrow -side left -fill y
 …
             Rappture::Tooltip::for $w \
                 "@[itcl::code $this _getTooltip label $col]"
-            set w $popup.dial$_counter
-            Rappture::Radiodial $w -valuewidth 0
-            grid $w -row $row2 -column 2 -sticky ew -padx 4 -pady {0 4}
-            $w configure -variable ::Rappture::ResultSet::_cntlInfo($this-$col-value)
-            Rappture::Tooltip::for $w \
-                "@[itcl::code $this _getTooltip dial $col]"
-            set w $popup.all$_counter
-            label $w -text "All" -padx 8 \
-                -borderwidth 1 -relief raised -font $fn
-            grid $w -row $row -rowspan 2 -column 1 -sticky nsew -padx 2 -pady 4
-            Rappture::Tooltip::for $w \
-                "@[itcl::code $this _getTooltip all $col]"
-            bind $w <ButtonRelease> [itcl::code $this _toggleAll $col]
-            # Create the controls for the "short list" area.
-            set w $shortlist.label$_counter
-            frame $w
-            grid $w -row $row -column 1 -sticky ew
-            label $w.arrow -bitmap [Rappture::icon empty] -borderwidth 0
-            pack $w.arrow -side left -fill y
-            _control bind $w.arrow $col
-            label $w.name -text $quantity -anchor w \
-                -borderwidth 0 -padx 0 -pady 1 -font $fn
-            pack $w.name -side left
-            bind $w.name <Configure> [itcl::code $this _fixValue $col resize]
-            _control bind $w.name $col
-            label $w.value -anchor w \
-                -borderwidth 0 -padx 0 -pady 1 -font $fn
-            pack $w.value -side left
-            bind $w.value <Configure> [itcl::code $this _fixValue $col resize]
-            _control bind $w.value $col
-            Rappture::Tooltip::for $w \
-                "@[itcl::code $this _getTooltip label $col]"
-            # if this is the "Simulation #" control, add a separator
-            if {$col == "xmlobj"} {
-                grid $popup.all$_counter -column 0
-                grid $popup.label$_counter -column 1 -columnspan 2
-                grid $popup.dial$_counter -column 1 -columnspan 2
-                if {![winfo exists $popup.sep]} {
-                    frame $popup.sep -height 1 -borderwidth 0 -background black
+                }
-                grid $popup.sep -row [expr {$row+2}] -column 0 \
-                    -columnspan 3 -sticky ew -pady 4
-                if {![winfo exists $popup.paraml]} {
-                    label $popup.paraml -text "Parameters:" -font $fn
+                }
-                grid $popup.paraml -row [expr {$row+3}] -column 0 \
-                    -columnspan 3 -sticky w -padx 4 -pady {0 4}
+            }
             # create a record for this control
 …
+        #
         set id $_cntlInfo($this-$col-id)
-        set popup $itk_component(popup)
-        set dial $popup.dial$id
-        _control load $popup.dial$id $col
         if {$col == $_layout(active)} {
 …
+    #
     if {$nadded > 0} {
         if {[$_results column names] == 2 || $nadded == 1} {
+        if {[$_results column names] == 3 || $nadded == 1} {
             activate [lindex $_cntlInfo($this-all) end]
         } else {
             activate xmlobj
+            activate simnum
+        }
+    }
 …
     # will then fix all other controls to match the one that changed.
+    #
     if {"" != $_recent} {
         set raw [lindex [$_results find -format xmlobj $_recent] 0]
         set raw "#[expr {$raw+1}]"
         set _cntlInfo($this-xmlobj-value) $raw
+    set irun [lindex [$_results find -format xmlobj $_recent] 0]
+    if {$irun ne ""} {
+        set simnum [$_results get -format simnum $irun]
+        set _cntlInfo($this-simnum-value) $simnum
+    }
+}
 …
 # so that the active control is displayed, and other recent controls
 # are shown above and/or below.  At the very least, we must show the
 # "more options..." control, which pops up a panel of all controls.
+# "more options..." control.
 # ----------------------------------------------------------------------
 itcl::body Rappture::ResultSet::_fixLayout {args} {
     array set eventdata $args
-    set popup $itk_component(popup)
     set shortlist $itk_component(dials)
 …
     foreach col $_cntlInfo($this-all) {
         set id $_cntlInfo($this-$col-id)
-        $popup.label$id configure -background $bg
-        $popup.label$id.arrow configure -background $bg \
-            -bitmap [Rappture::icon empty]
-        $popup.label$id.name configure -font $fn -background $bg
-        $popup.label$id.value configure -background $bg
-        $popup.all$id configure -background $bg -foreground $fg \
-            -relief raised
-        $popup.dial$id configure -background $bg
         $shortlist.label$id configure -background $bg
         $shortlist.label$id.arrow configure -background $bg \
 …
         if {$col == $_active} {
-            # put the background behind the active control in the popup
-            set id $_cntlInfo($this-$_active-id)
-            array set ginfo [grid info $popup.label$id]
-            grid $popup.bg -row $ginfo(-row) -rowspan 2 \
-                -column 0 -columnspan 3 -sticky nsew
-            lower $popup.bg
             if {$_layout(mode) == "usual"} {
                 # put the background behind the active control in the shortlist
 …
         set fg $itk_option(-activecontrolforeground)
         set bg $itk_option(-activecontrolbackground)
-        $popup.label$id configure -background $bg
-        $popup.label$id.arrow configure -foreground $fg -background $bg \
-            -bitmap [Rappture::icon rarrow]
-        $popup.label$id.name configure -foreground $fg -background $bg \
-            -font $bf
-        $popup.label$id.value configure -foreground $fg -background $bg
-        $popup.dial$id configure -background $bg
-        $popup.bg configure -background $bg
-        if {$_plotall} {
-            $popup.all$id configure -relief sunken \
-                -background $itk_option(-togglebackground) \
-                -foreground $itk_option(-toggleforeground)
-        } else {
-            $popup.all$id configure -relief raised \
-                -background $itk_option(-activecontrolbackground) \
-                -foreground $itk_option(-activecontrolforeground)
+        }
         if {$_layout(mode) == "usual"} {
 …
 # ----------------------------------------------------------------------
+# USAGE: _fixNumResults
+#
+# Used internally to update the number of results displayed near the
+# top of this widget.  If there is only 1 result, then there is also
+# a single "Clear" button.  If there are no results, the clear button
+# is diabled.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultSet::_fixNumResults {} {
+    switch [$_results size] {
+{
+            $itk_component(status) configure -text "No results"
+            $itk_component(clearall) configure -state disabled -text "Clear"
+            pack forget $itk_component(clear)
+        }
+{
+            $itk_component(status) configure -text "1 result"
+            $itk_component(clearall) configure -state normal -text "Clear"
+            pack forget $itk_component(clear)
+        }
+        default {
+            $itk_component(status) configure -text "[$_results size] results"
+            $itk_component(clearall) configure -state normal -text "Clear All"
+            $itk_component(clear) configure -state normal
+            pack $itk_component(clear) -side right \
+                -after $itk_component(clearall) -padx {0 6}
+        }
+    }
+}
+# ----------------------------------------------------------------------
 # USAGE: _fixSettings ?<eventArgs...>?
+#
 …
         set changed ""
+    }
-    _doPrompt off
     if {[info exists _cntlInfo($this-$_active-label)]} {
 …
 {
             # only one data set? then plot it
+            set simnum [$_results get -format simnum 0]
             _doSettings [list \
 [list -width 2 \
+                $simnum [list -width 2 \
                         -param [_getValues $_active current] \
                         -description [_getParamDesc all] \
 …
     # for a tuple that matches the current settings.
+    #
+    if {$changed == "xmlobj"} {
+        # value is "#2" -- skip # and adjust range starting from 0
+        set irun [string range $_cntlInfo($this-xmlobj-value) 1 end]
+        if {"" != $irun} { set irun [expr {$irun-1}] }
+    if {$changed == "xmlobj" || $changed == "simnum"} {
+        set irun [$_results find -format simnum $_cntlInfo($this-simnum-value)]
     } else {
         set format ""
         set tuple ""
         foreach col [lrange [$_results column names] 1 end] {
+        foreach col [lrange [$_results column names] 2 end] {
             lappend format $col
             lappend tuple $_cntlInfo($this-$col-value)
 …
         set irun [lindex [$_results find -format $format -- $tuple] 0]
+        if {"" == $irun && "" != $changed
+             && $itk_option(-missingdata) == "skip"} {
+            #
+            # No data for these settings.  Try leaving the next
+            # column open, then the next, and so forth, until
+            # we find some data.
+            #
+            # allcols:  foo bar baz qux
+            #               ^^^changed
+            #
+            # search:   baz qux foo
+            #
+            set val $_cntlInfo($this-$changed-value)
+            set allcols [lrange [$_results column names] 1 end]
+            set i [lsearch -exact $allcols $changed]
+            set search [concat \
+                [lrange $allcols [expr {$i+1}] end] \
+                [lrange $allcols 0 [expr {$i-1}]] \
+            ]
+            set nsearch [llength $search]
+            for {set i 0} {$i < $nsearch} {incr i} {
+                set format $changed
+                set tuple [list $val]
+                for {set j [expr {$i+1}]} {$j < $nsearch} {incr j} {
+                    set col [lindex $search $j]
+                    lappend format $col
+                    lappend tuple $_cntlInfo($this-$col-value)
+                }
+                set irun [lindex [$_results find -format $format -- $tuple] 0]
+                if {"" != $irun} {
+                    break
+                }
+            }
+        }
+        if {"" == $irun && "" != $changed} {
+            #
+            # No data for these settings.  Try leaving the next
+            # column open, then the next, and so forth, until
+            # we find some data.
+            #
+            # allcols:  foo bar baz qux
+            #               ^^^changed
+            #
+            # search:   baz qux foo
+            #
+            set val $_cntlInfo($this-$changed-value)
+            set allcols [lrange [$_results column names] 2 end]
+            set i [lsearch -exact $allcols $changed]
+            set search [concat \
+                [lrange $allcols [expr {$i+1}] end] \
+                [lrange $allcols 0 [expr {$i-1}]] \
+            ]
+            set nsearch [llength $search]
+            for {set i 0} {$i < $nsearch} {incr i} {
+                set format $changed
+                set tuple [list $val]
+                for {set j [expr {$i+1}]} {$j < $nsearch} {incr j} {
+                    set col [lindex $search $j]
+                    lappend format $col
+                    lappend tuple $_cntlInfo($this-$col-value)
+                }
+                set irun [lindex [$_results find -format $format -- $tuple] 0]
+                if {"" != $irun} {
+                    break
+                }
+            }
+        }
+    }
 …
         set _settings 1
         set format [lrange [$_results column names] 1 end]
+        set format [lrange [$_results column names] 2 end]
         if {[llength $format] == 1} {
             set data [$_results get -format $format $irun]
 …
             set _cntlInfo($this-$col-value) $val
+        }
+        set _cntlInfo($this-xmlobj-value) "#[expr {$irun+1}]"
+        set simnum [$_results get -format simnum $irun]
+        set _cntlInfo($this-simnum-value) $simnum
         # okay, react to value changes again
 …
     # plot them.
+    #
     if {$_plotall && $_active == "xmlobj"} {
+    if {$_plotall && $_active == "simnum"} {
         set format ""
     } else {
         set format ""
         set tuple ""
         foreach col [lrange [$_results column names] 1 end] {
+        foreach col [lrange [$_results column names] 2 end] {
             if {!$_plotall || $col != $_active} {
                 lappend format $col
 …
         set format ""
         set tuple ""
         foreach col [lrange [$_results column names] 1 end] {
+        foreach col [lrange [$_results column names] 2 end] {
             lappend format $col
             lappend tuple $_cntlInfo($this-$col-value)
+        }
         set icurr [$_results find -format $format -- $tuple]
-        # no data for these settings? prompt the user to simulate
-        if {"" == $icurr} {
-            _doPrompt on
+        }
         if {[llength $ilist] == 1} {
             # single result -- always use active color
             set i [lindex $ilist 0]
+            set simnum [$_results get -format simnum $i]
             set plist [list \
                 $i [list -width 2 \
+                $simnum [list -width 2 \
                          -param [_getValues $_active $i] \
                          -description [_getParamDesc all $i] \
 …
             set plist [list params $params]
             foreach i $ilist {
+                set simnum [$_results get -format simnum $i]
                 if {$i == $icurr} {
                     lappend plist $i [list -width 3 -raise 1 \
+                    lappend plist $simnum [list -width 3 -raise 1 \
                         -param [_getValues $_active $i] \
                         -description [_getParamDesc all $i]]
                 } else {
                     lappend plist $i [list -brightness 0.7 -width 1 \
+                    lappend plist $simnum [list -brightness 0.7 -width 1 \
                         -param [_getValues $_active $i] \
                         -description [_getParamDesc all $i]]
 …
+        #
         _doSettings $plist
-    } elseif {$itk_option(-missingdata) == "prompt"} {
-        # prompt the user to simulate these settings
-        _doPrompt on
-        _doSettings  ;# clear plotting area
-        # clear the current run selection -- there is no run for this
-        set _settings 1
-        set _cntlInfo($this-xmlobj-value) ""
-        set _settings 0
+    }
+}
-# ----------------------------------------------------------------------
-# USAGE: _fixExplore
+#
-# Called automatically whenever the user toggles the "Explore" button
-# on the parameter popup.  Changes the -missingdata option back and
-# forth, to allow for missing data or skip it.
-# ----------------------------------------------------------------------
-itcl::body Rappture::ResultSet::_fixExplore {} {
-    if {$_explore} {
-        configure -missingdata prompt
-    } else {
-        configure -missingdata skip
+    }
+}
 …
     if {[info exists _cntlInfo($this-$col-id)]} {
         set id $_cntlInfo($this-$col-id)
-        set popup $itk_component(popup)
-        set widget $popup.label$id
-        set wmax [winfo width $popup.dial$id]
-        _drawValue $col $widget $wmax
         set widget $itk_component(dials).label$id
 …
+    }
     set id $_cntlInfo($this-$col-id)
-    set popup $itk_component(popup)
-    set pbutton $popup.all$id
-    set current [$pbutton cget -relief]
     set sbutton $itk_component(dials).all
+    foreach c $_cntlInfo($this-all) {
+        set id $_cntlInfo($this-$c-id)
+        $popup.all$id configure -relief raised \
+            -background $itk_option(-background) \
+            -foreground $itk_option(-foreground)
+    }
+    set current [$sbutton cget -relief]
     if {$current == "sunken"} {
-        $pbutton configure -relief raised \
-            -background $itk_option(-activecontrolbackground) \
-            -foreground $itk_option(-activecontrolforeground)
         $sbutton configure -relief raised \
             -background $itk_option(-activecontrolbackground) \
 …
         set _plotall 0
     } else {
-        $pbutton configure -relief sunken \
-            -background $itk_option(-togglebackground) \
-            -foreground $itk_option(-toggleforeground)
         $sbutton configure -relief sunken \
             -background $itk_option(-togglebackground) \
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::ResultSet::_getValues {col {which ""}} {
     if {$col == "xmlobj"} {
+    if {$col == "simnum"} {
         # load the Simulation # control
         set nruns [$_results size]
         for {set n 0} {$n < $nruns} {incr n} {
             set v "#[expr {$n+1}]"
+            set v [$_results get -format simnum $n]
             set label2val($v) $n
+        }
 …
         default {
             if {[string is integer $which]} {
                 if {$col == "xmlobj"} {
                     set val "#[expr {$which+1}]"
+                if {$col == "simnum"} {
+                    set val [$_results get -format simnum $which]
                 } else {
                     # Be careful giving singleton elements as the "columns"
 …
             append tip "\n\nCurrently, plotting $what.  Click to toggle."
+        }
-        more {
-            set tip "Click to access all parameters."
+        }
+    }
     return [string trim $tip]
 …
         set format ""
         set tuple ""
         foreach col [lrange [$_results column names] 1 end] {
+        foreach col [lrange [$_results column names] 2 end] {
             lappend format $col
             lappend tuple $_cntlInfo($this-$col-value)
 …
                 # argument to "Tuples::get". It is expecting a list.
                 set val [lindex [$_results get -format [list $col] $index] 0]
                 if {$col == "xmlobj"} {
                     set num [lindex [$_results find -format xmlobj $val] 0]
                     set val "#[expr {$num+1}]"
+                if {$col == "simnum"} {
+                    set irun [lindex [$_results find -format xmlobj $val] 0]
+                    set val [$_results get -format simnum $irun]
+                }
                 append desc "$quantity = $val\n"
 …
 # ----------------------------------------------------------------------
+# OPTION: -missingdata
+# ----------------------------------------------------------------------
+itcl::configbody Rappture::ResultSet::missingdata {
+    set opts {prompt skip}
+    if {[lsearch -exact $opts $itk_option(-missingdata)] < 0} {
+        error "bad value \"$itk_option(-missingdata)\": should be [join $opts {, }]"
+    }
+    set _explore [expr {$itk_option(-missingdata) != "skip"}]
+# USAGE: _addOneResult <tuples> <xmlobj> ?<simNum>?
+#
+# Used internally to add one new <xmlobj> to the given <tuples>
+# object.  If the new xmlobj contains different input parameters
+# that are not already columns in the tuple, then this routine
+# creates the new columns.  If the optional <simNum> is specified,
+# then it is added as the simulation number #1, #2, #3, etc.  If
+# not, then the new object is automatically numbered.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultSet::_addOneResult {tuples xmlobj {simnum ""}} {
+    #
+    # Compare this new object against the last XML object in the
+    # results set.  If it has a difference, make sure that there
+    # is a column to represent the quantity with the difference.
+    #
+    set xmlobj0 [$tuples get -format xmlobj end]
+    foreach {op vpath oldval newval} [$xmlobj0 diff $xmlobj] {
+        if {[$xmlobj get $vpath.about.diffs] == "ignore"} {
+            continue
+        }
+        if {$op == "+" || $op == "-"} {
+            # ignore differences where parameters come and go
+            # such differences make it hard to work controls
+            continue
+        }
+        # make sure that these values really are different
+        set oldval [lindex [Rappture::LibraryObj::value $xmlobj0 $vpath] 0]
+        set newval [lindex [Rappture::LibraryObj::value $xmlobj $vpath] 0]
+        if {$oldval != $newval && [$tuples column names $vpath] == ""} {
+            # no column for this quantity yet
+            $tuples column insert end -name $vpath -default $oldval
+        }
+    }
+    # build a tuple for this new object
+    set cols ""
+    set tuple ""
+    foreach col [lrange [$tuples column names] 2 end] {
+        lappend cols $col
+        set raw [lindex [Rappture::LibraryObj::value $xmlobj $col] 0]
+        lappend tuple $raw  ;# use the "raw" (user-readable) label
+    }
+    # find a matching tuple? then replace it -- only need one
+    if {[llength $cols] > 0} {
+        set ilist [$tuples find -format $cols -- $tuple]
+    } else {
+        set ilist 0  ;# no diffs -- must match first entry
+    }
+    # add all remaining columns for this new entry
+    set tuple [linsert $tuple 0 $xmlobj]
+    set cols [linsert $cols 0 "xmlobj"]
+    if {[llength $ilist] > 0} {
+        if {[llength $ilist] > 1} {
+            error "why so many matching results?"
+        }
+        # overwrite the first matching entry
+        set index [lindex $ilist 0]
+        $tuples put -format $cols $index $tuple
+    } else {
+        if {$simnum eq ""} {
+            set simnum "#[incr _resultnum]"
+        }
+        set tuple [linsert $tuple 1 $simnum]
+        $tuples insert end $tuple
+    }
+    return $simnum
+}

branches/blt4/gui/scripts/resultviewer.tcl

-                      r2745
+                      r2966
     protected method _plotAdd {xmlobj {settings ""}}
     protected method _fixScale {args}
+    protected proc _xml2data {xmlobj path}
+    protected method _xml2data {xmlobj path}
+    protected method _cleanIndex {index}
     private variable _dispatcher ""  ;# dispatchers for !events
 …
     private variable _mode2widget    ;# maps plotting mode => widget
     private variable _dataslots ""   ;# list of all data objects in this widget
+    private variable _xml2data       ;# maps xmlobj => data obj in _dataslots
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::ResultViewer::add {index xmlobj path} {
+    set index [_cleanIndex $index]
     set dobj [_xml2data $xmlobj $path]
 …
 # ----------------------------------------------------------------------
+# USAGE: clear ?<index>?
+#
+# Clears one or all results in this result viewer.
+# USAGE: clear ?<index>|<xmlobj>?
+#
+# Clears one or all results in this result viewer.  If a particular
+# <index> is specified, then all data objects at that index are
+# deleted.  If a particular <xmlobj> is specified, then all data
+# objects related to that <xmlobj> are removed--regardless of whether
+# they reside at one or more indices.
 # ----------------------------------------------------------------------
 itcl::body Rappture::ResultViewer::clear {{index ""}} {
     if {"" != $index} {
+    if {$index ne ""} {
         # clear one result
+        if {$index >= 0 && $index < [llength $_dataslots]} {
+            set slot [lindex $_dataslots $index]
+            foreach dobj $slot {
+        if {[catch {_cleanIndex $index} i] == 0} {
+            if {$i >= 0 && $i < [llength $_dataslots]} {
+                set slot [lindex $_dataslots $i]
+                foreach dobj $slot {
+                    itcl::delete object $dobj
+                }
+                set _dataslots [lreplace $_dataslots $i $i ""]
+                $_dispatcher event -idle !scale
+            }
+        } else {
+            foreach key [array names _xml2data $index-*] {
+                set dobj $_xml2data($key)
+                # search for and remove all references to this data object
+                for {set n 0} {$n < [llength $_dataslots]} {incr n} {
+                    set slot [lindex $_dataslots $n]
+                    set pos [lsearch -exact $slot $dobj]
+                    if {$pos >= 0} {
+                        set slot [lreplace $slot $pos $pos]
+                        set _dataslots [lreplace $_dataslots $n $n $slot]
+                        $_dispatcher event -idle !scale
+                    }
+                }
+                # destroy the object and forget it
                 itcl::delete object $dobj
+            }
             set _dataslots [lreplace $_dataslots $index $index ""]
+                unset _xml2data($key)
+            }
+        }
     } else {
 …
+        }
         set _dataslots ""
+        catch {unset _xml2data}
+    }
+}
 …
 # ----------------------------------------------------------------------
 # USAGE: plot add ?<index> <settings> <index> <settings> ...?
+# USAGE: plot add ?<simnum> <settings> <simnum> <settings> ...?
 # USAGE: plot clear
+#
 …
 # command clears the current viewer.  Data is still stored in the
 # widget, but the results are not shown on screen.  The "plot add"
+# command adds the data at the specified <index> to the plot.  If
+# command adds the data at the specified <simnum> to the plot.  Each
+# <simnum> is the simulation number, like "#1", "#2", "#3", etc.  If
 # the optional <settings> are specified, then they are applied
 # to the plot; otherwise, default settings are used.
 …
                     continue
+                }
+                set index [_cleanIndex $index]
                 set reset "-color autoreset"
                 set slot [lindex $_dataslots $index]
 …
                     set mode "contour"
                     if {![info exists _mode2widget($mode)]} {
+                        global env
                         if { [$dataobj isunirect2d] } {
                             if { [$dataobj hints type] == "contour" } {
 …
                                 set resultMode "heightmap"
+                            }
+                        } elseif { [info exists env(VTKCONTOUR)] } {
+                            set resultMode "vtkcontour"
                         } else {
                             set resultMode "vtk"
 …
                                 set fmt "vtk"
+                            }
+                            "opendx" - "dx" - "points-on-mesh" {
+                            "points-on-mesh" {
+                                set mesh [$dataobj mesh]
+                                set fmt [expr {("" != $mesh) ? "vtk" : "nanovis"}]
+                                set extents [$dataobj extents]
+                                if { $extents > 1 } {
+                                    set fmt "flowvis"
+                                }
+                            }
+                            "opendx" - "dx" {
                                 set fmt "nanovis"
                                 set extents [$dataobj extents]
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::ResultViewer::_xml2data {xmlobj path} {
+    if {[info exists _xml2data($xmlobj-$path)]} {
+        return $_xml2data($xmlobj-$path)
+    }
     set type [$xmlobj element -as type $path]
     switch -- $type {
         curve {
             return [Rappture::Curve ::#auto $xmlobj $path]
+            set dobj [Rappture::Curve ::#auto $xmlobj $path]
+        }
         datatable {
             return [Rappture::DataTable ::#auto $xmlobj $path]
+            set dobj [Rappture::DataTable ::#auto $xmlobj $path]
+        }
         histogram {
             return [Rappture::Histogram ::#auto $xmlobj $path]
+            set dobj [Rappture::Histogram ::#auto $xmlobj $path]
+        }
         field {
             return [Rappture::Field ::#auto $xmlobj $path]
+            set dobj [Rappture::Field ::#auto $xmlobj $path]
+        }
         mesh {
             return [Rappture::Mesh ::#auto $xmlobj $path]
+            set dobj [Rappture::Mesh ::#auto $xmlobj $path]
+        }
         table {
             return [Rappture::Table ::#auto $xmlobj $path]
+            set dobj [Rappture::Table ::#auto $xmlobj $path]
+        }
         image {
             return [Rappture::Image ::#auto $xmlobj $path]
+            set dobj [Rappture::Image ::#auto $xmlobj $path]
+        }
         sequence {
             return [Rappture::Sequence ::#auto $xmlobj $path]
+            set dobj [Rappture::Sequence ::#auto $xmlobj $path]
+        }
         string - log {
             return [$xmlobj element -as object $path]
+            set dobj [$xmlobj element -as object $path]
+        }
         structure {
             return [$xmlobj element -as object $path]
+            set dobj [$xmlobj element -as object $path]
+        }
         number - integer - boolean - choice {
             return [$xmlobj element -as object $path]
+            set dobj [$xmlobj element -as object $path]
+        }
         drawing3d - drawing {
             return [Rappture::Drawing ::#auto $xmlobj $path]
+            set dobj [Rappture::Drawing ::#auto $xmlobj $path]
+        }
         time - status {
+            return ""
+        }
+    }
+    error "don't know how to plot <$type> data path=$path"
+            set dobj ""
+        }
+        default {
+            error "don't know how to plot <$type> data path=$path"
+        }
+    }
+    # store the mapping xmlobj=>dobj so we can find this result later
+    if {$dobj ne ""} {
+        set _xml2data($xmlobj-$path) $dobj
+    }
+    return $dobj
+}
+# ----------------------------------------------------------------------
+# USAGE: _cleanIndex <index>
+#
+# Used internally to create a data object for the data at the
+# specified <path> in the <xmlobj>.
+# ----------------------------------------------------------------------
+itcl::body Rappture::ResultViewer::_cleanIndex {index} {
+    if {[regexp {^#([0-9]+)} $index match num]} {
+        return [expr {$num-1}]  ;# start from 0 instead of 1
+    } elseif {[string is integer -strict $index]} {
+        return $index
+    }
+    error "bad plot index \"$index\": should be 0,1,2,... or #1,#2,#3,..."
+}

branches/blt4/gui/scripts/unirect3d.tcl

-                      r2745
+                      r2966
     GetSize $m "zaxis.numpoints" _zNum
     set _compNum $extents
+    foreach {key path} {
+        group   about.group
+        label   about.label
+        color   about.color
+        style   about.style
+        type    about.type
+        xlabel  xaxis.label
+        xdesc   xaxis.description
+        xunits  xaxis.units
+        xscale  xaxis.scale
+        ylabel  yaxis.label
+        ydesc   yaxis.description
+        yunits  yaxis.units
+        yscale  yaxis.scale
+        zlabel  zaxis.label
+        zdesc   zaxis.description
+        zunits  zaxis.units
+        zscale  zaxis.scale
+        order   about.axisorder
+    } {
+        set str [$m get $path]
+        if {"" != $str} {
+            set _hints($key) $str
+        }
+    }
+    foreach {key} { axisorder } {
+        set str [$field get $cname.$key]
+        if {"" != $str} {
+            set _hints($key) $str
+        }
+    }
     itcl::delete object $m
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Unirect3d::hints {{keyword ""}} {
+    if {![info exists _hints]} {
+        foreach {key path} {
+            group   about.group
+            label   about.label
+            color   about.color
+            style   about.style
+            type    about.type
+            xlabel  xaxis.label
+            xdesc   xaxis.description
+            xunits  xaxis.units
+            xscale  xaxis.scale
+            ylabel  yaxis.label
+            ydesc   yaxis.description
+            yunits  yaxis.units
+            yscale  yaxis.scale
+            zlabel  zaxis.label
+            zdesc   zaxis.description
+            zunits  zaxis.units
+            zscale  zaxis.scale
+            order   about.axisorder
+        } {
+            set str [$_curve get $path]
+            if {"" != $str} {
+                set _hints($key) $str
+            }
+        }
+        if {[info exists _hints(xlabel)] && "" != $_hints(xlabel)
+              && [info exists _hints(xunits)] && "" != $_hints(xunits)} {
+            set _hints(xlabel) "$_hints(xlabel) ($_hints(xunits))"
+        }
+        if {[info exists _hints(ylabel)] && "" != $_hints(ylabel)
+              && [info exists _hints(yunits)] && "" != $_hints(yunits)} {
+            set _hints(ylabel) "$_hints(ylabel) ($_hints(yunits))"
+        }
+        if {[info exists _hints(zlabel)] && "" != $_hints(zlabel)
+              && [info exists _hints(zunits)] && "" != $_hints(zunits)} {
+            set _hints(ylabel) "$_hints(zlabel) ($_hints(zunits))"
+        }
+        if {[info exists _hints(group)] && [info exists _hints(label)]} {
+            # pop-up help for each curve
+            set _hints(tooltip) $_hints(label)
+        }
+    if {[info exists _hints(xlabel)] && "" != $_hints(xlabel)
+        && [info exists _hints(xunits)] && "" != $_hints(xunits)} {
+        set _hints(xlabel) "$_hints(xlabel) ($_hints(xunits))"
+    }
+    if {[info exists _hints(ylabel)] && "" != $_hints(ylabel)
+        && [info exists _hints(yunits)] && "" != $_hints(yunits)} {
+        set _hints(ylabel) "$_hints(ylabel) ($_hints(yunits))"
+    }
+    if {[info exists _hints(zlabel)] && "" != $_hints(zlabel)
+        && [info exists _hints(zunits)] && "" != $_hints(zunits)} {
+        set _hints(ylabel) "$_hints(zlabel) ($_hints(zunits))"
+    }
+    if {[info exists _hints(group)] && [info exists _hints(label)]} {
+        # pop-up help for each curve
+        set _hints(tooltip) $_hints(label)
+    }
     if {$keyword != ""} {

branches/blt4/gui/scripts/visviewer.tcl

-                      r2745
+                      r2966
     #private variable _idleTimeout 5000;    # 5 seconds
     #private variable _idleTimeout 0;       # No timeout
+    private variable _logging 0
     protected variable _dispatcher "";  # dispatcher for !events
 …
     pack $itk_component(plotarea) -fill both -expand yes
     set _image(plot) [image create picture]
+    global env
+    if { [info exists env(VISRECORDER)] } {
+        set _logging 1
+    }
     eval itk_initialize $args
+}
 …
+#
 # ReceiveBytes --
+# StartWaiting --
+#
 #    Read some number of bytes from the visualization server.
 …
+#
 itcl::body Rappture::VisViewer::SendEcho {channel {data ""}} {
+    if { $_logging }  {
+        set f [open "/tmp/recording.log" "a"]
+        puts $f $data
+        close $f
+    }
     #puts stderr ">>($data)"
     if {[string length $itk_option(-sendcommand)] > 0} {

branches/blt4/gui/scripts/vtkvolumeviewer.tcl

-                      r2791
+                      r2966
         cutplane-zposition      50
         cutplane-visible        1
+        cutplane-lighting       1
         cutplane-wireframe      0
         cutplane-opacity        100
         volume-lighting         1
+        volume-material         80
         volume-opacity          40
+        volume-quality          50
         volume-visible          1
-        volume-wireframe        0
         legend-visible          1
     }]
 …
     set _first ""
     InitSettings axis-xgrid axis-ygrid axis-zgrid axis-mode \
+        axis-visible axis-labels cutplane-visible \
+        cutplane-xposition cutplane-yposition cutplane-zposition \
+        cutplane-xvisible cutplane-yvisible cutplane-zvisible
+        axis-visible axis-labels
     SendCmd "imgflush"
 …
+    }
+    InitSettings volume-palette volume-visible
+    InitSettings volume-palette volume-material volume-quality volume-visible \
+        cutplane-visible \
+        cutplane-xposition cutplane-yposition cutplane-zposition \
+        cutplane-xvisible cutplane-yvisible cutplane-zvisible
     if { $_reset } {
 …
+            }
+        }
+        "volume-material" {
+            set val $_settings(volume-material)
+            set diffuse [expr {0.01*$val}]
+            set specular [expr {0.01*$val}]
+            #set power [expr {sqrt(160*$val+1.0)}]
+            set power [expr {$val+1.0}]
+            foreach dataset [CurrentDatasets -visible] {
+                SendCmd "volume shading diffuse $diffuse $dataset"
+                SendCmd "volume shading specular $specular $power $dataset"
+            }
+        }
         "volume-lighting" {
             set bool $_settings(volume-lighting)
             foreach dataset [CurrentDatasets -visible] {
                 SendCmd "volume lighting $bool $dataset"
+            }
+        }
+        "volume-quality" {
+            set val $_settings(volume-quality)
+            set val [expr {0.01*$val}]
+            foreach dataset [CurrentDatasets -visible] {
+                SendCmd "volume quality $val $dataset"
+            }
+        }
 …
                     -troughcolor grey82
+            }
+            SendCmd "cutplane axis $axis $bool"
+            foreach dataset [CurrentDatasets -visible] {
+                SendCmd "cutplane axis $axis $bool $dataset"
+            }
+        }
         "cutplane-xposition" - "cutplane-yposition" - "cutplane-zposition" {
             set axis [string range $what 9 9]
             set pos [expr $_settings($what) * 0.01]
+            SendCmd "cutplane slice ${axis} ${pos}"
+            foreach dataset [CurrentDatasets -visible] {
+                SendCmd "cutplane slice ${axis} ${pos} $dataset"
+            }
             set _cutplanePending 0
+        }
 …
          $_dataset2style($tag) != $name } {
         SendCmd "volume colormap $name $tag"
         SendCmd "cutplane colormap $name $tag"
+        SendCmd "cutplane colormap $name-opaque $tag"
         set _dataset2style($tag) $name
+    }
 …
     set max $_settings(volume-opacity)
+    set wmap "0.0 1.0 1.0 1.0"
+    set wmap "0.0 0.0 0.1 0.0 0.2 0.8 0.98 0.8 0.99 0.0 1.0 0.0"
+    set opaqueWmap "0.0 1.0 1.0 1.0"
+    #set wmap "0.0 0.0 0.1 0.0 0.2 0.8 0.98 0.8 0.99 0.0 1.0 0.0"
+    # Approximate cubic opacity curve
+    set wmap "0.0 0.0 0.1 0.001 0.2 0.008 0.3 0.027 0.4 0.064 0.5 0.125 0.6 0.216 0.7 0.343 0.8 0.512 0.9 0.729 1.0 1.0"
     SendCmd "colormap add $name { $cmap } { $wmap }"
+    SendCmd "colormap add $name-opaque { $cmap } { $opaqueWmap }"
+}
 …
         -font "Arial 9"
+    label $inner.dim_l -text "Dim" -font "Arial 9"
+    ::scale $inner.material -from 0 -to 100 -orient horizontal \
+        -variable [itcl::scope _settings(volume-material)] \
+        -width 10 \
+        -showvalue off -command [itcl::code $this AdjustSetting volume-material]
+    label $inner.bright_l -text "Bright" -font "Arial 9"
     label $inner.opacity_l -text "Opacity" -font "Arial 9"
     ::scale $inner.opacity -from 0 -to 100 -orient horizontal \
 …
         -showvalue off \
         -command [itcl::code $this AdjustSetting volume-opacity]
+    label $inner.quality_l -text "Quality" -font "Arial 9"
+    ::scale $inner.quality -from 0 -to 100 -orient horizontal \
+        -variable [itcl::scope _settings(volume-quality)] \
+        -width 10 \
+        -showvalue off -command [itcl::code $this AdjustSetting volume-quality]
     label $inner.field_l -text "Field" -font "Arial 9"
 …
     blt::table $inner \
+,0 $inner.volume    -anchor w -pady 2 \
+,0 $inner.lighting  -anchor w -pady 2 \
+,0 $inner.field_l     -anchor w -pady 2  \
+,1 $inner.field       -anchor w -pady 2  \
+,0 $inner.palette_l   -anchor w -pady 2  \
+,1 $inner.palette     -anchor w -pady 2  \
+,0 $inner.volume    -anchor w -pady 2 -cspan 4 \
+,0 $inner.lighting  -anchor w -pady 2 -cspan 4 \
+,0 $inner.dim_l     -anchor e -pady 2 \
+,1 $inner.material  -fill x   -pady 2 \
+,2 $inner.bright_l  -anchor w -pady 2 \
+,0 $inner.quality_l -anchor w -pady 2 -cspan 2 \
+,0 $inner.quality   -fill x   -pady 2 -cspan 2 \
+,0 $inner.field_l   -anchor w -pady 2  \
+,1 $inner.field     -anchor w -pady 2 -cspan 2 \
+,0 $inner.palette_l -anchor w -pady 2  \
+,1 $inner.palette   -anchor w -pady 2 -cspan 2 \
     blt::table configure $inner r* c* -resize none
     blt::table configure $inner r8 c1 -resize expand
+    blt::table configure $inner r8 c3 -resize expand
+}
 …
     #SendCmd "cutplane visible $tag"
     foreach axis { x y z } {
         SendCmd "cutplane slice $axis 1.0 $tag"
+        SendCmd "cutplane slice $axis 0.5 $tag"
         SendCmd "cutplane axis $axis 0 $tag"
+    }

branches/blt4/gui/scripts/xyresult.tcl

-                      r2746
+                      r2966
     common _downloadPopup          ;# download options from popup
     private variable _markers
+    private variable _nextElement 0
+}
 …
+            }
             set elem "elem[incr count]"
+            set elem "elem[incr _nextElement]"
             set _elem2dataobj($elem) $dataobj
             lappend label2elem($label) $elem

branches/blt4/lang/tcl/scripts/library.tcl

-                      r2936
+                      r2966
+    }
     set string [$node text]
-    # Expat (via tDOM) will always produce utf-8 output, regardless of the
-    # encoding of the tool.xml.  We need to convert utf-8 to unicode for
-    # Tcl/Tk.  This shouldn't affect ASCII tool.xml files.
-    #puts stderr "before $path=$string"
-    #set string [encoding convertfrom utf-8 $string]
-    #puts stderr "after $path=$string [string length $string]"
-    #Rappture::encoding::debug $string
     if {$params(-decode) == "yes"} {
         set string [Rappture::encoding::decode -- $string]
+    }
+    puts stderr "returning $path=$string"
+    return [string trim $string]
+    } else {
+        set string [string trim $string]
+    }
+    return $string
+}

branches/blt4/lang/tcl/src/RpEncodeTclInterface.cc

-                      r2936
+                      r2966
     string = Tcl_GetStringFromObj(objv[last], &numBytes);
+    if ((switches.flags == 0) && (strncmp(string, "@@RP-ENC:", 9) != 0)) {
+        /* This string doesn't have a header, so it's not encoded.
+         * Just return the string as-is. */
+        Tcl_SetObjResult(interp, objv[last]);
+        return TCL_OK;
+    }
     Rappture::Buffer buf(string, numBytes);
     Rappture::Outcome status;
     if (!Rappture::encoding::decode(status, buf, switches.flags)) {
 …
         return TCL_ERROR;
+    }
+    Tcl_SetStringObj(Tcl_GetObjResult(interp), buf.bytes(), buf.size());
+    Tcl_SetByteArrayObj(Tcl_GetObjResult(interp),
+                        (const unsigned char *)buf.bytes(), buf.size());
     return TCL_OK;
+}

branches/blt4/packages/vizservers/nanovis/Axis.cpp

r2936	r2966
111	111
112	112	Axis::Axis(const char *axisName) :
113		_name(~~axisName~~),
	113	_name(strdup(axisName)),
114	114	_flags(AUTOSCALE),
115	115	_title(NULL),

branches/blt4/packages/vizservers/nanovis/Axis.h

-                      r2936
+                      r2966
 #ifndef AXIS_H
 #define AXIS_H
+#include <stdlib.h>
 #include <cmath>
 …
 };
+/*
+ * ----------------------------------------------------------------------
+ *
+ * Ticks --
+ *
+ *         Structure containing information where the ticks (major or
+ *        minor) will be displayed on the graph.
+ *
+ * ----------------------------------------------------------------------
+/**
+ * Class containing information where the ticks (major or
+ * minor) will be displayed on the graph.
  */
 class Ticks
 …
 /**
  * Structure contains options controlling how the axis will be
+ * Class contains options controlling how the axis will be
  * displayed.
  */
 …
+    }
+    bool firstMajor(TickIter& iter)
+    {
+        return _major.firstTick(iter);
+    }
+    bool firstMinor(TickIter& iter)
+    {
+        return _minor.firstTick(iter);
+    }
     void resetRange();
 …
     void setScale(double min, double max);
     double scale()
+    double scale() const
+    {
         return _scale;
+    }
     double range()
+    double range() const
+    {
         return _range;
+    }
-    bool firstMajor(TickIter& iter)
+    {
-        return _major.firstTick(iter);
+    }
-    bool firstMinor(TickIter& iter)
+    {
-        return _minor.firstTick(iter);
+    }
     void getDataLimits(double& min, double& max)
+    {
         min = _valueMin, max = _valueMax;
+    }
+    double min() const
+    {
+        return _min;
+    }
+    void min(double min)
+    {
+        _reqMin = min;
+    }
+    double max() const
+    {
+        return _max;
+    }
+    void max(double max)
+    {
+        _reqMax = max;
+    }
+    void setLimits(double min, double max)
+    {
+        _reqMin = min, _reqMax = max;
+    }
+    void unsetLimits()
+    {
+        min(NAN), max(NAN);
+    }
 …
+        }
         _title = strdup(title);
+    }
-    double min()
+    {
-        return _min;
+    }
-    void min(double min)
+    {
-        _reqMin = min;
+    }
-    double max()
+    {
-        return _max;
+    }
-    void max(double max)
+    {
-        _reqMax = max;
+    }
-    void setLimits(double min, double max)
+    {
-        _reqMin = min, _reqMax = max;
+    }
-    void unsetLimits()
+    {
-        min(NAN), max(NAN);
+    }

branches/blt4/packages/vizservers/nanovis/Command.cpp

-                      r2936
+                      r2966
 .0  1 0 1\n\
 } {\n\
+.00  1.0\n\
+.05  0.0\n\
+.15  0.0\n\
+.20  1.0\n\
+.25  0.0\n\
+.35  0.0\n\
+.40  1.0\n\
+.45  0.0\n\
+.55  0.0\n\
+.60  1.0\n\
+.65  0.0\n\
+.75  0.0\n\
+.80  1.0\n\
+.85  0.0\n\
+.95  0.0\n\
+.00  1.0\n\
+.00000  0.0\n\
+.19999  0.0\n\
+.20000  1.0\n\
+.20001  0.0\n\
+.39999  0.0\n\
+.40000  1.0\n\
+.40001  0.0\n\
+.59999  0.0\n\
+.60000  1.0\n\
+.60001  0.0\n\
+.79999  0.0\n\
+.80000  1.0\n\
+.80001  0.0\n\
+.00000  0.0\n\
 }";
 …
     NanoVis::readScreen();
     NanoVis::ppmWrite("nv>image -bytes %d -type print");
+    NanoVis::ppmWrite("nv>image -type print -bytes %d");
     NanoVis::resizeOffscreenBuffer(w, h);

branches/blt4/packages/vizservers/nanovis/FlowCmd.cpp

-                      r2936
+                      r2966
     Vector3 loc = _volPtr->location();
-    /*This is wrong. Need to compute origin. */
-    NanoVis::xOrigin = loc.x;
-    NanoVis::yOrigin = loc.y;
-    NanoVis::zOrigin = loc.z;
     _fieldPtr->setVectorField(_volPtr, loc,
 …
     Volume *volPtr;
+    volPtr = NanoVis::loadVolume(_name, _dataPtr->xNum(), _dataPtr->yNum(),
+                                 _dataPtr->zNum(), 4, data,
+    volPtr = NanoVis::loadVolume(_name,
+                                 _dataPtr->xNum(),
+                                 _dataPtr->yNum(),
+                                 _dataPtr->zNum(),
+, data,
                                  NanoVis::magMin, NanoVis::magMax, 0);
     volPtr->xAxis.setRange(_dataPtr->xMin(), _dataPtr->xMax());
 …
           NanoVis::magMin, NanoVis::magMax);
     volPtr->setPhysicalBBox(physicalMin, physicalMax);
-    //volPtr->numSlices(256 - _volIndex);
-    //volPtr->numSlices(512 - _volIndex);
-    //volPtr->numSlices(256 - n);
-    // TBD..
-    /* Don't set the slice number until we're are about to render the
-       volume. */
     volPtr->disableCutplane(0);
     volPtr->disableCutplane(1);
 …
     volPtr->specular(_sv.specular);
     volPtr->diffuse(_sv.diffuse);
-    TRACE("volume is now %d %d\n", _sv.showVolume, volPtr->visible());
     volPtr->visible(_sv.showVolume);
     float dx0 = -0.5;
 …
             continue;
+        }
+        Rappture::Unirect3d *dataPtr;
+        dataPtr = flowPtr->data();
+        Rappture::Unirect3d *dataPtr = flowPtr->data();
         min = dataPtr->magMin();
         max = dataPtr->magMax();
 …
         // FIXME: This doesn't work when there is more than one flow.
         licRenderer->setOffset(flowPtr->GetRelativePosition());
         NanoVis::velocityArrowsSlice->slicePos(flowPtr->GetRelativePosition());
+        velocityArrowsSlice->slicePos(flowPtr->GetRelativePosition());
+    }
     AdvectFlows();

branches/blt4/packages/vizservers/nanovis/Grid.cpp

-                      r2936
+                      r2966
     _majorColor(1.0f, 1.0f, 1.0f, 1.0f),
     _minorColor(0.5f, 0.5f, 0.5f, 1.0f),
     _font(0),
+    _font(NULL),
     _visible(false)
+{
+}
+Grid::~Grid()
+{
+}

branches/blt4/packages/vizservers/nanovis/Grid.h

r2936	r2966
33	33	public:
34	34	Grid();
	35	virtual ~Grid();
35	36
36	37	bool isVisible() const

branches/blt4/packages/vizservers/nanovis/HeightMap.cpp

-                      r2936
+                      r2966
  /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-#include <memory.h>
-#include <stdlib.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <stdlib.h>
 #include <GL/glew.h>
-#include <Cg/cgGL.h>
 #include "Grid.h"
 …
 #include "ContourLineFilter.h"
 #include "Texture1D.h"
-#include "R2/R2FilePath.h"
-#include "RpField1D.h"
 #include "RenderContext.h"
 …
 HeightMap::HeightMap() :
     _vertexBufferObjectID(0),
     _textureBufferObjectID(0),
+    _texcoordBufferObjectID(0),
     _vertexCount(0),
     _contour(0),
 …
     _shader = new NvShader();
     _shader->loadFragmentProgram("heightcolor.cg", "main");
-    _tfParam      = _shader->getNamedParameterFromFP("tf");
-    _opacityParam = _shader->getNamedParameterFromFP("opacity");
+}
 …
     reset();
     if (_shader) {
+    if (_shader != NULL) {
         delete _shader;
+    }
     if (_heights != NULL) {
         free(_heights);
+        delete [] _heights;
+    }
+}
 …
             //
             _shader->bind();
+            cgGLSetTextureParameter(_tfParam, _tfPtr->id());
+            cgGLEnableTextureParameter(_tfParam);
+            cgGLSetParameter1f(_opacityParam, _opacity);
+            _shader->setFPTextureParameter("tf", _tfPtr->id());
+            _shader->setFPParameter1f("opacity", _opacity);
             glEnable(GL_TEXTURE_1D);
 …
         glVertexPointer(3, GL_FLOAT, 12, 0);
         glBindBuffer(GL_ARRAY_BUFFER, _textureBufferObjectID);
+        glBindBuffer(GL_ARRAY_BUFFER, _texcoordBufferObjectID);
         glTexCoordPointer(3, GL_FLOAT, 12, 0);
 …
             glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+            _shader->disableFPTextureParameter("tf");
             _shader->unbind();
+        }
 …
         _vertexBufferObjectID = 0;
+    }
     if (_textureBufferObjectID) {
         glDeleteBuffers(1, &_textureBufferObjectID);
         _textureBufferObjectID = 0;
+    if (_texcoordBufferObjectID) {
+        glDeleteBuffers(1, &_texcoordBufferObjectID);
+        _texcoordBufferObjectID = 0;
+    }
     if (_contour != NULL) {
 …
+    }
+}
+#if 0
 void
 HeightMap::setHeight(int xCount, int yCount, Vector3 *heights)
 …
     glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof( Vector3 ), heights,
         GL_STATIC_DRAW);
     glGenBuffers(1, &_textureBufferObjectID);
     glBindBuffer(GL_ARRAY_BUFFER, _textureBufferObjectID);
+    glGenBuffers(1, &_texcoordBufferObjectID);
+    glBindBuffer(GL_ARRAY_BUFFER, _texcoordBufferObjectID);
     glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof(float) * 3, texcoord,
         GL_STATIC_DRAW);
 …
     //}
+}
+#endif
 void
 HeightMap::setHeight(float xMin, float yMin, float xMax, float yMax,
 …
     glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof(Vector3), map,
         GL_STATIC_DRAW);
     glGenBuffers(1, &_textureBufferObjectID);
     glBindBuffer(GL_ARRAY_BUFFER, _textureBufferObjectID);
+    glGenBuffers(1, &_texcoordBufferObjectID);
+    glBindBuffer(GL_ARRAY_BUFFER, _texcoordBufferObjectID);
     glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof(float) * 3, texcoord,
         GL_STATIC_DRAW);
 …
     glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof(Vector3), vertices,
         GL_STATIC_DRAW);
     glGenBuffers(1, &_textureBufferObjectID);
     glBindBuffer(GL_ARRAY_BUFFER, _textureBufferObjectID);
+    glGenBuffers(1, &_texcoordBufferObjectID);
+    glBindBuffer(GL_ARRAY_BUFFER, _texcoordBufferObjectID);
     glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof(float) * 3, texcoord,
         GL_STATIC_DRAW);
 …
         if (_tfPtr != NULL) {
             _shader->bind();
+            cgGLSetTextureParameter(_tfParam, _tfPtr->id());
+            cgGLEnableTextureParameter(_tfParam);
+            _shader->setFPTextureParameter("tf", _tfPtr->id());
             glEnable(GL_TEXTURE_1D);
 …
         glVertexPointer(3, GL_FLOAT, 12, 0);
         glBindBuffer(GL_ARRAY_BUFFER, _textureBufferObjectID);
+        glBindBuffer(GL_ARRAY_BUFFER, _texcoordBufferObjectID);
         glTexCoordPointer(3, GL_FLOAT, 12, 0);
 …
             glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+            _shader->disableFPTextureParameter("tf");
             _shader->unbind();
+        }

branches/blt4/packages/vizservers/nanovis/HeightMap.h

-                      r2936
+                      r2966
 #ifndef HEIGHTMAP_H
 #define HEIGHTMAP_H
-#include <Cg/cg.h>
 #include <R2/graphics/R2Geometry.h>
 …
     /**
      *@brief Create a height map with heigh values
      *@param startX a x position of the first height value
      *@param startY a y position of the first height value
      *@param endX a x position of the last height value
      *@param endY a y position of the last height value
+     *@param startX x position of the first height value
+     *@param startY y position of the first height value
+     *@param endX x position of the last height value
+     *@param endY y position of the last height value
      *@param xCount the number of columns of height values
      *@param yCount the number of rows of height values
 …
     void setHeight(float startX, float startY, float endX, float endY,
                    int xCount, int yCount, float *height);
+#if 0
     /**
      *@brief Create a height map with a set of points
 …
      */
     void setHeight(int xCount, int yCount, Vector3 *heights);
+#endif
     void mapToGrid(Grid *gridPtr);
 …
 private:
     void createIndexBuffer(int xCount, int zCount, float* heights);
+    void createIndexBuffer(int xCount, int zCount, float *heights);
     Vector3 *createHeightVertices(float startX, float startY,
                                   float endX, float endY,
                                   int xCount, int yCount, float  *height);
+                                  int xCount, int yCount, float *height);
     void reset();
     unsigned int _vertexBufferObjectID;
     unsigned int _textureBufferObjectID;
+    unsigned int _texcoordBufferObjectID;
     int _vertexCount;
-    CGparameter _tfParam;
-    CGparameter _opacityParam;
     R2Geometry *_contour;
     R2Geometry *_topContour;
 …
     int _indexCount;
     Vector3 _contourColor;
     bool _contourVisible;
     bool _topContourVisible;
     bool _visible;
     Vector3 _scale;
     Vector3 _centerPoint;

branches/blt4/packages/vizservers/nanovis/Makefile.in

-                      r2936
+                      r2966
                 NvColorTableRenderer.o \
                 NvColorTableShader.o \
-                NvDefaultTFData.o \
                 NvEventLog.o \
-                NvFlowVisRenderer.o \
                 NvLIC.o \
                 NvParticleAdvectionShader.o \
 …
 ifdef NOTDEF
 OBJS +=         DataLoader.o \
+                NvFlowVisRenderer.o \
                 ParticleEmitter.o \
                 ParticleSystem.o \
 …
 NvColorTableRenderer.o: NvColorTableRenderer.cpp NvColorTableRenderer.h
 NvColorTableShader.o: NvColorTableShader.cpp NvColorTableShader.h NvShader.h
-NvDefaultTFData.o: NvDefaultTFData.cpp
 NvEventLog.o: NvEventLog.cpp NvEventLog.h
 NvFlowVisRenderer.o: NvFlowVisRenderer.cpp NvFlowVisRenderer.h

branches/blt4/packages/vizservers/nanovis/NvColorTableRenderer.cpp

r2936	r2966
1	1	/* -- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -- */
2	2	#include <stdlib.h>
	3
	4	#include <GL/glew.h>
3	5
4	6	#include <R2/R2Fonts.h>

branches/blt4/packages/vizservers/nanovis/NvColorTableShader.cpp

-                      r2936
+                      r2966
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-#include <R2/R2FilePath.h>
-#include <GL/glew.h>
-#include <Cg/cgGL.h>
 #include "NvColorTableShader.h"
-#include "Trace.h"
 NvColorTableShader::NvColorTableShader()
 …
+{
     loadFragmentProgram("one_plane.cg", "main");
-    _dataParam = getNamedParameterFromFP("data");
-    _tfParam = getNamedParameterFromFP("tf");
-    _renderParam = getNamedParameterFromFP("render_param");
+}
 void NvColorTableShader::bind(Texture2D *plane, TransferFunction *tf)
+{
+    cgGLSetTextureParameter(_dataParam, plane->id());
+    cgGLSetTextureParameter(_tfParam, tf->id());
+    cgGLEnableTextureParameter(_dataParam);
+    cgGLEnableTextureParameter(_tfParam);
+    cgGLSetParameter4f(_renderParam, 0., 0., 0., 0.);
+    setFPTextureParameter("data", plane->id());
+    setFPTextureParameter("tf", tf->id());
+    setFPParameter4f("render_param", 0., 0., 0., 0.);
     NvShader::bind();
 …
 void NvColorTableShader::unbind()
+{
     cgGLDisableTextureParameter(_dataParam);
     cgGLDisableTextureParameter(_tfParam);
+    disableFPTextureParameter("data");
+    disableFPTextureParameter("tf");
     NvShader::unbind();

branches/blt4/packages/vizservers/nanovis/NvColorTableShader.h

-                      r2936
+                      r2966
 #ifndef NV_COLORTABLE_SHADER_H
 #define NV_COLORTABLE_SHADER_H
-#include <Cg/cg.h>
 #include "NvShader.h"
 …
 private :
     void init();
-    CGparameter _dataParam;
-    CGparameter _tfParam;
-    CGparameter _renderParam;
 };

branches/blt4/packages/vizservers/nanovis/NvFlowVisRenderer.cpp

-                      r2936
+                      r2966
  */
-#include <stdio.h>
-#include <assert.h>
-#include <malloc.h>
-#include <string.h>
-#include <R2/R2FilePath.h>
 #include "NvFlowVisRenderer.h"
-#include "NvVectorField.h"
-#include "Trace.h"
 #define NV_32

branches/blt4/packages/vizservers/nanovis/NvFlowVisRenderer.h

-                      r2936
+                      r2966
 #define NVFLOWVISRENDERER_H
-#include <vector>
 #include <map>
 #include <string>
-#include <GL/glew.h>
-#include <Cg/cgGL.h>
-#include "config.h"
-#include "Renderable.h"
-#include "RenderVertexArray.h"
 #include "Vector3.h"
-#include "NvParticleAdvectionShader.h"
 #include "NvVectorField.h"

branches/blt4/packages/vizservers/nanovis/NvLIC.cpp

-                      r2936
+                      r2966
 NvLIC::NvLIC(int size, int width, int height, int axis,
              const Vector3& offset) :
+             float offset) :
     Renderable(Vector3(0.0f, 0.0f, 0.0f)),
     _width(width),
 …
         case 0 :
             // TBD..
             glTexCoord3f(_offset.x, 0., 0.); glVertex2f(0.,    0.);
             glTexCoord3f(_offset.x, 1., 0.); glVertex2f(_size, 0.);
             glTexCoord3f(_offset.x, 1., 1.); glVertex2f(_size, _size);
             glTexCoord3f(_offset.x, 0., 1.); glVertex2f(0.,    _size);
+            glTexCoord3f(_offset, 0., 0.); glVertex2f(0.,    0.);
+            glTexCoord3f(_offset, 1., 0.); glVertex2f(_size, 0.);
+            glTexCoord3f(_offset, 1., 1.); glVertex2f(_size, _size);
+            glTexCoord3f(_offset, 0., 1.); glVertex2f(0.,    _size);
                 break;
         case 1 :
             // TBD..
             glTexCoord3f(0., _offset.y, 0.); glVertex2f(0.,    0.);
             glTexCoord3f(1., _offset.y, 0.); glVertex2f(_size, 0.);
             glTexCoord3f(1., _offset.y, 1.); glVertex2f(_size, _size);
             glTexCoord3f(0., _offset.y, 1.); glVertex2f(0.,    _size);
+            glTexCoord3f(0., _offset, 0.); glVertex2f(0.,    0.);
+            glTexCoord3f(1., _offset, 0.); glVertex2f(_size, 0.);
+            glTexCoord3f(1., _offset, 1.); glVertex2f(_size, _size);
+            glTexCoord3f(0., _offset, 1.); glVertex2f(0.,    _size);
                 break;
         case 2 :
             glTexCoord3f(0., 0., _offset.z); glVertex2f(0.,    0.);
             glTexCoord3f(1., 0., _offset.z); glVertex2f(_size, 0.);
             glTexCoord3f(1., 1., _offset.z); glVertex2f(_size, _size);
             glTexCoord3f(0., 1., _offset.z); glVertex2f(0.,    _size);
+            glTexCoord3f(0., 0., _offset); glVertex2f(0.,    0.);
+            glTexCoord3f(1., 0., _offset); glVertex2f(_size, 0.);
+            glTexCoord3f(1., 1., _offset); glVertex2f(_size, _size);
+            glTexCoord3f(0., 1., _offset); glVertex2f(0.,    _size);
             break;
+        }
 …
     case 0:
         glNormal3f(1, 0, 0);
         glTexCoord2f(0, 0); glVertex3f(_offset.x, 0, 0);
         glTexCoord2f(1, 0); glVertex3f(_offset.x, 1, 0);
         glTexCoord2f(1, 1); glVertex3f(_offset.x, 1, 1);
         glTexCoord2f(0, 1); glVertex3f(_offset.x, 0, 1);
+        glTexCoord2f(0, 0); glVertex3f(_offset, 0, 0);
+        glTexCoord2f(1, 0); glVertex3f(_offset, 1, 0);
+        glTexCoord2f(1, 1); glVertex3f(_offset, 1, 1);
+        glTexCoord2f(0, 1); glVertex3f(_offset, 0, 1);
         break;
     case 1:
         glNormal3f(0, 1, 0);
         glTexCoord2f(0, 0); glVertex3f(0, _offset.y, 0);
         glTexCoord2f(1, 0); glVertex3f(1, _offset.y, 0);
         glTexCoord2f(1, 1); glVertex3f(1, _offset.y, 1);
         glTexCoord2f(0, 1); glVertex3f(0, _offset.y, 1);
+        glTexCoord2f(0, 0); glVertex3f(0, _offset, 0);
+        glTexCoord2f(1, 0); glVertex3f(1, _offset, 0);
+        glTexCoord2f(1, 1); glVertex3f(1, _offset, 1);
+        glTexCoord2f(0, 1); glVertex3f(0, _offset, 1);
         break;
     case 2:
         glNormal3f(0, 0, 1);
         glTexCoord2f(0, 0); glVertex3f(0, 0, _offset.z);
         glTexCoord2f(1, 0); glVertex3f(1, 0, _offset.z);
         glTexCoord2f(1, 1); glVertex3f(1, 1, _offset.z);
         glTexCoord2f(0, 1); glVertex3f(0, 1, _offset.z);
+        glTexCoord2f(0, 0); glVertex3f(0, 0, _offset);
+        glTexCoord2f(1, 0); glVertex3f(1, 0, _offset);
+        glTexCoord2f(1, 1); glVertex3f(1, 1, _offset);
+        glTexCoord2f(0, 1); glVertex3f(0, 1, _offset);
         break;
+    }
 …
 void
+NvLIC::setOffset(float v)
+{
+    switch (_axis) {
+    case 0 : _offset.x = v; break;
+    case 1 : _offset.y = v; break;
+    case 2 : _offset.z = v; break;
+    }
+NvLIC::setOffset(float offset)
+{
+    _offset = offset;
     getSlice();
+}

branches/blt4/packages/vizservers/nanovis/NvLIC.h

-                      r2936
+                      r2966
+{
 public:
+    NvLIC(int size, int width, int height, int axis,
+          const Vector3& offset);
+    NvLIC(int size, int width, int height, int axis, float offset);
     ~NvLIC();
 …
     void getSlice();
     void setOffset(float v);
+    void setOffset(float offset);
     /**
 …
                                         // plane to fit the actual dimensions
     Vector3 _origin;
+    Vector3 _offset;                    // [0,1] offset could be x, y, or z
+                                        // direction
+    float _offset;                      // [0,1] offset of _axis plane
     int _axis;

branches/blt4/packages/vizservers/nanovis/NvParticleAdvectionShader.cpp

-                      r2936
+                      r2966
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-#include <R2/R2FilePath.h>
-#include <GL/glew.h>
-#include <Cg/cgGL.h>
 #include "NvParticleAdvectionShader.h"
-#include "Trace.h"
 NvParticleAdvectionShader::NvParticleAdvectionShader() :
 …
+{
     loadFragmentProgram("update_pos.cg", "main");
-    _posTexParam       = getNamedParameterFromFP("pos_tex");
-    _initPosTexParam   = getNamedParameterFromFP("init_pos_tex");
-    _velTexParam       = getNamedParameterFromFP("vel_tex");
-    _posTimestepParam  = getNamedParameterFromFP("timestep");
-    _maxParam          = getNamedParameterFromFP("max");
-    _modeParam         = getNamedParameterFromFP("mode");
-    _scaleParam        = getNamedParameterFromFP("scale");
+}
 …
 NvParticleAdvectionShader::bind(unsigned int texID, unsigned int initPosTexID)
+{
+    cgGLSetTextureParameter(_posTexParam, texID);
+    cgGLEnableTextureParameter(_posTexParam);
+    setFPTextureParameter("pos_tex", texID);
+    setFPTextureParameter("init_pos_tex", initPosTexID);
+    setFPTextureParameter("vel_tex", _velocityVolumeID);
+    cgGLSetTextureParameter(_initPosTexParam, initPosTexID);
+    cgGLEnableTextureParameter(_initPosTexParam);
+    cgGLSetTextureParameter(_velTexParam, _velocityVolumeID);
+    cgGLEnableTextureParameter(_velTexParam);
+    cgGLSetParameter1f(_posTimestepParam, _timeStep);
+    cgGLSetParameter1f(_maxParam, _max);
+    cgGLSetParameter1f(_modeParam, _mode);
+    cgGLSetParameter3f(_scaleParam, _scale.x, _scale.y, _scale.z);
+    setFPParameter1f("timestep", _timeStep);
+    setFPParameter1f("max", _max);
+    setFPParameter1f("mode", _mode);
+    setFPParameter3f("scale", _scale.x, _scale.y, _scale.z);
     NvShader::bind();
 …
 NvParticleAdvectionShader::unbind()
+{
      cgGLDisableTextureParameter(_posTexParam);
      cgGLDisableTextureParameter(_initPosTexParam);
      cgGLDisableTextureParameter(_velTexParam);
+     disableFPTextureParameter("pos_tex");
+     disableFPTextureParameter("init_pos_tex");
+     disableFPTextureParameter("vel_tex");
      NvShader::unbind();

branches/blt4/packages/vizservers/nanovis/NvParticleAdvectionShader.h

-                      r2936
+                      r2966
 class NvParticleAdvectionShader : public NvShader
+{
 public:
+public:
     NvParticleAdvectionShader();
 …
         _max = max;
         // FIXME: Is this needed?
         //if (_max > 100.f)
         //    _max = 100.0f;
+        if (_max > 100.f)
+            _max = 100.0f;
+    }
 …
     void init();
-    CGparameter _posTexParam;
-    CGparameter _initPosTexParam;
-    CGparameter _velTexParam;
-    CGparameter _posTimestepParam;
-    CGparameter _maxParam;
-    CGparameter _modeParam;
-    CGparameter _scaleParam;
     unsigned int _velocityVolumeID;
     Vector3 _scale;

branches/blt4/packages/vizservers/nanovis/NvParticleRenderer.cpp

-                      r2936
+                      r2966
  */
-#include <stdio.h>
 #include <assert.h>
-#include <malloc.h>
 #include <string.h>
 #include <stdlib.h>
 #include <R2/R2FilePath.h>
+#include <GL/glew.h>
 #include "NvParticleRenderer.h"
 …
                               GL_TEXTURE_RECTANGLE_ARB, _psysTex[0], 0);
+    CHECK_FRAMEBUFFER_STATUS();
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _psysFbo[1]);
 …
                               GL_TEXTURE_RECTANGLE_ARB, _psysTex[1], 0);
+    CHECK_FRAMEBUFFER_STATUS();
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboOrig);
 …
                  _psysWidth, _psysHeight, 0, GL_RGBA, GL_FLOAT, NULL);
 #endif
-    CHECK_FRAMEBUFFER_STATUS();
     if (_advectionShader == NULL) {
 …
     if (_psysFrame == _maxLife) {
         _psysFrame = 0;
         //        _reborn = true;
+        // _reborn = true;
+    }
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboOrig);
 …
     //_vertexArray->loadData(vert);     //does not work??
     //assert(glGetError()==0);
+}
-void
-NvParticleRenderer::drawBoundingBox(float x0, float y0, float z0,
-                                    float x1, float y1, float z1,
-                                    float r, float g, float b,
-                                    float line_width)
+{
-    glPushAttrib(GL_ENABLE_BIT);
-    glEnable(GL_DEPTH_TEST);
-    glDisable(GL_TEXTURE_2D);
-    glEnable(GL_BLEND);
-    glColor4d(r, g, b, 1.0);
-    glLineWidth(line_width);
-    glBegin(GL_LINE_LOOP);
+    {
-        glVertex3d(x0, y0, z0);
-        glVertex3d(x1, y0, z0);
-        glVertex3d(x1, y1, z0);
-        glVertex3d(x0, y1, z0);
+    }
-    glEnd();
-    glBegin(GL_LINE_LOOP);
+    {
-        glVertex3d(x0, y0, z1);
-        glVertex3d(x1, y0, z1);
-        glVertex3d(x1, y1, z1);
-        glVertex3d(x0, y1, z1);
+    }
-    glEnd();
-    glBegin(GL_LINE_LOOP);
+    {
-        glVertex3d(x0, y0, z0);
-        glVertex3d(x0, y0, z1);
-        glVertex3d(x0, y1, z1);
-        glVertex3d(x0, y1, z0);
+    }
-    glEnd();
-    glBegin(GL_LINE_LOOP);
+    {
-        glVertex3d(x1, y0, z0);
-        glVertex3d(x1, y0, z1);
-        glVertex3d(x1, y1, z1);
-        glVertex3d(x1, y1, z0);
+    }
-    glEnd();
-    glPopAttrib();
+}
 …
     glScaled(_scale.x, _scale.y, _scale.z);
-    // TBD...
-    /*
-      drawBoundingBox(0, 0, 0,
-, 1, 1,
-, 1, 1, 2);
-      drawBoundingBox(0, 0.5f / 4.5f, 0.5f / 4.5,
-, 4.0f / 4.5f, 4.0f / 4.5,
-, 0, 0, 2);
-      drawBoundingBox(1/3.0f, 1.0f / 4.5f, 0.5f / 4.5,
-/3.0f, 3.5f / 4.5f, 3.5f / 4.5,
-, 1, 0, 2);
-    */
     glPointSize(_particleSize);
     glColor4f(_color.x, _color.y, _color.z, _color.w);
     glEnableClientState(GL_VERTEX_ARRAY);
     _vertexArray->setPointer(0);
 …
     glPopMatrix();
     glPopAttrib();
-    //assert(glGetError()==0);
+}

branches/blt4/packages/vizservers/nanovis/NvParticleRenderer.h

-                      r2936
+                      r2966
 #define NVPARTICLERENDERER_H
-#include <vector>
 #include <GL/glew.h>
-#include <Cg/cgGL.h>
-#include "config.h"
 #include "Renderable.h"
+#include "NvParticleAdvectionShader.h"
 #include "RenderVertexArray.h"
 #include "Vector3.h"
 #include "NvParticleAdvectionShader.h"
+#include "Vector4.h"
 struct Particle {
 …
     void setPos(float pos);
-    void drawBoundingBox(float x0, float y0, float z0,
-                         float x1, float y1, float z1,
-                         float r, float g, float b, float line_width);
     void initializeDataArray();

branches/blt4/packages/vizservers/nanovis/NvShader.cpp

-                      r2936
+                      r2966
     TRACE("In ~NvShader");
     if (_cgContext == NULL) {
         TRACE("Lost Cg context");
+        TRACE("Lost Cg context: vp: %s, fp: %s", _vpFile.c_str(), _fpFile.c_str());
     } else {
         resetPrograms();
 …
     _cgVP = loadCgSourceProgram(_cgContext, fileName,
                                 _vertexProfile, entryPoint);
+    _vpFile = fileName;
+}
 …
     _cgFP = loadCgSourceProgram(_cgContext, fileName,
                                 _fragmentProfile, entryPoint);
+    _fpFile = fileName;
+}
 …
+{
     if (_cgVP != NULL) {
+        TRACE("Destroying vertex program: %s\n", _vpFile.c_str());
         cgDestroyProgram(_cgVP);
+    }
     if (_cgFP != NULL) {
+        TRACE("Destroying fragment program: %s\n", _fpFile.c_str());
         cgDestroyProgram(_cgFP);
+    }

branches/blt4/packages/vizservers/nanovis/NvShader.h

-                      r2936
+                      r2966
 #define NV_SHADER_H
+#include <string>
+#include <tr1/unordered_map>
 #include <GL/glew.h>
 #include <Cg/cg.h>
 …
+{
 public:
+    enum NvGLMatrix {
+        MODELVIEW_MATRIX = CG_GL_MODELVIEW_MATRIX,
+        PROJECTION_MATRIX = CG_GL_PROJECTION_MATRIX,
+        MODELVIEW_PROJECTION_MATRIX = CG_GL_MODELVIEW_PROJECTION_MATRIX
+    };
+    enum NvGLMatrixType {
+        MATRIX_IDENTITY = CG_GL_MATRIX_IDENTITY,
+        MATRIX_INVERSE = CG_GL_MATRIX_INVERSE
+    };
     typedef void NvCgCallbackFunction(void);
 …
             return cgGetNamedParameter(_cgFP, paramName);
+        }
+        ERROR("Unknown fragment program parameter: %s\n", paramName);
         return 0;
+    }
 …
             return cgGetNamedParameter(_cgVP, paramName);
+        }
+        ERROR("Unknown vertex program parameter: %s\n", paramName);
         return 0;
+    }
+    void setTextureParameter(CGparameter param, GLuint texobj)
+    {
+    void setVPParameter1f(const char *name, float val)
+    {
+        CGparameter param = getVPParam(name);
+        if (param == NULL)
+            return;
+        cgSetParameter1f(param, val);
+    }
+    void setFPParameter1f(const char *name, float val)
+    {
+        CGparameter param = getFPParam(name);
+        if (param == NULL)
+            return;
+        cgSetParameter1f(param, val);
+    }
+    void setVPParameter2f(const char *name, float val1, float val2)
+    {
+        CGparameter param = getVPParam(name);
+        if (param == NULL)
+            return;
+        cgSetParameter2f(param, val1, val2);
+    }
+    void setFPParameter2f(const char *name, float val1, float val2)
+    {
+        CGparameter param = getFPParam(name);
+        if (param == NULL)
+            return;
+        cgSetParameter2f(param, val1, val2);
+    }
+    void setVPParameter3f(const char *name, float val1, float val2, float val3)
+    {
+        CGparameter param = getVPParam(name);
+        if (param == NULL)
+            return;
+        cgSetParameter3f(param, val1, val2, val3);
+    }
+    void setFPParameter3f(const char *name, float val1, float val2, float val3)
+    {
+        CGparameter param = getFPParam(name);
+        if (param == NULL)
+            return;
+        cgSetParameter3f(param, val1, val2, val3);
+    }
+    void setVPParameter4f(const char *name, float val1, float val2, float val3, float val4)
+    {
+        CGparameter param = getVPParam(name);
+        if (param == NULL)
+            return;
+        cgSetParameter4f(param, val1, val2, val3, val4);
+    }
+    void setFPParameter4f(const char *name, float val1, float val2, float val3, float val4)
+    {
+        CGparameter param = getFPParam(name);
+        if (param == NULL)
+            return;
+        cgSetParameter4f(param, val1, val2, val3, val4);
+    }
+    void setVPTextureParameter(const char *name, GLuint texobj, bool enable = true)
+    {
+        CGparameter param = getVPParam(name);
+        if (param == NULL)
+            return;
         cgGLSetTextureParameter(param, texobj);
+    }
+    CGprogram getVP() const
+    {
+        return _cgVP;
+    }
+    CGprogram getFP() const
+    {
+        return _cgFP;
+        if (enable)
+            cgGLEnableTextureParameter(param);
+    }
+    void setFPTextureParameter(const char *name, GLuint texobj, bool enable = true)
+    {
+        CGparameter param = getFPParam(name);
+        if (param == NULL)
+            return;
+        cgGLSetTextureParameter(param, texobj);
+        if (enable)
+            cgGLEnableTextureParameter(param);
+    }
+    void enableVPTextureParameter(const char *name)
+    {
+        CGparameter param = getVPParam(name);
+        if (param == NULL)
+            return;
+        cgGLEnableTextureParameter(param);
+    }
+    void enaableFPTextureParameter(const char *name)
+    {
+        CGparameter param = getFPParam(name);
+        if (param == NULL)
+            return;
+        cgGLEnableTextureParameter(param);
+    }
+    void disableVPTextureParameter(const char *name)
+    {
+        CGparameter param = getVPParam(name);
+        if (param == NULL)
+            return;
+        cgGLDisableTextureParameter(param);
+    }
+    void disableFPTextureParameter(const char *name)
+    {
+        CGparameter param = getFPParam(name);
+        if (param == NULL)
+            return;
+        cgGLDisableTextureParameter(param);
+    }
+    void setGLStateMatrixVPParameter(const char *name, NvGLMatrix matrix, NvGLMatrixType type)
+    {
+        CGparameter param = getVPParam(name);
+        if (param == NULL)
+            return;
+        cgGLSetStateMatrixParameter(param, (CGGLenum)matrix, (CGGLenum)type);
+    }
+    void setGLStateMatrixFPParameter(const char *name, NvGLMatrix matrix, NvGLMatrixType type)
+    {
+        CGparameter param = getFPParam(name);
+        if (param == NULL)
+            return;
+        cgGLSetStateMatrixParameter(param, (CGGLenum)matrix, (CGGLenum)type);
+    }
 …
 protected:
+    typedef std::tr1::unordered_map<std::string, CGparameter> ParameterHashmap;
+    CGprogram getVP()
+    {
+        return _cgVP;
+    }
+    CGprogram getFP()
+    {
+        return _cgFP;
+    }
+    CGparameter getVPParam(const char *name)
+    {
+        CGparameter param;
+        ParameterHashmap::iterator itr = _vpParams.find(name);
+        if (itr == _vpParams.end()) {
+            param = getNamedParameterFromVP(name);
+            if (param != NULL)
+                _vpParams[name] = param;
+            else
+                ERROR("Unknown vertex program parameter: %s\n", name);
+        } else {
+            param = itr->second;
+        }
+        return param;
+    }
+    CGparameter getFPParam(const char *name)
+    {
+        CGparameter param;
+        ParameterHashmap::iterator itr = _fpParams.find(name);
+        if (itr == _fpParams.end()) {
+            param = getNamedParameterFromFP(name);
+            if (param != NULL)
+                _fpParams[name] = param;
+            else
+                ERROR("Unknown fragment program parameter: %s\n", name);
+        } else {
+            param = itr->second;
+        }
+        return param;
+    }
     void resetPrograms();
     CGprofile _vertexProfile;
     CGprofile _fragmentProfile;
+    std::string _vpFile;
     CGprogram _cgVP;
+    std::string _fpFile;
     CGprogram _cgFP;
+    ParameterHashmap _vpParams;
+    ParameterHashmap _fpParams;
     static CGprofile _defaultVertexProfile;

branches/blt4/packages/vizservers/nanovis/NvStdVertexShader.cpp

-                      r2936
+                      r2966
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-#include <stdio.h>
-#include <GL/glew.h>
-#include <Cg/cgGL.h>
 #include "NvStdVertexShader.h"
 …
+{
     loadVertexProgram("vertex_std.cg", "main");
-    _mvpVertStdParam = getNamedParameterFromVP("modelViewProjMatrix");
-    _mviVertStdParam = getNamedParameterFromVP("modelViewInv");
+}
 void NvStdVertexShader::bind()
+{
     cgGLSetStateMatrixParameter(_mvpVertStdParam, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
     cgGLSetStateMatrixParameter(_mviVertStdParam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE);
+    setGLStateMatrixVPParameter("modelViewProjMatrix", MODELVIEW_PROJECTION_MATRIX, MATRIX_IDENTITY);
+    setGLStateMatrixVPParameter("modelViewInv", MODELVIEW_MATRIX, MATRIX_INVERSE);
     NvShader::bind();

branches/blt4/packages/vizservers/nanovis/NvStdVertexShader.h

-                      r2936
+                      r2966
 private:
     void init();
-    /// A parameter id for ModelViewProjection matrix of Cg program
-    CGparameter _mvpVertStdParam;
-    /// A parameter id for ModelViewInverse matrix of Cg program
-    CGparameter _mviVertStdParam;
 };

branches/blt4/packages/vizservers/nanovis/NvZincBlendeVolumeShader.cpp

r2936	r2966
1	1	/* -- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -- */
2
3		~~#include <string.h>~~
4	2
5	3	#include <GL/glew.h>

branches/blt4/packages/vizservers/nanovis/PlaneRenderer.cpp

r2936	r2966
14	14	* ======================================================================
15	15	*/
	16
	17	#include <GL/glew.h>
16	18
17	19	#include "PlaneRenderer.h"

branches/blt4/packages/vizservers/nanovis/PlaneRenderer.h

-                      r2936
+                      r2966
 #define PLANE_RENDERER_H
-#include <math.h>
-#include <stdio.h>
-#include <assert.h>
-#include <float.h>
 #include <vector>
-#include <GL/glew.h>
-#include <Cg/cgGL.h>
 #include "NvColorTableShader.h"

branches/blt4/packages/vizservers/nanovis/PointSetRenderer.cpp

-                      r2936
+                      r2966
+}
+PointSetRenderer::~PointSetRenderer()
+{
+}
 void PointSetRenderer::renderPoints(PCA::Point *points, int length)
+{
 …
     glBegin(GL_POINTS);
     PCA::ClusterList* p;
+    PCA::ClusterList *p;
     for (int i = size - 1; i >= 0; --i) {
         p = bucket[i];

branches/blt4/packages/vizservers/nanovis/PointSetRenderer.h

r2936	r2966
11	11	class PointSetRenderer
12	12	{
13		public:
	13	public:
14	14	PointSetRenderer();
15	15	~PointSetRenderer();

branches/blt4/packages/vizservers/nanovis/PointShader.cpp

-                      r2936
+                      r2966
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <R2/R2FilePath.h>
-#include <R2/R2string.h>
 #include "PointShader.h"
 PointShader::PointShader() :
+    NvShader(),
+    NvShader(),
+    _scale(1.0f),
     _normal(NULL)
+{
     loadVertexProgram("pointsvp.cg", "main");
-    _modelviewVP  = getNamedParameterFromVP("modelview");
-    _projectionVP = getNamedParameterFromVP("projection");
-    _attenVP      = getNamedParameterFromVP("atten");
-    _posoffsetVP  = getNamedParameterFromVP("posoffset");
-    _baseposVP    = getNamedParameterFromVP("basepos");
-    _scaleVP      = getNamedParameterFromVP("scale");
-    _normalParam  = getNamedParameterFromVP("normal");
+}
 …
+}
 void PointShader::setParameters()
+void PointShader::bind()
+{
     cgGLSetStateMatrixParameter(_modelviewVP, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
     cgGLSetStateMatrixParameter(_projectionVP, CG_GL_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
+    setGLStateMatrixVPParameter("modelview", MODELVIEW_MATRIX, MATRIX_IDENTITY);
+    setGLStateMatrixVPParameter("projection", PROJECTION_MATRIX, MATRIX_IDENTITY);
+    cgGLSetParameter1f(_attenVP, 1.0f);
+    cgGLSetParameter4f(_posoffsetVP, 1.0f, 1.0f, 1.0f, 1.0f);
+    cgGLSetParameter4f(_baseposVP, 1.0f, 1.0f, 1.0f, 1.0f);
+    cgGLSetParameter4f(_scaleVP, 1.0f, 1.0f, 1.0f, 1.0f);
+    setVPParameter1f("atten", 1.0f);
+    setVPParameter4f("posoffset", 1.0f, 1.0f, 1.0f, 1.0f);
+    setVPParameter4f("basepos", 1.0f, 1.0f, 1.0f, 1.0f);
+    setVPParameter4f("scale", _scale, 1.0f, 1.0f, 1.0f);
+    //setVPTextureParameter("normal", _normal->getGraphicsObjectID());
+    //cgGLSetTextureParameter(_normalParam,_normal->getGraphicsObjectID());
+    //cgGLEnableTextureParameter(_normalParam);
+    NvShader::bind();
+}
 void PointShader::resetParameters()
+void PointShader::unbind()
+{
+    //cgGLDisableTextureParameter(_normalParam);
+    //disableVPTextureParameter("normal");
+    NvShader::unbind();
+}

branches/blt4/packages/vizservers/nanovis/PointShader.h

-                      r2936
+                      r2966
     void setScale(float scale)
+    {
         cgGLSetParameter4f(_scaleVP, scale, 1.0f, 1.0f, 1.0f);
+        _scale = scale;
+    }
     void setNormalTexture(Texture3D *n)
+    void setNormalTexture(Texture3D *normal)
+    {
         _normal = n;
+        _normal = normal;
+    }
+    virtual void bind()
+    {
+        setParameters();
+    virtual void bind();
+        NvShader::bind();
+    }
+    virtual  void unbind()
+    {
+        resetParameters();
+        NvShader::unbind();
+    }
+protected:
+    virtual void setParameters();
+    virtual void resetParameters();
+    virtual void unbind();
 private:
+    CGparameter _modelviewVP;
+    CGparameter _projectionVP;
+    CGparameter _attenVP;
+    CGparameter _posoffsetVP;
+    CGparameter _baseposVP;
+    CGparameter _scaleVP;
+    CGparameter _normalParam;
+    float _scale;
+    float _scale;
     Texture3D *_normal;
 };

branches/blt4/packages/vizservers/nanovis/R2/src/R2Fonts.cpp

-                      r2936
+                      r2966
 R2Fonts::begin()
+{
+    glPushAttrib(GL_TRANSFORM_BIT | GL_ENABLE_BIT);
     glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, _fonts[_fontIndex]. _fontTextureID);
+    glPushAttrib(GL_TRANSFORM_BIT | GL_ENABLE_BIT);
+    glBindTexture(GL_TEXTURE_2D, _fonts[_fontIndex]._fontTextureID);
     glMatrixMode(GL_PROJECTION);
     glPushMatrix();
+    glLoadIdentity( );
+    glLoadIdentity();
     gluOrtho2D(0.0f, _screenWidth, _screenHeight, 0.0f);
     glMatrixMode(GL_MODELVIEW);
+    glPushMatrix( );
+    glLoadIdentity( );
+    glEnable(GL_TEXTURE_2D);
+    glPushMatrix();
+    glLoadIdentity();
     glEnable(GL_BLEND);
     glDisable(GL_DEPTH_TEST);
 …
     glMatrixMode(GL_PROJECTION);
     glPopMatrix( );
+    glPopMatrix();
     glMatrixMode(GL_MODELVIEW);
     glPopMatrix( );
     glPopAttrib( );
+    glPopMatrix();
+    glPopAttrib();
+}
 …
+        }
         fsInput.close( );
+        fsInput.close();
+    }
     delete [] path;

branches/blt4/packages/vizservers/nanovis/RenderVertexArray.cpp

-                      r2936
+                      r2966
     switch (_type) {
     case GL_HALF_FLOAT_NV:
+        _bytesPerComponent = 2; break;
+        _bytesPerComponent = 2;
+        break;
     case GL_FLOAT:
+        _bytesPerComponent = sizeof(float); break;
+        _bytesPerComponent = sizeof(float);
+        break;
     default:
         ERROR("unsupported RenderVertexArray type\n");
 …
     switch(_size) {
     case 1:
+        _format = GL_LUMINANCE; break;
+        _format = GL_LUMINANCE;
+        break;
     case 3:
+        _format = GL_RGB; break;
+        _format = GL_RGB;
+        break;
     case 4:
+        _format = GL_RGBA; break;
+        _format = GL_RGBA;
+        break;
     default:
         ERROR("unsupported RenderVertexArray size\n");

branches/blt4/packages/vizservers/nanovis/Unirect.cpp

r2936	r2966
734	734	}
735	735	}
736		TRACE("~~GetVectorRange~~ %g %g\n", _magMin, _magMax);
	736	TRACE("getVectorRange: %g %g\n", _magMin, _magMax);
737	737	}
738	738

branches/blt4/packages/vizservers/nanovis/VelocityArrowsSlice.h

-                      r2936
+                      r2966
 private:
+    void createRenderTarget();
+    void computeSamplingTicks();
     unsigned int _vectorFieldGraphicsID;
     float _vfXscale;
 …
     RenderMode _renderMode;
-    void createRenderTarget();
-    void computeSamplingTicks();
 };

branches/blt4/packages/vizservers/nanovis/VolumeInterpolator.cpp

-                      r2936
+                      r2966
     _numBytes(0),
     _dataCount(0),
+    _numComponents(0),
+    _referenceOfVolume(0)
+    _numComponents(0)
+{
+}
 …
         _numComponents = refPtr->numComponents();
         _numBytes = _dataCount * _numComponents * sizeof(float);
         Vector3 loc = refPtr->location();
+        Vector3 loc = refPtr->location();
         _volume = new Volume(loc.x, loc.y, loc.z,
                              refPtr->width, refPtr->height, refPtr->depth,
 …
                              refPtr->wAxis.min(),
                              refPtr->wAxis.max(),
+                             refPtr->nonZeroMin());
+        /*
+        _referenceOfVolume = refPtr->dataID();
+        */
+                             refPtr->nonZeroMin());
         _volume->numSlices(256-1);
         _volume->disableCutplane(0);
 …
         _volume->isosurface(0);
         TRACE("VOL : location %f %f %f\n\tid : %s\n", loc.x, loc.y, loc.z,
                refPtr->name());
+               refPtr->name());
+    }
     _volumes.push_back(_volume);

branches/blt4/packages/vizservers/nanovis/VolumeInterpolator.h

-                      r2936
+                      r2966
     double getStartTime() const;
-    unsigned int getReferenceVolumeID() const;
     Volume *getVolume();
 …
     unsigned int _dataCount;
     unsigned int _numComponents;
-    unsigned int _referenceOfVolume;
     double _startTime;
 };
 …
+}
-inline unsigned int VolumeInterpolator::getReferenceVolumeID() const
+{
-    return _referenceOfVolume;
+}
 #endif

branches/blt4/packages/vizservers/nanovis/VolumeRenderer.h

r2936	r2966
146	146
147	147	//standard vertex shader parameters
148		~~CGprogram _vertStdVprog;~~
149	148	CGparameter _mvpVertStdParam;
150	149	CGparameter _mviVertStdParam;

branches/blt4/packages/vizservers/nanovis/dxReader.cpp

-                      r2936
+                      r2966
                 // save corners of bounding box first, to work around meshing
                 // problems in voronoi utility
+                ftmp << xymesh.rangeMin(Rappture::xaxis) << " "
+                     << xymesh.rangeMin(Rappture::yaxis) << std::endl;
+                ftmp << xymesh.rangeMax(Rappture::xaxis) << " "
+                     << xymesh.rangeMin(Rappture::yaxis) << std::endl;
+                ftmp << xymesh.rangeMax(Rappture::xaxis) << " "
+                     << xymesh.rangeMax(Rappture::yaxis) << std::endl;
+                ftmp << xymesh.rangeMin(Rappture::xaxis) << " "
+                     << xymesh.rangeMax(Rappture::yaxis) << std::endl;
+                int numBoundaryPoints = 4;
+                // Bump out the bounds by an epsilon to avoid problem when
+                // corner points are already nodes
+                double XEPS = (xymesh.rangeMax(Rappture::xaxis) -
+                               xymesh.rangeMin(Rappture::xaxis)) / 10.0f;
+                double YEPS = (xymesh.rangeMax(Rappture::yaxis) -
+                               xymesh.rangeMin(Rappture::yaxis)) / 10.0f;
+                ftmp << xymesh.rangeMin(Rappture::xaxis) - XEPS << " "
+                     << xymesh.rangeMin(Rappture::yaxis) - YEPS << std::endl;
+                ftmp << xymesh.rangeMax(Rappture::xaxis) + XEPS << " "
+                     << xymesh.rangeMin(Rappture::yaxis) - YEPS << std::endl;
+                ftmp << xymesh.rangeMax(Rappture::xaxis) + XEPS << " "
+                     << xymesh.rangeMax(Rappture::yaxis) + YEPS << std::endl;
+                ftmp << xymesh.rangeMin(Rappture::xaxis) - XEPS << " "
+                     << xymesh.rangeMax(Rappture::yaxis) + YEPS << std::endl;
                 for (int i = 0; i < nxy; i++) {
                     ftmp << xymesh.atNode(i).x() << " " << xymesh.atNode(i).y() << std::endl;
 …
                         ftri.getline(line,sizeof(line)-1);
                         if (sscanf(line, "%d %d %d", &cx, &cy, &cz) == 3) {
+                            if (cx >= 4 && cy >= 4 && cz >= 4) {
+                                // skip first 4 boundary points
+                                xymesh.addCell(cx-4, cy-4, cz-4);
+                            if (cx >= numBoundaryPoints &&
+                                cy >= numBoundaryPoints &&
+                                cz >= numBoundaryPoints) {
+                                // skip boundary points we added
+                                xymesh.addCell(cx - numBoundaryPoints,
+                                               cy - numBoundaryPoints,
+                                               cz - numBoundaryPoints);
+                            }
+                        }
 …
+    }
+    TRACE("found nx=%d ny=%d nz=%d\ndx=%f dy=%f dz=%f\nx0=%f y0=%f z0=%f\n",
+          nx, ny, nz, dx, dy, dz, x0, y0, z0);
+    TRACE("found nx=%d ny=%d nxy=%d nz=%d\ndx=%f dy=%f dz=%f\nx0=%f y0=%f z0=%f\n",
+          nx, ny, nxy, nz, dx, dy, dz, x0, y0, z0);
+    lx = (nx - 1) * dx;
+    ly = (ny - 1) * dy;
+    lz = (nz - 1) * dz;
     // read data points
 …
+    }
     Volume *volPtr = NULL;
+    lx = (nx - 1) * dx;
+    ly = (ny - 1) * dy;
+    lz = (nz - 1) * dz;
+    float *data = NULL;
+    double vmin = DBL_MAX;
+    double nzero_min = DBL_MAX;
+    double vmax = -DBL_MAX;
     if (isrect) {
 #if ISO_TEST
         float *data = new float[nx *  ny *  nz * 4];
+        data = new float[nx *  ny *  nz * 4];
         memset(data, 0, nx*ny*nz*4);
-        double vmin = DBL_MAX;
-        double nzero_min = DBL_MAX;
-        double vmax = -DBL_MAX;
 #else // !ISO_TEST
         Rappture::Mesh1D xgrid(x0, x0 + lx, nx);
 …
 #if ISO_TEST
         double dv = vmax - vmin;
-        int count = nx*ny*nz;
-        int ngen = 0;
-        double v;
         if (dv == 0.0) {
             dv = 1.0;
+        }
+        for (int i = 0; i < count; ++i) {
+            v = data[ngen];
+        int ngen = 0;
+        const int step = 4;
+        for (int i = 0; i < nx*ny*nz; ++i) {
+            double v = data[ngen];
             // scale all values [0-1], -1 => out of bounds
             v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
             data[ngen] = v;
             ngen += 4;
+            ngen += step;
+        }
 …
         dz = lz /(double)(nz - 1);
+        double vmin = field.valueMin();
+        double vmax = field.valueMax();
+        vmin = field.valueMin();
+        vmax = field.valueMax();
+        nzero_min = DBL_MAX;
         double dv = vmax - vmin;
         if (dv == 0.0) {
             dv = 1.0;
+        }
+        double nzero_min = DBL_MAX;
         int ngen = 0;
 #if FILTER_GRADIENTS
 …
         // to be filled in by computeSimpleGradient()
         const int step = 4;
         float *data = new float[nx*ny*nz * step];
+        data = new float[nx*ny*nz * step];
 #endif // FILTER_GRADIENTS
 …
         // computeGradient returns a new array with gradients
         // filled in, so data is now 4 floats per node
         float *data = computeGradient(cdata, nx, ny, nz,
                                       dx, dy, dz,
                                       vmin, vmax);
+        data = computeGradient(cdata, nx, ny, nz,
+                               dx, dy, dz,
+                               vmin, vmax);
         delete [] cdata;
 #else // !FILTER_GRADIENTS
 …
 #endif // ISO_TEST
-        TRACE("nx = %i ny = %i nz = %i\n", nx, ny, nz);
-        TRACE("lx = %lg ly = %lg lz = %lg\n", lx, ly, lz);
-        TRACE("dx = %lg dy = %lg dz = %lg\n", dx, dy, dz);
-        TRACE("dataMin = %lg\tdataMax = %lg\tnzero_min = %lg\n",
-              vmin, vmax, nzero_min);
-        volPtr = NanoVis::loadVolume(tag, nx, ny, nz, 4, data,
-                                     vmin, vmax, nzero_min);
-        volPtr->xAxis.setRange(x0, x0 + lx);
-        volPtr->yAxis.setRange(y0, y0 + ly);
-        volPtr->zAxis.setRange(z0, z0 + lz);
-        volPtr->wAxis.setRange(vmin, vmax);
-        volPtr->updatePending = true;
-        // TBD..
-#if 0 && defined(USE_POINTSET_RENDERER)
-        PointSet *pset = new PointSet();
-        pset->initialize(volPtr, (float*)data);
-        pset->setVisible(true);
-        NanoVis::pointSet.push_back(pset);
-        updateColor(pset);
-        volPtr->pointsetIndex = NanoVis::pointSet.size() - 1;
-#endif
-        delete [] data;
     } else {
         Rappture::Mesh1D zgrid(z0, z0 + (nz-1)*dz, nz);
 …
+        }
-        // figure out a good mesh spacing
-        int nsample = 30;
         x0 = field.rangeMin(Rappture::xaxis);
         lx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
 …
         z0 = field.rangeMin(Rappture::zaxis);
         lz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
+        // figure out a good mesh spacing
+        int nsample = 30;
         double dmin = pow((lx*ly*lz)/((nsample-1)*(nsample-1)*(nsample-1)), 0.333);
 …
         dz = lz /(double)(nz - 1);
+        float *data = new float[4*nx*ny*nz];
+        double vmin = field.valueMin();
+        double vmax = field.valueMax();
+        vmin = field.valueMin();
+        vmax = field.valueMax();
+        nzero_min = DBL_MAX;
         double dv = vmax - vmin;
         if (dv == 0.0) {
 …
+        }
+        data = new float[4*nx*ny*nz];
         // generate the uniformly sampled data that we need for a volume
         int ngen = 0;
-        double nzero_min = DBL_MAX;
         for (int iz = 0; iz < nz; iz++) {
             double zval = z0 + iz*dz;
 …
         computeSimpleGradient(data, nx, ny, nz,
                               dx, dy, dz);
+        volPtr = NanoVis::loadVolume(tag, nx, ny, nz, 4, data,
+                                     vmin, vmax, nzero_min);
+        volPtr->xAxis.setRange(field.rangeMin(Rappture::xaxis),
+                               field.rangeMax(Rappture::xaxis));
+        volPtr->yAxis.setRange(field.rangeMin(Rappture::yaxis),
+                               field.rangeMax(Rappture::yaxis));
+        volPtr->zAxis.setRange(field.rangeMin(Rappture::zaxis),
+                               field.rangeMax(Rappture::zaxis));
+        volPtr->wAxis.setRange(field.valueMin(), field.valueMax());
+        volPtr->updatePending = true;
+        // TBD..
+    }
+    TRACE("nx = %i ny = %i nz = %i\n", nx, ny, nz);
+    TRACE("x0 = %lg y0 = %lg z0 = %lg\n", x0, y0, z0);
+    TRACE("lx = %lg ly = %lg lz = %lg\n", lx, ly, lz);
+    TRACE("dx = %lg dy = %lg dz = %lg\n", dx, dy, dz);
+    TRACE("dataMin = %lg dataMax = %lg nzero_min = %lg\n",
+          vmin, vmax, nzero_min);
+    volPtr = NanoVis::loadVolume(tag, nx, ny, nz, 4, data,
+                                 vmin, vmax, nzero_min);
+    volPtr->xAxis.setRange(x0, x0 + lx);
+    volPtr->yAxis.setRange(y0, y0 + ly);
+    volPtr->zAxis.setRange(z0, z0 + lz);
+    volPtr->updatePending = true;
+    // TBD..
 #if 0 && defined(USE_POINTSET_RENDERER)
         PointSet *pset = new PointSet();
         pset->initialize(volPtr, (float*)data);
         pset->setVisible(true);
         NanoVis::pointSet.push_back(pset);
         updateColor(pset);
         volPtr->pointsetIndex = NanoVis::pointSet.size() - 1;
+    PointSet *pset = new PointSet();
+    pset->initialize(volPtr, (float*)data);
+    pset->setVisible(true);
+    NanoVis::pointSet.push_back(pset);
+    updateColor(pset);
+    volPtr->pointsetIndex = NanoVis::pointSet.size() - 1;
 #endif
+        delete [] data;
+    }
+    delete [] data;
     //

branches/blt4/packages/vizservers/nanovis/imgLoaders/BMPImageLoaderImpl.cpp

-                      r2936
+                      r2966
+            }
         } else if (_targetImageFormat == Image::IMG_RGBA) {
             char *buff = (char*)malloc(width * height * sizeof(unsigned char) * 3);
+            unsigned char *buff = (unsigned char*)malloc(width * height * sizeof(unsigned char) * 3);
             if (fread(buff, width*height*3, 1, f) != 1) {
                 ERROR("can't read BMP image data\n");
 …
             for (x = 0, y = 0; x < width*height*3; x += 3, y += 4) {       //except the format is BGR, grr
                 bytes[y] = buff[x+2];
+                bytes[y+1] = buff[x+1];
                 bytes[y+2] = buff[x];
                 bytes[y+3] = 255;
 …
+            }
         } else if (_targetImageFormat == Image::IMG_RGB) {
             char *buff = (char*)malloc(width * height * sizeof(unsigned char) * 3);
+            unsigned char *buff = (unsigned char*)malloc(width * height * sizeof(unsigned char) * 4);
             if (fread(buff, width*height*4, 1, f) != 1) {
                 ERROR("can't read BMP image data\n");
 …
             for (x = 0, y = 0; x < width*height*4; x += 4, y += 3) {       //except the format is BGR, grr
                 bytes[y] = buff[x+2];
+                bytes[y+1] = buff[x+1];
                 bytes[y+2] = buff[x];
+            }
 …
                 for (int c = 0; c < 3; ++c) {
                     //bytes[(y*width+x)*3+c] = cols[byte*4+2-c];        //and look up in the table
                     bytes[(y*width+x)*_targetImageFormat + c] = cols[byte*4+2-c];       //and look up in the table
+                    bytes[(y*width+x)*_targetImageFormat + c] = cols[byte*4+2-c];       //and look up in the table
+                }
+            }
+                if (_targetImageFormat == Image::IMG_RGBA) {
+                    bytes[(y*width+x)*_targetImageFormat + 3] = 255;
+                }
+            }
+        }
         break;

branches/blt4/packages/vizservers/nanovis/nanovis.cpp

-                      r2936
+                      r2966
 Texture2D *NanoVis::legendTexture = NULL;
 NvColorTableRenderer *NanoVis::colorTableRenderer = NULL;
+#ifdef notdef
 NvFlowVisRenderer *NanoVis::flowVisRenderer = NULL;
+#endif
 VelocityArrowsSlice *NanoVis::velocityArrowsSlice = NULL;
 …
 Tcl_Interp *NanoVis::interp;
-Tcl_DString NanoVis::cmdbuffer;
 //frame buffer for final rendering
 …
 float NanoVis::wMin = FLT_MAX;
 float NanoVis::wMax = -FLT_MAX;
-float NanoVis::xOrigin;
-float NanoVis::yOrigin;
-float NanoVis::zOrigin;
 /* FIXME: This variable is always true. */
 …
 // Image based flow visualization slice location
 // FLOW
+float NanoVis::_licSliceX = 0.5f;
+float NanoVis::_licSliceY = 0.5f;
+float NanoVis::_licSliceZ = 0.5f;
+float NanoVis::_licSlice = 0.5f;
 int NanoVis::_licAxis = 2; // z axis
 static void
 removeAllData()
+void
+NanoVis::removeAllData()
+{
     //
 …
 doExit(int code)
+{
     TRACE("in doExit\n");
     removeAllData();
+    TRACE("in doExit: %d\n", code);
+    NanoVis::removeAllData();
     NvShader::exitCg();
 …
 int
 NanoVis::renderLegend(TransferFunction *tf, double min, double max,
                       int width, int height, const char* volArg)
+                      int width, int height, const char *volArg)
+{
     TRACE("in renderLegend\n");
 …
         ssize_t nWritten;
         TRACE("ppm legend image");
+        TRACE("Sending ppm legend image %s min:%g max:%g", volArg, min, max);
         sprintf(prefix, "nv>legend %s %g %g", volArg, min, max);
         ppmWrite(prefix);
 …
     resizeOffscreenBuffer(old_width, old_height);
+    delete legendTexture;
+    legendTexture = NULL;
     TRACE("leaving renderLegend\n");
-    delete legendTexture;
     return TCL_OK;
+}
 …
 #endif
-void NanoVis::initParticle()
+{
-    flowVisRenderer->initialize();
-    licRenderer->makePatterns();
+}
 static
 void cgErrorCallback(void)
 …
     colorTableRenderer = new NvColorTableRenderer();
     colorTableRenderer->setFonts(fonts);
+#ifdef notdef
     flowVisRenderer = new NvFlowVisRenderer(NMESH, NMESH);
+#endif
     velocityArrowsSlice = new VelocityArrowsSlice;
+    licRenderer = new NvLIC(NMESH, NPIX, NPIX, _licAxis,
+                            Vector3(_licSliceX, _licSliceY, _licSliceZ));
+    licRenderer = new NvLIC(NMESH, NPIX, NPIX, _licAxis, _licSlice);
     grid = new Grid();
 …
 #endif
 static void
 draw3dAxis()
+void
+NanoVis::draw3dAxis()
+{
     glPushAttrib(GL_ENABLE_BIT);
 …
 #ifdef notdef
+void NanoVis::initParticle()
+{
+    flowVisRenderer->initialize();
+    licRenderer->makePatterns();
+}
 static
 void addVectorField(const char* filename, const char* vf_name,
 …
     //  Read and execute as many commands as we can from stdin...
+    Tcl_DString cmdbuffer;
+    Tcl_DStringInit(&cmdbuffer);
     int nCommands = 0;
     bool isComplete = false;
 …
     NvInitEventLog();
 #endif
-    Tcl_DStringInit(&NanoVis::cmdbuffer);
     NanoVis::interp = initTcl();
     NanoVis::resizeOffscreenBuffer(NanoVis::winWidth, NanoVis::winHeight);

branches/blt4/packages/vizservers/nanovis/nanovis.h

-                      r2936
+                      r2966
     static void displayOffscreenBuffer();
     static void display();
+    static void draw3dAxis();
     static void idle();
     static void update();
+    static void removeAllData();
     static void pan(float dx, float dy);
 …
     static void setVolumeRanges();
     static void setHeightmapRanges();
+#ifdef notdef
     static void initParticle();
+#endif
     static void ppmWrite(const char *prefix);
     static void sendDataToClient(const char *command, const char *data,
 …
     static int renderWindow;
     static unsigned char *screenBuffer;
+    static Texture2D *legendTexture;
     static Grid *grid;
     static R2Fonts *fonts;
 …
     static graphics::RenderContext *renderContext;
+    static Tcl_HashTable tfTable;
     static Tcl_HashTable volumeTable;
-    static std::vector<NvVectorField *> flow;
     static Tcl_HashTable flowTable;
+    static Tcl_HashTable heightmapTable;
     static double magMin, magMax;
     static float xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
+    static float xOrigin, yOrigin, zOrigin;
+    static NvColorTableRenderer *colorTableRenderer;
     static VolumeRenderer *volRenderer;
+#ifdef notdef
     static NvFlowVisRenderer *flowVisRenderer;
+#endif
     static VelocityArrowsSlice *velocityArrowsSlice;
     static NvLIC *licRenderer;
 …
 #endif
-    static Tcl_HashTable tfTable;
-    static Texture2D *legendTexture;
-    static NvColorTableRenderer *colorTableRenderer;
-    static std::vector<HeightMap *> heightMap;
-    static Tcl_HashTable heightmapTable;
     static Tcl_Interp *interp;
-    static Tcl_DString cmdbuffer;
 private:
+    static float _licSliceX;
+    static float _licSliceY;
+    static float _licSliceZ;
+    static int _licAxis;     /* 0:x, 1:y, 2:z */
+    static float _licSlice;  ///< Slice position [0,1]
+    static int _licAxis;     ///< Slice axis: 0:x, 1:y, 2:z
     //frame buffer for final rendering

branches/blt4/packages/vizservers/nanovis/protocol-nanovis.txt

-                      r2936
+                      r2966
   (followed by bytes)
+nv>data tag <dataobj-tag> min <val> max <val> vmin <val> vmax <val>
+   The min,max data values for the data object and the cumulative volume data
+   min,max over all volumes
 ================================================================================
 Error Replies:

branches/blt4/packages/vizservers/nanovis/shaders/update_pos.cg

-                      r2936
+                      r2966
     //reconstruct negative value
     float4 vel = float4(tex3D(vel_tex, pos.xyz).yzw, 0) - float4(0.5, 0.5, 0.5, 0.0f);
     vel = vel * (2 * max);
+    float4 vel = float4(tex3D(vel_tex, pos.xyz).yzw, 0.0) * 2.0 - float4(1.0, 1.0, 1.0, 0.0f);
+    vel = vel * max;
     //vel *= float4(scale, 1);
     ret = pos + (vel * timestep);

Context Navigation

Legend:

Download in other formats: