source: trunk/excledt.tcl @ 473

#!/usr/local/bin/wish
# $Id: excledt.tcl 473 2009-12-04 23:06:45Z toby $
set Revision {$Revision: 473 $ $Date: 2009-12-04 23:06:45 +0000 (Fri, 04 Dec 2009) $}

# process command line arguments
set exitstat 0
set expnam [lindex $argv 0]
if {$expnam == ""} {puts "error -- no experiment name"; set exitstat 1}
if $exitstat {
    puts "usage: $argv0 expnam \[hist #\] \[legend\]"
    destroy .
}

if {[lindex $argv 1] == ""} {
    set hst 1
} else {
    set hst [lindex $argv 1]
    if {[llength $hst] > 1} {set hst [lindex $hst 0]}
}
if {[lindex $argv 2] == ""} {
    set graph(legend) 1
} else {
    set graph(legend) [lindex $argv 2]
}

# default values
set graph(exclPrompt) 1
set expgui(font) 14
set changes 0
set graph(outname) out.ps
set graph(outcmd) lpr
set graph(color_excl) orange
set graph(color_calc) red
set graph(color_obs) black
set xunits {}
set yunits {}
set graph(xunits) 0
set graph(yunits) 0
set graph(autoraise) 1
set graph(FillExclRegionBox) 1
set expgui(debug) 0
catch {if $env(DEBUG) {set expgui(debug) 1}}
#set expgui(debug) 1
set expgui(autotick) 0
# location for web pages, if not found locally
set expgui(website) www.ncnr.nist.gov/xtal/software/expgui
set peakinfo(obssym) scross
set peakinfo(obssize) 1.0
set peakinfo(exclsym) scross
set peakinfo(exclsize) 1.2
# create a set of markers for each phase
for {set i 1} {$i < 10} {incr i} {
    set peakinfo(flag$i) 0
    set peakinfo(max$i) Inf
    set peakinfo(min$i) -Inf
    set peakinfo(dashes$i) 1
}

if [catch {package require BLT} errmsg] {
    tk_dialog .err "BLT Error" "Error -- Unable to load the BLT package" \
            error 0 Quit
    destroy .
}
# handle Tcl/Tk v8+ where BLT is in a namespace
#  use the command so that it is loaded
catch {blt::graph}
catch {
    namespace import blt::graph
    namespace import blt::vector
}
# old versions of blt don't report a version number
if [catch {set blt_version}] {set blt_version 0}
# option for coloring markers: note that GH keeps changing how to do this!
# also element -mapped => -show
if {$blt_version < 2.3 || $blt_version >= 8.0} {
    # version 8.0 is ~same as 2.3
    set graph(MarkerColorOpt) -fg 
    # mapped is needed in 8.0, both are OK in 2.3
    set graph(ElementShowOption) "-mapped 1"
    set graph(ElementHideOption) "-mapped 0"
} elseif {$blt_version >= 2.4} {
    set graph(MarkerColorOpt) -outline
    set graph(ElementShowOption) "-hide 0"
    set graph(ElementHideOption) "-hide 1"
} else {
    set graph(MarkerColorOpt) -color
    set graph(ElementShowOption) "-mapped 1"
    set graph(ElementHideOption) "-mapped 0"
}

#--------------------------------------------------------------
# define constants
array set peakinfo {
    color1 magenta 
    color2 cyan 
    color3 yellow 
    color4 sienna 
    color5 orange 
    color6 DarkViolet 
    color7 HotPink 
    color8 salmon 
    color9 LimeGreen
}
set cycle -1

#----------------------------------------------------------------
# where are we?
set expgui(script) [info script]
# translate links -- go six levels deep
foreach i {1 2 3 4 5 6} {
    if {[file type $expgui(script)] == "link"} {
        set link [file readlink $expgui(script)]
        if { [file  pathtype  $link] == "absolute" } {
            set expgui(script) $link
        } {
            set expgui(script) [file dirname $expgui(script)]/$link
        }
    } else {
        break
    }
}

# fixup relative paths
if {[file pathtype $expgui(script)] == "relative"} {
    set expgui(script) [file join [pwd] $expgui(script)]
}
set expgui(scriptdir) [file dirname $expgui(script) ]
set expgui(gsasdir) [file dirname $expgui(scriptdir)]
set expgui(gsasexe) [file join $expgui(gsasdir) exe]
set expgui(docdir) [file join $expgui(scriptdir) doc]

proc readdata {box} { 
    global expgui expnam
    if [catch {
        set loadtime [time {
            readdata_hst $box
        }]
        if $expgui(debug) {
            tk_dialog .time "Timing info" \
                    "Histogram loading took $loadtime" "" 0 OK
        }
    } errmsg] {
        if $expgui(debug) {
            catch {console show}
            error $errmsg
        }
        $box config -title "Read error"
        tk_dialog .err "Read Error" "Read Error -- $errmsg" \
                error 0 OK
        update
    }
    $box element show [lsort -decreasing [$box element show]]
}
   
proc readdata_hst {box} {
    global expgui expnam reflns graph
#    global lasthst
    global hst peakinfo xunits
#    $box config -title "(Histogram update in progress)"
    update
    # parse the output of a file
#    set lasthst $hst
    # use histdmp for histogram info
    set input [open histdump$hst.inp w]
    puts $input "$expnam"
    puts $input "L"
    puts $input "$hst"
    puts $input "0"
    close $input
    # use hstdmp without an experiment name so that output 
    # is not sent to the .LST file
    exec $expgui(gsasexe)/hstdmp < histdump$hst.inp > histdump$hst.out
    set input [open histdump$hst.out r]
    catch {file delete histdump$hst.inp}

    # initalize arrays
    set num -1
    set xlist {}
    set obslist {}
    set calclist {}
    set allxlist {}
    set xunits {}
    set exclistx {}
    set exclistobs {}
    # define a list of reflection positions for each phase
    for {set i 1} {$i < 10} {incr i} {
        set reflns($i) {}
    }
    set i 0
    while {[gets $input line] >= 0} {
        incr i
        # run update every 200th line
        if {$i > 200} {set i 0; update}
        if [scan $line %d num] {
            if {$num > 0} {
                set Ispec 0
                set X -999
                scan [string range $line 8 end] %e%e%e%e \
                        X Iobs Icalc Ispec
                #puts $line
                lappend allxlist $X
                # eliminate excluded points
                if {$Ispec > 0.0 && $X >= 0} {
                    lappend xlist $X
                    lappend obslist $Iobs
                    lappend calclist $Icalc
                } elseif {$X != -999} {
                    lappend exclistx $X
                    lappend exclistobs $Iobs
                }
                if [regexp {[1-9]} [string range $line 6 7] ph] {
                    lappend reflns($ph) $X
                }
            } 
        } else {
            regexp {Time|Theta|keV} $line xunits
        }
    }
    close $input
    if {$xunits == "Theta"} {set xunits "2-Theta"}
    # convert the x units, if requested
    if {$graph(xunits) == 1} {
        set xlist [tod $xlist $hst]
        set exclistx [tod $exclistx $hst]
        set xunits d-space
    } elseif {$graph(xunits) == 2} {
        set xlist [toQ $xlist $hst]
        set exclistx [toQ $exclistx $hst]
        set xunits Q
    }
    catch {file delete histdump$hst.out}
    if {[llength $allxlist] > 0} {
        allxvec set $allxlist
        xvec set $xlist
        obsvec set $obslist
        calcvec set $calclist
        diffvec set [obsvec - calcvec]
        exxvec set $exclistx
        exobsvec set $exclistobs 
        global obsvec calcvec diffvec 
        set maxdiff  [set diffvec(max)]
        set cmin [set calcvec(min)]
        set omin [set obsvec(min)]
        set cmax [set calcvec(max)]
        set omax [set obsvec(max)]
        set expgui(min) [expr $omin < $cmin ? $omin : $cmin]
        set expgui(max) [expr $omax > $cmax ? $omax : $cmax]
        set ymin1 [expr $cmin - 1.1*$maxdiff]
        set ymin2 [expr $omin - 1.1*$maxdiff]
        if {$ymin1 < $ymin2} {
            diffvec set [diffvec + $ymin1]
        } {
            diffvec set [diffvec + $ymin2]
        }
    }
    plotdata
}

