Index: dashboard.scm
==================================================================
--- dashboard.scm
+++ dashboard.scm
@@ -132,11 +132,11 @@
   (if (dboard:common-get-tabdat commondat tab-num: tab-num) ;; only update if there is a tabdat
       (let* ((tnum     (or tab-num (dboard:commondat-curr-tab-num commondat)))
 	     (updaters (hash-table-ref/default (dboard:commondat-updaters commondat)
 					       tnum
 					       '())))
-	(debug:print 0 *default-log-port* "Found these updaters: " updaters)
+	(debug:print 0 *default-log-port* "Found these updaters: " updaters " for tab-num: " tnum)
 	(for-each
 	 (lambda (updater)
 	   (updater))
 	 updaters))))
 
@@ -932,11 +932,11 @@
 ;;======================================================================
 ;;
 ;; A gui for launching tests
 ;;
 
-(define (dashboard:run-controls commondat tabdat)
+(define (dashboard:run-controls commondat tabdat #!key (tab-num #f))
   (let* ((targets       (make-hash-table))
 	 (test-records  (make-hash-table))
 	 (all-tests-registry (tests:get-all)) ;; (tests:get-valid-tests *toppath* '()))
 	 (test-names    (hash-table-keys all-tests-registry))
 	 (sorted-testnames #f)
@@ -975,12 +975,12 @@
 
        ;; Target, testpatt, state and status input boxes
        ;;
        (iup:vbox
 	;; Command to run, placed over the top of the canvas
-	(dcommon:command-action-selector commondat tabdat)
-	(dcommon:command-runname-selector commondat tabdat)
+	(dcommon:command-action-selector commondat tabdat tab-num: tab-num)
+	(dcommon:command-runname-selector commondat tabdat tab-num: tab-num)
 	(dcommon:command-testname-selector commondat tabdat update-keyvals key-listboxes))
        
        (dcommon:command-tests-tasks-canvas tabdat test-records sorted-testnames tests-draw-state))
        
  ;;(iup:frame
@@ -995,11 +995,11 @@
 ;; R U N   C O N T R O L S
 ;;======================================================================
 ;;
 ;; A gui for launching tests
 ;;
-(define (dashboard:run-times commondat tabdat)
+(define (dashboard:run-times commondat tabdat #!key (tab-num #f))
   (let* ((tabdat          tabdat) ;; (dboard:tabdat-make-data)) ;; (make-vector 25 #f))
 	 (targets       (make-hash-table))
 	 (test-records  (make-hash-table))
 	 (all-tests-registry (tests:get-all)) ;; (tests:get-valid-tests *toppath* '()))
 	 (test-names    (hash-table-keys all-tests-registry))
@@ -1038,12 +1038,12 @@
 
        ;; Target, testpatt, state and status input boxes
        ;;
        (iup:vbox
 	;; Command to run, placed over the top of the canvas
-	(dcommon:command-action-selector commondat tabdat)
-	(dcommon:command-runname-selector commondat tabdat)
+	(dcommon:command-action-selector commondat tabdat tab-num: tab-num)
+	(dcommon:command-runname-selector commondat tabdat tab-num: tab-num)
 	(dcommon:command-testname-selector tabdat tabdat update-keyvals key-listboxes))
        
        (dcommon:command-tests-tasks-canvas tabdat test-records sorted-testnames tests-draw-state))
        
 ;; (iup:frame
@@ -1057,11 +1057,11 @@
 ;;======================================================================
 ;; S U M M A R Y 
 ;;======================================================================
 ;;
 ;; General info about the run(s) and megatest area
-(define (dashboard:summary commondat tabdat)
+(define (dashboard:summary commondat tabdat #!key (tab-num #f))
   (let* ((rawconfig        (read-config (conc *toppath* "/megatest.config") #f #f))) ;; changed to #f since I want #{} to be expanded by [system ...] to NOT be expanded. WAS: 'return-string)))
     (iup:vbox
      (iup:split
       #:value 500
       (iup:frame 
@@ -1086,11 +1086,11 @@
 	;; (iup:frame
 	;; #:title "Disks Areas"
 	(dcommon:section-matrix rawconfig "disks" "Disk area" "Path"))))
      (iup:frame
       #:title "Run statistics"
-      (dcommon:run-stats commondat tabdat)))))
+      (dcommon:run-stats commondat tabdat tab-num: tab-num)))))
 
 ;;======================================================================
 ;; R U N
 ;;======================================================================
 ;;
@@ -1128,11 +1128,11 @@
 		       (< anum bnum)
 		       (string<= aval bval)))))))
 
 ;; This is the Run Summary tab
 ;; 
-(define (dashboard:one-run commondat tabdat)
+(define (dashboard:one-run commondat tabdat #!key (tab-num #f))
   (let* ((tb      (iup:treebox
 		   #:value 0
 		   #:name "Runs"
 		   #:expand "YES"
 		   #:addexpanded "NO"
@@ -1157,130 +1157,130 @@
 			(let* ((toolpath (car (argv)))
 			       (key      (conc lin ":" col))
 			       (test-id  (hash-table-ref/default cell-lookup key -1))
 			       (cmd      (conc toolpath " -test " (dboard:tabdat-curr-run-id tabdat) "," test-id "&")))
 			  (system cmd)))))
-	 (updater  (lambda ()
-		     (let* ((runs-dat     (rmt:get-runs-by-patt (dboard:tabdat-keys tabdat) "%" #f #f #f #f))
-			    (runs-header  (vector-ref runs-dat 0)) ;; 0 is header, 1 is list of records
-			    (run-id       (dboard:tabdat-curr-run-id tabdat))
-			    (last-update  0) ;; fix me
-			    (tests-dat    (dboard:get-tests-dat tabdat run-id last-update))
-			    (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 (common:max (map cadr row-indices))))
-			    (max-col      (if (null? col-indices) 1 (common:max (map cadr col-indices))))
-			    (max-visible  (max (- (dboard:tabdat-num-tests tabdat) 15) 3)) ;; (dboard:tabdat-num-tests tabdat) 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))))))
-		       
-		       (dboard:tabdat-filters-changed-set! tabdat #f)
-		       ;; (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))
-							   (dboard:tabdat-keys tabdat)))
-					  (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)))
-					  (existing   (tree:find-node tb run-path)))
-				     (if (not (hash-table-ref/default (dboard:tabdat-path-run-ids tabdat) run-path #f))
-					 (begin
-					   (hash-table-set! (dboard:tabdat-run-keys tabdat) run-id run-path)
-					   ;; (iup:attribute-set! (dboard:tabdat-runs-matrix tabdat)
-					   ;;    		 (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" run-path ;; (append key-vals (list run-name))
-							  userdata: (conc "run-id: " run-id))
-					   (hash-table-set! (dboard:tabdat-path-run-ids tabdat) run-path run-id)
-					   ;; (set! colnum (+ colnum 1))
-					   ))))
-				 run-ids)
-		       (iup:attribute-set! run-matrix "CLEARVALUE" "ALL") ;; NOTE: Was CONTENTS
-		       (iup:attribute-set! run-matrix "CLEARATTRIB" "CONTENTS")
-		       (iup:attribute-set! run-matrix "RESIZEMATRIX" "YES")
-		       (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)
-		       
-		       ;; 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)))
-				     (hash-table-set! cell-lookup key test-id)
-				     (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)
-		       
-		       ;; Col labels - do after setting Cell contents so they are accounted for in the size calc.
-
-		       (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)
-		       (if changed (iup:attribute-set! run-matrix "REDRAW" "ALL"))))))
+	 (one-run-updater  (lambda ()
+			     (if  (dashboard:database-changed? commondat tabdat)
+				  (let* ((runs-dat     (rmt:get-runs-by-patt (dboard:tabdat-keys tabdat) "%" #f #f #f #f))
+					 (runs-header  (vector-ref runs-dat 0)) ;; 0 is header, 1 is list of records
+					 (run-id       (dboard:tabdat-curr-run-id tabdat))
+					 (last-update  0) ;; fix me
+					 (tests-dat    (dboard:get-tests-dat tabdat run-id last-update))
+					 (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 (common:max (map cadr row-indices))))
+					 (max-col      (if (null? col-indices) 1 (common:max (map cadr col-indices))))
+					 (max-visible  (max (- (dboard:tabdat-num-tests tabdat) 15) 3)) ;; (dboard:tabdat-num-tests tabdat) 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))))))
+				    (dboard:tabdat-filters-changed-set! tabdat #f)
+				    ;; (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))
+									(dboard:tabdat-keys tabdat)))
+						       (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)))
+						       (existing   (tree:find-node tb run-path)))
+						  (if (not (hash-table-ref/default (dboard:tabdat-path-run-ids tabdat) run-path #f))
+						      (begin
+							(hash-table-set! (dboard:tabdat-run-keys tabdat) run-id run-path)
+							;; (iup:attribute-set! (dboard:tabdat-runs-matrix tabdat)
+							;;    		 (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" run-path ;; (append key-vals (list run-name))
+								       userdata: (conc "run-id: " run-id))
+							(hash-table-set! (dboard:tabdat-path-run-ids tabdat) run-path run-id)
+							;; (set! colnum (+ colnum 1))
+							))))
+					      run-ids)
+				    (iup:attribute-set! run-matrix "CLEARVALUE" "ALL") ;; NOTE: Was CONTENTS
+				    (iup:attribute-set! run-matrix "CLEARATTRIB" "CONTENTS")
+				    (iup:attribute-set! run-matrix "RESIZEMATRIX" "YES")
+				    (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)
+				    
+				    ;; 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)))
+						  (hash-table-set! cell-lookup key test-id)
+						  (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)
+				    
+				    ;; Col labels - do after setting Cell contents so they are accounted for in the size calc.
+
+				    (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)
+				    (if changed (iup:attribute-set! run-matrix "REDRAW" "ALL")))))))
     
     ;; REPLACE ME!!!! BUGGG!!!!
     ;; (set! dashboard:update-run-summary-tab updater)
