Index: Makefile
==================================================================
--- Makefile
+++ Makefile
@@ -172,12 +172,12 @@
 
 #======================================================================
 # Make the records files
 #======================================================================
 
-vg_records.scm : records.sh
-	./records.sh
+# vg_records.scm : records.sh
+#	./records.sh
 
 #======================================================================
 # Deploy section (not complete yet)
 #======================================================================
 

Index: dashboard.scm
==================================================================
--- dashboard.scm
+++ dashboard.scm
@@ -190,14 +190,17 @@
   run-start-row
   max-row
   running-layout
   originx
   originy
+  layout-update-ok
 
   ;; Controls used to launch runs etc.
-  command
+  command          ;; for run control this is the command being built up
   command-tb 
+  key-listboxes
+  key-lbs           
   run-name         ;; from run name setting widget
   states           ;; states for -state s1,s2 ...
   statuses         ;; statuses for -status s1,s2 ...
 
   ;; Selector variables
@@ -252,19 +255,23 @@
   (let ((dat (make-dboard:tabdat
 	      allruns-by-id:        (make-hash-table)
 	      allruns:              '() ;; list of run records (vectors)
 	      buttondat:            (make-hash-table)
 	      curr-test-ids:        (make-hash-table)
+	      command:              ""
 	      dbdir:                #f
 	      filters-changed:      #f
 	      header:               #f 
 	      hide-empty-runs:      #f
 	      hide-not-hide-button: #f
 	      hide-not-hide:        #t
 	      item-test-names:      '()
+	      keys:                 #f
+	      key-listboxes:        #f
 	      last-db-update:       0
 	      last-data-update:     0
+	      layout-update-ok:     #t
 	      not-done-runs:        '()
 	      done-runs:            '()
 	      num-tests:            15
 	      numruns:              16
 	      originx:              #f
@@ -323,23 +330,27 @@
 (defstruct dboard:rundat
   run
   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
   key-vals
   last-update    ;; last query to db got records from before last-update
+  data-changed
   )
 
-(define (dboard:rundat-make-init #!key (run #f)(key-vals #f)(tests #f)(last-update -100))
+(define (dboard:rundat-make-init #!key (run #f)(key-vals #f)(tests #f)(last-update -100));; -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)) ;; -100 is before time began
+   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)))
     (if (and (hash-table? src-ht)(hash-table? trg-ht))
@@ -499,12 +510,17 @@
 	 (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 (dboard:rundat-make-init run: run key-vals: key-vals))))
+			(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))))
 	 ;; (prev-tests  (dboard:rundat-tests prev-dat)) ;; (vector-ref prev-dat 1))
 	 (last-update (dboard:tabdat-last-update tabdat)) ;; (vector-ref prev-dat 3))
 	 (tmptests    (rmt:get-tests-for-run run-id testnamepatt states statuses  ;; run-id testpatt states statuses
 					     #f #f                                ;; offset limit 
 					     (dboard:tabdat-hide-not-hide tabdat) ;; no-in
@@ -520,10 +536,11 @@
 	 (start-time (current-seconds)))
     (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) 10)) ;; go back two seconds in time to ensure all changes are captured.
@@ -915,33 +932,40 @@
 	  (if (not (null? values))
 	      (let ((newval (car values)))
 		(iup:attribute-set! lb "VALUE" newval)
 		newval))))))
 
-(define (dashboard:update-target-selector key-lbs #!key (action-proc #f))
+(define (dashboard:update-target-selector tabdat #!key (action-proc #f))
   (let* ((runconf-targs (common:get-runconfig-targets))
+	 (key-lbs       (dboard:tabdat-key-listboxes tabdat))
 	 (db-target-dat (rmt:get-targets))
 	 (header        (vector-ref db-target-dat 0))
 	 (db-targets    (vector-ref db-target-dat 1))
-	 (all-targets   (append db-targets
-				(map (lambda (x)
-				       (list->vector
-					(take (append (string-split x "/")
-						      (make-list (length header) "na"))
-					      (length header))))
-				     runconf-targs)))
+	 (munge-target  (lambda (x)            ;; create a target vector from a string. Pad with na if needed.
+			  (list->vector
+			   (take (append (string-split x "/")
+					 (make-list (length header) "na"))
+				 (length header)))))
+	 (all-targets   (append (list (munge-target (string-intersperse 
+						     (map (lambda (x) "%") header)
+						     "/")))
+				db-targets
+				(map munge-target
+				     runconf-targs)
+				))
 	 (key-listboxes (if key-lbs key-lbs (make-list (length header) #f))))
+    (if (not (dboard:tabdat-key-listboxes tabdat))(dboard:tabdat-key-listboxes-set! tabdat key-listboxes))
     (let loop ((key     (car header))
 	       (remkeys (cdr header))
 	       (refvals '())
 	       (indx    0)
 	       (lbs     '()))
       (let* ((lb (let ((lb (list-ref key-listboxes indx)))
 		   (if lb
 		       lb
 		       (iup:listbox 
-			#:size "45x50" 
+			#:size "x60" 
 			#:fontsize "10"
 			#:expand "YES" ;; "VERTICAL"
 			;; #:dropdown "YES"
 			#:editbox "YES"
 			#:action (lambda (obj a b c)
@@ -951,18 +975,20 @@
 			))))
 	     ;; loop though all the targets and build the list for this dropdown
 	     (selected-value (dashboard:populate-target-dropdown lb refvals all-targets)))
 	(if (null? remkeys)
 	    ;; return a list of the listbox items and an iup:hbox with the labels and listboxes
-	    (let ((listboxes (append lbs (list lb))))
-	      (list listboxes
-		    (map (lambda (htxt lb)
-			   (iup:vbox
-			    (iup:label htxt) 
-			    lb))
-			 header
-			 listboxes)))
+	    (let* ((listboxes (append lbs (list lb)))
+		   (res       (list listboxes
+				    (map (lambda (htxt lb)
+					   (iup:vbox
+					    (iup:label htxt) 
+					    lb))
+					 header
+					 listboxes))))
+	      (dboard:tabdat-key-listboxes-set! tabdat res)
+	      res)
 	    (loop (car remkeys)
 		  (cdr remkeys)
 		  (append refvals (list selected-value))
 		  (+ indx 1)
 		  (append lbs (list lb))))))))
@@ -974,10 +1000,11 @@
   (let ((alltgls (make-hash-table)))
     (apply iup:vbox
 	   (map (lambda (item)
 		  (iup:toggle 
 		   item
+		   #:fontsize 8
 		   #:expand "YES"
 		   #:action (lambda (obj tstate)
 			       (debug:catch-and-dump 
 				(lambda ()
 				  (if (eq? tstate 0)
@@ -1059,10 +1086,23 @@
 ;; R U N   C O N T R O L S
 ;;======================================================================
 ;;
 ;; A gui for launching tests
 ;;
+
+(define (dboard:target-updater tabdat) ;;  key-listboxes)
+  (let ((targ (map (lambda (x)
+		     (iup:attribute x "VALUE"))
+		   (car (dashboard:update-target-selector tabdat))))
+	(curr-runname (dboard:tabdat-run-name tabdat)))
+    (dboard:tabdat-target-set! tabdat targ)
+    ;; (if (dboard:tabdat-updater-for-runs tabdat)
+    ;; 	 ((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)))
 
 (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* '()))
@@ -1069,23 +1109,13 @@
 	 (test-names    (hash-table-keys all-tests-registry))
 	 (sorted-testnames #f)
 	 (action        "-run")
 	 (cmdln         "")
 	 (runlogs       (make-hash-table))
-	 (key-listboxes #f)
-	 (update-keyvals (lambda ()
-			   (let ((targ (map (lambda (x)
-					      (iup:attribute x "VALUE"))
-					    (car (dashboard:update-target-selector key-listboxes))))
-				 (curr-runname (dboard:tabdat-run-name tabdat)))
-			     (dboard:tabdat-target-set! tabdat targ)
-			;; (if (dboard:tabdat-updater-for-runs tabdat)
-			;; 	 ((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))))
+	 ;;; (key-listboxes #f)
+	 (update-keyvals (lambda () ;; gets called in dashboard:update-target-selector as "action-proc"
+			   (dboard:target-updater (dboard:tabdat-key-listboxes tabdat))))
 	 (tests-draw-state (make-hash-table)) ;; use for keeping state of the test canvas
 	 (test-patterns-textbox  #f))
     (hash-table-set! tests-draw-state 'first-time #t)
     ;; (hash-table-set! tests-draw-state 'scalef 1)
     (tests:get-full-data test-names test-records '() all-tests-registry)
@@ -1105,11 +1135,11 @@
        ;;
        (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-testname-selector commondat tabdat update-keyvals)) ;;  key-listboxes))
        
        (dcommon:command-tests-tasks-canvas tabdat test-records sorted-testnames tests-draw-state))
        
  ;;(iup:frame
  ;; #:title "Logs" ;; To be replaced with tabs
@@ -1124,59 +1154,65 @@
 ;;======================================================================
 ;;
 ;; A gui for launching tests
 ;;
 (define (dashboard:run-times commondat tabdat #!key (tab-num #f))
-  (let ((drawing               (vg:drawing-new))
-	(run-times-tab-updater (lambda ()	
-				 (debug:catch-and-dump 
-				  (lambda ()
-				    (let ((tabdat        (dboard:common-get-tabdat commondat tab-num: tab-num)))
-				      (if tabdat
-					  (let ((last-data-update (dboard:tabdat-last-data-update tabdat))
-						(now-time         (current-seconds)))
-					    (dashboard:run-times-tab-canvas-updater commondat tabdat tab-num)
-					    (if (> (- now-time last-data-update) 5)
-						(if (not (dboard:tabdat-running-layout tabdat))
-						    (begin
-						      (dashboard:run-times-tab-run-data-updater commondat tabdat tab-num)
-						      (dboard:tabdat-last-data-update-set! tabdat now-time)
-						      (thread-start! (make-thread
-								      (lambda ()
-									(dboard:tabdat-running-layout-set! tabdat #t)
-									(dashboard:run-times-tab-layout-updater commondat tabdat tab-num)
-									(dboard:tabdat-running-layout-set! tabdat #f))
-								      "run-times-tab-layout-updater")))
-						  ))))))
-				  "dashboard:run-times-tab-updater"))))
+  (let* ((drawing               (vg:drawing-new))
+	 (run-times-tab-updater (lambda ()	
+				  (debug:catch-and-dump 
+				   (lambda ()
+				     (let ((tabdat        (dboard:common-get-tabdat commondat tab-num: tab-num)))
+				       (if tabdat
+					   (let ((last-data-update (dboard:tabdat-last-data-update tabdat))
+						 (now-time         (current-seconds)))
+					     (dashboard:run-times-tab-canvas-updater commondat tabdat tab-num)
+					     (if (> (- now-time last-data-update) 5)
+						 (if (not (dboard:tabdat-running-layout tabdat))
+						     (begin
+						       (dashboard:run-times-tab-run-data-updater commondat tabdat tab-num)
+						       (dboard:tabdat-last-data-update-set! tabdat now-time)
+						       (thread-start! (make-thread
+								       (lambda ()
+									 (dboard:tabdat-running-layout-set! tabdat #t)
+									 (dashboard:run-times-tab-layout-updater commondat tabdat tab-num)
+									 (dboard:tabdat-running-layout-set! tabdat #f))
+								       "run-times-tab-layout-updater")))
+						     ))))))
+				   "dashboard:run-times-tab-updater")))
+	 (key-listboxes #f) ;; 
+	 (update-keyvals (lambda ()
+			   (dboard:target-updater tabdat))))
     (dboard:tabdat-drawing-set! tabdat drawing)
     (dboard:commondat-add-updater commondat run-times-tab-updater tab-num: tab-num)
     (iup:split
      #:orientation "VERTICAL" ;; "HORIZONTAL"
-     #:value 200
-     (let* ((tb      (iup:treebox
-		      #:value 0
-		      #:name "Runs"
-		      #:expand "YES"
-		      #:addexpanded "NO"
-		      #:selection-cb
-		      (lambda (obj id state)
-			(debug:catch-and-dump
-			 (lambda ()
-			   (let* ((run-path (tree:node->path obj id))
-				  (run-id    (tree-path->run-id tabdat (cdr run-path))))
-			     (print "run-path: " run-path)
-			     (if (number? run-id)
-				 (begin
-				   (dboard:tabdat-curr-run-id-set! tabdat run-id)
-				   (dboard:tabdat-view-changed-set! tabdat #t))
-				 (debug:print-error 0 *default-log-port* "tree-path->run-id returned non-number " run-id))))
-			 "treebox"))
-			;; (print "path: " (tree:node->path obj id) " run-id: " run-id)
-		      )))
-       (dboard:tabdat-runs-tree-set! tabdat tb)
-       tb)
+     #:value 150
+     (iup:vbox
+      (let* ((tb      (iup:treebox
+		       #:value 0
+		       #:name "Runs"
+		       #:expand "YES"
+		       #:addexpanded "NO"
+		       #:selection-cb
+		       (lambda (obj id state)
+			 (debug:catch-and-dump
+			  (lambda ()
+			    (let* ((run-path (tree:node->path obj id))
+				   (run-id    (tree-path->run-id tabdat (cdr run-path))))
+			      (dboard:tabdat-target-set! tabdat (cdr run-path)) ;; (print "run-path: " run-path)
+			      (if (number? run-id)
+				  (begin
+				    (dboard:tabdat-curr-run-id-set! tabdat run-id)
+				    (dboard:tabdat-view-changed-set! tabdat #t))
+				  (debug:print-error 0 *default-log-port* "tree-path->run-id returned non-number " run-id))))
+			  "treebox"))
+		       ;; (print "path: " (tree:node->path obj id) " run-id: " run-id)
+		       )))
+	(dboard:tabdat-runs-tree-set! tabdat tb)
+	tb)
+      (dcommon:command-runname-selector commondat tabdat tab-num: tab-num)
+      (dcommon:command-testname-selector commondat tabdat update-keyvals))
      (iup:vbox
       (let* ((cnv-obj (iup:canvas 
 		       ;; #:size "500x400"
 		       #:expand "YES"
 		       #:scrollbar "YES"
@@ -2490,22 +2526,51 @@
 		   (hash-table-set! (dboard:tabdat-path-run-ids tabdat) run-path run-id)
 		   ;; (set! colnum (+ colnum 1))
 		   ))))
 	 run-ids))
     (print "Updating rundat")
-    (update-rundat tabdat
-		   "%" ;; (hash-table-ref/default (dboard:tabdat-searchpatts tabdat) "runname" "%") 
-		   100  ;; (dboard:tabdat-numruns tabdat)
-		   "%" ;; (hash-table-ref/default (dboard:tabdat-searchpatts tabdat) "test-name" "%/%")
-		   ;; (hash-table-ref/default (dboard:tabdat-searchpatts tabdat) "item-name" "%")
-		   (let ((res '()))
-		     (for-each (lambda (key)
-				 (if (not (equal? key "runname"))
-				     (let ((val (hash-table-ref/default (dboard:tabdat-searchpatts tabdat) key #f)))
-				       (if val (set! res (cons (list key val) res))))))
-			       (dboard:tabdat-dbkeys tabdat))
-		     res))))
+    (if (dboard:tabdat-keys tabdat) ;; have keys yet?
+	(let* ((num-keys (length (dboard:tabdat-keys tabdat)))
+	       (targpatt (map (lambda (k v)
+				(list k v))
+			      (dboard:tabdat-keys tabdat)
+			      (take (append (or (dboard:tabdat-target tabdat);; (string-split (dboard: "/")
+						'("%" "%"))
+					    (make-list num-keys "%"))
+				    num-keys)
+			      ))
+	       (runpatt   (if (dboard:tabdat-target tabdat)
+			     (last (dboard:tabdat-target tabdat))
+			     "%")))
+	  (print "targpatt: " targpatt " runpatt: " runpatt)
+
+	  (if (dboard:tabdat-view-changed tabdat)
+	      (let ((dwg (dboard:tabdat-drawing tabdat)))
+		(dboard:tabdat-layout-update-ok-set! tabdat #f)
+		(vg:drawing-libs-set! dwg (make-hash-table))
+		(vg:drawing-insts-set! dwg (make-hash-table))
+		(vg:drawing-cache-set! dwg '())
+		(dboard:tabdat-allruns-by-id-set! tabdat (make-hash-table))
+		(dboard:tabdat-max-row-set! tabdat 0)))
+	  (update-rundat tabdat
+			 runpatt
+			 ;; (hash-table-ref/default (dboard:tabdat-searchpatts tabdat) "runname" "%") 
+			 100  ;; (dboard:tabdat-numruns tabdat)
+			 "%" ;; (hash-table-ref/default (dboard:tabdat-searchpatts tabdat) "test-name" "%/%")
+			 ;; (hash-table-ref/default (dboard:tabdat-searchpatts tabdat) "item-name" "%")
+			 
+			 targpatt
+			 
+			 ;; old method 
+			 ;; (let ((res '()))
+			 ;;   (for-each (lambda (key)
+			 ;;      	 (if (not (equal? key "runname"))
+			 ;;      	     (let ((val (hash-table-ref/default (dboard:tabdat-searchpatts tabdat) key #f)))
+			 ;;      	       (if val (set! res (cons (list key val) res))))))
+			 ;;             (dboard:tabdat-dbkeys tabdat))
+			 ;;   res)
+			 )))))
 
 ;; run times canvas updater
 ;;
 (define (dashboard:run-times-tab-canvas-updater commondat tabdat tab-num)
   (let ((cnv (dboard:tabdat-cnv tabdat))
@@ -2537,10 +2602,11 @@
 	     (runslib      (vg:get/create-lib drawing "runslib")) ;; creates and adds lib
 	     (layout-start (current-milliseconds))
 	     (allruns      (dboard:tabdat-allruns tabdat))
 	     (num-runs     (length allruns))
 	     (cnv          (dboard:tabdat-cnv tabdat)))
+	(dboard:tabdat-layout-update-ok-set! tabdat #t)
 	(if (canvas? cnv)
 	    (let*-values (((sizex sizey sizexmm sizeymm) (canvas-size cnv))
 			  ((originx originy)             (canvas-origin cnv))
 			  ((calc-y)                      (lambda (rownum)
 							   (- (/ sizey 2)
@@ -2570,11 +2636,16 @@
 		       (run-key  (string-intersperse key-vals "\n"))
 		       (run-full-name (string-intersperse key-vals "/"))
 		       (curr-run-start-row  (dboard:tabdat-max-row tabdat)))
 		  ;; (print "run: " run-full-name " curr-run-start-row: " curr-run-start-row)
 		  (if (not (vg:lib-get-component runslib run-full-name))
-		      (let* ((hierdat   (dboard:tests-sort-by-time-group-by-item (dboard:rundat-tests rundat))) ;; hierarchial list of ids
+		      (let* ((hierdat   (if (or (dboard:rundat-data-changed rundat) ;; attempt to not sort when possible.
+						(not (dboard:rundat-hierdat rundat)))
+					    (let ((hd (dboard:tests-sort-by-time-group-by-item (dboard:rundat-tests rundat)))) ;; hierarchial list of ids
+					      (dboard:rundat-hierdat-set! rundat hd)
+					      hd)
+					    (dboard:run-hierdat rundat)))
 			     (tests-ht  (dboard:rundat-tests rundat))
 			     (all-tids  (hash-table-keys   tests-ht)) ;; (apply append hierdat)) ;; was testsdat
 			     (testsdat  (hash-table-values tests-ht))
 			     (runcomp   (vg:comp-new));; new component for this run
 			     (rows-used (make-hash-table)) ;; keep track of what parts of the rows are used here row1 = (obj1 obj2 ...)
@@ -2669,16 +2740,18 @@
 											  text:  (db:test-get-testname (hash-table-ref tests-ht (car test-ids)))
 											  line-color:  (vg:rgb->number  0 0 255 a: 128)
 											  font: "Helvetica -10"))
 					    ;; (vg:instance-move drawing run-full-name 0 (dboard:tabdat-max-row tabdat))
 					    (dboard:tabdat-view-changed-set! tabdat #t))) ;; trigger a redraw
-				      (testitemloop (car tidstal)(cdr tidstal)(+ item-num 1) new-test-objs)))))
+				      (if (dboard:tabdat-layout-update-ok tabdat)
+					  (testitemloop (car tidstal)(cdr tidstal)(+ item-num 1) new-test-objs))))))
 			    ;; If it is an iterated test put box around it now.
 			    (if (not (null? tests-tal))
 				(if #f ;; (> (- (current-seconds) update-start-time) 5)
 				    (print "drawing runs taking too long")
-				    (testsloop  (car tests-tal)(cdr tests-tal)(+ test-num 1))))))
+				    (if (dboard:tabdat-layout-update-ok tabdat)
+					(testsloop  (car tests-tal)(cdr tests-tal)(+ test-num 1)))))))
 			;; placeholder box
 			(dboard:tabdat-max-row-set! tabdat (+ (dboard:tabdat-max-row tabdat) 1))
 			;; (let ((y  (calc-y (dboard:tabdat-max-row tabdat)))) ;;  (- sizey (* (dboard:tabdat-max-row tabdat) row-height))))
 			;;   (vg:add-obj-to-comp runcomp (vg:make-rect-obj 0 y 0 y)))
 			;; instantiate the component
@@ -2701,20 +2774,22 @@
 			  ))
 		      ;; end of the run handling loop 
 		      (let ((newdoneruns (cons rundat doneruns)))
 			(if (null? runtal)
 			    (begin
+			      (dboard:rundat-data-changed-set! rundat #f) 
 			      (dboard:tabdat-not-done-runs-set! tabdat '())
 			      (dboard:tabdat-done-runs-set! tabdat allruns))
 			    (if #f ;; (> (- (current-seconds) update-start-time) 5)
 				(begin
 				  (print "drawing runs taking too long....  have " (length runtal) " remaining")
 				  ;; (dboard:tabdat-done-runs-set! tabdat newdoneruns) ;; taking too long? stop here!
 				  ;; (time (vg:draw (dboard:tabdat-drawing tabdat) #t))
 				  (dboard:tabdat-not-done-runs-set! tabdat runtal))
 				(begin
-				  (runloop (car runtal)(cdr runtal) (+ run-num 1) newdoneruns)))))))) ;;  new-run-start-row
+				  (if (dboard:tabdat-layout-update-ok tabdat)
+				      (runloop (car runtal)(cdr runtal) (+ run-num 1) newdoneruns))))))))) ;;  new-run-start-row
 	      )
 	    (print "Layout end: " (current-milliseconds) " delta: " (- (current-milliseconds) layout-start))))
       (debug:print 2 *default-log-port* "no tabdat for run-times-tab-updater")))
 
 (define (dashboard:runs-tab-updater commondat tab-num)

Index: dcommon.scm
==================================================================
--- dcommon.scm
+++ dcommon.scm
@@ -919,22 +919,28 @@
   (iup:frame
    #:title "Runname"
    (let* ((default-run-name (seconds->work-week/day (current-seconds)))
 	  (tb (iup:textbox #:expand "HORIZONTAL"
 			   #:action (lambda (obj val txt)
-				      ;; (print "obj: " obj " val: " val " unk: " unk)
-				      (dboard:tabdat-run-name-set! tabdat txt) ;; (iup:attribute obj "VALUE"))
-				      (dashboard:update-run-command tabdat))
+				      (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)
-				      (if (not (equal? val ""))
-					  (begin
-					    (iup:attribute-set! tb "VALUE" val)
-					    (dboard:tabdat-run-name-set! tabdat val)
-					    (dashboard:update-run-command tabdat))))))
+				      (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))
@@ -951,56 +957,56 @@
      (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:frame
-   #:title "SELECTORS"
-   (iup:vbox
-    ;; Text box for test patterns
-    (iup:frame
-     #:title "Test patterns (one per line)"
-     (let ((tb (iup:textbox #:action (lambda (val a b)
-				       (dboard:tabdat-test-patts-set!-use
-					tabdat
-					(dboard:lines->test-patt b))
-				       (dashboard:update-run-command tabdat))
-			    #:value (dboard:test-patt->lines
-				     (dboard:tabdat-test-patts-use tabdat))
-			    #:expand "YES"
-			    #:size "x50"
-			    #:multiline "YES")))
-       (set! test-patterns-textbox tb)
-       tb))
-    (iup:frame
-     #:title "Target"
-     ;; Target selectors
-     (apply iup:hbox
-	    (let* ((dat      (dashboard:update-target-selector key-listboxes action-proc: update-keyvals))
-		   (key-lb   (car dat))
-		   (combos   (cadr dat)))
-	      (set! key-listboxes key-lb)
-	      combos)))
-    (iup:hbox
-     ;; Text box for STATES
-     (iup:frame
-      #:title "States"
-      (dashboard:text-list-toggle-box 
-       ;; Move these definitions to common and find the other useages and replace!
-       (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-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 "x30"
+			   #: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)