其它语言_程序设计与WEB开发_计算机类_最新资料_得益网

css商业网站布局之道第一章

2008-09-03 15:31:39

css商业网站布局之道

OReilly.Learning.Perl.5th.Edition.Jul

2008-08-29 22:41:55

Preface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xi
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Questions and Answers 1
What Does “Perl” Stand For? 4
How Can I Get Perl? 8
How Do I Make a Perl Program? 12
A Whirlwind Tour of Perl 16
Exercises 17
2. Scalar Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Numbers 19
Strings 22
Perl’s Built-in Warnings 26
Scalar Variables 27
Output with print 29
The if Control Structure 33
Getting User Input 34
The chomp Operator 35
The while Control Structure 36
The undef Value 36
The defined Function 37
Exercises 38
3. Lists and Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Accessing Elements of an Array 40
Special Array Indices 41
List Literals 41
List Assignment 43
Interpolating Arrays into Strings 46
The foreach Control Structure 47
Scalar and List Context 49
v
<STDIN> in List Context 52
Exercises 54
4. Subroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Defining a Subroutine 55
Invoking a Subroutine 56
Return Values 56
Arguments 58
Private Variables in Subroutines 60
Variable-Length Parameter Lists 60
Notes on Lexical (my) Variables 63
The use strict Pragma 64
The return Operator 65
Nonscalar Return Values 67
Persistent, Private Variables 68
Exercises 69
5. Input and Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Input from Standard Input 71
Input from the Diamond Operator 73
The Invocation Arguments 75
Output to Standard Output 76
Formatted Output with printf 79
Filehandles 81
Opening a Filehandle 83
Fatal Errors with die 86
Using Filehandles 88
Reopening a Standard Filehandle 90
Output with say 90
Exercises 91
6. Hashes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
What Is a Hash? 93
Hash Element Access 96
Hash Functions 100
Typical Use of a Hash 103
The %ENV hash 104
Exercises 105
7. In the World of Regular Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
What Are Regular Expressions? 107
Using Simple Patterns 108
Character Classes 113
vi | Table of Contents
Exercises 115
8. Matching with Regular Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Matches with m// 117
Option Modifiers 118
Anchors 120
The Binding Operator, =~ 121
Interpolating into Patterns 122
The Match Variables 123
General Quantifiers 129
Precedence 130
A Pattern Test Program 132
Exercises 132
9. Processing Text with Regular Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Substitutions with s/// 135
The split Operator 138
The join Function 139
m// in List Context 140
More Powerful Regular Expressions 140
Exercises 147
10. More Control Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
The unless Control Structure 149
The until Control Structure 150
Expression Modifiers 151
The Naked Block Control Structure 152
The elsif Clause 153
Autoincrement and Autodecrement 154
The for Control Structure 155
Loop Controls 158
The Ternary Operator, ?: 162
Logical Operators 164
Exercises 168
11. Perl Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Finding Modules 169
Installing Modules 170
Using Simple Modules 171
Exercise 177
12. File Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
File Test Operators 179
Table of Contents | vii
The stat and lstat Functions 186
The localtime Function 187
Bitwise Operators 188
Exercises 189
13. Directory Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
Moving Around the Directory Tree 191
Globbing 192
An Alternate Syntax for Globbing 193
Directory Handles 194
Recursive Directory Listing 195
Manipulating Files and Directories 195
Removing Files 196
Renaming Files 197
Links and Files 198
Making and Removing Directories 203
Modifying Permissions 205
Changing Ownership 205
Changing Timestamps 206
Exercises 206
14. Strings and Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Finding a Substring with index 209
Manipulating a Substring with substr 210
Formatting Data with sprintf 212
Advanced Sorting 214
Exercises 219
15. Smart Matching and given-when . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
The Smart Match Operator 221
Smart Match Precedence 224
The given Statement 225
when with Many Items 229
Exercises 230
16. Process Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
The system Function 233
The exec Function 236
The Environment Variables 237
Using Backquotes to Capture Output 238
Processes as Filehandles 241
Getting Down and Dirty with Fork 243
Sending and Receiving Signals 244
viii | Table of Contents
Exercises 246
17. Some Advanced Perl Techniques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Trapping Errors with eval 249
Picking Items from a List with grep 252
Transforming Items from a List with map 253
Unquoted Hash Keys 254
Slices 254
Exercise 259
A. Exercise Answers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
B. Beyond the Llama . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315

WAP网站实例解析

2008-08-26 10:47:48

第一章会员登录网页
1-1WAP网站一定要有个人化
1-2如何建立WAP入口网站的个人化设置
第二章生活宅急便
2-1网络花店
2-2旅馆订房
2-3在线租车
2-4餐厅订位
2-5在线租片
第三章任我行交通网
3-1即时路况查询
3-2公交车路线查询
3-3火车时刻表查询及订票
3-4航班查询及订位
3-5捷运票价查询
第四章生活博士
4-1随身食谱
4-2购物指南
第五章滚钱专家
5-l股市查询
5-2期货查询
5-3投资指南
第六章小蜗牛的家
6-1租屋查询
第七章WAPMail
7-1电子邮件收发
第二篇WAP执行环境建置
第八章WAP网站架设
8-1WindowsNT＆IIS的WAP网站架设
8-2Linux＆Apache的WAP网站架设
第九章摸拟器安装及使用
9-1EricssonWapIDE
9-2NokiaWapToolkit
9-3其他模拟器安装及使用
第十章开发工具建置
10-1ASP环境建置
10-2PHP环境建置
10-3JDK环境建置
10-4JSP及Servlet环境建置
第十一章网络花店（JSP+SQLServer）
11-1信息源建置——SQLServer7.0数据库建置
11-2程序编写
第十二章旅馆订房（JSP+SQLServer）
12-1信息源建置
12-2程序编写
第十三章即时路况查询（JSP+textfile）
13-1信息源建置及网页规划
13-2程序编写
第十四章火车时刻表查询及订票（ASP+SQLServer）
14-1信息源建置
14-2程序编写
第十五章捷运票价查询（JavaServlet+textfile）
15-1信息源规划
15-2程序编写
第十六章随身食谱（JSP+SQLServer）
16-1信息源建置
16-2程序编写
第十七章股市查询（ASP+VisualBasic）
17-1信息源建置
17-2程序编写
第十八章投资指南（PHP语言）（PHP+Textfile）
18-1情息源建置
18-2程序编写
第十九章租屋查询（ASP+SQLServer）
19-1信息源建置
19-2程序编写
第二十章电子邮件收发（PHP+Mailserver）
20-1发信程序编写
20-2收信程序编写

Prentice.Hall.A.Practical.Guide.To.Linux.Commands.Editors.And.Shell.Programming.2005

2008-08-24 16:50:31

Copyright
Praise for Mark Sobell's Books
Preface
Command line interface (CLI)
Linux distributions
Overlap
Audience
Benefits
Features Of This Book
Contents
Supplements
Thanks
Chapter 1. Welcome to Linux
Free beer
The Gnu–Linux Connection
The Heritage of Linux: Unix
What is so good about linux?
Overview of Linux
Additional Features of Linux
Chapter Summary
Exercises
Part I. The Linux Operating System
Chapter 2. Getting Started
Conventions Used in This Book
Logging In
Working with the Shell
Curbing Your Power: Superuser Access
Getting the Facts: Where to Find Documentation
More About Logging In
Chapter Summary
Exercises
Advanced Exercises
Chapter 3. Command Line Utilities
Special Characters
Basic Utilities
Working with Files
| (Pipe): Communicates Between Processes
Four More Utilities
Compressing and Archiving Files
Locating Commands
Obtaining User and System Information
Communicating with Other Users
Email
Chapter Summary
Exercises
Advanced Exercises
Chapter 4. The Linux Filesystem
The Hierarchical Filesystem
Directory and Ordinary Files
Working with Directories
touch
Access peremissions
Links
Chapter summary
Exercises
ADVANCED EXERCISES
Chapter 5. The Shell
The Command Line
Standard Input and Standard Output
Running a Program in the Background
Filename Generation/Pathname Expansion
Builtins
Chapter Summary
Exercises
Advanced Exercises
Part II. The Editors
Chapter 6. The vim Editor
History
Tutorial: Creating and Editing a File with vim
The compatible Parameter
Introduction to vim Features
Command Mode: Moving the Cursor
Input Mode
Command Mode: Deleting and Changing Text
Searching and Substituting
Miscellaneous Commands
Yank, Put, and Delete Commands
Reading and Writing Files
Setting Parameters
Advanced Editing Techniques
Units of Measure
Chapter Summary
Exercises
Advanced Exercises
Chapter 7. The emacs Editor
History
Tutorial: Getting Started with emacs
Basic Editing Commands
Online Help
Advanced Editing
Language-Sensitive Editing
More Information
Chapter Summary
Exercises
Advanced Exercises
Part III. THE SHELLS
Chapter 8. The Bourne Again Shell
Background
Shell Basics
Parameters and Variables
Processes
History
Aliases
Functions
Controlling bash Features and Options
Processing The Command Line
Chapter Summary
Exercises
Advanced Exercises
Chapter 9. The Tc Shell
Assignment statement
Part IV. Programming Tools
Chapter 10. Programming Tools
Programming In C
Using Shared Libraries
make: Keeps a Set of Programs Current
Debugging C Programs
Threads
System Calls
Source Code Management
Chapter Summary
Exercises
Advanced Exercises
Chapter 11. Programming The Bourne Again Shell
Control Structures
file Descriptors
Parameters And Variables
Builtin Commands
Expressions
Shell Programs
Chapter Summary
Exercises
Advanced Exercises
Chapter 12. The gawk Pattern Processing Language
Syntax
Arguments
Options
Notes
Language Basics
Examples
Error Messages
Chapter Summary
Exercises
Advanced Exercises
Chapter 13. The sed Editor
Syntax
Arguments
Options
Editor Basics
Examples
Chapter Summary
Exercises
Part V. Command Reference
Command Reference
Utilities That Display and Manipulate Files
Network Utilities
Utilities That Display and Alter Status
Utilities That Are Programming Tools
Miscellaneous Utilities
Standard Multiplicative Suffixes
Common Options
The sample Utility
Part VI. Appendixes
Appendix A. Regular Expressions
Characters
Delimiters
Simple Strings
Special Characters
Rules
Bracketing Expressions
The Replacement String
Extended Regular Expressions
Appendix Summary
Appendix B. Help
Solving A Problem
Finding Linux-Related Information
Specifying a Terminal
Appendix C. Keeping The System Up-To-Date
yum: Updates And Installs Packages
APT: An Alternative To yum
BitTorrent
Glossary

