Tcl and the Tk Toolkit

tcl and the tk toolkit second edition and tcl/tk interpreter and gui toolkit
Dr.MattWood Profile Pic
Dr.MattWood,United States,Teacher
Published Date:25-07-2017
Your Website URL(Optional)
Comment
Tcl and the Tk Toolkit John K. Ousterhout Computer Science Division Department of Electrical Engineering and Computer Sciences University of California Berkeley, CA 94720 Copyright © 1993 Addison-Wesley Publishing Company, Inc. All rights reserved. Duplication of this draft is permitted by individuals for personal use only. Any other form of duplication or reproduction requires prior written permis- sion of the author or publisher. This statement must be easily visible on the first page of any reproduced copies. The publisher does not offer warranties in regard to this draft. Note to readers: This manuscript is a partial draft of a book to be published in early 1994 by Addison- Wesley (ISBN 0-201-63337-X). Addison-Wesley has given me permission to make drafts of the book available to the Tcl community to help meet the need for introduc- tory documentation on Tcl and Tk until the book becomes available. Please observe the restrictions set forth in the copyright notice above: you’re welcome to make a copy for yourself or a friend but any sort of large-scale reproduction or reproduction for profit requires advance permission from Addison-Wesley. I would be happy to receive any comments you might have on this draft; send them to me via electronic mail atoustercs.berkeley.edu. I’m particularly interested in hearing about things that you found difficult to learn or that weren’t adequately explained in this document, but I’m also interested in hearing about inaccuracies, typos, or any other constructive criticism you might have.Chapter 1 Introduction 1.1 Introduction FIGURE 1 This book is about two packages called Tcl and Tk. Together they provide a programming TABLE 1 system for developing and using graphical user interface (GUI) applications. Tcl stands for “tool command language” and is pronounced “tickle”; is a simple scripting language for controlling and extending applications. It provides generic programming facilities that are useful for a variety of applications, such as variables and loops and procedures. Fur- thermore, 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. One of the most useful extensions to Tcl is Tk. It is a toolkit for the X Window Sys- tem, and its name is pronounced “tee-kay”. Tk extends the core Tcl facilities with addi- tional commands for building user interfaces, so that you can construct Motif user interfaces by writing Tcl scripts instead of C code. Like Tcl, Tk is implemented as a library of C procedures so it too can be used in many different applications. Individual applica- tions can also extend the base Tk features with new user-interface widgets and geometry managers written in C. Together, Tcl and Tk provide four benefits to application developers and users. First, Tcl makes it easy for any application to have a powerful scripting language. All that an application needs to do is to implement a few new Tcl commands that provide the basic features of that application. Then the application can be linked with the Tcl interpreter to produce a full-function scripting language that includes both the commands provided by Tcl (called the Tcl core) and those implemented by the application (see Figure 1.1). 1 Copyright © 1993 Addison-Wesley Publishing Company, Inc. All rights reserved. Duplication of this draft is permitted by individuals for personal use only. Any other form of duplication or reproduction requires prior written permission of the author or pub- lisher. This statement must be easily visible on the first page of any reproduced copies. The publisher does not offer warranties in regard to this draft.2 Introduction Tcl Library Application Tcl Application Interpreter Data Structures Built-in Commands Application Commands Figure 1.1. To create a new application based on Tcl, an application developer designs new C data structures specific to that application and writes C code to implement a few new Tcl commands. The Tcl library provides everything else that is needed to produce a fully programmable command language. The application can then be modified and extended by writing Tcl scripts. For example, an application for reading electronic bulletin boards might contain C code that implements one Tcl command to query a bulletin board for new messages and another Tcl command to retrieve a given message. Once these commands exist, Tcl scripts can be written to cycle through the new messages from all the bulletin boards and display them one at a time, or keep a record in disk files of which messages have been read and which haven’t, or search one or more bulletin boards for messages on a particular topic. The bulletin board application would not have to implement any of these additional func- tions in C; they could all be written as Tcl scripts, and users of the application could write additional Tcl scripts to add more functions to the application. The second benefit of Tcl and Tk is rapid development. For example, many interest- ing windowing applications can be written entirely as Tcl scripts with no C code at all, using a windowing shell calledwish. This allows you to program at a much higher level than you would in C or C++, and many of the details that C programmers must address are hidden from you. Compared to toolkits where you program entirely in C, such as Xt/ Motif, there is much less to learn in order to use Tcl and Tk and much less code to write. New Tcl/Tk users can often create interesting user interfaces after just a few hours of learning, and many people have reported ten-fold reductions in code size and development time when they switched from other toolkits to Tcl and Tk. Another reason for rapid development with Tcl and Tk is that Tcl is an interpreted lan- guage. When you use a Tcl application such aswish you can generate and execute new scripts on-the-fly without recompiling or restarting the application. This allows you to test out new ideas and fix bugs very rapidly. Since Tcl is interpreted it executes more slowly than compiled C code, of course, but modern workstations are surprisingly fast. For exam- ple, you can execute scripts with hundreds or even thousands of Tcl commands on each movement of the mouse with no perceptible delay. In the rare cases where performance becomes an issue, you can re-implement the most performance-critical parts of your Tcl scripts in C. DRAFT (8/12/93): Distribution Restricted1.2 Organization of the book 3 The third benefit of Tcl is that it makes an excellent “glue language”. Because it is embeddable, it can be used for many different purposes in many different programs. Once this happens, it becomes possible to write Tcl scripts that combine the features of all the programs. For example, any windowing application based on Tk can issue a Tcl script to any other Tk application. This feature makes multi-media effects much more accessible: once audio and video applications have been built with Tk (and there exist several already), any Tk application can issue “record” and “play” commands to them. In addi- tion, spreadsheets can update themselves from database applications, user-interface edi- tors can modify the appearance and behavior of live applications as they run, and so on. Tcl provides the lingua franca that allows application to work together. The fourth benefit of Tcl is user convenience. Once a user learns Tcl and Tk, he or she can write scripts for any Tcl and Tk application merely by learning the few application- specific commands for the new application. This should make it possible for more users to personalize and enhance their applications. 1.2 Organization of the book Chapter 2 uses several simple scripts to provide a quick overview of the most important features of Tcl and Tk. It is intended to give you the flavor of the systems and convince you that they are useful without explaining anything in detail. The remainder of the book goes through everything again in a more comprehensive fashion. It is divided into four parts: • Part I introduces the Tcl scripting language. After reading this section you will be able to write scripts for Tcl applications. • Part II describes the additional Tcl commands provided by Tk, which allow you to cre- ate user-interface widgets such as menus and scrollbars and arrange them in windowing applications. After reading this section you’ll be able to create new windowing applica- tion aswish scripts and write scripts to enhance existing Tk applications. • Part III discusses the C procedures in the Tcl library and how to use them to create new Tcl commands. After reading this section you’ll be able to write new Tcl packages and applications in C. • Part IV describes Tk’s library procedures. After reading this section you’ll be able to create new widgets and geometry managers in C. Each of these major parts contains about ten short chapters. Each chapter is intended to be a self-contained description of a piece of the system, and you need not necessarily read the chapters in order. I recommend that you start by reading through Chapters 3-9 quickly, then skip to Chapters XXX-YYY, then read other chapters as you need them. Not every feature of Tcl and Tk is covered here, and the explanations are organized to provide a smooth introduction rather than a terse reference source. A separate set of refer- DRAFT (8/12/93): Distribution Restricted4 Introduction ence manual entries is available with the Tcl and Tk distributions. These are much more terse but they cover absolutely every feature of both systems. This book assumes that you are familiar with the C programming language as defined by the ANSI C standard, and that you have some experience with UNIX and X11. In order to understand Part IV you will need to understand many of the features provided by the Xlib interface, such as graphics contexts and window attributes; however, these details are not necessary except in Part IV. You need not know anything about either Tcl or Tk before reading this book; both of them will be introduced from scratch. 1.3 Notation Throughout the book I use aCourier font for anything that might be typed to a com- puter, such as variable names, procedure and command names, Tcl scripts, and C code. The examples of Tcl scripts use notation like the following: set a 44 ⇒ 44 Tcl commands such as “set a 44” is the example appear in Courier and their results, such as “44” in the example, appear in Courier oblique. The ⇒ symbol before the result indicates that this is a normal return value. If an error occurs in a Tcl command then the error message appears in Courier oblique, preceded by a ∅ symbol to indicate that this is an error rather than a normal return: set a 44 55 ∅ wrong args: should be "set varName ?newValue?" When describing the syntax of Tcl commands, Courier oblique is used for formal argument names. If an argument or group of arguments is enclosed in question marks it means that the arguments are optional. For example, the syntax of theset command is as follows: set varName ?newValue? This means that the wordset would be entered verbatim to invoke the command, while varName andnewValue are the names ofset’s arguments; when invoking the com- mand you would type a variable name instead ofvarName and a new value for the vari- able instead ofnewValue. ThenewValue argument is optional. DRAFT (8/12/93): Distribution RestrictedChapter 2 An Overview of Tcl and Tk This chapter introduces Tcl and Tk with a series of scripts that illustrate the main features FIGURE 2 of the systems. Although you should be able to start writing simple scripts after reading this chapter, the explanations here are not intended to be complete. All of the information TABLE 2 in this chapter will be revisited in more detail in later chapters, and several important aspects of the systems, such as their C interfaces, are not discussed at all in this chapter. The purpose of this chapter is to show you the overall structure of Tcl and Tk and the kinds of things they can do, so that when individual features are discussed in detail you’ll be able to see why they are useful. 2.1 Getting started In order to invoke Tcl scripts you must run a Tcl application. If Tcl is installed on your sys- tem then there should exist a simple Tcl shell application calledtclsh, which you can use to try out some of the examples in this chapter (if Tcl has not been installed on your system then refer to Appendix A for information on how to obtain and install it). Type the command tclsh to your shell to invoketclsh;tclsh will start up in interactive mode, reading Tcl com- mands from its standard input and passing them to the Tcl interpreter for evaluation. For starters, type the following command totclsh: expr 2 + 2 Tclsh will print the result “4” and prompt you for another command. 5 Copyright © 1993 Addison-Wesley Publishing Company, Inc. All rights reserved. Duplication of this draft is permitted by individuals for personal use only. Any other form of duplication or reproduction requires prior written permission of the author or pub- lisher. This statement must be easily visible on the first page of any reproduced copies. The publisher does not offer warranties in regard to this draft.6 An Overview of Tcl and Tk This example illustrates several features of Tcl. First, Tcl commands are similar in form to shell commands. Each command consists of one or more words separated by spaces or tabs. In the example there are four words:expr,2,+, and2. The first word of each command is its name: the name selects a C procedure in the application that will carry out the function of the command. The other words are arguments that are passed to the C procedure.Expr is one of the core commands built into the Tcl interpreter, so it exists in every Tcl application. It concatenates its arguments into a single string and evalu- ates the string as an arithmetic expression. Each Tcl command returns a result string. For theexpr command the result is the value of the expression. Results are always returned as strings, soexpr converts its numerical result back to a string in order to return it. If a command has no meaningful result then it returns an empty string. From now on I will use notation like the following to describe examples: expr 2 + 2 ⇒ 4 The first line is the command you type and the second line is the result returned by the command. The ⇒ symbol indicates that the line contains a return value; the ⇒ will not actually be printed out bytclsh. I will omit return values in cases where they aren’t important, such as sequences of commands where only the last command’s result matters. Commands are normally terminated by newlines, so when you are typing totclsh each line normally becomes a separate command. Semi-colons also act as command sepa- rators, in case you wish to enter multiple commands on a single line. It is also possible for a single command to span multiple lines; you’ll see how to do this later. Theexpr command supports an expression syntax similar to that of expressions in ANSI C, including the same precedence rules and most of the C operators. Here are a few examples that you could type totclsh: expr 3 2 ⇒ 12 expr 14.16 ⇒ 84.6 expr (3 4) (6 = 7) ⇒ 1 The first example illustrates the bitwise left-shift operator. The second example shows that expressions can contain real values as well as integer values. The last example shows the use of relational operators and= and the logical or operator. As in C, boolean results are represented numerically with 1 for true and 0 for false. To leavetclsh, invoke theexit command: exit This command will terminate the application and return you to your shell. DRAFT (8/12/93): Distribution Restricted2.2 Hello world with Tk 7 Figure 2.1. The “hello world” application. All of the decorations around the “Hello, world” button are provided by themwm window manager. If you use a different window manager then your decorations may be different. 2.2 Hello world with Tk Although Tcl provides a full set of programming features such as variables, loops, and procedures, it is not intended to be a stand-alone programming environment. Tcl is intended to be used as part of applications that provide their own Tcl commands in addi- tion to those in the Tcl core. The application-specific commands provide interesting prim- itives and Tcl is used to assemble the primitives into useful functions. Tcl by itself isn’t very interesting and it is hard to motivate all of Tcl’s facilities until you have seen some interesting application-specific commands to use them with. Tk provides a particularly interesting set of commands to use with Tcl’s programming tools. Most of the examples in the book will use an application calledwish, which is sim- ilar totclsh except that it also includes the commands defined by Tk. Tk’s commands allow you to create graphical user interfaces. If Tcl and Tk have been installed on your system then you can invokewish from your shell just liketclsh; it will display a small empty window on your screen and then read commands from standard input. Here is a simplewish script: button .b -text "Hello, world" -command exit pack .b If you type these two Tcl commands towish the window’s appearance will change to what is shown in Figure 2.1. If you then move the pointer over the window and click mouse button 1, the window will disappear andwish will exit. There are several things to explain about this example. First let us deal with the syn- tactic issues. The example contains two commands,button andpack, both of which are implemented by Tk. Although these commands look different than theexpr com- mand in the previous section, they have the same basic structure as all Tcl commands, consisting of one or more words separated by white space. Thebutton command con- tains six words and the pack command contains two words. The fourth word of thebutton command is enclosed in double quotes. This allows the word to include white space characters: without the quotes “Hello,” and “world” would be separate words. The double-quotes are not part of the word itself; they are removed by the Tcl interpreter before the word is passed to the command as an argument. DRAFT (8/12/93): Distribution Restricted8 An Overview of Tcl and Tk For theexpr command the word structure doesn’t matter much sinceexpr concate- nates all its arguments together. However for thebutton andpack commands, and for most Tcl commands, the word structure is important. Thebutton command expects its first argument to be the name of a window and the following arguments to come in pairs, where the first argument of each pair is the name of a configuration 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 configuration option. Since there is no option defined 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 reflect their position in the hierarchy. The main widget, which appeared on the screen when you startedwish, has the name “.”. The name.b refers to a child of the main widget. Widget names in Tk are like file 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 thebutton command creates button widgets. All of the widget creation commands have the same form: the first argument is the name of a new widget to create and additional arguments specify configuration options. Different widget classes support different sets of options. Widgets typically have many options (there are about 20 different options defined for buttons, for example), and default values are pro- vided for the options that you don’t specify. When a widget creation command likebut- ton is invoked it creates a new window by the given name and configures it as specified by the options. Thebutton command in the example specifies 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 isexit. 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. DRAFT (8/12/93): Distribution Restricted2.3 Script files 9 Thepack 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. Thepack command in the example asks a geometry manager called the packer to manage.b. The command asks that.b fill 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 thepack command the main window shrunk from its original size to the size that appears in Figure 2.1. 2.3 Script files In the examples so far you have typed Tcl commands interactively totclsh orwish. You can also place commands into script files and invoke the script files just like shell scripts. To do this for the hello world example, place the following text in a file 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 first line. As far aswish is concerned this line is a comment but if you make the file executable (type “chmod 775 hello” to your shell, for example) you can then invoke the file directly by typinghello to your shell. When you do this the system will invokewish, passing it the file 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 ifwish is installed in/usr/local/bin. Ifwish has been installed somewhere else then you’ll need to change the first line to reflect 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 file. During debugging, though, it is common for application developers to type Tcl com- mands interactively. For example, you could test out thehello script by startingwish interactively (typewish to your shell instead ofhello). Then type the following Tcl command: source hello DRAFT (8/12/93): Distribution Restricted10 An Overview of Tcl and Tk Source is a Tcl command that takes a file name as argument. It reads the file 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 file to change the-command option to -command "puts Good-bye; exit" then type the following commands interactively towish without restarting the program: destroy .b source hello The first 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 theputs command will print a message on standard output beforewish 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 eithertclsh orwish: set a 44 ⇒ 44 expr a4 ⇒ 176 The first command assigns the value “44” to variablea 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 byexpr is “444”. 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 inexpr if the value ofa 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 a4 ⇒ 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”. DRAFT (8/12/93): Distribution Restricted2.5 Control structures 11 2.5 Control structures The next example uses variables and substitutions along with some simple control struc- tures to create a Tcl procedurepower that raises a base to an integer power: proc power base p set result 1 while p 0 set result expr resultbase set p expr p-1 return result If you type the above lines towish ortclsh, or if you enter them into a file and then source the file, a new commandpower 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 theproc command starts after the open brace on the first 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, toproc 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 toproc without any special processing. Theproc 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 first argu- ment to power andp will hold the second argument. The body of thepower procedure contains three Tcl commands:set,while, and return. Thewhile 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. Thewhile 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 thewhile command multi- DRAFT (8/12/93): Distribution Restricted12 An Overview of Tcl and Tk plies the result value bybase and then decrementsp. Whenp reaches zero the result con- tains the desired power ofbase. Thereturn 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 ofpower this would be the result ofwhile, which is always an empty string. The use of braces in this example is crucial. The single most difficult 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 thewhile command is enclosed in braces for the same rea- son: rather than performing the substitutions once, while parsing thewhile 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 towhile. Without them the value of variablep would be substituted when parsing thewhile command; the expression would have a constant value andwhile 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 thatwhile andproc are not special syntactic elements in Tcl. They are just commands that take arguments just like all Tcl commands. The only special thing aboutwhile andproc is that they treat some of their arguments as Tcl scripts and cause the scripts to be evaluated. Many other commands also do this. Thebutton command was one example (its-com- mand option is a Tcl script), and you’ll read about several other control structures later on, such asfor,foreach,case, andeval. One final note about procedures. The variables in a procedure are normally local to that procedure and will not be visible outside the procedure. In thepower example the local variables include the argumentsbase andp as well as the variableresult. 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- DRAFT (8/12/93): Distribution Restricted2.6 Event bindings 13 Figure 2.2. A graphical user interface that computes powers of a base. ables named outside any procedure are called global variables; they last forever unless explicitly deleted. You’ll find out later how a procedure can access global variables and the local variables of other active procedures. 2.6 Event bindings The next example provides a graphical front-end for thepower procedure. In addition to demonstrating two new widget classes it illustrates Tk’s binding mechanism. A binding causes a particular Tcl script to be evaluated whenever a particular event occurs in a par- ticular window. The-command option for buttons is an example of a simple binding implemented by a particular widget class. Tk also includes a more general mechanism that can be used to extend the behavior of arbitrary widgets in nearly arbitrary ways. To run the example, copy the following script into a filepower and invoke the file from your shell. /usr/local/bin/wish -f proc power base p set result 1 while p 0 set result expr resultbase set p expr p-1 return result entry .base -width 6 -relief sunken -textvariable base label .label1 -text "to the power" entry .power -width 6 -relief sunken -textvariable power label .label2 -text "is" label .result -textvariable result pack .base .label1 .power .label2 .result \ -side left -padx 1m -pady 2m bind .base Return set result power base power bind .power Return set result power base power This script will produce a screen display like that in Figure 2.2. There are two entry wid- gets in which you can click with the mouse and type numbers. If you type return in either DRAFT (8/12/93): Distribution Restricted14 An Overview of Tcl and Tk of the entries, the result will appear on the right side of the window. You can compute dif- ferent results by modifying either the base or the power and then typing return again. This application consists of five widgets: two entries and three labels. Entries are wid- gets that display one-line text strings that you can edit interactively. The two entries, .base and.power, are used for entering the numbers. Each entry is configured with a -width of 6, which means it will be large enough to display about 6 digits, and a -relief ofsunken, which gives the entry a depressed appearance. The -textvariable option for each entry specifies the name of a global variable to hold the entry’s text: any changes you make in the entry will be reflected in the variable and vice versa. Two of the labels,.label1 and.label2, hold decorative text and the third, .result, holds the result of the power computation. The-textvariable option for .result causes it to display whatever string is in global variableresult whereas.label1 and.label2 display constant strings. Thepack command arranges the five widgets in a row from left to right. The com- mand occupies two lines in the script; the backslash at the end of the first line is a line-con- tinuation character: it causes the newline to be treated as a space. The-side option means that each widget is placed at the left side of the remaining space in the main widget: first.base is placed at the left edge of the main window, then.label1 is placed at the left side of the space not occupied by.base, and so on. The-padx and-pady options make the display a bit more attractive by arranging for 1 millimeter of extra space on the left and right sides of each widget, plus 2 millimeters of extra space above and below each widget. The “m” suffix specifies millimeters; you could also use “c” for centimeters, “i” for inches, “p” for points, or no suffix for pixels. Thebind commands connect the user interface to thepower procedure. Eachbind command has three arguments: the name of a window, an event specification, and a Tcl script to invoke when the given event occurs in the given window.Return specifies an event consisting of the user typing the return key on the keyboard. Here are a few other event specifiers that you might find useful: Button-1 Mouse button 1 is pressed. ButtonRelease-1 Mouse button 1 is released. Double-Button-1 Double-click on mouse button 1. 1 Short-hand forButton-1. Key-a Key “a” is pressed. a ora Short-hand forKey-a. Motion Pointer motion with no buttons or modifier keys pressed. B1-Motion Pointer motion with button 1 pressed. Any-Motion Pointer motion with any (or no) buttons or modifier keys pressed. DRAFT (8/12/93): Distribution Restricted2.7 Subprocesses 15 The scripts for the bindings invokepower, passing it the values in the two entries, and they store the result inresult so that it will be displayed in the.result widget. These bindings extend the generic built-in behavior of the entries (editing text strings) with application-specific behavior (computing a value based on two entries and displaying that value in a third widget). The script for a binding has access to several pieces of information about the event, such as the location of the pointer when the event occurred. For an example, start upwish interactively and type the following command to it: bind . Any-Motion puts "pointer at %x,%y" Now move the pointer over the window. Each time the pointer moves a message will be printed on standard output giving its new location. When the pointer motion event occurs, Tk scans the script for % sequences and replaces them with information about the event before passing the script to Tcl for evaluation.%x is replaced with the pointer’s x-coordi- nate and%y is replaced with the pointer’s y-coordinate. 2.7 Subprocesses Normally Tcl executes each command by invoking a C procedure in the application to carry out its function; this is different from a shell program likesh where each command is normally executed in a separate subprocess. However, Tcl also allows you to create sub- processes, using theexec command. Here is a simple example ofexec: exec grep include tk.h ⇒ include tcl.h include X11/Xlib.h include stddef.h Theexec command treats its arguments much like the words of a shell command line. In this exampleexec creates a new process to run thegrep program and passes it “include” and “tk.h” as arguments, just as if you had typed grep include tk.h to your shell. Thegrep program searches filetk.h for lines that contain the string include and prints those lines on its standard output. However,exec arranges for standard output from the subprocess to be piped back to Tcl.Exec waits for the process to exit and then it returns all of the standard output as its result. With this mechanism you can execute subprocesses and use their output in Tcl scripts.Exec also supports input and out- put redirection using standard shell notation such as,, and, pipelines with, and background processes with&. The example below creates a simple user interface for saving and re-invoking com- monly used shell commands. Type the following script into a file namedredo and invoke it: DRAFT (8/12/93): Distribution Restricted16 An Overview of Tcl and Tk (a) (c) (b) Figure 2.3. Theredo application. The user can type a command in the entry window, as in (a). When the user types return the command is invoked as a subprocess usingexec and a new button is created that can be used to re-invoke the command later, as in (b). Additional commands can be typed to create additional buttons, up to a limit of five buttons as in (c). /usr/local/bin/wish -f set id 0 entry .entry -width 30 -relief sunken -textvariable cmd pack .entry -padx 1m -pady 1m bind .entry Return set id expr id + 1 if id 5 destroy .bexpr id - 5 button .bid -command "exec stdin stdout cmd" \ -text cmd pack .bid -fill x .bid invoke .entry delete 0 end Initially the script creates an interface with a single entry widget. You can type a shell command such asls into the entry, as shown in Figure 2.3(a). When you type return the command gets executed just as if you had typed it to the shell from which you invoked redo, and output from the command appears in the shell’s window. Furthermore, the script creates a new button widget that displays the command (see Figure 2.3(b)) and you can re-invoke the command later by clicking on the button. As you type more and more commands, more and more buttons appear, up to a limit of five remembered commands as in Figure 2.3(c). DRAFT (8/12/93): Distribution Restricted2.7 Subprocesses 17 Note: This example suffers from several limitations. For example, you cannot specify wild-cards such as “” in command lines, and the “cd” command doesn’t behave properly. In Part I you’ll read about Tcl facilities that you can use to eliminate these limitations. The most interesting part of theredo script is in thebind command. The binding forReturn must execute the command, which is stored in thecmd variable, and cre- ate a new button widget. First it creates the widget. The button widgets have names like .b1,.b2, and so on, where the number comes from the variableid.Id starts at zero and increments before each new button is created. The notation “.bid” generates a wid- get name by “.b” and the value ofid. Before creating a new widget the script checks to see if there are already five saved commands; if so then the oldest existing button is deleted. The notation “.bexpr id - 5” produces the name of the oldest button by subtracting five from the number of the new button and concatenating it with “.b”. The- command option for the new button invokesexec and redirects standard input and stan- dard output for the subprocess(es) towish’s standard input and standard output, which are the same as those of the shell from whichwish was invoked: this causes output from the subprocesses to appear in the shell’s window instead of being returned towish. The command “pack .bid -fill x” makes the new button appear at the bot- tom of the window. The option “-fill x” improves the appearance by stretching the button horizontally so that it fills the width of the window even it it doesn’t really need that much space for its text. Try omitting the-fill option to see what happens without it. The last two commands of the binding script are called widget commands. Whenever a new widget is created a new Tcl command is also created with the same name as the widget, and you can invoke this command to communicate with the widget. The first argu- ment to a widget command selects one of several operations and additional arguments are used as parameters for that operation. In theredo script the first widget command causes the button widget to invoke its-command option just as if you had clicked the mouse button on it. The second widget command clears the entry widget in preparation for a new command to be typed. Each class of widget supports a different set of operations in its widget commands, but many of the operations are similar from widget to widget. For example, every widget class supports aconfigure widget command that can be used to modify any of the con- figuration options for the widget. If you run theredo script interactively you could type the following command to change the background of the entry widget to yellow: .entry configure -background yellow Or, you could type .b1 configure -foreground brown .b1 flash to change the color of the text in button.b1 to brown and then cause the button to flash. One of the most important things about Tcl and Tk is that they make every aspect of an application accessible and modifiable at run-time. For example, theredo script modi- DRAFT (8/12/93): Distribution Restricted18 An Overview of Tcl and Tk fies its own interface on the fly. In addition, Tk provides commands that you can use to query the structure of the widget hierarchy, and you can use configure widget com- mands to query and modify the configuration options of individual widgets. 2.8 Additional features of Tcl and Tk The examples in this chapter used every aspect of the Tcl language syntax and they illus- trated many of the most important features of Tcl and Tk. However, Tcl and Tk contain many other facilities that are not used in this chapter; all of these will be described later in the book. Here is a sampler of some of the most useful features that haven’t been men- tioned yet: Arrays and lists. Tcl provides associative arrays for storing key-value pairs efficiently and lists for managing aggregates of data. More control structures. Tcl provides several additional commands for controlling the flow of execution, such aseval,for,foreach, andswitch. String manipulation. Tcl contains a number of commands for manipulating strings, such as measuring their length and performing regular expression pattern matching and substitution. File access. You can read and write files from Tcl scripts and retrieve directory infor- mation and file attributes such as length and creation time. More widgets. Tk contains many widget classes besides those shown here, such as menus, scrollbars, a drawing widget called a canvas, and a text widget that makes it easy to achieve hypertext effects. Access to other X facilities. Tk provides commands for accessing all of the major facilities in the X Window System, such as a command for communicating with the window manager (to set the window’s title, for example), a command for retrieving the selection, and a command to manage the input focus. C interfaces. Tcl provides C library procedures that you can use to define your own new Tcl commands in C, and Tk provides a library that you can use to create your own widget classes and geometry managers in C. 2.9 Extensions and applications Tcl and Tk have an active and rapidly-growing user community that now numbers in the tens of thousands. Many people have built applications based on Tcl and Tk and packages that extend the base functionality of Tcl and Tk. Several of these packages and applica- tions are publically available and widely used in the Tcl/Tk community. There isn’t space in this book to discuss all of the exciting Tcl/Tk software in detail but this section gives a DRAFT (8/12/93): Distribution Restricted2.9 Extensions and applications 19 quick overview of five of the most popular extensions and applications. See Appendix A for information on how you can obtain them and other contributed Tcl/Tk software. 2.9.1 Expect Expect is one of the oldest Tcl applications and also one of the most popular. It is a pro- gram that “talks” to interactive programs. Following a script,expect knows what output can be expected from a program and what the correct responses should be. It can be used to automatically control programs likeftp,telnet,rlogin,crypt,fsck,tip, and others that cannot be automated from a shell script because they require interactive input. Expect also allows the user to take control and interact directly with the program when desired. For example, the followingexpect script logs into a remote machine using the rlogin program, sets the working directory to that of the originating machine, then turns control over to the user: /usr/local/bin/expect spawn rlogin lindex argv 1 expect -re "(%) " send "cd pwd\r" interact Thespawn,expect,send, andinteract commands are implemented byexpect, andlindex andpwd are built-in Tcl commands. Thespawn command starts uprlo- gin, using a command-line argument as the name of the remote machine. Theexpect command waits forrlogin to output a prompt (either “%” or “”, followed by a space), thensend outputs a command to change the working directory, just as if a user had typed the command interactively. Finally,interact causesexpect to step out of the way so that the user who invoked theexpect script can now talk directly torlogin. Expect can be used for many purposes, such as a scriptable front-end to debuggers, mailers, and other programs that don’t have scripting languages of their own. The pro- grams require no changes to be driven by expect.Expect is also useful for regression testing of interactive programs.Expect can be combined with Tk or other Tcl exten- sions. For example, using Tk it is possible to make a graphical front end for an existing interactive application without changing the application. Expect was created by Don Libes. 2.9.2 Extended Tcl Extended Tcl (TclX) is a library package that augments the built-in Tcl commands with many additional commands and procedures oriented towards system programming tasks. It can be used with any Tcl application. Here are a few of the most popular features of TclX: • Access to many additional POSIX system calls and functions. • A file scanning facility with functionality much like that of theawk program. DRAFT (8/12/93): Distribution Restricted

Advise: Why You Wasting Money in Costly SEO Tools, Use World's Best Free SEO Tool Ubersuggest.