# convert x values to d-space
proc tod {xlist hst} {
    global expmap
    if {[string range $expmap(htype_$hst) 2 2] == "T"} {
        return [toftod $xlist $hst]
    } elseif {[string range $expmap(htype_$hst) 2 2] == "C"} {
        return [tttod $xlist $hst]
    } elseif {[string range $expmap(htype_$hst) 2 2] == "E"} {
        return [engtod $xlist $hst]
    } else {
        return {}
    }
}

# convert tof to d-space
proc toftod {toflist hst} {
    set difc [expr {[histinfo $hst difc]/1000.}]
    set difc2 [expr {$difc*$difc}]
    set difa [expr {[histinfo $hst difa]/1000.}]
    set zero [expr {[histinfo $hst zero]/1000.}]
    set ans {}
    foreach tof $toflist {
        if {$tof == 0.} {
            lappend ans 0.
        } elseif {$tof == 1000.} {
            lappend ans 1000.
        } else {
            set td [expr {$tof-$zero}]
            lappend ans [expr {$td*($difc2+$difa*$td)/ \
                    ($difc2*$difc+2.0*$difa*$td)}]
        }
    }
    return $ans
}

# convert two-theta to d-space
proc tttod {twotheta hst} {
    set lamo2 [expr {0.5 * [histinfo $hst lam1]}]
    set zero [expr [histinfo $hst zero]/100.]
    set ans {}
    set cnv [expr {acos(0.)/180.}]
    foreach tt $twotheta {
        if {$tt == 0.} {
            lappend ans 99999.
        } elseif {$tt == 1000.} {
            lappend ans 0.
        } else {
            lappend ans [expr {$lamo2 / sin($cnv*($tt-$zero))}]
        }
    }
    return $ans
}
# convert energy (edx-ray) to d-space 
# (note that this ignores the zero correction)
proc engtod {eng hst} {
    set lam [histinfo $hst lam1]
    set zero [histinfo $hst zero]
    set ans {}
    set v [expr {12.398/(2.0*[sind[expr ($lam/2.0)]])}]
    foreach e $eng {
        if {$e == 0.} {
            lappend ans 1000.
        } elseif {$e == 1000.} {
            lappend ans 0.
        } else {
            lappend ans [expr {$v/$e}]
        }
    }
    return $ans
}

# convert x values to Q
proc toQ {xlist hst} {
    global expmap
    if {[string range $expmap(htype_$hst) 2 2] == "T"} {
        return [toftoQ $xlist $hst]
    } elseif {[string range $expmap(htype_$hst) 2 2] == "C"} {
        return [tttoQ $xlist $hst]
    } elseif {[string range $expmap(htype_$hst) 2 2] == "E"} {
        return [engtoQ $xlist $hst]
    } else {
        return {}
    }
}
# convert tof to Q
proc toftoQ {toflist hst} {
    set difc [expr {[histinfo $hst difc]/1000.}]
    set difc2 [expr {$difc*$difc}]
    set difa [expr {[histinfo $hst difa]/1000.}]
    set zero [expr {[histinfo $hst zero]/1000.}]
    set 2pi [expr {4.*acos(0.)}]
    set ans {}
    foreach tof $toflist {
        if {$tof == 0.} {
            lappend ans 99999.
        } elseif {$tof == 1000.} {
            lappend ans 0.
        } else {
            set td [expr {$tof-$zero}]
            lappend ans [expr {$2pi * \
                    ($difc2*$difc+2.0*$difa*$td)/($td*($difc2+$difa*$td))}]
        }
    }
    return $ans
}

# convert two-theta to Q
proc tttoQ {twotheta hst} {
    set lamo2 [expr {0.5 * [histinfo $hst lam1]}]
    set zero [expr [histinfo $hst zero]/100.]
    set ans {}
    set cnv [expr {acos(0.)/180.}]
    set 2pi [expr {4.*acos(0.)}]
    foreach tt $twotheta {
        if {$tt == 0.} {
            lappend ans 0.
        } elseif {$tt == 1000.} {
            lappend ans 1000.
        } else {
            lappend ans [expr {$2pi * sin($cnv*($tt-$zero)) / $lamo2}]
        }
    }
    return $ans
}
# convert energy (edx-ray) to Q 
# (note that this ignores the zero correction)
proc engtoQ {eng hst} {
    set lam [histinfo $hst lam1]
    set zero [histinfo $hst zero]
    set ans {}
    set v [expr {12.398/(2.0*[sind[expr ($lam/2.0)]])}]
    set 2pi [expr {4.*acos(0.)}]
    foreach e $eng {
        if {$e == 0.} {
            lappend ans 0.
        } elseif {$e == 1000.} {
            lappend ans 1000.
        } else {
            lappend ans [expr {$2pi * $e / $v}]
        }
    }
    return $ans
}
proc sind {angle} {
    return [expr {sin($angle*acos(0.)/90.)}]
}

# convert d-space values to 2theta, TOF or KeV
proc fromd {dlist hst} {
    global expmap
    if {[string range $expmap(htype_$hst) 2 2] == "T"} {
        set difc [expr {[histinfo $hst difc]/1000.}]
        set difa [expr {[histinfo $hst difa]/1000.}]
        set zero [expr {[histinfo $hst zero]/1000.}]
        set ans {}
        foreach d $dlist {
            if {$d == 0.} {
                lappend ans 0.
            } elseif {$d == 1000.} {
                lappend ans 1000.
            } else {
                lappend ans [expr {$difc*$d + $difa*$d*$d + $zero}]
            }
        }
        return $ans
    } elseif {[string range $expmap(htype_$hst) 2 2] == "C"} {
        set lamo2 [expr {0.5 * [histinfo $hst lam1]}]
        set zero [expr [histinfo $hst zero]/100.]
        set ans {}
        set cnv [expr {180./acos(0.)}]
        foreach d $dlist {
            if {$d == 99999.} {
                lappend ans 0
            } elseif {$d == 0.} {
                lappend ans 1000.
            } else {
                lappend ans [expr {$cnv*asin($lamo2/$d) + $zero}]
            }
        }
        return $ans
    } elseif {[string range $expmap(htype_$hst) 2 2] == "E"} {
        set lam [histinfo $hst lam1]
        set zero [histinfo $hst zero]
        set v [expr {12.398/(2.0*[sind[expr ($lam/2.0)]])}]
        set ans {}
        foreach d $dlist {
            if {$d == 1000.} {
                lappend ans 0
            } elseif {$d == 0.} {
                lappend ans 1000.
            } else {
                lappend ans [expr {$v/$d}]
            }
        }
        return $ans
    } else {
        return {}
    }
}

# convert Q values to 2theta, TOF or KeV
proc fromQ {Qlist hst} {
    global expmap
    if {[string range $expmap(htype_$hst) 2 2] == "T"} {
        set difc [expr {[histinfo $hst difc]/1000.}]
        set difa [expr {[histinfo $hst difa]/1000.}]
        set zero [expr {[histinfo $hst zero]/1000.}]
        set ans {}
        foreach Q $Qlist {
            if {$Q == 0.} {
                lappend ans 1000.
            } elseif {$Q == 99999.} {
                lappend ans 1000.
            } else {
                set d [expr {4.*acos(0.)/$Q}]
                lappend ans [expr {$difc*$d + $difa*$d*$d + $zero}]
            }
        }
        return $ans
    } elseif {[string range $expmap(htype_$hst) 2 2] == "C"} {
        set lamo4pi [expr {[histinfo $hst lam1]/(8.*acos(0.))}]
        set zero [expr [histinfo $hst zero]/100.]
        set ans {}
        set cnv [expr {180./acos(0.)}]
        foreach Q $Qlist {
            if {$Q == 0.} {
                lappend ans 0
            } elseif {$Q == 1000.} {
                lappend ans 1000.
            } else {
                lappend ans [expr {$cnv*asin($Q*$lamo4pi) + $zero}]
            }
        }
        return $ans
    } elseif {[string range $expmap(htype_$hst) 2 2] == "E"} {
        set lam [histinfo $hst lam1]
        set zero [histinfo $hst zero]
        set v [expr {12.398/(2.0*[sind[expr ($lam/2.0)]])}]
        set ans {}
        set 2pi [expr {4.*acos(0.)}]
        foreach Q $Qlist {
            if {$Q == 1000.} {
                lappend ans 0
            } elseif {$Q == 0.} {
                lappend ans 1000.
            } else {
                lappend ans [expr {$Q * $v/$2pi}]
            }
        }
        return $ans
    } else {
        return {}
    }
}

proc plotdata {args} {
    global box
    global expnam hst peakinfo xunits yunits cycle reflns
    global graph expgui

    $box config -title "$expnam cycle $cycle Hist $hst"
    $box xaxis config -title $xunits
    $box yaxis config -title $yunits
    setlegend $box $graph(legend)
    # reconfigure the data display
    $box element configure 3 \
            -symbol $peakinfo(obssym) -color $graph(color_obs) \
            -pixels [expr 0.125 * $peakinfo(obssize)]i
    $box element config 2 -color $graph(color_calc)
    $box element config 12 \
            -symbol $peakinfo(exclsym) -color $graph(color_excl) \
            -pixels [expr 0.125 * $peakinfo(exclsize)]i

    foreach vec {xvec obsvec calcvec diffvec exxvec exobsvec} {
        $vec notify now
    }
    # now deal with tick marks
    for {set i 1} {$i < 10} {incr i} {
        if {$expgui(autotick)} {
            set div [expr ( $expgui(max) - $expgui(min) )/40.]
            set ymin [expr $expgui(min) - ($i+1) * $div]
            set ymax [expr $expgui(min) - $i * $div]
        } else {
            set ymin $peakinfo(min$i)
            set ymax $peakinfo(max$i)
        }
        set j 0
        if [set peakinfo(flag$i)] {
            if {$graph(xunits) == 1} {
                set Xlist [tod $reflns($i) $hst]
            } elseif {$graph(xunits) == 2} {
                set Xlist [toQ $reflns($i) $hst]
            } else {
                set Xlist $reflns($i)
            }
            foreach X $Xlist {
                incr j
                catch {
                    $box marker create line -name peaks${i}_$j 
                }
                $box marker config peaks${i}_$j  -under 1 \
                        -coords "$X $ymin $X $ymax" 
                catch {
                    $box marker config peaks${i}_$j \
                            $graph(MarkerColorOpt) [list $peakinfo(color$i)]
                    if $peakinfo(dashes$i) {
                        $box marker config peaks${i}_$j -dashes "5 5"
                    }
                }
            }
            catch {$box element create phase$i}
            catch {
                $box element config phase$i -color $peakinfo(color$i) 
            }
        } else {
            eval $box marker delete [$box marker names peaks${i}_*]
            eval $box element delete [$box element names phase$i]
        }
    }
    # force an update of the plot as BLT may not
    $box config -title [$box cget -title]
    update
}

proc setlegend {box legend} {
    global blt_version
    if {$blt_version >= 2.3 && $blt_version < 8.0} {
        if $legend {
            $box legend config -hide no
        } else {
            $box legend config -hide yes
        }
    } else {
        if $legend {
            $box legend config -mapped yes
        } else {
            $box legend config -mapped no
        }
    }
}

proc minioptionsbox {num} {
    global blt_version tcl_platform peakinfo expgui
    set bx .opt$num
    catch {destroy $bx}
    toplevel $bx
    wm iconname $bx "Phase $num options"
    wm title $bx "Phase $num options"

    set i $num
    pack [label $bx.0 -text "Phase $i reflns" ] -side top
    pack [checkbutton $bx.1 -text "Show reflections" \
            -variable peakinfo(flag$i)] -side top
    # remove option that does not work
    if {$blt_version != 8.0 || $tcl_platform(platform) != "windows"} {
        pack [checkbutton $bx.2 -text "Use dashed line" \
                -variable peakinfo(dashes$i)] -side top 
    }
    if !$expgui(autotick) {
        pack [frame $bx.p$i -bd 2 -relief groove] -side top
        #       pack [checkbutton $bx.p$i.0 -text "Show phase $i reflns" \
                #               -variable peakinfo(flag$i)] -side left -anchor w
        pack [label $bx.p$i.1 -text "  Y min:"] -side left
        pack [entry $bx.p$i.2 -textvariable peakinfo(min$i) -width 5] \
                -side left
        pack [label $bx.p$i.3 -text "  Y max:"] -side left
        pack [entry $bx.p$i.4 -textvariable peakinfo(max$i) -width 5] \
                -side left
    }
    pack [frame $bx.c$i -bd 2 -relief groove] -side top
    
    pack [label $bx.c$i.5 -text " color:"] -side left
    pack [entry $bx.c$i.6 -textvariable peakinfo(color$i) -width 12] \
            -side left
    pack [button $bx.c$i.2 -bg $peakinfo(color$i) -state disabled] -side left
    pack [button $bx.c$i.1 -text "Color\nmenu" \
            -command "setcolor $i"] -side left
    pack [frame $bx.b] -side top
    pack [button $bx.b.4 -command "destroy $bx" -text Close ] -side right
}

proc setcolor {num} {
    global peakinfo
    set color [tk_chooseColor -initialcolor $peakinfo(color$num) -title "Choose color"]
    if {$color == ""} return
    set peakinfo(color$num) $color
}

proc makepostscriptout {} {
    global graph box
    if !$graph(printout) {
        set out [open "| $graph(outcmd) >& plot.msg" w]
        catch {
            puts $out [$box postscript output -landscape 1 \
                -decorations no -height 7.i -width 9.5i]
            close $out
        } msg
        catch {
            set out [open plot.msg r]
            if {$msg != ""} {append msg "\n"}
            append msg [read $out]
            close $out
            catch {file delete plot.msg}
        }
        if {$msg != ""} {
            tk_dialog .msg "file created" \
                    "Postscript file processed with command \
                    $graph(outcmd). Result: $msg" "" 0 OK
        } else {
            tk_dialog .msg "file created" \
                    "Postscript file processed with command \
                    $graph(outcmd)" "" 0 OK
        }
    } else {
        $box postscript output $graph(outname) -landscape 1 \
                -decorations no -height 7.i -width 9.5i    
        tk_dialog .msg "file created" \
                "Postscript file $graph(outname) created" "" 0 OK
    }
}

proc setprintopt {page} {
    global graph
    if $graph(printout) { 
        $page.4.1 config -fg black
        $page.4.2 config -fg black -state normal
        $page.6.1 config -fg #888 
        $page.6.2 config -fg #888 -state disabled
    } else {
        $page.4.1 config -fg #888 
        $page.4.2 config -fg #888 -state disabled
        $page.6.1 config -fg black
        $page.6.2 config -fg black -state normal
    }
}

proc setpostscriptout {} {
    global graph tcl_platform
    set box .out
    catch {destroy $box}
    toplevel $box
    focus $box
    pack [frame $box.4] -side top -anchor w -fill x
    pack [checkbutton $box.4.a -text "Write PostScript files" \
            -variable graph(printout) -offvalue 0 -onvalue 1 \
            -command "setprintopt $box"] -side left -anchor w
    pack [entry $box.4.2 -textvariable graph(outname)] -side right -anchor w
    pack [label $box.4.1 -text "PostScript file name:"] -side right -anchor w
    pack [frame $box.6] -side top -anchor w -fill x
    pack [checkbutton $box.6.a -text "Print PostScript files" \
            -variable graph(printout) -offvalue 1 -onvalue 0 \
            -command "setprintopt $box" ] -side left -anchor w
    pack [entry $box.6.2 -textvariable graph(outcmd)] -side right -anchor w
    pack [label $box.6.1 -text "Command to print files:"] -side right -anchor w

    pack [button $box.a -text "Close" -command "destroy $box"] -side top
    if {$tcl_platform(platform) == "windows"} {
        set graph(printout) 1
        $box.4.a config -state disabled
        $box.6.a config -fg #888 -state disabled
    }
    setprintopt $box
}

proc getsymopts {"sym obs"} {
    global expgui peakinfo
    set box .out
    catch {destroy $box}
    toplevel $box
    focus $box
    wm title .out "set $sym symbol"
    pack [frame $box.d] -side left -anchor n
    pack [label $box.d.t -text "Symbol type"] -side top
    set expgui(sym) $peakinfo(${sym}sym) 
    set expgui(size) $peakinfo(${sym}size) 
    foreach symbol {square circle diamond plus cross \
            splus scross} \
            symbol_name {square circle diamond plus cross \
            thin-plus thin-cross} {
        pack [radiobutton $box.d.$symbol \
                -text $symbol_name -variable expgui(sym) \
                -value $symbol] -side top -anchor w
    }
    pack [frame $box.e] -side left -anchor n -fill y
    pack [label $box.e.l -text "Symbol Size"] -side top
    pack [scale $box.e.s -variable expgui(size) \
            -from .1 -to 3 -resolution 0.05] -side top
    pack [frame $box.a] -side bottom
    pack [button $box.a.1 -text "Apply" -command "setsymopts $sym"] -side left
    pack [button $box.a.2 -text "Close" -command "destroy $box"] -side left
}
proc setsymopts {sym} {
    global peakinfo expgui
    if {$peakinfo(${sym}sym) != $expgui(sym)} {set peakinfo(${sym}sym) $expgui(sym)}
    if {$peakinfo(${sym}size) != $expgui(size)} {set peakinfo(${sym}size) $expgui(size)}
}

# save some of the global options in ~/.gsas_config
proc SaveOptions {} {
    global graph expgui peakinfo
    set fp [open [file join ~ .gsas_config] a]
    foreach v {printout legend outname outcmd autoraise color_excl \
            color_obs color_calc} {
        puts $fp "set graph($v) $graph($v)"
    }
    foreach v {obssym obssize exclsym exclsize} {
        puts $fp "set peakinfo($v) $peakinfo($v)"
    }
    puts $fp "set expgui(font) $expgui(font)"
    puts $fp "set expgui(autotick) $expgui(autotick)"
    close $fp
}

proc about {} {
    global Revision
    tk_dialog .warn About "
GSAS\n\
A. C. Larson and\n R. B. Von Dreele,\n LANSCE, Los Alamos\n\n\
EXCLEDT\nB. Toby, NIST\nNot subject to copyright\n\n\
$Revision\n\
" {} 0 OK
}

proc getcycle {} {
    global expnam
    set cycle -1
    catch {
        set fp [open $expnam.EXP r]
        set text [read $fp]
        close $fp
        regexp {GNLS  RUN.*Total cycles run *([0-9]*) } $text x cycle
    }
    return $cycle
}

proc updateplot {} {
    global cycle expnam env tcl_platform graph hst box
    $box config -title "Please wait: loading histogram $hst"
    exxvec set {}
    exobsvec  set {}
    exxvec notify now
    exobsvec notify now
    eval .g marker delete [.g marker names]

    # are we in windows and are "locked?" If not, OK to update
    if {$tcl_platform(platform) == "windows" && [file exists expgui.lck]} {
        .g config -title "(Experiment directory locked)"
        # check again in a second
        after 1000 updateplot
    } else { 
        set cycle [getcycle]
        readdata .g
        if {$tcl_platform(platform) == "windows" && $graph(autoraise)} {
            # raise does not seem to be global in Windows, 
            # but this works in Win-95
            # nothing seems to work in Win-NT
            wm withdraw .
            wm deiconify .
        } elseif {$graph(autoraise)} {
            raise .
        }
    }
    ShowExlMarks
    $box element config 3 -color $graph(color_obs)
    $box element config 2 -color $graph(color_calc)
    $box element config 12 -color $graph(color_excl)
    foreach vec {xvec obsvec calcvec diffvec exxvec exobsvec} {
        $vec notify now
    }
    FillExclRegionBox
    global cycle expnam
    $box config -title "$expnam cycle $cycle Hist $hst"
}

proc ShowExlMarks {} {
    global hst graph
    eval .g marker delete [.g marker names excl*]
    set exclist [histinfo $hst excl]
    set i 0
    foreach rng $exclist {
        if {$graph(xunits) == 1} {
            set rng [tod $rng $hst]
        } elseif {$graph(xunits) == 2} {
            set rng [toQ $rng $hst]
        }
        set x1 [lindex [lsort -real $rng] 0]
        set x2 [lindex [lsort -real $rng] end]
        .g marker create line -under 1 -name excl[incr i] \
                -coords "$x1 -Inf $x2 -Inf" \
                -outline $graph(color_excl) -linewidth 3
        # copy any points that should be excluded
        set l [lsort -integer [xvec search $x1 $x2]]
        if {$l != ""} {
            set n1 [lindex $l 0]
            set n2 [lindex $l end]
            exxvec append [xvec range $n1 $n2]
            exobsvec append [obsvec range $n1 $n2]
        }
    }
}

# change the binding of the mouse, based on the selected mode
proc exclEditMode {b bb} {
    global zoom box
    # get binding
    set bindtag $box
    catch {
        if {[bind bltZoomGraph] != ""} {
            set bindtag bltZoomGraph
        }
    }
    # save the zoom and unzoom commands
    if [catch {set zoom(in)}] {
        set zoom(in) [bind $bindtag <1>]
        set zoom(out) [bind $bindtag <3>]
    }
    foreach c {1 2 3} {
        if {$c == $b} {
            $bb.l.b$c config -relief sunken
        } else {
            $bb.l.b$c config -relief raised
        }
    }

    # reset previous mode; if in the middle
    if {[string trim [bind $box <Motion>]] != ""} {
        if {[lindex [bind $box <Motion>] 0] == "exclMove"} {
            exclReset $bindtag
        } else {
            blt::ResetZoom $box
        }
    }
    if {$b == 2} {
        bind $bindtag <1> "exclAdd $bindtag %x %y"
        .g config -cursor arrow
    } elseif {$b == 3} {
        bind $bindtag <1> "exclDel $bindtag %x %y"
        .g config -cursor circle
    } else {
        bind $bindtag <1> $zoom(in)
        bind $bindtag <3> $zoom(out)
        .g config -cursor crosshair
    }
}

proc exclDel {bindtag x y} {
    global graph box changes hst
    set x1 [$box xaxis invtransform $x]
    if {$graph(xunits) == 1} {
        set x1 [fromd $x1 $hst]
    } elseif {$graph(xunits) == 2} {
        set x1 [fromQ $x1 $hst]
    }
    set exclist [histinfo $hst excl]
    # don't delete the high or low ranges
    if {$x1 <= [lindex [lindex $exclist 0] 1] || \
            $x1 >= [lindex [lindex $exclist end] 0]} {
        bell
        return
    }
    set newlist {}
    set msg ""
    foreach rng $exclist {
        if {$x1 < [lindex $rng 0] || $x1 > [lindex $rng 1]} {
            lappend newlist $rng
        } else {
            if {$graph(xunits) == 1} {
                set drng [tod $rng $hst]
                set msg "Delete excluded region from "
                append msg "[format %.5f [lindex $drng 1]] A "
                append msg "to [format %.5f [lindex $drng 0]] A?"
            } elseif {$graph(xunits) == 2} {
                set qrng [toQ $rng $hst]
                set msg "Delete excluded region from "
                append msg "[format %.5f [lindex $qrng 0]] A-1 "
                append msg "to [format %.5f [lindex $qrng 1]] A-1?"
            } else {
                set msg "Delete excluded region from [lindex $rng 0] to [lindex $rng 1]?"
            }
            global graph
            if {$graph(exclPrompt)} {
                set ans [MyMessageBox -parent . -message $msg \
                        -helplink "expguierr.html ExcludeRegion" \
                        -title "Delete region" -type okcancel]
            } else {
                set ans ok
            }
            if {$ans == "ok"} {
                incr changes
            } else {
                lappend newlist $rng
            }
        }
    }
    if {[llength $newlist] == [llength $exclist]} {
        if {$msg == ""} bell
    } else {
        histinfo $hst excl set $newlist
        updateplot
    }
}

proc exclAdd {bindtag x y} {
    global graph box 
    bind $box <Motion> "exclMove $bindtag %x %y"
    bind $bindtag <1> "exclDone $bindtag %x %y"
    bind $bindtag <3> "exclReset $bindtag"
    set graph(excl-x1) [$box xaxis invtransform $x]
    .g marker create text -name AddExclLbl -text "Adding\nRegion" \
            -bg yellow -coords "+Inf +Inf" -anchor ne
}

proc exclReset {bindtag} {
    global box
    bind $box <Motion> {}
    $box marker delete exclShade
    bind $bindtag <1> "exclAdd $bindtag %x %y"
    .g marker delete AddExclLbl
}

proc exclMove {bindtag x y} {
    global graph box
    set x1 $graph(excl-x1)
    set x2 [$box xaxis invtransform $x]
    if { ![$box marker exists "exclShade"] } {
        $box marker create polygon -name "exclShade" -under 1 -fill yellow
    }
    $box marker configure "exclShade" \
            -coords "$x1 -Inf $x1 +Inf $x2 +Inf $x2 -Inf"
}

proc exclDone {bindtag x y} {
    global box graph hst
    bind $box <Motion> {}
    bind $bindtag <1> "exclAdd $bindtag %x %y"
    set x1 $graph(excl-x1)
    set x2 [$box xaxis invtransform $x]
    if {$graph(xunits) == 1} {
        set x1 [fromd $x1 $hst]
        set x2 [fromd $x2 $hst]
    } elseif {$graph(xunits) == 2} {
        set x1 [fromQ $x1 $hst]
        set x2 [fromQ $x2 $hst]
    }
    catch {
        $box marker delete "exclShade"
    }
    .g marker delete AddExclLbl
    # get the points in the range
    set l [lsort -integer [allxvec search $x1 $x2]]
    if {[llength $l] == 0} return
    set p1 [allxvec index [set n1 [lindex $l 0]]]
    set p2 [allxvec index [set n2 [lindex $l end]]]
    if {$graph(xunits) == 1} {
        set d1 [tod $p1 $hst]
        set d2 [tod $p2 $hst]
        set msg "Exclude data from "
        append msg "[format %.5f $d2] A to [format %.5f $d1] A"
        append msg " ([expr $n2-$n1+1] points)?"
        set coords "$d2 -Inf $d1 -Inf"
        set l [lsort -integer [xvec search $d1 $d2]]
    } elseif {$graph(xunits) == 2} {
        set q1 [toQ $p1 $hst]
        set q2 [toQ $p2 $hst]
        set msg "Exclude data from "
        append msg "[format %.5f $q1] A-1 to [format %.5f $q2] A-1"
        append msg " ([expr $n2-$n1+1] points)?"
        set coords "$q1 -Inf $q2 -Inf"
        set l [lsort -integer [xvec search $q1 $q2]]
    } else {
        set msg "Exclude data from "
        append msg "[format %.5f $p1] to [format %.5f $p2]"
        append msg " ([expr $n2-$n1+1] points)?"
        set coords "$p1 -Inf $p2 -Inf"
        set l [lsort -integer [xvec search $x1 $x2]]
    }
    global graph
    if {$graph(exclPrompt)} {
        set ans [MyMessageBox -parent . -message $msg -title "Exclude?"\
                -type okcancel -helplink "expguierr.html ExcludeRegion"]
    } else {
        set ans ok
    }
    if {$ans == "ok"} {
        global changes
        incr changes
        global hst
        set exclist [histinfo $hst excl]
        lappend exclist [list $p1 $p2]
        set oldtmax [lindex [lindex $exclist end] 0]
        CheckForOverlappingRegions $exclist
        if {$oldtmax < [set tmax [lindex [lindex $exclist end] 0]]} {
            histinfo $hst dmin set [tod $tmax $hst]
            HighLimitChanged
        } elseif {$oldtmax != [set tmax [lindex [lindex $exclist end] 0]]} {
            histinfo $hst dmin set [tod $tmax $hst]
        } else {
            exxvec append [xvec range [lindex $l 0] [lindex $l end]]
            exobsvec append [obsvec range [lindex $l 0] [lindex $l end]]
            exxvec notify now
            exobsvec notify now
        }
        ShowExlMarks
        FillExclRegionBox
    }
}

proc CheckForOverlappingRegions {exclist} {
    set exclist [lsort -real -index 0 $exclist]
    set prvlow -1
    set prvhigh -1
    set i 0
    set ip -1
    foreach pair $exclist {
        set low [lindex $pair 0] 
        set high [lindex $pair 1] 
        # is there overlap with the previous range?
        if {$low < $prvhigh && $i != 0} {
            set exclist [lreplace $exclist $ip $i [list $prvlow $high]]
            set prvhigh $high
            continue
        }
        # are there any points between the regions
        if {$i != 0} {
            set seppts [allxvec search \
                    [expr -.00001+$low] [expr .00001+$prvhigh]]
            if {[llength $seppts] == 0} {
                set exclist [lreplace $exclist $ip $i [list $prvlow $high]]
                set prvhigh $high
                continue
            }
        }
        incr i; incr ip
        set prvlow $low
        set prvhigh $high
    }
    global hst
    histinfo $hst excl set $exclist
}

