Index: Makefile
==================================================================
--- Makefile
+++ Makefile
@@ -5,11 +5,12 @@
 SRCFILES = common.scm items.scm launch.scm \
            ods.scm runconfig.scm server.scm configf.scm \
            db.scm keys.scm margs.scm megatest-version.scm \
            process.scm runs.scm tasks.scm tests.scm genexample.scm \
 	   fs-transport.scm http-transport.scm \
-           client.scm gutils.scm synchash.scm daemon.scm mt.scm dcommon.scm
+           client.scm gutils.scm synchash.scm daemon.scm mt.scm dcommon.scm \
+	   tree.scm
 
 GUISRCF  = dashboard-tests.scm dashboard-guimonitor.scm 
 
 OFILES   = $(SRCFILES:%.scm=%.o)
 GOFILES  = $(GUISRCF:%.scm=%.o)

Index: common.scm
==================================================================
--- common.scm
+++ common.scm
@@ -202,11 +202,11 @@
 	       (existing-coldat (assoc colkey colnames))
 	       (curr-rownum     (if existing-rowdat rownum (+ rownum 1)))
 	       (curr-colnum     (if existing-coldat colnum (+ colnum 1)))
 	       (new-rownames    (if existing-rowdat rownames (cons (list rowkey curr-rownum) rownames)))
 	       (new-colnames    (if existing-coldat colnames (cons (list colkey curr-colnum) colnames))))
-	  (debug:print-info 0 "Processing record: " hed )
+	  ;; (debug:print-info 0 "Processing record: " hed )
 	  (if proc (proc curr-rownum curr-colnum rowkey colkey value))
 	  (if (null? tal)
 	      (list new-rownames new-colnames)
 	      (loop (car tal)
 		    (cdr tal)
@@ -320,26 +320,26 @@
     ((red)    "223 33 49")
     ((grey)   "192 192 192")
     ((orange) "255 172 13")
     ((purple) "This is unfinished ...")))
 
