path: root/tcl/bin/halconfig.tcl

#!/bin/sh
# the next line restarts using emcsh \
exec $LINUXCNC_EMCSH "$0" "$@"

###############################################################
# Description:  halconfig.tcl
#               This file, shows a running hal configuration
#               and has menu for modifying and tuning
#
#  Author: Raymond E Henry
#  License: GPL Version 2
#
#  Copyright (c) 2006-2009 All rights reserved.
###############################################################
# Script accesses HAL through two modes halcmd show xxx for show
# and open halcmd -skf for building tree, watch, edit, and such
# FIXME -- empty mod entry widgets after execute
# FIXME -- please hal param naming conventions aren't
###############################################################
# Description:  halconfig.tcl
#               Part of the HAL online configuration system
#
#  Author: Raymond E Henry
#  License: GPL Version 2
#
#  Copyright (c) 2006-2009 All rights reserved.
###############################################################

# Load the linuxcnc.tcl file, which defines variables for various useful paths
source [file join [file dirname [info script]] .. linuxcnc.tcl]
eval emc_init $argv

package require BWidget

#----------open channel to halcmd ----------

proc openHALCMD {} {
    global fid
    set fid [open "|halcmd -skf" "r+"]
    fconfigure $fid -buffering line -blocking on
    gets $fid
    fileevent $fid readable {getsHAL}
}

proc exHAL {argv} {
    global fid chanflag returnstring
    set chanflag rd
    puts $fid "${argv}"
    vwait chanflag
    set tmp $returnstring
    set returnstring ""
    return $tmp
}

# getsHAL appends lines to returnstring until it receives a line with just 
# a percent sign "%" on it 
# Once the % is received, the global var chanflag is set to "wr"
set returnstring ""
proc getsHAL {} {
    global fid chanflag returnstring
    gets $fid tmp
    if {$tmp != "\%"} {
        append returnstring $tmp
    } else {
        set chanflag wr
    }
}
openHALCMD
#
#----------end of open halcmd----------

# add a few default characteristics to the display
foreach class { Button Checkbutton Entry Label Listbox Menu Menubutton \
    Message Radiobutton Scale } {
    option add *$class.borderWidth 1  100
}

set numaxes [emc_ini "AXES" "TRAJ"]

# Find the name of the ini file used for this run.
set thisinifile "$EMC_INIFILE"
set thisconfigdir [file dirname $thisinifile]


#----------start toplevel----------
#

wm title . [msgcat::mc "HAL Configuration"]
wm protocol . WM_DELETE_WINDOW tk_
set masterwidth 700
set masterheight 475
# set fixed size for configuration display and center
set xmax [winfo screenwidth .]
set ymax [winfo screenheight .]
set x [expr ($xmax - $masterwidth )  / 2 ]
set y [expr ($ymax - $masterheight )  / 2]
wm geometry . "${masterwidth}x${masterheight}+$x+$y"

# trap mouse click on window manager delete and ask to save
wm protocol . WM_DELETE_WINDOW askKill
proc askKill {} {
    global thisconfigdir
    set tmp [tk_dialog .quit [msgcat::mc "Quit"] [msgcat::mc "Would you like to save your configuration before you exit?"] "warning" [msgcat::mc "Save All"] [msgcat::mc "Save All"] [msgcat::mc "Save Tune"] [msgcat::mc "Save as Netlist"] [msgcat::mc "Don't Save"] [msgcat::mc "Cancel"]] 
    switch -- $tmp {
        0 {saveHAL save ; killHalConfig}
        1 {saveHAL savetune ; killHalConfig}
        2 {saveHAL savenetlist ; killHalConfig}
        3 {killHalConfig}
        4 {return}
    }
}

# clean up a possible problems during shutdown
proc killHalConfig {} {
    global fid
    if {[info exists fid] && $fid != ""} {
        catch flush $fid
        catch close $fid
    }
    destroy .
    exit
}

set main [frame .main ]
pack $main -fill both -expand yes

# build frames from left side
set tf [frame $main.maint]
set top [NoteBook $main.note]

# Each mode has a unique set of widgets inside tab
set showhal [$top insert 0 ps -text [msgcat::mc "Show"] -raisecmd {showMode showhal} ]
set watchhal [$top insert 1 pw -text [msgcat::mc "Watch"] -raisecmd {showMode watchhal}]
set modifyhal [$top insert 2 pm -text [msgcat::mc "Modify"] -raisecmd {showMode modifyhal}]
# Each axis or HAL section has its own tab 
# These are built in the tuning processes

# use place manager to fix locations of frames within top
place configure $tf -in $main -x 0 -y 0 -relheight 1 -relwidth .3
place configure $top -in $main -relx .3 -y 0 -relheight 1 -relwidth .7

# slider process is used for several widgets
proc sSlide {f a b} {
    $f.sc set $a $b
}

# Build menu
# fixme clean up the underlines so they are unique under each set
set menubar [menu $top.menubar -tearoff 0]
set filemenu [menu $menubar.file -tearoff 0]
    $menubar add cascade -label [msgcat::mc "File"] \
            -menu $filemenu
        $filemenu add command -label [msgcat::mc "Refresh"] \
            -command {refreshHAL}
        $filemenu add command -label [msgcat::mc "Save"] \
            -command {saveHAL save}
        $filemenu add command -label [msgcat::mc "Save INI Tuning"] \
            -command {saveHAL savetune} -state disabled
        $filemenu add command -label [msgcat::mc "Save HAL Ini"] \
            -command {saveHAL savenetini} -state disabled
        $filemenu add command -label [msgcat::mc "Save HAL Net"] \
            -command {saveHAL savenetlist}
        $filemenu add command -label [msgcat::mc "Save and Exit"] \
            -command {saveHAL saveandexit}
        $filemenu add command -label [msgcat::mc "Exit"] \
            -command {killHalConfig}