战胜Javascript必做练习50题

2008-08-21 22:15:45

【内容简介】
　　本书以50个精选的Javascript程序实例作为练习，每个例子均有详细的操作步骤，并附有针对性很强的思考题，有助于读者快速巩固和提高自己的Javascript编程水平。
　　在内容编排上，本书将50个练习按照浏览器相关、页面特效、时间日期、图形图像Cookie，菜单特效、鼠标特效、综合技巧和游戏编程分类，同时又兼顾了从易到难、由浅入深的一般学习顺序。
　　本书主要面向具有一定Javascript和HTML语言基础，能够读懂简单的Javascript脚本程序，希望进一步提高Javascript编程水平的初、中级读者。同时，本书的50个练习中，也不乏功能强大，设计精妙的程序实例，对高水平的读者亦有参考价值。希望各个层次的读者都能在本书中有所收获。
　　本书含1张教学光盘。
【下载说明】
　　Javascript在交互式网页设计中历来占有举足轻重的地位。近年来，随着Ajax技术的兴起，作为其核心技术之一的Javascript更是在Web开发中备受推崇，甚至在最近火爆的网页游戏开发中也大展拳脚，因此学好Javascript对于Web设计人员是极其重要的。《战胜Javascript必做练习50题》是针对Javascript这一门实践性极强技术的优秀教材，本资料为该书PDF格式的清晰电子版，可用Adobe Reader 7.0或兼容阅读工具打开，强烈推荐Web设计人员下载！
【图书目录】
练习1 Title栏特效
练习2 模拟街霸
练习3 检测浏览器信息并跳转到相应页面
练习4 表单检验
练习5 页面的百叶窗打开效果
练习6 页面放射性收缩打开
练习7 页面的马赛克打开特效
练习8 COOL电子表
练习9 机械手表(一)
练习10 节日提示
练习11 袖珍日历
练习12 鼠标经过时变换图像
练习13 漂浮的图像
练习14 雪花飞舞
练习15 落叶飘飘
练习16 多媒体播放
练习17 以任意格式打开新窗口
练习18 科学计算器
练习19 滤镜效果
练习20 状态栏特效(一)
练习21 状态栏特效(二)
练习22 记录用户访问次数
练习23 记录上次访问时间
练习24 系统详细信息检测
练习25 配图游戏
练习26 走迷宫(一)
练习27 走迷宫(二)
练习28 测试鼠标点击速度
练习29 测试打字速度
练习30 折叠式菜单
练习31 下拉式菜单
练习32 隐藏菜单
练习33 淡入淡出菜单
练习34 仿OICQ菜单
练习35 在线考试(一)
练习36 在线考试(二)
练习37 图像跟随鼠标
练习38 图像围绕鼠标旋转
练习39 跟随鼠标的字符
练习40 跟随鼠标的流星雨
练习41 鼠标礼花
练习42 探照灯效果
练习43 搜索引擎接口
练习44 危险程序
练习45 猜数字
练习46 汉诺塔问题
练习47 给源代码加密
练习48 俄罗斯方块(一)
练习49 俄罗斯方块(二)
练习50 俄罗斯方块(三)

Beginning Game Development with Python and Pygame

2008-08-21 20:49:11

Product Description

Like music and movies, video games are rapidly becoming an integral part of our lives. Over the years, you’ve yearned for every new gaming console, mastered each blockbuster within weeks after its release, and have even won a local gaming competition or two. But lately you’ve been spending a lot of time thinking about a game idea of your own, or are exploring the possibility of making a career of this vibrant and growing industry. But where should you begin?

Beginning Game Development with Python and Pygame is written with the budding game developer in mind, introducing games development through the Python programming language and the popular Pygame games development library. Authored by industry veteran and Python expert Will McGugan, who most recently worked on the MotorStorm game for Play Station 3, you’ll be privy to insights that will not only help you to exploit PyGame to its maximum potential, but also make you a more creative and knowledgeable games developer all round.

* Learn how to create advanced games by taking advantage of the popular open source Python programming language and Pygame games development library.
* Learn about coding gaming preferences, sound, visual effects, and joystick/keyboard interaction.
* Discover the concepts that are crucial to success in todays gaming industry, such as support for multiple platforms, and granting users the ability to extend and customize your games.

What you’ll learn

* Take advantage of Python and the Pygame library to build compelling cross-platform games.
* Learn to best use these technologies to turn your dream game into reality.
* Create professional games by accounting for sound, special effects, and user interaction through the joystick and keyboard.
* Build both two- and three-dimensional games, and learn more about the factors that contribute to choosing one approach over the other.
* Provide users with the means for extending your games through level creation and custom modifications as a means to build a vibrant community around your product.
* Package your games in a manner that allows even novice computer users to install, use, and update your games with ease.

Who is this book for?

This book has been written for any budding games developer. While knowledge of the Python language helps, it isn’t required. To help new programmers along, two early chapters are devoted to an overview of Python.
About the Apress Beginning Series

The Beginning series from Apress is the right choice to get the information you need to land that crucial entry-level job. These books will teach you a standard and important technology from the ground up because they are explicitly designed to take you from “novice to professional.” You’ll start your journey by seeing what you need to know, but without needless theory and filler. You’ll build your skill set by learning how to put together real-world projects step by step. So whether your goal is your next career challenge or a new learning opportunity, the Beginning series from Apress will take you there. It is your trusted guide through unfamiliar territory!

About the Author

Will McGugan is a software developer currently living and working in North West England. He has worked in video games and computer graphics since the early days of 3D and has created several shareware games in his spare time. Currently Will works for Evolution Studios, one of the world’s leading games development studios. He also has extensive experience in application development, having worked in the field of user interface creation and video conferencing. His current interests include application and web development in Python. Outside of work Will enjoys juggling and cycling, although not at the same time. For more information on Will’s current work and various musings, visit his blog at www.willmcgugan.com.

边用边学JavaScript

2008-08-19 10:21:24

JavaScript是实现网页动态性、交互性的脚本语言，本书通俗易懂，按照循序渐进的方法详细介绍了JavaScript的基本概念、HTML基本知识、JavaScript的基本语法及其内置对象和浏览器对象，书中对于每个知识点都配备了相应的实例，帮助读者加深理解。
本书适合作为JavaScript初学者的培训教材，也可以作为中、高级网页编程人员的参考书。

JavaScript实例应用

2008-08-19 10:15:12

本书主要以实力为主，全书共分4章，第1章主要介绍了JavaScript脚本语言的主要特征和基本功能，并通过一些实例来帮助读者加深理解；第2章主要介绍了编写JavaScript脚本的规则以及如何在HTML文档中嵌入JavaScript脚本语言；第3章主要介绍了JavaScript系统中预先定义的对象，相比用户自定义的对象而言，预定义对象的利用率更高；第4章给出了大量的精彩实例范例，除了可供练习之用以外，读者还可以在实际应用中稍加修改，即可运用到自己的网页中。
本书特别适用于初、中级网页编程人员，但对高级网页编程人员也是不可缺少的参考手册。

JavaScript实例教程

2008-08-19 09:57:52

本书通过大量的实例介绍了JavaScript的基础知识和实际应用，使读者可以按部就班的系统掌握JavaScript客户端编程技术。全书共分为9章，分别介绍了JavaScript语言基础、JavaScript对象、JavaScript事件处理、文档对象、窗口与浏览器、表单对象、链接与图像、DHTML基础以及DHTML应用。

JavaScript从入门到精通

2008-08-19 09:52:09

本书介绍了JavaScript的基础知识，例如语句、操作符函数、时间和对象等；较少了各种可用的编程工具，如窗口、帧、字段、Cookies、链接、图标；同时介绍了许多Web的新技术，如饰件、样式单、插入件、接口技术等等。本书内容全面（涵盖了JavaScript1.1、1.2），介绍由浅入深，加之强大的后续支持（有关程序及后续更新内容可直接从Web上下载）。因而完全称得上是“从入门到精通”。通过本书的介绍，加之大量的程序实例，相信它会帮助读者在Web上大显身手。

JavaScript程序设计基础教程

2008-08-19 09:40:28

本书是学习JavaScript程序设计的基础教材，共分10章，主要内容包括：HTML制作、JavaScript编程基础、流程控制、函数、对象编程、文档对象模型与事件驱动、使用浏览器对象、级联样式表（CSS）技术和JavaScript网页特效等。为便于教学，每张均附有练习题。
本书内容丰富，讲解循序渐进、深入浅出、简明易懂、本书为高等院校本、专科各专业JavaScript程序设计、动态网页制作、计算机应用基础（编程入门部分）等课程的教材，也可作为电子商务、电子政务的辅助培训教材。

(面向方面编程的可靠应用程序开发)Using Aspect Oriented Programming for Trustworthy Software Developme

2008-08-16 14:13:13

