Changeset 3330

trunk/configure

-                      r3282
+                      r3330
 SIZEOF_INT
 SHLIB_LDFLAGS
+RUBY_VERSION_RV
+RUBY_PLATFORM
 RP_BASE
 PYTHON_VERSION
 …
 JAVA_HOME
 INSTALL_PREFIX
+HAVE_RUBY_DEVEL
 HAVE_INTTYPES_H
 HAVE_FFMPEG_LIBS
 …
 LDFLAGS_DEFAULT
 CFLAGS_DEFAULT
+host_os
+host_vendor
+host_cpu
+host
+build_os
+build_vendor
+build_cpu
+build
+HAVE_RUBY_H
+RUBY_SITELIBDIR
+RUBY_LIBRUBYARG_STATIC
+RUBY_LIBRUBYARG
+RUBY_LIBS
+RUBY_EXTRA_LIBS
+RUBY_SITE_PKG
 RUBY_LDFLAGS
-RUBY_CXXFLAGS
-RUBY_CFLAGS
 RUBY_CPPFLAGS
+RUBY_VERSION_CODE
+AWK
+RUBY_VERSION
+SED
 RUBY
+R
 …
 with_R
 with_ruby
-with_ruby_sitelibdir
 enable_shared
 enable_symbols
 …
   cat <<\_ACEOF
-System types:
-  --build=BUILD     configure for building on BUILD [guessed]
-  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 _ACEOF
 fi
 …
   --with-java=DIR         location of java [default=yes]
   --with-R=DIR            location of R interpreter [default=yes]
+  --with-ruby=PATH        path to the ruby interpreter [[ruby]]
+  --with-ruby-sitelibdir=PATH
+                          path to install ruby scripts [[auto-detect]]
+  --with-ruby=DIR         location of ruby [default=yes]
 Some influential environment variables:
 …
     for path in \
      $libdir \
+     $prefix/lib/tcltk \
      $prefix/lib \
      $exec_prefix/lib \
 …
    ${JAVA_HOME} \
    /apps/java/jdk1.6* \
+   /usr/lib/jvm/java-6-openjdk \
+   /usr/lib/jvm/icedtea-6 \
+   /usr/lib/jvm/*sun-1.6* \
    /opt/sun-jdk-1.6* \
+   /usr/lib/jvm/icedtea-7 \
    /opt/icedtea6-* \
    /opt/sun-jdk-1.5* \
+   /usr/lib/jvm/*sun* \
+   /usr/lib/jvm/*icedtea* \
+   /usr/lib/jvm/*openjdk*
+   /usr/lib/jvm/*sun-1.5*
   do
     if test -r "${d}/include/jni.h" ; then
 …
+# Make sure we can run config.sub.
+$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
+  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
+$as_echo_n "checking build system type... " >&6; }
+if ${ac_cv_build+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_build_alias=$build_alias
+test "x$ac_build_alias" = x &&
+  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
+test "x$ac_build_alias" = x &&
+  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
+ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
+  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
+$as_echo "$ac_cv_build" >&6; }
+case $ac_cv_build in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
+esac
+build=$ac_cv_build
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_build
+shift
+build_cpu=$1
+build_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+build_os=$*
+IFS=$ac_save_IFS
+case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
+$as_echo_n "checking host system type... " >&6; }
+if ${ac_cv_host+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "x$host_alias" = x; then
+  ac_cv_host=$ac_cv_build
+else
+  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
+    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
+$as_echo "$ac_cv_host" >&6; }
+case $ac_cv_host in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
+esac
+host=$ac_cv_host
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_host
+shift
+host_cpu=$1
+host_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+host_os=$*
+IFS=$ac_save_IFS
+case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+RUBY=""
+RUBY_DEV_PKG="no"
 # Check whether --with-ruby was given.
 if test "${with_ruby+set}" = set; then :
+  withval=$with_ruby;  RUBY=$withval
+else
+   RUBY=ruby
+fi
+# Check whether --with-ruby_sitelibdir was given.
+if test "${with_ruby_sitelibdir+set}" = set; then :
+  withval=$with_ruby_sitelibdir;  ruby_sitelibdir=$withval
+else
+   ruby_sitelibdir=NONE
+fi
+RUBY_VERSION_CODE=`$RUBY -e "puts RUBY_VERSION.gsub(/\./, '')"`
+RUBY_CONFIG_SO_NAME=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['RUBY_SO_NAME'] || '')"`
+RUBY_CONFIG_ARCHDIR=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['archdir'] || '')"`
+RUBY_CONFIG_ARCH=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['arch'] || '')"`
+RUBY_CONFIG_LIBDIR=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['libdir'] || '')"`
+RUBY_CONFIG_BINDIR=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['bindir'] || '')"`
+RUBY_CONFIG_RUBYHDRDIR=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['rubyhdrdir'] || '')"`
+RUBY_CONFIG_CFLAGS=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['CFLAGS'] || '')"`
+RUBY_CONFIG_LIBS=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['LIBS'] || '')"`
+RUBY_CONFIG_DLDLIBS=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['DLDLIBS'] || '')"`
+RUBY_CONFIG_LDFLAGS=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['LDFLAGS'] || '')"`
+RUBY_CONFIG_LIBRUBYARG=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['LIBRUBYARG'] || '')"`
+RUBY_CONFIG_LIBRUBYARG_STATIC=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['LIBRUBYARG_STATIC'] || '')"`
+RUBY_CONFIG_CCDLFLAGS=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['CCDLFLAGS'] || '')"`
+if test "x${RUBY_CONFIG_RUBYHDRDIR}x" != "xx"; then
+  # 1.9
+  RUBY_CPPFLAGS="-I${RUBY_CONFIG_RUBYHDRDIR}"
+  RUBY_CPPFLAGS="${RUBY_CPPFLAGS} -I${RUBY_CONFIG_RUBYHDRDIR}/${RUBY_CONFIG_ARCH}"
+else
+  # 1.8
+  RUBY_CPPFLAGS="-I${RUBY_CONFIG_ARCHDIR}"
+fi
+RUBY_CFLAGS="${RUBY_CONFIG_CFLAGS} ${RUBY_CONFIG_CCDLFLAGS}"
+RUBY_CXXFLAGS="${RUBY_CONFIG_CFLAGS} ${RUBY_CONFIG_CCDLFLAGS}"
+RUBY_LDFLAGS="-L${RUBY_CONFIG_ARCHDIR} -L${RUBY_CONFIG_LIBDIR} ${RUBY_CONFIG_LDFLAGS}"
+RUBY_LIBS="${RUBY_CONFIG_LIBS} ${RUBY_CONFIG_DLDLIBS}"
+RUBY_LIBRUBYARG="${RUBY_CONFIG_LIBRUBYARG}"
+RUBY_LIBRUBYARG_STATIC="${RUBY_CONFIG_LIBRUBYARG_STATIC}"
+if test "x${ruby_sitelibdir}x" != "xNONEx"
+then
+  RUBY_SITELIBDIR="${ruby_sitelibdir}"
+else
+  if test "x${prefix}x" = "xNONEx"
+  then
+    RUBY_SITELIBDIR=`
+          $RUBY -rrbconfig -e "puts(Config::CONFIG['sitelibdir'] || '')"`
+  withval=$with_ruby;
+else
+  with_ruby="yes"
+fi
+if test "${with_ruby}" != "no" ; then
+  if test "${with_ruby}" = "yes" ; then
+    # Extract the first word of "ruby", so it can be a program name with args.
+set dummy ruby; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_path_RUBY+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $RUBY in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_RUBY="$RUBY" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_path_RUBY="$as_dir/$ac_word$ac_exec_ext"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+  ;;
+esac
+fi
+RUBY=$ac_cv_path_RUBY
+if test -n "$RUBY"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUBY" >&5
+$as_echo "$RUBY" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
   else
+    sitelibdir_no_prefix=`$RUBY -rrbconfig \
+    -e "include Config; \
+    puts CONFIG['sitelibdir'].sub(CONFIG['prefix'], '')"`
+    RUBY_SITELIBDIR="${prefix}/${sitelibdir_no_prefix}"
+    # Extract the first word of "ruby", so it can be a program name with args.
+set dummy ruby; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_path_RUBY+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $RUBY in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_RUBY="$RUBY" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_dummy="${with_ruby}/bin:${with_ruby}"
+for as_dir in $as_dummy
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_path_RUBY="$as_dir/$ac_word$ac_exec_ext"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
   fi
+fi
+CPPFLAGS_save="${CPPFLAGS}"
+CPPFLAGS="${CPPFLAGS} ${RUBY_CPPFLAGS}"
+CXXFLAGS="${CPPFLAGS}"
+for ac_header in ruby.h
+do :
+  ac_fn_cxx_check_header_mongrel "$LINENO" "ruby.h" "ac_cv_header_ruby_h" "$ac_includes_default"
+if test "x$ac_cv_header_ruby_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_RUBY_H 1
+_ACEOF
+fi
+done
+HAVE_RUBY_H=${ac_cv_header_ruby_h}
+for ac_header in node.h
+do :
+  ac_fn_cxx_check_header_compile "$LINENO" "node.h" "ac_cv_header_node_h" "
+#include <ruby.h>
+"
+if test "x$ac_cv_header_node_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_NODE_H 1
+_ACEOF
+fi
+done
+for ac_header in ruby/node.h
+do :
+  ac_fn_cxx_check_header_compile "$LINENO" "ruby/node.h" "ac_cv_header_ruby_node_h" "
+                             #include <ruby.h>
+"
+if test "x$ac_cv_header_ruby_node_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_RUBY_NODE_H 1
+_ACEOF
+$as_echo "#define REALLY_HAVE_RUBY_NODE_H /**/" >>confdefs.h
+fi
+done
+for ac_header in version.h
+do :
+  ac_fn_cxx_check_header_compile "$LINENO" "version.h" "ac_cv_header_version_h" "
+#include <ruby.h>
+"
+if test "x$ac_cv_header_version_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_VERSION_H 1
+_ACEOF
+fi
+done
+for ac_header in env.h
+do :
+  ac_fn_cxx_check_header_compile "$LINENO" "env.h" "ac_cv_header_env_h" "
+#include <ruby.h>
+"
+if test "x$ac_cv_header_env_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_ENV_H 1
+_ACEOF
+fi
+done
+CPPFLAGS="${CPPFLAGS_save}"
+case $host_os in
+  *mingw32* ) MINGW32=yes;;
+          * ) MINGW32=no;;
+done
+  done
+IFS=$as_save_IFS
+  ;;
 esac