-(define (common:get-color-for-state-status state status)
-  (case (string->symbol state)
-    ((COMPLETED)
-     (case (string->symbol status)
-       ((PASS)        "70  249 73")
-       ((WARN WAIVED) "255 172 13")
-       ((SKIP)        "230 230 0")
-       (else "223 33 49")))
-    ((LAUNCHED)         "101 123 142")
-    ((CHECK)            "255 100 50")
-    ((REMOTEHOSTSTART)  "50  130 195")
-    ((RUNNING)          "9   131 232")
-    ((KILLREQ)          "39  82  206")
-    ((KILLED)           "234 101 17")
-    ((NOT_STARTED)      "240 240 240")
-    (else               "192 192 192")))
+;; (define (common:get-color-for-state-status state status)
+;;   (case (string->symbol state)
+;;     ((COMPLETED)
+;;      (case (string->symbol status)
+;;        ((PASS)        "70  249 73")
+;;        ((WARN WAIVED) "255 172 13")
+;;        ((SKIP)        "230 230 0")
+;;        (else "223 33 49")))
+;;     ((LAUNCHED)         "101 123 142")
+;;     ((CHECK)            "255 100 50")
+;;     ((REMOTEHOSTSTART)  "50  130 195")
+;;     ((RUNNING)          "9   131 232")
+;;     ((KILLREQ)          "39  82  206")
+;;     ((KILLED)           "234 101 17")
+;;     ((NOT_STARTED)      "240 240 240")
+;;     (else               "192 192 192")))
 
 (define (common:get-color-from-status status)
   (cond
    ((equal? status "PASS")    "green")
    ((equal? status "FAIL")    "red")

Index: dashboard-tests.scm
==================================================================
--- dashboard-tests.scm
+++ dashboard-tests.scm
@@ -23,10 +23,11 @@
 (import (prefix sqlite3 sqlite3:))
 
 (declare (unit dashboard-tests))
 (declare (uses common))
 (declare (uses db))
+(declare (uses gutils))
 
 (include "common_records.scm")
 (include "db_records.scm")
 (include "run_records.scm")
 
@@ -62,12 +63,12 @@
 			       (lambda (testdat)
 				 (let ((newstatus (db:test-get-status testdat))
 				       (oldstatus (iup:attribute lbl "TITLE")))
 				   (if (not (equal? oldstatus newstatus))
 				       (begin
-					 (iup:attribute-set! lbl "FGCOLOR" (common:get-color-for-state-status (db:test-get-state testdat)
-												       (db:test-get-status testdat)))
+					 (iup:attribute-set! lbl "FGCOLOR" (car (gutils:get-color-for-state-status (db:test-get-state testdat)
+														   (db:test-get-status testdat))))
 					 (iup:attribute-set! lbl "TITLE" (db:test-get-status testdat)))))))
 	      lbl)
 	    (store-label "testcomment"
 			 (iup:label "TestComment                             "
 				    #:expand "HORIZONTAL")
@@ -188,11 +189,11 @@
 ;;                           state status teststeps
 (define *state-status* (vector #f #f #f))
 (define (update-state-status-buttons testdat)
   (let* ((state  (db:test-get-state  testdat))
 	 (status (db:test-get-status testdat))
-	 (color  (common:get-color-for-state-status state status)))
+	 (color  (car (gutils:get-color-for-state-status state status))))
     ((vector-ref *state-status* 0) state color)
     ((vector-ref *state-status* 1) status color)))
 
 ;;======================================================================
 ;; Set fields 

Index: dashboard.scm
==================================================================
--- dashboard.scm
+++ dashboard.scm
@@ -29,10 +29,11 @@
 (declare (uses process))
 (declare (uses launch))
 (declare (uses runs))
 (declare (uses dashboard-tests))
 (declare (uses dashboard-guimonitor))
+(declare (uses tree))
 (declare (uses dcommon))
 
 ;; (declare (uses dashboard-main))
 (declare (uses megatest-version))
 (declare (uses mt))
@@ -118,28 +119,29 @@
 (define *searchpatts*  (make-hash-table))
 (define *num-runs*      8)
 (define *tot-run-count* (cdb:remote-run db:get-num-runs #f "%"))
 ;; (define *tot-run-count* (db:get-num-runs *db* "%"))
 (define *last-update*   (current-seconds))
+(define *last-db-update-time* 0)
+(define *please-update-buttons* #t)
+(define *delayed-update* 0)
+
 (define *num-tests*     15)
 (define *start-run-offset*  0)
 (define *start-test-offset* 0)
 (define *examine-test-dat* (make-hash-table))
 (define *exit-started* #f)
 (define *status-ignore-hash* (make-hash-table))
 (define *state-ignore-hash*  (make-hash-table))
 
-(define *last-db-update-time* 0)
-(define *please-update-buttons* #t)
-(define *delayed-update* 0)
-
 (define *db-file-path* (conc *toppath* "/megatest.db"))
 
 (define *tests-sort-reverse* #f)
 (define *hide-empty-runs* #f)
 
 (define *current-tab-number* 0)
+(define *updaters* (make-hash-table))
 
 (debug:setup)
 
 (define uidat #f)
 
@@ -176,75 +178,46 @@
 	 (delta (map (lambda (a b)(abs (- a b))) c1 c2)))
     (null? (filter (lambda (x)(> x 3)) delta))))
 
 ;; keypatts: ( (KEY1 "abc%def")(KEY2 "%") )
 (define (update-rundat runnamepatt numruns testnamepatt keypatts)
-  (let ((modtime             (file-modification-time *db-file-path*))
-	(referenced-run-ids '()))
-    (if (or (and (> modtime *last-db-update-time*)
-		 (> (current-seconds)(+ *last-db-update-time* 5)))
-	    (> *delayed-update* 0))
-	;;
-	;; Run this stuff only when the megatest.db file has changed
-	;;
-	(let ((full-run (> (random 100) 75))) ;; 25% of the time do a full refresh
-	  (debug:print-info 4 "update-rundat runnamepatt: " runnamepatt " numruns: " numruns " testnamepatt: " testnamepatt " keypatts: " keypatts)
-	  (set! *please-update-buttons* #t)
-	  (set! *last-db-update-time* modtime)
-	  (set! *delayed-update* (- *delayed-update* 1))
-	  (let* ((allruns     (cdb:remote-run db:get-runs #f runnamepatt numruns ;; (+ numruns 1) ;; (/ numruns 2))
-					   *start-run-offset* keypatts))
-		 (header      (db:get-header allruns))
-		 (runs        (db:get-rows   allruns))
-		 (result      '())
-		 (maxtests    0)
-		 (states      (hash-table-keys *state-ignore-hash*))
-		 (statuses    (hash-table-keys *status-ignore-hash*)))
-	    ;; (thread-sleep! 0.1) ;; give some time to other threads
-	    (debug:print 6 "update-rundat, got " (length runs) " runs")
-	    (if (> (+ *last-update* 300) (current-seconds)) ;; every five minutes
-		(begin
-		  (set! *last-update* (current-seconds))
-		  (set! *tot-run-count* (length runs))))
-	    ;; 
-	    ;; trim runs to only those that are changing often here
-	    ;; 
-	    (for-each (lambda (run)
-			(let* ((run-id   (db:get-value-by-header run header "id"))
-			       (tests    (let ((tsts (mt:get-tests-for-run run-id testnamepatt states statuses)))
-					   (if *tests-sort-reverse* (reverse tsts) tsts)))
-			       (key-vals (cdb:remote-run db:get-key-vals #f run-id)))
-			  ;; Not sure this is needed?
-			  (set! referenced-run-ids (cons run-id referenced-run-ids))
-			  (if (> (length tests) maxtests)
-			      (set! maxtests (length tests)))
-			  (if (or (not *hide-empty-runs*) ;; this reduces the data burden when set
-				  (not (null? tests)))
-			      (let ((dstruct (vector run tests key-vals)))
-				;;
-				;; compare the tests with the tests in *allruns-by-id* same run-id 
-				;; if different then increment value in *runchangerate*
-				;;
-				(hash-table-set! *allruns-by-id* run-id dstruct)
-				(set! result (cons dstruct result))))))
-		      runs)
-	    
-	    ;;
-	    ;; if full-run use referenced-run-ids to delete data in *all-runs-by-id* and *runchangerate*
-	    ;;
-
-	    (set! *header*  header)
-	    (set! *allruns* result)
-	    (debug:print 6 "*allruns* has " (length *allruns*) " runs")
-	    ;; (set! *tot-run-count* (+ 1 (length *allruns*)))
-	    maxtests))
-	;; 
-	;; Run this if the megatest.db file did not get touched
-	;;
-	(begin
-	  
-	  *num-tests*)))) ;; FIXME, naughty coding eh?
+  (let* ((referenced-run-ids '())
+	 (allruns     (cdb:remote-run db:get-runs #f runnamepatt numruns ;; (+ numruns 1) ;; (/ numruns 2))
+				      *start-run-offset* keypatts))
+	 (header      (db:get-header allruns))
+	 (runs        (db:get-rows   allruns))
+	 (result      '())
+	 (maxtests    0)
+	 (states      (hash-table-keys *state-ignore-hash*))
+	 (statuses    (hash-table-keys *status-ignore-hash*)))
+    ;; 
+    ;; trim runs to only those that are changing often here
+    ;; 
+    (for-each (lambda (run)
+		(let* ((run-id   (db:get-value-by-header run header "id"))
+		       (tests    (let ((tsts (mt:get-tests-for-run run-id testnamepatt states statuses)))
+				   (if *tests-sort-reverse* (reverse tsts) tsts)))
+		       (key-vals (cdb:remote-run db:get-key-vals #f run-id)))
+		  ;; Not sure this is needed?
+		  (set! referenced-run-ids (cons run-id referenced-run-ids))
+		  (if (> (length tests) maxtests)
+		      (set! maxtests (length tests)))
+		  (if (or (not *hide-empty-runs*) ;; this reduces the data burden when set
+			  (not (null? tests)))
+		      (let ((dstruct (vector run tests key-vals)))
+			;;
+			;; compare the tests with the tests in *allruns-by-id* same run-id 
+			;; if different then increment value in *runchangerate*
+			;;
+			(hash-table-set! *allruns-by-id* run-id dstruct)
+			(set! result (cons dstruct result))))))
+	      runs)
+
+    (set! *header*  header)
+    (set! *allruns* result)
+    (debug:print-info 6 "*allruns* has " (length *allruns*) " runs")
+    maxtests))
 
 (define *collapsed* (make-hash-table))
 ; (define *row-lookup* (make-hash-table)) ;; testname => (rownum lableobj)
 
 (define (toggle-hide lnum) ; fulltestname)
@@ -326,103 +299,101 @@
 	(iup:attribute-set! lbl "FGCOLOR" (if (hash-table-ref/default *collapsed* newval #f) "0 112 112" "0 0 0"))
 	(if (< i maxn)
 	    (loop (+ i 1)))))))
 
 (define (update-buttons uidat numruns numtests)
-  (if *please-update-buttons*
-      (let* ((runs        (if (> (length *allruns*) numruns)
-			      (take-right *allruns* numruns)
-			      (pad-list *allruns* numruns)))
-	     (lftcol      (dboard:uidat-get-lftcol uidat))
-	     (tableheader (dboard:uidat-get-header uidat))
-	     (table       (dboard:uidat-get-runsvec uidat))
-	     (coln        0))
-	(set! *please-update-buttons* #f)
-	(set! *alltestnamelst* '())
-	;; create a concise list of test names
-	(for-each
-	 (lambda (rundat)
-	   (if (vector? rundat)
-	       (let* ((testdat   (vector-ref rundat 1))
-		      (testnames (map test:test-get-fullname testdat)))
-		 (if (not (and *hide-empty-runs*
-			       (null? testnames)))
-		     (for-each (lambda (testname)
-				 (if (not (member testname *alltestnamelst*))
-				     (begin
-				       (set! *alltestnamelst* (append *alltestnamelst* (list testname))))))
-			       testnames)))))
-	 runs)
-
-	(set! *alltestnamelst* (collapse-rows *alltestnamelst*)) ;;; argh. please clean up this sillyness
-	(set! *alltestnamelst* (let ((xl (if (> (length *alltestnamelst*) *start-test-offset*)
-					     (drop *alltestnamelst* *start-test-offset*)
-					     '())))
-				 (append xl (make-list (- *num-tests* (length xl)) ""))))
-	(update-labels uidat)
-	(for-each
-	 (lambda (rundat)
-	   (if (not rundat) ;; handle padded runs
-	       ;;           ;; id run-id testname state status event-time host cpuload diskfree uname rundir item-path run-duration
-	       (set! rundat (vector (make-vector 20 #f) '() (map (lambda (x) "") *keys*))));; 3)))
-	   (let* ((run      (vector-ref rundat 0))
-		  (testsdat (vector-ref rundat 1))
-		  (key-val-dat (vector-ref rundat 2))
-		  (run-id   (db:get-value-by-header run *header* "id"))
-		  (key-vals (append key-val-dat
-				    (list (let ((x (db:get-value-by-header run *header* "runname")))
-					    (if x x "")))))
-		  (run-key  (string-intersperse key-vals "\n")))
-
-	     ;; fill in the run header key values
-	     (let ((rown      0)
-		   (headercol (vector-ref tableheader coln)))
-	       (for-each (lambda (kval)
-			   (let* ((labl      (vector-ref headercol rown)))
-			     (if (not (equal? kval (iup:attribute labl "TITLE")))
-				 (iup:attribute-set! (vector-ref headercol rown) "TITLE" kval))
-			     (set! rown (+ rown 1))))
-			 key-vals))
-
-	     ;; For this run now fill in the buttons for each test
-	     (let ((rown 0)
-		   (columndat  (vector-ref table coln)))
-	       (for-each
-		(lambda (testname)
-		  (let ((buttondat  (hash-table-ref/default *buttondat* (mkstr coln rown) #f)))
-		    (if buttondat
-			(let* ((test       (let ((matching (filter 
-							    (lambda (x)(equal? (test:test-get-fullname x) testname))
-							    testsdat)))
-					     (if (null? matching)
-						 (vector -1 -1 "" "" "" 0 "" "" 0 "" "" "" 0 "" "")
-						 (car matching))))
-			       (testname   (db:test-get-testname  test))
-			       (itempath   (db:test-get-item-path test))
-			       (testfullname (test:test-get-fullname test))
-			       (teststatus (db:test-get-status   test))
-			       (teststate  (db:test-get-state    test))
-			       (teststart  (db:test-get-event_time test))
-			       (runtime    (db:test-get-run_duration test))
-			       (buttontxt  (if (equal? teststate "COMPLETED") teststatus teststate))
-			       (button     (vector-ref columndat rown))
-			       (color      (common:get-color-for-state-status teststate teststatus))
-			       (curr-color (vector-ref buttondat 1)) ;; (iup:attribute button "BGCOLOR"))
-			       (curr-title (vector-ref buttondat 2))) ;; (iup:attribute button "TITLE")))
-			  (if (not (equal? curr-color color))
-			      (iup:attribute-set! button "BGCOLOR" color))
-			  (if (not (equal? curr-title buttontxt))
-			      (iup:attribute-set! button "TITLE"   buttontxt))
-			  (vector-set! buttondat 0 run-id)
-			  (vector-set! buttondat 1 color)
-			  (vector-set! buttondat 2 buttontxt)
-			  (vector-set! buttondat 3 test)
-			  (vector-set! buttondat 4 run-key)))
-		    (set! rown (+ rown 1))))
-		*alltestnamelst*))
-	     (set! coln (+ coln 1))))
-	 runs))))
+  (let* ((runs        (if (> (length *allruns*) numruns)
+			  (take-right *allruns* numruns)
+			  (pad-list *allruns* numruns)))
+	 (lftcol      (dboard:uidat-get-lftcol uidat))
+	 (tableheader (dboard:uidat-get-header uidat))
+	 (table       (dboard:uidat-get-runsvec uidat))
+	 (coln        0))
+    (set! *alltestnamelst* '())
+    ;; create a concise list of test names
+    (for-each
+     (lambda (rundat)
+       (if (vector? rundat)
+	   (let* ((testdat   (vector-ref rundat 1))
+		  (testnames (map test:test-get-fullname testdat)))
+	     (if (not (and *hide-empty-runs*
+			   (null? testnames)))
+		 (for-each (lambda (testname)
+			     (if (not (member testname *alltestnamelst*))
+				 (begin
+				   (set! *alltestnamelst* (append *alltestnamelst* (list testname))))))
+			   testnames)))))
+     runs)
+
+    (set! *alltestnamelst* (collapse-rows *alltestnamelst*)) ;;; argh. please clean up this sillyness
+    (set! *alltestnamelst* (let ((xl (if (> (length *alltestnamelst*) *start-test-offset*)
+					 (drop *alltestnamelst* *start-test-offset*)
+					 '())))
+			     (append xl (make-list (- *num-tests* (length xl)) ""))))
+    (update-labels uidat)
+    (for-each
+     (lambda (rundat)
+       (if (not rundat) ;; handle padded runs
+	   ;;           ;; id run-id testname state status event-time host cpuload diskfree uname rundir item-path run-duration
+	   (set! rundat (vector (make-vector 20 #f) '() (map (lambda (x) "") *keys*))));; 3)))
+       (let* ((run      (vector-ref rundat 0))
+	      (testsdat (vector-ref rundat 1))
+	      (key-val-dat (vector-ref rundat 2))
+	      (run-id   (db:get-value-by-header run *header* "id"))
+	      (key-vals (append key-val-dat
+				(list (let ((x (db:get-value-by-header run *header* "runname")))
+					(if x x "")))))
+	      (run-key  (string-intersperse key-vals "\n")))
+	 
+	 ;; fill in the run header key values
+	 (let ((rown      0)
+	       (headercol (vector-ref tableheader coln)))
+	   (for-each (lambda (kval)
+		       (let* ((labl      (vector-ref headercol rown)))
+			 (if (not (equal? kval (iup:attribute labl "TITLE")))
+			     (iup:attribute-set! (vector-ref headercol rown) "TITLE" kval))
+			 (set! rown (+ rown 1))))
+		     key-vals))
+	 
+	 ;; For this run now fill in the buttons for each test
+	 (let ((rown 0)
+	       (columndat  (vector-ref table coln)))
+	   (for-each
+	    (lambda (testname)
+	      (let ((buttondat  (hash-table-ref/default *buttondat* (mkstr coln rown) #f)))
+		(if buttondat
+		    (let* ((test       (let ((matching (filter 
+							(lambda (x)(equal? (test:test-get-fullname x) testname))
+							testsdat)))
+					 (if (null? matching)
+					     (vector -1 -1 "" "" "" 0 "" "" 0 "" "" "" 0 "" "")
+					     (car matching))))
+			   (testname   (db:test-get-testname  test))
+			   (itempath   (db:test-get-item-path test))
+			   (testfullname (test:test-get-fullname test))
+			   (teststatus (db:test-get-status   test))
+			   (teststate  (db:test-get-state    test))
+			   (teststart  (db:test-get-event_time test))
+			   (runtime    (db:test-get-run_duration test))
+			   (buttontxt  (if (equal? teststate "COMPLETED") teststatus teststate))
+			   (button     (vector-ref columndat rown))
+			   (color      (car (gutils:get-color-for-state-status teststate teststatus)))
+			   (curr-color (vector-ref buttondat 1)) ;; (iup:attribute button "BGCOLOR"))
+			   (curr-title (vector-ref buttondat 2))) ;; (iup:attribute button "TITLE")))
+		      (if (not (equal? curr-color color))
+			  (iup:attribute-set! button "BGCOLOR" color))
+		      (if (not (equal? curr-title buttontxt))
+			  (iup:attribute-set! button "TITLE"   buttontxt))
+		      (vector-set! buttondat 0 run-id)
+		      (vector-set! buttondat 1 color)
+		      (vector-set! buttondat 2 buttontxt)
+		      (vector-set! buttondat 3 test)
+		      (vector-set! buttondat 4 run-key)))
+		(set! rown (+ rown 1))))
+	    *alltestnamelst*))
+	 (set! coln (+ coln 1))))
+     runs)))
 
 (define (mkstr . x)
   (string-intersperse (map conc x) ","))
 
 (define (update-search x val)
@@ -664,11 +635,154 @@
 	;; #:title "Disks Areas"
 	(dcommon:section-matrix rawconfig "disks" "Disk area" "Path"))))
      (iup:frame
       #:title "Run statistics"
       (dcommon:run-stats)))))
-   
+
+;;======================================================================
+;; R U N
+;;======================================================================
+;;
+;; display and manage a single run at a time
+
+(define (tree-path->run-id path)
+  (if (not (null? path))
+      (hash-table-ref/default (dboard:data-get-path-run-ids *data*) path #f)
+      #f))
+
+(define dashboard:update-run-summary-tab #f)
+
+;; (define (tests window-id)
+(define (dashboard:one-run)
+  (let* ((tb      (iup:treebox
+		   #:value 0
+		   #:name "Runs"
+		   #:expand "YES"
+		   #:selection-cb
+		   (lambda (obj id state)
+		     ;; (print "obj: " obj ", id: " id ", state: " state)
+		     (let* ((run-path (tree:node->path obj id))
+			    (run-id   (tree-path->run-id (cdr run-path))))
+		       (if run-id
+			   (begin
+			     (dboard:data-set-curr-run-id! *data* run-id)
+			     (dashboard:update-run-summary-tab)))
+		       ;; (print "path: " (tree:node->path obj id) " run-id: " run-id)
+		       ))))
+	 (run-matrix (iup:matrix
+		      #:expand "YES"))
+	 (updater  (lambda ()
+		     (let* ((runs-dat     (mt:get-runs-by-patt *keys* "%" #f))
+			    (runs-header  (vector-ref runs-dat 0)) ;; 0 is header, 1 is list of records
+			    (run-id       (dboard:data-get-curr-run-id *data*))
+			    (tests-dat    (let ((tdat (mt:get-tests-for-run run-id "%" '() '()
+									    qryvals: "id,testname,item_path,state,status"))) ;; get 'em all
+					    (sort tdat (lambda (a b)
+							 (string<= (vector-ref a 2)(vector-ref b 2))))))
+			    (tests-mindat (dcommon:minimize-test-data tests-dat))
+			    (indices      (common:sparse-list-generate-index tests-mindat)) ;;  proc: set-cell))
+			    (row-indices  (cadr indices))
+			    (col-indices  (car indices))
+			    (max-row      (if (null? row-indices) 1 (apply max (map cadr row-indices))))
+			    (max-col      (if (null? col-indices) 1 (apply max (map cadr col-indices))))
+			    (max-visible  (max (- *num-tests* 15) 3)) ;; *num-tests* is proportional to the size of the window
+			    (numrows      1)
+			    (numcols      1)
+			    (changed      #f)
+			    (runs-hash    (let ((ht (make-hash-table)))
+					    (for-each (lambda (run)
+							(hash-table-set! ht (db:get-value-by-header run runs-header "id") run))
+						      (vector-ref runs-dat 1))
+					    ht))
+			    (run-ids      (sort (filter number? (hash-table-keys runs-hash))
+						(lambda (a b)
+						  (let* ((record-a (hash-table-ref runs-hash a))
+							 (record-b (hash-table-ref runs-hash b))
+							 (time-a   (db:get-value-by-header record-a runs-header "event_time"))
+							 (time-b   (db:get-value-by-header record-b runs-header "event_time")))
+						    (< time-a time-b))))))
+		       
+		       ;; (iup:attribute-set! tb "VALUE" "0")
+		       ;; (iup:attribute-set! tb "NAME" "Runs")
+		       ;; Update the runs tree
+		       (for-each (lambda (run-id)
+				   (let* ((run-record (hash-table-ref/default runs-hash run-id #f))
+					  (key-vals   (map (lambda (key)(db:get-value-by-header run-record runs-header key))
+							   *keys*))
+					  (run-name   (db:get-value-by-header run-record runs-header "runname"))
+					  (col-name   (conc (string-intersperse key-vals "\n") "\n" run-name))
+					  (run-path   (append key-vals (list run-name))))
+				     (hash-table-set! (dboard:data-get-run-keys *data*) run-id run-path)
+				     ;; (iup:attribute-set! (dboard:data-get-runs-matrix *data*)
+				     ;;    		 (conc rownum ":" colnum) col-name)
+				     ;; (hash-table-set! runid-to-col run-id (list colnum run-record))
+				     ;; Here we update the tests treebox and tree keys
+				     (tree:add-node tb "Runs" (append key-vals (list run-name))
+						    userdata: (conc "run-id: " run-id))
+				     (let ((path ;;(string-intersperse "/" 
+					    (append key-vals (list run-name))))
+				       (hash-table-set! (dboard:data-get-path-run-ids *data*) path run-id))
+				     ;; (set! colnum (+ colnum 1))
+				     ))
+				 run-ids)
+		       (iup:attribute-set! run-matrix "CLEARVALUE" "CONTENTS")
+		       (iup:attribute-set! run-matrix "CLEARATTRIB" "CONTENTS")
+		       (iup:attribute-set! run-matrix "NUMCOL" max-col )
+		       (iup:attribute-set! run-matrix "NUMLIN" (if (< max-row max-visible) max-visible max-row)) ;; min of 20
+		       ;; (iup:attribute-set! run-matrix "NUMCOL_VISIBLE" max-col)
+		       ;; (iup:attribute-set! run-matrix "NUMLIN_VISIBLE" (if (> max-row max-visible) max-visible max-row))
+		       
+		       ;; Row labels
+		       (for-each (lambda (ind)
+				   (let* ((name (car ind))
+					  (num  (cadr ind))
+					  (key  (conc num ":0")))
+				     (if (not (equal? (iup:attribute run-matrix key) name))
+					 (begin
+					   (set! changed #t)
+					   (iup:attribute-set! run-matrix key name)))))
+				 row-indices)
+		       
+		       ;; Col labels
+		       (for-each (lambda (ind)
+				   (let* ((name (car ind))
+					  (num  (cadr ind))
+					  (key  (conc "0:" num)))
+				     (if (not (equal? (iup:attribute run-matrix key) name))
+					 (begin
+					   (set! changed #t)
+					   (iup:attribute-set! run-matrix key name)
+					   (iup:attribute-set! run-matrix "FITTOTEXT" (conc "C" num))))))
+				 col-indices)
+		       
+		       ;; Cell contents
+		       (for-each (lambda (entry)
+				   (let* ((row-name  (cadr entry))
+					  (col-name  (car entry))
+					  (valuedat  (caddr entry))
+					  (test-id   (list-ref valuedat 0))
+					  (test-name row-name) ;; (list-ref valuedat 1))
+					  (item-path col-name) ;; (list-ref valuedat 2))
+					  (state     (list-ref valuedat 1))
+					  (status    (list-ref valuedat 2))
+					  (value     (gutils:get-color-for-state-status state status))
+					  (row-num   (cadr (assoc row-name row-indices)))
+					  (col-num   (cadr (assoc col-name col-indices)))
+					  (key       (conc row-num ":" col-num)))
+				     (if (not (equal? (iup:attribute run-matrix key) (cadr value)))
+					 (begin
+					   (set! changed #t)
+					   (iup:attribute-set! run-matrix key (cadr value))
+					   (iup:attribute-set! run-matrix (conc "BGCOLOR" key) (car value))))))
+				 tests-mindat)
+		       (if changed (iup:attribute-set! run-matrix "REDRAW" "ALL"))))))
+    (set! dashboard:update-run-summary-tab updater)
+    (dboard:data-set-runs-tree! *data* tb)
+    (iup:split
+     tb
+     run-matrix)))
+
 ;;======================================================================
 ;; R U N S 
 ;;======================================================================
 
 (define (make-dashboard-buttons nruns ntests keynames)
@@ -858,19 +972,22 @@
 					(apply iup:hbox (reverse hdrlst))
 					(apply iup:hbox (reverse bdylst))))))
 			 controls))
 	     (tabs (iup:tabs
 		    #:tabchangepos-cb (lambda (obj curr prev)
+					(set! *please-update-buttons* #t)
 					(set! *current-tab-number* curr))
 		    (dashboard:summary)
 		    runs-view
+		    (dashboard:one-run)
 		    (dashboard:run-controls)
 		    )))
 	;; (set! (iup:callback tabs tabchange-cb:) (lambda (a b c)(print "SWITCHED TO TAB: " a " " b " " c)))
 	(iup:attribute-set! tabs "TABTITLE0" "Summary")
 	(iup:attribute-set! tabs "TABTITLE1" "Runs")
-	(iup:attribute-set! tabs "TABTITLE2" "Run Control")
+	(iup:attribute-set! tabs "TABTITLE2" "Run Summary")
+	(iup:attribute-set! tabs "TABTITLE3" "Run Control")
 	tabs)))
      (vector keycol lftcol header runsvec)))
 
 (if (or (args:get-arg "-rows")
 	(get-environment-variable "DASHBOARDROWS" ))
@@ -893,26 +1010,54 @@
   (> (file-modification-time (conc *toppath* "/megatest.db")) *last-db-update-time*))
 
 (define (dashboard:set-db-update-time)
   (set! *last-db-update-time* (file-modification-time (conc *toppath* "/megatest.db"))))
 
+(define (dashboard:recalc modtime please-update-buttons last-db-update-time)
+  (or please-update-buttons
+      (and (> modtime last-db-update-time)
+	   (> (current-seconds)(+ last-db-update-time 1)))))
+
 (define (dashboard:run-update x)
-  (case *current-tab-number* 
-    ((0) (dashboard:update-summary-tab))
-    ((1) ;; The runs table is active
-     (update-buttons uidat *num-runs* *num-tests*)
-     (update-rundat (hash-table-ref/default *searchpatts* "runname" "%") *num-runs*
-		    (hash-table-ref/default *searchpatts* "test-name" "%/%")
-		    ;; (hash-table-ref/default *searchpatts* "item-name" "%")
-		    (let ((res '()))
-		      (for-each (lambda (key)
-				  (if (not (equal? key "runname"))
-				      (let ((val (hash-table-ref/default *searchpatts* key #f)))
-					(if val (set! res (cons (list key val) res))))))
-				*dbkeys*)
-		      res)) ;; (dashboard:set-db-update-time)
-     )))
+  (let* ((modtime         (file-modification-time *db-file-path*))
+	 (run-update-time (current-seconds))
+	 (recalc          (dashboard:recalc modtime *please-update-buttons* *last-db-update-time*)))
+    (if recalc
+	(begin
+	  (case *current-tab-number* 
+	    ((0) 
+	     ;; (thread-sleep! 0.25) ;; 
+	     (dashboard:update-summary-tab))
+	    ((1) ;; The runs table is active
+	     (update-rundat (hash-table-ref/default *searchpatts* "runname" "%") *num-runs*
+			    (hash-table-ref/default *searchpatts* "test-name" "%/%")
+			    ;; (hash-table-ref/default *searchpatts* "item-name" "%")
+			    (let ((res '()))
+			      (for-each (lambda (key)
+					  (if (not (equal? key "runname"))
+					      (let ((val (hash-table-ref/default *searchpatts* key #f)))
+						(if val (set! res (cons (list key val) res))))))
+					*dbkeys*)
+			      res))
+	     (update-buttons uidat *num-runs* *num-tests*))
+	    ((2)
+	     (dashboard:update-run-summary-tab))
+	    (else
+	     (let ((updater (hash-table-ref/default *updaters* *current-tab-number* #f)))
+	       (if updater (updater)))))
+	  (set! *please-update-buttons* #f)
+	  (set! *last-db-update-time* modtime)
+	  (set! *last-update* run-update-time)))))
+
+;;======================================================================
+;; The heavy lifting starts here
+;;======================================================================
+
+;; ease debugging by loading ~/.megatestrc
+(let ((debugcontrolf (conc (get-environment-variable "HOME") "/.megatestrc")))
+  (if (file-exists? debugcontrolf)
+      (load debugcontrolf)))
 
 (cond 
  ((args:get-arg "-run")
   (let ((runid (string->number (args:get-arg "-run"))))
     (if runid
@@ -936,9 +1081,9 @@
  (else
   (set! uidat (make-dashboard-buttons *num-runs* *num-tests* *dbkeys*))
   (iup:callback-set! *tim*
 		     "ACTION_CB"
 		     (lambda (x)
-		       (dashboard:run-update x)))))
-		       ;(print x)))))
+		       (dashboard:run-update x)
+		       1))))
 
 (iup:main-loop)

Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -691,15 +691,15 @@
        (let* ((stateparts (string-split state "|"))
 	      (newstate   (conc (car stateparts) "\n" (cadr stateparts))))
 	 (hash-table-set! totals newstate (+ (hash-table-ref/default totals newstate 0) count))
 	 (set! res (cons (list runname newstate count) res))))
      db
-    "SELECT runname,t.state||'|'||t.status AS s,count(t.id) FROM runs AS r INNER JOIN tests AS t ON r.id=t.run_id GROUP BY s,runname ORDER BY r.event_time DESC;" )
-    (set! res (reverse res))
+    "SELECT runname,t.state||'|'||t.status AS s,count(t.id) FROM runs AS r INNER JOIN tests AS t ON r.id=t.run_id GROUP BY s,runname ORDER BY r.event_time,s DESC;" )
+    ;; (set! res (reverse res))
     (for-each (lambda (state)
 		(set! res (cons (list "Totals" state (hash-table-ref totals state)) res)))
-	      (hash-table-keys totals))
+	      (sort (hash-table-keys totals) string>=))
     res))
 
 ;; db:get-runs-by-patt
 ;; get runs by list of criteria
 ;; register a test run with the db
@@ -713,11 +713,11 @@
 	 (header   (cadr tmp))
 	 (res     '())
 	 (key-patt "")
 	 (runwildtype (if (substring-index "%" runnamepatt) "like" "glob"))
 	 (qry-str  #f)
-	 (keyvals  (keys:target->keyval keys targpatt)))
+	 (keyvals  (if targpatt (keys:target->keyval keys targpatt) '())))
     (for-each (lambda (keyval)
 		(let* ((key    (car keyval))
 		       (patt   (cadr keyval))
 		       (fulkey (conc ":" key))
 		       (wildtype (if (substring-index "%" patt) "like" "glob")))
@@ -725,11 +725,11 @@
 		      (set! key-patt (conc key-patt " AND " key " " wildtype " '" patt "'"))
 		      (begin
 			(debug:print 0 "ERROR: searching for runs with no pattern set for " fulkey)
 			(exit 6)))))
 	      keyvals)
-    (set! qry-str (conc "SELECT " keystr " FROM runs WHERE runname " runwildtype " ? " key-patt " ORDER BY event_time;"))
+    (set! qry-str (conc "SELECT " keystr " FROM runs WHERE state != 'deleted' AND runname " runwildtype " ? " key-patt " ORDER BY event_time;"))
     (debug:print-info 4 "runs:get-runs-by-patt qry=" qry-str " " runnamepatt)
     (sqlite3:for-each-row 
      (lambda (a . r)
        (set! res (cons (list->vector (cons a r)) res)))
      db 
@@ -849,14 +849,15 @@
 ;; i.e. these lists define what to NOT show.
 ;; states and statuses are required to be lists, empty is ok
 ;; not-in #t = above behaviour, #f = must match
 (define (db:get-tests-for-run db run-id testpatt states statuses offset limit not-in sort-by
 			      #!key
-			      (qryvals "id,run_id,testname,state,status,event_time,host,cpuload,diskfree,uname,rundir,item_path,run_duration,final_logf,comment")
+			      (qryvals #f)
 			      )
   (debug:print-info 11 "db:get-tests-for-run START run-id=" run-id ", testpatt=" testpatt ", states=" states ", statuses=" statuses ", not-in=" not-in ", sort-by=" sort-by)
-  (let* ((res '())
+  (let* ((qryvals         (if qryvals qryvals "id,run_id,testname,state,status,event_time,host,cpuload,diskfree,uname,rundir,item_path,run_duration,final_logf,comment"))
+	 (res            '())
 	 ;; if states or statuses are null then assume match all when not-in is false
 	 (states-qry      (if (null? states) 
 			      #f
 			      (conc " state "  
 				    (if not-in

Index: dcommon.scm
==================================================================
--- dcommon.scm
+++ dcommon.scm
@@ -25,10 +25,232 @@
 (include "db_records.scm")
 (include "key_records.scm")
 
 ;; yes, this is non-ideal 
 (define dashboard:update-summary-tab #f)
+
+;;======================================================================
+;; C O M M O N   D A T A   S T R U C T U R E
+;;======================================================================
+;; 
+;; A single data structure for all the data used in a dashboard.
+;; Share this structure between newdashboard and dashboard with the 
+;; intent of converging on a single app.
+;;
+(define *data* (make-vector 15 #f))
+(define (dboard:data-get-runs          vec)    (vector-ref  vec 0))
+(define (dboard:data-get-tests         vec)    (vector-ref  vec 1))
+(define (dboard:data-get-runs-matrix   vec)    (vector-ref  vec 2))
+(define (dboard:data-get-tests-tree    vec)    (vector-ref  vec 3))
+(define (dboard:data-get-run-keys      vec)    (vector-ref  vec 4))
+(define (dboard:data-get-curr-test-ids vec)    (vector-ref  vec 5))
+;; (define (dboard:data-get-test-details  vec)    (vector-ref  vec 6))
+(define (dboard:data-get-path-test-ids vec)    (vector-ref  vec 7))
+(define (dboard:data-get-updaters      vec)    (vector-ref  vec 8))
+(define (dboard:data-get-path-run-ids  vec)    (vector-ref  vec 9))
+(define (dboard:data-get-curr-run-id   vec)    (vector-ref  vec 10))
+(define (dboard:data-get-runs-tree     vec)    (vector-ref  vec 11))
+
+(define (dboard:data-set-runs!          vec val)(vector-set! vec 0 val))
+(define (dboard:data-set-tests!         vec val)(vector-set! vec 1 val))
+(define (dboard:data-set-runs-matrix!   vec val)(vector-set! vec 2 val))
+(define (dboard:data-set-tests-tree!    vec val)(vector-set! vec 3 val))
+(define (dboard:data-set-run-keys!      vec val)(vector-set! vec 4 val))
+(define (dboard:data-set-curr-test-ids! vec val)(vector-set! vec 5 val))
+;; (define (dboard:data-set-test-details!  vec val)(vector-set! vec 6 val))
+(define (dboard:data-set-path-test-ids! vec val)(vector-set! vec 7 val))
+(define (dboard:data-set-updaters!      vec val)(vector-set! vec 8 val))
+(define (dboard:data-set-path-run-ids!  vec val)(vector-set! vec 9 val))
+(define (dboard:data-set-curr-run-id!   vec val)(vector-set! vec 10 val))
+(define (dboard:data-set-runs-tree!     vec val)(vector-set! vec 12 val))
+
+(dboard:data-set-run-keys! *data* (make-hash-table))
+
+;; List of test ids being viewed in various panels
+(dboard:data-set-curr-test-ids! *data* (make-hash-table))
+
+;; Look up test-ids by (key1 key2 ... testname [itempath])
+(dboard:data-set-path-test-ids! *data* (make-hash-table))
+
+;; Look up run-ids by ??
+(dboard:data-set-path-run-ids! *data* (make-hash-table))
+
+;;======================================================================
+;; P R O C E S S   R U N S
+;;======================================================================
+
+;; MOVE THIS INTO *data*
+(define *cachedata* (make-hash-table))
+(hash-table-set! *cachedata* "runid-to-col"    (make-hash-table))
+(hash-table-set! *cachedata* "testname-to-row" (make-hash-table))
+
+;; TO-DO
+;;  1. Make "data" hash-table hierarchial store of all displayed data
+;;  2. Update synchash to understand "get-runs", "get-tests" etc.
+;;  3. Add extraction of filters to synchash calls
+;;
+;; Mode is 'full or 'incremental for full refresh or incremental refresh
+(define (run-update keys data runname keypatts testpatt states statuses mode window-id)
+  (let* (;; count and offset => #f so not used
+	 ;; the synchash calls modify the "data" hash
+	 (get-runs-sig    (conc (client:get-signature) " get-runs"))
+	 (get-tests-sig   (conc (client:get-signature) " get-tests"))
+	 (get-details-sig (conc (client:get-signature) " get-test-details"))
+
+	 ;; test-ids to get and display are indexed on window-id in curr-test-ids hash
+	 (test-ids        (hash-table-values (dboard:data-get-curr-test-ids *data*)))
+
+ 	 (run-changes     (synchash:client-get 'db:get-runs get-runs-sig (length keypatts) data runname #f #f keypatts))
+	 (tests-detail-changes (if (not (null? test-ids))
+				   (synchash:client-get 'db:get-test-info-by-ids get-details-sig 0  data test-ids)
+				   '()))
+
+	 ;; Now can calculate the run-ids
+	 (run-hash    (hash-table-ref/default data get-runs-sig #f))
+	 (run-ids     (if run-hash (filter number? (hash-table-keys run-hash)) '()))
+
+	 (test-changes (synchash:client-get 'db:get-tests-for-runs-mindata get-tests-sig 0 data run-ids testpatt states statuses))
+	 (runs-hash    (hash-table-ref/default data get-runs-sig #f))
+	 (header       (hash-table-ref/default runs-hash "header" #f))
+	 (run-ids      (sort (filter number? (hash-table-keys runs-hash))
+			     (lambda (a b)
+			       (let* ((record-a (hash-table-ref runs-hash a))
+				      (record-b (hash-table-ref runs-hash b))
+				      (time-a   (db:get-value-by-header record-a header "event_time"))
+				      (time-b   (db:get-value-by-header record-b header "event_time")))
+				 (> time-a time-b)))
+			     ))
+	 (runid-to-col    (hash-table-ref *cachedata* "runid-to-col"))
+	 (testname-to-row (hash-table-ref *cachedata* "testname-to-row")) 
+	 (colnum       1)
+	 (rownum       0)) ;; rownum = 0 is the header
+;; (debug:print 0 "test-ids " test-ids ", tests-detail-changes " tests-detail-changes)
+    
+	 ;; tests related stuff
+	 ;; (all-testnames (delete-duplicates (map db:test-get-testname test-changes))))
+
+    ;; Given a run-id and testname/item_path calculate a cell R:C
+
+    ;; NOTE: Also build the test tree browser and look up table
+    ;;
+    ;; Each run is unique on its keys and runname or run-id, store in hash on colnum
+    (for-each (lambda (run-id)
+		(let* ((run-record (hash-table-ref/default runs-hash run-id #f))
+		       (key-vals   (map (lambda (key)(db:get-value-by-header run-record header key))
+					keys))
+		       (run-name   (db:get-value-by-header run-record header "runname"))
+		       (col-name   (conc (string-intersperse key-vals "\n") "\n" run-name))
+		       (run-path   (append key-vals (list run-name))))
+		  (hash-table-set! (dboard:data-get-run-keys *data*) run-id run-path)
+		  (iup:attribute-set! (dboard:data-get-runs-matrix *data*)
+				      (conc rownum ":" colnum) col-name)
+		  (hash-table-set! runid-to-col run-id (list colnum run-record))
+		  ;; Here we update the tests treebox and tree keys
+		  (tree:add-node (dboard:data-get-tests-tree *data*) "Runs" (append key-vals (list run-name))
+				 userdata: (conc "run-id: " run-id))
+		  (set! colnum (+ colnum 1))))
+	      run-ids)
+
+    ;; Scan all tests to be displayed and organise all the test names, respecting what is in the hash table
+    ;; Do this analysis in the order of the run-ids, the most recent run wins
+    (for-each (lambda (run-id)
+		(let* ((run-path       (hash-table-ref (dboard:data-get-run-keys *data*) run-id))
+		       (new-test-dat   (car test-changes))
+		       (removed-tests  (cadr test-changes))
+		       (tests          (sort (map cadr (filter (lambda (testrec)
+								 (eq? run-id (db:mintest-get-run_id (cadr testrec))))
+							       new-test-dat))
+					     (lambda (a b)
+					       (let ((time-a (db:mintest-get-event_time a))
+						     (time-b (db:mintest-get-event_time b)))
+						 (> time-a time-b)))))
+		       ;; test-changes is a list of (( id record ) ... )
+		       ;; Get list of test names sorted by time, remove tests
+		       (test-names (delete-duplicates (map (lambda (t)
+							     (let ((i (db:mintest-get-item_path t))
+								   (n (db:mintest-get-testname  t)))
+							       (if (string=? i "")
+								   (conc "   " i)
+								   n)))
+							   tests)))
+		       (colnum     (car (hash-table-ref runid-to-col run-id))))
+		  ;; for each test name get the slot if it exists and fill in the cell
+		  ;; or take the next slot and fill in the cell, deal with items in the
+		  ;; run view panel? The run view panel can have a tree selector for
+		  ;; browsing the tests/items
+
+		  ;; SWITCH THIS TO USING CHANGED TESTS ONLY
+		  (for-each (lambda (test)
+			      (let* ((test-id   (db:mintest-get-id test))
+				     (state     (db:mintest-get-state test))
+				     (status    (db:mintest-get-status test))
+				     (testname  (db:mintest-get-testname test))
+				     (itempath  (db:mintest-get-item_path test))
+				     (fullname  (conc testname "/" itempath))
+				     (dispname  (if (string=? itempath "") testname (conc "   " itempath)))
+				     (rownum    (hash-table-ref/default testname-to-row fullname #f))
+				     (test-path (append run-path (if (equal? itempath "") 
+								     (list testname)
+								     (list testname itempath)))))
+				(tree:add-node (dboard:data-get-tests-tree *data*) "Runs" 
+					       test-path
+					       userdata: (conc "test-id: " test-id))
+				(hash-table-set! (dboard:data-get-path-test-ids *data*) test-path test-id)
+				(if (not rownum)
+				    (let ((rownums (hash-table-values testname-to-row)))
+				      (set! rownum (if (null? rownums)
+						       1
+						       (+ 1 (apply max rownums))))
+				      (hash-table-set! testname-to-row fullname rownum)
+				      ;; create the label
+				      (iup:attribute-set! (dboard:data-get-runs-matrix *data*)
+							  (conc rownum ":" 0) dispname)
+				      ))
+				;; set the cell text and color
+				;; (debug:print 2 "rownum:colnum=" rownum ":" colnum ", state=" status)
+				(iup:attribute-set! (dboard:data-get-runs-matrix *data*)
+						    (conc rownum ":" colnum)
+						    (if (string=? state "COMPLETED")
+							status
+							state))
+				(iup:attribute-set! (dboard:data-get-runs-matrix *data*)
+						    (conc "BGCOLOR" rownum ":" colnum)
+						    (car (gutils:get-color-for-state-status state status)))
+				))
+			    tests)))
+	      run-ids)
+
+    (let ((updater (hash-table-ref/default  (dboard:data-get-updaters *data*) window-id #f)))
+      (if updater (updater (hash-table-ref/default data get-details-sig #f))))
+
+    (iup:attribute-set! (dboard:data-get-runs-matrix *data*) "REDRAW" "ALL")
+    ;; (debug:print 2 "run-changes: " run-changes)
+    ;; (debug:print 2 "test-changes: " test-changes)
+    (list run-changes test-changes)))
+
+;;======================================================================
+;; TESTS DATA
+;;======================================================================
+
+;; Produce a list of lists ready for common:sparse-list-generate-index
+;;
+(define (dcommon:minimize-test-data tests-dat)
+  (if (null? tests-dat) 
+      '()
+      (let loop ((hed (car tests-dat))
+		 (tal (cdr tests-dat))
+		 (res '()))
+	(let* ((test-id    (vector-ref hed 0)) ;; look at the tests-dat spec for locations
+	       (test-name  (vector-ref hed 1))
+	       (item-path  (vector-ref hed 2))
+	       (state      (vector-ref hed 3))
+	       (status     (vector-ref hed 4))
+	       (newitem    (list test-name item-path (list test-id state status))))
+	  (if (null? tal)
+	      (reverse (cons newitem res))
+	      (loop (car tal)(cdr tal)(cons newitem res)))))))
+	  
 
 ;;======================================================================
 ;; D A T A   T A B L E S
 ;;======================================================================
 
@@ -112,64 +334,63 @@
     (iup:attribute-set! general-matrix "3:1" megatest-version)
     general-matrix))
 
 (define (dcommon:run-stats)
   (let* ((stats-matrix (iup:matrix expand: "YES"))
+	 (changed      #f)
 	 (updater      (lambda ()
 			 (let* ((run-stats    (mt:get-run-stats))
 				(indices      (common:sparse-list-generate-index run-stats)) ;;  proc: set-cell))
-				(max-row      (apply max (map cadr (car indices))))
-				(max-col      (apply max (map cadr (cadr indices))))
+				(row-indices  (car indices))
+				(col-indices  (cadr indices))
+				(max-row      (if (null? row-indices) 1 (apply max (map cadr row-indices))))
+				(max-col      (if (null? col-indices) 1 (apply max (map cadr col-indices))))
 				(max-visible  (max (- *num-tests* 15) 3))
 				(numrows      1)
-				(numcols      1)
-				(set-cell     (lambda (rnum cnum rname cname v) ;; rownum colnum value
-						(print "proc called: " rnum " " cnum " " rname " " cname " " v)
-						(if (> rnum numrows)
-						    (begin 
-						      ;; add rows numrows to r
-						      (debug:print 0 "Extending matrix from " numrows " to " rnum)
-						      (iup:attribute-set! stats-matrix  "ADDLIN" (conc numrows "-" (- rnum numrows)))
-						      (set! numrows rnum)))
-						(if (> cnum numcols)
-						    (begin 
-						      ;; add rows numrows to r
-						      (debug:print 0 "Extending matrix from " numcols " to " cnum)
-						      (iup:attribute-set! stats-matrix  "ADDLIN" (conc numcols "-" (- rnum numcols)))
-						      (set! numcols cnum)))
-						(debug:print 0 "Setting row " rnum ", col " cnum " to " v)
-						(iup:attribute-set! stats-matrix (conc rnum ":" cnum) v)))
-				(row-indices  (car indices))
-				(col-indices  (cadr indices)))
+				(numcols      1))
+			   (iup:attribute-set! stats-matrix "CLEARVALUE" "CONTENTS")
 			   (iup:attribute-set! stats-matrix "NUMCOL" max-col )
 			   (iup:attribute-set! stats-matrix "NUMLIN" (if (< max-row max-visible) max-visible max-row)) ;; min of 20
 			   (iup:attribute-set! stats-matrix "NUMCOL_VISIBLE" max-col)
 			   (iup:attribute-set! stats-matrix "NUMLIN_VISIBLE" (if (> max-row max-visible) max-visible max-row))
 
 			   ;; Row labels
 			   (for-each (lambda (ind)
-				       (let ((name (car ind))
-					     (num  (cadr ind)))
-					 (iup:attribute-set! stats-matrix (conc num ":0") name)))
+				       (let* ((name (car ind))
+					      (num  (cadr ind))
+					      (key  (conc num ":0")))
+					 (if (not (equal? (iup:attribute stats-matrix key) name))
+					     (begin
+					       (set! changed #t)
+					       (iup:attribute-set! stats-matrix key name)))))
 				     row-indices)
 
 			   ;; Col labels
 			   (for-each (lambda (ind)
-				       (let ((name (car ind))
-					     (num  (cadr ind)))
-					 (iup:attribute-set! stats-matrix (conc "0:" num) name)))
+				       (let* ((name (car ind))
+					      (num  (cadr ind))
+					      (key  (conc "0:" num)))
+					 (if (not (equal? (iup:attribute stats-matrix key) name))
+					     (begin
+					       (set! changed #t)
+					       (iup:attribute-set! stats-matrix key name)))))
 				     col-indices)
 
 			   ;; Cell contents
 			   (for-each (lambda (entry)
 				       (let* ((row-name (car entry))
 					      (col-name (cadr entry))
 					      (value    (caddr entry))
 					      (row-num  (cadr (assoc row-name row-indices)))
-					      (col-num  (cadr (assoc col-name col-indices))))
-					 (iup:attribute-set! stats-matrix (conc row-num ":" col-num) value)))
-				     run-stats)))))
+					      (col-num  (cadr (assoc col-name col-indices)))
+					      (key      (conc row-num ":" col-num)))
+					 (if (not (equal? (iup:attribute stats-matrix key) value))
+					     (begin
+					       (set! changed #t)
+					       (iup:attribute-set! stats-matrix key value)))))
+				     run-stats)
+			   (if changed (iup:attribute-set! stats-matrix "REDRAW" "ALL"))))))
     (updater)
     (set! dashboard:update-summary-tab updater)
     (iup:attribute-set! stats-matrix "WIDTHDEF" "40")
     (iup:vbox
      (iup:label "Run statistics"  #:expand "HORIZONTAL")

ADDED   docs/dashboard-summary-tab.png
Index: docs/dashboard-summary-tab.png
==================================================================
--- /dev/null
+++ docs/dashboard-summary-tab.png
cannot compute difference between binary files

Index: gutils.scm
==================================================================
--- gutils.scm
+++ gutils.scm
@@ -20,23 +20,24 @@
   (let* ((c1 (map string->number (string-split color1)))
 	 (c2 (map string->number (string-split color2)))
 	 (delta (map (lambda (a b)(abs (- a b))) c1 c2)))
     (null? (filter (lambda (x)(> x 3)) delta))))
 
-(define (gutils:get-color-for-state-status state status)
-  (case (string->symbol state)
-    ((COMPLETED)
-     (if (equal? status "PASS")
-	 "70 249 73"
-	 (if (or (equal? status "WARN")
-		 (equal? status "WAIVED"))
-	     "255 172 13"
-	     "223 33 49"))) ;; greenish orangeish redish
-    ((LAUNCHED)         "101 123 142")
-    ((CHECK)            "255 100 50")
-    ((REMOTEHOSTSTART)  "50 130 195")
-    ((RUNNING)          "9 131 232")
-    ((KILLREQ)          "39 82 206")
-    ((KILLED)           "234 101 17")
-    ((NOT_STARTED)      "240 240 240")
-    (else               "192 192 192")))
+(define (gutils:get-color-for-state-status state status);; #!key (get-label #f))
+  ;; ((if get-label cadr car)
+   (case (string->symbol state)
+     ((COMPLETED)
+      (if (equal? status "PASS")
+	  '("70 249 73" "PASS")
+	  (if (or (equal? status "WARN")
+		  (equal? status "WAIVED"))
+	      (list "255 172 13" status)
+	      (list "223 33 49"  status)))) ;; greenish orangeish redish
+     ((LAUNCHED)         (list "101 123 142"  state))
+     ((CHECK)            (list "255 100 50"   state))
+     ((REMOTEHOSTSTART)  (list "50 130 195"   state))
+     ((RUNNING)          (list "9 131 232"    state))
+     ((KILLREQ)          (list "39 82 206"    state))
+     ((KILLED)           (list "234 101 17"   state))
+     ((NOT_STARTED)      (list "240 240 240"  state))
+     (else               (list "192 192 192"  state))))
 

Index: mt.scm
==================================================================
--- mt.scm
+++ mt.scm
@@ -45,21 +45,21 @@
 
 ;;======================================================================
 ;;  T E S T S
 ;;======================================================================
 
-(define (mt:get-tests-for-run run-id testpatt states status #!key (not-in #t) (sort-by #f))
-  (let loop ((testsdat (cdb:remote-run db:get-tests-for-run #f run-id testpatt states status 0 500 not-in sort-by))
+(define (mt:get-tests-for-run run-id testpatt states status #!key (not-in #t) (sort-by #f) (qryvals #f))
+  (let loop ((testsdat (cdb:remote-run db:get-tests-for-run #f run-id testpatt states status 0 500 not-in sort-by qryvals: qryvals))
 	     (res      '())
 	     (offset   0)
 	     (limit    500))
     (let* ((full-list (append res testsdat))
 	   (have-more (eq? (length testsdat) limit)))
       (if have-more 
 	  (let ((new-offset (+ offset limit)))
-	    (debug:print-info 0 "More than " limit " tests, have " (length full-list) " tests so far.")
-	    (loop (cdb:remote-run db:get-tests-for-run #f run-id testpatt states status new-offset limit not-in sort-by)
+	    (debug:print-info 4 "More than " limit " tests, have " (length full-list) " tests so far.")
+	    (loop (cdb:remote-run db:get-tests-for-run #f run-id testpatt states status new-offset limit not-in sort-by qryvals: qryvals)
 		  full-list
 		  new-offset
 		  limit))
 	  full-list))))
 

Index: newdashboard.scm
==================================================================
--- newdashboard.scm
+++ newdashboard.scm
@@ -23,10 +23,11 @@
 (declare (uses gutils))
 (declare (uses db))
 (declare (uses server))
 (declare (uses synchash))
 (declare (uses dcommon))
+(declare (uses tree))
 
 (include "common_records.scm")
 (include "db_records.scm")
 (include "key_records.scm")
 
@@ -83,42 +84,10 @@
 (debug:setup)
 
 (define *tim* (iup:timer))
 (define *ord* #f)
 
-(define *data* (make-vector 10 #f))
-(define-inline (dboard:data-get-runs          vec)    (vector-ref  vec 0))
-(define-inline (dboard:data-get-tests         vec)    (vector-ref  vec 1))
-(define-inline (dboard:data-get-runs-matrix   vec)    (vector-ref  vec 2))
-(define-inline (dboard:data-get-tests-tree    vec)    (vector-ref  vec 3))
-(define-inline (dboard:data-get-run-keys      vec)    (vector-ref  vec 4))
-(define-inline (dboard:data-get-curr-test-ids vec)    (vector-ref  vec 5))
-;; (define-inline (dboard:data-get-test-details  vec)    (vector-ref  vec 6))
-(define-inline (dboard:data-get-path-test-ids vec)    (vector-ref  vec 7))
-(define-inline (dboard:data-get-updaters      vec)    (vector-ref  vec 8))
-
-(define-inline (dboard:data-set-runs!          vec val)(vector-set! vec 0 val))
-(define-inline (dboard:data-set-tests!         vec val)(vector-set! vec 1 val))
-(define-inline (dboard:data-set-runs-matrix!   vec val)(vector-set! vec 2 val))
-(define-inline (dboard:data-set-tests-tree!    vec val)(vector-set! vec 3 val))
-(define-inline (dboard:data-set-run-keys!      vec val)(vector-set! vec 4 val))
-(define-inline (dboard:data-set-curr-test-ids! vec val)(vector-set! vec 5 val))
-;; (define-inline (dboard:data-set-test-details!  vec val)(vector-set! vec 6 val))
-(define-inline (dboard:data-set-path-test-ids! vec val)(vector-set! vec 7 val))
-(define-inline (dboard:data-set-updaters!      vec val)(vector-set! vec 8 val))
-
-(dboard:data-set-run-keys! *data* (make-hash-table))
-
-;; List of test ids being viewed in various panels
-(dboard:data-set-curr-test-ids! *data* (make-hash-table))
-
-;; Look up test-ids by (key1 key2 ... testname [itempath])
-(dboard:data-set-path-test-ids! *data* (make-hash-table))
-
-;; Each test panel has an updater, only call when the tab is exposed
-(dboard:data-set-updaters!      *data* (make-hash-table))
-
 (iup:attribute-set! *tim* "TIME" 300)
 (iup:attribute-set! *tim* "RUN" "YES")
 
 (define (message-window msg)
   (iup:show
@@ -274,108 +243,10 @@
 ;;
 (define (rconfig window-id)
   (iup:vbox
    (iup:frame #:title "Default")))
 
-;;======================================================================
-;; T R E E   S T U F F 
-;;======================================================================
-
-;; path is a list of nodes, each the child of the previous
-;; this routine returns the id so another node can be added
-;; either as a leaf or as a branch
-;;
-;; BUG: This needs a stop sensor for when a branch is exhausted
-;;
-(define (tree-find-node obj path)
-  ;; start at the base of the tree
-  (if (null? path)
-      #f ;; or 0 ????
-      (let loop ((hed      (car path))
-		 (tal      (cdr path))
-		 (depth    0)
-		 (nodenum  0))
-	;; nodes in iup tree are 100% sequential so iterate over nodenum
-	(if (iup:attribute obj (conc "DEPTH" nodenum)) ;; end when no more nodes
-	    (let ((node-depth (string->number (iup:attribute obj (conc "DEPTH" nodenum))))
-		  (node-title (iup:attribute obj (conc "TITLE" nodenum))))
-	      (if (and (equal? depth node-depth)
-		       (equal? hed   node-title)) ;; yep, this is the one!
-		  (if (null? tal) ;; end of the line
-		      nodenum
-		      (loop (car tal)(cdr tal)(+ depth 1)(+ 1 nodenum)))
-		  ;; this is the case where we found part of the hierarchy but not 
-		  ;; all of it, i.e. the node-depth went from deep to less deep
-		  (if (> depth node-depth) ;; (+ 1 node-depth))
-		      #f
-		      (loop hed tal depth (+ nodenum 1)))))
-	    #f))))
-
-;; top is the top node name zeroeth node VALUE=0
-(define (tree-add-node obj top nodelst #!key (userdata #f))
-  (if (not (iup:attribute obj "TITLE0"))
-      (iup:attribute-set! obj "ADDBRANCH0" top))
-  (cond
-   ((not (string=? top (iup:attribute obj "TITLE0")))
-    (print "ERROR: top name " top " doesn't match " (iup:attribute obj "TITLE0")))
-   ((null? nodelst))
-   (else
-    (let loop ((hed      (car nodelst))
-	       (tal      (cdr nodelst))
-	       (depth    1)
-	       (pathl    (list top)))
-      ;; Because the tree dialog changes node numbers when
-      ;; nodes are added or removed we must look up nodes
-      ;; each and every time. 0 is the top node so default
-      ;; to that.
-      (let* ((newpath    (append pathl (list hed)))
-	     (parentnode (tree-find-node obj pathl))
-	     (nodenum    (tree-find-node obj newpath)))
-	;; Add the branch under lastnode if not found
-	(if (not nodenum)
-	    (begin
-	      (iup:attribute-set! obj (conc "ADDBRANCH" parentnode) hed)
-	      (if userdata
-		  (iup:attribute-set! obj (conc "USERDATA"   parentnode) userdata))
-	      (if (null? tal)
-		  #t
-		  ;; reset to top
-		  (loop (car nodelst)(cdr nodelst) 1 (list top)))) 
-	    (if (null? tal) ;; if null here then this path has already been added
-		#t
-		(loop (car tal)(cdr tal)(+ depth 1) newpath))))))))
-
-(define (tree-node->path obj nodenum)
-  ;; (print "\ncurrnode  nodenum  depth  node-depth  node-title   path")
-  (let loop ((currnode 0)
-	     (depth    0)
-	     (path     '()))
-    (let ((node-depth (iup:attribute obj (conc "DEPTH" currnode)))
-	  (node-title (iup:attribute obj (conc "TITLE" currnode))))
-      ;; (display (conc "\n   "currnode "        " nodenum "       " depth "         " node-depth "          " node-title "         " path))
-      (if (> currnode nodenum)
-	  path
-	  (if (not node-depth) ;; #f if we are out of nodes
-	      '()
-	      (let ((ndepth (string->number node-depth)))
-		(if (eq? ndepth depth)
-		    ;; This next is the match condition depth == node-depth
-		    (if (eq? currnode nodenum)
-			(begin
-			  ;; (display " <X>")
-			  (append path (list node-title)))
-			(loop (+ currnode 1)
-			      (+ depth 1)
-			      (append path (list node-title))))
-		    ;; didn't match, reset to base path and keep looking
-		    ;; due to more iup odditys we don't reset to base
-		    (begin 
-		      ;; (display " <L>")
-		      (loop (+ 1 currnode)
-			    2
-			    (append (take path ndepth)(list node-title)))))))))))
-
 ;;======================================================================
 ;; T E S T S
 ;;======================================================================
 
 (define (tree-path->test-id path)
@@ -547,16 +418,16 @@
   (iup:hbox 
    (let* ((tb      (iup:treebox
 		    #:selection-cb
 		    (lambda (obj id state)
 		      ;; (print "obj: " obj ", id: " id ", state: " state)
-		      (let* ((run-path (tree-node->path obj id))
+		      (let* ((run-path (tree:node->path obj id))
 			     (test-id  (tree-path->test-id (cdr run-path))))
 			(if test-id
 			    (hash-table-set! (dboard:data-get-curr-test-ids *data*)
 					     window-id test-id))
-			(print "path: " (tree-node->path obj id) " test-id: " test-id))))))
+			(print "path: " (tree:node->path obj id) " test-id: " test-id))))))
      (iup:attribute-set! tb "VALUE" "0")
      (iup:attribute-set! tb "NAME" "Runs")
      ;;(iup:attribute-set! tb "ADDEXPANDED" "NO")
      (dboard:data-set-tests-tree! *data* tb)
      tb)
@@ -672,163 +543,10 @@
 ;; Browse and control a single run
 ;;
 (define (runcontrol window-id)
   (iup:hbox))
 
-;;======================================================================
-;; P R O C E S S   R U N S
-;;======================================================================
-
-;; MOVE THIS INTO *data*
-(define *cachedata* (make-hash-table))
-(hash-table-set! *cachedata* "runid-to-col"    (make-hash-table))
-(hash-table-set! *cachedata* "testname-to-row" (make-hash-table))
-
-;; TO-DO
-;;  1. Make "data" hash-table hierarchial store of all displayed data
-;;  2. Update synchash to understand "get-runs", "get-tests" etc.
-;;  3. Add extraction of filters to synchash calls
-;;
-;; Mode is 'full or 'incremental for full refresh or incremental refresh
-(define (run-update keys data runname keypatts testpatt states statuses mode window-id)
-  (let* (;; count and offset => #f so not used
-	 ;; the synchash calls modify the "data" hash
-	 (get-runs-sig    (conc (client:get-signature) " get-runs"))
-	 (get-tests-sig   (conc (client:get-signature) " get-tests"))
-	 (get-details-sig (conc (client:get-signature) " get-test-details"))
-
-	 ;; test-ids to get and display are indexed on window-id in curr-test-ids hash
-	 (test-ids        (hash-table-values (dboard:data-get-curr-test-ids *data*)))
-
- 	 (run-changes     (synchash:client-get 'db:get-runs get-runs-sig (length keypatts) data runname #f #f keypatts))
-	 (tests-detail-changes (if (not (null? test-ids))
-				   (synchash:client-get 'db:get-test-info-by-ids get-details-sig 0  data test-ids)
-				   '()))
-
-	 ;; Now can calculate the run-ids
-	 (run-hash    (hash-table-ref/default data get-runs-sig #f))
-	 (run-ids     (if run-hash (filter number? (hash-table-keys run-hash)) '()))
-
-	 (test-changes (synchash:client-get 'db:get-tests-for-runs-mindata get-tests-sig 0 data run-ids testpatt states statuses))
-	 (runs-hash    (hash-table-ref/default data get-runs-sig #f))
-	 (header       (hash-table-ref/default runs-hash "header" #f))
-	 (run-ids      (sort (filter number? (hash-table-keys runs-hash))
-			     (lambda (a b)
-			       (let* ((record-a (hash-table-ref runs-hash a))
-				      (record-b (hash-table-ref runs-hash b))
-				      (time-a   (db:get-value-by-header record-a header "event_time"))
-				      (time-b   (db:get-value-by-header record-b header "event_time")))
-				 (> time-a time-b)))
-			     ))
-	 (runid-to-col    (hash-table-ref *cachedata* "runid-to-col"))
-	 (testname-to-row (hash-table-ref *cachedata* "testname-to-row")) 
-	 (colnum       1)
-	 (rownum       0)) ;; rownum = 0 is the header
-;; (debug:print 0 "test-ids " test-ids ", tests-detail-changes " tests-detail-changes)
-    
-	 ;; tests related stuff
-	 ;; (all-testnames (delete-duplicates (map db:test-get-testname test-changes))))
-
-    ;; Given a run-id and testname/item_path calculate a cell R:C
-
-    ;; NOTE: Also build the test tree browser and look up table
-    ;;
-    ;; Each run is unique on its keys and runname or run-id, store in hash on colnum
-    (for-each (lambda (run-id)
-		(let* ((run-record (hash-table-ref/default runs-hash run-id #f))
-		       (key-vals   (map (lambda (key)(db:get-value-by-header run-record header key))
-					keys))
-		       (run-name   (db:get-value-by-header run-record header "runname"))
-		       (col-name   (conc (string-intersperse key-vals "\n") "\n" run-name))
-		       (run-path   (append key-vals (list run-name))))
-		  (hash-table-set! (dboard:data-get-run-keys *data*) run-id run-path)
-		  (iup:attribute-set! (dboard:data-get-runs-matrix *data*)
-				      (conc rownum ":" colnum) col-name)
-		  (hash-table-set! runid-to-col run-id (list colnum run-record))
-		  ;; Here we update the tests treebox and tree keys
-		  (tree-add-node (dboard:data-get-tests-tree *data*) "Runs" (append key-vals (list run-name))
-				 userdata: (conc "run-id: " run-id))
-		  (set! colnum (+ colnum 1))))
-	      run-ids)
-
-    ;; Scan all tests to be displayed and organise all the test names, respecting what is in the hash table
-    ;; Do this analysis in the order of the run-ids, the most recent run wins
-    (for-each (lambda (run-id)
-		(let* ((run-path       (hash-table-ref (dboard:data-get-run-keys *data*) run-id))
-		       (new-test-dat   (car test-changes))
-		       (removed-tests  (cadr test-changes))
-		       (tests          (sort (map cadr (filter (lambda (testrec)
-								 (eq? run-id (db:mintest-get-run_id (cadr testrec))))
-							       new-test-dat))
-					     (lambda (a b)
-					       (let ((time-a (db:mintest-get-event_time a))
-						     (time-b (db:mintest-get-event_time b)))
-						 (> time-a time-b)))))
-		       ;; test-changes is a list of (( id record ) ... )
-		       ;; Get list of test names sorted by time, remove tests
-		       (test-names (delete-duplicates (map (lambda (t)
-							     (let ((i (db:mintest-get-item_path t))
-								   (n (db:mintest-get-testname  t)))
-							       (if (string=? i "")
-								   (conc "   " i)
-								   n)))
-							   tests)))
-		       (colnum     (car (hash-table-ref runid-to-col run-id))))
-		  ;; for each test name get the slot if it exists and fill in the cell
-		  ;; or take the next slot and fill in the cell, deal with items in the
-		  ;; run view panel? The run view panel can have a tree selector for
-		  ;; browsing the tests/items
-
-		  ;; SWITCH THIS TO USING CHANGED TESTS ONLY
-		  (for-each (lambda (test)
-			      (let* ((test-id   (db:mintest-get-id test))
-				     (state     (db:mintest-get-state test))
-				     (status    (db:mintest-get-status test))
-				     (testname  (db:mintest-get-testname test))
-				     (itempath  (db:mintest-get-item_path test))
-				     (fullname  (conc testname "/" itempath))
-				     (dispname  (if (string=? itempath "") testname (conc "   " itempath)))
-				     (rownum    (hash-table-ref/default testname-to-row fullname #f))
-				     (test-path (append run-path (if (equal? itempath "") 
-								     (list testname)
-								     (list testname itempath)))))
-				(tree-add-node (dboard:data-get-tests-tree *data*) "Runs" 
-					       test-path
-					       userdata: (conc "test-id: " test-id))
-				(hash-table-set! (dboard:data-get-path-test-ids *data*) test-path test-id)
-				(if (not rownum)
-				    (let ((rownums (hash-table-values testname-to-row)))
-				      (set! rownum (if (null? rownums)
-						       1
-						       (+ 1 (apply max rownums))))
-				      (hash-table-set! testname-to-row fullname rownum)
-				      ;; create the label
-				      (iup:attribute-set! (dboard:data-get-runs-matrix *data*)
-							  (conc rownum ":" 0) dispname)
-				      ))
-				;; set the cell text and color
-				;; (debug:print 2 "rownum:colnum=" rownum ":" colnum ", state=" status)
-				(iup:attribute-set! (dboard:data-get-runs-matrix *data*)
-						    (conc rownum ":" colnum)
-						    (if (string=? state "COMPLETED")
-							status
-							state))
-				(iup:attribute-set! (dboard:data-get-runs-matrix *data*)
-						    (conc "BGCOLOR" rownum ":" colnum)
-						    (gutils:get-color-for-state-status state status))
-				))
-			    tests)))
-	      run-ids)
-
-    (let ((updater (hash-table-ref/default  (dboard:data-get-updaters *data*) window-id #f)))
-      (if updater (updater (hash-table-ref/default data get-details-sig #f))))
-
-    (iup:attribute-set! (dboard:data-get-runs-matrix *data*) "REDRAW" "ALL")
-    ;; (debug:print 2 "run-changes: " run-changes)
-    ;; (debug:print 2 "test-changes: " test-changes)
-    (list run-changes test-changes)))
-
 ;;======================================================================
 ;; D A S H B O A R D
 ;;======================================================================
 
 ;; Main Panel

Index: tests/Makefile
==================================================================
--- tests/Makefile
+++ tests/Makefile
@@ -113,10 +113,21 @@
 
 test9d :
 	@echo Run an itemized test with no items
 	cd mintest;megatest -runtests g -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
 
+test10 :
+	@echo Run a bunch of different targets simultaneously
+	(cd fullrun;$(MEGATEST) -server - ;sleep 2)&
+	for targ in mint/btrfs/mintdir sunos/sshfs/loc; do \
+	   (cd fullrun;$(MEGATEST) -runtests priority_10_waiton_1 -target $$targ :runname $(RUNNAME) &); done
+	for sys in ubuntu suse redhat debian;do \
+	  for fs in afs nfs zfs; do \
+	     for dpath in none tmp; do \
+	        (cd fullrun;$(MEGATEST) -runtests priority_10_waiton_1 -target $$sys/$$fs/$$dpath :runname $(RUNNAME) &);\
+	     done;done;done
+
 minsetup : 
 	cd ..;make && make install
 	mkdir -p mintest/runs mintest/links
 	cd mintest;megatest -stop-server 0
 	cd mintest;megatest -server - -debug $(DEBUG) > server.log 2> server.log & 

ADDED   tree.scm
Index: tree.scm
==================================================================
--- /dev/null
+++ tree.scm
@@ -0,0 +1,116 @@
+;;======================================================================
+;; Copyright 2006-2013, Matthew Welland.
+;; 
+;;  This program is made available under the GNU GPL version 2.0 or
+;;  greater. See the accompanying file COPYING for details.
+;; 
+;;  This program is distributed WITHOUT ANY WARRANTY; without even the
+;;  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;;  PURPOSE.
+;;======================================================================
+
+(use format)
+(require-library iup)
+(import (prefix iup iup:))
+(use canvas-draw)
+
+(use sqlite3 srfi-1 posix regex regex-case srfi-69)
+(import (prefix sqlite3 sqlite3:))
+
+(declare (unit tree))
+(declare (uses margs))
+(declare (uses launch))
+(declare (uses megatest-version))
+(declare (uses gutils))
+(declare (uses db))
+(declare (uses server))
+(declare (uses synchash))
+(declare (uses dcommon))
+
+(include "common_records.scm")
+(include "db_records.scm")
+(include "key_records.scm")
+
+;;======================================================================
+;; T R E E   S T U F F 
+;;======================================================================
+
+;; path is a list of nodes, each the child of the previous
+;; this routine returns the id so another node can be added
+;; either as a leaf or as a branch
+;;
+;; BUG: This needs a stop sensor for when a branch is exhausted
+;;
+(define (tree:find-node obj path)
+  ;; start at the base of the tree
+  (if (null? path)
+      #f ;; or 0 ????
+      (let loop ((hed      (car path))
+		 (tal      (cdr path))
+		 (depth    0)
+		 (nodenum  0))
+	;; nodes in iup tree are 100% sequential so iterate over nodenum
+	(if (iup:attribute obj (conc "DEPTH" nodenum)) ;; end when no more nodes
+	    (let ((node-depth (string->number (iup:attribute obj (conc "DEPTH" nodenum))))
+		  (node-title (iup:attribute obj (conc "TITLE" nodenum))))
+	      (if (and (equal? depth node-depth)
+		       (equal? hed   node-title)) ;; yep, this is the one!
+		  (if (null? tal) ;; end of the line
+		      nodenum
+		      (loop (car tal)(cdr tal)(+ depth 1)(+ 1 nodenum)))
+		  ;; this is the case where we found part of the hierarchy but not 
+		  ;; all of it, i.e. the node-depth went from deep to less deep
+		  (if (> depth node-depth) ;; (+ 1 node-depth))
+		      #f
+		      (loop hed tal depth (+ nodenum 1)))))
+	    #f))))
+
+;; top is the top node name zeroeth node VALUE=0
+(define (tree:add-node obj top nodelst #!key (userdata #f))
+  (if (not (iup:attribute obj "TITLE0"))
+      (iup:attribute-set! obj "ADDBRANCH0" top))
+  (cond
+   ((not (string=? top (iup:attribute obj "TITLE0")))
+    (print "ERROR: top name " top " doesn't match " (iup:attribute obj "TITLE0")))
+   ((null? nodelst))
+   (else
+    (let loop ((hed      (car nodelst))
+	       (tal      (cdr nodelst))
+	       (depth    1)
+	       (pathl    (list top)))
+      ;; Because the tree dialog changes node numbers when
+      ;; nodes are added or removed we must look up nodes
+      ;; each and every time. 0 is the top node so default
+      ;; to that.
+      (let* ((newpath    (append pathl (list hed)))
+	     (parentnode (tree:find-node obj pathl))
+	     (nodenum    (tree:find-node obj newpath)))
+	;; Add the branch under lastnode if not found
+	(if (not nodenum)
+	    (begin
+	      (iup:attribute-set! obj (conc "ADDBRANCH" parentnode) hed)
+	      (if userdata
+		  (iup:attribute-set! obj (conc "USERDATA"   parentnode) userdata))
+	      (if (null? tal)
+		  #t
+		  ;; reset to top
+		  (loop (car nodelst)(cdr nodelst) 1 (list top)))) 
+	    (if (null? tal) ;; if null here then this path has already been added
+		#t
+		(loop (car tal)(cdr tal)(+ depth 1) newpath))))))))
+
+(define (tree:node->path obj nodenum)
+  (let loop ((currnode 0)
+	     (path     '()))
+    (let* ((node-depth (string->number (iup:attribute obj (conc "DEPTH" currnode))))
+	   (node-title (iup:attribute obj (conc "TITLE" currnode)))
+	   (trimpath   (if (and (not (null? path))
+				(> (length path) node-depth))
+			   (take path node-depth)
+			   path))
+	   (newpath    (append trimpath (list node-title))))
+      (if (>= currnode nodenum)
+	  newpath
+	  (loop (+ currnode 1)
+		newpath)))))
+