@@ -11,11 +11,12 @@
 
 (use format)
 (require-library iup)
 (import (prefix iup iup:))
 (use canvas-draw)
-(use regex)
+(import canvas-draw-iup)
+(use regex typed-records)
 
 (declare (unit dcommon))
 
 (declare (uses megatest-version))
 (declare (uses gutils))
@@ -32,76 +33,10 @@
 
 ;;======================================================================
 ;; 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))
 
 ;;======================================================================
 ;; D O T F I L E
 ;;======================================================================
 
@@ -129,26 +64,40 @@
 
 ;; 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))
+
+;; modify a cell if the data is changed, return #t or-ed with previous if modified, #f elsewise
+;;
+(define (dcommon:modifiy-if-different mtrx cell-name new-val prev-changed)
+  (let ((curr-val (iup:attribute mtrx cell-name)))
+    (if (not (equal? curr-val new-val)) 
+	(begin
+	  (iup:attribute-set! mtrx cell-name col-name)
+	  #t) ;; need a re-draw
+	prev-changed)))
+
 
 ;; 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
+;;
+;;    NOTE: Used in newdashboard
 ;;
 ;; Mode is 'full or 'incremental for full refresh or incremental refresh
 (define (dcommon: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
+	 (changed         #f)
 	 (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*)))
+	 (test-ids        (hash-table-values (dboard:tabdat-curr-test-ids data)))
 	 ;; run-id is #f in next line to send the query to server 0
  	 (run-changes     (synchash:client-get 'db:get-runs get-runs-sig (length keypatts) data #f 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 #f test-ids)
 				   '()))
@@ -174,12 +123,13 @@
 				 (> 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)
+	 (rownum       0)
+	 (cellname (conc rownum ":" colnum))) ;; rownum = 0 is the header
+;; (debug:print 0 *default-log-port* "test-ids " test-ids ", tests-detail-changes " tests-detail-changes)
     
 	 ;; tests related stuff
 	 ;; (all-testnames (delete-duplicates (map db:test-testname test-changes))))
 
     ;; Given a run-id and testname/item_path calculate a cell R:C
@@ -192,24 +142,24 @@
 		       (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! (dboard:tabdat-run-keys data) run-id run-path)
+		  ;; modify cell - but only if changed
+		  (set! changed (dcommon:modifiy-if-different (dboard:tabdat-runs-matrix data) cellname col-name changed))
 		  (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))
+		  (tree:add-node (dboard:tabdat-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))
+		(let* ((run-path       (hash-table-ref (dboard:tabdat-run-keys data) run-id))
 		       (test-changes   (hash-table-ref all-test-changes 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))))
@@ -244,50 +194,74 @@
 				     (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))))
-				     (tb         (dboard:data-get-tests-tree *data*)))
+				     (tb         (dboard:tabdat-tests-tree data)))
 				(print "INFONOTE: run-path: " run-path)
