Index: .fossil-settings/ignore-glob
==================================================================
--- .fossil-settings/ignore-glob
+++ .fossil-settings/ignore-glob
@@ -25,5 +25,7 @@
 fullrun/config/*.config
 fullrun/envfile.txt
 *.bak
 simplerun/*.scm
 simplerun/simpleruns
+tests/mintest/runs/*
+tests/mintest/linktree/*

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
+           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
@@ -170,11 +170,53 @@
 		    (loop (car tala)
 			  (cdr tala)
 			  (car talb)
 			  (cdr talb)))
 		#f)))))
-      
+
+;;======================================================================
+;; Munge data into nice forms
+;;======================================================================
+
+;; Generate an index for a sparse list of key values
+;;   ( (rowname1 colname1 val1)(rowname2 colname2 val2) )
+;;
+;; => 
+;;
+;;   ( (rowname1 0)(rowname2 1))    ;; rownames -> num
+;;     (colname1 0)(colname2 1)) )  ;; colnames -> num
+;; 
+;; optional apply proc to rownum colnum value
+(define (common:sparse-list-generate-index data #!key (proc #f))
+  (if (null? data)
+      (list '() '())
+      (let loop ((hed (car data))
+		 (tal (cdr data))
+		 (rownames '())
+		 (colnames '())
+		 (rownum   0)
+		 (colnum   0))
+	(let* ((rowkey          (car   hed))
+	       (colkey          (cadr  hed))
+	       (value           (caddr hed))
+	       (existing-rowdat (assoc rowkey rownames))
+	       (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 )
+	  (if proc (proc curr-rownum curr-colnum rowkey colkey value))
+	  (if (null? tal)
+	      (list new-rownames new-colnames)
+	      (loop (car tal)
+		    (cdr tal)
+		    new-rownames
+		    new-colnames
+		    (if (> curr-rownum rownum) curr-rownum rownum)
+		    (if (> curr-colnum colnum) curr-colnum colnum)
+		    ))))))
 
 ;;======================================================================
 ;; System stuff
 ;;======================================================================
 
@@ -267,10 +309,14 @@
 
 (define (seconds->time-string sec)
   (time->string 
    (seconds->local-time sec) "%H:%M:%S"))
 
+(define (seconds->work-week/day sec)
+  (time->string
+   (seconds->local-time sec) "%V.%u"))
+
 ;;======================================================================
 ;; Colors
 ;;======================================================================
       
 (define (common:name->iup-color name)
@@ -278,26 +324,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 
@@ -270,10 +271,12 @@
 	       (keydat        (if testdat (open-run-close db:get-key-val-pairs #f run-id) #f))
 	       (rundat        (if testdat (open-run-close db:get-run-info #f run-id) #f))
 	       (runname       (if testdat (db:get-value-by-header (db:get-row rundat)
 								  (db:get-header rundat)
 								  "runname") #f))
+	       ;; These next two are intentional bad values to ensure errors if they should not
+	       ;; get filled in properly.
 	       (logfile       "/this/dir/better/not/exist")
 	       (rundir        logfile)
 	       (teststeps     (if testdat (db:get-compressed-steps test-id work-area: rundir) '()))
 	       (testfullname  (if testdat (db:test-get-fullname testdat) "Gathering data ..."))
 	       (testname      (if testdat (db:test-get-testname testdat) "n/a"))
@@ -292,10 +295,17 @@
 	       (viewlog    (lambda (x)
 			     (if (file-exists? logfile)
 					;(system (conc "firefox " logfile "&"))
 				 (iup:send-url logfile)
 				 (message-window (conc "File " logfile " not found")))))
+	       (view-a-log (lambda (lfile)
+			     (let ((lfilename (conc rundir "/" lfile)))
+			       ;; (print "lfilename: " lfilename)
+			       (if (file-exists? lfilename)
+					;(system (conc "firefox " logfile "&"))
+				   (iup:send-url lfilename)
+				   (message-window (conc "File " lfilename " not found"))))))
 	       (xterm      (lambda (x)
 			     (if (directory-exists? rundir)
 				 (let ((shell (if (get-environment-variable "SHELL") 
 						  (conc "-e " (get-environment-variable "SHELL"))
 						  "")))
@@ -417,15 +427,16 @@
 							    #:numcol 6
 							    #:numlin 30
 							    #:numcol-visible 6
 							    #:numlin-visible 5
 							    #:click-cb (lambda (obj lin col status)
-									 (if (equal? col 6)
-									     (let ((fname (iup:attribute obj (conc lin ":" col))))
-									       (viewlog fname)
-									       (print "obj: " obj " lin: " lin " col: " col " status: " status)))))
-							   ))
+									 ;; (if (equal? col 6)
+									 (let* ((mtrx-rc (conc lin ":" 6))
+										(fname   (iup:attribute obj mtrx-rc))) ;; col))))
+									   (view-a-log fname)))
+									   ;; (print "obj: " obj " mtrx-rc: " mtrx-rc " fname: " fname " lin: " lin " col: " col " status: " status)))
+							    )))
 					 ;; (let loop ((count 0))
 					 ;;   (iup:attribute-set! steps-matrix "FITTOTEXT" (conc "L" count))
 					 ;;   (if (< count 30)
 					 ;;       (loop (+ count 1))))
 					 (iup:attribute-set! steps-matrix "0:1" "Step Name")
@@ -444,12 +455,13 @@
 						  (if (not (null? teststeps))
 						      (let loop ((hed    (car teststeps))
 								 (tal    (cdr teststeps))
 								 (rownum 1)
 								 (colnum 1))
-							(let ((val (vector-ref hed (- colnum 1))))
-							  (iup:attribute-set! steps-matrix  (conc rownum ":" colnum)(if val (conc val) ""))
+							(let ((val     (vector-ref hed (- colnum 1)))
+							      (mtrx-rc (conc rownum ":" colnum)))
+							  (iup:attribute-set! steps-matrix  mtrx-rc (if val (conc val) ""))
 							  (if (< colnum 6)
 							      (loop hed tal rownum (+ colnum 1))
 							      (if (not (null? tal))
 								  (loop (car tal)(cdr tal)(+ rownum 1) 1))))
 							(iup:attribute-set! steps-matrix "REDRAW" "ALL"))))))

Index: dashboard.scm
==================================================================
--- dashboard.scm
+++ dashboard.scm
@@ -29,10 +29,13 @@
 (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))
 
 (include "common_records.scm")
@@ -40,11 +43,11 @@
 (include "run_records.scm")
 
 (define help (conc 
 "Megatest Dashboard, documentation at http://www.kiatoa.com/fossils/megatest
   version " megatest-version "
-  license GPL, Copyright (C) Matt Welland 2011
+  license GPL, Copyright (C) Matt Welland 2013
 
 Usage: dashboard [options]
   -h                : this help
   -server host:port : connect to host:port instead of db access
   -test testid      : control test identified by testid
@@ -116,27 +119,30 @@
 (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)
 
 (define-inline (dboard:uidat-get-keycol  vec)(vector-ref vec 0))
@@ -149,21 +155,20 @@
   (iup:show
    (iup:dialog
     (iup:vbox 
      (iup:label msg #:margin "40x40")))))
 
-(define (iuplistbox-fill-list lb items . default)
-  (let ((i 1)
-	(selected-item (if (null? default) #f (car default))))
-    (iup:attribute-set! lb "VALUE" (if selected-item selected-item ""))
+(define (iuplistbox-fill-list lb items #!key (selected-item #f))
+  (let ((i 1))
     (for-each (lambda (item)
 		(iup:attribute-set! lb (number->string i) item)
 		(if selected-item
 		    (if (equal? selected-item item)
-			(iup:attribute-set! lb "VALUE" item))) ;; (number->string i))))
+			(iup:attribute-set! lb "VALUE" i))) ;; (number->string i))))
 		(set! i (+ i 1)))
 	      items)
+    ;; (iup:attribute-set! lb "VALUE" (if selected-item selected-item ""))
     i))
 
 (define (pad-list l n)(append l (make-list (- n (length l)))))
 
 (define (colors-similar? color1 color2)
@@ -172,75 +177,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)
@@ -322,103 +298,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)
@@ -446,11 +420,11 @@
 ;;   a b c
 ;;   a d e
 ;;   a b f
 ;;        a/b => c f
 ;;
-(define (dashboard:populate-target-dropdown lb referent-vals targets)
+(define (dashboard:populate-target-dropdown lb referent-vals targets) ;;  runconf-targs)
   ;; is the current value in the new list? choose new default if not
   (let* ((remvalues  (map (lambda (row)
 			    (common:list-is-sublist referent-vals (vector->list row)))
 			  targets))
 	 (values     (delete-duplicates (map car (filter list? remvalues))))
@@ -474,13 +448,21 @@
 	      (let ((newval (car values)))
 		(iup:attribute-set! lb "VALUE" newval)
 		newval))))))
 
 (define (dashboard:update-target-selector key-lbs #!key (action-proc #f))
-  (let* ((db-target-dat (open-run-close db:get-targets #f))
+  (let* ((runconf-targs (common:get-runconfig-targets))
+	 (db-target-dat (open-run-close db:get-targets #f))
 	 (header        (vector-ref db-target-dat 0))
 	 (db-targets    (vector-ref db-target-dat 1))
+	 (all-targets   (append db-targets
+				(map (lambda (x)
+				       (list->vector
+					(take (append (string-split x "/")
+						      (make-list (length header) "na"))
+					      (length header))))
+				     runconf-targs)))
 	 (key-listboxes (if key-lbs key-lbs (make-list (length header) #f))))
     (let loop ((key     (car header))
 	       (remkeys (cdr header))
 	       (refvals '())
 	       (indx    0)
@@ -487,66 +469,142 @@
 	       (lbs     '()))
       (let* ((lb (let ((lb (list-ref key-listboxes indx)))
 		   (if lb
 		       lb
 		       (iup:listbox 
-			#:size "x10" 
+			;; #:size "x10" 
 			#:fontsize "10"
-			#:expand "VERTICAL"
+			#:expand "YES" ;; "VERTICAL"
 			;; #:dropdown "YES"
 			#:editbox "YES"
-			#:action action-proc
+			#:action (lambda (obj a b c)
+				   (action-proc))
+			#:caret_cb (lambda (obj a b c)(action-proc))
 			))))
 	     ;; loop though all the targets and build the list for this dropdown
-	     (selected-value (dashboard:populate-target-dropdown lb refvals db-targets)))
+	     (selected-value (dashboard:populate-target-dropdown lb refvals all-targets)))
 	(if (null? remkeys)
 	    ;; return a list of the listbox items and an iup:hbox with the labels and listboxes
 	    (let ((listboxes (append lbs (list lb))))
 	      (list listboxes
 		    (map (lambda (htxt lb)
 			   (iup:vbox
-			    (iup:label htxt)
+			    (iup:label htxt) 
 			    lb))
 			 header
 			 listboxes)))
 	    (loop (car remkeys)
 		  (cdr remkeys)
 		  (append refvals (list selected-value))
 		  (+ indx 1)
 		  (append lbs (list lb))))))))
 
-(define (dashboard:draw-tests cnv xadj yadj test-draw-state sorted-testnames)
+;; Make a vertical list of toggles using items, when toggled call proc with the conc'd string 
+;; interspersed with commas
+;;
+(define (dashboard:text-list-toggle-box items proc)
+  (let ((alltgls (make-hash-table)))
+    (apply iup:vbox
+	   (map (lambda (item)
+		  (iup:toggle 
+		   item
+		   #:expand "YES"
+		   #:action (lambda (obj tstate)
+			      (if (eq? tstate 0)
+				  (hash-table-delete! alltgls item)
+				  (hash-table-set! alltgls item #t))
+			      (let ((all (hash-table-keys alltgls)))
+				(proc all)))))
+		items))))
+
+;; Extract the various bits of data from *data* and create the command line equivalent that will be displayed
+;;
+(define (dashboard:update-run-command)
+  (let* ((cmd-tb       (dboard:data-get-command-tb *data*))
+	 (cmd          (dboard:data-get-command    *data*))
+	 (test-patt    (let ((tp (dboard:data-get-test-patts *data*)))
+			 (if (equal? tp "") "%" tp)))
+	 (states       (dboard:data-get-states     *data*))
+	 (statuses     (dboard:data-get-statuses   *data*))
+	 (target       (let ((targ-list (dboard:data-get-target     *data*)))
+			 (if targ-list (string-intersperse targ-list "/") "no-target-selected")))
+	 (run-name     (dboard:data-get-run-name   *data*))
+	 (states-str   (if (or (not states)
+			       (null? states))
+			   ""
+			   (conc " :state "  (string-intersperse states ","))))
+	 (statuses-str (if (or (not statuses)
+			       (null? statuses))
+			   ""
+			   (conc " :status " (string-intersperse statuses ","))))
+	 (full-cmd  "megatest"))
+    (case (string->symbol cmd)
+      ((runtests)
+       (set! full-cmd (conc full-cmd 
+			    " -runtests "
+			    test-patt
+			    " -target "
+			    target
+			    " :runname "
+			    run-name
+			    )))
+      ((remove-runs)
+       (set! full-cmd (conc full-cmd
+			    " -remove-runs :runname "
+			    run-name
+			    " -target " 
+			    target
+			    " -testpatt "
+			    test-patt
+			    states-str
+			    statuses-str
+			    )))
+      (else (set! full-cmd " no valid command ")))
+    (iup:attribute-set! cmd-tb "VALUE" full-cmd)))
+
+;; Display the tests as rows of boxes on the test/task pane
+;;
+(define (dashboard:draw-tests cnv xadj yadj tests-draw-state sorted-testnames)
   (canvas-clear! cnv)
-  (canvas-font-set! cnv "Courier New, -10")
+  (canvas-font-set! cnv "Helvetica, -10")
   (let-values (((sizex sizey sizexmm sizeymm) (canvas-size cnv))
 	       ((originx originy)             (canvas-origin cnv)))
-      (if (hash-table-ref/default test-draw-state 'first-time #t)
+      ;; (print "originx: " originx " originy: " originy)
+      ;; (canvas-origin-set! cnv 0 (- (/ sizey 2)))
+      (if (hash-table-ref/default tests-draw-state 'first-time #t)
 	  (begin
-	    (hash-table-set! test-draw-state 'first-time #f)
-	    (hash-table-set! test-draw-state 'scalef 8)
+	    (hash-table-set! tests-draw-state 'first-time #f)
+	    (hash-table-set! tests-draw-state 'scalef 8)
+	    (hash-table-set! tests-draw-state 'tests-info (make-hash-table))
+	    (hash-table-set! tests-draw-state 'selected-tests (make-hash-table))
 	    ;; set these 
-	    (hash-table-set! test-draw-state 'test-browse-xoffset 20) ;; (- 0 (* (/ sizex 2) (* 8 xadj))))
-	    (hash-table-set! test-draw-state 'test-browse-yoffset 20))) ;; (- 0 (* (/ sizey 2) (* 8 (- 1 yadj)))))))
-      (let* ((scalef (hash-table-ref/default test-draw-state 'scalef 8))
-	     (test-browse-xoffset (hash-table-ref test-draw-state 'test-browse-xoffset))
-	     (test-browse-yoffset (hash-table-ref test-draw-state 'test-browse-yoffset))
+	    (hash-table-set! tests-draw-state 'test-browse-xoffset 20) ;; (- 0 (* (/ sizex 2) (* 8 xadj))))
+	    (hash-table-set! tests-draw-state 'test-browse-yoffset 20))) ;; (- 0 (* (/ sizey 2) (* 8 (- 1 yadj)))))))
+      (let* ((scalef (hash-table-ref/default tests-draw-state 'scalef 8))
+	     (test-browse-xoffset (hash-table-ref tests-draw-state 'test-browse-xoffset))
+	     (test-browse-yoffset (hash-table-ref tests-draw-state 'test-browse-yoffset))
 	     (xtorig (+ test-browse-xoffset (* (/ sizex 2) scalef (- 0.5 xadj)))) ;;  (- xadj 1))))
 	     (ytorig (+ test-browse-yoffset (* (/ sizey 2) scalef (- yadj 0.5))))
 	     (boxw   90)
 	     (boxh   25)
 	     (gapx   20)
-	     (gapy   30))
-	(print "sizex: " sizex " sizey: " sizey " font: " (canvas-font cnv) " originx: " originx " originy: " originy " xtorig: " xtorig " ytorig: " ytorig " xadj: " xadj " yadj: " yadj)
+	     (gapy   30)
+	     (tests-hash     (hash-table-ref tests-draw-state 'tests-info))
+	     (selected-tests (hash-table-ref tests-draw-state 'selected-tests )))
+	;; (print "sizex: " sizex " sizey: " sizey " font: " (canvas-font cnv) " originx: " originx " originy: " originy " xtorig: " xtorig " ytorig: " ytorig " xadj: " xadj " yadj: " yadj)
 	(let loop ((hed (car (reverse sorted-testnames)))
 		   (tal (cdr (reverse sorted-testnames)))
 		   (llx xtorig)
 		   (lly ytorig)
 		   (urx (+ xtorig boxw))
 		   (ury (+ ytorig boxh)))
 	  ; (print "hed " hed " llx " llx " lly " lly " urx " urx " ury " ury)
 	  (canvas-text! cnv (+ llx 5)(+ lly 5) hed) ;; (conc testname " (" xtorig "," ytorig ")"))
 	  (canvas-rectangle! cnv llx urx lly ury)
+	  (if (hash-table-ref/default selected-tests hed #f)
+	      (canvas-box! cnv llx (+ llx 5) lly (+ lly 5)))
+	  (hash-table-set! tests-hash hed (list llx urx (- sizey ury)(- sizey lly))) ;; NB// Swap ury and lly
 	  (if (not (null? tal))
 	      ;; leave a column of space to the right to list items
 	      (let ((have-room 
 		     (if #t ;; put "auto" here where some form of auto rearanging can be done
 			 (> (* 3 (+ boxw gapx)) (- urx xtorig))
@@ -556,56 +614,236 @@
 		      (if have-room (+ llx boxw gapx) xtorig) ;; have room, 
 		      (if have-room lly (+ lly boxh gapy))
 		      (if have-room (+ urx boxw gapx) (+ xtorig boxw))
 		      (if have-room ury (+ ury boxh gapy)))))))))
 
+;;======================================================================
+;; R U N   C O N T R O L S
+;;======================================================================
+;;
+;; A gui for launching tests
+;;
 (define (dashboard:run-controls)
   (let* ((targets       (make-hash-table))
-	 (runconf-targs (common:get-runconfig-targets))
 	 (test-records  (make-hash-table))
 	 (test-names    (tests:get-valid-tests *toppath* '()))
 	 (sorted-testnames #f)
 	 (action        "-runtests")
 	 (cmdln         "")
 	 (runlogs       (make-hash-table))
 	 (key-listboxes #f)
-	 (update-keyvals (lambda (obj b c d)
-			   ;; (print "obj: " obj ", b " b ", c " c ", d " d)
-			   (dashboard:update-target-selector key-listboxes)
-			   ))
-	 (tests-draw-state (make-hash-table))) ;; use for keeping state of the test canvas
+	 (updater-for-runs #f)
+	 (update-keyvals (lambda ()
+			   (let ((targ (map (lambda (x)
+					      (iup:attribute x "VALUE"))
+					    (car (dashboard:update-target-selector key-listboxes)))))
+			     (dboard:data-set-target! *data* targ)
+			     (if updater-for-runs (updater-for-runs))
+			     (dashboard:update-run-command))))
+	 (tests-draw-state (make-hash-table)) ;; use for keeping state of the test canvas
+	 (test-patterns-textbox  #f))
     (hash-table-set! tests-draw-state 'first-time #t)
     (hash-table-set! tests-draw-state 'scalef 8)
     (tests:get-full-data test-names test-records '())
     (set! sorted-testnames (tests:sort-by-priority-and-waiton test-records))
     
     ;; refer to *keys*, *dbkeys* for keys
     (iup:vbox
-     (iup:hbox
-       ;; Target and action
-      (iup:frame
-       #:title "Target"
-       (iup:vbox
-        ;; Target selectors
-        (apply iup:hbox
-	       (let* ((dat      (dashboard:update-target-selector key-listboxes action-proc: update-keyvals))
-		      (key-lb   (car dat))
-		      (combos   (cadr dat)))
-		 (set! key-listboxes key-lb)
-		 combos))))
-      (iup:frame
-       #:title "Tests and Tasks"
-       (iup:vbox
+     ;; The command line display/exectution control
+     (iup:frame
+      #:title "Command to be exectuted"
+      (iup:hbox
+       (iup:label "Run on" #:size "40x")
+       (iup:radio 
+	(iup:hbox
+	 (iup:toggle "Local" #:size "40x")
+	 (iup:toggle "Server" #:size "40x")))
+       (let ((tb (iup:textbox 
+		  #:value "megatest "
+		  #:expand "HORIZONTAL"
+		  #:readonly "YES"
+		  #:font "Courier New, -12"
+		  )))
+	 (dboard:data-set-command-tb! *data* tb)
+	 tb)
+       (iup:button "Execute" #:size "50x"
+		   #:action (lambda (obj)
+			      (let ((cmd (conc "xterm -geometry 180x20 -e \""
+					       (iup:attribute (dboard:data-get-command-tb *data*) "VALUE")
+					       ";echo Press any key to continue;bash -c 'read -n 1 -s'\" &")))
+				(system cmd))))))
+
+     (iup:split
+      #:orientation "HORIZONTAL"
+      
+      (iup:split
+       #:value 300
+
+       ;; Target, testpatt, state and status input boxes
+       ;;
+       (iup:vbox
+	;; Command to run
+	(iup:frame
+	 #:title "Set the action to take"
+	 (iup:hbox
+	  ;; (iup:label "Command to run" #:expand "HORIZONTAL" #:size "70x" #:alignment "LEFT:ACENTER")
+	  (let* ((cmds-list '("runtests" "remove-runs" "set-state-status" "lock-runs" "unlock-runs"))
+		 (lb         (iup:listbox #:expand "HORIZONTAL"
+					  #:dropdown "YES"
+					  #:action (lambda (obj val index lbstate)
+						     ;; (print obj " " val " " index " " lbstate)
+						     (dboard:data-set-command! *data* val)
+						     (dashboard:update-run-command))))
+		 (default-cmd (car cmds-list)))
+	    (iuplistbox-fill-list lb cmds-list selected-item: default-cmd)
+	    (dboard:data-set-command! *data* default-cmd)
+	    lb)))
+
+	(iup:frame
+	 #:title "Runname"
+	 (let* ((default-run-name (conc "ww" (seconds->work-week/day (current-seconds))))
+		(tb (iup:textbox #:expand "HORIZONTAL"
+				 #:action (lambda (obj val txt)
+					    ;; (print "obj: " obj " val: " val " unk: " unk)
+					    (dboard:data-set-run-name! *data* txt) ;; (iup:attribute obj "VALUE"))
+					    (dashboard:update-run-command))
+				 #:value default-run-name))
+		(lb (iup:listbox #:expand "HORIZONTAL"
+				 #:dropdown "YES"
+				 #:action (lambda (obj val index lbstate)
+					    (iup:attribute-set! tb "VALUE" val)
+					    (dboard:data-set-run-name! *data* val)
+					    (dashboard:update-run-command))))
+		(refresh-runs-list (lambda ()
+				     (let* ((target        (dboard:data-get-target-string *data*))
+					    (runs-for-targ (mt:get-runs-by-patt *keys* "%" target))
+					    (runs-header   (vector-ref runs-for-targ 0))
+					    (runs-dat      (vector-ref runs-for-targ 1))
+					    (run-names     (cons default-run-name 
+								 (map (lambda (x)
+									(db:get-value-by-header x runs-header "runname"))
+								      runs-dat))))
+				       (iup:attribute-set! lb "REMOVEITEM" "ALL")
+				       (iuplistbox-fill-list lb run-names selected-item: default-run-name)))))
+	   (set! updater-for-runs refresh-runs-list)
+	   (refresh-runs-list)
+	   (dboard:data-set-run-name! *data* default-run-name)
+	   (iup:hbox
+	    tb
+	    lb)))
+
+	(iup:frame
+	 #:title "SELECTORS"
+	 (iup:vbox
+	  ;; Text box for test patterns
+	  (iup:frame
+	   #:title "Test patterns (one per line)"
+	   (let ((tb (iup:textbox #:action (lambda (val a b)
+					     (dboard:data-set-test-patts!
+					      *data*
+					      (dboard:lines->test-patt b))
+					     (dashboard:update-run-command))
+				  #:value (dboard:test-patt->lines
+					   (dboard:data-get-test-patts *data*))
+				  #:expand "YES"
+				  #:multiline "YES")))
+	     (set! test-patterns-textbox tb)
+	     tb))
+	  (iup:frame
+	   #:title "Target"
+	   ;; Target selectors
+	   (apply iup:hbox
+		  (let* ((dat      (dashboard:update-target-selector key-listboxes action-proc: update-keyvals))
+			 (key-lb   (car dat))
+			 (combos   (cadr dat)))
+		    (set! key-listboxes key-lb)
+		    combos)))
+	  (iup:hbox
+	   ;; Text box for STATES
+	   (iup:frame
+	    #:title "States"
+	    (dashboard:text-list-toggle-box 
+	     ;; Move these definitions to common and find the other useages and replace!
+	     '("COMPLETED" "RUNNING" "STUCK" "INCOMPLETE" "LAUNCHED" "REMOTEHOSTSTART" "KILLED")
+	     (lambda (all)
+	       (dboard:data-set-states! *data* all)
+	       (dashboard:update-run-command))))
+	   ;; Text box for STATES
+	   (iup:frame
+	    #:title "Statuses"
+	    (dashboard:text-list-toggle-box 
+	     '("PASS" "FAIL" "n/a" "CHECK" "WAIVED" "SKIP" "DELETED" "STUCK/DEAD")
+	     (lambda (all)
+	       (dboard:data-set-statuses! *data* all)
+	       (dashboard:update-run-command))))))))
+      
+       (iup:frame
+	#:title "Tests and Tasks"
+	(let* ((updater #f)
+	       (last-xadj 0)
+	       (last-yadj 0)
+	       (canvas-obj   
 	(iup:canvas #:action (make-canvas-action
 			      (lambda (cnv xadj yadj)
-				;; (print "cnv: " cnv " x: " x " y: " y)
-				(dashboard:draw-tests cnv xadj yadj tests-draw-state sorted-testnames)))
+				(if (not updater)
+				    (set! updater (lambda (xadj yadj)
+						    ;; (print "cnv: " cnv " x: " x " y: " y)
+						    (dashboard:draw-tests cnv xadj yadj tests-draw-state sorted-testnames))))
+				(updater xadj yadj)
+				(set! last-xadj xadj)
+				(set! last-yadj yadj)))
+		    ;; Following doesn't work 
+		    ;; #:wheel-cb (make-canvas-action
+		    ;;           (lambda (cnv xadj yadj)
+		    ;;    	 ;; (print "cnv: " cnv " x: " x " y: " y)
+		    ;;    	 (dashboard:draw-tests cnv xadj yadj tests-draw-state sorted-testnames)))
 		    #:size "150x150"
 		    #:expand "YES"
 		    #:scrollbar "YES"
 		    #:posx "0.5"
-		    #:posy "0.5")))))))
+		    #:posy "0.5"
+		    #:button-cb (lambda (obj btn pressed x y status)
+				  ;; (print "obj: " obj)
+				  (let ((tests-info     (hash-table-ref tests-draw-state  'tests-info))
+					(selected-tests (hash-table-ref tests-draw-state  'selected-tests)))
+				    ;; (print "x\ty\tllx\tlly\turx\tury")
+				    (for-each (lambda (test-name)
+						(let* ((rec-coords (hash-table-ref tests-info test-name))
+						       (llx        (list-ref rec-coords 0))
+						       (urx        (list-ref rec-coords 1))
+						       (lly        (list-ref rec-coords 2))
+						       (ury        (list-ref rec-coords 3)))
+						  ;; (print x "\t" y "\t" llx "\t" lly "\t" urx "\t" ury "\t" test-name " "
+						  (if (and (eq? pressed 1)
+							   (> x llx)
+							   (> y lly)
+							   (< x urx)
+							   (< y ury))
+						      (let ((patterns (string-split (iup:attribute test-patterns-textbox "VALUE"))))
+							(let* ((selected     (not (member test-name patterns)))
+							       (newpatt-list (if selected
+										 (cons test-name patterns)
+										 (delete test-name patterns)))
+							       (newpatt      (string-intersperse newpatt-list "\n")))
+							  ;; (if cnv-obj
+							  ;;    (dashboard:draw-tests cnv-obj 0 0 tests-draw-state sorted-testnames))
+							  (iup:attribute-set! obj "REDRAW" "ALL")
+							  (hash-table-set! selected-tests test-name selected)
+							  (iup:attribute-set! test-patterns-textbox "VALUE" newpatt)
+							  (dboard:data-set-test-patts! *data* (dboard:lines->test-patt newpatt))
+							  (dashboard:update-run-command)
+							  (if updater (updater last-xadj last-yadj)))))))
+					      (hash-table-keys tests-info)))))))
+	  canvas-obj)))
+      ;; (print "obj: " obj " btn: " btn " pressed: " pressed " x: " x " y: " y " status: " status))
+      
+      (iup:frame
+       #:title "Logs" ;; To be replaced with tabs
+       (let ((logs-tb (iup:textbox #:expand "YES"
+				   #:multiline "YES")))
+	 (dboard:data-set-logs-textbox! *data* logs-tb)
+	 logs-tb))))))
 
 
 ;; (trace dashboard:populate-target-dropdown
 ;;        common:list-is-sublist)
 ;; 
@@ -628,11 +866,180 @@
 ;;      )
 ;;     ;; The command log monitor
 ;;     (iup:tabs
 ;;      ;; log monitor
 ;;      )))
-   
+
+;;======================================================================
+;; S U M M A R Y 
+;;======================================================================
+;;
+;; General info about the run(s) and megatest area
+(define (dashboard:summary)
+  (let ((rawconfig        (read-config (conc *toppath* "/megatest.config") #f 'return-string)))
+    (iup:vbox
+     (iup:frame 
+      #:title "General Info"
+      (iup:hbox 
+       (dcommon:general-info)
+       (dcommon:keys-matrix rawconfig)))
+     (iup:frame 
+      #:title "Megatest config settings"
+      (iup:hbox
+       (dcommon:section-matrix rawconfig "setup" "Varname" "Value")
+       (iup:vbox
+	(dcommon:section-matrix rawconfig "server" "Varname" "Value")
+	;; (iup:frame
+	;; #: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)
@@ -692,11 +1099,11 @@
 		     (iup:toggle status  #:action   (lambda (obj val)
 						      (mark-for-update)
 						      (if (eq? val 1)
 							  (hash-table-set! *status-ignore-hash* status #t)
 							  (hash-table-delete! *status-ignore-hash* status)))))
-	      '("PASS" "FAIL" "WARN" "CHECK" "WAIVED" "STUCK/DEAD" "n/a" "SKIP")))
+		   '("PASS" "FAIL" "WARN" "CHECK" "WAIVED" "STUCK/DEAD" "n/a" "SKIP")))
 	     (apply 
 	      iup:hbox
 	      (map (lambda (state)
 		     (iup:toggle state   #:action   (lambda (obj val)
 						      (mark-for-update)
@@ -712,54 +1119,54 @@
 						 (mark-for-update)
 						 (debug:print 6 "*start-run-offset* " *start-run-offset* " maxruns: " maxruns ", val: " val " oldmax: " oldmax)
 						 (iup:attribute-set! obj "MAX" (* maxruns 10))))
 			   #:expand "YES"
 			   #:max (* 10 (length *allruns*)))))
-	   ;(iup:button "inc rows" #:action (lambda (obj)(set! *num-tests* (+ *num-tests* 1))))
-	   ;(iup:button "dec rows" #:action (lambda (obj)(set! *num-tests* (if (> *num-tests* 0)(- *num-tests* 1) 0))))
+					;(iup:button "inc rows" #:action (lambda (obj)(set! *num-tests* (+ *num-tests* 1))))
+					;(iup:button "dec rows" #:action (lambda (obj)(set! *num-tests* (if (> *num-tests* 0)(- *num-tests* 1) 0))))
 	   )
 	  )
     
     ;; create the left most column for the run key names and the test names 
     (set! lftlst (list (iup:hbox
 			(iup:label) ;; (iup:valuator)
 			(apply iup:vbox 
 			       (map (lambda (x)		
 				      (let ((res (iup:hbox #:expand "HORIZONTAL"
-						  (iup:label x #:size "x15" #:fontsize "10" #:expand "HORIZONTAL")
-						  (iup:textbox #:size "x15" #:fontsize "10" #:value "%" #:expand "HORIZONTAL"
-							       #:action (lambda (obj unk val)
-									  (mark-for-update)
-									  (update-search x val))))))
+							   (iup:label x #:size "x15" #:fontsize "10" #:expand "HORIZONTAL")
+							   (iup:textbox #:size "x15" #:fontsize "10" #:value "%" #:expand "HORIZONTAL"
+									#:action (lambda (obj unk val)
+										   (mark-for-update)
+										   (update-search x val))))))
 					(set! i (+ i 1))
 					res))
 				    keynames)))))
     (let loop ((testnum  0)
 	       (res      '()))
       (cond
        ((>= testnum ntests)
 	;; now lftlst will be an hbox with the test keys and the test name labels
 	(set! lftlst (append lftlst (list (iup:hbox  #:expand "HORIZONTAL"
-					   (iup:valuator #:valuechanged_cb (lambda (obj)
-									     (let ((val (string->number (iup:attribute obj "VALUE")))
-										   (oldmax  (string->number (iup:attribute obj "MAX")))
-										   (newmax  (* 10 (length *alltestnamelst*))))
-									       (set! *please-update-buttons* #t)
-									       (set! *start-test-offset* (inexact->exact (round (/ val 10))))
-									       (debug:print 6 "*start-test-offset* " *start-test-offset* " val: " val " newmax: " newmax " oldmax: " oldmax)
-									       (if (< val 10)
-										   (iup:attribute-set! obj "MAX" newmax))
-									       ))
-							 #:expand "VERTICAL" 
-							 #:orientation "VERTICAL")
-					   (apply iup:vbox (reverse res)))))))
+						     (iup:valuator #:valuechanged_cb (lambda (obj)
+										       (let ((val (string->number (iup:attribute obj "VALUE")))
+											     (oldmax  (string->number (iup:attribute obj "MAX")))
+											     (newmax  (* 10 (length *alltestnamelst*))))
+											 (set! *please-update-buttons* #t)
+											 (set! *start-test-offset* (inexact->exact (round (/ val 10))))
+											 (debug:print 6 "*start-test-offset* " *start-test-offset* " val: " val " newmax: " newmax " oldmax: " oldmax)
+											 (if (< val 10)
+											     (iup:attribute-set! obj "MAX" newmax))
+											 ))
+								   #:expand "VERTICAL" 
+								   #:orientation "VERTICAL")
+						     (apply iup:vbox (reverse res)))))))
        (else
 	(let ((labl  (iup:button "" 
 				 #:flat "YES" 
 				 #:alignment "ALEFT"
-				 ; #:image img1
-				 ; #:impress img2
+					; #:image img1
+					; #:impress img2
 				 #:size "x15"
 				 #:expand "HORIZONTAL"
 				 #:fontsize "10"
 				 #:action (lambda (obj)
 					    (mark-for-update)
@@ -801,73 +1208,113 @@
 				       #:action (lambda (x)
 						  (let* ((toolpath (car (argv)))
 							 (buttndat (hash-table-ref *buttondat* button-key))
 							 (test-id  (db:test-get-id (vector-ref buttndat 3)))
 							 (cmd  (conc toolpath " -test " test-id "&")))
-						    ;(print "Launching " cmd)
+					;(print "Launching " cmd)
 						    (system cmd))))))
 	  (hash-table-set! *buttondat* button-key (vector 0 "100 100 100" button-key #f #f)) 
 	  (vector-set! testvec testnum butn)
 	  (loop runnum (+ testnum 1) testvec (cons butn res))))))
     ;; now assemble the hdrlst and bdylst and kick off the dialog
     (iup:show
      (iup:dialog 
-      #:title "Megatest dashboard"
-      (let ((tabs (iup:tabs
-		   (iup:vbox
-		    (apply iup:hbox 
-			   (cons (apply iup:vbox lftlst)
-				 (list 
-				  (iup:vbox
-				   ;; the header
-				   (apply iup:hbox (reverse hdrlst))
-				   (apply iup:hbox (reverse bdylst))))))
-		    controls)
-		   (dashboard:run-controls)
-		   )))
-	(iup:attribute-set! tabs "TABTITLE0" "Runs")
-	(iup:attribute-set! tabs "TABTITLE1" "Run Control")
+      #:title (conc "Megatest dashboard " (current-user-name) ":" *toppath*)
+      #:menu (dcommon:main-menu)
+      (let* ((runs-view (iup:vbox
+			 (apply iup:hbox 
+				(cons (apply iup:vbox lftlst)
+				      (list 
+				       (iup:vbox
+					;; the header
+					(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 Summary")
+	(iup:attribute-set! tabs "TABTITLE3" "Run Control")
 	tabs)))
-     (vector keycol lftcol header runsvec)))
+    (vector keycol lftcol header runsvec)))
 
 (if (or (args:get-arg "-rows")
 	(get-environment-variable "DASHBOARDROWS" ))
     (begin
-        (set! *num-tests* (string->number (or (args:get-arg "-rows")
-					      (get-environment-variable "DASHBOARDROWS"))))
-	(update-rundat "%" *num-runs* "%/%" '()))
+      (set! *num-tests* (string->number (or (args:get-arg "-rows")
+					    (get-environment-variable "DASHBOARDROWS"))))
+      (update-rundat "%" *num-runs* "%/%" '()))
     (set! *num-tests* (min (max (update-rundat "%" *num-runs* "%/%" '()) 8) 20)))
 
 (define *tim* (iup:timer))
 (define *ord* #f)
 (iup:attribute-set! *tim* "TIME" 300)
 (iup:attribute-set! *tim* "RUN" "YES")
 
-;; Move this stuff to db.scm FIXME
+;; Move this stuff to db.scm? I'm not sure that is the right thing to do...
 ;;
 (define *last-db-update-time* (file-modification-time (conc *toppath* "/megatest.db")))
-(define (db:been-changed)
+
+(define (dashboard:been-changed)
   (> (file-modification-time (conc *toppath* "/megatest.db")) *last-db-update-time*))
-(define (db:set-db-update-time)
+
+(define (dashboard:set-db-update-time)
   (set! *last-db-update-time* (file-modification-time (conc *toppath* "/megatest.db"))))
 
-(define (run-update x)
-  (update-buttons uidat *num-runs* *num-tests*)
-  ;; (if (db:been-changed)
-  (begin
-    (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))
-    ; (db:set-db-update-time)
-    ))
+(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)
+  (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
@@ -878,11 +1325,11 @@
 	    (cdb:remote-run examine-run *db* runid)))
 	(begin
 	  (print "ERROR: runid is not a number " (args:get-arg "-run"))
 	  (exit 1)))))
  ((args:get-arg "-test")
-    (let ((testid (string->number (args:get-arg "-test"))))
+  (let ((testid (string->number (args:get-arg "-test"))))
     (if testid
 	(examine-test testid)
 	(begin
 	  (print "ERROR: testid is not a number " (args:get-arg "-test"))
 	  (exit 1)))))
@@ -891,9 +1338,9 @@
  (else
   (set! uidat (make-dashboard-buttons *num-runs* *num-tests* *dbkeys*))
   (iup:callback-set! *tim*
 		     "ACTION_CB"
 		     (lambda (x)
-		       (run-update x)))))
-		       ;(print x)))))
+		       (dashboard:run-update x)
+		       1))))
 
 (iup:main-loop)

Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -596,11 +596,11 @@
 	   db
 	   (let ((qry (conc "SELECT id FROM runs WHERE (runname=? " andstr key=?str ");")))
 	     ;(debug:print 4 "qry: " qry) 
 	     qry)
 	   qryvals)
-	  (sqlite3:execute db "UPDATE runs SET state=?,status=? WHERE id=?;" state status res)
+	  (sqlite3:execute db "UPDATE runs SET state=?,status=?,event_time=strftime('%s','now') WHERE id=?;" state status res)
 	  res) 
 	(begin
 	  (debug:print 0 "ERROR: Called without all necessary keys")
 	  #f))))
 
@@ -676,10 +676,31 @@
        (set! numruns count))
      db
      "SELECT COUNT(id) FROM runs WHERE runname LIKE ? AND state != 'deleted';" runpatt)
     (debug:print-info 11 "db:get-num-runs END " runpatt)
     numruns))
+
+;; get some basic run stats
+;;
+;; ( (runname (( state  count ) ... ))
+;;   (   ...  
+(define (db:get-run-stats db)
+  (let ((totals       (make-hash-table))
+	(res          '()))
+    (sqlite3:for-each-row
+     (lambda (runname state count)
+       (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,s DESC;" )
+    ;; (set! res (reverse res))
+    (for-each (lambda (state)
+		(set! res (cons (list "Totals" state (hash-table-ref totals state)) res)))
+	      (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
 ;;
@@ -692,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")))
@@ -704,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 ";"))
+    (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 
@@ -828,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
@@ -2127,17 +2149,24 @@
 		  (set! ever-seen #t)
 		  (cond
 		   ;; case 1, non-item (parent test) is 
 		   ((and (equal? item-path "") ;; this is the parent test
 			 is-completed
-			 (or is-ok (eq? mode 'toplevel)))
+			 (or is-ok (member mode '(toplevel itemmatch))))
 		    (set! parent-waiton-met #t))
-		   ((and same-itempath
-			 is-completed
-			 (or is-ok (eq? mode 'toplevel)))
+		   ((or (and (not same-itempath)
+			     (eq? mode 'itemmatch))  ;; in itemmatch mode we look only at the same itempath
+			(and same-itempath
+			     is-completed
+			     (or is-ok 
+				 (eq? mode 'toplevel)              ;; toplevel does not block on FAIL
+				 (and is-ok (eq? mode 'itemmatch)) ;; itemmatch blocks on not ok
+				 )))
 		    (set! item-waiton-met #t)))))
 	      tests)
+             ;; both requirements, parent and item-waiton must be met to NOT add item to
+             ;; prereq's not met list
 	     (if (not (or parent-waiton-met item-waiton-met))
 		 (set! result (append (if (null? tests) (list waitontest-name) tests) result)))
 	     ;; if the test is not found then clearly the waiton is not met...
 	     ;; (if (not ever-seen)(set! result (cons waitontest-name result)))))
 	     (if (not ever-seen)

ADDED   dcommon.scm
Index: dcommon.scm
==================================================================
--- /dev/null
+++ dcommon.scm
@@ -0,0 +1,457 @@
+;;======================================================================
+;; 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 regex)
+
+(declare (unit dcommon))
+
+(declare (uses megatest-version))
+(declare (uses gutils))
+(declare (uses db))
+(declare (uses synchash))
+
+(include "common_records.scm")
+(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 25 #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))
+;; For test-patts convert #f to ""
+(define (dboard:data-get-test-patts    vec)    
+  (let ((val (vector-ref  vec 12)))(if val val "")))
+(define (dboard:data-get-states        vec)    (vector-ref vec 13))
+(define (dboard:data-get-statuses      vec)    (vector-ref vec 14))
+(define (dboard:data-get-logs-textbox  vec val)(vector-ref vec 15))
+(define (dboard:data-get-command       vec)    (vector-ref vec 16))
+(define (dboard:data-get-command-tb    vec)    (vector-ref vec 17))
+(define (dboard:data-get-target        vec)    (vector-ref vec 18))
+(define (dboard:data-get-target-string vec)
+  (let ((targ (dboard:data-get-target vec)))
+    (if (list? targ)(string-intersperse targ "/") "no-target-specified")))
+(define (dboard:data-get-run-name      vec)    (vector-ref vec 19))
+(define (dboard:data-get-runs-listbox  vec)    (vector-ref vec 20))
+
+(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 11 val))
+;; For test-patts convert "" to #f 
+(define (dboard:data-set-test-patts!    vec val)
+  (vector-set! vec 12 (if (equal? val "") #f val)))
+(define (dboard:data-set-states!        vec val)(vector-set! vec 13 val))
+(define (dboard:data-set-statuses!      vec val)(vector-set! vec 14 val))
+(define (dboard:data-set-logs-textbox!  vec val)(vector-set! vec 15 val))
+(define (dboard:data-set-command!       vec val)(vector-set! vec 16 val))
+(define (dboard:data-set-command-tb!    vec val)(vector-set! vec 17 val))
+(define (dboard:data-set-target!        vec val)(vector-set! vec 18 val))
+(define (dboard:data-set-run-name!      vec val)(vector-set! vec 19 val))
+(define (dboard:data-set-runs-listbox!  vec val)(vector-set! vec 20 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))
+
+;;======================================================================
+;; TARGET AND PATTERN MANIPULATIONS
+;;======================================================================
+
+;; Convert to and from list of lines (for a text box)
+;; "," => "\n"
+(define (dboard:test-patt->lines test-patt)
+  (string-substitute (regexp ",") "\n" test-patt))
+
+(define (dboard:lines->test-patt lines)
+  (string-substitute (regexp "\n") "," lines #t))
+
+
+;;======================================================================
+;; 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
+;;======================================================================
+
+;; Table of keys
+(define (dcommon:keys-matrix rawconfig)
+  (let* ((curr-row-num 1)
+	 (key-vals     (configf:section-vars rawconfig "fields"))
+	 (keys-matrix  (iup:matrix
+			#:alignment1 "ALEFT"
+			#:expand "YES" ;; "HORIZONTAL" ;; "VERTICAL"
+			;; #:scrollbar "YES"
+			#:numcol 1
+			#:numlin (length key-vals)
+			#:numcol-visible 1
+			#:numlin-visible (length key-vals)
+			#:click-cb (lambda (obj lin col status)
+				     (print "obj: " obj " lin: " lin " col: " col " status: " status)))))
+    (iup:attribute-set! keys-matrix "0:0" "Run Keys")
+    (iup:attribute-set! keys-matrix "0:1" "Key Name")
+    ;; (iup:attribute-set! keys-matrix "WIDTH1" "100")
+    ;; fill in keys
+    (for-each 
+     (lambda (var)
+       ;; (iup:attribute-set! keys-matrix "ADDLIN" (conc curr-row-num))
+       (iup:attribute-set! keys-matrix (conc curr-row-num ":0") curr-row-num)
+       (iup:attribute-set! keys-matrix (conc curr-row-num ":1") var)
+       (set! curr-row-num (+ 1 curr-row-num))) ;; (config-lookup *configdat* "fields" var)))
+     key-vals)
+    keys-matrix))
+
+;; Section to table
+(define (dcommon:section-matrix rawconfig sectionname varcolname valcolname #!key (title #f))
+  (let* ((curr-row-num    1)
+	 (key-vals        (configf:section-vars rawconfig sectionname))
+	 (section-matrix  (iup:matrix
+			   #:alignment1 "ALEFT"
+			   #:expand "YES" ;; "HORIZONTAL"
+			   #:numcol 1
+			   #:numlin (length key-vals)
+			   #:numcol-visible 1
+			   #:numlin-visible (length key-vals)
+			   #:scrollbar "YES")))
+    (iup:attribute-set! section-matrix "0:0" varcolname)
+    (iup:attribute-set! section-matrix "0:1" valcolname)
+    (iup:attribute-set! section-matrix "WIDTH1" "200")
+    ;; fill in keys
+    (for-each 
+     (lambda (var)
+       ;; (iup:attribute-set! keys-matrix "ADDLIN" (conc curr-row-num))
+       (iup:attribute-set! section-matrix (conc curr-row-num ":0") var)
+       (iup:attribute-set! section-matrix (conc curr-row-num ":1") (configf:lookup rawconfig sectionname var))
+       (set! curr-row-num (+ 1 curr-row-num))) ;; (config-lookup *configdat* "fields" var)))
+     key-vals)
+    (iup:vbox
+     (iup:label (if title title (conc "Settings from [" sectionname "]"))  
+		#:size   "5x"
+		#:expand "HORIZONTAL"
+		)
+     section-matrix)))
+    
+;; General data
+;;
+(define (dcommon:general-info)
+  (let ((general-matrix (iup:matrix
+			 #:alignment1 "ALEFT"
+			 #:expand "YES" ;; "HORIZONTAL"
+			 #:numcol 1
+			 #:numlin 3
+			 #:numcol-visible 1
+			 #:numlin-visible 3)))
+    (iup:attribute-set! general-matrix "WIDTH1" "200")
+    (iup:attribute-set! general-matrix "0:1" "About this Megatest area") 
+    ;; User (this is not always obvious - it is common to run as a different user
+    (iup:attribute-set! general-matrix "1:0" "User")
+    (iup:attribute-set! general-matrix "1:1" (current-user-name))
+    ;; Megatest area
+    (iup:attribute-set! general-matrix "2:0" "Megatest area")
+    (iup:attribute-set! general-matrix "2:1" *toppath*)
+    ;; Megatest version
+    (iup:attribute-set! general-matrix "3:0" "Megatest version")
+    (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))
+				(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))
+			   (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))
+					      (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))
+					      (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)))
+					      (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")
+     stats-matrix)))
+
+;; The main menu
+(define (dcommon:main-menu)
+  (iup:menu ;; a menu is a special attribute to a dialog (think Gnome putting the menu at screen top)
+   (iup:menu-item "Files" (iup:menu   ;; Note that you can use either #:action or action: for options
+		       (iup:menu-item "Open"  action: (lambda (obj)
+							(iup:show (iup:file-dialog))
+							(print "File->open " obj)))
+		       (iup:menu-item "Save"  #:action (lambda (obj)(print "File->save " obj)))
+		       (iup:menu-item "Exit"  #:action (lambda (obj)(exit)))))
+   (iup:menu-item "Tools" (iup:menu
+		       (iup:menu-item "Create new blah" #:action (lambda (obj)(print "Tools->new blah")))
+		       ;; (iup:menu-item "Show dialog"     #:action (lambda (obj)
+		       ;;  					   (show message-window
+		       ;;  					     #:modal? #t
+		       ;;  					     ;; set positon using coordinates or center, start, top, left, end, bottom, right, parent-center, current
+		       ;;  					     ;; #:x 'mouse
+		       ;;  					     ;; #:y 'mouse
+		       ;;  )					     
+		       ))))
+

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: megatest-version.scm
==================================================================
--- megatest-version.scm
+++ megatest-version.scm
@@ -1,7 +1,7 @@
 ;; Always use two digit decimal
 ;; 1.01, 1.02...1.10,1.11 ... 1.99,2.00..
 
 (declare (unit megatest-version))
 
-(define megatest-version 1.5506)
+(define megatest-version 1.5507)
 

Index: mt.scm
==================================================================
--- mt.scm
+++ mt.scm
@@ -45,23 +45,26 @@
 
 ;;======================================================================
 ;;  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))))
 
 (define (mt:get-prereqs-not-met run-id waitons ref-item-path #!key (mode 'normal))
   (db:get-prereqs-not-met run-id waitons ref-item-path mode: mode))
+
+(define (mt:get-run-stats)
+  (cdb:remote-run db:get-run-stats #f))

Index: newdashboard.scm
==================================================================
--- newdashboard.scm
+++ newdashboard.scm
@@ -1,7 +1,7 @@
 ;;======================================================================
-;; Copyright 2006-2012, Matthew Welland.
+;; 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
@@ -22,10 +22,12 @@
 (declare (uses megatest-version))
 (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")
 
@@ -82,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
@@ -145,49 +115,17 @@
   (string-intersperse (map conc x) ","))
 
 (define (update-search x val)
   (hash-table-set! *searchpatts* x val))
 
-(define (main-menu)
-  (iup:menu ;; a menu is a special attribute to a dialog (think Gnome putting the menu at screen top)
-   (iup:menu-item "Files" (iup:menu   ;; Note that you can use either #:action or action: for options
-		       (iup:menu-item "Open"  action: (lambda (obj)
-							(iup:show (iup:file-dialog))
-							(print "File->open " obj)))
-		       (iup:menu-item "Save"  #:action (lambda (obj)(print "File->save " obj)))
-		       (iup:menu-item "Exit"  #:action (lambda (obj)(exit)))))
-   (iup:menu-item "Tools" (iup:menu
-		       (iup:menu-item "Create new blah" #:action (lambda (obj)(print "Tools->new blah")))
-		       ;; (iup:menu-item "Show dialog"     #:action (lambda (obj)
-		       ;;  					   (show message-window
-		       ;;  					     #:modal? #t
-		       ;;  					     ;; set positon using coordinates or center, start, top, left, end, bottom, right, parent-center, current
-		       ;;  					     ;; #:x 'mouse
-		       ;;  					     ;; #:y 'mouse
-		       ;;  )					     
-		       ))))
-
 ;; mtest is actually the megatest.config file
 ;;
 (define (mtest window-id)
   (let* ((curr-row-num     0)
 	 (rawconfig        (read-config (conc *toppath* "/megatest.config") #f 'return-string))
-	 (keys-matrix      (iup:matrix
-		            #:expand "VERTICAL"
-		            ;; #:scrollbar "YES"
-		            #:numcol 1
-		            #:numlin 20
-		            #:numcol-visible 1
-		            #:numlin-visible 5
-		            #:click-cb (lambda (obj lin col status)
-					 (print "obj: " obj " lin: " lin " col: " col " status: " status))))
-	 (setup-matrix     (iup:matrix
-		            #:expand "YES"
-		            #:numcol 1
-		            #:numlin 5
-		            #:numcol-visible 1
-		            #:numlin-visible 3))
+	 (keys-matrix      (dcommon:keys-matrix rawconfig))
+	 (setup-matrix     (dcommon:section-matrix rawconfig "setup" "Varname" "Value"))
 	 (jobtools-matrix  (iup:matrix
 			    #:expand "YES"
 			    #:numcol 1
 			    #:numlin 5
 			    #:numcol-visible 1
@@ -209,28 +147,17 @@
 			    #:numcol 1
 			    #:numlin 20
 			    #:numcol-visible 1
 			    #:numlin-visible 8))
 	 )
-    (iup:attribute-set! keys-matrix "0:0" "Field Num")
-    (iup:attribute-set! keys-matrix "0:1" "Field Name")
-    (iup:attribute-set! keys-matrix "WIDTH1" "100")
     (iup:attribute-set! disks-matrix "0:0" "Disk Name")
     (iup:attribute-set! disks-matrix "0:1" "Disk Path")
     (iup:attribute-set! disks-matrix "WIDTH1" "120")
     (iup:attribute-set! disks-matrix "WIDTH0" "100")
     (iup:attribute-set! disks-matrix "ALIGNMENT1" "ALEFT")
     (iup:attribute-set! disks-matrix "FIXTOTEXT" "C1")
     (iup:attribute-set! disks-matrix "RESIZEMATRIX" "YES")
-    ;; fill in keys
-    (set! curr-row-num 1)
-    (for-each 
-     (lambda (var)
-       (iup:attribute-set! keys-matrix (conc curr-row-num ":0") curr-row-num)
-       (iup:attribute-set! keys-matrix (conc curr-row-num ":1") var)
-       (set! curr-row-num (+ 1 curr-row-num))) ;; (config-lookup *configdat* "fields" var)))
-     (configf:section-vars rawconfig "fields"))
 
     ;; fill in existing info
     (for-each 
      (lambda (mat fname)
        (set! curr-row-num 1)
@@ -316,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)
@@ -589,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)
@@ -714,172 +543,19 @@
 ;; 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
 (define (main-panel window-id)
   (iup:dialog
    #:title "Megatest Control Panel"
-   #:menu (main-menu)
+   #:menu (dcommon:main-menu)
    (let ((tabtop (iup:tabs 
 		  (runs window-id)
 		  (tests window-id)
 		  (runcontrol window-id)
 		  (mtest window-id) 
@@ -897,11 +573,11 @@
 (define (newdashboard)
   (let* ((data     (make-hash-table))
 	 (keys     (cdb:remote-run db:get-keys #f))
 	 (runname  "%")
 	 (testpatt "%")
-	 (keypatts (map (lambda (k)(list (vector-ref k 0) "%")) keys))
+	 (keypatts (map (lambda (k)(list k "%")) keys))
 	 (states   '())
 	 (statuses '())
 	 (nextmintime (current-milliseconds))
 	 (my-window-id *current-window-id*))
     (set! *current-window-id* (+ 1 *current-window-id*))

Index: tests/Makefile
==================================================================
--- tests/Makefile
+++ tests/Makefile
@@ -110,16 +110,27 @@
 test9c :
 	@echo Run mintest a with full waiton chain a -> b -> c -> d -> e
 	cd mintest;megatest -runtests a -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
 
 test9d :
-	@echo Run mintest f with an empty waiton spec
-	cd mintest;megatest -runtests f -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
+	@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,links}
+	mkdir -p mintest/runs mintest/links
 	cd mintest;megatest -stop-server 0
 	cd mintest;megatest -server - -debug $(DEBUG) > server.log 2> server.log & 
 	sleep 3
 	cd mintest;dashboard -rows 20 &
 

Index: tests/fdktestqa/testqa/Makefile
==================================================================
--- tests/fdktestqa/testqa/Makefile
+++ tests/fdktestqa/testqa/Makefile
@@ -1,10 +1,11 @@
 BINDIR    = $(PWD)/../../../bin
 PATH     := $(BINDIR):$(PATH)
 MEGATEST  = $(BINDIR)/megatest
 DASHBOARD = $(BINDIR)/dashboard
 all :
+	$(MEGATEST) -remove-runs -target a/b :runname c -testpatt %/%
 	$(MEGATEST) -runtests % -target a/b :runname c
 
 bigbig :
 	for tn in a b c d;do \
 	   ($(MEGATEST) -runtests % -target a/b :runname $tn & ) ; \

Index: tests/fdktestqa/testqa/tests/bigrun/step1.sh
==================================================================
--- tests/fdktestqa/testqa/tests/bigrun/step1.sh
+++ tests/fdktestqa/testqa/tests/bigrun/step1.sh
@@ -1,7 +1,8 @@
 #!/bin/sh
 if [ $NUMBER -lt 200 ];then 
+   sleep 20
    sleep $NUMBER
 else
    sleep 200
 fi
 

Index: tests/fdktestqa/testqa/tests/bigrun/testconfig
==================================================================
--- tests/fdktestqa/testqa/tests/bigrun/testconfig
+++ tests/fdktestqa/testqa/tests/bigrun/testconfig
@@ -7,11 +7,11 @@
 # waiton setup
 priority 0
 
 # Iteration for your tests are controlled by the items section
 [items]
-NUMBER #{scheme (string-intersperse (map number->string (sort (let loop ((a 0)(res '()))(if (< a (or (any->number (get-environment-variable "NUMTESTS")) 1100))(loop (+ a 1)(cons a res)) res)) >)) " ")}
+NUMBER #{scheme (string-intersperse (map number->string (sort (let loop ((a 0)(res '()))(if (<= a (or (any->number (get-environment-variable "NUMTESTS")) 2500))(loop (+ a 1)(cons a res)) res)) <)) " ")}
 
 # test_meta is a section for storing additional data on your test
 [test_meta]
 author matt
 owner  matt

Index: tests/fdktestqa/testqa/tests/bigrun2/testconfig
==================================================================
--- tests/fdktestqa/testqa/tests/bigrun2/testconfig
+++ tests/fdktestqa/testqa/tests/bigrun2/testconfig
@@ -2,18 +2,18 @@
 [ezsteps]
 step1 step1.sh
 
 # Test requirements are specified here
 [requirements]
-# waiton bigrun
+waiton bigrun
 priority 0
 mode itemmatch
 
 
 # Iteration for your tests are controlled by the items section
 [items]
-NUMBER #{scheme (string-intersperse (map number->string (sort (let loop ((a 0)(res '()))(if (< a 1500)(loop (+ a 1)(cons a res)) res)) >)) " ")}
+NUMBER #{scheme (string-intersperse (map number->string (sort (let loop ((a 0)(res '()))(if (<= a (or (any->number (get-environment-variable "NUMTESTS")) 2500))(loop (+ a 1)(cons a res)) res)) <)) " ")}
 
 # test_meta is a section for storing additional data on your test
 [test_meta]
 author matt
 owner  matt

Index: tests/fullrun/runconfigs.config
==================================================================
--- tests/fullrun/runconfigs.config
+++ tests/fullrun/runconfigs.config
@@ -22,5 +22,8 @@
 
 [default]
 SOMEVAR3 #{rget SOMEVAR}
 SOMEVAR4 #{rget SOMEVAR2}
 SOMEVAR5 #{runconfigs-get SOMEVAR2}
+
+[this/a/test]
+BLAHFOO 123

Index: tests/fullrun/tests/priority_3/main.sh
==================================================================
--- tests/fullrun/tests/priority_3/main.sh
+++ tests/fullrun/tests/priority_3/main.sh
@@ -2,10 +2,11 @@
 
 # a bunch of steps in 2 second increments
 for i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17;do
   $MT_MEGATEST -step step$i :state start :status running -setlog results$i.html
   sleep 2
+  echo "<html><header>Results$i</header><body>Nothing but faux results here!</body></html>" > results$i.html
   $MT_MEGATEST -step step$i :state end :status 0
 done
 
 # get a previous test
 export EZFAILPATH=`$MT_MEGATEST -test-files lookithome.log -target $MT_TARGET :runname $MT_RUNNAME -testpatt ez_fail`

Index: tests/mintest/tests/g/testconfig
==================================================================
--- tests/mintest/tests/g/testconfig
+++ tests/mintest/tests/g/testconfig
@@ -2,5 +2,8 @@
 [ezsteps]
 step1 echo SUCCESS
 
 [requirements]
 waiton b
+
+[items]
+NADA 

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)))))
+