Preface
This book is devoted to the basic concepts and generic relationships of two
new software engineering and computer science areas: trustworthy computing
(TWC) and aspect - oriented programming (AOP).
These two disciplines are now so popular, even “ fashionable, ” that many
software students and experts are looking for more information about them.
Both TWC and AOP and, in particular, their relationship, have not yet been
described suf? ciently in the scienti? c literature up to now, and this gap needs
to be ? lled. The reason for the current status lies in the fact that both AOP
and TWC are still quite novel even though their foundations were laid long
ago, and the worldwide software engineering community has not yet acquired
enough experience in these areas. The book should be very helpful in this
regard.
The main principle behind the book is that AOP, used properly, can be
bene? cial in trustworthy software development, due to the fact that the two
are related generically. To analyze, demonstrate, and teach using AOP for
TWC, I take typical TWC tasks, such as security checks, in and out conditions,
and multithreaded safety and show how they can be implemented using AOP,
since I believe that in terms of AOP, most TWC tasks are cross - cutting concerns
and, consequently, can and should be implemented as aspects . In the text I
describe my team ’ s latest results, analyzing my 30 years ’ experience in research,
development, and university teaching in the areas of software engineering and
computer science, and my 15 years ’ experience collaborating with leading
global software companies: Microsoft Research, Sun Microsystems, and
others.
In particular, I describe the results of two research and educational projects
supported by Microsoft Research:
? Aspect.NET [1 – 6] : an AOP framework for the Microsoft.NET platform
based on Microsoft Phoenix [7] and Microsoft Visual Studio.NET 2005.
Aspect.NET is based on our approach to AOP as well as our AOP frame-
work. Aspect.NET already has a number of users in 16 countries, includ-
ing the United States, Canada, and other countries in the Americas,
Europe, Asia, and the C.I.S. We hope the book will contribute to extend-
ing the Aspect.NET user community.
? TrustSPBU.NET [8] : a set of educational materials on advanced secure
software engineering and trustworthy computing, Microsoft.NET and C#,
compilers, software engineering and compiler development, and my
related project, SPBU.NET [9] , used as the foundation for TrustSPBU.
NET. The curriculum materials of these two projects, available on Micro-
soft Developer ’ s Network Academic Alliance Curriculum Repository
Web site, have already attracted the attention of both students and soft-
ware experts.
For all examples of trustworthy software design and code included in the
book, I use our Aspect.NET framework. I consider the basics of Aspect.NET
architecture, its advantages compared to other AOP tools, its functionality, and
examples of trustworthy application development using Aspect.NET. The
book is not limited to Microsoft technologies, although we do appreciate using
such advanced toolkits as Visual Studio.NET and Phoenix. We consider general
principles and other software technologies and tools applicable to using AOP
for trustworthy software development, such as Java and AspectJ [10] , based
on Java, currently the most widely used AOP instrument.
Chapter 5 is devoted to teaching, but actually, the style used to present all
the material in the book is based on the ERATO teaching paradigm [9] , on
which I have based my university teaching for many years. ERATO is an
acronym for experience, retrospective, analysis, theory, oncoming perspectives.
Erato is the name of the muse of romantic poetry in ancient Greek mythology.
The ERATO teaching paradigm can be summarized as follows:
? Experience: describing my long - term commercial and research software
project experience in my courses. In particular, in 1992 – 2002 I led St.
Petersburg Sun projects in the compiler development and Java technol-
ogy areas. In 2002 I started working with Microsoft Research on the
Aspect.NET project, in 2003 on the Phoenix compiler development
tool, in 2004 on SPBU.NET, and in 2006 on TrustSPBU.NET educational
projects. Such types of things are of deep interest to students since they
can judge how closely coupled academic learning and teaching activity
can be to advanced research and tools and working with leading compa-
nies, so it helps to better illustrate concepts and principles to be taught.
They can participate personally in our projects to get their own
experience.
? Retrospective: considering the historical background of each topic being
taught since its early origin, for deeper understanding of fundamental
concepts by the students. For example, I consider the concepts of concur-
rency and multithreading since Dijkstra ’ s 1960s pioneering work on sema-
phores; generics since Liskov ’ s CLU language parametrized types in early
1970s (rather than since 2004 – 2005, when generics were implemented in
Java 1.5 and C# 2.0).
? Analysis: making critical and comparative analysis of the most important
related and mutually in? uenced concepts and technologies when teaching
them. For example, I analyze the Microsoft.NET platform, compared to
the competitive Java platform, and explain the fundamental reasons why
.NET is more general and open - style. On the other hand, I show to stu-
dents that .NET technologies have a backward in? uence on Java. I believe
that in this way students can better understand the dialectic nature of
software engineering.
? Theory: formulating and explaining the essence of theoretical de? nitions,
justi? cations, known theorems, and issues relevant to the topic being
taught. In particular, when teaching the concept of data type, I make a
review of the techniques of formal speci? cations of abstract data types:
Hoare ’ s theoretical papers on data types published in the 1960s and
1970s; papers by Scott on type theory; and pioneering papers on initial
and ? nal algebra semantics of abstract data types by the ADJ group
(1970s), resulting in algebraic data type speci? cation languages OBJ and
SDL.
? Oncoming perspectives: explaining the vision of future progress in the
topic being taught by a variety of software experts.
The book is targeted primarily at undergraduate and graduate students who
would like to study TWC and AOP, but it will also be useful for software
managers, computer scientists, software engineers, and university teachers in
the area, especially those working with and teaching Microsoft.NET. For
readers who want to learn the basics of trustworthy computing and its applica-
tion to modern software development platforms such as .NET and Java,
Chapter 2 will be appropriate. Chapter 3 focuses on readers interested primar-
ily in aspect - oriented programming and Aspect.NET. Those speci? cally inter-
ested in applying AOP to develop trustworthy software are directed to Chapter
4 . Chapter 5 will be of most interest to those who wish to teach TWC and AOP
and related areas of software engineering.
For more information, the reader is directed to the book and to the Aspect.
NET Web site: www.aspectdotnet.org . The site contains all the examples used
in the book, other material selected from the book, the Aspect.NET framework
with documentation, and data on other publications related to Aspect.NET.
Please send your questions, remarks, suggestions, and proposals regarding
Aspect.NET or my book directly to my e - mail address: v_o_safonov@mail.ru .
ACKNOWLEDGMENTS
First, I would like to thank my colleagues from Microsoft: Igor Agamirzian,
Marco Combetto, Peter Drayton, Van Eden, Kang Su Gatlin, Alexander Gavr-
ilov, Alexander Gil (who was my doctoral student), John Larcheveque, John
Lefor, Mark Lewin, Vassily Lutsarev, Shahrokh Mortazavi, John Spencer,
Andrey Terekhov, Damien Watkins, Yan Xu, Romualds Zdebskis, and many
others. They have provided a lot of support to me and my team.
Thanks also to my teachers from a variety of universities and companies
whose ideas, papers, education, and attention have had a great in? uence on
my work, results, professional views, and interests: Professors Alfred Aho
(Columbia University), Igor Bratchikov, Boris Martynenko and Joseph
Romanovsky (St. Petersburg University), Gregory Tseytin (St. Petersburg
University, now with IBM), and Niklaus Wirth (ETH Z ü rich).
Special thanks to Professor Gregor Kiczales, the inventor of AOP, for fruit-
ful e - mail discussions that helped me to understand the essence of his approach
more deeply.
I would like to memorialize two people whose papers inspired my profes-
sional work: corresponding member of the Russian Academy of Sciences
Professor Svyatoslav Lavrov, my scienti? c advisor, the developer of the ? rst
ALGOL compiler in the Soviet Union in the early 1960s, and the author of
many books and projects well known in our country; and Professor Adolph
Fouxman of Rostov University, the author of the vertical cut technology
(1979), predecessor of aspect - oriented programming, and initiator of pioneer-
ing projects on automated program synthesis, whose software engineering
papers of 1970s look quite contemporary.
Finally, I would like to thank deeply my Aspect.NET implementation team:
my doctoral students Dmitry Grigoryev, the developer of the Aspect.NET
weaver using Microsoft Phoenix [7] ; Mikhail Gratchev, the developer of the
Aspect.NET framework and its integration in Visual Studio.NET 2005 and
Aspect.NET installer; and Alexander Maslennikov, the developer of the
Aspect.NET.ML metalanguage converter to C#. They have not only developed
several releases of Aspect.NET but have also proposed and implemented a
lot of their own bright ideas to improve and enhance Aspect.NET architecture
and functionality. The results of their work should be considered an inherent
part of my book. Also, thanks to my graduate students Oleg Romashin and
Ruslan Mukhanov, who helped me to develop AspectRotor, a version of
Aspect.NET for SSCLI (Rotor), and to Anna Kogay, who developed a number
of useful aspect examples of using Aspect.NET for the design - by - contract
technology used in the book.
Last but not least, my thanks to all Aspect.NET users and supporters.

Object-Oriented JavaScript(Javascript面向对象)

2008-08-16 13:42:39

Preface
This book explores JavaScript for what it is: a highly expressive and lexible
prototype-based object-oriented programming language. Once dismissed as a toy for
designers to make things such as rollover buttons, today this interesting and unique
language is back, stronger than ever. Today's Web 2.0 world of AJAX,
fat-client programming, desktop-like rich Internet applications, drag-and-drop maps
and webmail clients, rely heavily on JavaScript to provide a highly interactive user
experience. And if we never had the chance to properly explore JavaScript before,
now is the time to sit down and (re-)learn it.
This book doesn't assume any prior knowledge of JavaScript and works from the
ground up to give you a thorough understanding of the language.
What This Book Covers
Chapter 1 talks briely about the history, present, and future of JavaScript, and then
moves on to explore the basics of object-oriented programming (OOP) in general.
You then learn how to set up your training environment (Firebug) in order to dive
into the language on your own, using the book examples as a base.
Chapter 2 discuses the language basics: variables, data types, arrays, loops,
and conditionals.
Chapter 3 covers functions. JavaScript has many uses for functions and here
you learn to master them all. You also learn about the scope of variables and
JavaScript's built-in functions. An interesting, but often misunderstood feature of
the language—closures—is demystiied at the end of the chapter.
Chapter 4 introduces objects: how to work with properties and methods, and the
various ways to create your objects. There's also an overview of the built-in objects in
JavaScript, such as Math and Date (just an overview, Appendix C has all the details).
Chapter 5 is dedicated to the all-important concept of prototypes in JavaScript.
Chapter 6 expands your "thinking in JavaScript" horizon, discussing a dozen ways to
implement inheritance in JavaScript.
Chapter 7 is the browser chapter. In this chapter, you learn about BOM (Browser
Object Model), DOM (W3C's Document Object Model), browser events, and AJAX.
Chapter 8 dives into various unique JavaScript coding patterns, as well as several
language-independent design patterns, translated to JavaScript from the Book of
Four, the most inluential work of software design patterns.
Appendix A lists the reserved words in JavaScript.
Appendix B is a reference to the built-in JavaScript functions, together with
sample uses.
Appendix C is a reference that provides detail and provides examples of the use of
every method and property of every built-in object in JavaScript.
Appendix D is a regular expressions pattern reference.

突破JavaScript编程实例五十讲

2008-08-13 16:21:32

第一篇时间日期篇
第—讲指定位置的时钟显示—…………………………………2
第二讲表针式时钟——————————————————5
第三讲带按钮开头的Form时钟………………………………11
第四讲年龄提示器………………………………………15
第五讲得到本文件的最后修改时间………………………………22
第二篇文本特效篇
第六讲文字的跑马灯效果……………………………………………………26
第七讲有提示的链接………………………………………………………．．34
第八讲火焰文字————————————38
第九讲彩色文字的顺序闪烁效果…………—…………41
第十讲文字从背景中飞出…………………………………45
第十一讲光晕效果的文字……………………………………………50
第三篇昆标特效篇
第十二讲跟随鼠标移动的彩色星星………………………56
第十三讲水中鼠标特效------61
第1四讲飞船攻击鼠标效果------66
第十五讲与鼠标联动的动画时钟-----78
第十六讲鼠标星云------87
第十七讲鼠标火焰-----93
第十八讲 Windows模拟鼠标轨迹 ------100
第四篇图片特效篇
第十九讲图片的谈入淡出幻灯效果--------106
第二十讲图片64右晃动---------------------110
第二十一讲图片的爆破效果------------115
第二十二讲不断扭曲的图片-------------122
第五篇页面特效篇
第二十三讲星光闪烁的背景------------126
第二十四讲下雨效果-------------130

第六篇页面技巧篇
第二十五讲禁止鼠标右键和键盘的Menu键---------136
第二十六讲页面文件的编码和译码----------------------139
第二十七讲站内搜索引擎-------------------145
第二十八讲调用共他搜索引擎------------------155
第七篇页面游戏篇
第二十九讲跳舞小游戏--------------163
第三十讲测试点击边皮---------------169
第三十一涂格子---------------------174
第三十二讲数字拼图游戏------------181
第八篇导航菜单篇
第三十三讲自动滚屏菜单--------------------190
第三十四讲卷帘菜啄的实现---------------------197
第三十五讲淡入淡出菜单--------------------------206
第三十六讲树壮菜单--------------------------214
第三十七讲动态弹出式卷轴菜单----------------219
第九篇 cookie篇
第三十八讲用coohe实现日历-----------------226
第三十九讲统计网友来访次数----------------235
第四十讲页向更新跟踪器……．----------------239
第四十—讲自动将访问者的信息Email至信箱-----------242
第十篇综合篇
第四十二讲设为主页和加入收藏夹……247
第四十三讲歌曲播放器…………………251
第四十四讲自定义IE浏览器中的右键菜单--257
第四十五讲自定义热键………………………．263
第四十六讲动态音乐按钮的实现……………270
第四十七讲创建一个科学计算器……………273
第四十八讲仿OICQ导航菜单的实现………289
第四十九讲俄罗斯方块游戏………………310
第五十讲在线测试系统………………331

Python核心编程(中文第二版)

2008-08-10 21:26:38

第1部分　Python核心
　第1章　欢迎来到Python世界　
　　1.1　什么是Python　
　　1.2　起源　
　　1.3　特点　
　　　1.3.1　高级　
　　　1.3.2　面向对象　
　　　1.3.3　可升级　
　　　1.3.4　可扩展　
　　　1.3.5　可移植性　
　　　1.3.6　易学　
　　　1.3.7　易读　
　　　1.3.8　易维护　
　　　1.3.9　健壮性　
　　　1.3.10　高效的快速原型开发工具　
　　　1.3.11　内存管理器　
　　　1.3.12　解释性和（字节）编译性　
　　1.4　下载和安装Python　
　　1.5　运行Python　
　　　1.5.1　命令行上的交互式解释器　
　　　1.5.2　从命令行启动脚本　
　　　1.5.3　集成开发环境　
　　　1.5.4　其他的集成开发环境和执行环境　
　　1.6　Python文档　
　　1.7　比较Python（Python与其他语言的比较）　
　　1.8　其他实现　
　　1.9　练习　
　第2章　快速入门　
　　2.1　程序输出，print语句及“Hello World!”　
　　2.2　程序输入和raw_input（）内建函数　
　　2.3　注释　
　　2.4　操作符　
　　2.5　变量和赋值　
　　2.6　数字　
　　2.7　字符串　
　　2.8　列表和元组　
　　2.9　字典　
　　2.10　代码块及缩进对齐　
　　2.11　if语句　
　　2.12　while循环　
　　2.13　for循环和range（）内建函数　
　　2.14　列表解析　
　　2.15　文件和内建函数open（）、file（）　
　　2.16　错误和异常　
　　2.17　函数　
　　　2.17.1　如何定义函数　
　　　2.17.2　如何调用函数　
　　　2.17.3　默认参数　
　　2.18　类　
　　2.19　模块　
　　　2.19.1　如何导入模块　
　　　2.19.2　如何访问一个模块函数或访问一个模块变量　
　　2.20　实用的函数　
　　2.21　练习　
　第3章　Python基础　
　　3.1　语句和语法　
　　　3.1.1　注释（#）　
　　　3.1.2　继续（\）　
　　　3.1.3　多个语句构成代码组（:）　
　　　3.1.4　代码组由不同的缩进分隔　
　　　3.1.5　同一行书写多个语句（;）　
　　　3.1.6　模块　
　　3.2　变量赋值　
　　　3.2.1　赋值操作符　
　　　3.2.2　增量赋值　
　　　3.2.3　多重赋值　
　　　3.2.4　“多元”赋值　
　　3.3　标识符　
　　　3.3.1　合法的Python标识符　
　　　3.3.2　关键字　
　　　3.3.3　内建　
　　　3.3.4　专用下划线标识符　
　　3.4　基本风格指南　
　　　3.4.1　模块结构和布局　
　　　3.4.2　在主程序中书写测试代码　
　　3.5　内存管理　
　　　3.5.1　变量定义　
　　　3.5.2　动态类型　
　　　3.5.3　内存分配　
　　　3.5.4　引用计数　
　　　3.5.5　垃圾收集　
　　3.6　第一个Python程序　
　　3.7　相关模块和开发工具　
　　3.8　练习　
　第4章　Python对象　
　　4.1　Python 对象　
　　4.2　标准类型　
　　4.3　其他内建类型　
　　　4.3.1　类型对象和type类型对象　
　　　4.3.2　None--Python的Null对象　
　　4.4　内部类型　
　　　4.4.1　代码对象　
　　　4.4.2　帧对象　
　　　4.4.3　跟踪记录对象　
　　　4.4.4　切片对象　
　　　4.4.5　省略对象　
　　　4.4.6　XRange 对象　
　　4.5　标准类型操作符　
　　　4.5.1　对象值的比较　
　　　4.5.2　对象身份比较　
　　　4.5.3　布尔类型　
　　4.6　标准类型内建函数　
　　　4.6.1　type（）　
　　　4.6.2　cmp（）　
　　　4.6.3　str（）和repr（）（及``操作符）　
　　　4.6.4　type（）和isinstance（）　
　　　4.6.5　Python类型操作符和内建函数总结　
　　4.7　类型工厂函数　
　　4.8　标准类型的分类　
　　　4.8.1　存储模型　
　　　4.8.2　更新模型　
　　　4.8.3　访问模型　
　　4.9　不支持的类型　
　　4.10　练习　
　第5章　数字　
　　5.1　数字简介　
　　　5.1.1　如何创建数值对象并用其赋值（数字对象）　
　　　5.1.2　如何更新数字对象　
　　　5.1.3　如何删除数字对象　
　　5.2　整型　
　　　5.2.1　布尔型　
　　　5.2.2　标准整型　
　　　5.2.3　长整型　
　　　5.2.4　整型和长整型的统一　
　　5.3　双精度浮点型　
　　5.4　复数　
　　5.5　操作符　
　　　5.5.1　混合模式操作符　
　　　5.5.2　标准类型操作符　
　　　5.5.3　算术操作符　
　　　5.5.4　*位操作符（只适用于整型）　
　　5.6　内建函数与工厂函数　
　　　5.6.1　标准类型函数　
　　　5.6.2　数字类型函数　
　　　5.6.3　仅用于整型的函数　
　　5.7　其他数字类型　
　　　5.7.1　布尔“数”　
　　　5.7.2　十进制浮点型　
　　5.8　相关模块　
　　5.9　练习　
　第6章　序列：字符串、列表和元组　
　　6.1　序列　
　　　6.1.1　标准类型操作符　
　　　6.1.2　序列类型操作符　
　　　6.1.3　内建函数（BIF）　
　　6.2　字符串　
　　6.3　字符串和操作符　
　　　6.3.1　标准类型操作符　
　　　6.3.2　序列操作符切片（[]和[:]）　
　　6.4　只适用于字符串的操作符　
　　　6.4.1　格式化操作符（％）　
　　　6.4.2　字符串模板: 更简单的替代品　
　　　6.4.3　原始字符串操作符（r/R）　
　　　6.4.4　Unicode字符串操作符（u/U）　
　　6.5　内建函数　
　　　6.5.1　标准类型函数　
　　　6.5.2　序列类型函数　
　　　6.5.3　字符串类型函数　
　　6.6　字符串内建函数　
　　　6.7　字符串的独特特性　
　　　6.7.1　特殊字符串和控制字符　
　　　6.7.2　三引号　
　　　6.7.3　字符串不变性　
　　6.8　Unicode　
　　　6.8.1　术语　
　　　6.8.2　什么是Unicode　
　　　6.8.3　怎样使用Unicode　
　　　6.8.4　Codec是什么　
　　　6.8.5　编码解码　
　　　6.8.6　把Unicode应用到实际应用中　
　　　6.8.7　从现实中得来的教训　
　　　6.8.8　Python的Unicode支持　
　　6.9　相关模块　
　　6.10　字符串关键点总结
　　6.11　列表　
　　6.12　操作符　
　　　6.12.1　标准类型操作符　
　　　6.12.2　序列类型操作符　
　　　6.12.3　列表类型操作符和列表解析　
　　6.13　内建函数　
　　　6.13.1　标准类型函数　
　　　6.13.2　序列类型函数　
　　　6.13.3　列表类型内建函数　
　　6.14　列表类型的内建函数　
　　6.15　列表的特殊特性　
　　6.16　元组　
　　6.17　元组操作符和内建函数　
　　　6.17.1　标准类型操作符、序列类型操作符和内建函数　
　　　6.17.2　元组类型操作符和内建函数、内建方法　
　　6.18　元组的特殊特性　
　　　6.18.1　不可变性给元组带来了什么影响　
　　　6.18.2　元组也不是那么“不可变”　
　　　6.18.3　默认集合类型　
　　　6.18.4　单元素元组　
　　　6.18.5　字典的关键字　
　　6.19　相关模块　
　　6.20　*拷贝Python对象、浅拷贝和深拷贝　
　　6.21　序列类型小结　
　　6.22　练习　
　第7章　映像和集合类型　
　　7.1　映射类型：字典　
　　　7.1.1　如何创建字典和给字典赋值　
　　　7.1.2　如何访问字典中的值　
　　　7.1.3　如何更新字典　
　　　7.1.4　如何删除字典元素和字典　
　　7.2　映射类型操作符　
　　　7.2.1　标准类型操作符　
　　　7.2.2　映射类型操作符　
　　7.3　映射类型的内建函数和工厂函数　
　　　7.3.1　标准类型函数[type（）、str（）和cmp（）]　
　　　7.3.2　映射类型相关的函数　
　　7.4　映射类型内建方法　
　　7.5　字典的键　
　　　7.5.1　不允许一个键对应多个值　
　　　7.5.2　键必须是可哈希的　
　　7.6　集合类型　
　　　7.6.1　如何创建集合类型和给集合赋值　
　　　7.6.2　如何访问集合中的值　
　　　7.6.3　如何更新集合　
　　　7.6.4　如何删除集合中的成员和集合　
　　7.7　集合类型操作符　
　　　7.7.1　标准类型操作符（所有的集合类型）　
　　　7.7.2　集合类型操作符（所有的集合类型）　
　　　7.7.3　集合类型操作符（仅适用于可变集合）　
　　7.8　内建函数　
　　　7.8.1　标准类型函数　
　　　7.8.2　集合类型工厂函数　
　　7.9　集合类型内建方法　
　　　7.9.1　方法（所有的集合方法）　
　　　7.9.2　方法（仅适用于可变集合）　
　　　7.9.3　操作符和内建方法比较　
　　7.10　集合类型总结表　
　　7.11　相关模块　
　　7.12　练习　
　第8章　条件和循环　
　　8.1　if语句　
　　　8.1.1　多重条件表达式　
　　　8.1.2　单一语句的代码块　
　　8.2　else语句　
　　8.3　elif（即else-if）语句　
　　8.4　条件表达式（即“三元操作符”）　
　　8.5　while语句　
　　　8.5.1　一般语法　
　　　8.5.2　计数循环　
　　　8.5.3　无限循环　
　　8.6　for语句　
　　　8.6.1　一般语法　
　　　8.6.2　用于序列类型　
　　　8.6.3　用于迭代器类型　
　　　8.6.4　range（）内建函数　
　　　8.6.5　xrange（）内建函数　
　　　8.6.6　与序列相关的内建函数　
　　8.7　break语句　
　　8.8　continue语句　
　　8.9　pass语句　
　　8.10　再谈else语句　
　　8.11　迭代器和iter（）函数　
　　　8.11.1　什么是迭代器　
　　　8.11.2　为什么要迭代器　
　　　8.11.3　如何迭代　
　　　8.11.4　使用迭代器　
　　　8.11.5　可变对象和迭代器　
　　　8.11.6　如何创建迭代器　
　　8.12　列表解析　
　　8.13　生成器表达式　
　　8.14　相关模块　
　　8.15　练习　
　第9章　文件和输入输出　
　　9.1　文件对象　
　　9.2　文件内建函数（open（）和file（））　
　　　9.2.1　工厂函数file（）　
　　　9.2.2　通用换行符支持（UNS）　
　　9.3　文件内建方法　
　　　9.3.1　输入　
　　　9.3.2　输出　
　　　9.3.3　文件内移动　
　　　9.3.4　文件迭代　
　　　9.3.5　其他　
　　　9.3.6　文件方法杂项　
　　9.4　文件内建属性　
　　9.5　标准文件　
　　9.6　命令行参数　
　　9.7　文件系统　
　　9.8　文件执行　
　　9.9　永久存储模块　
　　　9.9.1　pickle和marshal模块　
　　　9.9.2　DBM风格的模块　
　　　9.9.3　shelve模块　
　　9.10　相关模块　
　　9.11　练习　
　第10章　错误和异常　
　　10.1　什么是异常　
　　　10.1.1　错误　
　　　10.1.2　异常　
　　10.2　Python 中的异常　
　　10.3　检测和处理异常　
　　　10.3.1　try-except语句　
　　　10.3.2　包装内建函数　
　　　10.3.3　带有多个except的try语句　
　　　10.3.4　处理多个异常的except语句　
　　　10.3.5　捕获所有异常　
　　　10.3.6　“异常参数”　
　　　10.3.7　在应用使用我们封装的函数　
　　　10.3.8　else子句　
　　　10.3.9　finally子句　
　　　10.3.10　try-finally语句　
　　　10.3.11　try-except-else-finally：厨房一锅端　
10.4　上下文管理　
　　　10.4.1　with语句　
　　　10.4.2　*上下文管理协议　
　　10.5　*字符串作为异常　
　　10.6　触发异常　
　　10.7　断言　
　　10.8　标准异常　
　　10.9　*创建异常　
　　10.10　（现在）为什么用异常　
　　10.11　到底为什么要异常　
　　10.12　异常和sys模块　
　　10.13　相关模块　
　　10.14　练习　
　第11章　函数和函数式编程　
　　11.1　什么是函数？　
　　　11.1.1　函数vs过程　
　　　11.1.2　返回值与函数类型　
　　11.2　调用函数　
　　　11.2.1　函数操作符　
　　　11.2.2　关键字参数
　　　11.2.3　默认参数　
　　　11.2.4　参数组　
　　11.3　创建函数　
　　　11.3.1　def语句　
　　　11.3.2　声明与定义比较　
　　　11.3.3　前向引用　
　　　11.3.4　函数属性　
　　　11.3.5　内部/内嵌函数　
　　　11.3.6　*函数（与方法）装饰器　
　　11.4　传递函数　
　　11.5　Formal Arguments　
　　　11.5.1　位置参数　
　　　11.5.2　默认参数　
　　11.6　可变长度的参数　
　　　11.6.1　非关键字可变长参数（元组）　
　　　11.6.2　关键字变量参数（字典）　
　　　11.6.3　调用带有可变长参数对象函数　
　　11.7　函数式编程　
　　　11.7.1　匿名函数与lambda　
　　　11.7.2　内建函数apply（）、filter（）、map（）、reduce（）　
　　　11.7.3　偏函数应用　
　　11.8　变量作用域　
　　　11.8.1　全局变量与局部变量　
　　　11.8.2　globa语句　
　　　11.8.3　作用域的数字　
　　　11.8.4　闭包　
　　　11.8.5　作用域和lambda　
　　　11.8.6　变量作用域和名称空间　
　　11.9　*递归　
　　　11.10　生成器　
　　　11.10.1　简单的生成器特性　　　　
　　　11.10.2　加强的生成器特性　
　　11.11　练习　
　第12章　模块　
　　12.1　什么是模块　
　　12.2　模块和文件　
　　　12.2.1　模块名称空间　
　　　12.2.2　搜索路径和路径搜索　
　　12.3　名称空间　
　　　12.3.1　名称空间与变量作用域比较　
　　　12.3.2　名称查找、确定作用域、覆盖　
　　　12.3.3　无限制的名称空间　
　　12.4　导入模块　
　　　12.4.1　import语句　
　　　12.4.2　from-import语句　
　　　12.4.3　多行导入　
　　　12.4.4　扩展的import语句（as）　
　　12.5　模块导入的特性　
　　　12.5.1　载入时执行模块　
　　　12.5.2　导入（import）和加载（load）　
　　　12.5.3　导入到当前名称空间的名称　
　　　12.5.4　被导入到导入者作用域的名字　
　　　12.5.5　关于__future__　
　　　12.5.6　警告框架　
　　　12.5.7　从ZIP文件中导入模块　
　　　12.5.8　“新的”导入钩子　
　　12.6　模块内建函数　
　　　12.6.1　__import__（）　
　　　12.6.2　globals（）和locals（）　　　　
　　　12.6.3　reload（）　
　　12.7　包　
　　　12.7.1　目录结构　
　　　12.7.2　使用from-import导入包　
　　12.8　模块的其他特性　
　　　12.8.1　自动载入的模块　
　　　12.8.2　阻止属性导入　
　　　12.8.3　不区分大小的导入　
　　　12.8.4　源代码编码　
　　　12.8.5　导入循环　
　　　12.8.6　模块执行　
　　12.9　相关模块　
　　12.10　练习　
　第13章　面向对象编程　
　　13.1　引言　
　　13.2　面向对象编程　
　　　13.2.1　面向对象设计与面向对象编程的关系　
　　　13.2.2　现实中的问题　
　　　13.2.3　*常用术语　
　　13.3　类　
　　　13.3.1　创建类　
　　　13.3.2　声明与定义　
　　13.4　类属性　
　　　13.4.1　类的数据属性　
　　　13.4.2　Methods　
　　　13.4.3　决定类的属性　
　　　13.4.4　特殊的类属性　
　　13.5　实例　
　　　13.5.1　初始化：通过调用类对象来创建实例　
　　　13.5.2　__init__（）“构造器”方法　
　　　13.5.3　__new__（）“构造器”方法　
　　　13.5.4　__del__（）“解构器”方法　
　　13.6　实例属性　
　　　13.6.1　“实例化”实例属性（或创建一个更好的构造器）　
　　　13.6.2　查看实例属性　
　　　13.6.3　特殊的实例属性　
　　　13.6.4　建类型属性　
　　　13.6.5　实例属性vs类属性　
　　13.7　绑定和方法调用　
　　　13.7.1　调用绑定方法　
　　　13.7.2　调用非绑定方法　
　　13.8　静态方法和类方法　
　　　13.8.1　staticmethod（）和classmethod（）内建函数　
　　　13.8.2　使用函数修饰符　
　　13.9　组合　
　　13.10　子类和派生　
　　13.11　继承　
　　　13.11.1　__bases__类属性　
　　　13.11.2　通过继承覆盖方法　
　　　13.11.3　从标准类型派生　
　　　13.11.4　多重继承　
　　13.12　类、实例和其他对象的内建函数　
　　　13.12.1　issubclass（）　
　　　13.12.2　isinstance（）　
　　　13.12.3　hasattr（）、getattr（）、setattr（）、delattr（）　
　　　13.12.4　dir（）　
　　　13.12.5　super（）　
　　　13.12.6　vars（）　
　　13.13　用特殊方法定制类　
　　　13.13.1　简单定制（RoundFloat2）　
　　　13.13.2　数值定制（Time60）　
　　　13.13.3　迭代器（RandSeq和AnyIter）　
　　　13.13.4　*多类型定制（NumStr）　
　　13.14　私有化　
　　13.15　*授权　
　　　13.15.1　包装　
　　　13.15.2　实现授权　
　　13.16　新式类的高级特性（Python 2.2+）　
　　　13.16.1　新式类的通用特性　
　　　13.16.2　__slots__类属性　
　　　13.16.3　__getattribute__（）特殊方法　
　　　13.16.4　描述符　
　　　13.16.5　元类和__metaclass__　
　　13.17　相关模块和文档　
　　13.18　练习　
　第14章　执行环境　
　　14.1　可调用对象　
　　　14.1.1　函数　
　　　14.1.2　方法　
　　　14.1.3　类　
　　　14.1.4　类的实例　
　　14.2　代码对象　
　　14.3　可执行的对象声明和内建函数　
　　　14.3.1　callable（）　
　　　14.3.2　compile（）　
　　　14.3.3　eval（）　
　　　14.3.4　exec　
　　　14.3.5　input（）　
　　　14.3.6　使用Python在运行时生成和执行Python代码　
　　14.4　执行其他（Python）程序　
　　　14.4.1　导入　
　　　14.4.2　execfile（）　
　　　14.4.3　将模块作为脚本执行　
　　14.5　执行其他（非Python）程序　
　　　14.5.1　os.system（）　
　　　14.5.2　os.popen（）　
　　　14.5.3　os.fork（）、os.exec*（）、os.wait*（）　
　　　14.5.4　os.spawn*（）　
　　　14.5.5　subprocess 模块　
　　　14.5.6　相关函数　
　　14.6　受限执行　
　　14.7　结束执行　
　　　14.7.1　sys.exit（） and SystemExit　
　　　14.7.2　sys.exitfunc（）　
　　　14.7.3　os._exit（）函数　
　　　14.7.4　os.kill（） Function　
　　14.8　各种操作系统接口　
　　14.9　相关模块　
　　14.10　练习　
第2部分　高级主题
　第15章　正则表达式　
　　15.1　引言/动机　
　　15.2　正则表达式使用的特殊符号和字符　
　　　15.2.1　用管道符号（|）匹配多个正则表达式模式　
　　　15.2.2　匹配任意一个单个的字符（.）　
　　　15.2.3　从字符串的开头或结尾或单词边界开始匹配（^/$ /\b /\B ）　
　　　15.2.4　创建字符类（[]）　
　　　15.2.5　指定范围（-）和否定（^）　
　　　15.2.6　使用闭包操作符（*，+，?，{}）实现多次出现/重复匹配　
　　　15.2.7　特殊字符表示、字符集　
　　　15.2.8　用圆括号（（））组建组　
　　15.3　正则表达式和Python语言　
　　　15.3.1　re模块：核心函数和方法　
　　　15.3.2　使用compile（）编译正则表达式　
　　　15.3.3　匹配对象和group（）、groups（）方法
　　　15.3.4　用match（）匹配字符串　
　　　15.3.5　search（）在一个字符串中查找一个模式（搜索与匹配的比较）　
　　　15.3.6　匹配多个字符串（|）　
　　　15.3.7　匹配任意单个字符（.）　
　　　15.3.8　创建字符集合（[]）　
　　　15.3.9　重复、特殊字符和子组　
　　　15.3.10　从字符串的开头或结尾匹配及在单词边界上的匹配　
　　　15.3.11　用findall（）找到每个出现的匹配部分　
　　　15.3.12　用sub（）（和subn（））进行搜索和替换　
　　　15.3.13　用split（）分割（分隔模式）　
　　15.4　正则表达式示例　
　　　15.4.1　匹配一个字符串　
　　　15.4.2　搜索与匹配的比较，“贪婪”匹配　
　　15.5　练习　
　第16章　网络编程　
　　16.1　引言　
　　　16.1.1　什么是客户端/服务器架构　
　　　16.1.2　客户端/服务器网络编程　
　　16.2　套接字：通信端点　
　　　16.2.1　什么是套接字　
　　　16.2.2　套接字地址：主机与端口　
　　　16.2.3　面向连接与无连接　
　　16.3　Python中的网络编程　
　　　16.3.1　socket（）模块函数　
　　　16.3.2　套接字对象（内建）方法　
　　　16.3.3　创建一个TCP服务器　
　　　16.3.4　创建TCP客户端　
　　　16.3.5　运行我们的客户端与TCP服务器　
　　　16.3.6　创建一个UDP服务器　
　　　16.3.7　创建一个UDP客户端　
　　　16.3.8　执行UDP服务器和客户端　
　　　16.3.9　Socket模块属性　
　　16.4　*SocketServer模块　
　　　16.4.1　创建一个SocketServerTCP服务器　
　　　16.4.2　创建SocketServerTCP客户端　
　　　16.4.3　执行TCP服务器和客户端　
　　16.5　Twisted框架介绍　
　　　16.5.1　创建一个Twisted Reactor TCP服务器　
　　　16.5.2　创建一个Twisted Reactor TCP客户端　
　　　16.5.3　执行TCP服务器和客户端　
　　16.6　相关模块　
　　16.7　练习　
　第17章　网络客户端编程　
　　17.1　什么是因特网客户端　
　　17.2　文件传输　
　　　17.2.1　文件传输网际协议　
　　　17.2.2　文件传输协议（FTP）　
　　　17.2.3　Python和FTP　
　　　17.2.4　ftplib.FTP类方法　
　　　17.2.5　交互式FTP示例　
　　　17.2.6　客户端FTP程序举例　
　　　17.2.7　FTP的其他方面　
　　17.3　网络新闻　
　　　17.3.1　Usenet与新闻组　
　　　17.3.2　网络新闻传输协议（NNTP）　
　　　17.3.3　Python和NNTP　
　　　17.3.4　nntplib.NNTP类方法　
　　　17.3.5　交互式NNTP举例　
　　　17.3.6　客户端程序NNTP举例　
　　　17.3.7　NNTP的其他方面　
　　17.4　电子邮件　
　　　17.4.1　电子邮件系统组件和协议　
　　　17.4.2　发送电子邮件　
　　　17.4.3　Python和SMTP　
　　　17.4.4　smtplib.SMTP类方法　
　　　17.4.5　交互式SMTP示例　
　　　17.4.6　SMTP的其他方面　
　　　17.4.7　接收电子邮件　
　　　17.4.8　POP和IMAP　
　　　17.4.9　Python和POP3　
　　　17.4.10　交互式POP3举例　
　　　17.4.11　poplib.POP3类方法　
　　　17.4.12　客户端程序SMTP和POP3举例　
　　17.5　相关模块　
　　　17.5.1　电子邮件　
　　　17.5.2　其他网络协议　
　　17.6　练习　
　第18章　多线程编程　
　　18.1　引言/动机　
　　18.2　线程和进程　
　　　18.2.1　什么是进程　
　　　18.2.2　什么是线程　
　　18.3　Python、线程和全局解释器锁　
　　　18.3.1　全局解释器锁（GIL）　
　　　18.3.2　退出线程　
　　　18.3.3　在Python中使用线程　
　　　18.3.4　没有线程支持的情况　
　　　18.3.5　Python的threading模块　
　　18.4　thread模块　
　　18.5　threading模块　
　　　18.5.1　Thread类　
　　　18.5.2　斐波那契、阶乘和累加和　
　　　18.5.3　threading模块中的其他函数　　　　
　　　18.5.4　生产者-消费者问题和Queue模块　
　　18.6　相关模块　
　　18.7　练习　
　第19章　图形用户界面编程　
　　19.1　简介　
　　　19.1.1　什么是Tcl、Tk和Tkinter　
　　　19.1.2　安装和使用Tkinter　533
　　　19.1.3　客户端/服务器架构　534
　　19.2　Tkinter与Python编程　534
　　　19.2.1　Tkinter模块：把Tk引入你的程序　
　　　19.2.2　GUI程序开发简介　
　　　19.2.3　顶层窗口：Tkinter.Tk（）　
　　　19.2.4　Tk组件　
　　19.3　Tkinter举例　
　　　19.3.1　标签组件　
　　　19.3.2　按钮组件　
　　　19.3.3　标签和按钮组件　
　　　19.3.4　标签、按钮和进度条组件　
　　　19.3.5　偏函数应用举例　
　　　19.3.6　中级Tkinter范例　
　　19.4　其他GUI简介　
　　　19.4.1　Tk Interface eXtensions （Tix）　
　　　19.4.2　Python MegaWidgets （PMW）　
　　　19.4.3　wxWidgets和wxPython　
　　　19.4.4　GTK+和PyGTK　
　　19.5　相关模块和其他GUI　
　　19.6　练习　
　第20章　Web编程　
　　20.1　介绍　
　　　20.1.1　Web应用：客户端/服务器计算　
　　　20.1.2　因特网　
　　20.2　使用Python进行Web应用：创建一个简单的Web客户端　
　　　20.2.1　统一资源定位符　
　　　20.2.2　urlparse模块　
　　　20.2.3　urllib模块　
　　　20.2.4　urllib2模块　
　　20.3　高级Web客户端　
　　20.4　CGI：帮助Web服务器处理客户端数据　
　　　20.4.1　CGI介绍　
　　　20.4.2　CGI应用程序　
　　　20.4.3　cgi模块　
20.5　建立CGI应用程序　
　　　20.5.1　建立Web服务器　
　　　20.5.2　建立表单页　
　　　20.5.3　生成结果页　
　　　20.5.4　生成表单和结果页面　
　　　20.5.5　全面交互的Web站点　
20.6　在CGI中使用Unicode编码　
　　20.7　高级CGI　
　　　20.7.1　Mulitipart表单提交和文件的上传　
　　　20.7.2　多值字段　
　　　20.7.3　cookie　
　　　20.7.4　使用高级CGI　
　　20.8　Web（HTTP）服务器　
　　20.9　相关模块　
　　20.10　练习　
　第21章　数据库编程　
　　21.1　介绍　
　　　21.1.1　持久存储　
　　　21.1.2　基本的数据库操作和SQL语言　
　　　21.1.3　数据库和Python　
　　21.2　Python数据库应用程序程序员接口（DB-API）　
　　　21.2.1　模块属性　
　　　21.2.2　连接对象　
　　　21.2.3　游标对象　
　　　21.2.4　类型对象和构造器　
　　　21.2.5　关系数据库　
　　　21.2.6　数据库和Python：接口程序　
　　　21.2.7　使用数据库接口程序举例　
　　21.3　对象-关系管理器（ORM）　
　　　21.3.1　考虑对象，而不是SQL　
　　　21.3.2　Python和ORM　
　　　21.3.3　雇员数据库举例　
　　　21.3.4　总结　
　　21.4　相关模块　
　　21.5　练习　
　第22章　扩展Python　623
　　22.1　引言/动机　
　　　22.1.1　什么是扩展　
　　　22.1.2　为什么要扩展Python　
　　22.2　创建Python扩展　
　　　22.2.1　创建您的应用程序代码　
　　　22.2.2　用样板来包装你的代码　
　　　22.2.3　编译　
　　　22.2.4　导入和测试　
　　　22.2.5　引用计数　
　　　22.2.6　线程和全局解释器锁（GIL）　
22.3　相关话题　
　　22.4　练习
　第23章　其他话题　
　　23.1　Web服务　
　　23.2　用Win32的COM来操作微软Office　
　　　23.2.1　客户端COM编程　
　　　23.2.2 微软Excel　
　　　23.2.3　微软Word　第1部分　Python核心
　　　23.2.4　微软PowerPoint　
　　　23.2.5　微软Outlook　
　　　23.2.6　中等规模的例子　
23.3　用Jython写Python和Java的程序　
　　　23.3.1　什么是Jython　
　　　23.3.2　Swing GUI开发（Java或者Python!）　
　　23.4　练习　
　　　23.2.4　微软PowerPoint　
　　　23.2.5　微软Outlook　
　　　23.2.6　中等规模的例子　
　　23.3　用Jython写Python和Java的程序　
　　　23.3.1　什么是Jython　
　　　23.3.2　Swing GUI开发（Java或者Python!）　
　　23.4　练习

Practical Programming in Tcl and Tk, Fourth Edition

2008-08-05 16:01:11

我碰到一个qq群，这个群众的人说tcl工具非常好，机会什么东西都可以做，是高级语言，它的特点是所有的操作都是针对字符串，他是脚本语言。现在有很多这样的软件，我所熟悉的有ns2 一个网络仿真方面的工具，shell也算一个，非常不错。
我也来贴一个！下面是目录

1. Tcl Fundamentals

1.1 The "Hello, World!" example

1.2 Tcl variables

1.3 Command substitution

1.4 Simple arithmetic

1.5 Nested commands

1.6 Built-in math functions

1.7 Grouping expressions with braces

1.8 Quoting special characters with backslash

1.9 Continuing long lines with backslashes

1.10 Grouping with double quotes vs. braces

1.11 Embedded command and variable substitution

1.12 Defining a procedure

1.13 A while loop to compute factorial

1.14 A recursive definition of factorial

1.15 Using set to return a variable value

1.16 Embedded variable references

1.17 Using info to determine if a variable exists

1.18 Controlling precision with tcl_precision

2. Getting Started

2.1 A standalone Tcl script on UNIX

2.2 A standalone Tk script on UNIX

2.3 Using /bin/sh to run a Tcl script

2.4 The EchoArgs script

3. The Guestbook CGI Application

3.1 A simple CGI script

3.2 Output of Example 3-1

3.3 The guestbook.cgi script, version 1

3.4 The Cgi_Header procedure

3.5 The guestbook.cgi script, version 2

3.6 Initial output of guestbook.cgi with no data

3.7 Output of guestbook.cgi with guestbook data

3.8 The newguest.html form

3.9 The newguest.cgi script

3.10 The newguest.cgi script with error handling

4. String Processing in Tcl

4.1 Comparing strings with string compare

4.2 Comparing strings with string equal

4.3 Comparing strings with eq

4.4 Mapping Microsoft World special characters to ASCII

5. Tcl Lists

5.1 Constructing a list with the list command

5.2 Using lappend to add elements to a list

5.3 Using lset to set an element of a list

5.4 Using concat to splice lists together

5.5 Double quotes compared to the concat and list commands

5.6 Modifying lists with lreplace

5.7 Deleting a list element by value

5.8 Sorting a list using a comparison function

5.9 Use split to turn input data into Tcl lists

5.10 Implementing join in Tcl

6. Control Structure Commands

6.1 A conditional if then else command

6.2 Chained conditional with elseif

6.3 Using switch for an exact match

6.4 Using switch with substitutions in the patterns

6.5 A switch with "fall through" cases

6.6 Comments in switch commands

6.7 A while loop to read standard input

6.8 Looping with foreach

6.9 Parsing command-line arguments

6.10 Using list with foreach

6.11 Multiple loop variables with foreach

6.12 Multiple value lists with foreach

6.13 A for loop

6.14 A standard catch phrase

6.15 A longer catch phrase

6.16 There are several possible return values from catch

6.17 Raising an error

6.18 Preserving errorInfo when calling error

6.19 Raising an error with return

7. Procedures and Scope

7.1 Default parameter values

7.2 Variable number of arguments

7.3 Variable scope and Tcl procedures

7.4 A random number generator

7.5 Print variable by name

7.6 Improved incr procedure

8. Tcl Arrays

8.1 Using arrays

8.2 Referencing an array indirectly

8.3 Referencing an array indirectly using upvar

8.4 ArrayInvert inverts an array

8.5 Using arrays for records, version 1

8.6 Using arrays for records, version 2

8.7 Using arrays for records, version 3

8.8 Using a list to implement a stack

8.9 Using an array to implement a stack

8.10 A list of arrays

8.11 A list of arrays

8.12 A simple in-memory database

9. Working with Files and Programs

9.1 Using exec on a process pipeline

9.2 Comparing file modify times

9.3 Determining whether pathnames reference the same file

9.4 Opening a file for writing

9.5 A more careful use of open

9.6 Opening a process pipeline

9.7 Prompting for input

9.8 A read loop using gets

9.9 A read loop using read and split

9.10 Copy a file and translate to native format

9.11 Finding a file by name

9.12 Printing environment variable values

10. Quoting Issues and Eval

10.1 Using list to construct commands

10.2 Generating procedures dynamically with a template

10.3 Using eval with $args

10.4 lassign: list assignment with foreach

10.5 The File_Process procedure iterates over lines in a file

11. Regular Expressions

11.1 Expanded regular expressions allow comments

11.2 Using regular expressions to parse a string

11.3 A pattern to match URLs

11.4 An advanced regular expression to match URLs

11.5 The Url_Decode procedure

11.6 The Cgi_List and Cgi_Query procedures

11.7 Cgi_Parse and Cgi_Value store query data in the cgi array

11.8 Html_DecodeEntity

11.9 Html_Parse

12. Script Libraries and Packages

12.1 Maintaining a tclIndex file

12.2 Loading a tclIndex file

13. Reflection and Debugging

13.1 Calculating clicks per second

13.2 Printing a procedure definition

13.3 Mapping form data onto procedure arguments

13.4 Finding built-in commands

13.5 Getting a trace of the Tcl call stack

13.6 A procedure to read and evaluate commands

13.7 Using info script to find related files

13.8 Tracing variables

13.9 Creating array elements with array traces

13.10 Interactive history usage

13.11 Implementing special history syntax

13.12 A Debug procedure

13.13 Time Stamps in log records

14. Namespaces

14.1 Random number generator using namespaces

14.2 Random number generator using qualified names

14.3 Nested namespaces

14.4 The code procedure to wrap callbacks

14.5 Listing commands defined by a namespace

15. Internationalization

15.1 MIME character sets and file encodings

15.2 Using scripts in nonstandard encodings

15.3 Three sample message catalog files

15.4 Using msgcat::mcunknown to share message catalogs

16. Event-Driven Programming

16.1 A read event file handler

16.2 Using vwait to activate the event loop

16.3 A read event file handler for a nonblocking channel

17. Socket Programming

17.1 Opening a client socket with a timeout

17.2 Opening a server socket

17.3 The echo service

17.4 A client of the echo service

17.5 Opening a connection to an HTTP server

17.6 Opening a connection through a HTTP proxy

17.7 Http_Head validates a URL

17.8 Using Http_Head

17.9 Http_Get fetches the contents of a URL" endterm="ch17list09.title"/>

17.10 HttpGetText reads text URLs

17.11 HttpCopyDone is used with fcopy

17.12 Downloading files with http::geturl

17.13 Basic Authentication using http::geturl

18. TclHttpd Web Server

18.1 The hello.tcl file implements /hello/world

18.2 A simple URL domain

18.3 Application Direct URLs

18.4 Alternate types for Application Direct URLs

18.5 A sample document type handler

18.6 A one-level site structure

18.7 A two-level site structure

18.8 A HTML + Tcl template file

18.9 SitePage template procedure, version 1

18.10 SiteMenu and SiteFooter template procedures

18.11 The SiteLink procedure

18.12 Mail form results with /mail/forminfo

18.13 Mail message sent by /mail/forminfo

18.14 Processing mail sent by /mail/forminfo

18.15 Processing mail sent by /mail/forminfo, Safe-Tcl version

18.16 A self-checking form procedure

18.17 A page with a self-checking form

18.18 Generating a table with html::foreach

18.19 The /debug/source Application Direct URL implementation

19. Multiple Interpreters and Safe-Tcl

19.1 Creating and deleting an interpreter

19.2 Creating a hierarchy of interpreters

19.3 A command alias for exit

19.4 Querying aliases

19.5 Dumping aliases as Tcl commands

19.6 Substitutions and hidden commands

19.7 Opening a file for an unsafe interpreter

19.8 The Safesock security policy

19.9 The Tempfile security policy

19.10 Restricted puts using hidden commands

19.11 A safe after command

20. Safe-Tk and the Browser Plugin

20.1 Using EMBED to insert a Tclet

21. Multi-Threaded Tcl Scripts

21.1 Creating a separate thread to perform a lengthy operation

21.2 Initializing a thread before entering its event loop

21.3 Creating several threads in an application

21.4 Using joinable threads to detect thread termination

21.5 Examples of synchronous message sending

21.6 Using a return variable with synchronous message sending

21.7 Executing commands after thread::wait returns

21.8 Creating a custom thread error handler

21.9 A basic implementation of a logging thread

21.10 Deferring socket transfer until after the connection callback

21.11 Working around Tcl's socket transfer bug

21.12 A multi-threaded echo server

21.13 Using a mutex to protect a shared resource

21.14 Standard condition variable use for a signalling thread

21.15 Standard condition variable use for a waiting thread

22. Tclkit and Starkits

22.1 Accessing a Zip file through a VFS

22.2 The output of sdx lsk hello.kit

22.3 The main program of a Starkit

22.4 The pkgIndex.tcl in a Starkit

22.5 A Starkit that examines its Virtual File System

22.6 Creating a simple Starkit

22.7 The contents of the tclhttpd.vfs directory, version 1

22.8 The main program for the TclHttpd Starkit, version 1

22.9 Contents of the tclhttpd.vfs directory, version 2

22.10 The main program for the TclHttpd Starkit, version 2

22.11 The Standard Tcl Library Starkit main.tcl file

22.12 The main program for TclHttpd Starkit, version 3

22.13 Examining the views in a Metakit database

22.14 Examining data in a Metakit view

22.15 Selecting data with mk::select

22.16 Creating a new view

22.17 Adding data to a view

22.18 Storing data in a Starkit

23. Tk Fundamentals

23.1 "Hello, World!" Tk program

23.2 Looking at all widget attributes

24. Tk by Example

24.1 Logging the output of a program run with exec

24.2 A platform-specific cancel event

24.3 A browser for the code examples in the book

24.4 A Tcl shell in a text widget

24.5 Macintosh look and feel

24.6 Windows look and feel

24.7 UNIX look and feel

25. The Pack Geometry Manager

25.1 Two frames packed inside the main frame

25.2 Turning off geometry propagation

25.3 A horizontal stack inside a vertical stack

25.4 Even more nesting of horizontal and vertical stacks

25.5 Mixing bottom and right packing sides

25.6 Filling the display into extra packing space

25.7 Using horizontal fill in a menu bar

25.8 The effects of internal padding (-ipady)

25.9 Button padding vs. packer padding

25.10 The look of a default button

25.11 Resizing without the expand option

25.12 Resizing with expand turned on

25.13 More than one expanding widget

25.14 Setup for anchor experiments

25.15 The effects of noncenter anchors

25.16 Animating the packing anchors

25.17 Controlling the packing order

25.18 Packing into other relatives

26. The Grid Geometry Manager

26.1 A basic grid

26.2 A grid with sticky settings

26.3 A grid with row and column specifications

26.4 A grid with external padding

26.5 A grid with internal padding

26.6 All combinations of -sticky settings

26.7 Explicit row and column span

26.8 Grid syntax row and column span

26.9 Row padding compared to cell padding

26.10 Gridding a text widget and scrollbar

26.11 Uniform column width

27. The Place Geometry Manager

27.1 Centering a window with place

27.2 Covering a window with place

27.3 Combining relative and absolute sizes

27.4 Positioning a window above a sibling with place

27.5 Pane_Create sets up vertical or horizontal panes

27.6 PaneDrag adjusts the percentage

27.7 PaneGeometry updates the layout

28. The Panedwindow Widget

28.1 A panedwindow with complex managed widgets

29. Binding Commands to Events

29.1 Bindings on different binding tags

29.2 Output from the UNIX xmodmap program

29.3 Emacs-like binding convention for Meta and Escape

29.4 Virtual events for cut, copy, and paste

30. Buttons and Menus

30.1 A troublesome button command

30.2 Fixing the troublesome situation

30.3 A button associated with a Tcl procedure

30.4 Radiobuttons and checkbuttons

30.5 A command on a radiobutton or checkbutton

30.6 A menu sampler

30.7 A menu bar in Tk 8.0

30.8 Using the <<MenuSelect>> virtual event

30.9 A simple menu by name package

30.10 Using the Tk 8.0 menu bar facility

30.11 MenuGet maps from name to menu

30.12 Adding menu entries

30.13 A wrapper for cascade entries

30.14 Using the menu by name package

30.15 Keeping the accelerator display up to date

31. The Resource Database

31.1 Reading an option database file

31.2 A file containing resource specifications

31.3 Using resources to specify user-defined buttons

31.4 Resource_ButtonFrame defines buttons based on resources

31.5 Using Resource_ButtonFrame

31.6 Specifying menu entries via resources

31.7 Defining menus from resource specifications

31.8 Resource_GetFamily merges user and application resources

32. Simple Tk Widgets

32.1 Labelframe example

32.2 Using the labelAnchor option to position a labelframe's anchor

32.3 Associating an existing label widget with a labelframe

32.4 Macintosh window styles

32.5 A label that displays different strings

32.6 The message widget formats long lines of text

32.7 Controlling the text layout in a message widget

32.8 A scale widget

33. Scrollbars

33.1 A text widget and two scrollbars

33.2 Scroll_Set manages optional scrollbars

33.3 Listbox with optional scrollbars

34. The Entry and Spinbox Widgets

34.1 Associating entry widgets with variables and commands

34.2 Restricting entry text to integer values

34.3 Reestablishing validation using an idle task

34.4 A simple spinbox with calculated values

34.5 Formatting numeric values in a spinbox

34.6 Enumerating spinbox values and wrapping

34.7 Using the spinbox readonly state

35. The Listbox Widget

35.1 Using -listvariable to link a listbox and variable

35.2 Choosing items from a listbox

35.3 Using the <<ListboxSelect>> virtual event

36. The Text Widget

36.1 Tag configurations for basic character styles

36.2 Line spacing and justification in the text widget

36.3 An active text button

36.4 Delayed creation of embedded widgets

36.5 Using embedded images for a bulleted list

36.6 Finding the current range of a text tag

36.7 Dumping the text widget

36.8 Dumping the text widget with a command callback

37. The Canvas Widget

37.1 A large scrolling canvas

37.2 The canvas "Hello, World!" example

37.3 A min max scale canvas example

37.4 Moving the markers for the min max scale

37.5 Canvas arc items

37.6 Canvas bitmap items

37.7 Canvas image items

37.8 A canvas stroke drawing example

37.9 Canvas oval items

37.10 Canvas polygon items

37.11 Dragging out a box

37.12 Simple edit bindings for canvas text items

37.13 Using a canvas to scroll a set of widgets

37.14 Generating Postscript from a canvas

38. Selections and the Clipboard

38.1 Paste the PRIMARY or CLIPBOARD selection

38.2 Separate paste actions

38.3 Bindings for canvas selection

38.4 Selecting objects

38.5 A canvas selection handler

38.6 The copy and cut operations

38.7 Pasting onto the canvas

39. Focus, Grabs, and Dialogs

39.1 Procedures to help build dialogs

39.2 A simple dialog

39.3 A feedback procedure

40. Tk Widget Attributes

40.1 Equal-sized labels

40.2 3D relief sampler

40.3 Padding provided by labels and buttons

40.4 Anchoring text in a label or button

40.5 Borders and padding

41. Color, Images, and Cursors

41.1 Resources for reverse video

41.2 Computing a darker color

41.3 Specifying an image for a widget

41.4 Specifying a bitmap for a widget

41.5 The built-in bitmaps

41.6 The Tk cursors

42. Fonts and Text Attributes

42.1 The FontWidget procedure handles missing fonts

42.2 Font metrics

42.3 A gridded, resizable listbox

42.4 Font selection dialog

43. Send

43.1 The sender application

43.2 Hooking the browser to an eval server

43.3 Making the shell into an eval server

43.4 Remote eval using sockets

43.5 Reading commands from a socket

43.6 The client side of remote evaluation

44. Window Managers and Window Information

44.1 Gridded geometry for a canvas

44.2 Telling other applications what your name is

45. Managing User Preferences

45.1 Preferences initialization

45.2 Adding preference items

45.3 Setting preference variables

45.4 Using the preferences package

45.5 A user interface to the preference items

45.6 Interface objects for different preference types

45.7 Displaying the help text for an item

45.8 Saving preferences settings to a file

45.9 Read settings from the preferences file

45.10 Tracing a Tcl variable in a preference item

46. A User Interface to Bindings

46.1 A user interface to widget bindings

46.2 Bind_Display presents the bindings for a widget or class

46.3 Related listboxes are configured to select items together

46.4 Controlling a pair of listboxes with one scrollbar

46.5 Drag-scrolling a pair of listboxes together

46.6 An interface to define bindings

46.7 Defining and saving bindings

47. C Programming and Tcl

47.1 The initialization procedure for a loadable package

47.2 The RandomCmd C command procedure

47.3 The RandomObjCmd C command procedure

47.4 The Tcl_Obj structure

47.5 The Plus1ObjCmd procedure

47.6 The Blob and BlobState data structures

47.7 The Blob_Init and BlobCleanup procedures

47.8 The BlobCmd command procedure

47.9 BlobCreate and BlobDelete

47.10 The BlobNames procedure

47.11 \The BlobN and BlobData procedures

47.12 The BlobCommand and BlobPoke procedures

47.13 A canonical Tcl main program and Tcl_AppInit

47.14 A canonical Tk main program and Tk_AppInit

47.15 Calling C command procedure directly with Tcl_Invoke

48. Compiling Tcl and Extensions

Writing a Tk Widget in C

49.1 The Clock_Init procedure

49.2 The Clock widget data structure

49.3 The ClockCmd command procedure

49.4 The ClockObjCmd command procedure

49.5 The ClockInstanceCmd command procedure

49.6 The ClockInstanceObjCmd command procedure

49.7 ClockConfigure allocates resources for the widget

49.8 ClockObjConfigure allocates resources for the widget

49.9 The Tk_ConfigSpec typedef

49.10 Configuration specs for the clock widget

49.11 The Tk_OptionSpec typedef

49.12 The Tk_OptionSpec structure for the clock widget

49.13 ComputeGeometry computes the widget's size

49.14 The ClockDisplay procedure

49.15 The ClockEventProc handles window events

49.16 The ClockDestroy cleanup procedure

49.17 The ClockObjDelete command