set viewmenu [menu $menubar.view -tearoff 0]
    $menubar add cascade -label [msgcat::mc "View"] \
            -menu $viewmenu
        $viewmenu add command -label [msgcat::mc "Expand Tree"] \
            -command {showNode {open}}
        $viewmenu add command -label [msgcat::mc "Collapse Tree"] \
            -command {showNode {close}}
        $viewmenu add separator
        $viewmenu add command -label [msgcat::mc "Expand Pins"] \
            -command {showNode {pin}}
        $viewmenu add command -label [msgcat::mc "Expand Parameters"] \
            -command {showNode {param}}
        $viewmenu add command -label [msgcat::mc "Expand Signals"] \
            -command {showNode {sig}}
        $viewmenu add separator
        $viewmenu add command -label [msgcat::mc "Erase Watch"] \
            -command {watchReset all}
# set settingsmenu [menu $menubar.settings -tearoff 0]
#    $menubar add cascade -label [msgcat::mc "Settings"] \
            -menu $settingsmenu -underline 0
#        $settingsmenu add radiobutton -label [msgcat::mc "Show"] \
            -variable workmode -value showhal -underline 0 \
            -command {showMode showhal }
           
set helpmenu [menu $menubar.help -tearoff 0]
    $menubar add cascade -label [msgcat::mc "Help"] \
            -menu $helpmenu
        $helpmenu add command -label [msgcat::mc "About"] \
            -command {showHelp about}
        $helpmenu add command -label [msgcat::mc "Main"] \
            -command {showHelp main}
. configure -menu $menubar

# build the tree widgets left side
set treew [Tree $tf.t  -width 10 -yscrollcommand "sSlide $tf" ]
set str $tf.sc
scrollbar $str -orient vert -command "$treew yview"
pack $str -side right -fill y
pack $treew -side right -fill both -expand yes
$treew bindText <Button-1> {workMode   }

#----------tree widget handlers----------
# a global var -- treenodes -- holds the names of existing nodes
# nodenames are the text applied to the toplevel tree nodes
# they could be internationalized here but the international name
# must contain no whitespace.  I'm not certain how to do that.
set nodenames {Components Pins Parameters Signals Functions Threads}

# searchnames is the real name to be used to reference
set searchnames {comp pin param sig funct thread}
set signodes {X Y Z A "Spindle"}

set treenodes ""
proc refreshHAL {} {
    global treew treenodes oldvar
    set tmpnodes ""
    # look through tree for nodes that are displayed
    foreach node $treenodes {
        if {[$treew itemcget $node -open]} {
            lappend tmpnodes $node
        }
    }
    # clean out the old tree
    $treew delete [$treew nodes root]
    # reread hal and make new nodes
    listHAL
    # read opennodes and set tree state if they still exist
    foreach node $tmpnodes {
        if {[$treew exists $node]} {
            $treew opentree $node no
        }
    }
    showHAL $oldvar
}

# listhal gets $searchname stuff
# and calls makeNodeX with list of stuff found.
proc listHAL {} {
    global searchnames nodenames
    set i 0
    foreach node $searchnames {
        writeNode "$i root $node [lindex $nodenames $i] 1"
        set ${node}str [exHAL "list $node" ]
        switch -- $node {
            pin {-}
            param {
                makeNodeP $node [set ${node}str]
            }
            sig {
                makeNodeSig $sigstr
            }
            comp {-}
            funct {-}
            thread {
                makeNodeOther $node [set ${node}str]
            }
            default {}
        }
    incr i
    }
}

proc makeNodeP {which pstring} {
    global treew 
    # make an array to hold position counts
    array set pcounts {1 1 2 1 3 1 4 1 5 1}
    # consider each listed element
    foreach p $pstring {
        set elementlist [split $p "." ]
        set lastnode [llength $elementlist]
        set i 1
        foreach element $elementlist {
            switch $i {
                1 {
                    set snode "$which+$element"
                    if {! [$treew exists "$snode"] } {
                        set leaf [expr $lastnode - 1]
                        set j [lindex [array get pcounts 1] end]
                        writeNode "$j $which $snode $element $leaf"
                        array set pcounts "1 [incr j] 2 1 3 1 4 1 5 1"
                        set j 0
                    }
                    set i 2
                }
                2 {
                    set ssnode "$snode.$element"
                    if {! [$treew exists "$ssnode"] } {
                        set leaf [expr $lastnode - 2]
                        set j [lindex [array get pcounts 2] end]
                        writeNode "$j $snode $ssnode $element $leaf"
                        array set pcounts "2 [incr j] 3 1 4 1 5 1"
                        set j 0
                    }
                    set i 3
                }
                3 {
                    set sssnode "$ssnode.$element"
                    if {! [$treew exists "$sssnode"] } {
                        set leaf [expr $lastnode - 3]
                        set j [lindex [array get pcounts 3] end]
                        writeNode "$j $ssnode $sssnode $element $leaf"
                        array set pcounts "3 [incr j] 4 1 5 1"
                        set j 0
                    }
                    set i 4
                }
                4 {
                    set ssssnode "$sssnode.$element"
                    if {! [$treew exists "$ssssnode"] } {
                        set leaf [expr $lastnode - 4]
                        set j [lindex [array get pcounts 4] end]
                        writeNode "$j $sssnode $ssssnode $element $leaf"
                        array set pcounts "4 [incr j] 5 1"
                        set j 0
                    }
                    set i 5
                }
                5 {
                    set sssssnode "$ssssnode.$element"
                    if {! [$treew exists "$sssssnode"] } {
                        set leaf [expr $lastnode - 5]
                        set j [lindex [array get pcounts 5] end]
                        writeNode "$j $ssssnode $sssssnode $element $leaf"
                        array set pcounts "5 [incr j]"
                        set j 0
                    }
                }
              # end of node making switch
            }
           # end of element foreach
         }
        # end of param foreach
    }
    # empty the counts array in preparation for next proc call
    array unset pcounts {}
}