-    (dboard:commondat-add-updater commondat updater)
+    (dboard:commondat-add-updater commondat one-run-updater tab-num: tab-num)
     (dboard:tabdat-runs-tree-set! tabdat tb)
     (iup:split
      tb
      run-matrix)))
 
 ;; This is the New View tab
 ;; 
-(define (dashboard:new-view db commondat tabdat)
+(define (dashboard:new-view db commondat tabdat #!key (tab-num #f))
   (let* ((tb      (iup:treebox
 		   #:value 0
 		   #:name "Runs"
 		   #:expand "YES"
 		   #:addexpanded "NO"
@@ -1305,118 +1305,118 @@
 			(let* ((toolpath (car (argv)))
 			       (key      (conc lin ":" col))
 			       (test-id  (hash-table-ref/default cell-lookup key -1))
 			       (cmd      (conc toolpath " -test " (dboard:tabdat-curr-run-id tabdat) "," test-id "&")))
 			  (system cmd)))))
-	 (updater  (lambda ()
-		     (let* ((runs-dat     (rmt:get-runs-by-patt (dboard:tabdat-keys tabdat) "%" #f #f #f #f))
-			    (runs-header  (vector-ref runs-dat 0)) ;; 0 is header, 1 is list of records
-			    (run-id       (dboard:tabdat-curr-run-id tabdat))
-			    (last-update  0) ;; fix me
-			    (tests-dat    (dboard:get-tests-dat tabdat run-id last-update))
-			    (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 (common:max (map cadr row-indices))))
-			    (max-col      (if (null? col-indices) 1 (common:max (map cadr col-indices))))
-			    (max-visible  (max (- (dboard:tabdat-num-tests tabdat) 15) 3)) ;; (dboard:tabdat-num-tests tabdat) 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))
-							   (dboard:tabdat-keys tabdat)))
-					  (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)))
-					  (existing   (tree:find-node tb run-path)))
-				     (if (not (hash-table-ref/default (dboard:tabdat-path-run-ids tabdat) run-path #f))
-					 (begin
-					   (hash-table-set! (dboard:tabdat-run-keys tabdat) run-id run-path)
-					   ;; (iup:attribute-set! (dboard:tabdat-runs-matrix tabdat)
-					   ;;    		 (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" run-path ;; (append key-vals (list run-name))
-							  userdata: (conc "run-id: " run-id))
-					   (hash-table-set! (dboard:tabdat-path-run-ids tabdat) run-path run-id)
-					   ;; (set! colnum (+ colnum 1))
-					   ))))
-				 run-ids)
-		       (iup:attribute-set! run-matrix "CLEARVALUE" "ALL") ;; NOTE: Was CONTENTS
-		       (iup:attribute-set! run-matrix "CLEARATTRIB" "CONTENTS")
-		       (iup:attribute-set! run-matrix "RESIZEMATRIX" "YES")
-		       (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)
-		       
-		       ;; 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)))
-				     (hash-table-set! cell-lookup key test-id)
-				     (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)
-		       
-		       ;; Col labels - do after setting Cell contents so they are accounted for in the size calc.
-
-		       (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)
-		       (if changed (iup:attribute-set! run-matrix "REDRAW" "ALL"))))))
-    (dboard:commondat-add-updater commondat updater)
+	 (new-view-updater  (lambda ()
+			      (if  (dashboard:database-changed? commondat tabdat)
+				   (let* ((runs-dat     (rmt:get-runs-by-patt (dboard:tabdat-keys tabdat) "%" #f #f #f #f))
+					  (runs-header  (vector-ref runs-dat 0)) ;; 0 is header, 1 is list of records
+					  (run-id       (dboard:tabdat-curr-run-id tabdat))
+					  (last-update  0) ;; fix me
+					  (tests-dat    (dboard:get-tests-dat tabdat run-id last-update))
+					  (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 (common:max (map cadr row-indices))))
+					  (max-col      (if (null? col-indices) 1 (common:max (map cadr col-indices))))
+					  (max-visible  (max (- (dboard:tabdat-num-tests tabdat) 15) 3)) ;; (dboard:tabdat-num-tests tabdat) 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))
+									 (dboard:tabdat-keys tabdat)))
+							(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)))
+							(existing   (tree:find-node tb run-path)))
+						   (if (not (hash-table-ref/default (dboard:tabdat-path-run-ids tabdat) run-path #f))
+						       (begin
+							 (hash-table-set! (dboard:tabdat-run-keys tabdat) run-id run-path)
+							 ;; (iup:attribute-set! (dboard:tabdat-runs-matrix tabdat)
+							 ;;    		 (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" run-path ;; (append key-vals (list run-name))
+									userdata: (conc "run-id: " run-id))
+							 (hash-table-set! (dboard:tabdat-path-run-ids tabdat) run-path run-id)
+							 ;; (set! colnum (+ colnum 1))
+							 ))))
+					       run-ids)
+				     (iup:attribute-set! run-matrix "CLEARVALUE" "ALL") ;; NOTE: Was CONTENTS
+				     (iup:attribute-set! run-matrix "CLEARATTRIB" "CONTENTS")
+				     (iup:attribute-set! run-matrix "RESIZEMATRIX" "YES")
+				     (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)
+				     
+				     ;; 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)))
+						   (hash-table-set! cell-lookup key test-id)
+						   (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)
+				     
+				     ;; Col labels - do after setting Cell contents so they are accounted for in the size calc.
+
+				     (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)
+				     (if changed (iup:attribute-set! run-matrix "REDRAW" "ALL")))))))
+    (dboard:commondat-add-updater commondat new-view-updater tab-num: tab-num)
     (dboard:tabdat-runs-tree-set! tabdat tb)
     (iup:split
      tb
      run-matrix)))
 