-				(tree:add-node (dboard:data-get-tests-tree *data*) "Runs" 
+				(tree:add-node (dboard:tabdat-tests-tree data) "Runs" 
 					       test-path
 					       userdata: (conc "test-id: " test-id))
 				(let ((node-num (tree:find-node tb (cons "Runs" test-path)))
 				      (color    (car (gutils:get-color-for-state-status state status))))
-				  (debug:print 0 "node-num: " node-num ", color: " color)
-				  (iup:attribute-set! tb (conc "COLOR" node-num) color))
-				(hash-table-set! (dboard:data-get-path-test-ids *data*) test-path test-id)
+				  (debug:print 0 *default-log-port* "node-num: " node-num ", color: " color)
+
+				  (set! changed (dcommon:modifiy-if-different 
+						 tb
+						 (conc "COLOR" node-num)
+						 color changed))
+
+				  ;; (iup:attribute-set! tb (conc "COLOR" node-num) color)
+				  )
+				(hash-table-set! (dboard:tabdat-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! changed (dcommon:modifiy-if-different 
+						     (dboard:tabdat-runs-matrix data)
+						     (conc rownum ":" 0)
+						     dispname
+						     changed))
+				      ;; (iup:attribute-set! (dboard:tabdat-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 (member state '("ARCHIVED" "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)))
+				;; (debug:print 2 *default-log-port* "rownum:colnum=" rownum ":" colnum ", state=" status)
+				(set! changed (dcommon:modifiy-if-different 
+						     (dboard:tabdat-runs-matrix data)
+						     (conc rownum ":" colnum)
+						     (if (member state '("ARCHIVED" "COMPLETED"))
+							 status
+							 state)
+						     changed))
+				;; (iup:attribute-set! (dboard:tabdat-runs-matrix data)
+				;; 		    (conc rownum ":" colnum)
+				;; 		    (if (member state '("ARCHIVED" "COMPLETED"))
+				;; 			status
+				;; 			state))
+				(set! changed (dcommon:modifiy-if-different 
+					       (dboard:tabdat-runs-matrix data)
+					       (conc "BGCOLOR" rownum ":" colnum)
+					       (car (gutils:get-color-for-state-status state status))
+					       changed))
+				;; (iup:attribute-set! (dboard:tabdat-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)))
+    (let ((updater (hash-table-ref/default  (dboard:commondat-updaters commondat) 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)
+    (if changed (iup:attribute-set! (dboard:tabdat-runs-matrix data) "REDRAW" "ALL"))
+    ;; (debug:print 2 *default-log-port* "run-changes: " run-changes)
+    ;; (debug:print 2 *default-log-port* "test-changes: " test-changes)
     (list run-changes all-test-changes)))
 
 ;;======================================================================
 ;; TESTS DATA
 ;;======================================================================
@@ -298,20 +272,45 @@
   (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))
+	(let* ((test-id    (db:test-get-id hed)) ;; look at the tests-dat spec for locations
+	       (test-name  (db:test-get-testname hed))
+	       (item-path  (db:test-get-item-path hed))
+	       (state      (db:test-get-state hed))
+	       (status     (db:test-get-status hed))
 	       (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)))))))
-	  
+
+(define (dcommon:examine-xterm run-id test-id)
+  (let* ((testdat (rmt:get-test-info-by-id run-id test-id)))
+    (if (not testdat)
+	(begin
+	  (debug:print 2 "ERROR: No test data found for test " test-id ", exiting")
+	  (exit 1))
+        (let*
+            ((rundir        (if testdat 
+				(db:test-get-rundir testdat)
+				  logfile))
+             (testfullname  (if testdat (db:test-get-fullname testdat) "Gathering data ..."))
+             (xterm      (lambda ()
+                           (if (directory-exists? rundir)
+                               (let* ((shell (if (get-environment-variable "SHELL") 
+                                                (conc "-e " (get-environment-variable "SHELL"))
+                                                ""))
+                                      (command (conc "cd " rundir 
+                                                     ";mt_xterm -T \"" (string-translate testfullname "()" "  ") "\" " shell "&")))
+                                 (print "Command =" command)
+                                 (common:without-vars
+                                  command
+                                  "MT_.*"))
+                               (message-window  (conc "Directory " rundir " not found"))))))
+          (xterm)
+          (print "Adding xterm code")))))
 
 ;;======================================================================
 ;; D A T A   T A B L E S
 ;;======================================================================
 
@@ -352,11 +351,11 @@
 			   #:alignment1 "ALEFT"
 			   #:expand "YES" ;; "HORIZONTAL"
 			   #:numcol 1
 			   #:numlin (length key-vals)
 			   #:numcol-visible 1
-			   #:numlin-visible (length key-vals)
+			   #:numlin-visible (min 10 (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
@@ -396,75 +395,77 @@
     (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 dbstruct)
+(define (dcommon:run-stats commondat tabdat #!key (tab-num #f))
   (let* ((stats-matrix (iup:matrix expand: "YES"))
 	 (changed      #f)
-	 (updater      (lambda ()
-			 (let* ((run-stats    (db:get-run-stats dbstruct))
-				(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))
-				(max-col-vis  (if (> max-col 10) 10 max-col))
-				(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-vis)
-			   (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)
+	 (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))
+				    (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 (- (dboard:tabdat-num-tests tabdat) 15) 3))
+				    (max-col-vis  (if (> max-col 10) 10 max-col))
+				    (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-vis)
+			       (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")))))))
+    (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)))
 
-(define (dcommon:servers-table)
+(define (dcommon:servers-table commondat tabdat)
   (let* ((tdbdat         (tasks:open-db))
 	 (colnum         0)
 	 (rownum         0)
 	 (servers-matrix (iup:matrix #:expand "YES"
 				     #:numcol 7
@@ -471,84 +472,86 @@
 				     #:numcol-visible 7
 				     #:numlin-visible 5
 				     ))
 	 (colnames       (list "Id" "MTver" "Pid" "Host" "Interface:OutPort" "RunTime" "State" "RunId"))
 	 (updater        (lambda ()
-			   (let ((servers (tasks:get-all-servers (db:delay-if-busy tdbdat))))
-			     (iup:attribute-set! servers-matrix "NUMLIN" (length servers))
-			     ;; (set! colnum 0)
-			     ;; (for-each (lambda (colname)
-			     ;;    	 ;; (print "colnum: " colnum " colname: " colname)
-			     ;;    	 (iup:attribute-set! servers-matrix (conc "0:" colnum) colname)
-			     ;;    	 (set! colnum (+ 1 colnum)))
-			     ;;           colnames)
-			     (set! rownum 1)
-			     (for-each 
-			      (lambda (server)
-				(set! colnum 0)
-				(let* ((vals (list (vector-ref server 0) ;; Id
-						   (vector-ref server 9) ;; MT-Ver
-						   (vector-ref server 1) ;; Pid
-						   (vector-ref server 2) ;; Hostname
-						   (conc (vector-ref server 3) ":" (vector-ref server 4)) ;; IP:Port
-						   (seconds->hr-min-sec (- (current-seconds)(vector-ref server 6)))
-						   ;; (vector-ref server 5) ;; Pubport
-						   ;; (vector-ref server 10) ;; Last beat
-						   ;; (vector-ref server 6) ;; Start time
-						   ;; (vector-ref server 7) ;; Priority
-						   ;; (vector-ref server 8) ;; State
-						   (vector-ref server 8) ;; State
-						   (vector-ref server 12)  ;; RunId
-						   )))
-				  (for-each (lambda (val)
-					      (let* ((row-col (conc rownum ":" colnum))
-						     (curr-val (iup:attribute servers-matrix row-col)))
-						(if (not (equal? (conc val) curr-val))
-						    (begin
-						      (iup:attribute-set! servers-matrix row-col val)
-						      (iup:attribute-set! servers-matrix "FITTOTEXT" (conc "C" colnum))))
-						(set! colnum (+ 1 colnum))))
-					    vals)
-				  (set! rownum (+ rownum 1)))
-				 (iup:attribute-set! servers-matrix "REDRAW" "ALL"))
-			      servers)))))
+			   (if (dashboard:monitor-changed? commondat tabdat)
+			       (let ((servers (tasks:get-all-servers (db:delay-if-busy tdbdat))))
+				 (iup:attribute-set! servers-matrix "NUMLIN" (length servers))
+				 ;; (set! colnum 0)
+				 ;; (for-each (lambda (colname)
+				 ;;    	 ;; (print "colnum: " colnum " colname: " colname)
+				 ;;    	 (iup:attribute-set! servers-matrix (conc "0:" colnum) colname)
+				 ;;    	 (set! colnum (+ 1 colnum)))
+				 ;;           colnames)
+				 (set! rownum 1)
+				 (for-each 
+				  (lambda (server)
+				    (set! colnum 0)
+				    (let* ((vals (list (vector-ref server 0) ;; Id
+						       (vector-ref server 9) ;; MT-Ver
+						       (vector-ref server 1) ;; Pid
+						       (vector-ref server 2) ;; Hostname
+						       (conc (vector-ref server 3) ":" (vector-ref server 4)) ;; IP:Port
+						       (seconds->hr-min-sec (- (current-seconds)(vector-ref server 6)))
+						       ;; (vector-ref server 5) ;; Pubport
+						       ;; (vector-ref server 10) ;; Last beat
+						       ;; (vector-ref server 6) ;; Start time
+						       ;; (vector-ref server 7) ;; Priority
+						       ;; (vector-ref server 8) ;; State
+						       (vector-ref server 8) ;; State
+						       (vector-ref server 12)  ;; RunId
+						       )))
+				      (for-each (lambda (val)
+						  (let* ((row-col (conc rownum ":" colnum))
+							 (curr-val (iup:attribute servers-matrix row-col)))
+						    (if (not (equal? (conc val) curr-val))
+							(begin
+							  (iup:attribute-set! servers-matrix row-col val)
+							  (iup:attribute-set! servers-matrix "FITTOTEXT" (conc "C" colnum))))
+						    (set! colnum (+ 1 colnum))))
+						vals)
+				      (set! rownum (+ rownum 1)))
+				    (iup:attribute-set! servers-matrix "REDRAW" "ALL"))
+				  servers))))))
     (set! colnum 0)
     (for-each (lambda (colname)
 		(iup:attribute-set! servers-matrix (conc "0:" colnum) colname)
 		(iup:attribute-set! servers-matrix "FITTOTEXT" (conc "C" colnum))
 		(set! colnum (+ colnum 1)))
 	      colnames)
-    (set! dashboard:update-servers-table updater) 
+    ;; (set! dashboard:update-servers-table updater) 
+    (dboard:commondat-add-updater commondat updater)
     ;; (iup:attribute-set! servers-matrix "WIDTHDEF" "40")
-   ;;  (iup:hbox
-   ;;   (iup:vbox
-   ;;    (iup:button "Start"
-   ;;      	  ;; #:size "50x"
-   ;;      	  #:expand "YES"
-   ;;      	  #:action (lambda (obj)
-   ;;      		     (let ((cmd (conc ;; "xterm -geometry 180x20 -e \""
-   ;;      				      "megatest -server - &")))
-   ;;      				      ;; ";echo Press any key to continue;bash -c 'read -n 1 -s'\" &")))
-   ;;      		       (system cmd))))
-   ;;    (iup:button "Stop"
-   ;;      	  #:expand "YES"
-   ;;      	  ;; #:size "50x"
-   ;;      	  #:action (lambda (obj)
-   ;;      		     (let ((cmd (conc ;; "xterm -geometry 180x20 -e \""
-   ;;      				      "megatest -stop-server 0 &")))
-   ;;      				      ;; ";echo Press any key to continue;bash -c 'read -n 1 -s'\" &")))
-   ;;      		       (system cmd))))
-   ;;    (iup:button "Restart"
-   ;;      	  #:expand "YES"
-   ;;      	  ;; #:size "50x"
-   ;;      	  #:action (lambda (obj)
-   ;;      		     (let ((cmd (conc ;; "xterm -geometry 180x20 -e \""
-   ;;      				      "megatest -stop-server 0;megatest -server - &")))
-   ;;      				      ;; ";echo Press any key to continue;bash -c 'read -n 1 -s'\" &")))
-   ;;      		       (system cmd)))))
-   ;;    servers-matrix
-   ;;   )))
+    ;;  (iup:hbox
+    ;;   (iup:vbox
+    ;;    (iup:button "Start"
+    ;;      	  ;; #:size "50x"
+    ;;      	  #:expand "YES"
+    ;;      	  #:action (lambda (obj)
+    ;;      		     (let ((cmd (conc ;; "xterm -geometry 180x20 -e \""
+    ;;      				      "megatest -server - &")))
+    ;;      				      ;; ";echo Press any key to continue;bash -c 'read -n 1 -s'\" &")))
+    ;;      		       (system cmd))))
+    ;;    (iup:button "Stop"
+    ;;      	  #:expand "YES"
+    ;;      	  ;; #:size "50x"
+    ;;      	  #:action (lambda (obj)
+    ;;      		     (let ((cmd (conc ;; "xterm -geometry 180x20 -e \""
+    ;;      				      "megatest -stop-server 0 &")))
+    ;;      				      ;; ";echo Press any key to continue;bash -c 'read -n 1 -s'\" &")))
+    ;;      		       (system cmd))))
+    ;;    (iup:button "Restart"
+    ;;      	  #:expand "YES"
+    ;;      	  ;; #:size "50x"
+    ;;      	  #:action (lambda (obj)
+    ;;      		     (let ((cmd (conc ;; "xterm -geometry 180x20 -e \""
+    ;;      				      "megatest -stop-server 0;megatest -server - &")))
+    ;;      				      ;; ";echo Press any key to continue;bash -c 'read -n 1 -s'\" &")))
+    ;;      		       (system cmd)))))
+    ;;    servers-matrix
+    ;;   )))
     servers-matrix
     ))
 
 ;; The main menu
 (define (dcommon:main-menu)
@@ -579,16 +582,16 @@
 
 ;;======================================================================
 ;; CANVAS STUFF FOR TESTS
 ;;======================================================================
 
-(define (dcommon:draw-test cnv scalef x y w h name selected)
-  (let* ((llx (* scalef x))
-	 (lly (* scalef y))
-	 (urx (* scalef (+ x w)))
-	 (ury (* scalef (+ y h))))
-    (canvas-text! cnv (+ llx 5)(+ lly 5) name) ;; (conc testname " (" xtorig "," ytorig ")"))
+(define (dcommon:draw-test cnv xoffset yoffset scalef x y w h name selected)
+  (let* ((llx (dcommon:x->canvas x scalef xoffset))
+	 (lly (dcommon:y->canvas y scalef yoffset))
+	 (urx (dcommon:x->canvas (+ x w) scalef xoffset))
+	 (ury (dcommon:y->canvas (+ y h) scalef yoffset)))
+    (canvas-text! cnv (+ llx 5)(+ lly 5) name)
     (canvas-rectangle! cnv llx urx lly ury)
     (if selected (canvas-box! cnv llx (+ llx 5) lly (+ lly 5)))))
 
 (define (dcommon:draw-arrow cnv test-box-center waiton-center)
   (let* ((test-box-center-x (vector-ref test-box-center 0))
@@ -630,33 +633,41 @@
 		)
   (canvas-mark! cnv new-waiton-x new-waiton-y)))
 
 (define (dcommon:get-box-center box)
   (let* ((llx  (list-ref box 0))
-	 (lly  (list-ref box 4))
-	 (boxw (list-ref box 5))
-	 (boxh (list-ref box 6)))
+	 (lly  (list-ref box 1))
+	 (boxw (list-ref box 4))
+	 (boxh (list-ref box 5)))
     (vector (+ llx (/ boxw 2))
 	    (+ lly (/ boxh 2)))))
 
 (define-inline (num->int num)
   (inexact->exact (round num)))
 
-(define (dcommon:draw-edges cnv scalef edges)
+(define (dcommon:draw-edges cnv xoffset yoffset scalef edges)
   (for-each
    (lambda (e)
      (let loop ((x1 (car e))
 		(y1 (cadr e))
 		(x2 #f)
 		(y2 #f)
 		(tal (cddr e)))
        (if (and x1 y1 x2 y2)
-	   (canvas-line! cnv x1 y1 x2 y2)) ;; (num->int x1)(num->int y1)(num->int x2)(num->int y2)))
+	   (canvas-line! 
+	    cnv 
+	    (num->int (dcommon:x->canvas x1 scalef xoffset))
+	    (num->int (dcommon:y->canvas y1 scalef yoffset))
+	    (num->int (dcommon:x->canvas x2 scalef xoffset))
+	    (num->int (dcommon:y->canvas y2 scalef yoffset)))) ;; (num->int x1)(num->int y1)(num->int x2)(num->int y2)))
        (if (< (length tal) 2)
-	   (canvas-mark! cnv x1 y1) ;; (num->int x1)(num->int y1))
+	   (canvas-mark! cnv
+			 (num->int (dcommon:x->canvas x1 scalef xoffset))
+			 (num->int (dcommon:y->canvas y1 scalef yoffset))) ;; (num->int x1)(num->int y1))
 	   (loop (car tal)(cadr tal) x1 y1 (cddr tal)))))