+if test x"${MINGW32}"x = xyesx; then
+RUBY_LIBS=`echo ${RUBY_LIBS} | sed -e "s%oldnames.lib%-lmoldname%"`
+RUBY_LIBS=`echo ${RUBY_LIBS} | sed -e "s%user32.lib%-luser32%"`
+RUBY_LIBS=`echo ${RUBY_LIBS} | sed -e "s%advapi32.lib%-ladvapi32%"`
+RUBY_LIBS=`echo ${RUBY_LIBS} | sed -e "s%ws2_32.lib%-lws2_32%"`
+RUBY_LIBRUBYARG=`echo ${RUBY_LIBRUBYARG} | sed -e "s%\(msvcrt-ruby.*\).lib%${RUBY_CONFIG_BINDIR}/\1.dll%"`
+RUBY_LIBRUBYARG_STATIC=`echo ${RUBY_LIBRUBYARG_STATIC} | sed -e "s%\(msvcrt-ruby.*\).lib%${RUBY_CONFIG_LIBDIR}/\1.lib%"`
+fi
+fi
+RUBY=$ac_cv_path_RUBY
+if test -n "$RUBY"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUBY" >&5
+$as_echo "$RUBY" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+  fi
+fi
+RUBY_VERSION_RV=
+RUBY_PLATFORM=
+if test "x${RUBY}" != "x" ; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+$as_echo_n "checking for a sed that does not truncate output... " >&6; }
+if ${ac_cv_path_SED+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+     for ac_i in 1 2 3 4 5 6 7; do
+       ac_script="$ac_script$as_nl$ac_script"
+     done
+     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
+     { ac_script=; unset ac_script;}
+     if test -z "$SED"; then
+  ac_path_SED_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_SED" || continue
+# Check for GNU ac_path_SED and select it if it is found.
+  # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in
+*GNU*)
+  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo '' >> "conftest.nl"
+    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_SED_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_SED="$ac_path_SED"
+      ac_path_SED_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+      $ac_path_SED_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_SED"; then
+    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
+  fi
+else
+  ac_cv_path_SED=$SED
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+$as_echo "$ac_cv_path_SED" >&6; }
+ SED="$ac_cv_path_SED"
+  rm -f conftest.sed
+    if test -n "$RUBY"; then :
+        ax_ruby_version=""
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ruby version" >&5
+$as_echo_n "checking for ruby version... " >&6; }
+        ruby_version=`$RUBY --version 2>&1 | $GREP "^ruby " | $SED -e 's/^.* \([0-9]*\.[0-9]*\.[0-9]*\) .*/\1/'`
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ruby_version" >&5
+$as_echo "$ruby_version" >&6; }
+        RUBY_VERSION=$ruby_version
+  for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AWK+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+  test -n "$AWK" && break
+done
+  # Used to indicate true or false condition
+  ax_compare_version=false
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+  ax_compare_version_A=`echo "$ax_ruby_version" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+  ax_compare_version_B=`echo "$ruby_version" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+    ax_compare_version=`echo "x$ax_compare_version_A
+x$ax_compare_version_B" | sed 's/^ *//' | sort | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
+    if test "$ax_compare_version" = "true" ; then
+            :
+    else
+            :
+  fi
+else
+        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: could not find the ruby interpreter" >&5
+$as_echo "$as_me: WARNING: could not find the ruby interpreter" >&2;}
+fi
+  RUBY_VERSION_RV=`echo ${RUBY_VERSION} | cut -d'.' -f1-2`
+  RUBY_PLATFORM=`ruby -e 'puts RUBY_PLATFORM'`
+  ac_mkmf_result=`${RUBY} -r mkmf -e ";" 2>&1`
+  if test -z "$ac_mkmf_result"; then
+    HAVE_RUBY_DEVEL="yes"
+    #
+    # Check for Ruby include path
+    #
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ruby include path" >&5
+$as_echo_n "checking for Ruby include path... " >&6; }
+    if test -z "$RUBY_CPPFLAGS"; then
+        ruby_path=`$RUBY -rmkmf -e 'print Config::CONFIG["archdir"]'`
+        if test -n "${ruby_path}"; then
+                ruby_path="-I$ruby_path"
+        fi
+        RUBY_CPPFLAGS=$ruby_path
+    fi
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUBY_CPPFLAGS" >&5
+$as_echo "$RUBY_CPPFLAGS" >&6; }
+    #
+    # Check for Ruby library path
+    #
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ruby library path" >&5
+$as_echo_n "checking for Ruby library path... " >&6; }
+    if test -z "$RUBY_LDFLAGS"; then
+        RUBY_LDFLAGS=`$RUBY -rmkmf -e 'print Config::CONFIG["LIBRUBYARG_SHARED"]'`
+    fi
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUBY_LDFLAGS" >&5
+$as_echo "$RUBY_LDFLAGS" >&6; }
+    #
+    # Check for site packages
+    #
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ruby site-packages path" >&5
+$as_echo_n "checking for Ruby site-packages path... " >&6; }
+    if test -z "$RUBY_SITE_PKG"; then
+        RUBY_SITE_PKG=`$RUBY -rmkmf -e 'print Config::CONFIG["sitearchdir"]'`
+    fi
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUBY_SITE_PKG" >&5
+$as_echo "$RUBY_SITE_PKG" >&6; }
+    #
+    # libraries which must be linked in when embedding
+    #
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking ruby extra libraries" >&5
+$as_echo_n "checking ruby extra libraries... " >&6; }
+    if test -z "$RUBY_EXTRA_LIBS"; then
+       RUBY_EXTRA_LIBS=`$RUBY -rmkmf -e 'print Config::CONFIG["SOLIBS"]'`
+    fi
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUBY_EXTRA_LIBS" >&5
+$as_echo "$RUBY_EXTRA_LIBS" >&6; }
+    #
+    # linking flags needed when embedding
+    # (is it even needed for Ruby?)
+    #
+    # AC_MSG_CHECKING(ruby extra linking flags)
+    # if test -z "$RUBY_EXTRA_LDFLAGS"; then
+    # RUBY_EXTRA_LDFLAGS=`$RUBY -rmkmf -e 'print Config::CONFIG[["LINKFORSHARED"]]'`
+    # fi
+    # AC_MSG_RESULT([$RUBY_EXTRA_LDFLAGS])
+    # AC_SUBST(RUBY_EXTRA_LDFLAGS)
+    # this flags breaks ruby.h, and is sometimes defined by KDE m4 macros
+    CFLAGS="`echo "$CFLAGS" | sed -e 's/-std=iso9899:1990//g;'`"
+    #
+    # final check to see if everything compiles alright
+    #
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking consistency of all components of ruby development environment" >&5
+$as_echo_n "checking consistency of all components of ruby development environment... " >&6; }
+    ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+    # save current global flags
+    ac_save_LIBS="$LIBS"
+    LIBS="$ac_save_LIBS $RUBY_LDFLAGS"
+    ac_save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$ac_save_CPPFLAGS $RUBY_CPPFLAGS"
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+        #include <ruby.h>
+int
+main ()
+{
+        ruby_init();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  rubyexists=yes
+else
+  rubyexists=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $rubyexists" >&5
+$as_echo "$rubyexists" >&6; }
+    if test "$rubyexists" = "no"; then
+      HAVE_RUBY_DEVEL="no"
+    fi
+    ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+    # turn back to default flags
+    CPPFLAGS="$ac_save_CPPFLAGS"
+    LIBS="$ac_save_LIBS"
+    #
+    # all done!
+    #
+  fi
+fi
 …
 MAKE=${make_command}
 …
 INSTALL='$INSTALL'
 MKDIR_P='$MKDIR_P'
+AWK='$AWK'
 test -n "\$AWK" || AWK=awk
 _ACEOF

trunk/configure.in

-                      r3277
+                      r3330
     for path in \
      $libdir \
+     $prefix/lib/tcltk \
      $prefix/lib \
      $exec_prefix/lib \
 …
 RP_LANG_JAVA
 RP_LANG_R
+RP_LANG_RUBY
+RUBY=""
+RUBY_DEV_PKG="no"
+AC_ARG_WITH(
+    [ruby],
+    [AS_HELP_STRING([--with-ruby=DIR], [location of ruby @<:@default=yes@:>@])],
+    [],
+    [with_ruby="yes"])
+if test "${with_ruby}" != "no" ; then
+  if test "${with_ruby}" = "yes" ; then
+    AC_PATH_PROG(RUBY, ruby)
+  else
+    AC_PATH_PROG(RUBY, ruby, [], [${with_ruby}/bin:${with_ruby}])
+  fi
+fi
+RUBY_VERSION_RV=
+RUBY_PLATFORM=
+if test "x${RUBY}" != "x" ; then
+  AX_PROG_RUBY_VERSION
+  RUBY_VERSION_RV=`echo ${RUBY_VERSION} | cut -d'.' -f1-2`
+  RUBY_PLATFORM=`ruby -e 'puts RUBY_PLATFORM'`
+  ac_mkmf_result=`${RUBY} -r mkmf -e ";" 2>&1`
+  if test -z "$ac_mkmf_result"; then
+    HAVE_RUBY_DEVEL="yes"
+    AX_RUBY_DEV_FLAGS([${RUBY}])
+  fi
+fi
 RP_BASE=`pwd`
 …
 AC_SUBST(HAVE_FFMPEG_LIBS)
 AC_SUBST(HAVE_INTTYPES_H)
+AC_SUBST(HAVE_RUBY_DEVEL)
 AC_SUBST(INSTALL_PREFIX)
 AC_SUBST(JAVA)
 …
 AC_SUBST(R)
 AC_SUBST(RP_BASE)
+AC_SUBST(RUBY)
+AC_SUBST(RUBY_PLATFORM)
+AC_SUBST(RUBY_VERSION_RV)
 AC_SUBST(SHLIB_CFLAGS)
 AC_SUBST(SHLIB_LD)

trunk/gui/apps/rappture.env.in

-                      r3177
+                      r3330
 PATH=${bindir}:$PATH
 LD_LIBRARY_PATH=${libdir}:${vtkdir}:$LD_LIBRARY_PATH
+LD_LIBRARY_PATH=${libdir}:$LD_LIBRARY_PATH
 # For MacOS X
 DYLD_LIBRARY_PATH=${libdir}:${vtkdir}:$DYLD_LIBRARY_PATH
+DYLD_LIBRARY_PATH=${libdir}:$DYLD_LIBRARY_PATH
 export PATH LD_LIBRARY_PATH DYLD_LIBRARY_PATH

trunk/gui/apps/rappture.use.in

-                      r2709
+                      r3330
 prepend PATH ${bindir}
-prepend LD_LIBRARY_PATH ${vtkdir}
 prepend LD_LIBRARY_PATH ${libdir}
-prepend DYLD_LIBRARY_PATH ${vtkdir}
 prepend DYLD_LIBRARY_PATH ${libdir}

trunk/gui/scripts/Makefile.in

-                      r3186
+                      r3330
                 $(srcdir)/grab.tcl \
                 $(srcdir)/groupentry.tcl \
-                $(srcdir)/heightmapviewer.tcl \
                 $(srcdir)/histogram.tcl \
                 $(srcdir)/histogramresult.tcl \
 …
                 $(srcdir)/scroller.tcl \
                 $(srcdir)/sequence.tcl \
+                $(srcdir)/sequencedial.tcl \
                 $(srcdir)/sequenceresult.tcl \
                 $(srcdir)/service.tcl \
 …
                 $(srcdir)/visviewer.tcl \
                 $(srcdir)/vtkviewer.tcl \
                 $(srcdir)/vtkcontourviewer.tcl \
+                $(srcdir)/vtkisosurfaceviewer.tcl \
                 $(srcdir)/vtkstreamlinesviewer.tcl \
                 $(srcdir)/vtkvolumeviewer.tcl \

trunk/gui/scripts/analyzer.tcl

-                      r3187
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: analyzer - output area for Rappture
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Analyzer::_isPdbTrajectory {data} {
     if { [llength $data]  == 0 } {
+    if { [llength $data] == 0 } {
         return 0
+    }
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Analyzer::_isLammpsTrajectory { data } {
     if { [llength $data]  == 0 } {
+    if { [llength $data] == 0 } {
         return 0
+    }

trunk/gui/scripts/animicon.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: animicon - an animated icon

trunk/gui/scripts/animover.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: animover - animated move

trunk/gui/scripts/balloon.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: Balloon - toplevel popup window, like a cartoon balloon

trunk/gui/scripts/barchartresult.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/booleanentry.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: BooleanEntry - widget for entering boolean values

trunk/gui/scripts/bugreport.tcl

r3188	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# UTILITY: bugreport

trunk/gui/scripts/choiceentry.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: ChoiceEntry - widget for entering a choice of strings

trunk/gui/scripts/cloud.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: cloud - represents the mesh for a cloud of points
 …
     public method points {}
     public method mesh {}
+    public method vtkdata {}
     public method size {}
     public method dimensions {}
     public method limits {which}
     public method hints {{key ""}}
+    public method numpoints {} {
+        return $_numPoints
+    }
     public proc fetch {xmlobj path}
     public proc release {obj}
 …
     private common _xp2obj       ;# used for fetch/release ref counting
     private common _obj2ref      ;# used for fetch/release ref counting
+    private variable _numPoints 0
+    private variable _vtkdata ""
+    private variable _vtkpoints ""
+    private variable _points ""
+    private variable _dim 0
+}
 …
+    }
     # create the vtk object containing points
     vtkPoints $this-points
+    set data [$xmlobj get $path.points]
+    Rappture::ReadPoints $data _dim values
     foreach lim {xmin xmax ymin ymax zmin zmax} {
         set _limits($lim) ""
+    }
+    set _numPoints 0
+    set _points {}
     foreach line [split [$xmlobj get $path.points] \n] {
         if {"" == [string trim $line]} {
 …
+            }
+        }
+        $this-points InsertNextPoint $x $y $z
+    }
+        append _points "$x $y $z\n"
+        incr _numPoints
+    }
+    if { $_dim == 3 } {
+        set _vtkpoints [vtkPoints $this-vtkpoints]
+        foreach { x y z } $_points {
+            $_vtkpoints InsertNextPoint $x $y $z
+        }
+    }
+    append out "DATASET POLYDATA\n"
+    append out "POINTS $_numPoints float\n"
+    append out $_points
+    set _vtkdata $out
+}
 …
     # don't destroy the _xmlobj! we don't own it!
     itcl::delete object $_cloud
-    rename $this-points ""
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Cloud::points {} {
     return $this-points
+    return $_points
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Cloud::mesh {} {
+    return $this-points
+    if { $_dim == 3 } {
+        return $_vtkpoints
+    }
+    return $_points
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Cloud::size {} {
     return [$this-points GetNumberOfPoints]
+    return $_numPOints
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Cloud::dimensions {} {
+    return $_dim
     # count the dimensions with real limits
     set dims 0
 …
     return [array get hints]
+}
+itcl::body Rappture::Cloud::vtkdata {} {
+    return $_vtkdata
+}

trunk/gui/scripts/color.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# UTILITY: color

trunk/gui/scripts/combobox.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/combochecks.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: combochecks - like a combobox, but items with checkboxes

trunk/gui/scripts/contourresult.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: contourresult - contour plot in a ResultSet
 …
                         return
+                    }
+puts stderr "ContourResult: dataobj=$dataobj mesh=$mesh "
                     switch -- [$mesh GetClassName] {
                       vtkPoints {

trunk/gui/scripts/controlOwner.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: owner - manages Rappture controls

trunk/gui/scripts/controls.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: controls - a container for various Rappture controls

trunk/gui/scripts/curve.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/datatable.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/datatableresult.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/deviceEditor.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: deviceEditor - general-purpose device editor

trunk/gui/scripts/deviceLayout1D.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: deviceLayout1D - visualizer for 1D device geometries

trunk/gui/scripts/deviceViewer1D.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: deviceViewer1D - visualizer for 1D device geometries

trunk/gui/scripts/deviceresult.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: DeviceResult - output for <structure>

trunk/gui/scripts/diffview.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# WIDGET: diffview - view differences between two strings

trunk/gui/scripts/dispatcher.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: dispatcher - central notification mechanism

trunk/gui/scripts/drawing-obsolete.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: drawingobsolete - 2D drawing of data

trunk/gui/scripts/drawing.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/drawingcontrols.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/drawingentry.tcl

r3182	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/dropdown.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: dropdown - base class for drop-down panels

trunk/gui/scripts/dropdownchecks.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: dropdownchecks - drop-down list of checkbox items

trunk/gui/scripts/dropdownlist.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: dropdownlist - drop-down list of items

trunk/gui/scripts/editor.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: editor - pop-up editor for little bits of text

trunk/gui/scripts/energyLevels.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: EnergyLevels - visualizer for discrete energy levels

trunk/gui/scripts/field.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 …
 package require BLT
+namespace eval Rappture { # forward declaration }
+namespace eval Rappture {
+    # forward declaration
+}
+#
+# Possible field dataset types:
+#
+# 2D Datasets
+#       vtk             (range of z-axis is zero).
+#       unirect2d       (deprecated except where extents > 1)
+#       cloud           (x,y point coordinates) (deprecated)
+#       mesh
+# 3D Datasets
+#       vtk
+#       unirect3d
+#       cloud           (x,y,z coordinates) (deprecated)
+#       mesh
+#       dx              (FIXME: make dx-to-vtk converter work)
+#       ucd avs
+#
+# Viewers:
+#       Format     Dim  Description                     Viewer          Server
+#       vtk         2   vtk file data.                  contour         vtkvis
+#       vtk         3   vtk file data.                  isosurface      vtkvis
+#       mesh        2   points-on-mesh                  heightmap       vtkvis
+#       mesh        3   points-on-mesh                  isosurface      vtkvis
+#       dx          3   DX                              volume          nanovis
+#       unirect2d   2   unirect3d + extents > 1 flow    flow            nanovis
+#       unirect3d   3   unirect2d + extents > 1 flow    flow            nanovis
+#
+# The goal should be any 3D dataset can view a isosurface, volume,
+# streamlines, or flow (if extents > 1).  Any 2D dataset can view a
+# contour, heightmap, streamlines, or flow (if extents > 1).
+#
+#
 itcl::class Rappture::Field {
+    constructor {xmlobj path} { # defined below }
+    destructor { # defined below }
+    private variable _dim       0;      # Dimension of the mesh
+    private variable _xmlobj ""  ;      # ref to XML obj with field data
+    private variable _limits     ;      # maps box name => {z0 z1} limits
+    private variable _field ""
+    private variable _fieldNames ""   ; # list of field names.
+    private variable _fieldUnits ""   ; # list of units of each field name.
+    private variable _fieldLabels ""  ; # list of labels of each field name.
+    private variable _viewer            ""
+    private variable _hints
+    constructor {xmlobj path} {
+        # defined below
+    }
+    destructor {
+        # defined below
+    }
     public method components {args}
     public method mesh {{what -overall}}
     public method values {{what -overall}}
     public method blob {{what -overall}}
+    public method mesh {{cname -overall}}
+    public method values {{cname -overall}}
+    public method blob {{cname -overall}}
     public method limits {axis}
     public method controls {option args}
 …
     public method isunirect2d {}
     public method isunirect3d {}
     public method extents {{what -overall}}
+    public method extents {{cname -overall}}
     public method flowhints { cname }
     public method type {}
+    public method vtkdata {{what -overall}}
+    protected method _build {}
+    public method viewer {} {
+        return $_viewer
+    }
+    public method vtkdata {cname}
+    protected method Build {}
     protected method _getValue {expr}
-    private variable _xmlobj ""  ;      # ref to XML obj with device data
     private variable _path "";          # Path of this object in the XML
     private variable _units ""   ;      # system of units for this field
-    private variable _limits     ;# maps box name => {z0 z1} limits
     private variable _zmax 0     ;# length of the device
-    private variable _field ""   ;# lib obj representing this field
     private variable _comp2dims  ;# maps component name => dimensionality
     private variable _comp2xy    ;# maps component name => x,y vectors
+    private variable _comp2vtk   ;# maps component name => vtkFloatArray
+    private variable _comp2vtkstreamlines   ;# maps component name => vtkFloatArray
+    private variable _comp2vtkcontour   ;# maps component name => vtkFloatArray
+    private variable _comp2vtkvolume   ;# maps component name => vtkFloatArray
+    private variable _comp2volume   ;# maps component name => vtkFloatArray
+    private variable _comp2vtk   ;# maps component name => vtk file data
     private variable _comp2dx    ;# maps component name => OpenDX data
     private variable _comp2unirect2d ;# maps component name => unirect2d obj
 …
     private variable _comp2cntls ;# maps component name => x,y control points
     private variable _comp2extents
     private variable _comp2limits
+    private variable _comp2limits;      #  Array of limits per component
     private variable _type ""
     private variable _comp2flowhints
+    private variable _comp2mesh
     private common _counter 0    ;# counter for unique vector names
+    private method BuildPointsOnMesh { cname }
     private method ConvertToVtkData { cname }
     private method ReadVtkDataSet { cname contents }
     private variable _fields {}
     private variable _isVtk
+    private method AvsToVtk { cname contents }
+    private variable _values ""
+}
 …
     # build up vectors for various components of the field
     _build
+    Build
+}
 …
         eval blt::vector destroy $_comp2xy($name)
+    }
-    foreach name [array names _comp2vtk] {
-        set mobj [lindex $_comp2vtk($name) 0]
-        set class [$mobj info class]
-        ${class}::release $mobj
-        set fobj [lindex $_comp2vtk($name) 1]
-        rename $fobj ""
+    }
     foreach name [array names _comp2unirect2d] {
         itcl::delete object $_comp2unirect2d($name)
 …
     foreach name [array names _comp2flowhints] {
         itcl::delete object $_comp2flowhints($name)
+    }
+    foreach name [array names _comp2mesh] {
+        # Data is in the form of a mesh and a vector.
+        foreach { mesh vector } $_comp2mesh($name) break
+        # Release the mesh (may be shared)
+        set class [$mesh info class]
+        ${class}::release $mesh
+        # Destroy the vector
+        blt::vector destroy $vector
+    }
+}
 …
 # overall field (sum of all components).
 # ----------------------------------------------------------------------
+itcl::body Rappture::Field::mesh {{what -overall}} {
+    if {$what == "-overall" || $what == "component0"} {
+        set what [lindex [components -name] 0]
+    }
+    if {[info exists _comp2xy($what)]} {
+        return [lindex $_comp2xy($what) 0]  ;# return xv
+    }
+    if { [info exists _comp2vtkstreamlines($what)] } {
+        error "mesh: not implemented for streamlines"
+itcl::body Rappture::Field::mesh {{cname -overall}} {
+    if {$cname == "-overall" || $cname == "component0"} {
+        set cname [lindex [components -name] 0]
+    }
+    if {[info exists _comp2xy($cname)]} {
+        return [lindex $_comp2xy($cname) 0]  ;# return xv
+    }
+    if { [info exists _comp2vtk($cname)] } {
+        # FIXME: extract mesh from VTK file data.
+        error "method \"mesh\" is not implemented for VTK file data"
+    }
+    if {[info exists _comp2dx($cname)]} {
+        return ""  ;# no mesh -- it's embedded in the value data
+    }
+    if {[info exists _comp2mesh($cname)]} {
+        return ""  ;# no mesh -- it's embedded in the value data
+    }
+    if {[info exists _comp2unirect2d($cname)]} {
+        set mobj [lindex $_comp2unirect2d($cname) 0]
         return [$mobj mesh]
+    }
+    if { [info exists _comp2vtkcontour($what)] } {
+        error "method \"mesh\" is not implemented for vtkcontour"
+    }
+    if { [info exists _comp2vtk($what)] } {
+        set mobj [lindex $_comp2vtk($what) 0]
+    if {[info exists _comp2unirect3d($cname)]} {
+        set mobj [lindex $_comp2unirect3d($cname) 0]
         return [$mobj mesh]
+    }
+    if {[info exists _comp2dx($what)]} {
+        return ""  ;# no mesh -- it's embedded in the value data
+    }
+    if {[info exists _comp2vtkvolume($what)]} {
+        return ""  ;# no mesh -- it's embedded in the value data
+    }
+    if {[info exists _comp2unirect2d($what)]} {
+        set mobj [lindex $_comp2unirect2d($what) 0]
+        return [$mobj mesh]
+    }
+    if {[info exists _comp2unirect3d($what)]} {
+        set mobj [lindex $_comp2unirect3d($what) 0]
+        return [$mobj mesh]
+    }
+    error "bad option \"$what\": should be [join [lsort [array names _comp2dims]] {, }]"
+    error "bad option \"$cname\": should be [join [lsort [array names _comp2dims]] {, }]"
+}
 …
 # overall field (sum of all components).
 # ----------------------------------------------------------------------
+itcl::body Rappture::Field::values {{what -overall}} {
+    if {$what == "component0"} {
+        set what "component"
+    }
+    if {[info exists _comp2xy($what)]} {
+        return [lindex $_comp2xy($what) 1]  ;# return yv
+    }
+    if { [info exists _comp2vtkcontour($what)] } {
+        error "method \"values\" is not implemented for vtkcontour"
+    }
+    if { [info exists _comp2vtkstreamlines($what)] } {
+        # FIXME: Need to process the vtk file data to pull out the field's
+        # values.
+        error "vtkstreamlines: values not implemented"
+        return [lindex $_comp2vtkstreamlines($what) 1]
+    }
+    if { [info exists _comp2vtk($what)] } {
+        return [lindex $_comp2vtk($what) 1]  ;# return vtkFloatArray
+    }
+    if {[info exists _comp2dx($what)]} {
+        return $_comp2dx($what)  ;# return gzipped, base64-encoded DX data
+    }
+    if {[info exists _comp2unirect2d($what)]} {
+        return [$_comp2unirect2d($what) values]
+    }
+    if {[info exists _comp2unirect3d($what)]} {
+        return [$_comp2unirect3d($what) blob]
+    }
+    error "bad option \"$what\": should be [join [lsort [array names _comp2dims]] {, }]"
+itcl::body Rappture::Field::values {{cname -overall}} {
+    if {$cname == "component0"} {
+        set cname "component"
+    }
+    if {[info exists _comp2xy($cname)]} {
+        return [lindex $_comp2xy($cname) 1]  ;# return yv
+    }
+    # VTK file data
+    if { [info exists _comp2vtk($cname)] } {
+        # FIXME: extract the values from the VTK file data
+        error "method \"values\" is not implemented for vtk file data"
+    }
+    # Points-on-mesh
+    if { [info exists _comp2mesh($cname)] } {
+        set vector [lindex $_comp2mesh($cname) 1]
+        return [$vector range 0 end]
+    }
+    if {[info exists _comp2dx($cname)]} {
+        return $_comp2dx($cname)  ;# return gzipped, base64-encoded DX data
+    }
+    if {[info exists _comp2unirect2d($cname)]} {
+        return [$_comp2unirect2d($cname) values]
+    }
+    if {[info exists _comp2unirect3d($cname)]} {
+        return [$_comp2unirect3d($cname) blob]
+    }
+    error "bad option \"$cname\": should be [join [lsort [array names _comp2dims]] {, }]"
+}
 …
 # Returns a string representing the blob of data for the mesh and values.
 # ----------------------------------------------------------------------
 itcl::body Rappture::Field::blob {{what -overall}} {
     if {$what == "component0"} {
         set what "component"
+    }
     if {[info exists _comp2xy($what)]} {
+itcl::body Rappture::Field::blob {{cname -overall}} {
+    if {$cname == "component0"} {
+        set cname "component"
+    }
+    if {[info exists _comp2xy($cname)]} {
         return ""
+    }
+    if { [info exists _comp2vtk($what)] } {
+        return ""
+    }
+    if { [info exists _comp2vtkvolume($what)] } {
+        return $_comp2vtkvolume($what)
+    }
+    if { [info exists _comp2vtkcontour($what)] } {
+        return $_comp2vtkcontour($what)
+    }
+    if { [info exists _comp2vtkstreamlines($what)] } {
+        # Return the contents of the vtk file.
+        return $_comp2vtkstreamlines($what)
+    }
+    if {[info exists _comp2dx($what)]} {
+        return $_comp2dx($what)  ;# return gzipped, base64-encoded DX data
+    }
+    if {[info exists _comp2unirect2d($what)]} {
+        return [$_comp2unirect2d($what) blob]
+    }
+    if {[info exists _comp2unirect3d($what)]} {
+        return [$_comp2unirect3d($what) blob]
+    }
+    error "bad option \"$what\": should be [join [lsort [array names _comp2dims]] {, }]"
+    if { [info exists _comp2vtk($cname)] } {
+        error "blob not implemented for VTK file data"
+    }
+    if {[info exists _comp2dx($cname)]} {
+        return $_comp2dx($cname)  ;# return gzipped, base64-encoded DX data
+    }
+    if {[info exists _comp2unirect2d($cname)]} {
+        return [$_comp2unirect2d($cname) blob]
+    }
+    if {[info exists _comp2unirect3d($cname)]} {
+        return [$_comp2unirect3d($cname) blob]
+    }
+    error "bad option \"$cname\": should be [join [lsort [array names _comp2dims]] {, }]"
+}
 …
     set min ""
     set max ""
     blt::vector tmp zero
+    foreach comp [array names _comp2dims] {
+        switch -- $_comp2dims($comp) {
+    foreach cname [array names _comp2dims] {
+        switch -- $_comp2dims($cname) {
 D {
                 switch -- $which {
+                    x - xlin { set pos 0; set log 0; set axis xaxis }
+                    xlog { set pos 0; set log 1; set axis xaxis }
+                    y - ylin - v - vlin { set pos 1; set log 0; set axis yaxis }
+                    ylog - vlog { set pos 1; set log 1; set axis yaxis }
+                    x - xlin {
+                        set pos 0; set log 0; set axis x
+                    }
+                    xlog {
+                        set pos 0; set log 1; set axis x
+                    }
+                    y - ylin - v - vlin {
+                        set pos 1; set log 0; set axis y
+                    }
+                    ylog - vlog {
+                        set pos 1; set log 1; set axis y
+                    }
                     default {
                         error "bad option \"$which\": should be x, xlin, xlog, y, ylin, ylog, v, vlin, vlog"
 …
+                }
                 set vname [lindex $_comp2xy($comp) $pos]
+                set vname [lindex $_comp2xy($cname) $pos]
                 $vname variable vec
 …
                     tmp expr {abs(tmp)}             ;# get the abs value
                     tmp expr {tmp + zero*max(tmp)}  ;# replace 0's with abs max
                     set vmin [blt::vector expr min(tmp)]
                     set vmax [blt::vector expr max(tmp)]
+                    set axisMin [blt::vector expr min(tmp)]
+                    set axisMax [blt::vector expr max(tmp)]
                 } else {
                     set vmin $vec(min)
                     set vmax $vec(max)
+                    set axisMin $vec(min)
+                    set axisMax $vec(max)
+                }
                 if {"" == $min} {
                     set min $vmin
                 } elseif {$vmin < $min} {
                     set min $vmin
+                    set min $axisMin
+                } elseif {$axisMin < $min} {
+                    set min $axisMin
+                }
                 if {"" == $max} {
                     set max $vmax
                 } elseif {$vmax > $max} {
                     set max $vmax
+                    set max $axisMax
+                } elseif {$axisMax > $max} {
+                    set max $axisMax
+                }
+            }
 D - 3D {
                 if {[info exists _comp2unirect2d($comp)]} {
                     set limits [$_comp2unirect2d($comp) limits $which]
                     foreach {vmin vmax} $limits break
                     set axis vaxis
                 } elseif {[info exists _comp2unirect3d($comp)]} {
                     set limits [$_comp2unirect3d($comp) limits $which]
                     foreach {vmin vmax} $limits break
                     set axis vaxis
                 } elseif {[info exists _comp2vtk($comp)]} {
+                    foreach {xv yv} $_comp2vtk($comp) break
                     switch -- $which {
+                if {[info exists _comp2unirect2d($cname)]} {
+                    set limits [$_comp2unirect2d($cname) limits $which]
+                    foreach {axisMin axisMax} $limits break
+                    set axis v
+                } elseif {[info exists _comp2unirect3d($cname)]} {
+                    set limits [$_comp2unirect3d($cname) limits $which]
+                    foreach {axisMin axisMax} $limits break
+                    set axis v
+                } elseif {[info exists _comp2limits($cname)]} {
+                    array set limits $_comp2limits($cname)
+                    switch -- $which {
                         x - xlin - xlog {
                             foreach {vmin vmax} [$xv limits x] break
+                            set axis xaxis
+                            set axis x
+                            foreach {axisMin axisMax} $limits(x) break
+                        }
                         y - ylin - ylog {
                             foreach {vmin vmax} [$xv limits y] break
+                            set axis yaxis
+                            set axis y
+                            foreach {axisMin axisMax} $limits(y) break
+                        }
                         z - zlin - zlog {
                             foreach {vmin vmax} [$xv limits z] break
+                            set axis zaxis
+                            set axis y
+                            foreach {axisMin axisMax} $limits(z) break
+                        }
                         v - vlin - vlog {
+                            catch {unset style}
+                            array set style $_comp2style($comp)
+                            if {[info exists style(-min)] && [info exists style(-max)]} {
+                                # This component has its own hard-coded
+                                # min/max range.  Ignore it for overall limits.
+                                set vmin $min
+                                set vmax $max
+                            } else {
+                                foreach {vmin vmax} [$yv GetRange] break
+                            }
+                            set axis vaxis
+                        }
+                        default {
+                            error "bad option \"$which\": should be x, xlin, xlog, y, ylin, ylog, v, vlin, vlog"
+                        }
+                    }
+                            set axis v
+                            foreach {axisMin axisMax} $limits(v) break
+                        }
+                        default {
+                            if { ![info exists limits($which)] } {
+                                error "limits: unknown axis \"$which\""
+                            }
+                            set axis v
+                            foreach {axisMin axisMax} $limits($which) break
+                        }
+                    }
                 } else {
                     set vmin 0  ;# HACK ALERT! must be OpenDX data
                     set vmax 1
                     set axis vaxis
+                    set axisMin 0  ;# HACK ALERT! must be OpenDX data
+                    set axisMax 1
+                    set axis v
+                }
+            }
+        }
+        if {"" == $min} {
+            set min $vmin
+        } elseif {$vmin < $min} {
+            set min $vmin
+        }
+        if {"" == $max} {
+            set max $vmax
+        } elseif {$vmax > $max} {
+            set max $vmax
+        if { "" == $min || $axisMin < $min } {
+            set min $axisMin
+        }
+        if { "" == $max || $axisMax > $max } {
+            set max $axisMax
+        }
+    }
     blt::vector destroy tmp zero
+    set val [$_field get $axis.min]
+    set val [$_field get "${axis}axis.min"]
     if {"" != $val && "" != $min} {
         if {$val > $min} {
 …
+        }
+    }
+    set val [$_field get $axis.max]
+    set val [$_field get "${axis}axis.max"]
     if {"" != $val && "" != $max} {
         if {$val < $max} {
 …
     switch -- $option {
         get {
             set what [lindex $args 0]
             if {[info exists _comp2cntls($what)]} {
                 return $_comp2cntls($what)
+            set cname [lindex $args 0]
+            if {[info exists _comp2cntls($cname)]} {
+                return $_comp2cntls($cname)
+            }
             return ""
 …
             set value [lindex $args 1]
             $_xmlobj put $path.current $value
             _build
+            Build
+        }
         default {
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Field::hints {{keyword ""}} {
+    foreach {key path} {
+        camera          camera.position
+        color           about.color
+        default         about.default
+        group           about.group
+        label           about.label
+        scalars         about.scalars
+        scale           about.scale
+        seeds           about.seeds
+        style           about.style
+        toolId          tool.id
+        toolName        tool.name
+        toolRevision    tool.version.application.revision
+        type            about.type
+        units           units
+        updir           updir
+        vectors         about.vectors
+    } {
+        set str [$_field get $path]
+        if {"" != $str} {
+            set hints($key) $str
+        }
+    }
+    # Set tool and path hints
+    set hints(tool) [$_xmlobj get tool.name]
+    set hints(path) $_path
+    if 0 {
+        # to be compatible with curve objects
+        set hints(xlabel) "Position"
+    }
+    if {[info exists hints(group)] && [info exists hints(label)]} {
+        # pop-up help for each curve
+        set hints(tooltip) $hints(label)
+    }
+    if {$keyword != ""} {
+        if {[info exists hints($keyword)]} {
+            return $hints($keyword)
+    if { ![info exists _hints] } {
+        set _hints(fieldnames)  $_fieldNames
+        set _hints(fieldunits)  $_fieldUnits
+        set _hints(fieldlabels) $_fieldLabels
+        foreach {key path} {
+            camera          camera.position
+            color           about.color
+            default         about.default
+            group           about.group
+            label           about.label
+            fieldnames      about.fieldnames
+            fieldunits      about.fieldunits
+            fieldlabels     about.fieldlabels
+            scale           about.scale
+            seeds           about.seeds
+            style           about.style
+            type            about.type
+            xlabel          about.xaxis.label
+            ylabel          about.yaxis.label
+            zlabel          about.zaxis.label
+            xunits          about.xaxis.units
+            yunits          about.yaxis.units
+            zunits          about.zaxis.units
+            units           units
+            updir           updir
+            vectors         about.vectors
+        } {
+            set str [$_field get $path]
+            if { "" != $str } {
+                set _hints($key) $str
+            }
+        }
+        foreach {key path} {
+            toolid          tool.id
+            toolname        tool.name
+            toolcommand     tool.execute
+            tooltitle       tool.title
+            toolrevision    tool.version.application.revision
+        } {
+            set str [$_xmlobj get $path]
+            if { "" != $str } {
+                set _hints($key) $str
+            }
+        }
+        # Set toolip and path hints
+        set _hints(path) $_path
+        if { [info exists _hints(group)] && [info exists _hints(label)] } {
+            # pop-up help for each curve
+            set _hints(tooltip) $_hints(label)
+        }
+    }
+    if { $keyword != "" } {
+        if {[info exists _hints($keyword)]} {
+            return $_hints($keyword)
+        }
         return ""
+    }
     return [array get hints]
+}
 # ----------------------------------------------------------------------
 # USAGE: _build
+    return [array get _hints]
+}
+# ----------------------------------------------------------------------
+# USAGE: Build
+#
 # Used internally to build up the vector representation for the
 …
 # from scratch.
 # ----------------------------------------------------------------------
+itcl::body Rappture::Field::_build {} {
+    # discard any existing data
+itcl::body Rappture::Field::Build {} {
+    # Discard any existing data
     foreach name [array names _comp2xy] {
         eval blt::vector destroy $_comp2xy($name)
+    }
+    foreach name [array names _comp2vtk] {
+        set mobj [lindex $_comp2vtk($name) 0]
+        set class [$mobj info class]
+        ${class}::release $mobj
+        set fobj [lindex $_comp2vtk($name) 1]
+        rename $fobj ""
+    }
+    array unset _comp2vtk
     foreach name [array names _comp2unirect2d] {
         eval itcl::delete object $_comp2unirect2d($name)
 …
+    }
     catch {unset _comp2xy}
-    catch {unset _comp2vtk}
     catch {unset _comp2dx}
     catch {unset _comp2dims}
     catch {unset _comp2style}
-    array unset _comp2volume
-    array unset _comp2vtkstreamlines
-    array unset _comp2vtkcontour
     array unset _comp2unirect2d
     array unset _comp2unirect3d
 …
         set type ""
         if { ([$_field element $cname.constant] != "" &&
             [$_field element $cname.domain] != "") ||
             [$_field element $cname.xy] != ""} {
+              [$_field element $cname.domain] != "") ||
+              [$_field element $cname.xy] != "" } {
             set type "1D"
         } elseif {[$_field element $cname.mesh] != "" &&
             [$_field element $cname.values] != ""} {
+        } elseif { [$_field element $cname.mesh] != "" &&
+                   [$_field element $cname.values] != ""} {
             set type "points-on-mesh"
+        } elseif {[$_field element $cname.vtk] != ""} {
+            set _isVtkData($cname) 1
+            if { [$_field get "about.view"] == "streamlines" } {
+                set type "vtkstreamlines"
+            } elseif { [$_field get "about.view"] == "contour" } {
+                set type "vtkcontour"
+            } else {
+                set type "vtk"
+            }
+        } elseif { [$_field element $cname.vtk] != ""} {
+            set viewer [$_field get "about.view"]
+            set type "vtk"
+            if { $viewer != "" } {
+                set _viewer $viewer
+            }
         } elseif {[$_field element $cname.opendx] != ""} {
             global env
 …
                 set type "dx"
+            }
+        }
+        }
         set _comp2style($cname) ""
 …
                 # sort x-coords in increasing order
                 $xv sort $yv
                 set _comp2dims($cname) "1D"
                 set _comp2xy($cname) [list $xv $yv]
 …
+            }
         } elseif {$type == "points-on-mesh"} {
+            #
+            # More complex 2D/3D data is represented by a mesh
+            # object and an associated vtkFloatArray for field
+            # values.
+            #
+            set path [$_field get $cname.mesh]
+            if {[$_xmlobj element $path] != ""} {
+                set element [$_xmlobj element -as type $path]
+                if { $element == "unirect2d" } {
+                    set _comp2dims($cname) "2D"
+                    set _comp2unirect2d($cname) \
+                        [Rappture::Unirect2d \#auto $_xmlobj $_field $cname \
+                             $extents]
+                    set _comp2style($cname) [$_field get $cname.style]
+                    if {[$_field element $cname.flow] != ""} {
+                        set _comp2flowhints($cname) \
+                            [Rappture::FlowHints ::\#auto $_field $cname $_units]
+                    }
+                    incr _counter
+                } elseif { $element == "unirect3d" } {
+                    set _comp2dims($cname) "3D"
+                    set _comp2unirect3d($cname) \
+                        [Rappture::Unirect3d \#auto $_xmlobj $_field $cname \
+                            $extents]
+                    set _comp2style($cname) [$_field get $cname.style]
+                    if {[$_field element $cname.flow] != ""} {
+                        set _comp2flowhints($cname) \
+                            [Rappture::FlowHints ::\#auto $_field $cname $_units]
+                    }
+                    incr _counter
+                } elseif { $element == "cloud" || $element == "mesh" } {
+                    switch -- $element {
+                        cloud {
+                            set mobj [Rappture::Cloud::fetch $_xmlobj $path]
+                        }
+                        mesh {
+                            set mobj [Rappture::Mesh::fetch $_xmlobj $path]
+                        }
+                    }
+                    if {[$mobj dimensions] > 1} {
+                        #
+                        # 2D/3D data
+                        # Store cloud/field as components
+                        #
+                        set values [$_field get $cname.values]
+                        set farray [vtkFloatArray ::vals$_counter]
+                        foreach v $values {
+                            if {"" != $_units} {
+                                set v [Rappture::Units::convert $v \
+                                   -context $_units -to $_units -units off]
+                            }
+                            $farray InsertNextValue $v
+                        }
+                        set _comp2dims($cname) "[$mobj dimensions]D"
+                        set _comp2vtk($cname) [list $mobj $farray]
+                        set _comp2style($cname) [$_field get $cname.style]
+                        incr _counter
+                    } else {
+                        #
+                        # OOPS!  This is 1D data
+                        # Forget the cloud/field -- store BLT vectors
+                        #
+                        set xv [blt::vector create x$_counter]
+                        set yv [blt::vector create y$_counter]
+                        set vtkpts [$mobj points]
+                        set max [$vtkpts GetNumberOfPoints]
+                        for {set i 0} {$i < $max} {incr i} {
+                            set xval [lindex [$vtkpts GetPoint $i] 0]
+                            $xv append $xval
+                        }
+                        set class [$mobj info class]
+                        ${class}::release $mobj
+                        set values [$_field get $cname.values]
+                        foreach yval $values {
+                            if {"" != $_units} {
+                                set yval [Rappture::Units::convert $yval \
+                                      -context $_units -to $_units -units off]
+                            }
+                            $yv append $yval
+                        }
+                        # sort x-coords in increasing order
+                        $xv sort $yv
+                        set _comp2dims($cname) "1D"
+                        set _comp2xy($cname) [list $xv $yv]
+                        incr _counter
+                    }
+                }
+            } else {
+                puts "WARNING: can't find mesh $path for field component"
+            }
+            BuildPointsOnMesh $cname
         } elseif {$type == "vtk"} {
+            #
-            # Extract native vtk data from the XML and use a reader
-            # to load it.
+            #
-            vtkRectilinearGridReader $this-gr
-            $this-gr SetInputString [$_field get $cname.vtk]
-            set _comp2dims($cname) "[$mobj dimensions]D"
-            set _comp2vtk($cname) [list $mobj $farray]
-            set _comp2style($cname) [$_field get $cname.style]
-            incr _counter
-        } elseif {$type == "vtkstreamlines"} {
-            set _comp2dims($cname) "3D"
-            # Allow redirects to another element.
             set vtkdata [$_field get $cname.vtk]
+            set _comp2vtkstreamlines($cname) $vtkdata
+            set _comp2style($cname) [$_field get $cname.style]
+            incr _counter
+        } elseif {$type == "vtkcontour"} {
+            set _comp2dims($cname) "2D"
+            # Allow redirects to another element.
+            set data [$_field get $cname.vtk]
+            ReadVtkDataSet $cname $data
+            set _comp2vtkcontour($cname) $data
+            set _comp2style($cname) [$_field get $cname.style]
+            incr _counter
+        } elseif {$type == "vtkvolume"} {
+            set _comp2dims($cname) "3D"
+            # Allow redirects to another element.
+            set data [$_field get -decode no $cname.dx]
+            set data [Rappture::encoding::decode -as zb64 $data]
+            if 1 {
+            set file "/tmp/$cname.dx"
+            set f [open $file "w"]
+            puts $f $data
+            close $f
+            }
+            set data [Rappture::ConvertDxToVtk $data]
+            if 1 {
+            set file "/tmp/$cname.vtk"
+            set f [open $file "w"]
+            puts $f $data
+            close $f
+            }
+            set _comp2vtkvolume($cname) $data
+            set _comp2style($cname) [$_field get $cname.style]
+            incr _counter
+        } elseif {$type == "vtkstreamlines2"} {
+            set _comp2dims($cname) "3D"
+            set _comp2vtkstreamlines($cname) [$_field get $cname.vtk]
+            ReadVtkDataSet $cname $vtkdata
+            set _comp2vtk($cname) $vtkdata
             set _comp2style($cname) [$_field get $cname.style]
             incr _counter
 …
             # off to the NanoVis visualizer.
+            #
+            set _viewer "nanovis"
             set _comp2dims($cname) "3D"
             set _comp2dx($cname)  [$_field get -decode no $cname.dx]
 …
             # off to the NanoVis visualizer.
+            #
+            set _viewer "nanovis"
             set _comp2dims($cname) "3D"
             set data [$_field get -decode yes $cname.opendx]
 …
+            }
             incr _counter
+        } elseif {[$_field element $cname.ucd] != ""} {
+            set _viewer "isosurface"
+            set _comp2dims($cname) "3D"
+            set contents [$_field get $cname.ucd]
+            set vtkdata [AvsToVtk $cname $contents]
+            ReadVtkDataSet $cname $vtkdata
+            set _comp2vtk($cname) $vtkdata
+            set _comp2style($cname) [$_field get $cname.style]
+            incr _counter
+        }
+    }
+    # Sanity check.  Verify that all components of the field have the same
+    # dimension.
+    set dim ""
+    foreach cname [array names _comp2dims] {
+        if { $dim == "" } {
+            set dim $_comp2dims($cname)
+            continue
+        }
+        if { $dim != $_comp2dims($cname) } {
+            error "field can't have components of different dimensions: [join [array get _comp2dims] ,]"
+        }
+    }
 …
 # Returns if the field is a unirect2d object.
+#
 itcl::body Rappture::Field::extents {{what -overall}} {
     if {$what == "-overall" } {
+itcl::body Rappture::Field::extents {{cname -overall}} {
+    if {$cname == "-overall" } {
         set max 0
         foreach cname [$_field children -type component] {
 …
         return $max
+    }
+    if { $what == "component0"} {
+        set what [lindex [components -name] 0]
+    }
+    return $_comp2extents($what)
+}
+# ----------------------------------------------------------------------
+# USAGE: blob ?<name>?
+#
+# Returns a string representing the blob of data for the mesh and values.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Field::vtkdata {{what -overall}} {
+    if {$what == "component0"} {
+        set what "component"
+    }
+    if {[info exists _comp2xy($what)]} {
+        return ""
+    }
+    if { [info exists _comp2vtk($what)] } {
+        return ""
+    }
+    if { [info exists _comp2vtkcontour($what)] } {
+        return $_comp2contour($what)
+    }
+    if { [info exists _comp2vtkstreamlines($what)] } {
+        return $_comp2vtkstreamlines($what)
+    }
+    if { [info exists _comp2vtkvolume($what)] } {
+        return $_comp2vtkvolume($what)
+    }
+    if {[info exists _comp2dx($what)]} {
+        return $_comp2dx($what)
+    }
+    if {[info exists _comp2unirect2d($what)]} {
+        return [$_comp2unirect2d($what) blob]
+    }
+    if {[info exists _comp2unirect3d($what)]} {
+        return [$_comp2unirect3d($what) blob]
+    }
+    error "bad option \"$what\": should be [join [lsort [array names _comp2dims]] {, }]"
+}
+itcl::body Rappture::Field::ConvertToVtkData { comp } {
+    if { $cname == "component0"} {
+        set cname [lindex [components -name] 0]
+    }
+    return $_comp2extents($cname)
+}
+itcl::body Rappture::Field::ConvertToVtkData { cname } {
     set ds ""
     switch -- [typeof $comp] {
+    switch -- [typeof $cname] {
         "unirect2d" {
             foreach { x1 x2 xN y1 y2 yN } [$dataobj mesh $comp] break
+            foreach { x1 x2 xN y1 y2 yN } [$dataobj mesh $cname] break
             set spacingX [expr {double($x2 - $x1)/double($xN - 1)}]
             set spacingY [expr {double($y2 - $y1)/double($yN - 1)}]
 …
             $ds SetSpacing $spacingX $spacingY 0
             set arr [vtkDoubleArray $this-arrTemp]
             foreach {val} [$dataobj values $comp] {
+            foreach {val} [$dataobj values $cname] {
                 $arr InsertNextValue $val
+            }
 …
+        }
         "unirect3d" {
             foreach { x1 x2 xN y1 y2 yN z1 z2 zN } [$dataobj mesh $comp] break
+            foreach { x1 x2 xN y1 y2 yN z1 z2 zN } [$dataobj mesh $cname] break
             set spacingX [expr {double($x2 - $x1)/double($xN - 1)}]
             set spacingY [expr {double($y2 - $y1)/double($yN - 1)}]
 …
             $ds SetSpacing $spacingX $spacingY $spacingZ
             set arr [vtkDoubleArray $this-arrTemp]
             foreach {val} [$dataobj values $comp] {
+            foreach {val} [$dataobj values $cname] {
                 $arr InsertNextValue $val
+            }
             [$ds GetPointData] SetScalars $val
+        }
         "vtkcontour" {
             return [$dataobj blob $comp]
+        "contour" {
+            return [$dataobj blob $cname]
+        }
         "dx" {
             return [Rappture::ConvertDxToVtk $_comp2dx($what)]
+            return [Rappture::ConvertDxToVtk $_comp2dx($cname)]
+        }
         default {
             set mesh [$dataobj mesh $comp]
+            set mesh [$dataobj mesh $cname]
             switch -- [$mesh GetClassName] {
                 vtkPoints {
 …
                     set ds [vtkPolyData $this-polydataTemp]
                     $ds SetPoints $mesh
                     [$ds GetPointData] SetScalars [$dataobj values $comp]
+                    [$ds GetPointData] SetScalars [$dataobj values $cname]
+                }
                 vtkPolyData {
                     set ds [vtkPolyData $this-polydataTemp]
                     $ds ShallowCopy $mesh
                     [$ds GetPointData] SetScalars [$dataobj values $comp]
+                    [$ds GetPointData] SetScalars [$dataobj values $cname]
+                }
                 vtkUnstructuredGrid {
 …
                     set ds [vtkUnstructuredGrid $this-grdataTemp]
                     $ds ShallowCopy $mesh
                     [$ds GetPointData] SetScalars [$dataobj values $comp]
+                    [$ds GetPointData] SetScalars [$dataobj values $cname]
+                }
                 vtkRectilinearGrid {
 …
                     set ds [vtkRectilinearGrid $this-grdataTemp]
                     $ds ShallowCopy $mesh
                     [$ds GetPointData] SetScalars [$dataobj values $comp]
+                    [$ds GetPointData] SetScalars [$dataobj values $cname]
+                }
                 default {
 …
+}
 itcl::body Rappture::Field::ReadVtkDataSet { comp contents } {
+itcl::body Rappture::Field::ReadVtkDataSet { cname contents } {
     package require vtk
 …
     set limits {}
     foreach {xmin xmax ymin ymax zmin zmax} [$dataset GetBounds] break
+    lappend limits xmin $xmin xmax $xmax ymin $ymin ymax $ymax
+    # Figure out the dimension of the mesh from the bounds.
+    set _dim 0
+    if { $xmax > $xmin } {
+        incr _dim
+    }
+    if { $ymax > $ymin } {
+        incr _dim
+    }
+    if { $zmax > $zmin } {
+        incr _dim
+    }
+    if { $_viewer == "" } {
+        if { $_dim == 2 } {
+            set _viewer contour
+        } else {
+            set _viewer isosurface
+        }
+    }
+    set _comp2dims($cname) ${_dim}D
+    lappend limits x [list $xmin $xmax]
+    lappend limits y [list $ymin $ymax]
+    lappend limits z [list $zmin $zmax]
     set dataAttrs [$dataset GetPointData]
     if { $dataAttrs == ""} {
         puts stderr "No point data"
+    }
+    for {set i 0} {$i < [$dataAttrs GetNumberOfArrays] } {incr i} {
+        set array [$dataAttrs GetArray $i]
+        set name  [$dataAttrs GetArrayName $i]
+        foreach {min max} [$array GetRange] break
+        lappend limits $name-min $min $name-max $max
+        lappend _fields $name
+    }
+    set _comp2limits($comp) $limits
+    puts stderr limits=$limits
+    set vmin 0
+    set vmax 1
+    set numArrays [$dataAttrs GetNumberOfArrays]
+    if { $numArrays > 0 } {
+        set array [$dataAttrs GetArray 0]
+        foreach {vmin vmax} [$array GetRange] break
+        for {set i 0} {$i < [$dataAttrs GetNumberOfArrays] } {incr i} {
+            set array [$dataAttrs GetArray $i]
+            set name  [$dataAttrs GetArrayName $i]
+            foreach {min max} [$array GetRange] break
+            lappend limits $name [list $min $max]
+            lappend _fieldNames $name
+            lappend _fieldUnits ""
+            lappend _fieldLabels $name
+        }
+    }
+    lappend limits v [list $vmin $vmax]
+    set _comp2limits($cname) $limits
     $reader Delete
     file delete $tmpfile
+}
+#
+# vtkdata --
+#
+#       Returns a string representing the mesh and field data for a specific
+#       component in the legacy VTK file format.
+#
+itcl::body Rappture::Field::vtkdata {cname} {
+    if {$cname == "component0"} {
+        set cname "component"
+    }
+    # DX: Convert DX to VTK
+    if {[info exists _comp2dx($cname)]} {
+        return [Rappture::ConvertDxToVtk $_comp2dx($cname)]
+    }
+    # Unirect3d: isosurface
+    if {[info exists _comp2unirect3d($cname)]} {
+        return [$_comp2unirect3d($cname) vtkdata]
+    }
+    # VTK file data:
+    if { [info exists _comp2vtk($cname)] } {
+        return $_comp2vtk($cname)
+    }
+    # Points on mesh:  Construct VTK file output.
+    if { [info exists _comp2mesh($cname)] } {
+        # Data is in the form mesh and vector
+        foreach {mesh vector} $_comp2mesh($cname) break
+        set label [hints zlabel]
+        if { $label == "" } {
+            set label $cname
+        } else {
+            regsub -all { } $label {_} label
+        }
+        append out "# vtk DataFile Version 3.0\n"
+        append out "[hints label]\n"
+        append out "ASCII\n"
+        append out [$mesh vtkdata]
+        append out "POINT_DATA [$vector length]\n"
+        append out "SCALARS $label float\n"
+        append out "LOOKUP_TABLE default\n"
+        append out "[$vector range 0 end]\n"
+        return $out
+    }
+    error "can't find vtkdata for $cname. This method should only be called by the vtkheightmap widget"
+}
+#
+# BuildPointsOnMesh --
+#
+#       Parses the field XML description to build a mesh and values vector
+#       representing the field.  Right now we handle the deprecated types
+#       of "cloud", "unirect2d", and "unirect3d" (mostly for flows).
+#
+itcl::body Rappture::Field::BuildPointsOnMesh {cname} {
+    #
+    # More complex 2D/3D data is represented by a mesh
+    # object and an associated vector for field values.
+    #
+    set path [$_field get $cname.mesh]
+    if {[$_xmlobj element $path] == ""} {
+        # Unknown mesh designated.
+        return
+    }
+    set element [$_xmlobj element -as type $path]
+    lappend _fieldNames $cname
+    lappend _fieldLabels $cname
+    lappend _fieldUnits ""
+    # Handle bizarre cases that hopefully will be deprecated.
+    if { $element == "unirect3d" } {
+        # Special case: unirect3d (should be deprecated) + flow.
+        if { [$_field element $cname.extents] != "" } {
+            set extents [$_field get $cname.extents]
+        } else {
+            set extents 1
+        }
+        set _dim 3
+        set _viewer flowvis
+        set _comp2dims($cname) "3D"
+        set _comp2unirect3d($cname) \
+            [Rappture::Unirect3d \#auto $_xmlobj $_field $cname $extents]
+        set _comp2style($cname) [$_field get $cname.style]
+        if {[$_field element $cname.flow] != ""} {
+            set _comp2flowhints($cname) \
+                [Rappture::FlowHints ::\#auto $_field $cname $_units]
+        }
+        incr _counter
+        return
+    }
+    if { $element == "unirect2d" && [$_field element $cname.flow] != "" } {
+        # Special case: unirect2d (normally deprecated) + flow.
+        if { [$_field element $cname.extents] != "" } {
+            set extents [$_field get $cname.extents]
+        } else {
+            set extents 1
+        }
+        set _dim 2
+        set _viewer "flowvis"
+        set _comp2dims($cname) "2D"
+        set _comp2unirect2d($cname) \
+            [Rappture::Unirect2d \#auto $_xmlobj $path]
+        set _comp2style($cname) [$_field get $cname.style]
+        set _comp2flowhints($cname) \
+            [Rappture::FlowHints ::\#auto $_field $cname $_units]
+        set _values [$_field element $cname.values]
+        incr _counter
+        return
+    }
+    set _viewer "contour"
+    switch -- $element {
+        "cloud" {
+            set mesh [Rappture::Cloud::fetch $_xmlobj $path]
+        }
+        "mesh" {
+            set mesh [Rappture::Mesh::fetch $_xmlobj $path]
+        }
+        "unirect2d" {
+            set mesh [Rappture::Unirect2d::fetch $_xmlobj $path]
+            set _viewer "heightmap"
+        }
+    }
+    set _dim [$mesh dimensions]
+    if {$_dim == 1} {
+        # Is this used anywhere?
+        #
+        # OOPS!  This is 1D data
+        # Forget the cloud/field -- store BLT vectors
+        #
+        # Is there a natural growth path in generating output from 1D to
+        # higher dimensions?  If there isn't, let's kill this in favor
+        # or explicitly using a <curve> instead.  Otherwise, the features
+        # (methods such as xmarkers) or the <curve> need to be added
+        # to the <field>.
+        #
+        set xv [blt::vector create x$_counter]
+        set yv [blt::vector create y$_counter]
+        $yv set [$mesh points]
+        $xv seq 0 1 [$yv length]
+        # sort x-coords in increasing order
+        $xv sort $yv
+        set _comp2dims($cname) "1D"
+        set _comp2xy($cname) [list $xv $yv]
+        incr _counter
+        return
+    } elseif {$_dim == 2} {
+        set _type "heightmap"
+        set vector [blt::vector create \#auto]
+        $vector set [$_field get $cname.values]
+        set _comp2dims($cname) "[$mesh dimensions]D"
+        set _comp2mesh($cname) [list $mesh $vector]
+        set _comp2style($cname) [$_field get $cname.style]
+        incr _counter
+        set label [hints zlabel]
+        if { $label != "" } {
+            set _fieldLabels $label
+            set _fieldNames $label
+            regsub -all { } $_fieldNames {_} _fieldNames
+        }
+        set units [hints zunits]
+        if { $units != "" } {
+            set _fieldUnits $units
+        }
+        array unset _comp2limits $cname
+        lappend _comp2limits($cname) x [$mesh limits x]
+        lappend _comp2limits($cname) y [$mesh limits y]
+        lappend _comp2limits($cname) $label [$vector limits]
+        lappend _comp2limits($cname) v [$vector limits]
+        return
+    } elseif {$_dim == 3} {
+        #
+        # 3D data: Store cloud/field as components
+        #
+        set values [$_field get $cname.values]
+        set farray [vtkFloatArray ::vals$_counter]
+        foreach v $values {
+            if {"" != $_units} {
+                set v [Rappture::Units::convert $v \
+                           -context $_units -to $_units -units off]
+            }
+            $farray InsertNextValue $v
+        }
+        set _viewer "isosurface"
+        set _type "isosurface"
+        set vector [blt::vector create \#auto]
+        $vector set [$_field get $cname.values]
+        set _comp2dims($cname) "[$mesh dimensions]D"
+        set _comp2mesh($cname) [list $mesh $vector]
+        set _comp2style($cname) [$_field get $cname.style]
+        incr _counter
+        set label [hints zlabel]
+        if { $label != "" } {
+            set _fieldNames $label
+            regsub -all { } $_fieldNames {_} _fieldNames
+            set _fieldLabels $label
+        }
+        set units [hints zunits]
+        if { $units != "" } {
+            set _fieldUnits $units
+        }
+        lappend _comp2limits($cname) x [$mesh limits x]
+        lappend _comp2limits($cname) y [$mesh limits y]
+        lappend _comp2limits($cname) z [$mesh limits z]
+        lappend _comp2limits($cname) $label [$vector limits]
+        lappend _comp2limits($cname) v [$vector limits]
+        return
+    }
+    error "unhandled case in field"
+}
+itcl::body Rappture::Field::AvsToVtk { comp contents } {
+    package require vtk
+    set reader $this-datasetreader
+    vtkAVSucdReader $reader
+    # Write the contents to a file just in case it's binary.
+    set tmpfile file[pid].vtk
+    set f [open "$tmpfile" "w"]
+    fconfigure $f -translation binary -encoding binary
+    puts $f $contents
+    close $f
+    $reader SetFileName $tmpfile
+    $reader Update
+    file delete $tmpfile
+    set output [$reader GetOutput]
+    set pointData [$output GetPointData]
+    set _scalars {}
+    for { set i 0 } { $i < [$pointData GetNumberOfArrays] } { incr i } {
+        set name [$pointData GetArrayName $i]
+        lappend _scalars $name $name "???"
+    }
+    set writer $this-datasetwriter
+    vtkDataSetWriter $writer
+    $writer SetInputConnection [$reader GetOutputPort]
+    $writer SetFileName $tmpfile
+    $writer Write
+    rename $reader ""
+    rename $writer ""
+    set f [open "$tmpfile" "r"]
+    fconfigure $f -translation binary -encoding binary
+    set vtkdata [read $f]
+    close $f
+    file delete $tmpfile
+    return $vtkdata
+}

trunk/gui/scripts/field2dresult.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: field2dresult - plot a field in a ResultSet
 …
 option add *Field2DResult.controlBackground gray widgetDefault
 option add *Field2DResult.controlDarkBackground #999999 widgetDefault
 option add *Field2DResult.plotBackground black widgetDefault
 option add *Field2DResult.plotForeground white widgetDefault
+option add *Field2DResult.plotBackground white widgetDefault
+option add *Field2DResult.plotForeground black widgetDefault
 option add *Field2DResult.font \
     -*-helvetica-medium-r-normal-*-12-* widgetDefault
 …
     itk_option define -mode mode Mode "auto"
+    constructor {args} { # defined below }
+    destructor { # defined below }
+    constructor {args} {
+        # defined below
+    }
+    destructor {
+        # defined below
+    }
     public method add {dataobj {settings ""}}
 …
     public method scale {args}
     public method snap {w h}
+    public method parameters {title args} { # do nothing }
+    public method parameters {title args} {
+        # do nothing
+    }
     public method download {option args}
+}
 …
     set servers ""
     switch -- $flags(-mode) {
         "auto" - "heightmap" - "flowvis" {
+        "flowvis" {
             set servers [Rappture::VisViewer::GetServerList "nanovis"]
+        }
         "vtkcontour" - "vtkheightmap" - "vtkstreamlines" - "vtkviewer" {
+        "auto" - "contour" - "heightmap" - "streamlines" - "vtkviewer" {
             set servers [Rappture::VisViewer::GetServerList "vtkvis"]
+        }
 …
     if {"" != $servers && $flags(-mode) != "vtk"} {
         switch -- $flags(-mode) {
             "auto" - "heightmap" {
+            "contour" - "heightmap" {
                 itk_component add renderer {
+                    Rappture::HeightmapViewer $itk_interior.ren $servers
+                    Rappture::VtkHeightmapViewer $itk_interior.heightmap \
+                        $servers -mode $flags(-mode)
+                }
+            }
             "flowvis" {
                 itk_component add renderer {
                     Rappture::FlowvisViewer $itk_interior.ren $servers
+                    Rappture::FlowvisViewer $itk_interior.flow $servers
+                }
+            }
             "vtkcontour" {
+            "streamlines" {
                 itk_component add renderer {
+                    Rappture::VtkContourViewer $itk_interior.ren $servers
+                }
+            }
+            "vtkheightmap" {
+                itk_component add renderer {
+                    Rappture::VtkHeightmapViewer $itk_interior.ren $servers
+                }
+            }
+            "vtkstreamlines" {
+                itk_component add renderer {
+                    Rappture::VtkStreamlinesViewer $itk_interior.ren $servers
+                    Rappture::VtkStreamlinesViewer $itk_interior.streamlines \
+                        $servers
+                }
+            }
             "vtkviewer" {
                 itk_component add renderer {
                     Rappture::VtkViewer $itk_interior.ren $servers
+                    Rappture::VtkViewer $itk_interior.viewer $servers
+                }
+            }
 …
+        }
+    }
     if {![info exists itk_component(renderer)]} {
         itk_component add renderer {
             Rappture::ContourResult $itk_interior.ren
+            Rappture::ContourResult $itk_interior.oldcontour
+        }
         pack $itk_component(renderer) -expand yes -fill both
+    }
     eval itk_initialize $args
+    update
+}

trunk/gui/scripts/field3dresult.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: field3dresult - plot a field in a ResultSet
 …
         -mode auto
+    }
     array set flags $args
     switch -- $flags(-mode) {
+    array set flags $args
+   switch -- $flags(-mode) {
         "auto" - "nanovis" - "flowvis" {
             set servers [Rappture::VisViewer::GetServerList "nanovis"]
+        }
         "vtkcontour" - "vtkheightmap" - "vtkstreamlines" - "vtkviewer" - "vtkvolume" {
+        "isosurface" - "heightmap" - "streamlines" - "vtkviewer" - "vtkvolume" {
             set servers [Rappture::VisViewer::GetServerList "vtkvis"]
+        }
 …
+                }
+            }
+            "vtkcontour" {
+                itk_component add renderer {
+                    Rappture::VtkContourViewer $itk_interior.ren $servers
+                }
+            }
+            "vtkheightmap" {
+            "contour" - "heightmap" {
                 itk_component add renderer {
                     Rappture::VtkHeightmapViewer $itk_interior.ren $servers
+                }
+            }
+            "vtkstreamlines" {
+            "isosurface" {
+                itk_component add renderer {
+                    Rappture::VtkIsosurfaceViewer $itk_interior.ren $servers
+                }
+            }
+            "streamlines" {
                 itk_component add renderer {
                     Rappture::VtkStreamlinesViewer $itk_interior.ren $servers
 …
         pack $itk_component(renderer) -expand yes -fill both
+    }
     eval itk_initialize $args
+}

trunk/gui/scripts/filexfer.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: filexfer - support for file transfer with user's desktop

trunk/gui/scripts/flowdial.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: Flowdial - selector, like the dial on a flow

trunk/gui/scripts/flowhints.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/flowspeed.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/flowvisviewer.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: flowvisviewer - 3D flow rendering

trunk/gui/scripts/gauge.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: gauge - compact readout for real values

trunk/gui/scripts/getopts.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/grab.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: grab - improved version of the Tk grab command

trunk/gui/scripts/groupentry.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: GroupEntry - widget containing a group of controls

trunk/gui/scripts/histogram.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/histogramresult.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/htmlviewer.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: htmlviewer - easy way to display HTML text

trunk/gui/scripts/icons.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: icons - utility for loading icons from a library

trunk/gui/scripts/image.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: image - represents a picture image

trunk/gui/scripts/imageentry.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: ImageEntry - widget for displaying images

trunk/gui/scripts/imageresult.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: imageresult - picture image in a ResultSet

trunk/gui/scripts/integerentry.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: IntegerEntry - widget for entering integer values

trunk/gui/scripts/isomarker.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/loader.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: loader - widget for loading examples and old runs

trunk/gui/scripts/logger.tcl

r3187	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: logger - log user activities within the Rappture program

trunk/gui/scripts/main.tcl

r3187	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	#!/bin/sh
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/mainwin.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: mainwin - main application window for Rappture

trunk/gui/scripts/mesh.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: mesh - represents a structured mesh for a device
 …
 package require Itcl
+namespace eval Rappture { # forward declaration }
+namespace eval Rappture {
+    # forward declaration
+}
 itcl::class Rappture::Mesh {
+    constructor {xmlobj path} { # defined below }
+    destructor { # defined below }
+    private variable _xmlobj ""  ;      # Ref to XML obj with device data
+    private variable _mesh ""    ;      # Lib obj representing this mesh
+    private variable _dim       0;      # Dimension of mesh (1, 2, or 3)
+    private variable _type "";          # Indicates the type of mesh.
+    private variable _units "m m m" ;   # System of units for x, y, z
+    private variable _limits        ;   # Array of mesh limits. Keys are
+                                        # xmin, xmax, ymin, ymax, ...
+    private variable _numPoints 0   ;   # # of points in mesh
+    private variable _numCells 0   ;    # # of cells in mesh
+    private variable _vtkdata "";       # Mesh in vtk file format.
+    constructor {xmlobj path} {
+        # defined below
+    }
+    destructor {
+        # defined below
+    }
     public method points {}
     public method elements {}
     public method mesh {}
+    public method mesh {{-type "vtk"}}
     public method size {{what -points}}
     public method dimensions {}
 …
     public proc fetch {xmlobj path}
     public proc release {obj}
+    private method _buildNodesElements {xmlobj path}
+    private method _buildRectMesh {xmlobj path}
+    private method _getVtkElement {npts}
+    private variable _xmlobj ""  ;# ref to XML obj with device data
+    private variable _mesh ""    ;# lib obj representing this mesh
+    private variable _pts2elem   ;# maps # points => vtk element
+    private variable _units "m m m" ;# system of units for x, y, z
+    private variable _limits        ;# limits xmin, xmax, ymin, ymax, ...
+    private variable _pdata ""      ;# name of vtkPointData object
+    private variable _gdata ""      ;# name of vtkDataSet object
+    private common _xp2obj       ;# used for fetch/release ref counting
+    private common _obj2ref      ;# used for fetch/release ref counting
+    public method vtkdata {}
+    public method type {} {
+        return $_type
+    }
+    public method numpoints {} {
+        return $_numPoints
+    }
+    private method ReadNodesElements {xmlobj path}
+    private variable _points ""      ;  # name of vtkPointData object
+    private common _xp2obj       ;      # used for fetch/release ref counting
+    private common _obj2ref      ;      # used for fetch/release ref counting
+    private variable _isValid 0
+    private variable _vtkoutput ""
+    private variable _vtkreader ""
+    private variable _vtkpoints ""
+    private variable _vtkgrid   ""
+    private variable _xv        ""
+    private variable _yv        ""
+    private variable _zv        ""
+    private variable _xCoords   "";     # For the blt contour only
+    private variable _yCoords   "";     # For the blt contour only
+    private method GetDimension {}
+    private method GetDouble { path }
+    private method GetInt { path }
+    private method ReadCells { xmlobj path }
+    private method ReadCloud { xmlobj path }
+    private method ReadGrid { xmlobj path }
+    private method ReadTriangles { xmlobj path }
+    private method ReadVtk { xmlobj path }
+    private method ReadUnstructuredGrid { xmlobj path }
+}
 …
         return $obj
+    }
     set obj [Rappture::Mesh ::#auto $xmlobj $path]
     set _xp2obj($handle) $obj
 …
     set _mesh [$xmlobj element -as object $path]
+    # Initialize mesh bounds to empty
+    foreach axis {x y z} {
+        set _limits($axis) ""
+    }
+    GetDimension
     set u [$_mesh get units]
     if {"" != $u} {
 …
+    }
+    foreach lim {xmin xmax ymin ymax zmin zmax} {
+        set _limits($lim) ""
+    }
+    if {[$_mesh element vtk] != ""} {
+        _buildRectMesh $xmlobj $path
+    } elseif {[$_mesh element node] != "" && [$_mesh element element] != ""} {
+        _buildNodesElements $xmlobj $path
+    } else {
+        error "can't find mesh data in $path"
+    # Meshes comes in a variety of flavors
+    #
+    # Dimensionality is determined from the <dimension> tag.
+    #
+    # <vtk> described mesh
+    # <element> +  <node> definitions
+    # <cloud>           x,y coordinates or x,y,z coordinates
+    # <grid>            rectangular mesh
+    # <triangles>       triangular mesh
+    # <cells>           homogeneous cell type mesh.
+    # <unstructured_grid> homogeneous cell type mesh.
+    #
+    # Check that only one mesh type was defined.
+    set subcount 0
+    foreach cname [$_mesh children] {
+        foreach type { vtk cloud grid triangles cells unstructured_grid} {
+            if { $cname == $type } {
+                incr subcount
+                break
+            }
+        }
+    }
+    set elemcount 0
+    foreach cname [$_mesh children] {
+        foreach type { node element } {
+            if { $cname == $type } {
+                incr elemcount
+                break
+            }
+        }
+    }
+    if { $elemcount > 0 } {
+        incr $subcount
+    }
+    if { $subcount > 1 } {
+        puts stderr "too many mesh types specified: picking first found."
+    }
+    if { [$_mesh element "vtk"] != ""} {
+        ReadVtk $xmlobj $path
+    } elseif { [$_mesh element "cloud"] != "" } {
+        ReadCloud $xmlobj $path
+    } elseif {[$_mesh element "grid"] != "" } {
+        ReadGrid $xmlobj $path
+    } elseif {[$_mesh element "triangles"] != "" } {
+        ReadTriangles $xmlobj $path
+    } elseif {[$_mesh element "cells"] != "" } {
+        ReadCells $xmlobj $path
+    } elseif {[$_mesh element "unstructured_grid"] != "" } {
+        ReadUnstructuredGrid $xmlobj $path
+    } elseif {[$_mesh element "node"] != "" && [$_mesh element "element"]!=""} {
+        ReadNodesElements $xmlobj $path
+    }
+}
 …
     itcl::delete object $_mesh
+    catch {rename $this-points ""}
+    catch {rename $this-grid ""}
+    catch {rename $this-dset ""}
+    foreach type [array names _pts2elem] {
+        rename $_pts2elem($type) ""
+    }
+    if { $_xCoords != "" } {
+        blt::vector destroy $_xCoords
+    }
+    if { $_yCoords != "" } {
+        blt::vector destroy $_yCoords
+    }
+    if { $_vtkoutput != "" } {
+        rename $_vtkoutput ""
+    }
+    if { $_vtkreader != "" } {
+        rename $_vtkreader ""
+    }
+    if { $_points != "" } {
+        rename $_points ""
+    }
+}
+#
+# vtkdata --
+#
+#       This is called by the field object to generate a VTK file to send to
+#       the remote render server.  Returns the vtkDataSet object containing
+#       (at this point) just the mesh.  The field object doesn't know (or
+#       care) what type of mesh is used.  The field object will add field
+#       arrays before generating output to send to the remote render server.
+#
+itcl::body Rappture::Mesh::vtkdata {} {
+    return $_vtkdata
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Mesh::points {} {
     return $_pdata
+    return $_points
+}
 …
 # Returns the vtk object representing the mesh.
 # ----------------------------------------------------------------------
+itcl::body Rappture::Mesh::mesh {} {
+    return $_gdata
+itcl::body Rappture::Mesh::mesh { {type "vtk"} } {
+    switch $type {
+        "vtk" {
+            return $_vtkgrid
+        }
+        default {
+            error "Requested mesh type \"$type\" is unknown."
+        }
+    }
+}
 …
     switch -- $what {
         -points {
             return [$_pdata GetNumberOfPoints]
+            return $_numPoints
+        }
         -elements {
             return [$_gdata GetNumberOfCells]
+            return $_numCells
+        }
         default {
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Mesh::dimensions {} {
+    # count the dimensions with real limits
+    set dims 0
+    foreach d {x y z} {
+        if {$_limits(${d}min) != $_limits(${d}max)} {
+            incr dims
+        }
+    }
+    return $dims
+    return $_dim
+}
 …
 # USAGE: limits x|y|z
+#
 # Returns the {min max} values for the limits of the specified axis.
 # ----------------------------------------------------------------------
 itcl::body Rappture::Mesh::limits {which} {
     if {![info exists _limits(${which}min)]} {
+# Returns the {min max} coords for the limits of the specified axis.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Mesh::limits {axis} {
+    if {![info exists _limits($axis)]} {
         error "bad axis \"$which\": should be x, y, z"
+    }
     return [list $_limits(${which}min) $_limits(${which}max)]
+    return $_limits($axis)
+}
 …
+}
+# ----------------------------------------------------------------------
+# USAGE: _buildNodesElements <xmlobj> <path>
+itcl::body Rappture::Mesh::GetDimension {} {
+    set string [$_xmlobj get dimension]
+    if { [scan $string "%d" _dim] != 1 } {
+        set _dim -1
+        return
+    }
+    if { $_dim < 1 || $_dim > 4 } {
+        error "bad dimension in mesh"
+    }
+}
+itcl::body Rappture::Mesh::GetDouble { path } {
+    set string [$_xmlobj get $path]
+    if { [scan $string "%g" value] != 1 } {
+        puts stderr "can't get double value \"$string\" of \"$path\""
+        return 0.0
+    }
+    return $value
+}
+itcl::body Rappture::Mesh::GetInt { path } {
+    set string [$_xmlobj get $path]
+    if { [scan $string "%d" value] != 1 } {
+        puts stderr "can't get integer value \"$string\" of \"$path\""
+        return 0.0
+    }
+    return $value
+}
+itcl::body Rappture::Mesh::ReadCloud { xmlobj path } {
+    set _type "cloud"
+    set data [$xmlobj get $path.cloud.points]
+    Rappture::ReadPoints $data _dim coords
+    set all [blt::vector create \#auto]
+    $all set $coords
+    set xv [blt::vector create \#auto]
+    set yv [blt::vector create \#auto]
+    set zv [blt::vector create \#auto]
+    if { $_dim == 2 } {
+        $all split $xv $yv
+        $zv seq 0 0 [$xv length]
+    } elseif { $_dim == 3 } {
+        $all split $xv $yv $zv
+    } else {
+        error "invalid dimension \"$_dim\" of cloud mesh"
+    }
+    set _numPoints [$xv length]
+    if { $_dim == 2 } {
+        append out "DATASET POLYDATA\n"
+        append out "POINTS $_numPoints float\n"
+        foreach x [$xv range 0 end] y [$yv range 0 end]  {
+            append out "$x $y 0\n"
+        }
+        set _vtkdata $out
+        foreach axis {x y} {
+            set vector [set ${axis}v]
+            set _limits($axis) [$vector limits]
+        }
+    } elseif { $_dim == 3 } {
+        append out "DATASET POLYDATA\n"
+        append out "POINTS $_numPoints float\n"
+        foreach x [$xv range 0 end] y [$yv range 0 end] z [$zv range 0 end] {
+            append out "$x $y $z\n"
+        }
+        set _vtkdata $out
+        foreach axis {x y z} {
+            set vector [set ${axis}v]
+            set _limits($axis) [$vector limits]
+        }
+    }
+    blt::vector destroy $xv $yv $zv $all
+}
+itcl::body Rappture::Mesh::ReadVtk { xmlobj path } {
+    set _type "vtk"
+    # Create a VTK file with the mesh in it.
+    set _vtkdata [$xmlobj get $path.vtk]
+    append out "# vtk DataFile Version 3.0\n"
+    append out "mesh\n"
+    append out "ASCII\n"
+    append out "$_vtkdata\n"
+    # Write the contents to a file just in case it's binary.
+    set tmpfile file[pid].vtk
+    set f [open "$tmpfile" "w"]
+    fconfigure $f -translation binary -encoding binary
+    puts $f $out
+    close $f
+    # Read the data back into a vtk dataset and query the bounds.
+    set reader $this-datasetreader
+    vtkDataSetReader $reader
+    $reader SetFileName $tmpfile
+    $reader Update
+    set output [$reader GetOutput]
+    foreach { xmin xmax ymin ymax zmin zmax } [$output GetBounds] break
+    set _dim 3;                         # Hard coding all vtk meshes to 3D?
+    set _limits(x) [list $xmin $xmax]
+    set _limits(y) [list $ymin $ymax]
+    set _limits(z) [list $zmin $zmax]
+    if { $zmin >= $zmax } {
+        set _dim 2
+    }
+    file delete $tmpfile
+    rename $output ""
+    rename $reader ""
+    set _isValid 1
+}
+itcl::body Rappture::Mesh::ReadGrid { xmlobj path } {
+    set _type "grid"
+    set numUniform 0
+    set numRectilinear 0
+    set numCurvilinear 0
+    foreach axis { x y z } {
+        set min    [$xmlobj get "$path.grid.${axis}axis.min"]
+        set max    [$xmlobj get "$path.grid.${axis}axis.max"]
+        set num    [$xmlobj get "$path.grid.${axis}axis.numpoints"]
+        set coords [$xmlobj get "$path.grid.${axis}coords"]
+        set dim    [$xmlobj get "$path.grid.${axis}dim"]
+        if { $min != "" && $max != "" && $num != "" && $num > 0 } {
+            set ${axis}Min $min
+            set ${axis}Max $max
+            set ${axis}Num $num
+            incr numUniform
+        } elseif { $coords != "" } {
+            incr numRectilinear
+            set ${axis}Coords $coords
+        } elseif { $dim != "" } {
+            set ${axis}Num $dim
+            incr numCurvilinear
+        }
+    }
+    set _dim [expr $numRectilinear + $numUniform + $numCurvilinear]
+    if { $_dim == 0 } {
+        # No data found.
+        return 0
+    }
+    if { $numCurvilinear > 0 } {
+        # This is the 2D/3D curilinear case. We found <xdim>, <ydim>, or <zdim>
+        if { $numRectilinear > 0 || $numUniform > 0 } {
+            error "can't mix curvilinear and rectilinear grids."
+        }
+        if { $numCurvilinear < 2 } {
+            error "curvilinear grid must be 2D or 3D."
+        }
+        set points [$xmlobj get $path.grid.points]
+        if { $points == "" } {
+            error "missing <points> from grid description."
+        }
+        if { ![info exists xNum] || ![info exists yNum] } {
+            error "invalid dimensions for curvilinear grid: missing <xdim> or <ydim> from grid description."
+        }
+        set all [blt::vector create \#auto]
+        set xv [blt::vector create \#auto]
+        set yv [blt::vector create \#auto]
+        set zv [blt::vector create \#auto]
+        $all set $points
+        set numCoords [$all length]
+        if { [info exists zNum] } {
+            set _dim 3
+            set _numPoints [expr $xNum * $yNum * $zNum]
+            $all set $points
+            if { ($_numPoints*3) != $numCoords } {
+                error "invalid grid: \# of points does not match dimensions <xdim> * <ydim>"
+            }
+            if { ($numCoords % 3) != 0 } {
+                error "wrong \# of coordinates for 3D grid"
+            }
+            $all split $xv $yv $zv
+            foreach axis {x y z} {
+                set vector [set ${axis}v]
+                set _limits($axis) [$vector limits]
+            }
+            append out "DATASET STRUCTURED_GRID\n"
+            append out "DIMENSIONS $xNum $yNum $zNum\n"
+            append out "POINTS $_numPoints double\n"
+            append out [$all range 0 end]
+            append out "\n"
+            set _vtkdata $out
+        } else {
+            set _dim 2
+            set _numPoints [expr $xNum * $yNum]
+            if { ($_numPoints*2) != $numCoords } {
+                error "invalid grid: \# of points does not match dimensions <xdim> * <ydim> * <zdim>"
+            }
+            if { ($numCoords % 2) != 0 } {
+                error "wrong \# of coordinates for 2D grid"
+            }
+            foreach axis {x y} {
+                set vector [set ${axis}v]
+                set _limits($axis) [$vector limits]
+            }
+            $zv seq 0 0 [$xv length]
+            $all merge $xv $yv $zv
+            append out "DATASET STRUCTURED_GRID\n"
+            append out "DIMENSIONS $xNum $yNum 1\n"
+            append out "POINTS $_numPoints double\n"
+            append out [$all range 0 end]
+            append out "\n"
+            set _vtkdata $out
+        }
+        blt::vector destroy $all $xv $yv $zv
+        set _isValid 1
+        return 1
+    }
+    if { $numRectilinear == 0 && $numUniform > 0} {
+        # This is the special case where all axes 2D/3D are uniform.
+        # This results in a STRUCTURE_POINTS
+        if { $_dim == 2 } {
+            set xSpace [expr ($xMax - $xMin) / double($xNum - 1)]
+            set ySpace [expr ($yMax - $yMin) / double($yNum - 1)]
+            set _numPoints [expr $xNum * $yNum]
+            append out "DATASET STRUCTURED_POINTS\n"
+            append out "DIMENSIONS $xNum $yNum 1\n"
+            append out "SPACING $xSpace $ySpace 0\n"
+            append out "ORIGIN 0 0 0\n"
+            set _vtkdata $out
+            foreach axis {x y} {
+                set _limits($axis) [list [set ${axis}Min] [set ${axis}Max]]
+            }
+        } elseif { $_dim == 3 } {
+            set xSpace [expr ($xMax - $xMin) / double($xNum - 1)]
+            set ySpace [expr ($yMax - $yMin) / double($yNum - 1)]
+            set zSpace [expr ($zMax - $zMin) / double($zNum - 1)]
+            set _numPoints [expr $xNum * $yNum * zNum]
+            append out "DATASET STRUCTURED_POINTS\n"
+            append out "DIMENSIONS $xNum $yNum $zNum\n"
+            append out "SPACING $xSpace $ySpace $zSpace\n"
+            append out "ORIGIN 0 0 0\n"
+            set _vtkdata $out
+            foreach axis {x y z} {
+                set _limits($axis) [list [set ${axis}Min] [set ${axis}Max]]
+            }
+        } else {
+            error "bad dimension of mesh \"$_dim\""
+        }
+        set _isValid 1
+        return 1
+    }
+    # This is the hybrid case.  Some axes are uniform, others are nonuniform.
+    set xv [blt::vector create \#auto]
+    if { [info exists xMin] } {
+        $xv seq $xMin $xMax $xNum
+    } else {
+        $xv set [$xmlobj get $path.grid.xcoords]
+        set xMin [$xv min]
+        set xMax [$xv max]
+        set xNum [$xv length]
+    }
+    set yv [blt::vector create \#auto]
+    if { [info exists yMin] } {
+        $yv seq $yMin $yMax $yNum
+    } else {
+        $yv set [$xmlobj get $path.grid.ycoords]
+        set yMin [$yv min]
+        set yMax [$yv max]
+        set yNum [$yv length]
+    }
+    set zv [blt::vector create \#auto]
+    if { $_dim == 3 } {
+        if { [info exists zMin] } {
+            $zv seq $zMin $zMax $zNum
+        }  else {
+            $zv set [$xmlobj get $path.grid.zcoords]
+            set zMin [$zv min]
+            set zMax [$zv max]
+            set zNum [$zv length]
+        }
+    } else {
+        set zNum 1
+    }
+    if { $_dim == 3 } {
+        set _numPoints [expr $xNum * $yNum * $zNum]
+        append out "DATASET RECTILINEAR_GRID\n"
+        append out "DIMENSIONS $xNum $yNum $zNum\n"
+        append out "X_COORDINATES $xNum double\n"
+        append out [$xv range 0 end]
+        append out "\n"
+        append out "Y_COORDINATES $yNum double\n"
+        append out [$yv range 0 end]
+        append out "\n"
+        append out "Z_COORDINATES $zNum double\n"
+        append out [$zv range 0 end]
+        append out "\n"
+        set _vtkdata $out
+        foreach axis {x y z} {
+            if { [info exists ${axis}Min] } {
+                set _limits($axis) [list [set ${axis}Min] [set ${axis}Max]]
+            }
+        }
+    } elseif { $_dim == 2 } {
+        set _numPoints [expr $xNum * $yNum]
+        append out "DATASET RECTILINEAR_GRID\n"
+        append out "DIMENSIONS $xNum $yNum 1\n"
+        append out "X_COORDINATES $xNum double\n"
+        append out [$xv range 0 end]
+        append out "\n"
+        append out "Y_COORDINATES $yNum double\n"
+        append out [$yv range 0 end]
+        append out "\n"
+        append out "Z_COORDINATES 1 double\n"
+        append out "0\n"
+        foreach axis {x y} {
+            if { [info exists ${axis}Min] } {
+                set _limits($axis) [list [set ${axis}Min] [set ${axis}Max]]
+            }
+        }
+        set _vtkdata $out
+    } else {
+        error "invalid dimension of grid \"$_dim\""
+    }
+    blt::vector destroy $xv $yv $zv
+    set _isValid 1
+    return 1
+}
+itcl::body Rappture::Mesh::ReadCells { xmlobj path } {
+    set _type "cells"
+    set data [$xmlobj get $path.cells.points]
+    Rappture::ReadPoints $data _dim points
+    if { $points == "" } {
+        puts stderr "no <points> found for <cells> mesh"
+        return 0
+    }
+    array set celltype2vertices {
+        triangles 3
+        quads    4
+        tetraheadrons 4
+        voxels 8
+        hexaheadrons 8
+        wedges 6
+        pyramids 5
+    }
+    array set celltype2vtkid {
+        triangles 5
+        quads    9
+        tetraheadrons 10
+        voxels 11
+        hexaheadrons 12
+        wedges 13
+        pyramids 14
+    }
+    set count 0
+    # Try to detect the celltype used.  There should be a single XML tag
+    # containing all the cells defined.  It's an error if there's more than
+    # one of these, or if there isn't one.
+    foreach type {
+        triangles quads tetraheadrons voxels hexaheadrons wedges pyramids }  {
+        if { [$xmlobj get $path.cells.$type] != "" } {
+            set celltype $type
+            incr count
+        }
+    }
+    if { $count == 0 } {
+        puts stderr "no cell types found"
+        return 0
+    }
+    if { $count > 1 } {
+        puts stderr "too many cell types tags found"
+        return 0
+    }
+    set cells [$xmlobj get $path.cells.$celltype]
+    if { $cells == "" } {
+        puts stderr "no data for celltype \"$celltype\""
+        return 0
+    }
+    # Get the number of vertices for each cell and the corresponding VTK id.
+    set numVertices $celltype2vertices($celltype)
+    set vtkid       $celltype2vtkid($celltype)
+    if { $_dim == 2 } {
+        # Load the points into one big vector, then split out the x and y
+        # coordinates.
+        set all [blt::vector create \#auto]
+        $all set $points
+        set xv [blt::vector create \#auto]
+        set yv [blt::vector create \#auto]
+        $all split $xv $yv
+        set _numPoints [$xv length]
+        set data {}
+        set _numCells 0
+        set celltypes {}
+        # Build cell information.  Look line by line.  Most cell types
+        # have a specific number of vertices, but there are a few that
+        # have a variable number of vertices.
+        foreach line [split $cells \n] {
+            set numVerticies [llength $line]
+            if { $numVerticies == 0 } {
+                continue;               # Skip blank lines
+            }
+            append data "    $numVertices $line\n"
+            append celltypes "$vtkid\n"
+            incr _numCells
+        }
+        append out "DATASET UNSTRUCTURED_GRID\n"
+        append out "POINTS $_numPoints float\n"
+        foreach x [$xv range 0 end] y [$yv range 0 end] {
+            append out "    $x $y 0\n"
+        }
+        append out "CELLS $_numCells [expr $_numCells * ($numVertices + 1)]\n"
+        append out $data
+        append out "CELL_TYPES $_numCells\n"
+        append out $celltypes
+        set _limits(x) [$xv limits]
+        set _limits(y) [$yv limits]
+        blt::vector destroy $xv $yv $all
+    } else {
+        # Load the points into one big vector, then split out the x, y, and z
+        # coordinates.
+        set all [blt::vector create \#auto]
+        $all set $points
+        set xv [blt::vector create \#auto]
+        set yv [blt::vector create \#auto]
+        set zv [blt::vector create \#auto]
+        $all split $xv $yv $zv
+        set _numPoints [$xv length]
+        set data {}
+        set _numCells 0
+        set celltypes {}
+        # Build cell information.  Look line by line.  Most cell types
+        # have a specific number of vertices, but there are a few that
+        # have a variable number of vertices.
+        foreach line [split $cells \n] {
+            set numVerticies [llength $line]
+            if { $numVerticies == 0 } {
+                continue;               # Skip blank lines
+            }
+            append data "    $numVertices $line\n"
+            append celltypes "$vtkid\n"
+            incr _numCells
+        }
+        append out "DATASET UNSTRUCTURED_GRID\n"
+        append out "POINTS $_numPoints float\n"
+        foreach x [$xv range 0 end] y [$yv range 0 end] z [$zv range 0 end] {
+            append out "    $x $y $z\n"
+        }
+        append out "CELLS $_numCells [expr $_numCells * ($numVerticies + 1)]\n"
+        append out $data
+        append out "CELL_TYPES $_numCells\n"
+        append out $celltypes
+        set _limits(x) [$xv limits]
+        set _limits(y) [$yv limits]
+        set _limits(z) [$zv limits]
+        blt::vector destroy $xv $yv $zv $all
+    }
+    set _vtkdata $out
+    set _isValid 1
+}
+itcl::body Rappture::Mesh::ReadTriangles { xmlobj path } {
+    set _type "triangles"
+    set _dim 2
+    set triangles [$xmlobj get $path.triangles.indices]
+    if { $triangles == "" } {
+        puts stderr "no triangle indices specified in mesh"
+        return 0
+    }
+    set xcoords [$xmlobj get $path.triangles.xcoords]
+    set ycoords [$xmlobj get $path.triangles.ycoords]
+    set points [$xmlobj get $path.triangles.points]
+    set xv [blt::vector create \#auto]
+    set yv [blt::vector create \#auto]
+    if { $xcoords != "" && $ycoords != "" } {
+        $xv set $xcoords
+        $yx set $ycoords
+    } elseif { $points != "" } {
+        set all [blt::vector create \#auto]
+        $all set $points
+        $all split $xv $yv
+    } else {
+        puts stderr "missing either <xcoords>, <ycoords>, or <points> for triangular mesh"
+        return 0
+    }
+    set _numPoints [$xv length]
+    set count 0
+    set data {}
+    foreach { a b c } $triangles {
+        append data "    3 $a $b $c\n"
+        incr count
+    }
+    set celltypes {}
+    for { set i 0 } { $i < $count } { incr i } {
+        append celltypes "5\n"
+    }
+    append out "DATASET UNSTRUCTURED_GRID\n"
+    append out "POINTS $_numPoints float\n"
+    foreach x [$xv range 0 end] y [$yv range 0 end] {
+        append out "    $x $y 0\n"
+    }
+    append out "CELLS $count [expr $count * 4]\n"
+    append out $data
+    append out "CELL_TYPES $count\n"
+    append out $celltypes
+    set _limits(x) [$xv limits]
+    set _limits(y) [$yv limits]
+    set _vtkdata $out
+    set _isValid 1
+}
+itcl::body Rappture::Mesh::ReadUnstructuredGrid { xmlobj path } {
+    set _type "unstructured_grid"
+    set data [$xmlobj get $path.unstructured_grid.points]
+    Rappture::ReadPoints $data _dim points
+    if { $points == "" } {
+        puts stderr "no <points> found for <cells> mesh"
+        return 0
+    }
+    set cells [$xmlobj get $path.unstructured_grid.cells]
+    if { $cells == "" } {
+        puts stderr "no <cells> description found unstructured_grid"
+        return 0
+    }
+    set celltypes [$xmlobj get $path.unstructured_grid.celltypes]
+    if { $cells == "" } {
+        puts stderr "no <cells> description found unstructured_grid."
+        return 0
+    }
+    set lines [split $cells \n]
+    set all [blt::vector create \#auto]
+    set xv [blt::vector create \#auto]
+    set yv [blt::vector create \#auto]
+    set zv [blt::vector create \#auto]
+    $all set $points
+    if { $_dim == 2 } {
+        # Load the points into one big vector, then split out the x and y
+        # coordinates.
+        $all split $xv $yv
+        set _numPoints [$xv length]
+        set data {}
+        set count 0
+        set _numCells 0
+        foreach line $lines {
+            set length [llength $line]
+            if { $length == 0 } {
+                continue
+            }
+            set celltype [lindex $celltypes $_numCells]
+            if { $celltype == "" } {
+                puts stderr "can't find celltype for line \"$line\""
+                return 0
+            }
+            append data " $line\n"
+            incr count $length
+            incr _numCells
+        }
+        append out "DATASET UNSTRUCTURED_GRID\n"
+        append out "POINTS $_numPoints float\n"
+        $zv seq 0 0 [$xv length];       # Make an all zeroes vector.
+        $all merge $xv $yv $zv
+        append out [$all range 0 end]
+        append out "CELLS $_numCells $count\n"
+        append out $data
+        append out "CELL_TYPES $_numCells\n"
+        append out $celltypes
+        set _limits(x) [$xv limits]
+        set _limits(y) [$yv limits]
+    } else {
+        # Load the points into one big vector, then split out the x, y, and z
+        # coordinates.
+        $all split $xv $yv $zv
+        set _numPoints [$xv length]
+        set data {}
+        set count 0
+        set _numCells 0
+        foreach line $lines {
+            set length [llength $line]
+            if { $length == 0 } {
+                continue
+            }
+            set celltype [lindex $celltypes $_numCells]
+            if { $celltype == "" } {
+                puts stderr "can't find celltype for line \"$line\""
+                return 0
+            }
+            append data " $line\n"
+            incr count $length
+            incr _numCells
+        }
+        append out "DATASET UNSTRUCTURED_GRID\n"
+        append out "POINTS $_numPoints float\n"
+        $all merge $xv $yv $zv
+        append out [$all range 0 end]
+        append out "\n"
+        append out "CELLS $_numCells $count\n"
+        append out $data
+        append out "CELL_TYPES $_numCells\n"
+        append out $celltypes
+        set _limits(x) [$xv limits]
+        set _limits(y) [$yv limits]
+        set _limits(z) [$zv limits]
+    }
+    blt::vector destroy $xv $yv $zv $all
+    set _vtkdata $out
+    set _isValid 1
+}
+# ----------------------------------------------------------------------
+# USAGE: ReadNodesElements <xmlobj> <path>
+#
 # Used internally to build a mesh representation based on nodes and
 # elements stored in the XML.
 # ----------------------------------------------------------------------
+itcl::body Rappture::Mesh::_buildNodesElements {xmlobj path} {
+    # create the vtk objects containing points and connectivity
+    vtkPoints $this-points
+    set _pdata $this-points
+    vtkUnstructuredGrid $this-grid
+    set _gdata $this-grid
+    #
+    # Extract each node and add it to the points list.
+    #
+    foreach comp [$xmlobj children -type node $path] {
+        set xyz [$xmlobj get $path.$comp]
+        # make sure we have x,y,z
+        while {[llength $xyz] < 3} {
+            lappend xyz "0"
+        }
+        # extract each point and add it to the points list
+        foreach {x y z} $xyz break
+        foreach dim {x y z} units $_units {
+            set v [Rappture::Units::convert [set $dim] \
+                -context $units -to $units -units off]
+            set $dim $v  ;# save back to real x/y/z variable
+            if {"" == $_limits(${dim}min)} {
+                set _limits(${dim}min) $v
+                set _limits(${dim}max) $v
+            } else {
+                if {$v < $_limits(${dim}min)} { set _limits(${dim}min) $v }
+                if {$v > $_limits(${dim}max)} { set _limits(${dim}max) $v }
+            }
+        }
+        $this-points InsertNextPoint $x $y $z
+    }
+    $this-grid SetPoints $this-points
+    #
+    # Extract each element and add it to the mesh.
+    #
+    foreach comp [$xmlobj children -type element $path] {
+        set nlist [$_mesh get $comp.nodes]
+        set elem [_getVtkElement [llength $nlist]]
+        set i 0
+        foreach n $nlist {
+            [$elem GetPointIds] SetId $i $n
+            incr i
+        }
+        $this-grid InsertNextCell [$elem GetCellType] [$elem GetPointIds]
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: _buildRectMesh <xmlobj> <path>
+#
+# Used internally to build a mesh representation based on a native
+# VTK file for a rectangular mesh.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Mesh::_buildRectMesh {xmlobj path} {
+    vtkRectilinearGridReader $this-gr
+    $this-gr ReadFromInputStringOn
+    $this-gr SetInputString [$xmlobj get $path.vtk]
+    set _gdata [$this-gr GetOutput]
+    set _pdata [$_gdata GetPointData]
+    $_gdata Update
+    foreach name {xmin xmax ymin ymax zmin zmax} val [$_gdata GetBounds] {
+        set _limits($name) $val
+    }
+}
+# ----------------------------------------------------------------------
+# USAGE: _getVtkElement <npts>
+#
+# Used internally to find (or allocate, if necessary) a vtk element
+# that can be used to build up a mesh.  The element depends on the
+# number of points passed in.  4 points is a tetrahedron, 5 points
+# is a pyramid, etc.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Mesh::_getVtkElement {npts} {
+    if {![info exists _pts2elem($npts)]} {
+        switch -- $npts {
+{
+                set _pts2elem($npts) $this-elem3
+                vtkTriangle $_pts2elem($npts)
+            }
+{
+                set _pts2elem($npts) $this-elem4
+                vtkTetra $_pts2elem($npts)
+            }
+{
+                set _pts2elem($npts) $this-elem5
+                vtkPyramid $_pts2elem($npts)
+            }
+{
+                set _pts2elem($npts) $this-elem6
+                vtkWedge $_pts2elem($npts)
+            }
+{
+                set _pts2elem($npts) $this-elem8
+                vtkVoxel $_pts2elem($npts)
+            }
+        }
+    }
+    return $_pts2elem($npts)
+}
+itcl::body Rappture::Mesh::ReadNodesElements {xmlobj path} {
+    set type "nodeselements"
+    set count 0
+    # Scan for nodes.  Each node represents a vertex.
+    set data {}
+    foreach cname [$xmlobj children -type node $path] {
+        append data "[$xmlobj get $path.$cname]\n"
+    }
+    Rappture::ReadPoints $data _dim points
+    if { $_dim == 2 } {
+        set all [blt::vector create \#auto]
+        set xv [blt::vector create \#auto]
+        set yv [blt::vector create \#auto]
+        set zv [blt::vector create \#auto]
+        $all set $points
+        $all split $xv $yv
+        set _numPoints [$xv length]
+        foreach axis {x y} {
+            set vector [set ${axis}v]
+            set _limits($axis) [${vector} limits]
+        }
+        # 2D Dataset. All Z coordinates are 0
+        $zv seq 0.0 0.0 $_numPoints
+        $all merge $xv $yv $zv
+        set points [$all range 0 end]
+        blt::vector destroy $all $xv $yv $zv
+    } elseif { $_dim == 3 } {
+        set all [blt::vector create \#auto]
+        set xv [blt::vector create \#auto]
+        set yv [blt::vector create \#auto]
+        set zv [blt::vector create \#auto]
+        $all set $points
+        $all split $xv $yv $zv
+        set _numPoints [$xv length]
+        foreach axis {x y z} {
+            set vector [set ${axis}v]
+            set _limits($axis) [${vector} limits]
+        }
+        set points [$all range 0 end]
+        blt::vector destroy $all $xv $yv $zv
+    } else {
+        error "bad dimension \"$_dim\" for nodes mesh"
+    }
+    array set node2celltype {
+5
+10
+11
+13
+14
+    }
+    set count 0
+    set _numCells 0
+    set celltypes {}
+    set data {}
+    # Next scan for elements.  Each element represents a cell.
+    foreach cname [$xmlobj children -type element $path] {
+        set nodeList [$_mesh get $cname.nodes]
+        set numNodes [llength $nodeList]
+        if { ![info exists node2celltype($numNodes)] } {
+            puts stderr "unknown number of indices \"$_numNodes\": should be 3, 4, 5, 6, or 8"
+            return 0
+        }
+        set celltype $node2celltype($numNodes)
+        append celltypes "  $celltype\n"
+        append data "  $numNodes $nodeList\n"
+        incr _numCells
+        incr count $numNodes
+        incr count;                     # One extra for the VTK celltype id.
+    }
+    append out "DATASET UNSTRUCTURED_GRID\n"
+    append out "POINTS $_numPoints float\n"
+    append out $points
+    append out "CELLS $_numCells $count\n"
+    append out $data
+    append out "CELL_TYPES $_numCells\n"
+    append out $celltypes
+    append out "\n"
+    set _vtkdata $out
+    set _isValid 1
+}

trunk/gui/scripts/meshresult.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: meshresult - mesh plot in a ResultSet

trunk/gui/scripts/moleculeViewer.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: MoleculeViewer - view a molecule in 3D

trunk/gui/scripts/molvisviewer.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 …
     private variable _cacheid ""
     private variable _cacheimage ""
+    private variable _first     ""
     private common _settings  ;         # Array of settings for all known
 …
     private variable _width
     private variable _height
     private variable _reset 1;  # Restore camera settings
+    private variable _reset 1;          # Restore camera settings
     private variable _cell 0;           # Restore camera settings
+    private variable _flush 1
+    constructor { hostlist args } {
+        Rappture::VisViewer::constructor $hostlist
+    constructor { servers args } {
+        Rappture::VisViewer::constructor $servers
     } {
         # defined below
 …
 # CONSTRUCTOR
 # ----------------------------------------------------------------------
 itcl::body Rappture::MolvisViewer::constructor {hostlist args} {
+itcl::body Rappture::MolvisViewer::constructor {servers args} {
     set _serverType "pymol"
 …
     # the visualization server.
     $_parser alias image [itcl::code $this ReceiveImage]
+    $_parser alias viserror [itcl::code $this ReceiveError]
     set _rocker(dir) 1
 …
     set _state(server) 1
     set _state(client) 1
-    set _hostlist $hostlist
     set _reset 1
 …
         ignore -highlightthickness -borderwidth  -background
+    }
+    bind $itk_component(3dview) <Control-F1> [itcl::code $this ToggleConsole]
     set f [$itk_component(main) component controls]
 …
     # delete all specified dataobjs
     set changed 0
-    set _flush 1
     foreach dataobj $args {
         set pos [lsearch -exact $_dlist $dataobj]
 …
     global readyForNextFrame
     set readyForNextFrame 1
+    set _reset 1
+}
 …
         SendCmd "raw -defer {set auto_show_lines,0}"
+    }
+    set _first ""
     set dlist [get]
     foreach dataobj $dlist {
+        if { $_first == "" } {
+            set _first $dataobj
+        }
         set model [$dataobj get components.molecule.model]
         if {"" == $model } {
 …
+    }
     if { $_reset } {
+        if 1 {
+            # Tell the server the name of the tool, the version, and dataset
+            # that we are rendering.  Have to do it here because we don't know
+            # what data objects are using the renderer until be get here.
+            global env
+            lappend out "hub" [exec hostname]
+            lappend out "viewer" "molvisviewer"
+            if { [info exists env(USER)] } {
+                lappend out "user" $env(USER)
+            }
+            if { [info exists env(SESSION)] } {
+                lappend out "session" $env(SESSION)
+            }
+            set parent [$_first parent -as object]
+            while { $parent != "" } {
+                set xmlobj $parent
+                set parent [$parent parent -as object]
+            }
+            lappend out "tool_id" [$xmlobj get tool.id]
+            lappend out "tool_name" [$xmlobj get tool.name]
+            lappend out "tool_title" [$xmlobj get tool.title]
+            lappend out "tool_command" [$xmlobj get tool.execute]
+            lappend out "tool_revision" \
+                [$xmlobj get tool.version.application.revision]
+            SendCmd "clientinfo $out"
+        }
         # Set or restore viewing parameters.  We do this for the first
         # model and assume this works for everything else.
 …
                                         # until we get an image.
         #SendCmd "ppm";                 # Flush the results.
-        set _flush 0
+    }
     set _buffering 0;                   # Turn off buffering.

trunk/gui/scripts/nanovisviewer.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 …
                                     # dataobj-components using the tf.
+    private variable _reset 1;          # Connection to server has been reset
     private variable _click        ;# info used for rotate operations
     private variable _limits       ;# autoscale min/max for all axes
 …
     $_parser alias legend [itcl::code $this ReceiveLegend]
     $_parser alias data [itcl::code $this ReceiveData]
+    $_parser alias viserror [itcl::code $this ReceiveError]
     # Initialize the view to some default parameters.
 …
     set _limits(vmin) 0.0
     set _limits(vmax) 1.0
+    set _reset 1
     array set _settings [subst {
 …
         ignore -highlightthickness -borderwidth  -background
+    }
+    bind $itk_component(3dview) <Control-F1> [itcl::code $this ToggleConsole]
     set f [$itk_component(main) component controls]
 …
         return 0
+    }
+    set _reset 1
     set result [VisViewer::Connect $_hosts]
     if { $result } {
 …
+        }
+    }
+    #
+    # Reset the camera and other view parameters
+    #
+    set _settings($this-theta) $_view(theta)
+    set _settings($this-phi)   $_view(phi)
+    set _settings($this-psi)   $_view(psi)
+    set _settings($this-pan-x) $_view(pan-x)
+    set _settings($this-pan-y) $_view(pan-y)
+    set _settings($this-zoom)  $_view(zoom)
+    set xyz [Euler2XYZ $_view(theta) $_view(phi) $_view(psi)]
+    SendCmd "camera angle $xyz"
+    PanCamera
+    SendCmd "camera zoom $_view(zoom)"
+    FixSettings light
+    FixSettings transp
+    FixSettings isosurface
+    FixSettings grid
+    FixSettings axes
+    FixSettings outline
+    # nothing to send -- activate the proper ivol
+    SendCmd "volume state 0"
+    set _first [lindex [get] 0]
+    if {"" != $_first} {
+        set axis [$_first hints updir]
+        if { "" != $axis } {
+            SendCmd "up $axis"
+        }
+        set location [$_first hints camera]
+        if { $location != "" } {
+            array set _view $location
+        }
+        set vols [array names _serverVols $_first-*]
+        if { $vols != "" } {
+            SendCmd "volume state 1 $vols"
+        }
+    }
+    # If the first volume already exists on the server, then make sure we
+    # display the proper transfer function in the legend.
+    set comp [lindex [$_first components] 0]
+    if { [info exists _serverVols($_first-$comp)] } {
+        updatetransferfuncs
+    }
+    foreach axis {x y z} {
+        # Turn off cutplanes for all volumes
+        SendCmd "cutplane state 0 $axis"
+    if { $_reset } {
+        #
+        # Reset the camera and other view parameters
+        #
+        set _settings($this-theta) $_view(theta)
+        set _settings($this-phi)   $_view(phi)
+        set _settings($this-psi)   $_view(psi)
+        set _settings($this-pan-x) $_view(pan-x)
+        set _settings($this-pan-y) $_view(pan-y)
+        set _settings($this-zoom)  $_view(zoom)
+        set xyz [Euler2XYZ $_view(theta) $_view(phi) $_view(psi)]
+        SendCmd "camera angle $xyz"
+        PanCamera
+        SendCmd "camera zoom $_view(zoom)"
+        FixSettings light
+        FixSettings transp
+        FixSettings isosurface
+        FixSettings grid
+        FixSettings axes
+        FixSettings outline
+        # nothing to send -- activate the proper ivol
+        SendCmd "volume state 0"
+        set _first [lindex [get] 0]
+        if {"" != $_first} {
+            set axis [$_first hints updir]
+            if { "" != $axis } {
+                SendCmd "up $axis"
+            }
+            set location [$_first hints camera]
+            if { $location != "" } {
+                array set _view $location
+            }
+            set vols [array names _serverVols $_first-*]
+            if { $vols != "" } {
+                SendCmd "volume state 1 $vols"
+            }
+            if 1 {
+                # Tell the server the name of the tool, the version, and dataset
+                # that we are rendering.  Have to do it here because we don't know
+                # what data objects are using the renderer until be get here.
+                global env
+                lappend out "hub" [exec hostname]
+                lappend out "viewer" "nanovisviewer"
+                if { [info exists env(USER)] } {
+                    lappend out "user" $env(USER)
+                }
+                if { [info exists env(SESSION)] } {
+                    lappend out "session" $env(SESSION)
+                }
+                lappend out "tool_id"      [$_first hints toolId]
+                lappend out "tool_name"    [$_first hints toolName]
+                lappend out "tool_version" [$_first hints toolRevision]
+                lappend out "tool_title"   [$_first hints toolTitle]
+                lappend out "tool_dataset" [$_first hints label]
+                SendCmd "clientinfo [list $out]"
+            }
+            foreach axis {x y z} {
+                # Turn off cutplanes for all volumes
+                SendCmd "cutplane state 0 $axis"
+            }
+            # If the first volume already exists on the server, then make sure
+            # we display the proper transfer function in the legend.
+            set comp [lindex [$_first components] 0]
+            if { [info exists _serverVols($_first-$comp)] } {
+                updatetransferfuncs
+            }
+        }
+    }
     set _buffering 0;                        # Turn off buffering.
 …
     SendBytes $_outbuf;
     blt::busy release $itk_component(hull)
+    set _reset 0
     set _outbuf "";                        # Clear the buffer.
+}

trunk/gui/scripts/note.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/notebook.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: notebook - series of pages, but only one packed at a time

trunk/gui/scripts/numberentry.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: NumberEntry - widget for entering numeric values

trunk/gui/scripts/numberresult.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/page.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: page - single page of widgets

trunk/gui/scripts/pager.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: pager - notebook for displaying pages of widgets

trunk/gui/scripts/panes.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/periodicelement.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/periodicelemententry.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: PeriodicElementEntry - widget for entering a choice of strings

trunk/gui/scripts/periodictable.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: periodictable - drop-down list of items

trunk/gui/scripts/postern.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: postern - a back door for debugging

trunk/gui/scripts/progress.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: progress - progress meter for long-running apps

trunk/gui/scripts/pushbutton.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 …
     itk_option define -onvalue onValue OnValue "normal"
     itk_option define -offvalue offValue OffValue "normal"
+    itk_option define -onbackground onBackground OnBackground "white"
+    itk_option define -offbackground offBackground OffBackground "grey85"
     constructor {args} {
 …
     public variable onvalue "1";        # Value set when selected.
     public variable offvalue "0";       # Value set when deselected.
+    public variable onbackground "white"
+    public variable offbackground "grey85"
+}
 …
         set _state 1
         $itk_component(button) configure -relief sunken \
             -image $onimage -bg white
+            -image $onimage -bg $onbackground
     } else {
         set _state 0
         $itk_component(button) configure -relief raise \
             -image $offimage -bg grey85
+            -image $offimage -bg $offbackground
+    }
+}

trunk/gui/scripts/radiodial.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: Radiodial - selector, like the dial on a car radio

trunk/gui/scripts/resources.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: resources

trunk/gui/scripts/resultselector.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: ResultSelector - controls for a ResultSet

trunk/gui/scripts/resultset.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: ResultSet - set of XML objects for simulated results

trunk/gui/scripts/resultviewer.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: ResultViewer - plots a collection of related results
 …
     itk_option define -simulatecommand simulateCommand SimulateCommand ""
+    constructor {args} { # defined below }
+    destructor { # defined below }
+    constructor {args} {
+        # defined below
+    }
+    destructor {
+        # defined below
+    }
     public method add {index xmlobj path}
     public method clear {{index ""}}
 …
+                }
 D {
+                    set mode "contour"
+                    if {![info exists _mode2widget($mode)]} {
+                        global env
+                        if { [$dataobj isunirect2d] } {
+                            if { [$dataobj hints type] == "contour" } {
+                                set resultMode "vtkcontour"
+                            } elseif { [info exists env(VTKHEIGHTMAP)] } {
+                                set resultMode "vtkheightmap"
+                            } else {
+                                set resultMode "heightmap"
+                            }
+                        } elseif { [info exists env(VTKCONTOUR)] } {
+                            set resultMode "vtkcontour"
+                        } else {
+                            set resultMode "vtk"
+                        }
+                        set extents [$dataobj extents]
+                        if { $extents > 1 } {
+                            set resultMode "flowvis"
+                        }
+                        set w $itk_interior.contour
+                    set mode "field2d"
+                    set viewer [$dataobj viewer]
+                    set extents [$dataobj extents]
+                    if { $extents > 1 } {
+                        set mode "flowvis"
+                    }
+                    if {![info exists _mode2widget($mode)]} {
+                        set w $itk_interior.$mode
                         if { ![winfo exists $w] } {
                             Rappture::Field2DResult $w -mode $resultMode
+                        }
+                        set _mode2widget($mode) $w
+                            Rappture::Field2DResult $w -mode $viewer
+                            set _mode2widget($mode) $w
+                        }
+                    }
+                }
 D {
+                    set mode "field3D"
+                    if {![info exists _mode2widget($mode)]} {
+                        switch -- [$dataobj type] {
+                            "vtk" {
+                                set fmt "vtk"
+                            }
+                            "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]
+                                if { $extents > 1 } {
+                                    set fmt "flowvis"
+                                }
+                            }
+                            "vtkvolume" {
+                                set fmt "vtkvolume"
+                            }
+                            "vtkstreamlines" {
+                                set fmt "vtkstreamlines"
+                            }
+                        }
+                        set w $itk_interior.field3D
+                        Rappture::Field3DResult $w -mode $fmt
+                    set mode [$dataobj viewer]
+                    set extents [$dataobj extents]
+                    if { $extents > 1 } {
+                        set mode "flowvis"
+                    }
+                    if {![info exists _mode2widget($mode)]} {
+                        set w $itk_interior.$mode
+                        Rappture::Field3DResult $w -mode $mode
                         set _mode2widget($mode) $w
+                    }

trunk/gui/scripts/scroller.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: scroller - adds scrollbars to any standard Tk widget

trunk/gui/scripts/sequence.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: sequence - represents a sequence of output results
 …
+                }
                 curve {
                     set obj [Rappture::Curve ::#auto $xmlobj $path.$name.$cname]
+                    set obj [Rappture::Curve ::\#auto $xmlobj $path.$name.$cname]
+                }
                 datatable {
                     set obj [Rappture::DataTable ::#auto $xmlobj $path.$name.$cname]
+                    set obj [Rappture::DataTable ::\#auto $xmlobj $path.$name.$cname]
+                }
                 histogram {
                     set obj [Rappture::Histogram ::#auto $xmlobj $path.$name.$cname]
+                    set obj [Rappture::Histogram ::\#auto $xmlobj $path.$name.$cname]
+                }
                 field {
                     set obj [Rappture::Field ::#auto $xmlobj $path.$name.$cname]
+                    set obj [Rappture::Field ::\#auto $xmlobj $path.$name.$cname]
+                }
                 image {
                     set obj [Rappture::Image ::#auto $xmlobj $path.$name.$cname]
+                    set obj [Rappture::Image ::\#auto $xmlobj $path.$name.$cname]
+                }
                 structure {
 …
+        }
+    }
+    #
     # Generate a list of sorted index values.
 …
         # sort according to raw values; store both values
         set _indices [lsort -real -index 1 $vals]
     } else {
         # are the indices integers, reals, or strings?
 …
 itcl::body Rappture::Sequence::value {pos} {
     set i [lindex [lindex $_indices $pos] 0]
+    # FIXME:  This is a bandaid on what appears to be a timing problem.
+    # This "dataobjs" method is now called before any sequence frames
+    # have been added.
+    if { ![info exists _dataobjs($i)] } {
+        return ""
+    }
     return $_dataobjs($i)
+}
 …
 itcl::body Rappture::Sequence::label {pos} {
     set i [lindex [lindex $_indices $pos] 0]
+    # FIXME:  This is a bandaid on what appears to be a timing problem.
+    # This "label" method is now called before any sequence frames
+    # have been added.
+    if { ![info exists _labels($i)] } {
+        return ""
+    }
     return $_labels($i)
+}

trunk/gui/scripts/sequenceresult.tcl

-                      r3186
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 …
     itk_component add dial {
         Rappture::Radiodial $itk_component(player).dial \
+        Rappture::SequenceDial $itk_component(player).dial \
             -length 10 -valuewidth 0 -valuepadding 0 -padding 6 \
             -linecolor "" -activelinecolor "" \
 …
     # Otherwise, hide it.
+    #
     set viewer $itk_component(area).viewer
     if {[winfo exists $viewer]} {
+    set w $itk_component(area).viewer
+    if {[winfo exists $w]} {
         if {"" == $_topmost} {
             pack forget $viewer
+            pack forget $w
             pack forget $itk_component(player)
             return
         } else {
             pack $viewer -expand yes -fill both
+            pack $w -expand yes -fill both
             pack $itk_component(player) -side bottom -fill x
+        }
 …
         switch -- $type {
             ::Rappture::Drawing {
                 Rappture::VtkViewer $viewer
                 pack $viewer -expand yes -fill both
+                Rappture::VtkViewer $w
+                pack $w -expand yes -fill both
+            }
             ::Rappture::Curve {
                 Rappture::XyResult $viewer
                 pack $viewer -expand yes -fill both
+                Rappture::XyResult $w
+                pack $w -expand yes -fill both
+            }
             ::Rappture::Histogram {
                 Rappture::HistogramResult $viewer
                 pack $viewer -expand yes -fill both
+                Rappture::HistogramResult $w
+                pack $w -expand yes -fill both
+            }
             ::Rappture::DataTable {
                 Rappture::DataTable $viewer
                 pack $viewer -expand yes -fill both
+                Rappture::DataTable $w
+                pack $w -expand yes -fill both
+            }
             ::Rappture::Image {
                 Rappture::ImageResult $viewer
                 pack $viewer -expand yes -fill both
+                Rappture::ImageResult $w
+                pack $w -expand yes -fill both
+            }
             ::Rappture::Field {
 …
+                    }
+                }
+                set mode [$dataobj viewer]
                 switch -- $dimensions {
 D {
+                        global env
+                        if { [$dataobj isunirect2d] } {
+                            if { [$dataobj hints type] == "contour" } {
+                                set mode "vtkcontour"
+                            } elseif { [info exists env(VTKHEIGHTMAP)] } {
+                                set mode "vtkheightmap"
+                            } else {
+                                set mode "heightmap"
+                            }
+                        } elseif { [info exists env(VTKCONTOUR)] } {
+                            set mode "vtkcontour"
+                        } else {
+                            set mode "vtk"
+                        }
+                        set extents [$dataobj extents]
+                        if { $extents > 1 } {
+                            set mode "flowvis"
+                        }
+                        Rappture::Field2DResult $viewer -mode $mode
+                        Rappture::Field2DResult $w -mode $mode
+                    }
 D {
+                        set fmt [$dataobj type]
+                        switch -- $fmt {
+                            "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]
+                                if { $extents > 1 } {
+                                    set fmt "flowvis"
+                                }
+                            }
+                            "vtkvolume" {
+                                set fmt "vtkvolume"
+                            }
+                            "vtkstreamlines" {
+                                set fmt "vtkstreamlines"
+                            }
+                            "" {
+                                set fmt "auto"
+                            }
+                        }
+                        Rappture::Field3DResult $viewer -mode $fmt
+                        Rappture::Field3DResult $w -mode $mode
+                    }
                     default {
                         error "don't know how to view sequences of $type\
                             with $dimensions dimensions"
+                            with \"$dimensions\" dimensions dim=[$dataobj components -dimensions]"
+                    }
+                }
                 pack $viewer -expand yes -fill both
+                pack $w -expand yes -fill both
+            }
             ::Rappture::LibraryObj {
                 switch -- [$dataobj element -as type] {
                     structure {
                         Rappture::DeviceResult $viewer
                         pack $viewer -expand yes -fill both
+                        Rappture::DeviceResult $w
+                        pack $w -expand yes -fill both
+                    }
                     default {
 …
+        }
+    }
+    #
     # Load the current sequence info the viewer.
+    #
     $itk_component(indexLabel) configure -text [$_topmost hints indexlabel]
     $viewer delete
+    $w delete
     $itk_component(dial) clear
 …
         eval lappend all [$_topmost value $i]
+    }
     eval $viewer scale $all
+    eval $w scale $all
     set _indices ""
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::SequenceResult::_fixValue {} {
     set viewer $itk_component(area).viewer
     if {![winfo exists $viewer]} {
+    set w $itk_component(area).viewer
+    if {![winfo exists $w]} {
         return
+    }
     $viewer delete
+    $w delete
     if { $_topmost == "" } {
         return
 …
     set val [$itk_component(dial) get -format label current]
     set _pos [lsearch -glob $_indices $val*]
     # populate the label for this element
     if { "" != [$_topmost hints indexlabel] } {
 …
+            }
+        }
         $viewer add $dataobj $settings
+    }
+}
+        $w add $dataobj $settings
+    }
+}

trunk/gui/scripts/service.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: service - represents a tool embedded within another tool

trunk/gui/scripts/sidebarframe.tcl

-                      r3287
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: SidebarFrame - pop-out controls for visualization widgets
 …
     public method disable { which }
     protected method _toggleTab { which }
+    protected method _toggleTab {which}
     protected method _sash {op x}
     protected method _fixLayout {args}
 …
             Background
+    }
+    pack $itk_component(tabs) -side top -expand yes -anchor e -padx {4 0} \
+        -fill y
+    pack $itk_component(tabs) -side top -expand yes -anchor e -padx {4 0} -fill y
     eval itk_initialize $args

trunk/gui/scripts/spectrum.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: spectrum - maps a range of real values onto a color

trunk/gui/scripts/spinint.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2
2	3	# ----------------------------------------------------------------------

trunk/gui/scripts/switch.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: switch - on/off switch

trunk/gui/scripts/table.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: table - extracts data from an XML description of a table

trunk/gui/scripts/tempgauge.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: tempgauge - gauge for temperature values

trunk/gui/scripts/textentry.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: textentry - general-purpose text entry widget

trunk/gui/scripts/textresult.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: TextResult - Log output for ResultSet

trunk/gui/scripts/tool.tcl

-                      r3275
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: tool - represents an entire tool
 …
             set cmd [linsert $cmd 0 submit --local]
+        }
+        $_xmlobj put tool.execute $cmd
         # starting job...

trunk/gui/scripts/tooltip.tcl

r3186	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: tooltip - help information that pops up beneath a widget

trunk/gui/scripts/tuples.tcl

r3177	r3330
	1	# -- mode: tcl; indent-tabs-mode: nil --
1	2	# ----------------------------------------------------------------------
2	3	# COMPONENT: tuples - represents a series of tuples for arbitrary data

trunk/gui/scripts/unirect2d.tcl

-                      r3177
+                      r3330
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 …
 itcl::class Rappture::Unirect2d {
+    constructor {xmlobj field cname {extents 1}} { # defined below }
+    constructor {xmlobj path} {
+        # defined below
+    }
     destructor { # defined below }
+    public proc fetch {xmlobj path}
+    public proc release {obj}
     public method limits {axis}
     public method blob {}
-    public method mesh.old {}
     public method mesh {}
+    public method values {}
+    public method dimensions {} {
+        return 2
+    }
+    public method numpoints {} {
+        return $_numPoints
+    }
+    public method vtkdata {} {
+        return $_vtkdata
+    }
     public method hints {{keyword ""}}
     private method GetString { obj path varName }
     private method GetValue { obj path varName }
     private method GetSize { obj path varName }
     private variable _axisOrder "x y"
     private variable _xMax      0
 …
     private variable _yMin      0
     private variable _yNum      0
-    private variable _compNum   1
-    private variable _values    "";     # BLT vector containing the z-values
     private variable _hints
+    private variable _vtkdata ""
+    private variable _numPoints 0
+    private common _xp2obj       ;      # used for fetch/release ref counting
+    private common _obj2ref      ;      # used for fetch/release ref counting
+}
+#
+# fetch <xmlobj> <path>
+#
+#    Clients use this instead of a constructor to fetch the Mesh for a
+#    particular <path> in the <xmlobj>.  When the client is done with the mesh,
+#    he calls "release" to decrement the reference count.  When the mesh is no
+#    longer needed, it is cleaned up automatically.
+#
+itcl::body Rappture::Unirect2d::fetch {xmlobj path} {
+    set handle "$xmlobj|$path"
+    if {[info exists _xp2obj($handle)]} {
+        set obj $_xp2obj($handle)
+        incr _obj2ref($obj)
+        return $obj
+    }
+    set obj [Rappture::Unirect2d ::#auto $xmlobj $path]
+    set _xp2obj($handle) $obj
+    set _obj2ref($obj) 1
+    return $obj
+}
+# ----------------------------------------------------------------------
+# USAGE: Rappture::Mesh::release <obj>
+#
+# Clients call this when they're no longer using a Mesh fetched
+# previously by the "fetch" proc.  This decrements the reference
+# count for the mesh and destroys the object when it is no longer
+# in use.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Unirect2d::release { obj } {
+    if { ![info exists _obj2ref($obj)] } {
+        error "can't find reference count for $obj"
+    }
+    incr _obj2ref($obj) -1
+    if {$_obj2ref($obj) <= 0} {
+        unset _obj2ref($obj)
+        foreach handle [array names _xp2obj] {
+            if {$_xp2obj($handle) == $obj} {
+                unset _xp2obj($handle)
+            }
+        }
+        itcl::delete object $obj
+    }
+}
 …
 # Constructor
 # ----------------------------------------------------------------------
 itcl::body Rappture::Unirect2d::constructor {xmlobj field cname {extents 1}} {
+itcl::body Rappture::Unirect2d::constructor {xmlobj path} {
     if {![Rappture::library isvalid $xmlobj]} {
         error "bad value \"$xmlobj\": should be Rappture::library"
+    }
-    set path [$field get $cname.mesh]
     set m [$xmlobj element -as object $path]
     GetValue $m "xaxis.min" _xMin
 …
     GetValue $m "yaxis.max" _yMax
     GetSize $m "yaxis.numpoints" _yNum
-    set _compNum $extents
     foreach {key path} {
         group   about.group
 …
+        }
+    }
-    foreach {key} { axisorder } {
-        set str [$field get $cname.$key]
-        if {"" != $str} {
-            set _hints($key) $str
+        }
+    }
     itcl::delete object $m
+    set _values [blt::vector create \#auto]
+    set values [$field get "$cname.values"]
+    if { $values == "" } {
+        set values [$field get "$cname.zvalues"]
+    }
+    $_values set $values
+    set n [expr $_xNum * $_yNum * $_compNum]
+    if { [$_values length] != $n } {
+        error "wrong \# of values in \"$cname.values\": expected $n values, got [$_values length]"
+    }
+    set _numPoints [expr $_xNum * $_yNum]
+    if { $_numPoints == 0 } {
+        set _vtkdata ""
+        return
+    }
+    append out "DATASET STRUCTURED_POINTS\n"
+    append out "DIMENSIONS $_xNum $_yNum 1"
+    set xSpace [expr ($_xMax - $_xMin) / double($_xNum - 1)]
+    set ySpace [expr ($_yMax - $_yMin) / double($_yNum - 1)]
+    append out "SPACING $xSpace $ySpace 0\n"
+    append out "ORIGIN 0 0 0\n"
+    set _vtkdata $out
+}
 …
 # ----------------------------------------------------------------------
 itcl::body Rappture::Unirect2d::destructor {} {
+    if { $_values != "" } {
+        blt::vector destroy $_values

Context Navigation

Legend: