Tcl和Tk工具包入门指南

需积分: 16 142 浏览量更新于2024-07-23 1 收藏 948KB PDF 举报

"Tcl and Tk Tookit - 一本由John K. Ousterhout编写的关于Tcl编程和Tk工具包的书籍草稿" Tcl（Tool Command Language）和Tk（Tk Toolkit）是一对用于创建图形用户界面（GUI）的开源编程语言和库。Tcl是一种简单易学、动态类型的脚本语言，而Tk是与其配套的GUI工具包，提供了一系列的函数和组件，使开发者能够构建功能丰富的跨平台应用程序。这本书草稿由John K. Ousterhout撰写，他是计算机科学领域的专家，曾在加州大学伯克利分校任职。该书版权归属于Addison-Wesley出版社，允许个人复制用于个人学习，但任何形式的商业复制或发行需得到作者或出版社的书面许可。书中的内容将详细介绍Tcl语言的基础和Tk工具包的使用。Tcl语言以其简洁的语法和强大的字符串处理能力著称，而Tk则提供了包括按钮、文本框、滚动条等多种GUI组件。通过Tcl和Tk，开发者可以轻松地构建出在多个操作系统上运行的交互式应用程序。在书中，读者可以期待涵盖以下几个关键知识点： 1. **Tcl语言基础**：包括变量、数据类型、控制结构（如循环和条件语句）、函数、命令定义和脚本编写等基础知识。 2. **Tk组件和布局管理**：介绍Tk中的各种窗口小部件（widgets），如Button、Label、Entry、Text等，以及如何使用Grid、Pack和Place等布局管理器进行窗口布局。 3. **事件驱动编程**：讲解Tcl/Tk如何处理用户的输入事件，如鼠标点击和键盘按键，以及如何定义事件处理器。 4. **图像处理与文件操作**：介绍如何在GUI中显示图像，以及读写文件和处理数据。 5. **高级特性**：如脚本调试、模块化编程、错误处理和性能优化等进阶主题。 6. **跨平台兼容性**：Tcl/Tk的一个重要特性是其良好的跨平台支持，书中可能涉及如何在不同操作系统上构建和运行Tcl/Tk程序。 7. **实际应用示例**：通过实例展示如何利用Tcl/Tk开发实际的应用程序，帮助读者巩固所学知识。这本书对于初学者来说是一个很好的资源，它将帮助填补Tcl和Tk入门文档的空白，直到正式版书籍出版。作者允许Tcl社区成员在遵守版权规定的前提下分享草稿，以促进技术的学习和交流。尽管这只是一个部分草稿，但它已经包含了大量有价值的信息，对于想要了解和掌握Tcl/Tk的人来说极具参考价值。

8 An Overview of Tcl and Tk

DRAFT (8/12/93): Distribution Restricted

For the expr command the word structure doesn’t matter much since expr concate-

nates all its arguments together. However for the button and pack commands, and for

most Tcl commands, the word structure is important. The button command expects its

ﬁrst argument to be the name of a window and the following arguments to come in pairs,

where the ﬁrst argument of each pair is the name of a conﬁguration option and the second

argument is a value for that option. Thus if the double-quotes were omitted the value of

the -text option would be “Hello,” and “world!” would be treated as the name of a

separate conﬁguration option. Since there is no option deﬁned with the name “world!”

the command would return an error.

Now let us move on to the behavior of the commands. The basic building block for a

graphical user interface in Tk is a widget. A widget is a window with a particular appear-

ance and behavior (the terms “widget” and “window” are used synonymously in Tk). Wid-

gets are divided into classes such as buttons, menus, and scrollbars. All the widgets in the

same class have the same general appearance and behavior. For example, all button wid-

gets display a text string or bitmap and execute a particular Tcl command when they are

invoked with the mouse.

Widgets are organized hierarchically in Tk, with names that reﬂect their position in

the hierarchy. The main widget, which appeared on the screen when you started wish, has

the name “.”. The name .b refers to a child of the main widget. Widget names in Tk are

like ﬁle names in UNIX except that they use “.” as a separator character instead of “/”.

Thus .a.b.c refers to a widget that is a child of widget .a.b, which in turn is a child of

.a, which is a child of the main widget.

Tk provides one command for each class of widgets, which you invoke to create wid-

gets of that class. For example the button command creates button widgets. All of the

widget creation commands have the same form: the ﬁrst argument is the name of a new

widget to create and additional arguments specify conﬁguration options. Different widget

classes support different sets of options. Widgets typically have many options (there are

about 20 different options deﬁned for buttons, for example), and default values are pro-

vided for the options that you don’t specify. When a widget creation command like but-

ton is invoked it creates a new window by the given name and conﬁgures it as speciﬁed

by the options.

The button command in the example speciﬁes two options: -text, which is a

string to display in the button, and -command, which is a Tcl script to execute when the

user invokes the button. In this example the -command option is exit. Here are a few

other button options that you can experiment with:

-background The background color for the button.

-foreground The color of the text in the button.

-font The name of the font to use for the button, such as

*-times-medium-r-normal--*-120-* for a 12-point

Times Roman font.

2.3 Script ﬁles 9

DRAFT (8/12/93): Distribution Restricted

The pack command makes the button widget appear on the screen. Creating a widget

does not automatically cause it to be displayed. Independent entities called geometry man-

agers are responsible for computing the sizes and locations of widgets and making them

appear on the screen. The pack command in the example asks a geometry manager called

the packer to manage .b. The command asks that .b ﬁll the entire area of its parent win-

dow; furthermore, if the parent has more space than needed by its child, as in the example,

the parent is shrunk so that it is just large enough to hold the child. Thus when you typed

the pack command the main window shrunk from its original size to the size that appears

in Figure 2.1.

2.3 Script ﬁles

In the examples so far you have typed Tcl commands interactively to tclsh or wish.

You can also place commands into script ﬁles and invoke the script ﬁles just like shell

scripts. To do this for the hello world example, place the following text in a ﬁle named

hello:

#!/usr/local/bin/wish -f

button .b -text "Hello, world!" -command exit

pack .b

This script is the same as the one you typed earlier except for the ﬁrst line. As far as wish

is concerned this line is a comment but if you make the ﬁle executable (type

“chmod 775 hello” to your shell, for example) you can then invoke the ﬁle directly

by typing hello to your shell. When you do this the system will invoke wish, passing it

the ﬁle as a script to interpret. Wish will display the same window shown in Figure 2.1

and wait for you to interact with it. In this case you will not be able to type commands

interactively to wish; all you can do is click on the button.

Note: This script will only work if wish is installed in /usr/local/bin. If wish has been

installed somewhere else then you’ll need to change the ﬁrst line to reﬂect its location on

your system.

In practice users of Tk applications rarely type Tcl commands; they interact with the

applications using the mouse and keyboard in the usual ways you would expect for graph-

ical applications. Tcl works behind the scenes where users don’t normally see it. The

hello script behaves just the same as an application that has been coded in C with a tool-

kit such as Motif and compiled into a binary executable ﬁle.

During debugging, though, it is common for application developers to type Tcl com-

mands interactively. For example, you could test out the hello script by starting wish

interactively (type wish to your shell instead of hello). Then type the following Tcl

command:

source hello

10 An Overview of Tcl and Tk

DRAFT (8/12/93): Distribution Restricted

Source is a Tcl command that takes a ﬁle name as argument. It reads the ﬁle and evalu-

ates it as a Tcl script. This will generate the same user interface as if you had invoked

hello directly from your shell, but you can now type Tcl commands interactively too.

For example, you could edit the script ﬁle to change the -command option to

-command "puts Good-bye!; exit"

then type the following commands interactively to wish without restarting the program:

destroy .b

source hello

The ﬁrst command will delete the existing button and the second command will recreate

the button with the new -command option. Now when you click on the button the puts

command will print a message on standard output before wish exits.

2.4 Variables and substitutions

Tcl allows you to store values in variables and use those values in commands. For exam-

ple, consider the following script, which you could type to either tclsh or wish:

set a 44

⇒ 44

expr $a*4

⇒ 176

The ﬁrst command assigns the value “44” to variable a and returns the variable’s value. In

the secon command t he $ causes Tcl to perform variable substitution: the Tcl interpreter

replaces the dollar-sign and the variable name following it with the value of the variable,

so that the actual argument received by expr is “44*4”. Variables need not be declared

in Tcl; they are created automatically when assigned to. Variable values are stored as

strings and arbitrary string values of any length are allowed. Of course, in this example an

error will occur in expr if the value of a doesn’t make sense as an integer or real number

(try other values and see what happens).

Tcl also provides command substitution, which allows you to use the result of one

command in an argument to another command:

set a 44

set b [expr $a*4]

⇒ 176

Square brackets invoke command substitution: everything inside the brackets is evaluated

as a separate Tcl script and the result of that script is substituted into the word in place of

the bracketed command. In this example the second argument of the second command will

be “176”.

2.5 Control structures 11

DRAFT (8/12/93): Distribution Restricted

2.5 Control structures

The next example uses variables and substitutions along with some simple control struc-

tures to create a Tcl procedure power that raises a base to an integer power:

proc power {base p} {

set result 1

while {$p > 0} {

set result [expr $result*$base]

set p [expr $p-1]

}

return $result

}

If you type the above lines to wish or tclsh, or if you enter them into a ﬁle and then

source the ﬁle, a new command power will become available. The command takes two

arguments, a number and an integer power, and its result is the number raised to the

power:

power 2 6

⇒ 64

power 1.15 5

⇒ 2.01136

This example uses one additional piece of Tcl syntax: braces. Braces are like double-

quotes in that they can be placed around a word that contains embedded spaces. However,

braces are different from double-quotes in two respects. First, braces nest. The last word

of the proc command starts after the open brace on the ﬁrst line and contains everything

up to the close brace on the last line. The Tcl interpreter removes the outer braces and

passes everything between them, including several nested pairs of braces, to proc as an

argument. The second difference between braces and double-quotes is that no substitu-

tions occur inside braces, whereas they do inside quotes. All of the characters between the

braces are passed verbatim to proc without any special processing.

The proc command takes three arguments: the name of a procedure, a list of argu-

ment names separated by white space, and the body of the procedure, which is a Tcl script.

Proc enters the procedure name into the Tcl interpreter as a new command. Whenever the

command is invoked, the body of the procedure will be evaluated. While the procedure

body is executing it can access its arguments as variables: base will hold the ﬁrst argu-

ment to power and p will hold the second argument.

The body of the power procedure contains three Tcl commands: set, while, and

return. The while command does most of the work of the procedure. It takes two

arguments, an expression “$p > 0” and a body, which is another multi-line Tcl script.

The while command evaluates its expression argument and if the result is non-zero then

it evaluates the body as a Tcl script. It repeats this process over and over until eventually

the expression evaluates to zero. In the example, the body of the while command multi-

12 An Overview of Tcl and Tk

DRAFT (8/12/93): Distribution Restricted

plies the result value by base and then decrements p. When p reaches zero the result con-

tains the desired power of base.

The return command causes the procedure to exit with the value of variable

result as the procedure’s result. If it is omitted then the return value of the procedure

will be the result of the last command in the procedure’s body. In the case of power this

would be the result of while, which is always an empty string.

The use of braces in this example is crucial. The single most difﬁcult issue in writing

Tcl scripts is managing substitutions: making them happen when you want them and pre-

venting them from happening when you don’t want them. Braces prevent substitutions or

defer them until later. The body of the procedure must be enclosed in braces because we

don’t want variable and command substitutions to occur at the time the body is passed to

proc as an argument; we want the substitutions to occur later, when the body is evaluated

as a Tcl script. The body of the while command is enclosed in braces for the same rea-

son: rather than performing the substitutions once, while parsing the while command,

we want the substitutions to be performed over and over, each time the body is evaluated.

Braces are also needed in the “{$p > 0}” argument to while. Without them the value

of variable p would be substituted when parsing the while command; the expression

would have a constant value and while would loop forever (you can try replacing some

of the braces in the example with double quotes to see what happens).

In the examples in this book I use a stylized syntax where the open brace for an argu-

ment that is a Tcl script appears at the end of one line, the script follows on successive

lines indented, and the close brace is on a line by itself after the script. Although I think

that this makes for readable scripts, Tcl doesn’t require this particular syntax. Script argu-

ments are subject to the same syntax rules as any other arguments; in fact the Tcl inter-

preter doesn’t even know that an argument is a script at the time it parses it. One

consequence of this is that the open parenthesis must be on the same line as the preceding

portion of the command. If the open brace is moved to a line by itself then the newline

before the open brace will terminate the command.

By now you have seen nearly the entire Tcl language syntax. The only remaining syn-

tactic feature is backslash substitution, which allows you to enter special characters such

as dollar-signs into a word without enclosing the entire word in braces. Note that while

and proc are not special syntactic elements in Tcl. They are just commands that take

arguments just like all Tcl commands. The only special thing about while and proc is

that they treat some of their arguments as Tcl scripts and cause the scripts to be evaluated.

Many other commands also do this. The button command was one example (its -com-

mand option is a Tcl script), and you’ll read about several other control structures later on,

such as for, foreach, case, and eval.

One ﬁnal note about procedures. The variables in a procedure are normally local to

that procedure and will not be visible outside the procedure. In the power example the

local variables include the arguments base and p as well as the variable result. A

fresh set of local variables is created for each call to a procedure (arguments are passed by

copying their values), and when a procedure returns its local variables are deleted. Vari-

剩余411页未读，继续阅读

funseeker

粉丝: 0
资源: 2

Tcl和Tk工具包入门指南

Tcl and the Tk Toolkit

slic_dump_tookit

uipath extened wpf tookit was not found

office2010 tookit csdn

lv_multisim tookit

cuda tookit

the data warehouse tookit pdf

anaconda安装tookit

vot tookit是干什么的

cuda tookit安装

最新资源