# signal node assumes more about HAL than pins or params.
# For this reason the hard coded variable signodes
proc makeNodeSig {sigstring} {
    global treew signodes
    # build sublists dotstring, each signode element, and remainder
    foreach nodename $signodes {
        set nodesig$nodename ""
    }
    set dotsig ""
    set remainder ""
    foreach tmp $sigstring {
        set i 0
        if {[string match *.* $tmp]} {
            lappend dotsig $tmp
            set i 1
        }
   
        foreach nodename $signodes {
	    if {$i == 0 && [string match *$nodename* $tmp]} {
                lappend nodesig$nodename $tmp
                set i 1
            }
        }
        if {$i == 0} {
            lappend remainder $tmp
        }
    }
    set i 0
    # build the signode named nodes and leaves
    foreach nodename $signodes {
        set tmpstring [set nodesig$nodename]
        if {$tmpstring != ""} {
            set snode "sig+$nodename"
            writeNode "$i sig $snode $nodename 1"
            incr i
            set j 0
            foreach tmp [set nodesig$nodename] {
                set ssnode sig+$tmp
                writeNode "$j $snode $ssnode $tmp 0"
                incr j
            }
        }
    }
    set j 0
    # build the linkpp based signals just below signode
    foreach tmp $dotsig {
        set tmplist [split $tmp "."]
        set tmpmain [lindex $tmplist 0]
        set tmpname [lindex $tmplist end] 
        set snode sig+$tmpmain
        if {! [$treew exists "$snode"] } {
            writeNode "$i sig $snode $tmpmain 1"
            incr i
        }
        set ssnode sig+$tmp
        writeNode "$j $snode $ssnode $tmp 0"
        incr j
    }
    # build the remaining leaves at the bottom of list
    foreach tmp $remainder {
        set snode sig+$tmp
        writeNode "$i sig $snode $tmp 0"
        incr i
    }

}

proc makeNodeOther {which otherstring} {
    global treew
    set i 0
    foreach element $otherstring {
        set snode "$which+$element"
        if {! [$treew exists "$snode"] } {
            set leaf 0
            writeNode "$i $which $snode $element $leaf"
        }
        incr i
    }
}

# writeNode handles tree node insertion for makeNodeX
# builds a global list -- treenodes -- but not leaves
proc writeNode {arg} {
    global treew treenodes
    scan $arg {%i %s %s %s %i} j base node name leaf
    $treew insert $j  $base  $node -text $name
    if {$leaf > 0} {
        lappend treenodes $node
    }
}

proc showNode {which} {
    global treew
    switch -- $which {
        open {-}
        close {
            foreach type {pin param sig} {
                $treew ${which}tree $type
            }
        }
        pin {-}
        param {-}
        sig {
            foreach type {pin param sig} {
                $treew closetree $type
            }
            $treew opentree $which
            $treew see $which
        }
        default {}
    }
    focus -force $treew
}

#
#----------end of tree building processes----------

set oldvar "zzz"
# build show mode right side
proc makeShow {} {
    global showhal disp showtext
    set what full
    if {$what == "full"} {
        set stf [frame $showhal.t]
        set disp [text $stf.tx  -wrap word -takefocus 0 -state disabled \
            -relief flat -borderwidth 0 -height 28 -yscrollcommand "sSlide $stf"]
        set stt $stf.sc
        scrollbar $stt -orient vert -command "$disp yview"
        pack $stt -side right -fill both -expand yes
        pack $disp -side right -fill both -expand yes
        set seps [frame $showhal.sep -bg black -borderwidth 2]
        set cfent [frame $showhal.b]
        set lab [label $cfent.label -text [msgcat::mc "Enter HAL command :"] ]
        set com [entry $cfent.entry -textvariable halcommand]
        bind $com <KeyPress-Return> {showEx $halcommand}
        set ex [button $cfent.execute -text [msgcat::mc "Execute"] \
            -command {showEx $halcommand} ]
        set showtext [text $showhal.txt -height 2  -borderwidth 2 -relief groove ]
        pack $lab -side left -padx 5 -pady 3 
        pack $com -side left -fill x -expand yes -pady 3
        pack $ex -side left -padx 5 -pady 3
        pack $stf $seps $cfent $showtext -side top -fill both -expand yes
    }
}

