1

TCL Structure 20.12.2024

UNIT-5

TCL Structure, syntax, Variables and Data in TCL, Control Flow. Data Structures,
input/output, procedures. strings, patterns, files, Advance TC- Eval, source, exec and up level
commands, Name spaces, trapping errors, event driven programs, making applications
internet aware, Nuts and Bolts Internet Programming, Security Issues, C Interface. Tk-Visual
Tool Kits. Fundamental Concepts of Tk. Tk by example, Events and Binding. Perl-Tk.
TCL:
 TCL stands for "Tool Command Language" and is pronounced "tickle"; is a simple scripting
language for controlling and extending applications.
 TCL is a radically simple open-source interpreted programming language that provides
common facilities such as variables, procedures, and control structures as well as many useful
features that are not found in any other major language.
 TCL runs on almost all modern operating systems such as Unix, Macintosh, and Windows
(including Windows Mobile). While TCL is flexible enough to be used in almost any
application imaginable, it does excel in a few key areas, including: automated interaction with
external programs, embedding as a library into application programs, language design, and
general scripting.
 TCL was created in 1988 by John Ouster out and is distributed under a BSD style license
(which allows you everything GPL does, plus closing your source code).
 The current stable version, in February 2008, is 8.5.1 (8.4.18 in the older 8.4 branch). The
first major GUI extension that works with TCI. is TK, a toolkit that aims to rapid GUI
development. That is why TCL is now more commonly called TCL/TK.
 The language features far-reaching introspection, and the syntax, while simple2, is very
different from the Fortran/Algol/C++/Java world.
 Although TCL is a string based language there are quite a few object-oriented extensions for
it like Snit3. iner Tel4, and XOTc15 to name a few.
 TCL is embeddable: its interpreter is implemented as a library of C procedures that can easily
be incorporated into applications, and each application can extend the core TCL features with
additional commands specific to that application.
 Tel was originally developed as a reusable command language for experimental computer
aided design (CAD) tools. The interpreter is implemented as a C library that could be linked
into any application. It is very easy to add new functions to the TCL interpreter, so it is an
ideal reusable "macro language that can be integrated into many applications. However, TCL
is a programming language in its own right, which can be roughly described as a cross-breed
between
 LISP/Scheme (mainly for its tail-recursion capabilities).
 C (control structure keywords, expr syntax) and
 Unix shells (but with more powerful structuring).

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

2
TCL Structure 20.12.2024

TCL Structure
 The TCL language has a tiny syntax there is only a single command structure, and a set of
rules to determine how to interpret the commands. Other languages have special syntaxes for
control structures (if, while, repeat...) not so in TCL.
 All such structures are implemented as commands. There is a runtime library of compiled "C"
routines, and the 'level' of the GUI interface is quite high.
 TCL Comments: If the first character of a command is #, it is a comment.
 TCL commands: TCL commands are just words separated by spaces. Commands return
strings. and arguments are just further words.
Command argument command
Argument
Spaces are important
expr 5*3 has a single
argument expr 5*3 has three
arguments
TCL commands are separated by a new line, or a semicolon, and arrays are indexed by text
set a(a\ text index) 4

Syntax
Syntax is just the rules how a language is structured. A simple syntax of English could say(Ignoring
punctuation for the moment). A text consists of one or more sentences A sentence consists of one or
more words' Simple as this is. it also describes Tel's syntax very well if you say "script" for "text",
and "command" for "sentence". There's also the difference that a Tel word can again contain a script
or a command.
So {$x < 0} {set x 0} is a command consisting of three words: if, a condition in braces, a command
(also consisting of three words) in braces. Take this for example is a well-formed Tel command: it
calls Take (which must have been defined before) with the three arguments "this", "for", and
"example". It is up to the command how it interprets its arguments,
e.g. puts acos(-1) will write the string "acos(-1)" to the stdout channel, and return the empty string
"", while expr acos(-1) will compute the arc cosine of-1 and return 3.14159265359 (an approximation
of Pi), or string length acos(-1) will invoke the string command, which again dispatches to its length
sub-command, which determines the length of the second argument and returns 8.A Tel script is a
string that is a sequence of commands, separated by newlines or semicolons. A command is a string
that is a list of words, separated by blanks. The first word is the name of the command; the other
words are passed to it as its arguments.
In Tel, "everything is a command" even what in other languages would be called declaration,
Definition, or control structure. A command can interpret its arguments in any way it wants in
particular, it can implement a different language, like expression. A word is a string that is a simple
word, or one that begins with and ends with the matching) (braces), or one that begins with" and ends

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

3
TCL Structure 20.12.2024

with the matching". Braced words are not evaluated by the parser. In quoted words, substitutions can
occur before the command is called: S[A-Za-z0-9_]+ substitutes the value of the given variable. Or,
if the variable name contains characters outside that regular expression, another layer of bracing helps
the parser to get it right
puts "Guten Morgen. ${Schuler}!"
If the code would say SSchuler, this would be parsed as the value of variable SSch, immediately
followed by the constant string üler. (Part of) a word can be an embedded script: a string in [] brackets
whose contents are evaluated as a script (see above) before the current command is called.In short:
Scripts and commands contain words. Words can again contain scripts and commands. (This can lead
to words more than a page long...) Arithmetic and logic expressions are not part of the Tei language
itself, but the language of the expr command (also used in some arguments of the if, for, while
commands) is basically equivalent to C's expressions, with infix operators and functions.

Rules of TCL
The following rules define the syntax and semantics of the Tel language:
(1) Commands A Tel script is a string containing one or more commands. Semi-colons and newlines
are command separators unless quoted as described below. Close brackets are command terminators
during command substitution (see below) unless quoted.
(2) Evaluation A command is evaluated in two steps. First, the Tel interpreter breaks the command
into words and performs substitutions as described below. These substitutions are performed in the
same way for all commands. The first word is used to locate a command procedure to carry out the
command, then all of the words of the command are passed to the command procedure. The command
procedure is free to interpret each of its words in any way it likes, such as an integer, variable name,
list, or Tcl script. Different commands interpret their words differently.
(3) Words of a command are separated by white space (except for newlines, which are command
separators).
(4) Double quotes If the first character of a word is double-quote (") then the word is terminated by
the next double-quote character. If semi-colons, close brackets, or white space characters (including
newlines) appear between the quotes then they are treated as ordinary characters and included in the
word. Command substitution, variable substitution, and backslash substitution are performed on the
characters between the quotes as described below. The double-quotes are not retained as part of the
word.
(5) Braces If the first character of a word is an open brace (() then the word is terminated by the
matching close brace (1). Braces nest within the word: for each additional open brace there must he
an additional close brace (however, if an open brace or close brace within the word is quoted with a
backslash then it is not counted in locating the matching close brace). No substitutions are performed
on the characters between the braces except for backslash-newline substitutions described below, nor
do semi-colons, newlines, close brackets, or white space receive any special
interpretation. The word will consist of exactly the characters between the outer braces, not including
the braces themselves.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

4
TCL Structure 20.12.2024

(6) Command substitution If a word contains an open bracket (1) then Tel performs command
substitution. To do this it invokes the Tel interpreter recursively to process the characters following
the open bracket as a Tel script. The script may contain any number of commands and must be
terminated by a close bracket (1). The result of the script (ie. the result of its last command) is
substituted into the word in place of the brackets and all of the characters between them. There may
be any number of command substitutions in a single word. Command
(7) Variable substitution If a word contains a dollar-sign (S) then Tel performs variable substitution:
the dollar-sign and the following characters are replaced in the word by the value of a variable.
Variable substitution may take any of the following forms:
$name
Tel: the Tool Command language
Name is the name of a scalar variable; the name is a sequence of one or more characters that are a
letter, digit, underscore, or namespace separators (two or more colons).
$name(index)
Name gives the name of an array variable and index gives the name of an element within that array.
Name must contain only letters, digits, underscores, and namespace separators, and may be an empty
string.
Command substitutions, variable substitutions, and backslash substitutions are performed on the
characters of index.
$(name)
Name is the name of a scalar variable. It may contain any characters whatsoever except for close
braces. There may be any number of variable substitutions in a single word. Variable substitution is
not performed on words enclosed in braces.
(8) Backslash substitution If a backslash (1) appears within a word then backslash substitution occurs.
In all cases but those described below the backslash is dropped and the following character is treated
as an ordinary character and included in the word. This allows characters such as double quotes, close
brackets, and dollar signs to be included in words without triggering special processing. The
following table lists the backslash sequences that are handled specially, along with the value that
replaces each sequence.
\a
Audible alert (bell) (0x7).
\b
Backspace (0x8).
\f.
Form feed (0xc).
\n
Newline (Oxa).

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

5
TCL Structure 20.12.2024

\n
Carriage-return (Oxd).
\t
Tab (0x9).
\v
Vertical tab (Oxb).
\<newline>whitespce
A single space character replaces the backslash, newline, and all spaces and tabs after the newline.
This backslash sequence is unique in that it is replaced in a separate pre-pass before the command is
actually parsed. This means that it will be replaced even when it occurs between braces, and the
resulting space will he treated as a word separator if it isn't in braces or quotes.
Contents
Literal backslash (\), no special effect.
\000
The digits ooo (one, two, or three of them) give an eight-bit octal value for the Unicode. character
that will be inserted. The upper bits of the Unicode character will be 0.
\hh
The hexadecimal digits hh give an eight-bit hexadecimal value for the Unicode character that will be
inserted. Any number of hexadecimal digits may be present: however, all but the last two are ignored
(the result is always a one-byte quantity). The upper bits of the Unicode character will be 0.
\uhhhh
The hexadecimal digits hhhh (one, two, three, or four of them) give a sixteen-bit hexadecimal value
for the Unicode character that will be inserted. Backslash substitution is not performed on words
enclosed in braces, except for backslash newline as described above.
(9) Comments If a hash character (#) appears at a point where Tel is expecting the first character of
the first word of a command, then the hash character and the characters that follow it, up through the
next newline, are treated as a comment and ignored. The comment character only has significance
when it appears at the beginning of a command.
(10) Order of substitution Each character is processed exactly once by the Tel interpreter as part of
creating the words of a command.
For example, if variable substitution occurs then no further substitutions are performed on the value
of the variable; the value is inserted into the word verbatim. If command substitution occurs then the
nested command is processed entirely by the recursive call to the Tel interpreter, no substitutions are
performed before making the recursive call and no additional substitutions are performed on the result
of the nested script. Substitutions take place from left to right, and each substitution is evaluated
completely before attempting to evaluate the next. Thus, a sequence like set y [set x 0][iner x][iner
x] will always set the variable y to the value, 012.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

6
TCL Structure 20.12.2024

(11) Substitution and word boundaries Substitutions do not affect the word boundaries of a command.
For example, during variable substitution the entire value of the variable becomes part of a single
word, even if the variable's value contains spaces.

Variables and Data in TCL

 As noted above, by default, variables defined inside a procedure are "local" to that procedure.
And, the argument variables of the procedure contain local "copies" of the argument data
used to invoke the procedure
 These local variables cannot be seen elsewhere in the script, and they only exist while the
procedure is being executed. In the "getAvg" procedure above, the local variables created in
the procedure are "n" "r" and "avg".
 TCL provides two commands to change the scope of a variable inside a procedure.
 The "global" command and The "upvar" command.
 The "global" command is used to declare that one or more variables are not local to any
procedure.
 The value of a global variable will persist until it is explicitly changed. So, a variable which
is declared with the "global" command can be seen and changed from inside any procedure
which also declares that variable with the "global command.
 Variables which are defined outside of any procedure are automatically global by default. The
TCL "global" command declares that references to a given variable should be global rather
than local, However, the "global" command does not create or set the variable... this must be
done by other means most commonly by the TCL "set" command.
 For example, here is an adjusted version of our averaging procedure which saves the input
list length in the global variable "currentLength" so that other parts of the script can access
this information after "getAvgN" is called:
proc getAvgN (rList }\
{
global currentLength
set currentl.ength [llength $rList]
if (!$currentl.ength) (return 0.01
set avg 0.0
foreach r $rList
set avg [expr $avg + $r]
}
set avg [expr $avg/double($currentLength)]
return $avg
}
Then, this adjusted version "getAvgN" could be used elsewhere as follows
global currentLength

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

7
TCL Structure 20.12.2024

set thisList "1.0 2.0 3.0"

set a [getAvgN $thisList]
puts "List: $thisList Length: $currentLength Avg: $a"

We can also use global variables as an alternative to procedure arguments. For example, we can make
a version of our averaging application which assumes that the input list is stored in a global variable
called "currentList"
proc getCurrentAvg {}\
{
global current List currentLength
set currentl.ength [llength $rl.ist]
if [ ! $currentLength) [return 0.0]
set avg 0.0
fore
set avg [expr $avg/double($currentLength)]
return $avg
}
Then, this adjusted version "getCurrentAvg" could be used elsewhere as follows
global currentList currentLength
set current List "1.10 2.0 3.0"
set a [getCurrent Avg)
puts "List: $currentList Len: $currentlLength Avg: $a"
A procedure can use global variables for persistent storage of information, including the possibility
to test whether the procedure has been called previously; this is useful for procedures that might need
to perform a one-time initialization. In these cases, a procedure will use a global variable which is
not set anywhere else. This means, the first time the procedure is called, the global variable will not
yet exist (recall that the "global" statement declares that a variable will be accessed as a global
variable, but it does not define or create the variable itself).
The TCL command "info exists" will evaluate to true if the given variable exists. For example,
suppose we wanted to make a version of our procedure "getAvg" which keeps an internal count of
how many times it has been called. In this version, we use a global variable named "callCount
getAvg" to keep track of the number of times "getAvg" is called. Because this global variable will
actually be used to store information for the specific use of the "getAvg" procedure, we need to
choose a global variable name which will not be used for a similar purpose in some other procedure.
The first time "getAvg" is called, the global variable does not yet exist, and must be set to zero

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

8
TCL Structure 20.12.2024

proc getAvg (rList }\

{
global callCount_getAvg
if [![info exists callCount_getAvg})\
{
set callCount_getAvg 0
}
iner callCount_getAvg
puts "get Avg has been called $callCount_getAvg times"
set n [llength SrList]
if (!$n)
{return 0.01
set avg 0.0
foreach r $rList \
{
set avg [expr $avg + $r]
}
set avg [expr $avg/double($n)]
return $avg
}
A more flexible way to manipulate persistent data is to use global arrays rather than scalar variables.
For example, instead of the procedure-specific scalar variable "callCount_getAvg" used above, we
can use a general-purpose array "callCount()" which could be used to record the call counts of any
number of procedures, by using the procedure name as the array index. Many nmrWish TCL scripts
use global arrays in this fashion, to simplify the sharing of many data values between procedures.
Here is a version of the "getAvg" procedure with the call count tallied in a global array location...
note that an array is declared global simply by listing its name in a "global" command, exactly as for
a scalar variable; no () parenthesis or index values are used.
proc getAvg { List } \
{
global callCount
if {![info exists callCount(getAvg)]} \
{

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

9
TCL Structure 20.12.2024

set callCount(getAvg) 0
}
iner callCount(getAvg).
puts "get Avg has been used $callCount(getAvg) times"
set n [llength SrList]
if (!$n) (return 0.01
set avg 0.0
foreach r $rList
{
set avg [expr Savg + $r]
{
set avg expr Savg/double($n)]
}
return Savg
}

TCL Variable Scope and the upvar Command

We have already seen that TCL procedures can generate a return value as a way to pass information
back to their caller. And, we have also seen that global variables can be used to share information
between parts of a TCL script, and so these also serve as a mechanism for returning information to a
caller. TCL includes the "upyar" command as a method for a given procedure to change the values
of variables in the scope of its caller. This provides a way for a procedure to provide additional
information to the caller, besides by using the procedure's return value.
We can also use global variables as an alternative to procedure arguments. For example, we can make
a version of our averaging application which assumes that the input list is stored in a global variable
called "currentList"
proc getCurrentAvg ||\
global current List currentLength
set currentl.ength [llength Srl.ist]
if [ !ScurrentLength) [return 0.0]
set avg 0.0
fore
set avg [expr $avg/double($currentLength)]
return $avg

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

10
TCL Structure 20.12.2024

}
Then, this adjusted version "getCurrentAvg" could be used elsewhere as follows
global currentList currentLength
set current List "1.10 2.0 3.0"
set a [getCurrent Avg)
puts "List: ScurrentList Len: ScurrentlLength Avg: Sa"

In the "upvar" scheme,

 A procedure's caller provides the names of one or more of its own variables as arguments to
the procedure.
 The procedure then uses the "upvar" command to map these variables from the caller onto
variables in the procedure.
 For example, here the caller passes its variable name "count" as the first argument to
procedure "getNAvg":
set count 0
set a [getNAvg count "1.0 2.0 3.0.4.0"]
Then, in this version of procedure "getNArg" the "upvar" command is used to map the first argument
value "SnPtr" onto the procedure's variable called "n"... this means that whenever the procedure gets
or changes the value of variable "n" it will actually be using the caller's variable "count".
proc getNAvg | nPtr rList }\ {
upvar $nPtr n
set n length $rList)
if (!$n) (return 0.01
set avg 0.0
foreach r $rList \ {
set avg [expr $avg + $r]
}
set avg [expr $avg/double($n)]
return $avg
}
Control Flow: In Tel language there are several commands that are used to alter the flow of a
program. When a program is run, its commands are executed from the top of the source file to the
bottom. One by one. This flow can be altered by specific commands. Commands can be executed
multiple times. Some commands are conditional. They are executed only if a specific condition is
met.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

11
TCL Structure 20.12.2024

The if command
The if command has the following general form:
expr1 "then? bodyl elseif expr2 "then? body2 elseif... ?else? "bodyN" if
The if command is used to check if an expression is true. If it is true, a body of command(s) is then
executed. The body is enclosed by curly brackets,
The if command evaluates an expression. The expression must return a boolean value. In Tel,
1. yes, true mean true and 0. no, false mean false.
!/usr/bin/tclsh
if yes {
puts "This message is always shown"
}
In the above example, the body enclosed by {} characters is always executed.
#!/usr/bin/tclsh
if true then{
puts "This message is always shown"
}
The then command is optional. We can use it if we think, it will make the code more clear. We can
use the else command to create a simple branch. If the expression inside the square brackets following
the if command evaluates to false, the command following the else command is automatically
executed.
#!/usr/bin/tclsh
set sex female if {$sex "male"}
{
puts "It is a boy"
}else {
puts "It is a girl"
}
We have a sex variable. It has "female" string. The Boolean expression evaluates to false and we get
"It is a girl" in the console.
$/girlboy.tcl
It is a girl

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

12
TCL Structure 20.12.2024

We can create multiple branches using the elseif command. The elseif command tests for another
condition, if and only if the previous condition was not met. Note that we can use multiple elseif
commands in our tests.
#!/usr/bin/tclsh
#nums.tcl
puts -nonewline "Enter a number: "
flush stdout
set a [gets stdin]
if{$a < 0}
{
puts "the number is negative"
} elseif {$a==0}
{
puts "the numer is zero" } else
{

puts "the missing

}
In the above script we have a prompt to enter a value. We test the value if it is a negative number or
positive or if it equals to zero. If the first expression evaluates to false, the second expression is
evaluated. If the previous conditions were not met, then the body following the else commands would
be executed.
$./nums.tcl
Enter a number: 2
the number is positive
$./nums.tcl
Enter a number: 0
the numer is zero
$/nums.tcl
Enter a number: -3
the number is negative
Running the example multiple times.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

13
TCL Structure 20.12.2024

Switch command
The switch command matches its string argument against each of the pattern arguments in order. As
soon as it finds a pattern that matches the string it evaluates the following body argument by passing
it recursively to the Tel interpreter and returns the result of that evaluation. If the last pattern argument
is default then it matches anything. If no pattern argument matches string and no default is given,
then the switch command returns an empty string.
#!/usr/bin/tclsh
#switch_cmd.tcl
puts-nonewline "Select a top level domain name:"
flush stdout
gets stdin domain
switch $domain
us { puts "United States"}
de { puts Germany }
sk (puts Slovakia
hu { puts Hungary }
default { puts "unknown" }
}
In our script, we prompt for a domain name. There are several options. If the value equals for example
to us the "United States" string is printed to the console. If the value does not match to any given
value, the default body is executed and unknown is printed to the console.
$./switch_cmd.tcl
Select a top level domain name:sk
$lovakia
We have entered sk string to the console and the program responded with Slovakia, While command:
The while command is a control flow command that allows code to be executed repeatedly based on
a given Boolean condition. The while command executes the commands inside the block enclosed
by curly brackets. The commands are executed each time the expression is evaluated to true.
#!/usr/bin/tclsh
#whileloop.tcl
set i 0
set sum 0
while $i<10 }
{

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

14
TCL Structure 20.12.2024

iner i incr sum $i }

puts $sum
In the code example, we calculate the sum of values from a range of numbers. The while loop has
three parts: initialization, testing, and updating. Each execution of the command is called a cycle.
set 10
We initiate the i variable. It is used as a counter.
while {$i<10}
{
……………
}
The expression inside the curly brackets following the while command is the second phase, the
testing. The commands in the body are executed, until the expression is evaluated to false.
incr i
The last, third phase of the while loop is the updating. The counter is incremented. Note that improper
handling of the while loops may lead to endless cycles.

FOR command: When the number of cycles is know before the loop is initiated, we can use the for
command. In this construct we declare a counter variable, which is automatically increased or
decreased in value during each repetition of the loop.
#!/usr/bin/tclsh
for {set i 0} {$i < 10} {incr i}
{
puts $i
}
In this exam,
for (set ($i < 10) {incr )
In this example, we print numbers 0..9 to the console.
for {set 10} {$i < 10} {incr i)
{
puts $i
}

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

15
TCL Structure 20.12.2024

There are three phases. First, we initiate the counter i to zero. This phase is done only once. Next
comes the condition. If the condition is met, the command inside the for block is executed. Then
comes the third phase: the counter is increased. Now we repeat phases 2 and 3 until the condition is
not met and the for loop is left. In our case, when the counter i is equal to 10, the for loop stops
executing.
$./forloop.tcl
0
1
2
3
4
5
7
8
9
Here we see the output of the forloop.tel script.
The foreach command: The foreach command simplifies traversing over collections of data. It has
no explicit counter. It goes through a list element by element and the current value is copied to a
variable defined in the construct.
#!/usr/bin/tclsh
set planets {Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune}
foreach planet $planet
{
puts $planet
}
In this example, we use the foreach command to go through a list of planets.
foreach planet $planets
{
puts $planet
}
The usage of the foreach command is straightforward. The planets is the list that we iterate through.
The planet is the temporary variable that has the current value from the list. The for each command
goes through all the planets and prints them to the console.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

16
TCL Structure 20.12.2024

$./planets.tcl
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune
Running the above Tel script gives this output.
#!/usr/bin/tclsh
set actresses Rachel Weiss Scarlett Johansson Jessica Alba
Marion Cotillard Jennifer Connelly}
foreach (first second) $actresses
puts "$first $second"
In this script, we iterate througn pairs of values of a list.
foreach (first second) $actresses
puts "$first $second"
}
We pick two values from the list at each iteration.
$ Jactresses.tel
Rachel Weiss
Scarlett Johansson
Jessica Alb
Marion Cotillard
Jennifer Connelly
This is the output of actresses tel script
#!/usr/bin/tclsh
foreach i {one two three } item {car coins rocks}
puts "$i $item" }

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

17
TCL Structure 20.12.2024

We can iterate over two lists in parallel.

$ ./parallel.tcl
one car
two coins
three rocks
This is the output of the parallel.tel script.
The break and continue commands: The break command can be used to terminate a block defined
by while, for, or switch commands.
#!/usr/bin/tclsh
while true
set r [expr 1 + round(rand()*30)]
puts-nonewline " $r"
if[ $r == 22} {break}
}
puts" ”
We define an endless while loop. We use the break command to get out of this loop. We choose a
random value from 1 to 30 and print it. If the value equals to 22, we finish the endless while loop.
set r [expr 1 + round(rand()*30)]
Here we calculate a random number between 1..30. The rand() is a built-in Tel procedure. It returns
a random number from 0 to 0.99999. The rand()*30 returns a random number between 0 to 29.99999.
The round() procedure rounds the final number.$/breakcommand.tcl 28 20 8 8 12 22.We might get
something like this. The continue command is used to skip a part of the loop and continue with the
next iteration of the loop. It can be used in combination with for and while commands. In the
following example, we will print a list of numbers that cannot be divided by 2 without a remainder.
#!/usr/bin/tclsh
set num 0
while {Snum 100}
incr num
if {Snum%2==0) {continue}
puts " $num"
}
Puts “ ”
We iterate

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

18
TCL Structure 20.12.2024

if (Snum%20] {continue]
If the expression num 2 returns 0, the number in question can be divided by 2. The continue command
is executed and the rest of the cycle is skipped. In our case, the last command of the loop is skipped
and the number is not printed to the console. The next iteration is started.

Data Structures
 The list is the basic Tcl data structure.
 A list is simply an ordered collection of stuff, numbers. words, strings, or other lists.
 Even commands in Tcl are just lists in which the first list entry is the name of a proc, and
subsequent members of the list are the arguments to the proc.
 Lists can be created in several way by setting a variable to be a list of values set lst (item 11)
(item 2) (item 31) with the split command set Ist [split "item 1.item 2.item 3" "."} with the
list command, set lst [list "item 1" "item 2" "item 3" An individual list member can he
accessed with the index command. The brief description of these commands is.
list ?arg1? ?arg2?... ?argN?
makes a list of the arguments
split string "splitChars?
Splits the string into a list of items wherever the splitChars occur in the code. SplitChars defaults to
being whitespace. Note that if there are two or more splitChars then each one will be used individually
to split the string. In other words: split "1234567" "36" would return the following list: (12 45
7).lindex list index Returns the index'th item from the list.
Note: lists start from 0, not 1, so the first item is at index 0, the second item is at index 1. and so
on.llength list. Returns the number of elements in a list. The items in list can be iterated through using
the foreach command.foreach varname list body The foreach command will execute the body code
one time for each list item in list. On each pass, varname will contain the value of the next list item
In reality, the above form of foreach is the simple form, but the command is quite powerful. It will
allow you to take more than one variable at a time from the list: foreach [a b] Slistofpairs |... ]. You
can even take a variable at a time from multiple lists! For example: foreach a $listOfA b $listOfB
{...}
Examples
set x "a b c"
puts "Item at index 2 of the list ($x) is: [lindex $x 2]\n"
set y [split 7/4/1776 "/"]
puts "We celebrate on the [lindex $y 11'th day of the [lindex $y Ol'th month\n"
set z [list puts "arg 2 is $y"]
puts "A command resembles: Szin"
set i 0

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

19
TCL Structure 20.12.2024