proc setminormax {} {
    set link excledt.html
    set box .limit
    toplevel $box
    grid [button $box.help -text Help -bg yellow \
            -command "MakeWWWHelp $link"] -col 98 -row 0
    bind $box <Key-F1> "MakeWWWHelp $link"
    global hst expmap graph expnam

    if {$graph(xunits) == 1} {
        set var d
        set unit A
    } elseif {$graph(xunits) == 2} {
        set var Q
        set unit A-1
    } elseif {[string range $expmap(htype_$hst) 2 2] == "T"} {
        set var TOF
        set unit ms
    } elseif {[string range $expmap(htype_$hst) 2 2] == "C"} {
        set var 2theta
        set unit deg
    } elseif {[string range $expmap(htype_$hst) 2 2] == "E"} {
        set var Energy
        set unit KeV
    } else {
        set var ?
        set unit ?
    }
    if {$graph(xunits) != 0} {
    }
    grid [label $box.t -text "Set usable data range"] -col 0 -columnspan 4 -row 0
    grid [label $box.lu -text "($unit)"] -col 2 -row 1 -rowspan 2
    grid [label $box.lmn -text "$var minimum"] -col 0 -row 1
    grid [entry $box.emn -textvariable graph(tmin) -width 10] -col 1 -row 1
    grid [label $box.lmx -text "$var maximum"] -col 0 -row 2
    grid [entry $box.emx -textvariable graph(tmax) -width 10] -col 1 -row 2
    grid [frame $box.c] -col 0 -columnspan 99 -row 99
    grid [button $box.c.1 -text Set -command "destroy $box"\
            ] -col 1 -row 0
    grid [button $box.c.2 -text Quit \
            -command "foreach i {min max} {set graph(\$i) {}}; destroy $box" \
            ] -col 2 -row 0
    set exclist [histinfo $hst excl]
    set oldtmax [lindex [lindex $exclist end] 0]
    if {$graph(xunits) == 1} {
        set graph(tmax) [format %.4f [tod [lindex [lindex $exclist 0] 1] $hst]]
        set graph(tmin) [format %.4f [tod [lindex [lindex $exclist end] 0] $hst]]
    } elseif {$graph(xunits) == 2} {
        set graph(tmin) [format %.4f [toQ [lindex [lindex $exclist 0] 1] $hst]]
        set graph(tmax) [format %.4f [toQ [lindex [lindex $exclist end] 0] $hst]]
    } else {
        set graph(tmin) [lindex [lindex $exclist 0] 1]
        set graph(tmax) [lindex [lindex $exclist end] 0]
    }
    foreach v {tmin tmax} {set start($v) $graph($v)}
    bind $box <Return> "$box.c.1 invoke"
    putontop $box
    tkwait window $box
    # fix grab...
    afterputontop
    global changes
    set highchange 0
    set startchanges $changes
    catch {
        if {$graph(tmin) != $start(tmin)} {
            incr changes
            if {$graph(xunits) == 1} {
                set tmax [fromd $graph(tmin) $hst]
                incr highchange
                set item [list $tmax [lindex [lindex $exclist end] 1]]
                set exclist [lreplace $exclist end end $item]
                histinfo $hst dmin set [tod $tmax $hst]
            } elseif {$graph(xunits) == 2} {
                set tmin [fromQ $graph(tmin) $hst]
                set item [list [lindex [lindex $exclist 0] 0] $tmin]
                set exclist [lreplace $exclist 0 0 $item]
            } else {
                set item [list [lindex [lindex $exclist 0] 0] $graph(tmin)]
                set exclist [lreplace $exclist 0 0 $item]
            }
        }
    }
    catch {
        if {$graph(tmax) != $start(tmax)} {
            incr changes
            if {$graph(xunits) == 1} {
                set tmin [fromd $graph(tmax) $hst]
                set item [list [lindex [lindex $exclist 0] 0] $tmin]
                set exclist [lreplace $exclist 0 0 $item]
            } elseif {$graph(xunits) == 2} {
                set tmax [fromQ $graph(tmax) $hst]
                incr highchange
                set item [list $tmax [lindex [lindex $exclist end] 1]]
                set exclist [lreplace $exclist end end $item]
                histinfo $hst dmin set [tod  $tmax $hst]
            } else {
                incr highchange
                set item [list $graph(tmax) [lindex [lindex $exclist end] 1]]
                set exclist [lreplace $exclist end end $item]
                histinfo $hst dmin set [tod  $graph(tmax) $hst]
            }
        }
    }
    if {$startchanges != $changes} {
        histinfo $hst excl set $exclist
        CheckForOverlappingRegions $exclist
    } else {
        return
    }
    if {$highchange && \
            $oldtmax < [set tmax [lindex [lindex $exclist end] 0]]} {
        histinfo $hst dmin set [tod $tmax $hst]
        HighLimitChanged
    } elseif {$oldtmax != [set tmax [lindex [lindex $exclist end] 0]]} {
        histinfo $hst dmin set [tod $tmax $hst]
        updateplot
    } else {
        updateplot
    }
}
proc HighLimitChanged {} {
    global expnam graph
    set msg "The upper data limit has changed.\nYou must run POWPREF to "
    append msg "to see the full range of data displayed. Do you want to "
    append msg "run POWPREF (& possibly GENLES with zero cycles)?"
    set ans [MyMessageBox -parent . -message $msg -title "Process limits?"\
            -helplink "expguierr.html ProcessRegions" \
            -type {Skip {Run POWPREF} {Run POWPREF & GENLES}}]
    if {$ans == "skip"} {
        expwrite $expnam
        updateplot
        return
    } elseif {$ans == "run powpref"} {
        set cmd powpref
        set cycsav {}
    } else {
        set cycsav [expinfo cycles]
        set cmd "powpref genles"
        expinfo cycles set 0
    }
    expwrite $expnam.EXP
    global expgui env
    set expgui(autoexpload) 0
    set expgui(archive) 0
    set expgui(expfile) $expnam.EXP
    set env(GSASBACKSPACE) 0
    set expgui(autoiconify) 0
    runGSASwEXP $cmd
    updateplot
    CheckTmax $cycsav
}

# find out what the maximum point really is
proc CheckTmax {cycsav} {
    # clone xvec
    xvec dup temp
    global graph hst expnam
    if {$graph(xunits) == 1} {
        temp sort
        set max [fromd [temp index 0] $hst]
        set step [expr abs($max - [fromd [temp index 1] $hst])]
    } elseif {$graph(xunits) == 2} {
        temp sort -reverse
        set max [fromQ [temp index 0] $hst]
        set step [expr abs($max - [fromQ [temp index 1] $hst])]
    } else {
        temp sort -reverse
        set max [temp index 0]
        set step [expr $max - [temp index 1]]
    }
    set exclist [histinfo $hst excl]
    if {[lindex [lindex $exclist end] 0] > $max + 10*$step} {
        if {$graph(xunits) == 1} {
            set msg "The lower data limit ([tod [lindex [lindex $exclist end] 0] $hst] A) " 
            set d [tod $max $hst]
            append msg "is much smaller than the smallest data point ($d A)\n"
            append msg "You are suggested to set the lower d limit to $d A\n"
        } elseif {$graph(xunits) == 2} {
            set msg "The upper data limit ([toQ [lindex [lindex $exclist end] 0] $hst] A-1) " 
            set q [toQ $max $hst]
            append msg "is much larger than the largest data point ($q A-1)\n"
            append msg "You are suggested to set the upper Q limit to $q A-1\n"
        } else {
            set msg "The upper data limit ([lindex [lindex $exclist end] 0]) " 
            append msg "is much larger than the largest data point ($max)\n"
            append msg "You are suggested to set the upper limit to $max\n"
        }
        append msg "OK to make this change?"
        set ans [MyMessageBox -parent . -message $msg -title "Reset limits?"\
                -helplink "expguierr.html RegionTooBig" \
                -type {OK Cancel}]
        if {$ans == "ok"} {
            set item [list [expr $max+$step] [lindex [lindex $exclist end] 1]]
            set exclist [lreplace $exclist end end $item]
            histinfo $hst excl set $exclist
            if {$cycsav != ""} {
                expinfo cycles set $cycsav
            }
            expwrite $expnam.EXP
            updateplot
            return
        }
    }
    if {$cycsav != ""} {
        expinfo cycles set $cycsav
        expwrite $expnam.EXP
    }
}

proc CheckChanges {} {
    global changes hst graph
    if {$changes == 0} return
    set msg "The excluded regions have changed.\nYou must run POWPREF before "
    append msg "running GENLES. Do you want to run POWPREF and possibly "
    append msg "GENLES with zero cycles now?"
    set ans [MyMessageBox -parent . -message $msg -title "Process limits?"\
            -helplink "expguierr.html ProcessRegions" \
            -type {Skip {Run POWPREF} {Run POWPREF & GENLES}}]
    global expgui env expnam
    if {$ans == "run powpref"} {
        set cmd powpref
        set cycsav {}
    } elseif {$ans == "skip"} {
        expwrite $expnam.EXP
        return
    } else {
        set cycsav [expinfo cycles]
        set cmd "powpref genles"
        expinfo cycles set 0
    }
    expwrite $expnam.EXP
    set expgui(autoexpload) 0
    set expgui(archive) 0
    set expgui(expfile) $expnam.EXP
    set env(GSASBACKSPACE) 0
    set expgui(autoiconify) 0
    runGSASwEXP $cmd
    set changes 0
    CheckTmax $cycsav
}

