快速开发GUI应用：Tcl/Tk与面向对象编程

需积分: 10 97 浏览量更新于2024-07-22 收藏 306KB PDF 举报

面向对象编程在ITCL中的应用与拓展 ITCL（Incr Tcl）是一种基于TCL（Tool Command Language）的高级编程框架，它扩展了TCL的核心功能，特别强调了面向对象（Object-Oriented Programming, OOP）的概念。TCL本身以其解释性、脚本友好性和强大的交互式开发环境而闻名，这使得它在快速原型设计和用户界面（Graphical User Interface, GUI）构建方面具有显著优势。通过集成[incrTk]工具包，ITCL进一步增强了TCL在创建大型GUI应用程序的能力，如构建复杂的窗口和组件，这些通常在像Motif这样的商业图形工具包中也需要大量时间和资源。在ITCL中，OOP的引入使得代码组织更为模块化和可重用，开发者能够以类和对象的形式管理程序逻辑，提高了开发效率。这种灵活性允许开发者快速迭代和测试新想法，缩短了产品上市周期，这对于竞争激烈的市场来说至关重要。由于TCL的解释型特性，任何对代码的修改都能立即在运行时看到效果，无需繁琐的编译、链接和运行流程，极大地加速了开发过程。《面向对象编程 with [incrTcl]》这本书由Michael J. McLennan撰写，他来自贝尔实验室（Bell Labs），代表了Lucent Technologies。书中详细介绍了如何利用ITCL进行高效的OOP实践，包括如何设计和实现类，以及如何利用继承、封装和多态等面向对象原则。此外，作者还展示了如何构建大型的GUI组件，使读者能够掌握在多种平台（如Unix、PC Windows和Macintosh）上实现一致用户体验的技术。总结来说，本书是面向希望在短周期内开发成功应用的开发者的宝贵资源，提供了ITCL和TCL语言环境下面向对象编程的最佳实践，是提升TCL开发技能和构建高效GUI应用的理想指南。通过阅读这本书，开发者不仅能学习到高效开发方法，还能深入了解如何将TCL的特性和OO理念结合，以适应不断变化的市场需求。

Tcl/Tk Tools

We simply add name and value variables to the class. We also define a

constructor, so that the name and the value are set when each object is created.

These are required arguments, so when we create a Tree node, the command

must look something like this:

Tree henry /usr/local/itcl 8619141

Actually, the name and value strings could be anything, but in this example, we

are using name to store the directory name, and value to store the directory size.

We have also added a destructor to the Tree so that when any node is

destroyed, it clears its list of children. This causes the children to be destroyed,

and their destructors cause their children to be destroyed, and so on. So

destroying any node causes an entire sub-tree to be recursively destroyed.

If we are moving up and down the tree and we reach a certain node, we will

probably want to find out its name and its value. Remember, variables like

name and value are kept hidden within an object. We can’t access them

directly. We can tell the object to do something only by calling one of its

methods. In this case, we invent a method called get that will give us access to

the necessary information. If we have a Tree node called henry, we might use

its get method like this:

puts "directory: [henry get -name]"

puts " size: [henry get -value]"

The get method itself is defined in Example 1-5. Its argument list looks a little

strange, but it is the standard Tcl syntax for an optional argument. The outer set

of braces represents the argument list, and the inner set represents one argu-

ment: its name is option, and its default value (if it is not specified) is

“-value”. So if we simply want the value, we can call the method without any

arguments, like this:

puts " size: [henry get]"

The get method merely looks at its option flag and returns the appropriate

information. We use a Tcl switch command to handle the various cases. Since

the option flag will start with a “-”, we are careful to include the “--” argu-

ment in the switch command. This tells the switch that the very next argument

is the string to match against, not an option for the switch command itself.

error "bad option \"$option\""

}

method contents {} {

return $children

}

Example 1-5 Tree class updated to store name/value pairs.

Chapter 1: Object-Oriented Programming with [incr Tcl]

With a new and improved Tree class in hand, we return to building a browser

for the Unix du utility. If you are not used to working with tree data structures,

this code may seem complicated. But keep in mind that it is the example

itself—not [INCR TCL]—that adds the complexity. If you don’t believe me, try

solving this same problem without [

INCR TCL]!

We create a procedure called get_usage to load the disk usage information for

any directory. This is shown in Example 1-6.

We simply pass it the name of a directory, and it runs the du program and

creates a tree to store its output. We use the Tcl exec command to execute the

du program, and we split its output into a list of lines. We traverse backward

through this list, starting at the root directory, and working our way downward

through the file hierarchy because the du program puts the parent directories

after their children in its output. We scan each line to pick out the directory

name and size, ignoring any lines have the wrong format. We create a new

Tree object to represent each directory. We don’t really care about the name of

the Tree object itself, and we don’t want to make up names like “henry” and

“jane”, so we use #auto to get automatically generated names. Once each Tree

node has been created, we add it into the node for its parent directory.

Finding the node for the parent directory is a little tricky. We can use the Tcl

“file dirname” command to get the name of the parent directory, but we must

figure out what Tree object represents this directory. We could scan through