@@ -1595,11 +1595,12 @@
 			  " " tconfig " &")))
 	  (system cmd))))
      ))))
 
 (define (make-dashboard-buttons commondat) ;;  runs-sum-dat new-view-dat)
-  (let* ((runs-dat        (dboard:tabdat-make-data))
+  (let* ((stats-dat       (dboard:tabdat-make-data))
+	 (runs-dat        (dboard:tabdat-make-data))
 	 (onerun-dat      (dboard:tabdat-make-data))
 	 (runcontrols-dat (dboard:tabdat-make-data))
 	 (runtimes-dat    (dboard:tabdat-make-data))
 	 (nruns           (dboard:tabdat-numruns runs-dat))
 	 (ntests          (dboard:tabdat-num-tests runs-dat))
@@ -1756,16 +1757,16 @@
 	     ;; (data (dboard:tabdat-init (make-d:data)))
 	     (tabs (iup:tabs
 		    #:tabchangepos-cb (lambda (obj curr prev)
 					(dboard:commondat-please-update-set! commondat #t)
 					(dboard:commondat-curr-tab-num-set! commondat curr))
-		    (dashboard:summary commondat runs-dat)
+		    (dashboard:summary commondat stats-dat tab-num: 0)
 		    runs-view
-		    (dashboard:one-run commondat onerun-dat)
-		    ;; (dashboard:new-view db data new-view-dat)
-		    (dashboard:run-controls commondat runcontrols-dat)
-		    (dashboard:run-times commondat runtimes-dat)
+		    (dashboard:one-run commondat onerun-dat tab-num: 2)
+		    ;; (dashboard:new-view db data new-view-dat tab-num: 3)
+		    (dashboard:run-controls commondat runcontrols-dat tab-num: 3)
+		    (dashboard:run-times commondat runtimes-dat tab-num: 4)
 		    )))
 	;; (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")
@@ -1775,15 +1776,15 @@
 	;; (iup:attribute-set! tabs "TABTITLE4" "Run Control")
 	(iup:attribute-set! tabs "BGCOLOR" "190 190 190")
 	;; make the iup tabs object available (for changing color for example)
 	(dboard:commondat-hide-not-hide-tabs-set! commondat tabs)
 	;; now set up the tabdat lookup
-	(dboard:common-set-tabdat! commondat 0 runs-dat)
+	(dboard:common-set-tabdat! commondat 0 stats-dat)
 	(dboard:common-set-tabdat! commondat 1 runs-dat)
 	(dboard:common-set-tabdat! commondat 2 onerun-dat)
 	(dboard:common-set-tabdat! commondat 3 runcontrols-dat)
-	(dboard:common-set-tabdat! commondat 3 runtimes-dat)
+	(dboard:common-set-tabdat! commondat 4 runtimes-dat)
 	(iup:vbox
 	 tabs
 	 controls))))
     (vector keycol lftcol header runsvec)))
 