proc EditExclRegion {reg "msg {}"} {
    global graph hst expmap changes
    set startchanges $changes
    set exclist [histinfo $hst excl]
    set oldtmax [lindex [lindex $exclist end] 0]
    set i [expr {$reg -1}]
    set range [lindex $exclist $i]
    toplevel [set box .edit]
    set beg minimum
    set end maximum
    set graph(tmin) [format %.4f [lindex $range 0]]
    set graph(tmax) [format %.4f [lindex $range 1]]
    if {$msg != ""} {
        grid [label $box.0 -text $msg -fg red] \
                -col 1 -row 0 -columnspan 99
    }
    if {$graph(xunits) == 1} {
        set var d-space
        set unit A
        set beg maximum
        set end minimum
        set graph(tmin) [format %.4f [tod [lindex $range 0] $hst]]
        set graph(tmax) [format %.4f [tod [lindex $range 1] $hst]]
    } elseif {$graph(xunits) == 2} {
        set var Q
        set unit A-1
        set graph(tmin) [format %.4f [toQ [lindex $range 0] $hst]]
        set graph(tmax) [format %.4f [toQ [lindex $range 1] $hst]]
    } elseif {[string range $expmap(htype_$hst) 2 2] == "T"} {
        set var TOF
        set unit ms
    } elseif {[string range $expmap(htype_$hst) 2 2] == "C"} {
        set var 2theta
        set unit deg
    } elseif {[string range $expmap(htype_$hst) 2 2] == "E"} {
        set var Energy
        set unit KeV
    } else {
        set var ?
        set unit ?
    }
    if {$reg == 1} {
        grid [label $box.1 -text "Editing Data Limits ($unit)"] \
                -col 1 -row 1 -columnspan 99
        grid [label $box.2 -text "$beg $var "] \
                -col 1 -row 2
        grid [entry $box.3 -width 12 -textvariable graph(tmax)] \
                -col 2 -row 2
    } elseif {$reg == [llength $exclist]} {
        grid [label $box.1 -text "Editing Data Limits ($unit)"] \
                -col 1 -row 1 -columnspan 99
        grid [label $box.2 -text "$end $var "] \
                -col 1 -row 2
        grid [entry $box.3 -width 12 -textvariable graph(tmin)] \
                -col 2 -row 2
    } else {
        grid [label $box.1 -text "Editing excluded region #$reg in $var ($unit)"] \
                -col 1 -row 1 -columnspan 99
        grid [label $box.2 -text "$beg $var "] \
                -col 1 -row 2
        grid [entry $box.3 -width 12 -textvariable graph(tmin)] \
                -col 2 -row 2
        grid [label $box.4 -text "$end $var "] \
                -col 1 -row 3
        grid [entry $box.5 -width 12 -textvariable graph(tmax)] \
                -col 2 -row 3
    }
    foreach v {tmin tmax} {
        set $v $graph($v)
    }
    bind $box <Return> "destroy .edit"
    grid [frame $box.c] -col 1 -row 99 -columnspan 99
    grid [button $box.c.1 -text "OK" -command "destroy .edit"] \
            -col 1 -row 1
    grid [button $box.c.2 -text "Cancel" \
            -command "set graph(tmin) $tmin; set graph(tmax) $tmax;destroy .edit"] \
            -col 2 -row 1
    putontop $box
    tkwait window $box
    afterputontop
    if {$tmin != $graph(tmin)} {
        if {[catch {
            expr $graph(tmin)
            if {$graph(xunits) == 1} {
                set tmin [fromd $graph(tmin) $hst]
            } elseif {$graph(xunits) == 2} {
                set tmin [fromQ $graph(tmin) $hst]
            } else {
                set tmin $graph(tmin)
            }
        }]} {
            EditExclRegion $reg "Invalid value entered, try again"
            return
        }
        set exclist [lreplace $exclist $i $i [lreplace $range 0 0 $tmin]]
        incr changes
    }
    if {$tmax != $graph(tmax)} {
        if {[catch {
            expr $graph(tmax)
            if {$graph(xunits) == 1} {
                set tmax [fromd $graph(tmax) $hst]
            } elseif {$graph(xunits) == 2} {
                set tmax [fromQ $graph(tmax) $hst]
            } else {
                set tmax $graph(tmax)
            }
        }]} {
            EditExclRegion $reg "Invalid value entered, try again"
            return
        }
        set exclist [lreplace $exclist $i $i [lreplace $range 1 1 $tmax]]
        incr changes
    }
    if {$changes != $startchanges} {
        histinfo $hst excl set $exclist
        CheckForOverlappingRegions $exclist
        if {$reg == [llength $exclist]} {
            histinfo $hst dmin set [tod $tmin $hst]
        }
        if {$oldtmax < [set tmax [lindex [lindex $exclist end] 0]]} {
            histinfo $hst dmin set [tod $tmin $hst]
            HighLimitChanged
        } elseif {$oldtmax != [set tmax [lindex [lindex $exclist end] 0]]} {
            histinfo $hst dmin set [tod $tmin $hst]
            updateplot
        } else {
            updateplot
        }
        FillExclRegionBox
    }
}

proc scheduleFillExclRegionBox {} {
    global graph
    # is an update pending?
    if {$graph(FillExclRegionBox)} return
    set graph(FillExclRegionBox) 1
    after idle FillExclRegionBox
}
# put the background regions into buttons
proc FillExclRegionBox {} {
    global graph hst
    set can $graph(ExclCanvas)
    set scroll $graph(ExclScroll)
    
    catch {destroy [set top $can.fr]}
    frame $top -class SmallFont
    $can create window 0 0 -anchor nw -window $top
    set exclist [histinfo $hst excl]
    set col 0
    foreach rng $exclist {
        if {$graph(xunits) == 1} {
            set rng [tod $rng $hst]
            if {$col == 0} {
                set lbl ">[format %.4f [lindex $rng 1]]"
            } else {
                set lbl "[format %.4f [lindex $rng 0]]\nto [format %.4f [lindex $rng 1]]"
            }
            incr col
            if {$col == [llength $exclist]} {
                set lbl "<[format %.4f [lindex $rng 0]]"
            }
        } else {
            if {$graph(xunits) == 2} {
                set rng [toQ $rng $hst]
            }
            if {$col == 0} {
                set lbl "<[format %.3f [lindex $rng 1]]"
            } else {
                set lbl "[format %.3f [lindex $rng 0]]\nto [format %.3f [lindex $rng 1]]"
            }
            incr col
            if {$col == [llength $exclist]} {
                set lbl ">[format %.3f [lindex $rng 0]]"
            }
        }
        grid [button $top.$col -text $lbl -command "EditExclRegion $col" \
                -padx 1 -pady 1] -row 0 -col $col -sticky  ns
    }
    update idletasks
    set sizes [grid bbox $top]
    $can config -scrollregion $sizes -height [lindex $sizes 3]
    if {[lindex $sizes 2] <= [winfo width $can]} {
        grid forget $scroll
    } else {
        grid $graph(ExclScroll) -column 1 -row 4 -columnspan 5 -sticky nsew
    }
    # clear flag
    set graph(FillExclRegionBox) 0
}

source [file join $expgui(scriptdir) gsascmds.tcl]
source [file join $expgui(scriptdir) readexp.tcl]
if {$tcl_platform(platform) == "windows"} {
    # platform-specific code
    if {$tcl_platform(os) == "Windows 95"} {
        if [catch {package require winexec}] {
            MyMessageBox -parent . -title "WINEXEC Error" \
                    -message "Error -- Unable to load the WINEXEC package. This is needed in Win95 machines" \
                    -icon error -type Quit -default quit \
                    -helplink "expgui_Win_readme.html Winexec"
            destroy .
        }
    }
    set graph(printout) 1
} else {
    set graph(printout) 0
}

# do not need archiving or checking for changed files here
proc savearchiveexp {} {}
proc whenidle {} {}

source [file join $expgui(scriptdir) opts.tcl]
# override options with locally defined values
if [file exists [file join $expgui(scriptdir) localconfig]] {
    source [file join $expgui(scriptdir) localconfig]
}
if [file exists [file join ~ .gsas_config]] {
    source [file join ~ .gsas_config]
}
SetTkDefaultOptions $expgui(font)

# vectors
foreach vec {allxvec xvec obsvec calcvec diffvec exxvec exobsvec} {
    vector $vec
    $vec notify never
}
# create the graph
if [catch {
    set box [graph .g -plotbackground white]
} errmsg] {
    tk_dialog .err "BLT Error" \
"BLT Setup Error: could not create a graph (msg: $errmsg). \
There is a problem with the setup of BLT on your system.
See the expgui.html file for more info." \
            error 0 "Quit"
exit
}

if [catch {
    Blt_ZoomStack $box
} errmsg] {
    tk_dialog .err "BLT Error" \
"BLT Setup Error: could not access a Blt_ routine (msg: $errmsg). \
The pkgIndex.tcl is probably not loading bltGraph.tcl.
See the expgui.html file for more info." \
            error 0 "Limp ahead"
}

$box element create 3 -color black -linewidth 0 -label Obs \
        -symbol $peakinfo(obssym) -color $graph(color_obs) \
        -pixels [expr 0.125 * $peakinfo(obssize)]i
$box element create 2 -label Calc -color $graph(color_calc)  -symbol none  
$box element create 12 -line 0 -label "Excl" -color $graph(color_excl) \
        -symbol $peakinfo(exclsym) \
        -pixels [expr 0.15 * $peakinfo(exclsize)]i
$box element show "3 2 12 1"
$box element config 3 -xdata xvec -ydata obsvec
$box element config 2 -xdata xvec -ydata calcvec
$box element config 12 -xdata exxvec -ydata exobsvec