-   (map (lambda (e)(map (lambda (x)(num->int (* x scalef))) e)) edges)))
+   ;; (map (lambda (e)(map (lambda (x)(num->int (* x scalef))) e)) edges)))
+   edges))
 
 
 (define (dcommon:draw-arrows cnv testname tests-hash test-records)
   (let* ((test-box-info   (hash-table-ref tests-hash testname))
 	 (test-box-center (dcommon:get-box-center test-box-info))
@@ -666,85 +677,150 @@
      (lambda (waiton)
        (let* ((waiton-box-info (hash-table-ref/default tests-hash waiton #f))
 	      (waiton-center   (dcommon:get-box-center (or waiton-box-info test-box-info))))
 	 (dcommon:draw-arrow cnv test-box-center waiton-center)))
      waitons)
-    ;; (debug:print 0 "test-box-info=" test-box-info)
-    ;; (debug:print 0 "test-record=" test-record)
+    ;; (debug:print 0 *default-log-port* "test-box-info=" test-box-info)
+    ;; (debug:print 0 *default-log-port* "test-record=" test-record)
     ))
 
+(define (dcommon:estimate-scale sizex sizey originx originy nodes)
+  ;; (print "sizex: " sizex " sizey: " sizey " originx: " originx " originy: " originy " nodes: " nodes)
+  (let* ((maxx 1)
+	 (maxy 1))
+    (for-each
+     (lambda (node)
+       (if (equal? (car node) "node")
+	   (let ((x (string->number (list-ref node 2)))
+		 (y (string->number (list-ref node 3))))
+	     (if (and x (> x maxx))(set! maxx x))
+	     (if (and y (> y maxy))(set! maxy y)))))
+     nodes)
+    (let ((scalex (/ sizex maxx))
+	  (scaley (/ sizey maxy)))
+      ;; (print "maxx: " maxx " maxy: " maxy " scalex: " scalex " scaley: " scaley)
+      (min scalex scaley))))
+
+(define (dcommon:get-xoffset tests-draw-state sizex-in xadj-in)
+  (let ((xadj  (or xadj-in  (hash-table-ref/default tests-draw-state 'xadj 0)))
+	(sizex (or sizex-in (hash-table-ref/default tests-draw-state 'sizex 500))))
+    (hash-table-set! tests-draw-state 'xadj xadj) ;; for use in de-scaling when handling mouse clicks
+    (hash-table-set! tests-draw-state 'sizex sizex)
+    (* (/ sizex 2) (- 0.5 xadj))))
+
+(define (dcommon:get-yoffset tests-draw-state sizey-in yadj-in)
+  (let ((yadj  (or yadj-in  (hash-table-ref/default tests-draw-state 'yadj 0)))
+	(sizey (or sizey-in (hash-table-ref/default tests-draw-state 'sizey 500))))
+    (hash-table-set! tests-draw-state 'yadj yadj) ;; for use in de-scaling when handling mouse clicks
+    (hash-table-set! tests-draw-state 'sizey sizey)
+    (* (/ sizey 2) (- yadj 0.5))))
+
+(define (dcommon:x->canvas x scalef xoffset)
+  (+ xoffset (* x scalef)))
+
+(define (dcommon:y->canvas y scalef yoffset)
+  (+ yoffset (* y scalef)))
+
+;; sizex, sizey     - canvas size
+;; originx, originy - canvas origin
+;;
 (define (dcommon:initial-draw-tests cnv xadj yadj sizex sizey sizexmm sizeymm originx originy tests-draw-state sorted-testnames test-records)
   (let* ((dot-data ;; (map cdr (filter
 		   ;; 	  (lambda (x)(equal? "node" (car x)))
-	  (map string-split (tests:lazy-dot test-records "plain"))) ;; (tests:easy-dot test-records "plain")))
-	 (scalef (hash-table-ref   tests-draw-state 'scalef))
-	 (dotscale (hash-table-ref tests-draw-state 'dotscale))
-	 (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) 1 (- 0.5 xadj)))) ;;  (- xadj 1))))
-	 (ytorig (+ test-browse-yoffset (* (/ sizey 2) 1 (- yadj 0.5))))
-	 (boxw   10)
-	 (tests-hash     (hash-table-ref tests-draw-state 'tests-info))
-	 (selected-tests (hash-table-ref tests-draw-state 'selected-tests )))
-    ;; (print "dot-data=" dot-data)
-    (hash-table-set! tests-draw-state 'xtorig xtorig)
-    (hash-table-set! tests-draw-state 'ytorig ytorig)
+	  (map string-split (tests:lazy-dot test-records "plain" sizex sizey))) ;; (tests:easy-dot test-records "plain")))
+	 (xoffset	 (dcommon:get-xoffset tests-draw-state sizex xadj))
+	 (yoffset        (dcommon:get-yoffset tests-draw-state sizey yadj))
+	 (no-dot         (configf:lookup *configdat* "setup" "nodot"))
+	 (boxh           15)
+	 (boxw           10)
+	 (margin         5)
+	 (tests-info     (hash-table-ref tests-draw-state 'tests-info))
+	 (selected-tests (hash-table-ref tests-draw-state 'selected-tests ))
+	 (scalef         (if no-dot
+			     1
+			     (dcommon:estimate-scale sizex sizey originx originy dot-data)))
+	 (sorted-testnames (if no-dot
+			       (sort sorted-testnames string>=?)
+			       sorted-testnames))
+	 (curr-x         0)  ;; NB// NOT screen units
+	 (curr-y         (/ (- sizey boxh margin) scalef)) ;; used when no-dot
+	 (scaled-sizex   (/ sizex scalef)))
+
+    (hash-table-set! tests-draw-state 'scalef scalef)
+    
     (let ((longest-str   (if (null? sorted-testnames) "         " (car (sort sorted-testnames (lambda (a b)(>= (string-length a)(string-length b))))))))
       (let-values (((x-max y-max) (canvas-text-size cnv longest-str)))
 	(if (> x-max boxw)(set! boxw (+ 10 x-max)))))
     ;; (print "sizex: " sizex " sizey: " sizey " font: " (canvas-font cnv) " originx: " originx " originy: " originy " xtorig: " xtorig " ytorig: " ytorig " xadj: " xadj " yadj: " yadj)
     (if (not (null? sorted-testnames))
 	(let loop ((hed (car (reverse sorted-testnames)))
 		   (tal (cdr (reverse sorted-testnames))))
-	  (let* ((nodedat (let ((tmpres (filter (lambda (x)
-						  (if (and (not (null? x))
-							   (equal? (car x) "node"))
-						      (equal? hed (cadr x))
-						      #f))
-						dot-data)))
-			    (if (null? tmpres)
-				;;           llx  lly boxw boxh
-				(list "0" "1" "1" (conc (length tal)) "2" "0.5") ;; return some junk
-				(car tmpres))))
-		 (edgedat (let ((edges (filter (lambda (x)  ;; filter for edge
-						 (if (and (not (null? x))
-							  (equal? (car x) "edge"))
-						     (equal? hed (cadr x))
-						     #f))
-					       dot-data)))
-			    (map (lambda (inlst)
-				   (dcommon:process-polyline 
-				    (map (lambda (instr)
-					   (* dotscale (string->number instr))) ;; convert to number and scale
-					 (let ((il (cddddr inlst)))
-					   (take il (- (length il) 2))))
-				    (lambda (x y)
-				      (list (+ x xtorig)
-					    (+ y ytorig)))
-				    #f #f)) ;; process polyline
-				 edges)))
-		 (llx  (* (string->number (list-ref nodedat 2)) dotscale))
-		 (lly  (* (string->number (list-ref nodedat 3)) dotscale))
-		 (boxw (* (string->number (list-ref nodedat 4)) dotscale))
-		 (boxh (* (string->number (list-ref nodedat 5)) dotscale))
+	  (let* ((nodedat (if no-dot
+			      #f
+			      (let ((tmpres (filter (lambda (x)
+						      (if (and (not (null? x))
+							       (equal? (car x) "node"))
+							  (equal? hed (cadr x))
+							  #f))
+						    dot-data)))
+				(if (null? tmpres)
+				    ;;           llx  lly boxw boxh
+				    (list "0" "1" "1" (conc (length tal)) "2" "0.5") ;; return some placeholder junk if no dat found
+				    (car tmpres)))))
+		 (edgedat (if no-dot
+			      '()
+			      (let ((edges (filter (lambda (x)  ;; filter for edge
+						     (if (and (not (null? x))
+							      (equal? (car x) "edge"))
+							 (equal? hed (cadr x))
+							 #f))
+						   dot-data)))
+				(map (lambda (inlst)
+				       (dcommon:process-polyline 
+					(map (lambda (instr)
+					       (string->number instr)) ;; convert to number and scale
+					     (let ((il (cddddr inlst)))
+					       (take il (- (length il) 2))))
+					(lambda (x y)
+					  (list (+ x 0)   ;; xtorig)
+						(+ y 0))) ;; ytorig)))
+					#f #f)) ;; process polyline
+				     edges))))
+		 (llx  (if no-dot
+			   curr-x
+			   (string->number (list-ref nodedat 2))))
+		 (lly  (if no-dot
+			   curr-y
+			   (string->number (list-ref nodedat 3))))
+		 (boxw (if no-dot
+			   boxw
+			   (string->number (list-ref nodedat 4))))
+		 (boxh (if no-dot
+			   boxh
+			   (string->number (list-ref nodedat 5))))
 		 (urx  (+ llx boxw))
 		 (ury  (+ lly boxh)))
+
+	    ;; if we are in no-dot mode then increment curr-x and curr-y as needed
+	    (if no-dot
+		(begin
+		  (cond 
+		   ((< curr-x (- scaled-sizex boxw boxw margin))
+		    (set! curr-x (+ curr-x boxw margin)))
+		   ((> curr-x (- scaled-sizex boxw boxw margin))
+		    (set! curr-x 0)
+		    (set! curr-y (- curr-y (+ boxh margin)))))))
 					; (print "hed " hed " llx " llx " lly " lly " urx " urx " ury " ury)
-	    (dcommon:draw-test cnv scalef llx lly boxw boxh hed (hash-table-ref/default selected-tests hed #f))
-	    ;; (dcommon:draw-arrows cnv testname tests-hash test-records))
-	    (dcommon:draw-edges cnv scalef edgedat)
+	    (dcommon:draw-test cnv xoffset yoffset scalef llx lly boxw boxh hed (hash-table-ref/default selected-tests hed #f))
+	    ;; (dcommon:draw-arrows cnv testname tests-info test-records))
+	    (dcommon:draw-edges cnv xoffset yoffset scalef edgedat)
 	    
 	    ;; data used by mouse click calc. keep the wacky order for now.
-	    (hash-table-set! tests-hash hed  (list llx urx (- sizey ury)(- sizey lly) lly boxw boxh edgedat)) 
-	    ;; (list llx lly boxw boxh)) ;; NB// Swap ury and lly
+	    (hash-table-set! tests-info hed  (list llx lly urx ury boxw boxh edgedat)) 
 	    (if (not (null? tal))
 		(loop (car tal)
 		      (cdr tal))))))
-    ;; (for-each
-    ;;  (lambda (testname)
-    ;;    (dcommon:draw-arrows cnv testname tests-hash test-records))
-    ;;  sorted-testnames))
     ))
 
 ;; per-point-proc required, remainder optional
 ;;
 (define (dcommon:process-polyline line per-point-proc per-segment-proc last-segment-proc)
@@ -764,55 +840,258 @@
 	      (append res (per-point-proc x1 y1)))
 	    (loop (car tal)(cadr tal) x1 y1 (cddr tal) (append res (per-point-proc x1 y1)))))))
 
 (define (dcommon:redraw-tests cnv xadj yadj sizex sizey sizexmm sizeymm originx originy tests-draw-state sorted-testnames test-records)
   (let* ((scalef              (hash-table-ref tests-draw-state 'scalef))
-	 (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) (- xadj 0.5)))) ;;  (- xadj 1))))
-	 (ytorig              (+ test-browse-yoffset (* (/ sizey 2) (- 0.5 yadj))))
-	 (xdelta              (- (hash-table-ref tests-draw-state 'xtorig) xtorig))
-	 (ydelta              (- (hash-table-ref tests-draw-state 'ytorig) ytorig))
-	 (tests-hash          (hash-table-ref tests-draw-state 'tests-info))
+	 (xoffset             (dcommon:get-xoffset tests-draw-state sizex xadj))
+	 (yoffset             (dcommon:get-yoffset tests-draw-state sizey yadj))
+	 (tests-info          (hash-table-ref tests-draw-state 'tests-info))
 	 (selected-tests      (hash-table-ref tests-draw-state 'selected-tests )))
-    (hash-table-set! tests-draw-state 'xtorig xtorig)
-    (hash-table-set! tests-draw-state 'ytorig ytorig)
     (if (not (null? sorted-testnames))
 	(let loop ((hed (car (reverse sorted-testnames)))
 		   (tal (cdr (reverse sorted-testnames))))
-	  (let* ((tvals (hash-table-ref tests-hash hed))
-		 (llx   (+ xdelta (list-ref tvals 0)))
-		 (lly   (+ ydelta (list-ref tvals 4)))
-		 (boxw  (list-ref tvals 5))
-		 (boxh  (list-ref tvals 6))
+	  (let* ((tvals (hash-table-ref tests-info hed))
+		 (llx   (list-ref tvals 0))
+		 (lly   (list-ref tvals 1))
+		 (boxw  (list-ref tvals 4))
+		 (boxh  (list-ref tvals 5))
 		 (edges (map (lambda (pline)
 			       (dcommon:process-polyline pline
 							 (lambda (x1 y1)
-							   (list (+ x1 xdelta)
-								 (+ y1 ydelta)))
+							   (list x1 y1))
 							 #f #f))
-			     (list-ref tvals 7)))
+			     (list-ref tvals 6)))
 		 (urx   (+ llx boxw))
 		 (ury   (+ lly boxh)))
-	    (dcommon:draw-test cnv scalef llx lly boxw boxh hed (hash-table-ref/default selected-tests hed #f))
-	    (dcommon:draw-edges cnv scalef edges)
-	    (hash-table-set! tests-hash hed (list llx urx (- sizey ury)(- sizey lly) lly boxw boxh edges))
+	    (dcommon:draw-test cnv xoffset yoffset scalef llx lly boxw boxh hed (hash-table-ref/default selected-tests hed #f))
+	    (dcommon:draw-edges cnv xoffset yoffset scalef edges)
 	    (if (not (null? tal))
 		;; leave a column of space to the right to list items
 		(loop (car tal)
 		      (cdr tal))))))))
-    ;; (for-each
-    ;;  (lambda (testname)
-    ;;    (dcommon:draw-edges cnv scalef edges)) ;; (dcommon:draw-arrows cnv testname tests-hash test-records))
-    ;;  sorted-testnames)))
+
+;;======================================================================
+;; RUN CONTROLS
+;;======================================================================
+
+(define (dcommon:command-execution-control data)
+  ;; 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:tabdat-command-tb-set! data tb)
+      tb)
+    (iup:button "Execute" #:size "50x"
+		#:action (lambda (obj)
+			   (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 #!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"))
+	   (lb         (iup:listbox #:expand "HORIZONTAL"
+				    #:dropdown "YES"
+				    #:action (lambda (obj val index lbstate)
+					       ;; (print obj " " val " " index " " lbstate)
+					       (dboard:tabdat-command-set! tabdat val)
+					       (dashboard:update-run-command tabdat))))
+	   (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 #!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)
+				      (debug:catch-and-dump
+				       (lambda ()
+					 ;; (print "obj: " obj " val: " val " unk: " unk)
+					 (dboard:tabdat-run-name-set! tabdat txt) ;; (iup:attribute obj "VALUE"))
+					 (dashboard:update-run-command tabdat))
+				       "command-runname-selector tb action"))
+			   #:value (or default-run-name (dboard:tabdat-run-name tabdat))))
+	  (lb (iup:listbox #:expand "HORIZONTAL"
+			   #:dropdown "YES"
+			   #:action (lambda (obj val index lbstate)
+				      (debug:catch-and-dump
+				       (lambda ()
+					 (if (not (equal? val ""))
+					     (begin
+					       (iup:attribute-set! tb "VALUE" val)
+					       (dboard:tabdat-run-name-set! tabdat val)
+					       (dashboard:update-run-command tabdat))))
+				       "command-runname-selector lb action"))))
+	  (refresh-runs-list (lambda ()
+			       (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 tab-num: tab-num)
+     (refresh-runs-list)
+     (dboard:tabdat-run-name-set! tabdat default-run-name)
+     (iup:hbox
+      tb
+      lb))))
+
+(define (dcommon:command-testname-selector commondat tabdat update-keyvals) ;;  key-listboxes)
+  (iup:vbox
+   ;; Text box for test patterns
+   (iup:frame
+    #:title "Test patterns (one per line)"
+    (let ((tb (iup:textbox #:action (lambda (val a b)
+				      (debug:catch-and-dump
+				       (lambda ()
+					 (dboard:tabdat-test-patts-set!-use
+					  tabdat
+					  (dboard:lines->test-patt b))
+					 (dashboard:update-run-command tabdat))
+				       "command-testname-selector tb action"))
+			   #:value (dboard:test-patt->lines
+				    (dboard:tabdat-test-patts-use tabdat))
+			   #:expand "YES"
+			   #:size "10x30"
+			   #:multiline "YES")))
+      (set! test-patterns-textbox tb)
+      tb))
+;; (iup:frame
+;;  #:title "Target"
+;;  ;; Target selectors
+;;  (apply iup:hbox
+;; 	   (let* ((dat      (dashboard:update-target-selector tabdat action-proc: update-keyvals))
+;; 		  (key-lb   (car dat))
+;; 		  (combos   (cadr dat)))
+;; 	     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!
+      (map cadr *common:std-states*) ;; '("COMPLETED" "RUNNING" "STUCK" "INCOMPLETE" "LAUNCHED" "REMOTEHOSTSTART" "KILLED")
+      (lambda (all)
+	(dboard:tabdat-states-set! tabdat all)
+	(dashboard:update-run-command tabdat))))
+    ;; Text box for STATES
+    (iup:frame
+     #:title "Statuses"
+     (dashboard:text-list-toggle-box 
+      (map cadr *common:std-statuses*) ;; '("PASS" "FAIL" "n/a" "CHECK" "WAIVED" "SKIP" "DELETED" "STUCK/DEAD")
+      (lambda (all)
+	(dboard:tabdat-statuses-set! tabdat all)
+	(dashboard:update-run-command tabdat)))))))
+
+(define (dcommon:command-tests-tasks-canvas data test-records sorted-testnames tests-draw-state)
+  (iup:frame
+   #:title "Tests and Tasks"
+   (let* ((updater #f)
+	  (last-xadj 0)
+	  (last-yadj 0)
+	  (the-cnv   #f)
+	  (canvas-obj 
+	   (iup:canvas #:action (make-canvas-action
+				 (lambda (cnv xadj yadj)
+				   (if (not updater)
+				       (set! updater (lambda (xadj yadj)
+						       ;; (print "cnv: " cnv " xadj: " xadj " yadj: " yadj)
+						       (dashboard:draw-tests cnv xadj yadj tests-draw-state sorted-testnames test-records)
+						       (set! last-xadj xadj)
+						       (set! last-yadj yadj))))
+				   (updater xadj yadj)
+				   (set! the-cnv cnv)
+				   ))
+		       ;; Following doesn't work 
+		       #:wheel-cb (lambda (obj step x y dir) ;; dir is 4 for up and 5 for down. I think.
+				    (let ((scalef (hash-table-ref tests-draw-state 'scalef)))
+				      (hash-table-set! tests-draw-state 'scalef (+ scalef
+										   (if (> step 0)
+										       (* scalef 0.01)
+										       (* scalef -0.01))))
+				      (if the-cnv
+					  (dashboard:draw-tests the-cnv last-xadj last-yadj tests-draw-state sorted-testnames test-records))
+				      ))
+		       ;; #:size "50x50"
+		       #:expand "YES"
+		       #:scrollbar "YES"
+		       #:posx "0.5"
+		       #:posy "0.5"
+		       #:button-cb (lambda (obj btn pressed x y status)
+				     ;; (print "obj: " obj ", pressed " pressed ", status " status)
+					; (print "canvas-origin: " (canvas-origin the-cnv))
+				     ;; (let-values (((xx yy)(canvas-origin the-cnv)))
+				     ;; (canvas-transform-set! the-cnv #f)
+				     ;; (print "canvas-origin: " xx " " yy " click at " x " " y))
+				     (let* ((tests-info     (hash-table-ref tests-draw-state 'tests-info))
+					    (selected-tests (hash-table-ref tests-draw-state 'selected-tests))
+					    (scalef         (hash-table-ref tests-draw-state 'scalef))
+					    (sizey          (hash-table-ref tests-draw-state 'sizey))
+					    (xoffset        (dcommon:get-xoffset tests-draw-state #f #f))
+					    (yoffset        (dcommon:get-yoffset tests-draw-state #f #f))
+					    (new-y          (- sizey y)))
+				       ;; (print "xoffset=" xoffset ", yoffset=" yoffset)
+				       ;; (print "\tx\ty\tllx\tlly\turx\tury")
+				       (for-each (lambda (test-name)
+						   (let* ((rec-coords (hash-table-ref tests-info test-name))
+							  (llx        (dcommon:x->canvas (list-ref rec-coords 0) scalef xoffset))
+							  (lly        (dcommon:y->canvas (list-ref rec-coords 1) scalef yoffset))
+							  (urx        (dcommon:x->canvas (list-ref rec-coords 2) scalef xoffset))
+							  (ury        (dcommon:y->canvas (list-ref rec-coords 3) scalef yoffset)))
+						     ;; (if (eq? pressed 1)
+						     ;;    (print "\tx=" x "\ty=" y "\tnew-y=" new-y "\tllx=" llx "\tlly=" lly "\turx=" urx "\tury=" ury "\t" test-name " "))
+						     (if (and (eq? pressed 1)
+							      (>= x llx)
+							      (>= new-y lly)
+							      (<= x urx)
+							      (<= new-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")))
+							     (iup:attribute-set! obj "REDRAW" "ALL")
+							     (hash-table-set! selected-tests test-name selected)
+							     (iup:attribute-set! test-patterns-textbox "VALUE" newpatt)
+							     (dboard:tabdat-test-patts-set!-use data (dboard:lines->test-patt newpatt))
+							     (dashboard:update-run-command data)
+							     (if updater (updater last-xadj last-yadj)))))))
+						 (hash-table-keys tests-info)))))))
+     canvas-obj)))
 
 ;;======================================================================
 ;;  S T E P S
 ;;======================================================================
 
 (define (dcommon:populate-steps teststeps steps-matrix)
-  (let ((max-row 0))
+  (let ((max-row 0)
+	(max-col 7))
     (if (null? teststeps)
 	(iup:attribute-set! steps-matrix "CLEARVALUE" "CONTENTS")
 	(let loop ((hed    (car teststeps))
 		   (tal    (cdr teststeps))
 		   (rownum 1)
@@ -819,30 +1098,30 @@
 		   (colnum 1))
 	  (if (> rownum max-row)(set! max-row rownum))
 	  (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)
+	    (if (< colnum max-col)
 		(loop hed tal rownum (+ colnum 1))
 		(if (not (null? tal))
 		    (loop (car tal)(cdr tal)(+ rownum 1) 1))))))
     (if (> max-row 0)
 	(begin
 	  ;; we are going to speculatively clear rows until we find a row that is already cleared
 	  (let loop ((rownum  (+ max-row 1))
 		     (colnum  0)
 		     (deleted #f))
-	    ;; (debug:print-info 0 "cleaning " rownum ":" colnum)
-	    (let* ((next-row (if (eq? colnum 6) (+ rownum 1) rownum))
-		   (next-col (if (eq? colnum 6) 1 (+ colnum 1)))
+	    ;; (debug:print-info 0 *default-log-port* "cleaning " rownum ":" colnum)
+	    (let* ((next-row (if (eq? colnum max-col) (+ rownum 1) rownum))
+		   (next-col (if (eq? colnum max-col) 1 (+ colnum 1)))
 		   (mtrx-rc  (conc rownum ":" colnum))
 		   (curr-val (iup:attribute steps-matrix mtrx-rc)))
-	      ;; (debug:print-info 0 "cleaning " rownum ":" colnum " currval= " curr-val)
+	      ;; (debug:print-info 0 *default-log-port* "cleaning " rownum ":" colnum " currval= " curr-val)
 	      (if (and (string? curr-val)
 		       (not (equal? curr-val "")))
 		  (begin
 		    (iup:attribute-set! steps-matrix mtrx-rc "")
 		    (loop next-row next-col #t))
-		  (if (eq? colnum 6) ;; not done, didn't get a full blank row
+		  (if (eq? colnum max-col) ;; not done, didn't get a full blank row
 		      (if deleted (loop next-row next-col #f)) ;; exit on this not met
 		      (loop next-row next-col deleted)))))
 	  (iup:attribute-set! steps-matrix "REDRAW" "ALL")))))