@@ -1848,11 +1849,12 @@
 
 (define (dashboard:database-changed? commondat tabdat)
   (let* ((run-update-time (current-seconds))
 	 (modtime         (dashboard:get-youngest-run-db-mod-time tabdat)) ;; NOTE: ensure this is tabdat!! 
 	 (recalc          (dashboard:recalc modtime (dboard:commondat-please-update commondat) (dboard:tabdat-last-db-update tabdat))))
-    recalc))
+     (dboard:commondat-please-update-set! commondat #f)
+     recalc))
 
 ;; (if dashboard:update-servers-table (dashboard:update-servers-table))))
 
 (define (dashboard:summary-tab-updater commondat tab-num)
   (if dashboard:update-summary-tab (dashboard:update-summary-tab)))
@@ -1869,12 +1871,10 @@
 				       (if val (set! res (cons (list key val) res))))))
 			       (dboard:tabdat-dbkeys tabdat))
 		     res))
     (let ((uidat (dboard:commondat-uidat commondat)))
       (update-buttons tabdat uidat (dboard:tabdat-numruns tabdat) (dboard:tabdat-num-tests tabdat)))
-    (dboard:commondat-please-update-set! commondat #f) ;; NOTE BUG! THIS NEEDS TO BE MADE TAB SPECIFIC!!!
-    ;; (dboard:tabdat-last-db-update-set! tabdat modtime)
     ))
 
 ;; ((2)
 ;;  (dashboard:update-run-summary-tab))
 ;; ((3)
@@ -1925,15 +1925,16 @@
       ;;  commondat 
       ;;  (lambda ()
       ;; 	 (dashboard:summary-tab-updater commondat 0))
       ;;  tab-num: 0)
       ;; runs tab