$box yaxis config -title {} 
setlegend $box $graph(legend)

frame .a -bd 3 -relief groove
pack [menubutton .a.file -text File -underline 0 -menu .a.file.menu] -side left
menu .a.file.menu
.a.file.menu add cascade -label Tickmarks -menu .a.file.menu.tick
menu .a.file.menu.tick
foreach num {1 2 3 4 5 6 7 8 9} {
    .a.file.menu.tick add checkbutton -label "Phase $num" \
            -variable  peakinfo(flag$num)
}
.a.file.menu add cascade -label Histogram -menu .a.file.menu.hist -state disabled

.a.file.menu add command -label "Set Min/Max Range" -command setminormax
.a.file.menu add command -label "Update Plot" -command "CheckChanges;updateplot"
.a.file.menu add command -label "Make PostScript" -command makepostscriptout
.a.file.menu add command -label Exit -command "CheckChanges;exit"

pack [menubutton .a.options -text Options -underline 0 -menu .a.options.menu] \
        -side left    
menu .a.options.menu
.a.options.menu add cascade -label "Configure Tickmarks" -menu .a.options.menu.tick
menu .a.options.menu.tick
.a.options.menu.tick add radiobutton -label "Manual Placement" \
        -value 0 -variable expgui(autotick) -command plotdata
.a.options.menu.tick add radiobutton -label "Auto locate" \
        -value 1 -variable expgui(autotick) -command plotdata
.a.options.menu.tick add separator
foreach num {1 2 3 4 5 6 7 8 9} {
    .a.options.menu.tick add command -label "Phase $num" \
            -command "minioptionsbox $num"
}
.a.options.menu add cascade -label "Symbol Type" -menu .a.options.menu.sym
menu .a.options.menu.sym
foreach var {excl obs} lbl {Excluded Observed} {
    .a.options.menu.sym add command -label $lbl -command "getsymopts $var"
}

.a.options.menu add cascade -label "Symbol color" -menu .a.options.menu.color
menu .a.options.menu.color
foreach var {excl calc obs} lbl {Excluded Calculated Observed} {
    .a.options.menu.color add command -label $lbl \
        -command "set graph(color_$var) \[tk_chooseColor -initialcolor \$graph(color_$var) -title \"Choose \$lbl color\"]; plotdata"
}
.a.options.menu add cascade -label "X units" -menu .a.options.menu.xunits
menu .a.options.menu.xunits
.a.options.menu.xunits add radiobutton -label "As collected" \
        -variable graph(xunits) -value 0 \
        -command updateplot
.a.options.menu.xunits add radiobutton -label "d-space" \
        -variable graph(xunits) -value 1 \
        -command updateplot
.a.options.menu.xunits add radiobutton -label "Q" \
        -variable graph(xunits) -value 2 \
        -command updateplot
    
.a.options.menu add checkbutton -label "Include legend" \
        -variable graph(legend) \
        -command {setlegend $box $graph(legend)}
.a.options.menu add checkbutton -label "Prompt on add/del" \
        -variable graph(exclPrompt)
.a.options.menu add command -label "Set PS output" -command setpostscriptout

.a.options.menu add cascade -menu  .a.options.menu.font \
        -label "Screen font"
menu .a.options.menu.font
foreach f {10 11 12 13 14 16 18 20 22} {
    .a.options.menu.font add radiobutton \
            -command {SetTkDefaultOptions $expgui(font); ResizeFont .} \
        -label $f -value $f -variable expgui(font) -font "Helvetica -$f"
}
.a.options.menu add command -label "Save Options" -command "SaveOptions"

set bb .b
catch {pack [frame $bb -bd 3 -relief sunken] -side bottom -fill both}
grid [label $bb.top -text "Excluded Region Editing"] \
        -col 0 -row 0 -columnspan 4
grid [button $bb.help -text Help -bg yellow \
        -command "MakeWWWHelp excledt.html"] \
        -column 5 -row 0 -rowspan 1 -sticky ne
    
grid [frame $bb.l -bd 3 -relief groove] \
        -col 0 -row 1 -columnspan 2 -sticky nse
grid [label $bb.l.1 -text "Mouse click\naction"] -col 0 -row 0
foreach c {1 2 3} l {zoom "Add\nregion" "Delete\nregion"} {
    grid [button $bb.l.b$c -text $l -command "exclEditMode $c $bb"] \
            -col $c -row 0 -sticky ns
}
exclEditMode 1 $bb
#grid [button $bb.mnmx -text "Min/Max\nRange" -command setminormax] \
#       -col 4 -columnspan 2 -row 1 -sticky e

grid [frame $bb.bl] \
        -col 0 -row 3 -rowspan 2 -sticky nsew
grid [label $bb.bl.1 -text "Excluded\nRegions"] -col 0 -row 0
grid [canvas [set graph(ExclCanvas) $bb.bc] \
        -scrollregion {0 0 5000 500} -width 0 -height 0 \
        -xscrollcommand "$bb.bs set"] \
        -column 1 -row 3 -columnspan 5 -sticky nsew
grid [scrollbar [set  graph(ExclScroll) $bb.bs] -command "$bb.bc xview" \
        -orient horizontal] \
        -column 1 -row 4 -columnspan 5 -sticky nsew
grid [button $bb.cw -text "Save\n& Exit" \
        -command "CheckChanges;exit"] \
        -col 4 -row 1 -columnspan 2 -sticky ns
#grid [button $bb.cq -text "Quit" \
#       -command "exit"] \
#       -col 5 -row 3 -rowspan 2 -sticky ns

grid columnconfigure $bb 1 -weight 1
#grid columnconfigure $bb 2 -weight 1
#grid columnconfigure $bb 3 -weight 1
grid columnconfigure $bb 5 -weight 1
grid rowconfigure $bb 3 -weight 1
grid rowconfigure $bb 5 -weight 1
#    .g config -title ""

pack [menubutton .a.help -text Help -underline 0 -menu .a.help.menu] -side right
menu .a.help.menu -tearoff 0
.a.help.menu add command -command "MakeWWWHelp excledt.html" -label "Web page"
.a.help.menu add command -command about -label About

pack .a -side top -fill both
pack $box -fill both -expand yes

if {[expload $expnam.EXP] < 0} {exit}
mapexp

# fill the histogram menu
if {[llength $expmap(powderlist)] > 1} {
    .a.file.menu entryconfigure Histogram -state normal
    menu .a.file.menu.hist
    if {[llength $expmap(powderlist)] > 15} {
        set i 0
        foreach num [lsort -integer $expmap(powderlist)] {
            incr i
            # for now include, but disable dummy histograms
            set state disabled
            if {[string trim [string range $expmap(htype_$num) 3 3]] != "D"} {
                set state normal
            }
            if {$i == 1} {
                set num1 $num
                menu .a.file.menu.hist.$num1
            }
            .a.file.menu.hist.$num1 add radiobutton -label $num -value $num \
                    -variable hst -state $state \
                    -command {set cycle [getcycle];readdata .g}
            if {$i >= 10} {
                set i 0
                .a.file.menu.hist add cascade -label "$num1-$num" \
                        -menu .a.file.menu.hist.$num1
            }
        }
        if {$i != 0} {
            .a.file.menu.hist add cascade -label "$num1-$num" \
                    -menu .a.file.menu.hist.$num1
        }
    } else {
        foreach num [lsort -integer $expmap(powderlist)] {
            # for now include, but disable dummy histograms
            set state disabled
            if {[string trim [string range $expmap(htype_$num) 3 3]] != "D"} {
                set state normal
            }
            .a.file.menu.hist add radiobutton -label $num -value $num \
                    -variable hst -state $state \
                    -command {set cycle [getcycle];readdata .g}
        }
    }
}

updateplot
trace variable peakinfo w plotdata

# catch exits -- launch POWPREF; if changes non-zero
wm protocol . WM_DELETE_WINDOW {CheckChanges;exit}
bind all <Control-KeyPress-c> {CheckChanges;exit}
# respond to resize events
bind . <Configure> scheduleFillExclRegionBox