proc makeWatch {} {
    global cisp watchhal
    set cisp [canvas $watchhal.c ]
    pack $cisp -side right -fill both -expand yes
}

proc makeModify {} {
    global modifyhal modtext focusname mcsets
    set mcsets { {loadrt 1} {unloadrt 1} {addf 1} {delf 1} {newsig 2} {delsig 1} \
        {linkpp 2} {linkps 2} {linksp 2} {unlinkp 1}  }
    set moddisplay [frame $modifyhal.textframe ]
    set modtext [text $moddisplay.text -width 40 -height 8 -wrap word \
        -takefocus 0 -relief groove]
    pack $modtext -side bottom -fill both -expand yes
    set j 1
    foreach cset $mcsets {
        set halmodcmd ""
        scan $cset { %s %i } commandname numvars
        if {$numvars == 2} {
            set colspan 1
        } else {
            set colspan 2
        }
        label $modifyhal.$commandname -text "$commandname: " -anchor w
        grid configure $modifyhal.$commandname -row $j -column 0 -sticky nsew
        for {set i 1} {$i <= $numvars} {incr i} {
            set $commandname$i ""
            entry $modifyhal.e$commandname$i -textvariable $commandname$i \
                -bg white
            bind $modifyhal.e$commandname$i <Button-1> \
                "copyVar $modifyhal.e$commandname$i"
            grid configure $modifyhal.e$commandname$i -row $j -column $i \
                -columnspan $colspan -sticky nsew
        }
        if {$i == "2"} {
            set tmp [subst {$commandname \$${commandname}1}]
        } else {
            set tmp [subst {$commandname \$${commandname}1 \$${commandname}2}]
        }
        button $modifyhal.b$commandname -text [msgcat::mc "Execute"] \
            -command [subst {modHAL "$tmp"}]
        grid configure $modifyhal.b$commandname -row $j -column 3 -sticky nsew
        incr j
    }
    grid configure $moddisplay -row $j -column 0 -columnspan 4 -sticky nsew
}

# modtypes handles highlighting mod entries
array set modtypes {
    comp "$modifyhal.eloadrt1 $modifyhal.eunloadrt1"
    funct "$modifyhal.eaddf1 $modifyhal.edelf1"
    thread "$modifyhal.eaddf1"
    pin "$modifyhal.elinkpp1 $modifyhal.elinkpp2 $modifyhal.elinkps1 \
        $modifyhal.elinksp2 $modifyhal.eunlinkp1"
    sig "$modifyhal.elinkps2 $modifyhal.elinksp1 $modifyhal.enewsig1 \
        $modifyhal.edelsig1"
}

set modlist "$modifyhal.eloadrt1 $modifyhal.eunloadrt1 $modifyhal.eaddf1 $modifyhal.edelf1 $modifyhal.elinkpp1 $modifyhal.elinkpp2 $modifyhal.elinkps1 $modifyhal.elinksp2 $modifyhal.elinkps2 $modifyhal.elinksp1 $modifyhal.enewsig1 $modifyhal.edelsig1 $modifyhal.eunlinkp1"

# Find whether this is ini tuned or hal netlist
proc whichTune {} {
    global top initext haltext thisinifile sectionarray halfilelist \
        thisconfigdir filemenu
    # Make a text widget to hold the ini file
    set initext [text $top.initext]
    set haltext [text $top.haltext]
    $initext config -state normal
    $initext delete 1.0 end
    if {[catch {open $thisinifile} programin]} {
        return 
    } else {
        $initext insert end [read $programin]
        catch {close $programin}
    }
    # setup array with section names and line numbers
    array set sectionarray {}
    scan [$initext index end] %d nl
    set inilastline $nl
    for {set i 1} {$i < $nl} {incr i} {
        if { [$initext get $i.0] == "\[" } {
            set inisectionname [$initext get $i.1 $i.end]
            set inisectionname [string trimright $inisectionname \] ]
            array set sectionarray "$inisectionname $i"
        }
    }

    # Find the HALFILE names between HAL and TRAJ
    set startline $sectionarray(HAL)
    set endline $sectionarray(TRAJ)
    set halfilelist ""
    for {set i $startline} {$i < $endline} {incr i} {
        set thisstring [$initext get $i.0 $i.end]
        if { [lindex $thisstring 0] == "HALFILE" } {
            set thishalname [lindex $thisstring end]
            lappend halfilelist $thisconfigdir/$thishalname
        }
    }

    set tmpret ""
    foreach fname $halfilelist {
        $haltext config -state normal
        $haltext delete 1.0 end
        if {[catch {open $fname} programin]} {
            return
        } else {
            $haltext insert end [read $programin]
            catch {close $programin}
        }
        append tmpret [$haltext search "\]" 1.0 end]
    }

    if {$tmpret == "" } {
        makeNetTune
    } else {
        $filemenu entryconfigure 2 -state normal
        makeIniTune
    }
}

# arg where is frame to build the widgets in what is HAL name
# returns sets with { 
proc makeWidgetSet {where what} {
    

    return $commandset
}

