What is stored in this Tcl variable?

Basics of variables

As others have pointed out, the confusing notation before $ or not $ can be simplified with the following rule.

var is a reference to the variable itself, not its value

$ var gives the value held in the variable

It can get a little more confusing when you start thinking of everything in Tcl as a string (it really isn't, but close enough), so you can store the name of one variable in another and restore its value by reference.

% set foo "hi"
hi
% set bar "foo"
foo
% set $foo
can't read "hi": no such variable
% set $bar
hi

      

        
        
        
      

    

Here, the notation set $foo

is evaluated in a step - first $foo

it gives its value hi

, and then the expression set

(when run without a third argument) tries to return the value held in the variable hi

. It fails. Notation set $bar

follows the same steps, but this time it set

can operate on a value bar

that is equal foo

, and thus returns a value foo

that is equal hi

. (link to API "set")

Initialization

One of the problems with this script is initialization. In Tcl variables does not exist until a value is assigned. It's clear why trying set $foo

above didn't work because there was no variable hi

.

At the top of your script, you are trying to declare a variable with

global colorimetric

      

        
        
        
      

    

which doesn't work because you are already working in the global field. The global "has no effect unless it is executed in the context of the process body." (link to "global" API) You really need to use the command set

to initialize the variable. That's why none of your print attempts colorimetric

to proc finish

not work.

Scale

Another problem you run into in this script is scoping, specifically when mixing global and procedural / local scopes. You are correct if you initialized correctly colorimetric

then the code

puts $::colorimetric ;# print the value of the global variable colorimetric

      

        
        
        
      

    

would work. Another way to achieve this is with

global colorimetric ;# reference a global variable into the local scope
puts $colorimetric  ;# print the value of colorimetric in the local scope

      

        
        
        
      

    

My decision

I would like to present my solution. I admit that I have moved a lot of code and I will give a short explanation of what changes I have implemented to make it more concise.

#!/usr/bin/env wish

# --- default configuration --- #
array set CONF {
    colorimetric "-c"
    spectral     ""
    cfilename    "/path/to/defaultCI.txt"
    sfilename    ""
    x            0
    y            0
    gretagnum    "/dev/ttyS0"
    filter       "-d65"
    baud         "B9600"
}

# --- build the interface --- #
wm title . "Gretag"
ttk::frame .f -borderwidth 5 -relief sunken -padding "5 10"
grid columnconfigure . 0 -weight 1
grid rowconfigure    . 0 -weight 1
grid .f


ttk::label .f.dataLabel -text "Data Type: "
foreach {dtname dttag dtfile} {
    colorimetric "-c" cfilename
    spectral     "-s" sfilename
} {
    lappend mygrid [
        ttk::checkbutton .f.$dtname -text [string totitle $dtname] \
        -variable CONF($dtname) -onvalue $dttag -offvalue "" \
        -command [list getFilename $dtname $dttag $dtfile ]
    ]
}
grid .f.dataLabel {*}$mygrid -sticky w ; set mygrid { }


ttk::label .f.gretagNumLabel -text "Gretag #: "
for {set tty 0} {$tty < 5} {incr tty} {
    lappend mygrid [
        ttk::radiobutton .f.gretagRadio$tty -text [expr $tty + 1] \
        -variable CONF(gretagnum) -value "/dev/ttyS$tty" 
    ]
}
grid .f.gretagNumLabel {*}$mygrid -sticky w ; set mygrid { }


ttk::label .f.sampleSize -text "Sample Size: "
ttk::label .f.samplex -text "X"
ttk::label .f.sampley -text "Y"
ttk::entry .f.x -textvariable CONF(x) -width 5 
ttk::entry .f.y -textvariable CONF(x) -width 5 
grid .f.sampleSize .f.samplex .f.x .f.sampley .f.y


ttk::label .f.filterLabel -text "Filter Type: "
foreach {ftname ftval} {
    D50        "-d50"
    D65        "-d65"
    Unfiltered "-U"
    Polarized  "-P"
} {
    lappend mygrid [
        ttk::radiobutton .f.filterRadio$ftname -text $ftname \
        -variable CONF(filter) -value $ftval
    ]
}
grid .f.filterLabel {*}$mygrid -sticky w ; set mygrid { }


ttk::label .f.baudLabel -text "Baud Rate: "
foreach {baud} {
    4800 9600 19200 38400 57600
} {
    lappend mygrid [
        ttk::radiobutton .f.baudRadio$baud -text $baud \
        -variable CONF(baud) -value "B$baud"
    ]
}
grid .f.baudLabel {*}$mygrid -sticky w ; set mygrid { }


ttk::button .f.submitBtn -text "Submit" -command submit
grid .f.submitBtn -columnspan 6 -sticky we

foreach w [winfo children .f] {
    grid configure $w -padx 5 -pady 5
}
focus .f.colorimetric
bind . <Return> submit

# --- callbacks --- #
proc getFilename {type tag file} {
    global CONF

    if {$CONF($type) eq $tag} {
        set CONF($file) [tk_getOpenFile]
        if {$CONF($file) eq ""} { .f.$type invoke }
    } else {
        set CONF($file) ""
    }
}

proc submit { } {
    global CONF

    exec ./gretag $CONF(colorimetric) $CONF(cfilename) \
        $CONF(spectral) $CONF(sfilename) $CONF(gretagnum) \
        $CONF(x) $CONF(y) $CONF(filter) $CONF(baud)
}

      

        
        
        
      

    

Discussion of changes

1. The first changes I made were to use options -text

in ttk::checkbutton

and ttk::radiobutton

. Of course, with an extra label for them, you can put text in front of the button, but this is non-standard and requires more code.

ttk::label .f.colorimetricLabel -text "Colorimetric"
ttk::checkbutton .f.colorimetric -onvalue "-c" -offvalue "" -command getFilename1

      

        
        
        
      

    

becomes

ttk::checkbutton .f.colorimetric -text "Colorimetric" -onvalue "-c" -offvalue "" -command getFilename1

      

        
        
        
      

    

2. Next, I used the similarities between the two buttons to abstract the creation in foreach. (I do this all the time in my Tcl code for the job.) This creates much easier code to read and allows you to add / remove / replace names and tags for widgets. This results in a slightly more, but much more stylish code.

ttk::checkbutton .f.colorimetric -text "Colorimetric" -onvalue "-c" -offvalue "" -command getFilename1
ttk::checkbutton .f.colorimetric -text "Spectral" -onvalue "-s" -offvalue "" -command getFilename2

      

        
        
        
      

    

becomes

foreach {dtname dttag dtcommand} {
    colorimetric "-c" getFilename1
    spectral     "-s" getFilename2
} {
        ttk::checkbutton .f.$dtname -text [string totitle $dtname] -onvalue $dttag -offvalue "" -command $dtcommand
}

      

        
        
        
      

    

3. The next change was to combine yours getFilename1

and getFilename2

into one procedure getFilename

. We can pass arguments to this function to determine who is calling it. I am using a command list

to generate a call for this new function. (link to list API)

I also started to combine your commands grid

in the widget code itself. It mygrid

stores a list of what to bind to each line in the GUI and then evaluates at the end of each section for GUI distribution on the fly. (grid API link)

The previous code gets the final version and becomes,

foreach {dtname dttag dtfile} {
    colorimetric "-c" cfilename
    spectral     "-s" sfilename
} {
    lappend mygrid [
        ttk::checkbutton .f.$dtname -text [string totitle $dtname] -variable CONF($dtname) -onvalue $dttag -offvalue "" -command [list getFilename $dtname $dttag $dtfile ]
    ]
}

      

        
        
        
      

    

Then the command grid

can be evaluated and the variable mygrid

is cleared after each use!

4. If you noticed, I also added a parameter -variable

to yours, ttk::checkbutton

and at that moment started storing the state of the button in a global variable CONF

. This is a big change.

Tk loves to pollute your global namespace and it's good practice to fight back. I usually add all of my configuration state to a global array and set that at the top of the code so that everyone can go in and change the default state of my code without breaking into it or making find / replace calls or something. Just good practice, so wherever you had a variable, I moved it in CONF

and moved it CONF

up.

array set CONF {
    colorimetric "-c"
    spectral     ""
    cfilename    "/path/to/defaultCI.txt"
    sfilename    ""
    x            0
    y            0
    gretagnum    "/dev/ttyS0"
    filter       "-d65"
    baud         "B9600"
}

      

        
        
        
      

    

5. I then propagated these changes throughout your code. Almost all widget creations have been susceptible to these changes. When it comes to creating a widget, this sometimes made the independent sections of code larger. But it also allowed me to remove the entire grid section by bundling that code into the widget code, as I said, significantly reducing the size and clutter of your code at the cost of additional complexity.

6. The final changes I made were related to your function code. You have a few minor bugs in your code getFilename1

and getFilename2

. The first error was what you want to call tk_getOpenFile

because I am only collecting a capture of the existing filename to pass to gretag

. (link to the 'tk_getOpenFile' API) If you use tk_getOpenFile

, the dialog will ensure that the file exists.

The second error getFilename1

is that the dialog has a button Cancel

, and if the user clicks the cancel button, the dialog returns an empty string. In this case, you need to uncheck the box ttk::checkbutton

and you need to disable the variable CONF(colorimetric)

. Or rather, you need to set CONF(colorimetric)

to a button -offvalue

. You can do this at the same time by sending a click to the current button.

proc getFilename1 {} {
set filename1 [tk_getSaveFile]
}

      

        
        
        
      

    

becomes

proc getFilename {type tag file} {
    global CONF

    if {$CONF($type) eq $tag} {
        set CONF($file) [tk_getOpenFile]
        if {$CONF($file) eq ""} { .f.$type invoke }
    } else {
        set CONF($file) ""
    }
}

      

        
        
        
      

    

In your function, finish

I renamed the function to submit

(sorry) and rewrote it to use the new variable CONF

.

Answer

Of course most of this is unnecessary. I wanted to give you some interesting Tcl / Tk code to think about and at the same time solve your problem. At this point, we should have a dictionary to answer your question.

The reason your variables weren't printed is due to initialization and scope. You should always use -variable

or -textvariable

in widgets that you will need to reference later. I usually initialize my reference variables before creating their containing widgets. So, at the top of your file, if you did,

set colorimetric "-c"
ttk::checkbutton .f.colorimetric -variable colorimetric [...]

      

        
        
        
      

    

Then you could do in the function finish

puts $::colorimetric

      

        
        
        
      

    

In your comment "# here" try adding

puts $ :: gretagNum

:: means a global variable, and the -variable parameter for widgets is always global.

I'm not sure what you want to do, if you end up printing the variable name and not the contents of the variable, use the set command as a function:

set content "hello"

set blah value

if you do:

puts $blah 

      

        
        
        
      

    

.. you get the content of the blah variable, which is the content.

To get the contents of a variable through blah use the following:

puts [set $blah]