@@ -304,25 +304,23 @@
   tests-drawn    ;; list of id's already drawn on screen
   tests-notdrawn ;; list of id's NOT already drawn
   rowsused       ;; hash of lists covering what areas used - replace with quadtree
   hierdat        ;; put hierarchial sorted list here
   tests          ;; hash of id => testdat
-  tests-by-name  ;; hash of testfullname => testdat
+  ((tests-by-name (make-hash-table)) : hash-table) ;; hash of testfullname => testdat
   key-vals
-  ((last-update 0) : fixnum) ;; last query to db got records from before last-update
-  data-changed
+  ((last-update   0)                 : fixnum) ;; last query to db got records from before last-update
+  ((data-changed  #f)                : boolean)
+  ((run-data-offset  0)              : number)      ;; get only 100 items per call, set back to zero when received less that 100 items
   (db-path #f)
   )
 
-(define (dboard:rundat-make-init #!key (run #f)(key-vals #f)(tests #f)(last-update -100));; -100 is before time began
+(define (dboard:rundat-make-init #!key (run #f)(key-vals #f)(tests #f));; -100 is before time began
   (make-dboard:rundat 
    run: run
    tests: (or tests (make-hash-table))
-   tests-by-name: (make-hash-table)
    key-vals: key-vals 
-   last-update: last-update
-   data-changed: #t
    )) 
 
 (define (dboard:rundat-copy-tests-to-by-name rundat)
   (let ((src-ht (dboard:rundat-tests rundat))
 	(trg-ht (dboard:rundat-tests-by-name rundat)))
@@ -477,25 +475,24 @@
 ;; gets all the tests for run-id that match testnamepatt and key-vals, merges them
 ;;
 ;;    NOTE: Yes, this is used
 ;;
 (define (dboard:get-tests-for-run-duplicate tabdat run-id run testnamepatt key-vals)
-  (let* ((states      (hash-table-keys (dboard:tabdat-state-ignore-hash tabdat)))
+  (let* ((num-to-get  20)
+	 (states      (hash-table-keys (dboard:tabdat-state-ignore-hash tabdat)))
 	 (statuses    (hash-table-keys (dboard:tabdat-status-ignore-hash tabdat)))
 	 (sort-info   (get-curr-sort))
 	 (sort-by     (vector-ref sort-info 1))
 	 (sort-order  (vector-ref sort-info 2))
 	 (bubble-type (if (member sort-order '(testname))
 			  'testname
 			  'itempath))
 	 ;; note: the rundat is normally created in "update-rundat". 
-	 (run-dat    (let ((rec (hash-table-ref/default (dboard:tabdat-allruns-by-id tabdat) run-id #f)))
-			(if rec 
-			    rec
-			    (let ((rd (dboard:rundat-make-init run: run key-vals: key-vals)))
-			      (hash-table-set! (dboard:tabdat-allruns-by-id tabdat) run-id rd)
-			      rd))))
+	 (run-dat    (or (hash-table-ref/default (dboard:tabdat-allruns-by-id tabdat) run-id #f)
+			 (let ((rd (dboard:rundat-make-init run: run key-vals: key-vals)))
+			   (hash-table-set! (dboard:tabdat-allruns-by-id tabdat) run-id rd)
+			   rd)))
 	 ;; (prev-tests  (dboard:rundat-tests prev-dat)) ;; (vector-ref prev-dat 1))
 	 (last-update (dboard:rundat-last-update run-dat)) ;; (vector-ref prev-dat 3))
 	 (db-path     (or (dboard:rundat-db-path run-dat)
 			  (let* ((db-dir (tasks:get-task-db-path))
 				 (db-pth (conc db-dir "/" run-id ".db")))
@@ -502,11 +499,12 @@
 			    (dboard:rundat-db-path-set! run-dat db-pth)
 			    db-pth)))
 	 (tmptests    (if (or (configf:lookup *configdat* "setup" "do-not-use-db-file-timestamps")
 			      (>= (file-modification-time db-path) last-update))
 			  (rmt:get-tests-for-run run-id testnamepatt states statuses  ;; run-id testpatt states statuses
-						 #f #f                                ;; offset limit 
+						 (dboard:rundat-run-data-offset run-dat)
+						 num-to-get
 						 (dboard:tabdat-hide-not-hide tabdat) ;; no-in
 						 sort-by                              ;; sort-by
 						 sort-order                           ;; sort-order
 						 #f ;; 'shortlist                           ;; qrytype
 						 (if (dboard:tabdat-filters-changed tabdat) 
@@ -519,20 +517,38 @@
 			 (let ((ht (make-hash-table)))
 			   (dboard:rundat-tests-set! run-dat ht)
 			   ht)
 			 (dboard:rundat-tests run-dat)))
 	 (start-time (current-seconds)))
+
+    ;; to limit the amount of data transferred each cycle use limit of num-to-get and offset
+    (dboard:rundat-run-data-offset-set! 
+     run-dat 
+     (if (< (length tmptests) num-to-get)
+	 0
+	 (let ((newval (+ num-to-get (dboard:rundat-run-data-offset run-dat))))
+	   ;; (print "Incremental get, offset=" (dboard:rundat-run-data-offset run-dat) " retrieved: " (length tmptests) " newval: " newval)
+	   newval)))
+     
     (for-each 
      (lambda (tdat)
        (let ((test-id (db:test-get-id tdat))
 	     (state   (db:test-get-state tdat)))
 	 (dboard:rundat-data-changed-set! run-dat #t)
 	 (if (equal? state "DELETED")
 	     (hash-table-delete! tests-ht test-id)
 	     (hash-table-set! tests-ht test-id tdat))))
      tmptests)
-    (dboard:rundat-last-update-set! run-dat (- (current-seconds) 2)) ;; go back two seconds in time to ensure all changes are captured.
+    
+    ;; set last-update to 0 if still getting data incrementally
+
+    (if (> (dboard:rundat-run-data-offset run-dat) 0)
+	(begin
+	  ;; (print "run-data-offset: " (dboard:rundat-run-data-offset run-dat) ", setting last-update to 0")
+	  (dboard:rundat-last-update-set! run-dat 0))
+	(dboard:rundat-last-update-set! run-dat (- (current-seconds) 2))) ;; go back two seconds in time to ensure all changes are captured.
+
     ;; (debug:print-info 0 *default-log-port* "tests-ht: " (hash-table-keys tests-ht))
     tests-ht))
 
 ;; tmptests   - new tests data
 ;; prev-tests - old tests data
@@ -589,22 +605,23 @@
 		 ;; GET RID OF dboard:get-tests-dat - it is superceded by dboard:get-tests-for-run-duplicate
 		 ;;  dboard:get-tests-for-run-duplicate - returns a hash table
 		 ;;  (dboard:get-tests-dat tabdat run-id last-update))
 		 (all-test-ids (hash-table-keys tests-ht))
 		 (num-tests    (length all-test-ids)))
+	    ;; (print "run-struct: " run-struct)
 	    ;; NOTE: bubble-up also sets the global (dboard:tabdat-item-test-names tabdat)
 	    ;; (tests       (bubble-up tmptests priority: bubble-type))
 	    ;; NOTE: 11/01/2013 This routine is *NOT* getting called excessively.
 	    ;; (debug:print 0 *default-log-port* "Getting data for run " run-id " with key-vals=" key-vals)
 	    ;; Not sure this is needed?
 	    (let* ((newmaxtests (max num-tests maxtests))
 		   (last-update (- (current-seconds) 10))
-		   (run-struct  (dboard:rundat-make-init
-				 run:         run 
-				 tests:       tests-ht
-				 key-vals:    key-vals
-				 last-update: last-update))
+		   (run-struct  (or run-struct
+				    (dboard:rundat-make-init
+				     run:         run 
+				     tests:       tests-ht
+				     key-vals:    key-vals)))
 		   (new-res     (if (null? all-test-ids) res (cons run-struct res)))
 		   (elapsed-time (- (current-seconds) start-time)))
 	      (if (null? all-test-ids)
 		  (hash-table-delete! (dboard:tabdat-allruns-by-id tabdat) run-id)
 		  (hash-table-set!    (dboard:tabdat-allruns-by-id tabdat) run-id run-struct))
@@ -612,11 +629,13 @@
 		      (> elapsed-time 2)) ;; stop loading data after 5 seconds, on the next call more data *should* be loaded since get-tests-for-run uses last update
 		  (begin
 		    (if (> elapsed-time 2)(print "WARNING: timed out in update-testdat " elapsed-time "s"))
 		    (dboard:tabdat-allruns-set! tabdat new-res)
 		    maxtests)
-		  (loop (car tal)(cdr tal) new-res newmaxtests))))))
+		  (if (> (dboard:rundat-run-data-offset run-struct) 0)
+		      (loop run tal new-res newmaxtests) ;; not done getting data for this run
+		      (loop (car tal)(cdr tal) new-res newmaxtests)))))))
     (dboard:tabdat-filters-changed-set! tabdat #f)
     (dboard:update-tree tabdat runs-hash header tb)))
 
 (define *collapsed* (make-hash-table))
 
@@ -1120,10 +1139,34 @@
     ;; 	 ((dboard:tabdat-updater-for-runs tabdat)))
     (if (or (not (equal? curr-runname (dboard:tabdat-run-name tabdat)))
 	    (equal? (dboard:tabdat-run-name tabdat) ""))
 	(dboard:tabdat-run-name-set! tabdat curr-runname))
     (dashboard:update-run-command tabdat)))
+
+;; used by run-controls
+;;
+(define (dashboard:update-tree-selector tabdat #!key (action-proc #f))
+  (let* ((tb            (dboard:tabdat-runs-tree tabdat))
+	 (runconf-targs (common:get-runconfig-targets))
+	 (db-target-dat (rmt:get-targets))
+	 (header        (vector-ref db-target-dat 0))
+	 (db-targets    (vector-ref db-target-dat 1))
+	 (munge-target  (lambda (x)            ;; create a target vector from a string. Pad with na if needed.
+			  (take (append (string-split x "/")
+					(make-list (length header) "na"))
+				(length header))))
+	 (all-targets   (append (list (munge-target (string-intersperse 
+						     (map (lambda (x) "%") header)
+						     "/")))
+				(map vector->list db-targets)
+				(map munge-target
+				     runconf-targs)
+				)))
+    (for-each
+     (lambda (target)
+       (tree:add-node tb "Runs" target)) ;; (append key-vals (list run-name))
+     all-targets)))
 
 (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* '()))
@@ -1141,36 +1184,44 @@
     ;; (hash-table-set! tests-draw-state 'scalef 1)
     (tests:get-full-data test-names test-records '() all-tests-registry)
     (set! sorted-testnames (tests:sort-by-priority-and-waiton test-records))
     
     ;; refer to (dboard:tabdat-keys tabdat), (dboard:tabdat-dbkeys tabdat) for keys
-    (iup:vbox
-     (dcommon:command-execution-control tabdat)
-     (iup:split
-      #:orientation "VERTICAL" ;; "HORIZONTAL"
-      #:value 200
-;; 
-;;       (iup:split
-;;        #:value 300
-
-       ;; 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 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))
-       
+    (let* ((result
+	    (iup:vbox
+	     (dcommon:command-execution-control tabdat)
+	     (iup:split
+	      #:orientation "VERTICAL" ;; "HORIZONTAL"
+	      #:value 200
+	      ;; 
+	     ;;       (iup:split
+	     ;;        #:value 300
+
+	     ;; 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 tab-num: tab-num)
+	      (dboard:runs-tree-browser commondat tabdat)
+	      (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))))
+	   (tb (dboard:tabdat-runs-tree tabdat)))
+      (dboard:commondat-add-updater 
+       commondat 
+       (lambda ()
+	 (dashboard:update-tree-selector tabdat))
+       tab-num: tab-num)
+      result)))
+
  ;;(iup:frame
  ;; #:title "Logs" ;; To be replaced with tabs
  ;; (let ((logs-tb (iup:textbox #:expand "YES"
  ;;				   #:multiline "YES")))
  ;;	 (dboard:tabdat-logs-textbox-set! tabdat logs-tb)
  ;;	 logs-tb))
-      )))
 
 (define (dboard:runs-tree-browser commondat tabdat)
   (let* ((tb      (iup:treebox
 		   #:value 0
 		   #:name "Runs"
@@ -1516,13 +1567,10 @@
 ;; R U N
 ;;======================================================================
 ;;
 ;; display and manage a single run at a time
 
-;; (define dashboard:update-run-summary-tab #f)
-;; (define dashboard:update-new-view-tab #f)
-
 ;; This is the Run Summary tab
 ;; 
 (define (dashboard:one-run commondat tabdat #!key (tab-num #f))
   (let* ((tb      (iup:treebox
 		   #:value 0
@@ -1529,21 +1577,24 @@
 		   #:name "Runs"
 		   #:expand "YES"
 		   #:addexpanded "NO"
 		   #:selection-cb
 		   (lambda (obj id state)
-		     ;; (print "RA => obj: " obj ", id: " id ", state: " state)
-		     (let* ((run-path (tree:node->path obj id))
-			    (run-id   (tree-path->run-id tabdat (cdr run-path))))
-		       (if (number? run-id)
-			   (begin
-			     (dboard:tabdat-curr-run-id-set! tabdat run-id)
-			     (dboard:tabdat-layout-update-ok-set! tabdat #f)
-			     ;; (dashboard:update-run-summary-tab)
-			     )
-			   ;; (debug:print-error 0 *default-log-port* "tree-path->run-id returned non-number " run-id)
-			   ))
+		     (debug:catch-and-dump
+		      (lambda ()
+			;; (print "obj: " obj ", id: " id ", state: " state)
+			(let* ((run-path (tree:node->path obj id))
+			       (run-id   (tree-path->run-id tabdat (cdr run-path))))
+			  (if (number? run-id)
+			      (begin
+				(dboard:tabdat-curr-run-id-set! tabdat run-id)
+				(dboard:tabdat-layout-update-ok-set! tabdat #f)
+				;; (dashboard:update-run-summary-tab)
+				)
+			      ;; (debug:print-error 0 *default-log-port* "tree-path->run-id returned non-number " run-id)
+			      )))
+		      "selection-cb in one-run")
 		     ;; (print "path: " (tree:node->path obj id) " run-id: " run-id)
 		     )))
 	 (cell-lookup (make-hash-table))
 	 (run-matrix (iup:matrix
 		      #:expand "YES"
@@ -1557,199 +1608,15 @@
 	 (one-run-updater  (lambda ()
 			     (if  (dashboard:database-changed? commondat tabdat)
 				  (dashboard:one-run-updater commondat tabdat tb cell-lookup run-matrix)))))
     (dboard:commondat-add-updater commondat one-run-updater tab-num: tab-num)
     (dboard:tabdat-runs-tree-set! tabdat tb)
-    (iup:split
-     tb
-     run-matrix)))
-;;     (iup:vbox
-;;      (let* ((cnv-obj (iup:canvas 
-;; 		     ;; #:size "500x400"
-;; 		     #:expand "YES"
-;; 		     #:scrollbar "YES"
-;; 		     #:posx "0.5"
-;; 		     #:posy "0.5"
-;; 		     #:action (make-canvas-action
-;; 			       (lambda (c xadj yadj)
-;; 				 (debug:catch-and-dump
-;; 				  (lambda ()
-;; 				    (if (not (dboard:tabdat-cnv tabdat))
-;; 					(dboard:tabdat-cnv-set! tabdat c))
-;; 				    (let ((drawing (dboard:tabdat-drawing tabdat))
-;; 					  (old-xadj (dboard:tabdat-xadj   tabdat))
-;; 					  (old-yadj (dboard:tabdat-yadj   tabdat)))
-;; 				      (if (not (and (eq? xadj old-xadj)(eq? yadj old-yadj)))
-;; 					  (begin
-;; 					    (print  "xadj: " xadj " yadj: " yadj "changed: "(eq? xadj old-xadj) " " (eq? yadj old-yadj))
-;; 					    (dboard:tabdat-view-changed-set! tabdat #t)
-;; 					    (dboard:tabdat-xadj-set! tabdat (* -500 (- xadj 0.5)))
-;; 					    (dboard:tabdat-yadj-set! tabdat (*  500 (- yadj 0.5)))
-;; 					    ))))
-;; 				  "iup:canvas action dashboard:one-run")))
-;; 		     #:wheel-cb (lambda (obj step x y dir) ;; dir is 4 for up and 5 for down. I think.
-;; 				  (debug:catch-and-dump
-;; 				   (lambda ()
-;; 				     (let* ((drawing (dboard:tabdat-drawing tabdat))
-;; 					    (scalex  (vg:drawing-scalex drawing)))
-;; 				       (dboard:tabdat-view-changed-set! tabdat #t)
-;; 				       (print "step: " step " x: " x " y: " y " dir: " dir " scalex: " scalex)
-;; 				       (vg:drawing-scalex-set! drawing
-;; 							       (+ scalex
-;; 								  (if (> step 0)
-;; 								      (* scalex  0.02)
-;; 								      (* scalex -0.02))))))
-;; 				   "dashboard:one-run wheel-cb"))
-;; 		     )))
-;;        cnv-obj))))
-
-
-;; This is the New View tab
-;; 
-;; (define (dashboard:new-view db commondat tabdat #!key (tab-num #f))
-;;   (let* ((tb      (iup:treebox
-;; 		   #:value 0
-;; 		   #:name "Runs"
-;; 		   #:expand "YES"
-;; 		   #:addexpanded "NO"
-;; 		   #: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 tabdat (cdr run-path))))
-;; 		       (if (number? run-id)
-;; 			   (begin
-;; 			     (dboard:tabdat-curr-run-id-set! tabdat run-id)
-;; 			     ;; (dashboard:update-new-view-tab)
-;; 			     (dboard:tabdat-layout-update-ok-set! tabdat #f)
-;; 			     )
-;; 			   (debug:print-error 0 *default-log-port* "tree-path->run-id returned non-number " run-id)))
-;; 		     ;; (print "path: " (tree:node->path obj id) " run-id: " run-id)
-;; 		     )))
-;; 	 (cell-lookup (make-hash-table))
-;; 	 (run-matrix (iup:matrix
-;; 		      #:expand "YES"
-;; 		      #:click-cb
-;; 		      (lambda (obj lin col status)
-;; 			(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)))))
-;; 	 (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)))
+    (iup:vbox
+     (iup:split
+      tb
+      run-matrix)
+     (dboard:make-controls commondat tabdat))))
 
 ;;======================================================================
 ;; R U N S 
 ;;======================================================================
 
@@ -1792,12 +1659,11 @@
 								    (hash-table-delete! *collapsed* tname))
 								  (hash-table-keys *collapsed*))
 							(iup:attribute-set! obj "TITLE" "Collapse"))))
 						(mark-for-update tabdat))
 					      "make-controls collapse button"))
-		      #:expand "NO" #:size "40x15"))
-	 )
+		      #:expand "NO" #:size "40x15")))
 	(iup:vbox
 	 ;; (iup:button "Sort -t"   #:action (lambda (obj)
 	 ;;   				 (next-sort-option)
 	 ;;   				 (iup:attribute-set! obj "TITLE" (vector-ref (vector-ref *tests-sort-options* *tests-sort-reverse*) 0))
 	 ;;   				 (mark-for-update tabdat)))
@@ -2000,21 +1866,21 @@
 	 (nkeys           (length keynames))
 	 (runsvec         (make-vector nruns))
 	 (header          (make-vector nruns))
 	 (lftcol          (make-vector ntests))
 	 (keycol          (make-vector ntests))
-	 (controls        '())
+	 (controls        (dboard:make-controls commondat runs-dat)) ;; '())
 	 (lftlst          '())
 	 (hdrlst          '())
 	 (bdylst          '())
 	 (result          '())
 	 (i               0)
 	 (btn-height      (dboard:tabdat-runs-btn-height runs-dat))
 	 (btn-fontsz      (dboard:tabdat-runs-btn-fontsz runs-dat))
 	 (cell-width      (dboard:tabdat-runs-cell-width runs-dat)))
     ;; controls (along bottom)
-    (set! controls (dboard:make-controls commondat runs-dat))
+    ;; (set! controls (dboard:make-controls commondat runs-dat))
     
     ;; 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 
@@ -2209,14 +2075,14 @@
 (iup:attribute-set! *tim* "TIME" 300)
 (iup:attribute-set! *tim* "RUN" "YES")
 
 (define *last-recalc-ended-time* 0)
 
-(define (dashboard:been-changed)
+(define (dashboard:been-changed tabdat)
   (> (file-modification-time (dboard:tabdat-dbfpath tabdat)) (dboard:tabdat-last-db-update tabdat)))
 
-(define (dashboard:set-db-update-time)
+(define (dashboard:set-db-update-time tabdat)
   (dboard:tabdat-last-db-update-set! tabdat (file-modification-time (dboard:tabdat-dbfpath tabdat))))
 
 (define (dashboard:recalc modtime please-update-buttons last-db-update-time)
   (or please-update-buttons
       (and (> (current-milliseconds)(+ *last-recalc-ended-time* 150))
@@ -2263,10 +2129,12 @@
 ;; point inside line
 ;;
 (define-inline (dashboard:px-between px lx1 lx2)
   (and (< lx1 px)(> lx2 px)))
 
+;;Not reference anywhere
+;;
 (define (dashboard:summary-tab-updater commondat tab-num)
   (if dashboard:update-summary-tab (dashboard:update-summary-tab)))
 ;; can a bar be placed in row "rownum" covering x1 to x2 without overlapping with existing 
 ;; bars? Use num-rows to check that a block will fit from rownum to (+ rownum num-rows)
 ;;
@@ -2576,11 +2444,12 @@
 		      (let* ((maxval   (apply max vals))
 			     (minval   (min 0 (apply min vals)))
 			     (yoff     (- minval lly)) ;;  minval))
 			     (deltaval (- maxval minval))
 			     (yscale   (/ delta-y (if (zero? deltaval) 1 deltaval)))
-			     (yfunc    (lambda (y)(+ lly (* yscale (- y minval)))))) ;; (lambda (y)(* (+ y yoff) yscale))))
+			     (yfunc    (lambda (y)(+ lly (* yscale (- y minval))))) ;; (lambda (y)(* (+ y yoff) yscale))))
+                             (graph-color (vg:generate-color)))
 			;; (print (car cf) "; maxval: " maxval " minval: " minval " deltaval: " deltaval " yscale: " yscale)
 			(vg:add-obj-to-comp
 			 cmp 
 			 (vg:make-text-obj (- llx 10)(yfunc maxval) (conc maxval)))
 			(vg:add-obj-to-comp
@@ -2587,28 +2456,28 @@
 			 cmp 
 			 (vg:make-text-obj (- llx 10)(yfunc minval) (conc minval)))
 			(fold 
 			 (lambda (next prev)  ;; #(time ? val) #(time ? val)
 			   (if prev
-			       (let* ((yval       (vector-ref prev 2))
-                                      (yval-next  (vector-ref next 2))
-				      (last-tval  (tfn   (vector-ref prev 0)))
-				      (last-yval  (yfunc yval)) ;; (+ lly (* yscale (vector-ref prev 2))))
-                                      (next-yval  (yfunc yval-next))
-				      (curr-tval  (tfn   (vector-ref next 0))))
+			       (let* ((yval        (vector-ref prev 2))
+                                      (yval-next   (vector-ref next 2))
+				      (last-tval   (tfn   (vector-ref prev 0)))
+				      (last-yval   (yfunc yval)) ;; (+ lly (* yscale (vector-ref prev 2))))
+                                      (next-yval   (yfunc yval-next))
+				      (curr-tval   (tfn   (vector-ref next 0))))
 				 (if (>= curr-tval last-tval)
                                      (begin
                                        (vg:add-obj-to-comp
                                         cmp 
                                         ;;(vg:make-rect-obj last-tval lly curr-tval last-yval ;; (- stval 2) lly (+ stval 2)(+ lly (* yval yscale))
                                         (vg:make-line-obj last-tval last-yval curr-tval last-yval
-                                                          line-color: stdcolor))
+                                                          line-color: graph-color))
                                        (vg:add-obj-to-comp
                                         cmp 
                                         ;;(vg:make-rect-obj last-tval lly curr-tval last-yval ;; (- stval 2) lly (+ stval 2)(+ lly (* yval yscale))
                                         (vg:make-line-obj curr-tval last-yval curr-tval next-yval
-                                                 line-color: stdcolor)))         
+                                                 line-color: graph-color)))         
 				     (print "ERROR: curr-tval is not > last-tval; curr-tval " curr-tval ", last-tval " last-tval))))
 			   next)
 			 ;; for init create vector tstart,0
 			 #f ;; (vector tstart minval minval)
 			 dat)
@@ -3034,14 +2903,14 @@
 			   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:commondat-please-update-set! commondat #t) ;; MRW: ww36.3 - why was please update set true here? Removing it for now.
 			      ;; (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)