-      (dboard:commondat-add-updater 
-       commondat 
-       (lambda ()
-	 (dashboard:runs-tab-updater commondat 1))
-       tab-num: 1)
+      (dboard:commondat-curr-tab-num-set! commondat 0)
+      ;; (dboard:commondat-add-updater 
+      ;;  commondat 
+      ;;  (lambda ()
+      ;; 	 (dashboard:runs-tab-updater commondat 1))
+      ;;  tab-num: 1)
       (iup:callback-set! *tim*
 			 "ACTION_CB"
 			 (lambda (time-obj)
 			   (let ((update-is-running #f))
 			     (mutex-lock! (dboard:commondat-update-mutex commondat))
@@ -1950,14 +1951,15 @@
 				 ))
 			   1))))
     
     (let ((th1 (make-thread (lambda ()
 			      (thread-sleep! 1)
-			      (dboard:common-run-curr-updaters commondat 0) ;; force update of summary tab (dboard:commondat-please-update-set! commondat #t)
+			      (dboard:common-run-curr-updaters commondat 0) ;; force update of summary tab 
+			      (dboard:commondat-please-update-set! commondat #t)
 			      ;; (dashboard:run-update commondat)
 			      ) "update buttons once"))
 	  (th2 (make-thread iup:main-loop "Main loop")))
       (thread-start! th1)
       (thread-start! th2)
       (thread-join! th2))))
 
 (main)