proc makeIniTune {} {
    global axisentry top initext sectionarray thisconfigdir haltext
    global numaxes ininamearray commandarray thisinifile halfilelist
    for {set j 0} {$j<$numaxes} {incr j} {
        global af$j
        set af$j [$top insert [expr $j+3] page$j \
        -text [msgcat::mc "Tune %d" $j]  -raisecmd "selectAxis $j" ]
    }
 
    # label display columns       
    for {set j 0} {$j < $numaxes} {incr j} {
        set col0 [label [set af$j].collabel0 -text [msgcat::mc "INI Name"]]
        set col1 [label [set af$j].collabel1 -text [msgcat::mc "HAL's Value"]]
        set col2 [label [set af$j].space -text "   "]
        set col3 [label [set af$j].collabel3 -text [msgcat::mc "Next Value"]]
        grid $col0 $col1 $col2 $col3 -ipady 5
    }

    foreach fname $halfilelist {
        $haltext config -state normal
        $haltext delete 1.0 end
        if {[catch {open $fname} programin]} {
            return
        } else {
            $haltext insert end [read $programin]
            catch {close $programin}
        }

        # find the ini references in this hal and build widgets        
        scan [$haltext index end] %d nl
        for {set i 1} {$i < $nl} {incr i} {
            set tmpstring [$haltext get $i.0 $i.end]
            if {[lsearch -regexp $tmpstring AXIS] > -1 && ![string match *#* $tmpstring]} { 
                for {set j 0} {$j < $numaxes} {incr j} {
                    if {[lsearch -regexp $tmpstring AXIS_$j] > -1} {
                        # this is a hal file search ordered loop
                        set thisininame [string trimright [lindex [split $tmpstring "\]" ] end ]]
                        set lowername "[string tolower $thisininame]"
                        set thishalcommand [lindex $tmpstring 1]
                        set tmpval [expr [lindex [split \
                            [exec halcmd -s show param $thishalcommand] " "] 3]]
                        global axis$j-$lowername axis$j-$lowername-next
                        set axis$j-$lowername $tmpval
                        set axis$j-$lowername-next $tmpval
                        set thisname [label [set af$j].label-$j-$lowername \
                            -text "$thisininame:  " -width 20 -anchor e]
                        set thisval [label [set af$j].entry-$lowername -width 8 \
                            -textvariable axis$j-$lowername -anchor e -foreg firebrick4 ]
                        set thisentry [entry [set af$j].next-$lowername -width 8 \
                        -width 12 -textvariable axis$j-$lowername-next ]
                        grid $thisname $thisval x $thisentry
                        lappend ininamearray($j) $lowername
                        lappend commandarray($j) $thishalcommand
                        break
                    }
                }
            }
        }
    }
    # build the buttons to control axis variables.
    for {set j 0} {$j<$numaxes } {incr j} {
        set bframe [frame [set af$j].buttons]
        grid configure $bframe -columnspan 4 -sticky nsew 
        set tmptest [button $bframe.test -text [msgcat::mc "Test"] \
            -command {iniTuneButtonpress test}]
        set tmpok [button $bframe.ok -text [msgcat::mc "OK"] \
            -command {iniTuneButtonpress ok} -state disabled  ]
        set tmpcancel [button $bframe.cancel -text [msgcat::mc "Cancel"] \
            -command {iniTuneButtonpress cancel} -state disabled ]
        pack $tmpok $tmptest $tmpcancel -side left -fill both -expand yes -pady 5
    }
}

proc makeNetTune {} {
    global axisentry top initext sectionarray halfilelist
    global ininamearray commandarray thisinifile

    # get all parameters from halcmd.
    set tmparam  [exHAL "list param"]
    # qualify each param by write test
    set pnamelist ""
    set j 0
    foreach pm $tmparam {
        set ret [exHAL "show param $pm"]
        set rwtype [lindex $ret 2]
        if {[string match -W $rwtype]} {
            set error ""
            set val [lindex $ret 3]
            set error [exHAL "setp $pm $val"]
            if {$error == ""} {
                # these are the variables we want to display
                append plist "$pm "
            }
        }
    }

    # notebook tabs, frames for bit, notbit, and action buttons 
    set j 0
    set pagelist ""
    foreach pm $plist {
        scan [split $pm .] {%s %s %s} first second sname
        set pname "$first.$second"
        # make tab pages and a list of pages made
        if { [lsearch $pagelist $pname] == -1} {
            global af$j
            set af$j [$top insert [expr $j+3] page$j -text $pname \
                -raisecmd "selectAxis $j" ]                    
            set bitframe [frame [set af$j].bit]
            set sepframe [frame [set af$j].sep]
            set sep [label $sepframe.l -text "   "]
            pack $sep
            set notbitframe [frame [set af$j].notbit ]
            grid $bitframe $sepframe $notbitframe -sticky nsew
            set bframe [frame [set af$j].buttons]
            set tmptest [button $bframe.test -text [msgcat::mc "Test"] \
                -command {iniTuneButtonpress test}]
            set tmpok [button $bframe.ok -text [msgcat::mc "OK"] \
                -command {iniTuneButtonpress ok} -state disabled  ]
            set tmpcancel [button $bframe.cancel -text [msgcat::mc "Cancel"] \
                -command {iniTuneButtonpress cancel} -state disabled ]
            pack $tmpok $tmptest $tmpcancel -side left -fill both -expand yes -pady 5
            grid configure $bframe -columnspan 3 -sticky nsew 
            incr j
            append pagelist "$pname "
        }
    append list$pname "$pm  "
    }

    # submit each good param name to halcmd save in bit notbit
    foreach pname $pagelist {
        set retbit$pname ""
        set retnotbit$pname ""
        foreach p [set list$pname] {
            set tmp [exHAL "show param $p"]
            set type [lindex $tmp 1]
            if {$type == "bit"} {
                append retbit$pname "$p "
            } else {
                append retnotbit$pname "$p "
            }
        }
    }
    # xx is the name of the page it's fully qualified widget name is
    # [set af[lsearch $pagelist $xx]] where .bit .notbit are frames
    foreach pname $pagelist {
        set bitframe [set af[lsearch $pagelist $pname]].bit
        set notbitframe [set af[lsearch $pagelist $pname]].notbit
        # make checkbutton from each bit variable and grid
        foreach bitvar [set retbit$pname] {
            set bitvar [lindex [split $bitvar . ] end]
            set thisname [checkbutton $bitframe.$bitvar -anchor w  -text $bitvar  \
                -onvalue TRUE -offvalue FALSE -variable cb-$bitvar ]
            grid $thisname -sticky nsew
        }
        # make labels and entry for other variables
        foreach nvar [set retnotbit$pname] {
            set nvar [lindex [split $nvar . ] end]
            set thisname [label $notbitframe.l0$nvar -text "$nvar: " -width 20 -anchor e]
            set thisval [label $notbitframe.l1$nvar   -width 8 \
            -textvariable $pname-$nvar -anchor e -foreg firebrick4 ]
            set thisentry [entry $notbitframe.next-$nvar -width 8 \
                -width 12 -textvariable $pname-$nvar-next ]
            grid $thisname $thisval x $thisentry
        }
        
        

# imhere -- above works

    }
}


proc selectAxis {which} {
    global axisentry
    set axisentry $which
}

proc iniTuneButtonpress {which} {
    global axisentry ininamearray
    set labelname ".main.note.fpage$axisentry.next"
    set basename ".main.note.fpage$axisentry.buttons"
    # which can be (test, ok, cancel)
    switch -- $which {
        test {
            $basename.test configure -state disabled
            $basename.ok configure -state normal
            $basename.cancel configure -state normal
            set entrystate "disabled"
        }
        cancel {
            $basename.test configure -state normal
            $basename.ok configure -state disabled
            $basename.cancel configure -state disabled
            set entrystate "normal"
        }
        ok {
            $basename.test configure -state normal
            $basename.ok configure -state disabled
            $basename.cancel configure -state disabled
            set entrystate "normal"
        }
        default {
        }
    }
    foreach name [set ininamearray($axisentry)] {
        $labelname-$name configure -state $entrystate
    }
    changeIni $which
}

proc changeIni {how } {
    global axisentry sectionarray ininamearray commandarray
    global numaxes main initext
    for {set i 0} {$i<$numaxes} {incr i} {
        global af$i
    }
    switch -- $how {
        cancel {-}
        test {
            set varnames [lindex [array get ininamearray $axisentry] end]
            set varcommands [lindex [array get commandarray $axisentry] end]
            set maxvarnum [llength $varnames]
            # handle each variable and values inside loop 
            for {set listnum 0} {$listnum < $maxvarnum} {incr listnum} {
                set var "axis$axisentry-[lindex $varnames $listnum]"
                global $var $var-next
                # get the values
                set oldval [set $var]
                set newval [set $var-next]
                # get the halcmd string
                set tmpcmd [lindex $varcommands $listnum]
                # use halcmd to set new parameter value in hal
                set thisret [exec halcmd setp $tmpcmd $newval]
                # set the current value for display
                set $var $newval
                # set the tmp value as next in display
                set $var-next $oldval
            }        
        }
        ok {
            set varnames [lindex [array get ininamearray $axisentry] end]
            set varcommands [lindex [array get commandarray $axisentry] end]
            set maxvarnum [llength $varnames]
            # handle each variable and values inside loop 
            for {set listnum 0} {$listnum < $maxvarnum} {incr listnum} {
                set var "axis$axisentry-[lindex $varnames $listnum]"
                global $var $var-next
                # get the values
                set oldval [set $var]
                # set the tmp value as next in display
                set $var-next $oldval
            }        
        }
        quit {
            # build a check for changed values here and ask
            for {set j 0} {$j < $numaxes} {incr j} {
                set oldvals [lindex [array get valarray $j] 1]
                set cmds [lindex [array get commandarray $j] 1]
                set k 0
                foreach cmd $cmds {
                    set tmpval [expr [lindex [split \
                        [exec halcmd -s show param $cmd] " "] 3]]
                    set oldval [lindex $oldvals $k]
                    if {$tmpval != $oldval} {
                        set answer [tk_messageBox \
                            -message [msgcat::mc "The HAL parameter \n \
                            %s \n has changed. \n Really quit?" $cmd] \
                            -type yesno -icon question] 
                        switch -- $answer { \
                                yes exit
                                no {return}
                        }
                    
                    }
                    incr k
                }
            }
            destroy .
        }
        default {}
    }
}

# showmode handles the tab selection of mode
proc showMode {mode} {
    global workmode
    set workmode $mode
    if {$mode=="watchhal"} {
        watchLoop
    }
}

# all clicks on tree node names go into workMode
# oldvar keeps the last HAL variable for refresh
proc workMode {which} {
    global workmode oldvar thisvar newmodvar
    set thisvar $which
    switch -- $workmode {
        showhal {
            showHAL $which
        }
        watchhal {
            watchHAL $which
        }
        modifyhal {
            set newmodvar 0
            setModifyVar $which
        }
        tunehal {
            tuneHAL $which
        }
        default {
            swapDisplay display showhal
            displayThis "Mode went way wrong."
        }
    }
    set oldvar $which
}

# process uses it's own halcmd show so that displayed
# info looks like what is in the Hal_Introduction.pdf
proc showHAL {which} {
    global disp
    if {![info exists disp]} {return}
    if {$which == "zzz"} {
        displayThis [msgcat::mc "Select a node to show."]
        return
    }
    set thisnode $which
    set thislist [split $which "+"]
    set searchbase [lindex $thislist 0]
    set searchstring [lindex $thislist 1]
    set thisret [exec halcmd show $searchbase $searchstring]
    displayThis $thisret
}

proc showEx {what} {
    global showtext
    set str [exHAL $what]
    $showtext delete 1.0 end
    $showtext insert end $str
    refreshHAL
}

set watchlist ""
set watchstring ""
proc watchHAL {which} {
    global watchlist watchstring watching cisp
    if {$which == "zzz"} {
        $cisp create text 40 [expr 1 * 20 + 12] -anchor w -tag firstmessage\
            -text [msgcat::mc "<-- Select a Leaf.  Click on its name."]
        set watchlist ""
        set watchstring ""
        return
    } else {
        $cisp delete firstmessage
    }
    # return if variable is already used.
    if {[lsearch $watchlist $which] != -1} {
        return
    }
    lappend watchlist $which
    set i [llength $watchlist]
    set label [lindex [split $which +] end]
    set tmplist [split $which +]
    set vartype [lindex $tmplist 0]
    set varname [lindex $tmplist end]
    set ret [exHAL "show $vartype $varname"]
    if {[lsearch $ret "bit"] != -1 } {
        $cisp create oval 20 [expr $i * 20 + 5] 35 [expr $i * 20 + 20] \
            -fill firebrick4 -tag oval$i
        $cisp create text 80 [expr $i * 20 + 12] -text $label \
            -anchor w -tag $label
    } else {
        # other gets a text display for value
        $cisp create text 10 [expr $i * 20 + 12] -text "xxxx" \
            -anchor w -tag text$i
        $cisp create text 80 [expr $i * 20 + 12] -text $label \
            -anchor w -tag $label
        }
    set tmplist [split $which +]
    set vartype [lindex $tmplist 0]
    set varname [lindex $tmplist end]
    lappend watchstring "$i $vartype $varname "
    if {$watching == 0} {watchLoop} 
}

# watchHAL prepares a string of {i HALtype name} sets
# watchLoop submits these to halcmd and sets canvas
# color or value based on reply
set watching 0
proc watchLoop {} {
    global cisp watchstring watching workmode
    set watching 1
    set which $watchstring
    foreach var $which {
        scan $var {%i %s %s} cnum vartype varname
        if {$vartype == "sig" } {
            set ret [lindex [exHAL "show $vartype $varname"] 1]
        } else {
            set ret [lindex [exHAL "show $vartype $varname"] 3]
        }
        if {$ret == "TRUE"} {
            $cisp itemconfigure oval$cnum -fill yellow
        } elseif {$ret == "FALSE"} {
            $cisp itemconfigure oval$cnum -fill firebrick4
        } else {
            set value [expr $ret]
            $cisp itemconfigure text$cnum -text $value
        }
    }
    if {$workmode == "watchhal"} {
        after 1000 watchLoop
    } else {
        set watching 0
    }
}

proc watchReset {del} {
    global watchlist cisp
    $cisp delete all
    switch -- $del {
        all {
            watchHAL zzz
            return
        }
        default {
            set place [lsearch $watchlist $del]
            if {$place != -1 } {
            set watchlist [lreplace $watchlist $place]
                foreach var $watchlist {
                    watchHAL $var
                }
            } else {            
                watchHAL zzz
            }
        }
    }
}

# modHAL gets the return from a halcmd and displays it.
proc modHAL {command} {
    global modtext
    set str [exHAL "$command"]
    $modtext delete 1.0 end
    $modtext insert end $str
    # this refresh takes a while on slow boxes.  Might think about 
    # modifying the tree code rather than erase and rebuild.
    refreshHAL
}

set newmodvar ""
proc setModifyVar {which} {
    global modtext treenodes modifyhal modlist modtypes
    # test to see if which is a leaf or node
    set isleaf [lsearch $treenodes $which]
    if {$isleaf == -1} {
        foreach w $modlist {
            $w configure -bg white
        }
        set tmp [split $which +]
        scan $tmp { %s %s } haltype varname
        # setup mode of entry widgets in modifyhal so they match
        # haltype above and so a click on available widget
        # inserts the varname above
        switch -- $haltype {
            pin {
                set str [msgcat::mc "Click a highlighted entry where %s should go." $which]
                set tmp $modtypes(pin)
                foreach widget $tmp {
                [subst $widget] configure -bg lightgreen
                }
            }
            param {
                set str [msgcat::mc "Nothing to be done for parameters here. Try the tuning page"]
            }
            sig {
                set str [msgcat::mc "Click a highlighted entry where %s should go." $which]
                set tmp [lindex [array get modtypes sig] 1]
                foreach widget $tmp {
                    [subst $widget] configure -bg lightgreen
                }
            }
            comp {
                set str [msgcat::mc "Click a highlighted entry where %s should go." $which]
                set tmp [lindex [array get modtypes comp] 1]
                foreach widget $tmp {
                    [subst $widget] configure -bg lightgreen
                }
            }
            funct {
                set str [msgcat::mc "Click a highlighted entry where %s should go." $which]
                set tmp [lindex [array get modtypes funct] 1]
                foreach widget $tmp {
                    [subst $widget] configure -bg lightgreen
                }
            }
            thread {
                set str [msgcat::mc "Click a highlighted entry where %s should go." $which]
                set tmp [lindex [array get modtypes thread] 1]
                foreach widget $tmp {
                    [subst $widget] configure -bg lightgreen
                }
            }
        }            
    } else {
        set str [msgcat::mc "%s is not a leaf, try again" $which]
    }
    $modtext delete 1.0 end
    $modtext insert end $str
}

proc copyVar {var} {
    global thisvar newmodvar
    if {$newmodvar == 0 } {
        set tmpvar [lindex [split $thisvar +] end]
        $var insert 0 $tmpvar
        set newmodvar 1
    }
}


# proc switches the insert and removal of upper right text
# This also removes any modify array variables
proc displayThis {str} {
    global disp
    $disp configure -state normal 
    $disp delete 1.0 end
    $disp insert end $str
    $disp configure -state disabled
}


#----------start up the displays----------
makeShow
makeWatch
makeModify
# makeIniTune
refreshHAL

#----------save config----------
#
# saveHAL prepares files for saving a netlist or using ini to save tune,
# FIXME add edit of ini for netlist and perhaps netini
# Netini replaces parameter values in netlist with ini lookup.
 
proc saveHAL {which} {
    global thisconfigdir thisinifile
    global sectionarray ininamearray commandarray
    global numaxes initext
    
    if {![file writable $thisinifile]} {
        tk_messageBox -type ok -message [msgcat::mc "Not permitted to save here.\n\n \
            You need to copy a configuration to your home directory and work there."] 
        killHalConfig 
    }
    switch -- $which {
        save {
            saveHAL savetune
            saveHAL savenetlist
        }
        savetune {
            for {set i 0} {$i<$numaxes} {incr i} {
                global af$i
            }
            for {set i 0} {$i<$numaxes} {incr i} {
            set varnames [lindex [array get ininamearray $i] end]
                set upvarnames [string toupper $varnames]
                set varcommands [lindex [array get commandarray $i] end]
                set maxvarnum [llength $varnames]
                set sectname "AXIS_$i"
                if {$i == [expr $numaxes-1]} {
                    set endsect EMCIO
                } else {
                    set endsect AXIS_[expr $i+1]
                }
                set sectnum "[set sectionarray($sectname)]"
                set nextsectnum "[set sectionarray($endsect)]"
                $initext configure -state normal
                for {set ind $sectnum} {$ind < $nextsectnum} {incr ind} {
                    switch -- [$initext get $ind.0] {
                        "#" {}
                        default {
                            set tmpstr [$initext get $ind.0 $ind.end]
                            set tmpvar [lindex $tmpstr 0]
                            set tmpindx [lsearch $upvarnames $tmpvar]
                            if {$tmpindx != -1} {
                                set cmd [lindex $varcommands $tmpindx]
                                $initext mark set insert $ind.0
                                set newval [expr [lindex [split \
                                    [exec halcmd -s show param $cmd] " "] 3]]
                                set tmptest [string first "e" $newval]
                                if {[string first "e" $newval] > 1} {
                                    set newval [format %f $newval]
                                }
                                regsub {(^.*=[ \t]*)[^ \t]*(.*)} $tmpstr "\\1$newval\\2" newvar
                                $initext delete insert "insert lineend"
                                $initext insert insert $newvar
                            }
                        }
                    }
                }
                $initext configure -state disabled
            }
            saveFile $thisinifile $initext
        }
        savenetlist {
            set netname [file join $thisconfigdir \
                [lindex [split [file tail $thisinifile] "."] 0]_net.hal]
            set tmphalnet [exec halcmd save]
            saveFile $netname $tmphalnet
        }
        saveandexit {
            # add HAL save here
            saveHAL savetune
            saveHAL savenetlist
            killHalConfig
        }
    }
}

proc saveFile {filename contents} {
    catch {file copy -force $filename $filename.bak}
    if { [catch {open $filename w} fileout] } {
        puts stdout [msgcat::mc "can't save %s" $halconfFilename($name)]
        return
    }
    switch -- [string index $contents 0] {
        "/" {
        # a filename
            puts "I got a filename"
        }
        "." {
            # this is a widget name so get contents  
            puts $fileout [$contents get 1.0 end]
            catch {close $fileout}
        }
        default {
            # assumes that contents is plain text so stuff it away
            puts $fileout $contents
            catch {close $fileout}
        }
    }    
}    




#----------Help processes----------
#
proc showHelp {which} {
    global helpabout helpmain helpcomponent helppin helpparameter
    global helpsignal helpfunction helpthread
    switch -- $which {
        about {displayThis  $helpabout}
        main {displayThis  "find help file"}
        default {I'm lost here in help land}
    }
}

# Help should include files for each of these
# Components Pins Parameters Signals Functions Threads

set helpabout [msgcat::mc "Copyright Raymond E Henry. 2006\nLicense: GPL Version 2\n\nHalconfig is an LinuxCNC configuration tool.  It requires that you have started an instance of linuxcnc.\n\nThis script carries no warranty or liability for its use to the extent allowed by law."]

whichTune
$top raise ps