foreach j $x
{
puts " $j is item number $i in list x"
incr i
}
Adding and deleting members of a list
The commands for adding and deleting list members are
concat ?argl arg2... argn?
Concatenates the args into a single list. It also eliminates leading and trailing spaces in the args and
adds a single separator space between args. The argsto concat may be either individual elements, or
lists. If an arg is already a list, the contents of that list is concatenated with the other args. lappend
list Name 7arg1 arg2 each are as a list element. argn? Appends the args to the list listName treating
linsert list Name index arg1 ?arg2... argn Returns a new list with the new list elements inserted just
before the index th element of listName. Each element argument will hecome a separate element of
the new list. If index is less than or equal to zero, then the new elements are inserted at the beginning
of the list. If index has the value end, or if it is greater than or equal to the number of elements in the
list, then the new elements are appended to the list. Ireplace list Name first last ?arg1 argn Returns a
new list with N elements of listName replaced by the args. If first is less than or equal to 0, lreplace
starts replacing from the first element of the list. If first is greater than the end of the list, or the word
end, then Ireplace behaves like lappend. If there are fewer args than the number of positions between
first and last, then the positions for which there are no args are deleted. lset varName index newValue
The Iset command can be used to set elements of a list directly, instead of using Ireplace. Lists in Tel
are the right data structure to use when you have an arbitrary number of things, and you'd like to
access them according to their order in the list. In C, you would use an array. In Tel, arrays are
associated arrays hash tables, as you'll see in the coming sections. If you want to have a collection of
things, and refer to the Nth thing (give me the 10th element in this group of numbers), or go through
them in order via foreach. Take a look at the example code. and pay special attention to the way that
sets of characters are grouped into single list elements.
Example
set b [list a b {c d e {f{g h}}]
puts "Treated as a list: $b\n"
set b [split "a b {c d e} {f{g h}}"]
puts "Transformed by split: $b\n"
set a [concat a b { cde} {f{gh}}]
puts "Concated: $ain"

lappend a [ij K lm )

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

20
TCL Structure 20.12.2024

#Note: [ij K lm) is a single element

puts "After lappending: $a\n"
set b [linsert $a 3 "123"]
#"123" is a single element
puts "After linsert at position 3: $b\n"
set b [lreplace $b 3 5 "AA" "BB"]
puts "After lreplacing 3 positions with 2 values at position 3: Sb\n
More list commands - lsearch, lsort, Irange
Lists can be searched with the lsearch command, sorted with the lsort command, and a range of list
entries can be extracted with the lrange command.
lsearch list pattern
Searches fist for an entry that matches pattern, and returns the index for the first match, or a-1 if there
is no match. By default, lscarch uses "glob" patterns for matching. See the section on globbing.
lsort list
Sorts fist and returns a new list in the sorted order. By default, it sorts the list into alphabetic order.
Note that this command returns the sorted list as a result, instead of sorting the list in place. If you
have a list in a variable, the way to sort it is like so: set lst [lsort $ist] lrange list first last
Returns a list composed of the first through last entries in the list. If first is less than or equal to 0, it
is treated as the first list element. If fast is end or a value greater than the number of elements in the
list, it is treated as the end. If first is greater than last then an empty list is returned.
Example
set list [list {Washington 1789} {Adams 1797} {Jefferson 1801}1 {Madison 1809}
{Monroe 1817} {Adams 1825}]
set x [lsearch $list Washington"]
set y [lsearch $list Madison"]
incr x
#Set range to be not-inclusive
incr y -1
set subsetlist [Irange $list $x $y]
puts "The following presidents served between Washington and Madison"
foreach item $subsetlist {
puts "Starting in (lindex $item 1]: President [lindex $item 01] "
}

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

21
TCL Structure 20.12.2024

set x [Isearch $list Madison"]

set srtlist [Isort $list]
set y [Isearch $srtlist Madison*]
puts "In $x Presidents came before Madison chronologically"
puts "Sy Presidents came before Madison alphabetically"

Input / Output
 Tcl uses objects called channels to read and write data.
 The channels can be created using the open or socket command.
 There are three standard channels available to Tcl scripts without explicitly creating them.
 They are automatically opened by the OS for each new application.
 They are stdin, stdout and stderr. The standard input, stdin, is used by the scripts to read data.
The standard output, stdout, is used by scripts to write data.
 The standard error, stderr, is used by scripts to write error messages. In the first example, we
will work with the puts command. It has the following synopsis:
puts ?-nonewline? ?channelId? string
The channelId is the channel where we want to write text. The channelld is optional. If not specified,
the default stdout is assumed.
#!/usr/bin/telsh
puts "Message 1"
puts stdout "Message 2"
puts stderr "Message 3"
The puts command writes text to the channel.
puts "Message 1"
puts stdout "Message 2"
puts stderr "Message 3"
If we do not specify the channelld, we write to stdout by default. This line does the same thing as the
previous one. We only have explicitly specified the channelld.
We write to the standard error channel. The error messages go to the terminal by default.
$./printing.tcl
Message 1
Message 2
Message 3.
Example output.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

22
TCL Structure 20.12.2024

The read command: The read command is used to read data from a channel. The optional argument
specifies the number of characters to read. If omitted, the command reads all of the data from the
channel up to the end.
#!/usr/bin/tclsh
set c [read stdin 1
while ($c != "q")
{
puts -nonewline "$c"
set e [read stdin 1]
}
The script reads a character from the standard input channel and then writes it to the standard output
until it encounters the q character.
output until it encounters the q character.
set c [read stdin 1]
We read one character from the standard input channel (stdin).
while ($c != "q"} {
We continue reading characters until the q is pressed.
The gets command
The gets command reads the next line from the channel, returns everything in the line up to
(but
not including) the end-of-line character.
#!/usr/bin/tclsh
puts -nonewline "Enter your name: "
flush stdout
set name [gets stdin]
puts "Hello $name"
The script asks for input from the user and then prints a message. The puts command is used to print
messages to the terminal. The no newline option suppresses the new line character. Tcl buffers output
internally, so characters written with puts may not appear immediately on the output file or device.
The flush command forces the output to appear immediately.
puts-no newline "Enter your name: "
flush stdout
set name [gets stdin)

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

23
TCL Structure 20.12.2024

The gets command reads a line from a channel.

$./hello.tcl
Enter your name: Jan
Hello Jan
Sample output of the script.
The pwd and ed commands
Tcl has pwd and ed commands, similar to shell commands. The pwd command returns the current
working directory and the ed command is used to change the working directory.
#!/usr/bin/tclsh
set dir [pwd]
puts $dir
cd..
set dir [pwd]
puts $dir
In this script, we will print the current working directory. Then we change the working directory and
print the working directory again.
set dir [pwd]
The pwd command returns the current working directory.
cd...
We change the working directory to the parent of the current directory. We use the cd command.
$./ewd.tel
/home/janbodnar/prog/tc/io /home/janbodnar/prog/tel
Sample output,
The glob command
Tcl has a glob command which returns the names of the files that match a pattern.
#!/usr/bin/tcIsh
set files glob "tcl]

foreach file $files

puts $file
}

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

24
TCL Structure 20.12.2024

The script prints all files with the tcl extension to the console. The glob command returns a list of
files that match the tcl pattern.
set files [glob "tcl]
foreach file $files
puts $file
We go through the list of files and print each item of the list to the console.
$./globemd.tcl
attributes.tcl
allfiles. tcl
printing. tcl
hello. tcl
read. tcl
files. tcl
globemd. tcl
write2file tcl
cwd. tcl
readfile. tcl
isfile. tcl
addnumbers. tcl

Procedures
 A procedure is a code block containing a series of commands.
 Procedures are called functions in many programming languages. It is a good programming
practice for procedures to do only one specific task.
 Procedures bring modularity to programs.
The proper use of procedures brings the following advantages

 Reducing duplication of code

 Decomposing complex problems into simpler pieces
 Improving clarity of the code
 Reuse of code
 Information hiding
 There are two basic types of procedures: built-in procedures and user defined ones.
The built- in procedures are part of the Tel core language. For instance, the rand(), sin() and exp()
are built-in procedures.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

25
TCL Structure 20.12.2024

 The user defined procedures are procedures created with the proc keyword. The proc
keyword is used to create new Tel commands. The term procedures and commands are often
used interchangeably.
We start with a simple example.
#!/usr/bin/tclsh
proc tclver {}
{
set v [info tclversion]
puts "This is Tcl version $v"
}
tclver
In this script, we create a simple tclver procedure. The procedure prints the version of Tel language.
proc tclver {}
The new procedure is created with the proc command. The {} characters reveal that the procedure
takes no arguments.
set v [info tclversion]
puts "This is Tel version $v’’
tclver
This is the body of the tclver procedure. It is executed when we execute the tclver command. The
hody of the command lies between the curly brackets. The procedure is called by specifying its name.
$. /version.tcl
This is Tcl version 8.6
Sample output.

Procedure arguments:
 An argument is a value passed to the procedure.
 Procedures can take one or more arguments. If procedures work with data, we must pass the
data to the procedures.
 In the following example, we have a procedure which takes one argument.
#!/usr/bin/tclsh
proc ftc (f)
{
return [expr $f9/5 + 321
}

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

26
TCL Structure 20.12.2024

puts [ftc 100]

puts [ftc 0]
puts [ftc 30]
We create a ftc procedure which transforms Fahrenheit temperature to Celsius temperature. The
procedure takes one parameter. Its name will be used in the body of the procedure.
proc ftc [1] {
return [expr $f * 9/5+32]
puts [ftc 100]
We compute the value of the Celsius temperature. The return command returns the value to the caller.
If the procedure does not execute an explicit return, then its return value is the value of the last
command executed in the procedure's body. The fte procedure is executed. It takes 100 as a
parameter. It is the temperature in Fahrenheit. The returned value is used by the puts command, which
prints it to the console. Output of the example.
$. /fahrenheit.tcl 212 32 86
Next we will have a procedure which takes two arguments.
#!/usr/bin/tclsh
proc maximum (x y)
{
if ($x > $y)
{
return $x
}
Else
{
return $y
}
set a 23
set b 32
set val [maximum $a $b]
puts "The max of $a, $b is $val"
The maximum procedure returns the maximum of two values. The method takes two arguments.
proc maximum (x y)

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

27
TCL Structure 20.12.2024

if { $x > $y }
{
return $x
}
Else
{
return $y
}
Here we compute which number is greater. We define two variables which are to be compared.
set a 23
set b 32
set val [maximum $a $b]
We calculate the maximum of the two variables. This is the output of the maximum.tel script.
$./maximum.tcl
The max of 23, 32 is 32
Variable number of arguments
A procedure can take and process variable number of arguments. For this we use the special
arguments and parameter.
#!/usr/bin/tclsh
proc sum (args)
{
set s 0
foreach arg $args
}
iner s $arg
return $s
}
puts [sum 1234]
puts [sum 1 2]
puts [sum 4]

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

28
TCL Structure 20.12.2024

We define a sum procedure which adds up all its arguments. The sum procedure has a special
args argument. It has a list of all values passed to the procedure.
proc sum {args}
{
foreach arg $args
{
iner s $arg
}
We go through the list and calculate the sum.
puts sum 1234]
puts [sum 1 2]
puts [sum 4]
We call the sum procedure three times. In the first case, it takes 4 arguments, in the second
case 2, in the last case one. Output of the variable tel script
$./variable.tel
10
3
4
Implicit arguments
The arguments in Tel procedures may have implicit values. An implicit value is used if no
explicit value is provided.
#!/usr/bin/tclsh
proc power {a {b 2}}
if {$b ==2}
{
return [expr $a $a]
}
set value 1
for {set i 0} {Si <$b} {incr i}
{
set value [expr $value" $a]

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

29
TCL Structure 20.12.2024

}
return $value
}
set v1 [power 5]
set v2 [power 5 4]
puts "5^2 is $v1"
puts "5^2 is $v 1"
puts "5^4 is $v2"
Here we create a power procedure. The procedure has one argument with an implicit value. We can
call the procedure with one and two arguments.
proc power {a {b2}} {
set vl [power 5]
set v2 [power 54]
The second argument b, has an implicit value 2. If we provide only one argument, the power
procedure then returns the value of a to the power 2. We call the power procedure with one and two
arguments. The first line computes the value of 5 to the power 2. The second line value of 5 to the
power 4. Output of the example.
$./implicit.tcl
5^2 is 25
5^4 is 625
Returning multiple values
The return command passes one value to the caller. There is often a need to return multiple values.
In such cases, we can return a list.
#!/usr/bin/tclsh
proc tworandoms {}
{
set r1 [expr round(rand()*10)]
set r2 [expr round(rand()*10)]
return [list $r1 $r2]
puts [two randoms]
puts [two randoms]
puts [two randoms]

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

30
TCL Structure 20.12.2024

puts [two randoms]

We have a two randoms procedure. It returns two random integers between 1 and 10. A random
integer is computed and set to the rl variable.
set r1 [expr round(rand()*10)]
return list $r1 $r2]
Two values are returned with the help of the list command. A sample output.
$./tworandoms.tcl
37
13
87
99
62%
Recursion
 Recursion, in mathematics and computer science, is a way of defining functions in which the
function being defined is applied within its own definition. In other words, a recursive
function calls itself to do its job.
 Recursion is a widely used approach to solve many programming tasks.
 Recursion is the fundamental approach in functional languages like Scheme, OCalm, or
Clojure.
 Recursion calls have a limit in Tcl. There cannot be more than 1000 recursion calls.
 A typical example of recursion is the calculation of a factorial. Factorial n! is the product of
all positive integers less than or equal to n.
#!/usr/bin/tclsh
proc factorial n
{
if {$n==()}
{
return l
}
else
{
return [expr Sn [factorial [expr $n-1]||
}
}

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

31
TCL Structure 20.12.2024

#Stack limit between 800 and 1000 levels

puts [factorial 4]
puts [factorial 10]
puts [factorial 18]
In this code example, we calculate the factorial of three numbers.
return [expr $n [factorial [expr Sn 1]]]
Inside the body of the factorial procedure, we call the factorial procedure with a modified
argument. The procedure calls itself.
S. /recursion.tel.
24 3628800
6402373705728000
These are the results. If we tried to compute the factorial of 100, we would receive "too many
nested evaluations" error.
Scope
 A variable declared inside a procedure has a procedure scope.
 The scope of a name is the region of a program text within which it is possible to refer to the
entity declared by the name without qualification of the name.
 A variable which is declared inside a procedure has a procedure scope: it is also called a local
scope.
 The variable is then valid only in this particular procedure.
#!/usr/bin/tclsh
proc test {}
{
puts "inside procedure"
#puts "x is $x"
set x 4
puts "x is $x"
}
set x l
puts "outside procedure"
puts "x is $x"
test
puts "outside procedure"

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

32
TCL Structure 20.12.2024

puts "x is $x"

In the preceding example, we have an x variable defined outside and inside of the test procedure.
Inside the test procedure, we define an x variable. The variable has local scope, valid only inside this
procedure.
set x 4
puts "x is $x"
set x 1
puts "outside procedure"
puts "x is $x"
We define an x variable outside the procedure. It has a global scope. The variables do not conflict
because they have different scopes.
$. /scope.tcl
outside procedure
x is 1
inside procedure
x is 4
outside procedure
x is 1
#!/usr/bin/tclsh
It is possible to change the global variable inside a procedure.
proc test {}
{
proc test {}
upvar x y
puts "inside procedure"
puts "y is Sy"
}
set y 4
puts "y is Sy"
set x 1
puts "outside procedure"

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

33
TCL Structure 20.12.2024

puts "x is $x"

test
puts "outside procedure"
puts "x is $x"
We define a global x variable. We change the variable inside the test procedure. We refer to the global
x variable by the name y with the upvar command..
upvar x y
set y 4
We assign a value to the local y variable and also change the value of the global x variable.
$. /scope2.tcl
outside procedure
x is l
inside procedure
y is 1
y is
outside procedure
x is 4
From the output we can see the test procedure has changed the x variable. With the global command,
we can refer to global variables from procedures.
#!/usr/bin/tclsh
proc test {}
global x
puts "inside test procedure x is $x"
proc nested {}
{
global x
puts "inside nested x is $x"
}
}
set x 1
test

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

34
TCL Structure 20.12.2024

nested
puts "outside x is $x"
In the above example, we have a test procedure and a nested procedure defined within the test
procedure. We refer to the global x variable from both procedures.
global x
puts "inside test procedure x is $x"
With the global command, we refer to the global x variable, defined outside the test procedure.
proc nested {}
{
global x
puts "inside nested x is $x"
}
It is possible to create nested procedures. These are procedures defined inside other procedures. We
refer to the global x variable with the global command.
test
nested
We call the test procedure and its nested procedure.
$. /scope3.tcl
inside test procedure x is 1
inside nested x is 1
outside x is l

Strings patterns
Files
The file command manipulates file names and attributes. It has plenty of options.
#!/usr/bin/tclsh
puts [file volumes]
[file mkdir new)
The script prints the system's mounted values and creates. new directory. The file volumes command
returns the absolute paths to the volumes mounted on the system.
puts [file volumes)
[file mkdir new]

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

35
TCL Structure 20.12.2024

The file mkdir creates a directory called new..

$. /voldir.tcl
$ ls-d*/
doc/new/tmp/
 On a Linux system, there is one mounted volume-the root directory.
 The is command confirms the creation of the new directory.
 In the following code example, we are going to check if a file name is a regular file or a
directory.
#!/usr/bin/tclsh
set files [glob*]
foreach fl Sfiles
{
if {[file isfile $fl]}
{
puts "$fl is a file"
}
Elseif
{
{ [file isdirectory $fl]}
{
puts "$il is a directory"
}
}
We go through all file names in the current working directory and print whether it is a file or a
directory.
Using the glob command we create a list of file and directory names of a current directory. We
execute the body of the if command if the file name in question is a file.
set files [glob*]
if {[file isfile $f1]}
{
elseif { [file isdirectory $fl]}
{

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

36
TCL Structure 20.12.2024

The file is directory command determines, whether a file name is a directory. Note that on Unix, a
directory is a special case of a file. The puts command can be used to write to files.
#!/usr/bin/tclsh
set fp [open days w]
set days { Monday Tuesday Wednesday Thursday Friday Saturday Sunday }
puts $fp $days
close $ip
In the script, we open a file for writing. We write days of a week to a file. We open a file named days
for writing. The open command returns a channel id. This data is going to be written to the file. We
used the channel id returned by the open command to write to the file.
set fp [open days w]
set days (Monday Tuesday Wednesday Thursday Friday Saturday Sunday)
puts Síp Sdays
close Sfp
We close the opened channel.
$. /write2file.tcl
$ cat days
Monday Tuesday Wednesday Thursday Friday Saturday Sunday
We run the script and check the contents of the days file. In the following script, we are going to read
data from a file.
S cat languages
Python
Tcl
Visual Basic
Perl
Java
C
C#

Ruby
Scheme
 We have a simple file called languages in a directory.
#!/usr/bin/tclsh

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

37
TCL Structure 20.12.2024

set fp [open languages r]

set data [read $ip]
puts -nonewline $data
close $fp
 We read data from the supplied file, read its contents and print the data to the terminal.
 We create a channel by opening the languages file in a read-only mode. If we do not provide
a second parameter to the real command, it reads all data from the file until the end of the file.
set fp [open languages r
set data [read Sfp]
puts -nonewline $data
We print the data to the console.
$. /readfile2.tcl
Python
Tcl
Visual Basic
Perl
Java
C
C#

Ruby
Scheme
 Sample run of the readfile.tel script.
 The eof command checks for end-of-line of a supplied channel.
#!/usr/bin/tclsh
set fp[open languages]
while {![eof $tp]}
{
puts [gets $fp]
}
close $f
We use the cof command to read the contents of a file.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

38
TCL Structure 20.12.2024

while {!feof $tp]}

{
puts [gets $fp]
}
The loop continues until the eof returns true if it encounters the end of a file. Inside the body, we use
the gets command to read a line from the file.
$./readfile2.tcl
Python
Tel
Visual Basic
Perl
Java
C
C#
Ruby
Scheme
Sample run of the readfile2.tcl script. The next script performs some additional file operations.
#!/usr/bin/tclsh
set fp [open newfile w]
puts $fp "this is new file"
flush $fp
file copy newfile newfile2
file delete newfile.
close $fp
We open a file and write some text to it. The file is copied. The original file is then deleted. The file
copy command copies a file
file copy newfile newfile2
file delete newfile
The original file is deleted with the file delete command. In the final example, we will work with file
attributes.
#!/usr/bin/tclsh

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

39
TCL Structure 20.12.2024

set files [glob *]

set mx (0)
foreach fl $files
{
set len [string length $fl]
if | $len > $mx)
{
set mx $len
}
set fstr "%-$mx\s %-s"
puts [format $fstr Name Size
set fstr "%-$mx's %d bytes"
foreach fl $files
{
set size [file size $fl]
puts [format $fstr $fl $size]
The script creates two columns. In the first column, we have the name of the file. In the second
column, we display the size of the file.
foreach in $files.
set len [string length $fl]
if | $len $mx]
set mx $len
In this loop, we find out the most lengthy file name. This will be used when formatting the output
columns.
set fstr "%-$mx\s %-s
puts [format $fstr Name Size
Here we print the headers of the columns. To format the data, we use the format command.
set fstr "%-$mx's %d bytes"
foreach fl $files
{
set size [file size $fl]

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

40
TCL Structure 20.12.2024

puts [format $fstr $il $size]

}
We go through the list of files and print each file name and its size. The file size command. determines
the size of the file.
$. /attributes.tcl
Name Size
attributes.tcl 337 bytes
newfile2 17 bytes
allfiles.tcl 75 bytes
printing.tcl 83 bytes
languages 51 bytes
hello.tcl 109 bytes
days 57 bytes
read.tcl 113 bytes
files.tcl 140 bytes
globemil.tcl 82 bytes
write2file.tcl 134 bytes
The script creates two columns. In the first column, we have the name of the file. In the second
column, we display the size of the file.
foreach fl $files
{
set len [string length $il]
if { $len > $mx}
set mx $len
}
}
In this loop, we find out the most lengthy file name. This will be used when formatting the output
columns.
set fstr "%-$mx\s %-s"
puts [format $fstr Name Size]
Here we print the headers of the columns. To format the data, we use the format command.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

41
TCL Structure 20.12.2024

set fstr " $mx/s %d bytes"

foreach fl Stiles
{
set size [file size $fl]
puts [format $fstr $fl $size]
}
We go through the list of files and print each file name and its size. The file size command determines
the size of the file.
$. /attributes.tel
Name Size
attributes.tel 337 bytes
newfile2 17 bytes
allfiles.tel 75 bytes
printing.tel 83 bytes
languages 51 bytes
hello.tcl 109 bytes
days 57 bytes
read.tcl 113 bytes
files.tcl 140 bytes
globcmd.tcl 82 bytes
write2file.tcl 134 bytes
doc 4096 bytes
ewd.tcl 76 bytes
tmp 4006 butes
tmp 4096 bytes
readfile.tcl 98 bytes
isfile.tcl 219 byte

Eval
 One difference between Tcl and most other compilers is that Tcl will allow an executing
program to create new commands and execute them while running.
 A tcl command is defined as a list of strings in which the first string is a command or proc.
Any string or list which meets this criteria can be evaluated and executed.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

42
TCL Structure 20.12.2024

 The eval command will evaluate a list of strings as though they were commands typed at the
% prompt or sourced from a file.
 The eval command normally returns the final value of the commands being evaluated. If the
commands being evaluated throw an error (for example, if there is a syntax error in one of the
strings), then eval will will throw an error.
 Note that either concat or list may be used to create the command string, but that these two
commands will create slightly different command strings.
eval arg1 ??arg2??.... ??argn??
 Evaluates arg! argn as one or more Tel commands.
 The args are concatenated into a string, and passed to tcl eval to evaluate and execute.
 Eval returns the result for error code) of that evaluation.
Example
set cmd {puts "Evaluating a puts"}
puts "CMD IS: $cmd"
eval $cmd
if (string match [info procs new ProcA] ""]}
{
puts "\nDefining newProcA for this invocation"
set num 0:
set end "proc new ProcA"
set emd [concat $cmd "{} {\n"]
set emd [concat $cmd "global num:\n"]
set emd [concat $emd "iner num:\n"]
set cmd [concat $cmd" return \"/tmp/TMP.[pid].\ $num\":\n"]
set cmd [concat $cmd")"]
eval Semd
}
puts "In The body of newProcA is: An info body new ProcA]\n"
puts "new ProcA returns: newProcA]"
puts "new ProcA returns: [newProcA]"
#
# Define a proc using lists
#

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

43
TCL Structure 20.12.2024

if {[string match [info procs new ProcB] ""] }

{
puts "\nDefining newProcB for this invocation"
set cmd "proc newProcB
lappend cmd (1
lappend cmd (global num; iner num; return $num;)
eval $cmd
}
puts "\n'The body of newProcB is: \n/info body new ProcB]\n"
puts "newProcB returns: [newProcB]"
Source
This command takes the contents of the specified file or resource and passes it to the Tcl interpreter
as a text script. The return value from source is the return value of the last command executed in the
script. If an error occurs in evaluating the contents of the script then the source command will return
that error. If a return command is invoked from within the script then the remainder of the file will
be skipped and the source command will return normally with the result from the return command.
The -rsre and -rsreid forms of this command are only available on Macintosh computers. These
versions of the command allow you to source a script from a TEXT resource. You may specify what
TEXT resource to source by either name or id. By default Tel searches

all open resource files, which include the current application and any loaded C extensions.
Alternatively, you may specify the fileName where the TEXT resource can be found.
source fileName
source -rsrc resourceName ?fileName?
source-rsrcid resourceld ?fileName?

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

44
TCL Structure 20.12.2024

Tk - Overview

 Tk refers to Toolkit and it provides cross platform GUI widgets, which helps you in building
a Graphical User Interface.
 It was developed as an extension to Tcl scripting language by John Ousterhout.
 Tk remained in development independently from Tcl with version being different to each
other, before, it was made in sync with Tcl in v8.0.

Features of Tk

It is cross platform with support for Linux, Mac OS, Unix, and Microsoft Windows operating systems.

 It is an open source.
 It provides high level of extendibility.
 It is customizable.
 It is configurable.
 It provides a large number of widgets.
 It can be used with other dynamic languages and not just Tcl.
 GUI looks identical across platforms.

Applications Built in Tk

Large successful applications have been built in Tcl/Tk.

 Dashboard Soft User Interface

 Forms GUI for Relational DB
 Ad Hoc GUI for Relational DB
 Software/Hardware System Design
 Xtask - Task Management
 Musicology with Tcl and Tk
 Calender app
 Tk mail
 Tk Debugger

Tk - Environment

Generally, all Mac and Linux mac come with Tk pre-installed. In case, it's not available or you
need the latest version, then you may need to install it. Windows don't come with Tcl/Tk and
you may need to use its specific binary to install it.

1. The Tk Interpreter

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

45
TCL Structure 20.12.2024

It is just a small program that enables you to type Tk commands and have them executed line
by line. It stops execution of a tcl file in case, it encounters an error unlike a compiler that
executes fully.

#!/usr/bin/wish

grid [ttk::button .mybutton -text "Hello World"]

The following section explains only how to install Tcl/Tk on each of the available platforms.

Installation on Windows

C:\Tcl> wish helloWorld.tcl

Press enter and we will see an output as shown below −

$ yum install tcl tk

$ wish helloWorld.tcl

Press enter and we will see an output similar to the following −

Tk - Special Variables

In Tk, we classify some of the variables as special variables and they have a predefined
usage/functionality. The list of special variables is listed below.

Sr.No. Special Variable & Description

1 tk_library
Used for setting the location of standard Tk libraries.

2 tk_patchLevel
Refers to the current patch level of the Tk interpreter.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

46
TCL Structure 20.12.2024

3 tk_strictMotif
When non-zero, Tk tries to adhere to Motif look-and-feel as closely as possible.

4 tk_version
Displays the Tk version.

Tk - Widgets Overview

 The basic component of a Tk-based application is called a widget.

 A component is also sometimes called a window, since, in Tk, "window" and "widget" are
often used interchangeably.
 Tk is a package that provides a rich set of graphical components for creating graphical
applications with Tcl.
 Tk provides a range of widgets ranging from basic GUI widgets like buttons and menus to
data display widgets. The widgets are very configurable as they have default configurations
making them easy to use.
 Tk applications follow a widget hierarchy where any number of widgets may be placed within
another widget, and those widgets within another widget. The main widget in a Tk program
is referred to as the root widget and can be created by making a new instance of the TkRoot
class.

Creating a Widget

The syntax for creating a widget is given below.

type variableName arguments options

The type here refers to the widget type like button, label, and so on. Arguments can be optional and
required based on individual syntax of each widget. The options range from size to formatting
of each component.

Widget Naming Convention

Widget uses a structure similar to naming packages. In Tk, the root window is named with a
period (.) and an element in window, for example button is named .myButton1. The variable
name should start with a lowercase letter, digit, or punctuation mark (except a period). After
the first character, other characters may be uppercase or lowercase letters, numbers, or
punctuation marks (except periods). It is recommended to use a lowercase letter to start the
label.

Color Naming Convention

The colors can be declared using name like red, green, and so on. It can also use hexadecimal
representing with #. The number of hexadecimal digits can be 3, 6, 9, or 12.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

47
TCL Structure 20.12.2024

Dimension Convention

The default unit is pixels and it is used when we specify no dimension. The other dimensions
are i for inches, m for millimeters, c for centimeters and p for points.

Common Options

There are so many common options available to all widgets and they are listed below in the
following table −

Sr.No. Syntax & Description

1 -background color
Used to set background color for widget.

2 -borderwidth width
Used to draw with border in 3D effects.

3 -font fontDescriptor
Used to set font for widget.

4 -foreground color
Used to set foreground color for widget.

5 -height number
Used to set height for widget.

-highlightbackground color
6 Used to set the color rectangle to draw around a widget when the widget does not have input
focus.

7 -highlightcolor color
Used to set the color rectangle to draw around a widget when the widget has input focus.

8 -padx number
Sets the padx for the widget.

9 -pady number
Sets the pady for the widget.

-relief condition
10 Sets the 3D relief for this widget. The condition may be raised, sunken, flat, ridge, solid, or
groove.

11 -text text

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

48
TCL Structure 20.12.2024

Sets the text for the widget.

-textvariable varName
12 Variable associated with the widget. When the text of widget changes, the variable is set
with text of widget.

13 -width number
Sets the width for widget.

A simple example for options is shown below.

#!/usr/bin/wish

grid [label .myLabel -background red -text "Hello World" -relief ridge -borderwidth 3]
-padx 100 -pady 100

When we run the above program, we will get the following output.

The list of available widgets are categorized below −

Basic widgets

Sr.No. Widget & Description

1 Label
Widget for displaying single line of text.

2 Button
Widget that is clickable and triggers an action.

3 Entry
Widget used to accept a single line of text as input.

4 Message
Widget for displaying multiple lines of text.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

49
TCL Structure 20.12.2024

5 Text
Widget for displaying and optionally edit multiple lines of text.

6 Toplevel
Window with all borders and decorations provided by the Window manager.

Layout Widgets

Sr.No. Widget & Description

1 Frame
Container widget to hold other widgets.

Place
2 Widget to hold other widgets in specific place with coordinates of its origin and an exact
size.

3 Pack
Simple widget to organize widgets in blocks before placing them in the parent widget.

4 Grid
Widget to nest widgets packing in different directions.

Selection Widgets

Sr.No. Widget & Description

1 Radiobutton
Widget that has a set of on/off buttons and labels, one of which may be selected.

2 Checkbutton
Widget that has a set of on/off buttons and labels, many of which may be selected..

3 Menu
Widget that acts as holder for menu items.

4 Listbox
Widget that displays a list of cells, one or more of which may be selected.

Mega Widgets

Sr.No. Widget & Description

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

50
TCL Structure 20.12.2024

1 Dialog
Widget for displaying dialog boxes.

2 Spinbox
Widget that allows users to choose numbers.

3 Combobox
Widget that combines an entry with a list of choices available to the use.

4 Notebook
Tabbed widget that helps to switch between one of several pages, using an index tab.

5 Progressbar
Widget to provide visual feedback to the progress of a long operation like file upload.

6 Treeview
Widget to display and allow browsing through a hierarchy of items more in form of tree.

7 Scrollbar
Scrolling widgets without a text or canvas widgets.

8 Scale
Scale widget to choose a numeric value through sliders.

Other Widgets

Sr.No. Widget & Description

1 Canvas
Drawing widget for displaying graphics and images..

We will cover each of these widgets in the upcoming chapters.

Tk - Basic Widgets

Basic widgets are common widgets available in almost all Tk applications. The list of available basic
widgets is given below −

Sr.No. Widgets & Description

Label
1
Widget for displaying single line of text.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

51
TCL Structure 20.12.2024

Button
2
Widget that is clickable and triggers an action.

Entry
3
Widget used to accept a single line of text as input.

Message
4
Widget for displaying multiple lines of text.

Text
5
Widget for displaying and optionally edit multiple lines of text.

Toplevel
6
Widget used to create a frame that is a new top level window.

A simple Tk example is shown below using basic widgets −

#!/usr/bin/wish

grid [label .myLabel -text "Label Widget" -textvariable labelText]

grid [text .myText -width 20 -height 5]
.myText insert 1.0 "Text\nWidget\n"
grid [entry .myEntry -text "Entry Widget"]
grid [message .myMessage -background red -foreground white -text "Message\nWidget"]
grid [button .myButton1 -text "Button" -command "set labelText clicked"]

When we run the above program, we will get the following output −

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

52
TCL Structure 20.12.2024

Tk - Layout Widgets

Layout widgets are used to handle layouts for the Tk application. Frame widget is used group other
widgets and place, pack, and grid are layout manager to give you total control over your adding
to windows. The list of available layout widgets are as shown below −

Sr.No. Widgets & Description

Frame
1
Container widget to hold other widgets.

Place
2
Widget to hold other widgets in specific place with coordinates of its origin and an exact
size.

Pack
3
Simple widget to organize widgets in blocks before placing them in the parent widget.

Grid
4
Widget to nest widgets packing in different directions.

A simple Tk example is shown below for layout widgets −

#!/usr/bin/wish

frame .myFrame1 -background red -relief ridge -borderwidth 8 -padx 10 -pady 10

-height 100 -width 100
frame .myFrame2 -background blue -relief ridge -borderwidth 8 -padx 10 -pady 10
-height 100 -width 50
pack .myFrame1
pack .myFrame2

When we run the above program, we will get the following output −

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

53
TCL Structure 20.12.2024

Tk - Selection Widgets

Selection widgets are used to select different options in a Tk application. The list of available selection
widgets are as shown below.

Sr.No. Widgets & Description

Radiobutton
1
Widget that has a set of on/off buttons and labels, one of which may be selected.

Checkbutton
2
Widget that has a set of on/off buttons and labels, many of which may be selected.

Menu
3
Widget that acts as holder for menu items.

Listbox
4
Widget that displays a list of cells, one or more of which may be selected.

A simple Tk example is shown below using selection widgets −

#!/usr/bin/wish

grid [frame .gender ]

grid [label .label1 -text "Male" -textvariable myLabel1 ]
grid [radiobutton .gender.maleBtn -text "Male" -variable gender -value "Male"
-command "set myLabel1 Male"] -row 1 -column 2
grid [radiobutton .gender.femaleBtn -text "Female" -variable gender -value "Female"
-command "set myLabel1 Female"] -row 1 -column 3
.gender.maleBtn select

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

54
TCL Structure 20.12.2024

grid [label .myLabel2 -text "Range 1 not selected" -textvariable myLabelValue2 ]

grid [checkbutton .chk1 -text "Range 1" -variable occupied1 -command {if {$occupied1 } {
set myLabelValue2 {Range 1 selected}
} else {
set myLabelValue2 {Range 1 not selected}
} }]
proc setLabel {text} {
.label configure -text $text
}

When we run the above program, we will get the following output −

Tk - Canvas Widgets

Canvas is used for providing drawing areas. The syntax for canvas widget is shown below −

canvas canvasName options

Options

The options available for the canvas widget are listed below in the following table −

Sr.No. Syntax & Description

1 -background color
Used to set background color for widget.

-closeenough distance
2 Sets the closeness of mouse cursor to a displayable item. The default is 1.0 pixel. This value
may be a fraction and must be positive.

3 -scrollregion boundingBox
The bounding box for the total area of this canvas.

4 -height number
Used to set height for widget.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

55
TCL Structure 20.12.2024

5 -width number
Sets the width for widget.

6 -xscrollincrement size
The amount to scroll horizontally when scrolling is requested.

7 -yscrollincrement size
The amount to scroll vertically when scrolling is requested.

A simple example for canvas widget is shown below −

#!/usr/bin/wish

canvas .myCanvas -background red -width 100 -height 100

pack .myCanvas

When we run the above program, we will get the following output −

Widgets for Drawing in Canvas

The list of the available widgets for drawing in canvas is listed below −

Sr.No. Widget & Description

Line
1
Draws a line.

Arc
2
Draws an arc.

Rectangle
3
Draws a rectangle.

4 Oval

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

56
TCL Structure 20.12.2024

Draws an oval.

Polygon
5
Draws a polygon.

Text
6
Draws a text.

Bitmap
7
Draws a bitmap.

Image
8
Draws an image.

An example using different canvas widgets is shown below −

#!/usr/bin/wish

canvas .myCanvas -background red -width 200 -height 200

pack .myCanvas
.myCanvas create arc 10 10 50 50 -fill yellow
.myCanvas create line 10 30 50 50 100 10 -arrow both -fill yellow -smooth true
-splinesteps 2
.myCanvas create oval 50 50 100 80 -fill yellow
.myCanvas create polygon 50 150 100 80 120 120 100 190 -fill yellow -outline green
.myCanvas create rectangle 150 150 170 170 -fill yellow
.myCanvas create text 170 20 -fill yellow -text "Hello" -font {Helvetica -18 bold}
.myCanvas create bitmap 180 50 -bitmap info

When we run the above program, we will get the following output −

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

57
TCL Structure 20.12.2024

Tk - Mega Widgets

Mega widgets include many complex widgets which is often required in some large scale Tk
applications. The list of available mega widgets are as shown below −

Sr.No. Widget & Description

Dialog
1
Widget for displaying dialog boxes.

Spinbox
2
Widget that allows users to choose numbers.

Combobox
3
Widget that combines an entry with a list of choices available to the use.

Notebook
4
Tabbed widget that helps to switch between one of several pages, using an index tab.

Progressbar
5
Widget to provide visual feedback to the progress of a long operation like file upload.

Treeview
6
Widget to display and allow browsing through a hierarchy of items more in form of tree.

Scrollbar
7
Scrolling widgets without a text or canvas widgets.

Scale
8
Scale widget to choose a numeric value through sliders.

A simple Tk example is shown below using some mega widgets.

#!/usr/bin/wish

ttk::treeview .tree -columns "Creator Year" -displaycolumns "Year Creator"

.tree heading Creator -text "Creator" -anchor center
.tree heading Year -text "Year" -anchor center
pack .tree
.tree insert {} end -id Languages -text "Languages"
.tree insert Languages end -text C -values [list "Dennis Ritchie" "1990"]

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

58
TCL Structure 20.12.2024

proc scaleMe {mywidget scaleValue} {

$mywidget configure -length $scaleValue
}
pack [scale .s2 -from 100.0 -to 200.0 -length 100 -background yellow -borderwidth 5
-font{Helvetica -18 bold} -foreground red -width 40 -relief ridge -orien horizontal
-variable a -command "scaleMe .s2" ]
pack [ttk::progressbar .p1 -orient horizontal -length 200 -mode indeterminate -value 90]
pack [ttk::progressbar .p2 -orient horizontal -length 200 -mode determinate -variable a
-maximum 75 -value 20]

When we run the above program, we will get the following output −

Tk - Fonts

There are a number of widgets that supports displaying text. Most of these provides the option of font
attribute. The syntax for creating a font is shown below −

font create fontName options

Options

The options available for the font create are listed below in the following table −

Sr.No. Syntax & Description

1 -family familyName
The name of font family.

2 -size number
The size of font.

3 -weight level
The weight for font.

A simple example for a font creation is shown below −

#!/usr/bin/wish

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

59
TCL Structure 20.12.2024

font create myFont -family Helvetica -size 18 -weight bold

pack [label .myLabel -font myFont -text "Hello World"]

When we run the above program, we will get the following output −

To get all the fonts available, we can use the following command −

#!/usr/bin/wish

puts [font families]

Tk - Images

The image widget is used to create and manipulate images. The syntax for creating image is as
follows −

image create type name options

In the above syntax type is photo or bitmap and name is the image identifier.

Options

The options available for image create are listed below in the following table −

Sr.No. Syntax & Description

1 -file fileName
The name of the image file name.

2 -height number
Used to set height for widget.

3 -width number
Sets the width for widget.

4 -data string
Image in base 64 encoded string.

A simple example for image widget is shown below −

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

60
TCL Structure 20.12.2024

#!/usr/bin/wish

image create photo imgobj -file "/Users/rajkumar/Desktop/F Drive/pictur/vb/Forests/

680049.png" -width 400 -height 400
pack [label .myLabel]
.myLabel configure -image imgobj

The available function for image are listed below in the following table −

Sr.No. Syntax & Description

1 mage delete imageName

Deletes the image from memory and related widgets visually.

2 mage height imageName

Returns the height for image.

3 mage width imageName

Returns the width for image.

4 mage type imageName

Returns the type for image.

5 mage names
Returns the list of images live in memory.

A simple example for using the above image widget commands is shown below −

#!/usr/bin/wish

image create photo imgobj -file "/Users/rajkumar/images/680049.png"

-width 400 -height 400
pack [label .myLabel]
.myLabel configure -image imgobj
puts [image height imgobj]
puts [image width imgobj]
puts [image type imgobj]
puts [image names]
image delete imgobj

The image will be deleted visually and from memory once "image delete imgobj" command executes.
In console, the output will be like the following −

400

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

61
TCL Structure 20.12.2024

400
photo
imgobj ::tk::icons::information ::tk::icons::error ::tk::icons::
warning ::tk::icons::question

Tk - Events

Events in its simplest form is handled with the help of commands. A simple example for event
handling is event handling with button and is shown below −

#!/usr/bin/wish

proc myEvent { } {
puts "Event triggered"
}
pack [button .myButton1 -text "Button 1" -command myEvent]

When we run the above program, we will get the following output −

A simple program to show delay text animation event is shown below −

#!/usr/bin/wish

proc delay {} {
for {set j 0} {$j < 100000} {incr j} {}
}

label .myLabel -text "Hello ............... " -width 25

pack .myLabel
set str "Hello ............... "
for {set i [string length $str]} {$i > -2} {set i [expr $i-1]} {
.myLabel configure -text [string range $str 0 $i]
update
delay
}

When we run the program, we will get the following output in animated way −

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

62
TCL Structure 20.12.2024

Event after delay

The syntax for event after delay is shown below −

after milliseconds number command

A simple program to show after delay event is shown below −

#!/usr/bin/wish

proc addText {} {
label .myLabel -text "Hello ............... " -width 25
pack .myLabel
}
after 1000 addText

When we run the program, we will get the following output after one second −

You can cancel an event using the after cancel command as shown below −

#!/usr/bin/wish

proc addText {} {
label .myLabel -text "Hello ............... " -width 25
pack .myLabel
}
after 1000 addText
after cancel addText

Event Binding

The syntax for event binding is as shown below −

bind arguments
Keyboard Events Example
#!/usr/bin/wish

bind . {puts "Key Pressed: %K "}

When we run the program and press a letter X, we will get the following output −

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

63
TCL Structure 20.12.2024

Key Pressed: X
Mouse Events Example
#!/usr/bin/wish

bind . {puts "Button %b Pressed : %x %y "}

When we run the program and press the left mouse button, we will get an output similar to the following
−

Button 1 Pressed : 89 90
Linking Events with Button Example
#!/usr/bin/wish

proc myEvent { } {
puts "Event triggered"
}
pack [button .myButton1 -text "Button 1" -command myEvent]
bind . ".myButton1 invoke"

When we run the program and press enter, we will get the following output −

Event triggered

Tk - Windows Manager

Window manager is used to handle the top level window. It helps in controlling the size,
position, and other attributes of the window. In Tk, . is used to refer the main window. The
syntax for window command is shown below −

wm option window arguments

The list of options available for Tk wm command is shown in the following table −

Sr.No. Syntax & Description

1 aspect windowName a b c d
Tries to maintain the ratio of width/height to be between a/b and c/d.

2 geometry windowName geometryParams

Use to set geometry for window.

3 grid windowName w h dx dy
Sets the grid size.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

64
TCL Structure 20.12.2024

4 group windowName leaderName

eaderName gives the leader of a group of related windows.

5 deiconify windowName
Brings the screen to normal if minimized.

6 conify windowName
Minimizes the window.

7 state windowName
Returns the current state of window.

8 withdraw windowName
Unmaps the window and removes its details in memory.

9 conbitmap windowName image

Sets or returns the icon bitmap.

10 conPhoto windowName image

Sets or returns the icon photo.

11 command windowName commandString

Records the startup command in the WM_COMMAND property.

protocol windowName arguments

Register a command to handle the protocol request name, which can be
12 WM_DELETE_WINDOW,
WM_SAVE_YOURSELF,
WM_TAKE_FOCUS. Eg: wm protocol.
WM_DELETE_WINDOW Quit.

13 minsize windowName size

Determines the minimum window size.

14 maxsize windowName size

Determines the maximum window size.

15 title windowName titleText

Determines the title for window.

16 attributes subOptions
There are lots of attributes available like alpha, full screen and so on.

Some of the above commands are used in the following example −

#!/usr/bin/wish

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

65
TCL Structure 20.12.2024

wm maxsize . 800 800

wm minsize . 300 300
wm title . "Hello"
wm attributes . -alpha ".90"
wm geometry . 300x200+100+100

When we run the above program, we will get the following output −

As you can see alpha is one of the attributes available. The list of commonly used subcommands are
listed below −

Sr.No. Syntax & Description

1 -alpha number
Sets the alpha for window.

2 -fullscreen number
Number can be 0 for normal screen or 1 for full screen.

3 -topmost number
Sets or returns whether window is topmost.Value can be 0 or 1.

Creating Window

We can use toplevel command to create window and an example is shown below −

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

66
TCL Structure 20.12.2024

#!/usr/bin/wish

toplevel .t

When we run the above program, we will get the following output −

Destroying Window

We can use destroy command to destroy window and an example is shown below −

#!/usr/bin/wish

destroy .t

The above command will destroy window named .t.

Tk - Geometry Manager

The geometry manager is used to manage the geometry of the window and other frames. We
can use it to handle the position and size of the window and frames. The layout widgets are
used for this purpose.

Positioning and sizing

The syntax for positioning and sizing window is shown below −

wm geometry . wxh+/-x+/-y

Here, w refers to width and h refers to height. It is followed by a '+' or '-' sign with number next referring
to the x position on screen. Similarly the following '+' or '-' sign with number refers to the y
position on screen

A simple example is shown below for the above Statement −.

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC

67
TCL Structure 20.12.2024

#!/usr/bin/wish

wm geometry . 300x200+100+100

When we run the above program, we will get the following output −

Grid Geometry

The syntax for grid geometry is shown below −

grid gridName -column number -row number -columnspan number -rowspan number

The column, row, columnspan, or rowspan helps in providing the grid geometry.

A simple example is shown below for the above statement −

#!/usr/bin/wish

frame .myFrame1 -background red -height 100 -width 100

frame .myFrame2 -background blue -height 100 -width 50
grid .myFrame1 -columnspan 10 -rowspan 10 -sticky w
grid .myFrame2 -column 10 -row 2

When we run the above program, we will get the following output −

Mr. AZMEERA RAMESH (Asst. Prof ), CMRTC