Index: dcommon.scm
==================================================================
--- dcommon.scm
+++ dcommon.scm
@@ -356,14 +356,14 @@
     (iup:attribute-set! general-matrix "2:0" "Version")
     (iup:attribute-set! general-matrix "2:1" (conc megatest-version "-" (substring megatest-fossil-hash 0 4)))
 
     general-matrix))
 
-(define (dcommon:run-stats commondat tabdat)
+(define (dcommon:run-stats commondat tabdat #!key (tab-num #f))
   (let* ((stats-matrix (iup:matrix expand: "YES"))
 	 (changed      #f)
-	 (updater      (lambda ()
+	 (stats-updater (lambda ()
 			 (if (dashboard:database-changed? commondat tabdat)
 			     (let* ((run-stats    (rmt:get-run-stats))
 				    (indices      (common:sparse-list-generate-index run-stats)) ;;  proc: set-cell))
 				    (row-indices  (car indices))
 				    (col-indices  (cadr indices))
@@ -414,12 +414,12 @@
 						 (begin
 						   (set! changed #t)
 						   (iup:attribute-set! stats-matrix key value)))))
 					 run-stats)
 			       (if changed (iup:attribute-set! stats-matrix "REDRAW" "ALL")))))))
-    (updater)
-    (dboard:commondat-add-updater commondat updater)
+    (stats-updater)
+    (dboard:commondat-add-updater commondat stats-updater tab-num: tab-num)
     ;; (set! dashboard:update-summary-tab updater)
     (iup:attribute-set! stats-matrix "WIDTHDEF" "40")
     (iup:vbox
      ;; (iup:label "Run statistics"  #:expand "HORIZONTAL")
      stats-matrix)))
@@ -857,11 +857,11 @@
 			   (let ((cmd (conc "xterm -geometry 180x20 -e \""
 					    (iup:attribute (dboard:tabdat-command-tb data) "VALUE")
 					    ";echo Press any key to continue;bash -c 'read -n 1 -s'\" &")))
 			     (system cmd)))))))
 
-(define (dcommon:command-action-selector commondat tabdat)
+(define (dcommon:command-action-selector commondat tabdat #!key (tab-num #f))
   (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 '("run" "remove-runs" "set-state-status" "lock-runs" "unlock-runs"))
@@ -874,11 +874,11 @@
 	   (default-cmd (car cmds-list)))
       (iuplistbox-fill-list lb cmds-list selected-item: default-cmd)
       (dboard:tabdat-command-set! tabdat default-cmd)
       lb))))
 
-(define (dcommon:command-runname-selector commondat tabdat) ;; alldat data)
+(define (dcommon:command-runname-selector commondat tabdat #!key (tab-num #f)) ;; alldat data)
   (iup:frame
    #:title "Runname"
    (let* ((default-run-name (seconds->work-week/day (current-seconds)))
 	  (tb (iup:textbox #:expand "HORIZONTAL"
 			   #:action (lambda (obj val txt)
@@ -893,22 +893,23 @@
 					  (begin
 					    (iup:attribute-set! tb "VALUE" val)
 					    (dboard:tabdat-run-name-set! tabdat val)
 					    (dashboard:update-run-command tabdat))))))
 	  (refresh-runs-list (lambda ()
-			       (let* ((target        (dboard:tabdat-target-string tabdat))
-				      (runs-for-targ (rmt:get-runs-by-patt (dboard:tabdat-keys tabdat) "%" target #f #f #f))
-				      (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)))))
+			       (if (dashboard:database-changed? commondat tabdat)
+				   (let* ((target        (dboard:tabdat-target-string tabdat))
+					  (runs-for-targ (rmt:get-runs-by-patt (dboard:tabdat-keys tabdat) "%" target #f #f #f))
+					  (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))))))
      ;; (dboard:tabdat-updater-for-runs-set! tabdat refresh-runs-list)
-     (dboard:commondat-add-updater commondat refresh-runs-list)
+     (dboard:commondat-add-updater commondat refresh-runs-list tab-num: tab-num)
      (refresh-runs-list)
      (dboard:tabdat-run-name-set! tabdat default-run-name)
      (iup:hbox
       tb
       lb))))