Example 1-6 Disk usage information is stored in a tree.

set root ""

proc get_usage {dir} {

global root

if {$root != ""} {

delete object $root

}

set parentDir [file dirname $dir]

set root [Tree #auto $parentDir ""]

set hiers($parentDir) $root

set info [split [exec du -b $dir] \n]

set last [expr [llength $info]-1]

for {set i $last} {$i >= 0} {incr i -1} {

set line [lindex $info $i]

if {[scan $line {%d %s} size name] == 2} {

set hiers($name) [Tree #auto $name $size]

set parentDir [file dirname $name]

set parent $hiers($parentDir)

$parent add $hiers($name)

}

return $root

}

Tcl/Tk Tools

the entire tree looking for it, but that would be horribly slow. Instead, we create

a lookup table using an array called hiers that maps a directory name to its

corresponding Tree object. As we create each object, we are careful to store it

in this array so it can be found later when its children are created. Figure 1-6

shows the array and how the values relate to the directory structure we started

with.

Since we traverse backward through the du output, parent Tree nodes will

always be created and entered into the hiers array before their child nodes.

The only exception is the parent for the very first node. It will not appear in the

output from du, so we have to create it ourselves to get everything started. We

call this the root node, and we save its name in a global variable called root.

The next time we call get_usage, we can destroy the old tree simply by

destroying the root node, and then start a new tree by creating a new root node.

We can put all of this together in an application like the one shown in Figure 1-

5. A complete example appears in the file itcl/tree/tree2.itcl, so I will not show

all of the code here. But it works something like this. When the user types a

directory name at the top of this application, we call the procedure get_usage

to execute du and build a tree containing the output. We then call another proce-

dure show_usage to display the root object in a listbox. The code for

show_usage appears in Example 1-7.

We start by clearing the listbox and clearing any elements that might have been

selected. If this node has a parent, we add the BACK UP element at the top of

the listbox. Double-clicking on this element will invoke show_usage for the

parent directory, so you can move back up in the hierarchy. We use the

Figure 1-6 Finding directories in a tree of disk usage information.

...

tree2

tree3

...

tree4

...

tree5

tree1

/usr/local tree1

/usr/local/itcl tree2

/usr/local/itcl/bin tree3

/usr/local/itcl/lib tree4

/usr/local/itcl/man tree5

array hiers:

tree1

variable root:

... ...

Chapter 1: Object-Oriented Programming with [incr Tcl]

contents method to scan through the list of child nodes, and for each of these

nodes, we add an element showing the directory size and its name. Double-

clicking on any of these elements will invoke show_usage for their node, so

you can move down in the hierarchy. We use a constant-width font for the

listbox, and we format each line with the Tcl format command, to make sure

that size and name fields align properly as two columns.

Notice that as we create each element, we are careful to build an array called

lbox which maps the element number to a Tree node. Later on when we get a

double-click, we can use this array to figure out which Tree node to show. We

simply add a binding to the listbox like this:

bind .display.lbox <Double-ButtonPress-1> {

set index [.display.lbox nearest %y]

show_usage $lbox($index)

break

}

When the double-click occurs, the %y field is replaced with the y-coordinate of

the mouse pointer, and the listbox nearest operation returns the number of the

element nearest this position. We convert this to the corresponding Tree object

using the lbox array, and then use show_usage to display the information for

that node. Normally, the double-click would also be handled as another ordi-

nary button press event, but we are careful to avoid this by breaking out of any

further event processing.

Without the Tree class, this application would have been considerably more

difficult to write. [INCR TCL] solves the problem by providing a way to create

new data structures. Data structures are encapsulated with a well-defined set of

Example 1-7 The contents of any Tree node can be displayed in a listbox.

proc show_usage {obj} {

global root lbox

catch {unset lbox}

.display.lbox delete 0 end

.display.lbox selection clear 0 end

set counter 0

if {[$obj get -parent] != ""} {

.display.lbox insert end " <- BACK UP"

set lbox($counter) [$obj get -parent]

incr counter

}

foreach kid [$obj contents] {

set name [$kid get -name]

set size [$kid get -value]

.display.lbox insert end [format "%9d %-50s" $size $name]

set lbox($counter) $kid

incr counter

}

剩余117页未读，继续阅读

yyy20150301

粉丝: 0
资源: 1

快速开发GUI应用：Tcl/Tk与面向对象编程

面对对象的TCL编程--ITCL [incr TCL]

itcl package

CD30在不同淋巴瘤的表达比例及相关文献

湖北工业大学在河南2021-2024各专业最低录取分数及位次表.pdf

西南交通大学在河南2021-2024各专业最低录取分数及位次表.pdf

DAY27使用的实时脚本文件

天水师范学院在河北2021-2024各专业最低录取分数及位次表.pdf

matlab simulink 双馈风机调频，风电调频，风火水调频，虚拟惯性控制，下垂控制 参与系统一次调频的Matlab Si

基于python实现的给定微博数据的反作弊识别

linux下文件删除脚本

最新资源

matlab simulink 双馈风机调频，风电调频，风火水调频，虚拟惯性控制，下垂控制参与系统一次调频的Matlab Si