TCL面向对象编程：快速构建大规模图形界面应用

4星 · 超过85%的资源需积分: 50 12 浏览量更新于2023-03-16 收藏 762KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源推荐

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页未读，继续阅读

corcoer2

粉丝: 0
资源: 1

会员权益专享

TCL面向对象编程：快速构建大规模图形界面应用

面向对象itcl

TCL脚本语言面向对象编程

itcl package

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

incr Tcl使用最广泛的OO系统-开源

2024java面试题

C课程设计之职工管理系统

PyOpenGL_accelerate-3.1.7-cp39-cp39-win_amd64.whl

【创新发文无忧】Matlab实现鲸鱼优化算法WOA-Kmean-Transformer-GRU故障诊断算法研究.rar

单片机控制的频率跟踪超声波电源的研究

【创新发文无忧】Matlab实现开普勒优化算法KOA-Kmean-Transformer-GRU故障诊断算法研究.rar

城市路灯集中管控和能耗监测系统软件设计方案.doc

Elman神经网络的数据预测----电力负荷预测模型研究.rar

LIBSVM参数实例详解.rar

视频监控系统需求设计说明书.doc

DirectShow过滤器-H264解码器

QtInstallerFramework-windows-x64-4.6.1

Streamlit app with HuggingFace transformers and OpenAI models fo

C++字体解析库SDK

【JCR2区】Matlab实现北方苍鹰优化算法NGO-LSSVM实现数据分类算法研究.rar

会员权益专享

最新资源