2020-06-22 11:24:04

docs/db/111.md

@@ -10,7 +10,7 @@ Hibernate 是 Java 语言的对象关系映射框架。 它提供了一个框架
 
 Apache Derby 是一个完全用 Java 实现的开源关系数据库。 Derby 占用空间小，易于部署和安装。 它支持嵌入式和客户端/服务器模式。
 
-Hibernate 查询语言（HQL）是类似于 SQL 的面向对象的查询语言。 SQL 在表和列上运行，而 HQL 在持久对象及其属性上运行。 HQL 了解继承，多态性和关联。 最终，HQL 查询由 Hibernate 转换为 SQL 查询，从而对数据库执行某些操作。
+Hibernate 查询语言（HQL）是类似于 SQL 的面向对象的查询语言。 SQL 在表和列上运行，而 HQL 在持久对象及其属性上运行。 HQL 了解继承，多态和关联。 最终，HQL 查询由 Hibernate 转换为 SQL 查询，从而对数据库执行某些操作。
 
 除了其本地 API，Hibernate 还包含 Java Persistence API（JPA）的实现。
 

docs/db/19.md

@@ -20,8 +20,8 @@ MySQL 提供了四个级别的事务隔离：
 
 *   可序列化
 *   可重复读
-*   阅读已提交
-*   阅读未提交
+*   已提交读
+*   未提交读
 
 在可序列化的隔离级别中，所有事务都以完全隔离的方式发生。 所有事务都一个接一个地执行。 在可重复读取的隔离级别中，语句无法读取已被其他事务修改但尚未提交的数据。 在当前事务完成之前，没有其他事务可以修改当前事务已读取的数据。 这是 InnoDB 的默认隔离级别。 其中，已提交读隔离级别的语句无法读取已被其他事务修改但未提交的数据。 语句等待直到被其他事务写锁定的数据行被解锁，然后才能获取自己的锁。 这样可以防止他们读取脏数据。 在未提交读的隔离级别中，语句可以读取已被其他事务修改但尚未提交的行。
 

docs/db/20.md

@@ -163,9 +163,9 @@ mysql> SELECT CircleArea(5.5);
 
 过程无法返回值。 但是，它可以使用三种类型的变量：
 
-*   在
-*   出
-*   进出
+*   `IN`
+*   `OUT`
+*   `INOUT`
 
 `IN`是默认参数类型。 未明确指定类型时使用。 `IN`参数传递给该过程。 可以在过程内部进行修改，但在外部保持不变。 对于`OUT`参数，不会将任何值传递给过程。 可以在过程内部进行修改。 并且该变量在过程外部可用。 `INOUT`变量是`IN`和`OUT`参数的混合。 可以将其传递给过程，在此进行更改，也可以在过程外部进行检索。
 

docs/db/31.md

@@ -88,10 +88,10 @@ MySQL client version: 5.1.67
 
 下一个代码示例将创建一个数据库。 该代码示例可以分为以下几部分：
 
-*   启动连接句柄结构
+*   创建连接句柄结构
 *   建立连接
 *   执行查询
-*   连接关闭
+*   关闭连接
 
 ```perl
 #include <my_global.h>
@@ -159,7 +159,7 @@ if (mysql_real_connect(con, "localhost", "root", "root_pswd",
 
 ```
 
-`mysql_real_connect()`功能建立与数据库的连接。 我们为该函数提供连接处理程序，主机名，用户名和密码参数。 其他四个参数是数据库名称，端口号，unix 套接字以及最后的客户端标志。 我们需要超级用户特权才能创建新数据库。
+`mysql_real_connect()`功能建立与数据库的连接。 我们为该函数提供连接处理器，主机名，用户名和密码参数。 其他四个参数是数据库名称，端口号，unix 套接字以及最后的客户端标志。 我们需要超级用户特权才能创建新数据库。
 
 ```perl
 if (mysql_query(con, "CREATE DATABASE testdb")) 
@@ -1010,7 +1010,7 @@ if (ferror(fp)) {
 
 ```
 
-我们使用`fseek()`函数将文件指针移到文件末尾。 我们将确定图像的大小。 如果发生错误，则设置错误指示器。 我们使用`fseek()`功能检查指示器。 如果发生错误，我们还将关闭打开的文件处理程序。
+我们使用`fseek()`函数将文件指针移到文件末尾。 我们将确定图像的大小。 如果发生错误，则设置错误指示器。 我们使用`fseek()`功能检查指示器。 如果发生错误，我们还将关闭打开的文件处理器。
 
 ```perl
 int flen = ftell(fp);
@@ -1054,7 +1054,7 @@ if (r == EOF) {
 
 ```
 
-读取数据后，我们可以关闭文件处理程序。
+读取数据后，我们可以关闭文件处理器。
 
 ```perl
 char chunk[2*size+1];
@@ -1186,7 +1186,7 @@ if (fp == NULL)
 
 ```
 
-我们打开一个新的文件处理程序进行写入。
+我们打开一个新的文件处理器进行写入。
 
 ```perl
 if (mysql_query(con, "SELECT Data FROM Images WHERE Id=1"))
@@ -1237,6 +1237,6 @@ if (r == EOF) {
 
 ```
 
-写入图像数据后，使用`fclose()`函数关闭文件处理程序。
+写入图像数据后，使用`fclose()`函数关闭文件处理器。
 
 这是 MySQL C API 教程。 您可能也对 [MySQL Python 教程](/db/mysqlpython/)， [MySQL Visual Basic 教程](/db/mysqlvb/)或 [MySQL PHP 教程](/databases/mysqlphptutorial/)， [PostgreSQL C 教程](/db/postgresqlc/)或[ [关于 ZetCode 的 SQLite C 教程](/db/sqlitec/)。
\ No newline at end of file

docs/db/37.md

@@ -13,7 +13,7 @@
 *   [创建，更改和删除表](tables/)
 *   [SQLite 表达式](expressions/)
 *   [插入，更新和删除数据](datamanipulation/)
-*   [SELECT 语句](select/)
+*   [`SELECT`语句](select/)
 *   [约束](constraints/)
 *   [连接表](joins/)
 *   [SQLite 函数](sqlitefunctions/)

docs/db/44.md

@@ -9,7 +9,7 @@
 在 SQLite 中，我们具有以下约束：
 
 *   非空
-*   独特
+*   唯一
 *   主键
 *   外键
 *   校验

docs/db/48.md

@@ -900,7 +900,7 @@ if (ferror(fp)) {
 
 ```
 
-我们使用`fseek()`函数将文件指针移到文件末尾。 我们需要确定图像的大小。 如果发生错误，则设置错误指示器。 我们使用`fseek()`功能检查指示器。 如果发生错误，将关闭打开的文件处理程序。
+我们使用`fseek()`函数将文件指针移到文件末尾。 我们需要确定图像的大小。 如果发生错误，则设置错误指示器。 我们使用`fseek()`功能检查指示器。 如果发生错误，将关闭打开的文件处理器。
 
 ```c
 int flen = ftell(fp);
@@ -944,7 +944,7 @@ if (r == EOF) {
 
 ```
 
-读取数据后，我们可以关闭文件处理程序。
+读取数据后，我们可以关闭文件处理器。
 
 ```c
 char *sql = "INSERT INTO Images(Data) VALUES(?)";

docs/db/89.md

@@ -11,12 +11,12 @@
 *   [引入 Derby](derby/)
 *   [安装&配置](install/)
 *   [工具](tools/)
-*   [ij 工具](ij/)
+*   [`ij`工具](ij/)
 *   [SQL](sql/)
 *   [使用 JDBC 编程](jdbc/)
 *   [安全性](sec/)
 *   [使用 Tomcat](tomcat/)
-*   [带 NetBeans 的 Derby](netbeans/)
+*   [NetBeans 和 Derby](netbeans/)
 
 
 

docs/dotnet/131.md

@@ -14,14 +14,14 @@
 *   [数据类型](datatypes/)
 *   [字符串](strings/)
 *   [运算符](operators/)
-*   [流量控制](flowcontrol/)
+*   [控制流](flowcontrol/)
 *   [数组](arrays/)
 *   [OOP I](oopi/)
 *   [方法](methods/)
 *   [OOP II](oopii/)
 *   [属性](properties/)
 *   [结构](structures/)
-*   [代表](delegates/)
+*   [委托](delegates/)
 *   [命名空间](namespaces/)
 *   [集合](collections/)
 *   [输入&输出](io/)

docs/dotnet/136.md

@@ -10,8 +10,8 @@
 
 字符串是对象。 有两个用于处理字符串的基本类：
 
-*   System.String
-*   System.Text.StringBuilder
+*   `System.String`
+*   `System.Text.StringBuilder`
 
 `String`是不可变的字符序列。 `StringBuilder`是可变的字符序列。
 

docs/dotnet/140.md

@@ -12,12 +12,12 @@
 
 OOP 中有一些基本的编程概念：
 
-*   抽象化
-*   多态性
-*   封装形式
+*   抽象
+*   多态
+*   封装
 *   继承
 
-抽象通过建模适合该问题的类来简化复杂的现实。 多态性是将运算符或函数以不同方式用于不同数据输入的过程。 封装对其他对象隐藏了类的实现细节。 继承是一种使用已经定义的类形成新类的方法。
+抽象通过建模适合该问题的类来简化复杂的现实。 多态是将运算符或函数以不同方式用于不同数据输入的过程。 封装对其他对象隐藏了类的实现细节。 继承是一种使用已经定义的类形成新类的方法。
 
 ## C# 对象
 
@@ -555,7 +555,7 @@ public MyFriend(string name, DateTime born)
 
 ```
 
-在构造函数中，我们启动两个数据成员。 `this`变量是用于引用对象变量的处理程序。
+在构造函数中，我们启动两个数据成员。 `this`变量是用于引用对象变量的处理器。
 
 ```cs
 var friend = new MyFriend(name, born);

docs/dotnet/141.md

@@ -35,12 +35,12 @@
 
 可以在方法名称中使用任何合法字符。 按照约定，方法名称以大写字母开头。 方法名称是动词或动词，后跟形容词或名词。 随后的每个单词都以大写字母开头。 以下是 C# 中方法的典型名称：
 
-*   执行
-*   FindId
-*   集名
-*   取名
-*   CheckIfValid
-*   测试有效性
+*   `Execute`
+*   `FindId`
+*   `SetName`
+*   `GetName`
+*   `CheckIfValid`
+*   `TestValidity`
 
 ## C# 简单示例
 

docs/dotnet/142.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://zetcode.com/lang/csharp/oopii/](https://zetcode.com/lang/csharp/oopii/)
 
-在 C# 教程的这一章中，我们将继续介绍 OOP。 我们介绍了接口，多态性，深层和浅层副本，密封类和异常。
+在 C# 教程的这一章中，我们将继续介绍 OOP。 我们介绍了接口，多态，深层和浅层副本，密封类和异常。
 
 ## C# 接口
 
@@ -10,10 +10,10 @@
 
 接口是：
 
-*   蜜蜂
+*   API
 *   合约
 
-对象通过其公开的方法与外界交互。 实际的实现对程序员而言并不重要，或者也可能是秘密的。 公司可能会出售图书馆，但它不想透露实际的实施情况。 程序员可能会在 GUI 工具箱的窗口上调用`Maximize()`方法，但对如何实现此方法一无所知。 从这个角度来看，接口是对象与外界交互的方式，而又不会过多地暴露其内部功能。
+对象通过其公开的方法与外界交互。 实际的实现对程序员而言并不重要，或者也可能是秘密的。 公司可能会出售图书馆，但它不想透露实际的实现情况。 程序员可能会在 GUI 工具箱的窗口上调用`Maximize()`方法，但对如何实现此方法一无所知。 从这个角度来看，接口是对象与外界交互的方式，而又不会过多地暴露其内部功能。
 
 从第二个角度来看，接口就是契约。 如果达成协议，则必须遵循。 它们用于设计应用的体系结构。 他们帮助组织代码。
 
@@ -280,13 +280,13 @@ Connecting to the database
 
 这是输出。
 
-## C# 多态性
+## C# 多态
 
-多态是以不同方式将运算符或函数用于不同数据输入的过程。 实际上，多态性意味着如果类 B 从类 A 继承，那么它不必继承关于类 A 的所有内容。 它可以完成 A 类所做的某些事情。
+多态是以不同方式将运算符或函数用于不同数据输入的过程。 实际上，多态意味着如果类 B 从类 A 继承，那么它不必继承关于类 A 的所有内容。 它可以完成 A 类所做的某些事情。
 
-通常，多态性是以不同形式出现的能力。 从技术上讲，它是重新定义派生类的方法的能力。 多态性与将特定实现应用于接口或更通用的基类有关。
+通常，多态是以不同形式出现的能力。 从技术上讲，它是重新定义派生类的方法的能力。 多态与将特定实现应用于接口或更通用的基类有关。
 
-多态性是重新定义派生类的方法的能力。
+多态是重新定义派生类的方法的能力。
 
 `Program.cs`
 
@@ -378,7 +378,7 @@ foreach (Shape shape in shapes)
 
 ```
 
-我们遍历每个形状，并在其上调用`Area()`方法。 编译器为每种形状调用正确的方法。 这就是多态性的本质。
+我们遍历每个形状，并在其上调用`Area()`方法。 编译器为每种形状调用正确的方法。 这就是多态的本质。
 
 ## C# 密封类
 
@@ -870,7 +870,7 @@ namespace ReadFile
 
 ```
 
-这些行确保关闭文件处理程序。
+这些行确保关闭文件处理器。
 
 ```cs
 $ cat langs.txt

docs/dotnet/145.md

@@ -8,14 +8,14 @@ C# 教程的这一部分专门针对委托。
 
 委托是引用类型。 但是委托不是引用对象，而是引用方法。
 
-在以下情况下使用代理：
+在以下情况下使用委托：
 
-*   事件处理程序
-*   回呼
+*   事件处理器
+*   回调
 *   LINQ
-*   设计模式的实施
+*   设计模式的实现
 
-委托没有什么可以用常规方法完成的。 之所以使用代表，是因为它们带来了许多优点。 它们提高了应用和代码重用的灵活性。 像接口一样，委托使我们能够解耦和泛化我们的代码。 委托还允许将方法作为参数传递。 当我们需要确定在运行时调用哪种方法时，可以使用委托。 最后，委托人提供了一种无需对子类进行子类化就可以对它的行为进行专门化的方法。 类可能具有复杂的泛型行为，但仍应专门化。 类是通过继承或通过委托来专用的。
+委托没有什么可以用常规方法完成的。 之所以使用委托，是因为它们带来了许多优点。 它们提高了应用和代码重用的灵活性。 像接口一样，委托使我们能够解耦和泛化我们的代码。 委托还允许将方法作为参数传递。 当我们需要确定在运行时调用哪种方法时，可以使用委托。 最后，委托提供了一种无需对子类进行子类化就可以对它的行为进行专门化的方法。 类可能具有复杂的泛型行为，但仍应专门化。 类是通过继承或通过委托来专用的。
 
 ## C# 使用委托
 
@@ -54,7 +54,7 @@ delegate void MyDelegate();
 
 ```
 
-这是我们的委托人声明。 它不返回任何值，不接受任何参数。
+这是我们的委托声明。 它不返回任何值，不接受任何参数。
 
 ```cs
 var md = new MyDelegate(MyCallback);
@@ -68,7 +68,7 @@ md();
 
 ```
 
-我们打电话给代表。
+我们打电话给委托。
 
 ```cs
 $ dotnet run
@@ -167,7 +167,7 @@ namespace DifferentMethods
 
 ```
 
-在此示例中，我们只有一名代表。 该委托用于指向`Person`类的两个方法。 方法与委托一起调用。
+在此示例中，我们只有一名委托。 该委托用于指向`Person`类的两个方法。 方法与委托一起调用。
 
 ```cs
 public delegate void NameDelegate(string msg);
@@ -191,7 +191,7 @@ Call 2: Maximus
 
 ```
 
-这两个名称都是通过代理打印的。
+这两个名称都是通过委托打印的。
 
 ## C# 多播委托
 
@@ -243,7 +243,7 @@ delegate void MyDelegate(int x, int y);
 
 ```
 
-我们的代表接受两个参数。 我们有一个`Oper`类，它具有两个静态方法。 一个将两个值相加，另一个将两个值相减。
+我们的委托接受两个参数。 我们有一个`Oper`类，它具有两个静态方法。 一个将两个值相加，另一个将两个值相减。
 
 ```cs
 var del = new MyDelegate(Oper.Add);
@@ -776,4 +776,4 @@ static bool greaterThanThree(int x)
 
 对于大于三个的所有值，谓词返回`true`。
 
-C# 教程的这一部分专用于代表。
\ No newline at end of file
+C# 教程的这一部分专用于委托。
\ No newline at end of file

docs/dotnet/147.md

@@ -7,8 +7,8 @@
 C# 中有三种不同的集合类型：
 
 *   标准
-*   通用的
-*   同时
+*   泛型
+*   并发
 
 标准集合可在`System.Collections`下找到。 它们不将元素存储为特定类型的对象，而是存储为`Object`类型的对象。 标准集合包括`ArrayList`，`Hashtable`，`Queue`和`Stack`。
 

docs/dotnet/154.md

@@ -436,7 +436,7 @@ File.WriteAllBytes(localPath, imageBytes);
 
 > **注意**：凭证未加密； 因此，必须将 HTTP 基本认证与 HTTPS 协议一起使用。
 
-HTTP 基本认证是用于实施对 Web 资源的访问控制的最简单技术。 它不需要 cookie，会话标识符或登录页面； 相反，HTTP 基本认证使用 HTTP 标头中的标准字段。
+HTTP 基本认证是用于实现对 Web 资源的访问控制的最简单技术。 它不需要 cookie，会话标识符或登录页面； 相反，HTTP 基本认证使用 HTTP 标头中的标准字段。
 
 `Program.cs`
 

docs/dotnet/155.md

@@ -240,7 +240,7 @@ app.Run(async (context) =>
 
 ```
 
-我们向请求添加最终处理程序。 处理程序以文本消息响应。 `WriteAsync`创建一个特定的线程来处理请求。 `WriteAsync`方法使用 UTF-8 将给定的文本异步写入响应主体流。
+我们向请求添加最终处理器。 处理器以文本消息响应。 `WriteAsync`创建一个特定的线程来处理请求。 `WriteAsync`方法使用 UTF-8 将给定的文本异步写入响应主体流。
 
 ```cs
 $ dotnet run
@@ -421,7 +421,7 @@ app.UseMvc(routes =>
 
 ```
 
-使用`UseMvc`，我们设置了路由。 路由是将请求 URL 解析为控制器处理程序的过程。 控制器名为`HelloController`。 操作名称是`Index`，这是`HelloController`中的方法名称。 该操作的名称也由视图共享，称为`Index.cshtml`。 该视图位于`Views/Hello`子目录中。 ASP.NET Core 在配置上使用约定，其中可以推断出许多设置，而不必明确声明。
+使用`UseMvc`，我们设置了路由。 路由是将请求 URL 解析为控制器处理器的过程。 控制器名为`HelloController`。 操作名称是`Index`，这是`HelloController`中的方法名称。 该操作的名称也由视图共享，称为`Index.cshtml`。 该视图位于`Views/Hello`子目录中。 ASP.NET Core 在配置上使用约定，其中可以推断出许多设置，而不必明确声明。
 
 `index.html`
 

docs/dotnet/87.md

@@ -14,9 +14,9 @@
 *   [数据类型](datatypes/)
 *   [字符串](strings/)
 *   [运算符](operators/)
-*   [流量控制](flowcontrol/)
+*   [控制流](flowcontrol/)
 *   [数组](arrays/)
-*   [过程&功能](procedures/)
+*   [过程&函数](procedures/)
 *   [组织代码](organizingcode/)
 *   [OOP I](oopi/)
 *   [OOP II](oopii/)

docs/dotnet/97.md

@@ -8,13 +8,13 @@ Visual Basic 语句被组织为块，模块，类和名称空间。 这有助于
 
 Visual Basic 程序的基本构建块是：
 
-*   部件
+*   程序集
 *   命名空间
 *   模块
-*   班级
-*   程序和功能
-*   积木
-*   陈述
+*   类
+*   过程和函数
+*   块
+*   语句
 
 程序集是 DLL 或 exe 文件。 程序集是用于部署，版本控制和安全性的已编译代码库。 名称空间是提供项目上下文的抽象容器。 模块是在其整个命名空间中可用的引用类型。 类是 OOP 程序的基本构建块。 过程是为执行特定任务而创建的程序的一个单元。 块是由`If`或`While`之类的某些关键字提供的 Visual Basic 语句的最低级别组织。 语句是 Visual Basic 程序中的原子，是代码的最小单位。
 

docs/dotnet/98.md

@@ -10,12 +10,12 @@
 
 OOP 中有一些基本的编程概念：
 
-*   抽象化
-*   多态性
-*   封装形式
+*   抽象
+*   多态
+*   封装
 *   继承
 
-抽象通过建模适合该问题的类来简化复杂的现实。 多态性是将运算符或函数以不同方式用于不同数据输入的过程。 封装对其他对象隐藏了类的实现细节。 继承是一种使用已经定义的类形成新类的方法。
+抽象通过建模适合该问题的类来简化复杂的现实。 多态是将运算符或函数以不同方式用于不同数据输入的过程。 封装对其他对象隐藏了类的实现细节。 继承是一种使用已经定义的类形成新类的方法。
 
 ## 对象
 
@@ -560,7 +560,7 @@ Private Name As String
 
 ```
 
-类定义中有两个变量。 `Private`关键字是访问修饰符。 它是一种封装形式。 `Private`关键字是限制性最强的修饰符。 它仅允许有问题的对象访问变量。 没有子孙，没有其他物件。
+类定义中有两个变量。 `Private`关键字是访问修饰符。 它是一种封装。 `Private`关键字是限制性最强的修饰符。 它仅允许有问题的对象访问变量。 没有子孙，没有其他物件。
 
 ```vb
 Sub New(ByVal Name As String, ByVal Born As Date)
@@ -570,7 +570,7 @@ End Sub
 
 ```
 
-在构造函数中，我们启动两个数据成员。 `Me`变量是用于引用对象变量的处理程序。
+在构造函数中，我们启动两个数据成员。 `Me`变量是用于引用对象变量的处理器。
 
 ```vb
 Dim fr As MyFriend = New MyFriend(name, born)

docs/dotnet/99.md

@@ -10,10 +10,10 @@
 
 接口是：
 
-*   蜜蜂
+*   API
 *   合约
 
-对象通过这些方法与外界交互。 实际的实现对程序员而言并不重要，或者也可能是秘密的。 公司可能会出售图书馆，但它不想透露实际的实施情况。 程序员可能会在 GUI 工具箱的窗口中调用`Maximize`方法，但对如何实现此方法一无所知。 从这个角度来看，接口是一种方法，通过这些方法，对象可以与外界交互，而不会过多地暴露其内部工作原理。
+对象通过这些方法与外界交互。 实际的实现对程序员而言并不重要，或者也可能是秘密的。 公司可能会出售图书馆，但它不想透露实际的实现情况。 程序员可能会在 GUI 工具箱的窗口中调用`Maximize`方法，但对如何实现此方法一无所知。 从这个角度来看，接口是一种方法，通过这些方法，对象可以与外界交互，而不会过多地暴露其内部工作原理。
 
 从第二个角度来看，接口就是契约。 如果达成协议，则必须遵循。 它们用于设计应用的体系结构。 他们帮助组织代码。
 
@@ -263,13 +263,13 @@ Connecting to the database
 
 输出。
 
-## 多态性
+## 多态
 
-多态是以不同方式将运算符或函数用于不同数据输入的过程。 实际上，多态性意味着如果类`B`从类`A`继承，则不必继承关于类`A`的所有内容； 它可以完成`A`类所做的某些事情。 （维基百科）
+多态是以不同方式将运算符或函数用于不同数据输入的过程。 实际上，多态意味着如果类`B`从类`A`继承，则不必继承关于类`A`的所有内容； 它可以完成`A`类所做的某些事情。 （维基百科）
 
-通常，多态性是以不同形式出现的能力。 从技术上讲，它是重新定义派生类的方法的能力。 多态性与将特定实现应用于接口或更通用的基类有关。
+通常，多态是以不同形式出现的能力。 从技术上讲，它是重新定义派生类的方法的能力。 多态与将特定实现应用于接口或更通用的基类有关。
 
-多态性是重新定义派生类的方法的能力。
+多态是重新定义派生类的方法的能力。
 
 ```vb
 Option Strict On
@@ -357,7 +357,7 @@ Next
 
 ```
 
-我们遍历每个形状并在其上调用`Area`方法。 编译器为每种形状调用正确的方法。 这就是多态性的本质。
+我们遍历每个形状并在其上调用`Area`方法。 编译器为每种形状调用正确的方法。 这就是多态的本质。
 
 ## `NotOverridable`，`NotInheritable`
 
@@ -823,7 +823,7 @@ Finally
 
 ```
 
-这些行确保关闭文件处理程序。
+这些行确保关闭文件处理器。
 
 ```vb
 Option Strict On
@@ -1306,7 +1306,7 @@ AddHandler gen.ValueFive, AddressOf five.OnFiveEvent
 
 ```
 
-我们将`ValueFive`事件插入其处理程序。
+我们将`ValueFive`事件插入其处理器。
 
 ```vb
 $ ./event2.exe 

docs/graph/10.md

@@ -787,7 +787,7 @@ private void pieceDropped() {
 
 ```
 
-`pieceDropped()`方法将下降的片段放入`board`数组。 木板再次保持了所有碎片的正方形和已经落下的碎片的剩余部分。 当一块完成落下时，就该检查我们是否可以从板上去除一些线了。 这是`removeFullLines()`方法的工作。 然后，我们创建一个新作品，或更准确地说，我们尝试创建一个新作品。
+`pieceDropped()`方法将下降的片段放入`board`数组。 棋盘再次保持了所有碎片的正方形和已经落下的碎片的剩余部分。 当一块完成落下时，就该检查我们是否可以从板上去除一些线了。 这是`removeFullLines()`方法的工作。 然后，我们创建一个新作品，或更准确地说，我们尝试创建一个新作品。
 
 ```java
 private void newPiece() {
@@ -1071,7 +1071,7 @@ board.start();
 
 ```
 
-木板被创建并添加到容器中。 `start()`方法启动俄罗斯方块游戏。
+棋盘被创建并添加到容器中。 `start()`方法启动俄罗斯方块游戏。
 
 ![Tetris](img/65937d82c9ca7815aa4ad7e9d948e349.jpg)
 

docs/graph/15.md

@@ -9,8 +9,8 @@
 
 
 *   [简介](introduction/)
-*   [基本图纸](basicdrawing/)
-*   [塑造并填充](shapesandfills/)
+*   [基本绘图](basicdrawing/)
+*   [形状和填充](shapesandfills/)
 *   [透明度](transparency/)
 *   [组成](composition/)
 *   [裁剪](clipping/)

docs/graph/16.md

@@ -52,7 +52,7 @@ Java 2D 是一项强大的技术。 它可以用来创建丰富的用户界面
 
 在将`Graphics`对象传递给`paintComponent()`方法之前，先对其进行初始化，然后将其转换为`paintBorder()`和`paintChildren()`方法。 这种重用可以提高性能，但是如果绘画代码永久更改`Graphics`状态，则可能会导致问题。 因此，我们必须恢复原始设置或使用`Graphics`对象的副本。 该副本是使用`Graphics`的`create()`方法创建的； 必须稍后使用`dispose()`方法将其释放。
 
-实际上，如果我们设置以下属性：字体，颜色和呈现提示，则无需创建`Graphics`对象的副本。 对于所有其他属性（尤其是剪辑，复合操作和转换），我们必须创建`Graphics`对象的副本并在以后处置它。
+实际上，如果我们设置以下属性：字体，颜色和呈现提示，则无需创建`Graphics`对象的副本。 对于所有其他属性（尤其是剪裁，复合操作和转换），我们必须创建`Graphics`对象的副本并在以后处置它。
 
 ## 简单的 Java 2D 示例
 

docs/graph/17.md

@@ -423,9 +423,9 @@ g2d.dispose();
 
 上限是应用于未封闭子路径和破折线段末端的装饰。 Java 2D 中有三种不同的端盖：`CAP_BUTT`，`CAP_ROUND`和`CAP_SQUARE`。
 
-*   `CAP_BUTT`-结束未封闭的子路径和虚线段，不添加任何修饰。
-*   `CAP_ROUND`-用圆形装饰结束未封闭的子路径和虚线段，该圆形装饰的半径等于笔的宽度的一半。
-*   `CAP_SQUARE`-以方形投影结束未封闭的子路径和虚线段，该方形投影超出段的末端并延伸到等于线宽一半的距离。
+*   `CAP_BUTT` - 结束未封闭的子路径和虚线段，不添加任何修饰。
+*   `CAP_ROUND` - 用圆形装饰结束未封闭的子路径和虚线段，该圆形装饰的半径等于笔的宽度的一半。
+*   `CAP_SQUARE` - 以方形投影结束未封闭的子路径和虚线段，该方形投影超出段的末端并延伸到等于线宽一半的距离。
 
 `CapsEx.java`
 
@@ -548,9 +548,9 @@ g2d.drawLine(254, 20, 254, 140);
 
 线连接是应用于两个路径段的交点以及子路径端点的交点的修饰。 一共有三种装饰：`JOIN_BEVEL`，`JOIN_MITER`和`JOIN_ROUND`。
 
-*   `JOIN_BEVEL`-通过将宽轮廓的外角与直线段相连来连接路径段。
-*   `JOIN_MITER`-通过扩展路径段的外部边缘直到它们交汇来连接路径段。
-*   `JOIN_ROUND`-通过以线宽一半的半径四舍五入拐角来连接路径段。
+*   `JOIN_BEVEL` - 通过将宽轮廓的外角与直线段相连来连接路径段。
+*   `JOIN_MITER` - 通过扩展路径段的外部边缘直到它们交汇来连接路径段。
+*   `JOIN_ROUND` - 通过以线宽一半的半径四舍五入拐角来连接路径段。
 
 `JoinsEx.java`
 

docs/graph/18.md

@@ -518,7 +518,7 @@ g2d.fillRect(10, 15, 90, 60);
 
 图：颜色
 
-## 渐变色
+## 渐变
 
 在计算机图形学中，渐变是从浅到深或从一种颜色到另一种颜色的阴影的平滑混合。 在 2D 绘图程序和绘画程序中，渐变用于创建彩色背景和特殊效果以及模拟灯光和阴影。 （answers.com）
 

docs/graph/2.md

@@ -11,8 +11,8 @@
 *   [移动精灵](movingsprites/)
 *   [碰撞检测](collision/)
 *   [拼图](puzzle/)
-*   [蛇](snake/)
-*   [突破](breakout/)
+*   [贪食蛇](snake/)
+*   [打砖块](breakout/)
 *   [俄罗斯方块](tetris/)
 *   [吃豆人](pacman/)
 *   [太空侵略者](spaceinvaders/)

docs/graph/21.md

@@ -6,7 +6,7 @@
 
 ## 剪裁
 
-剪裁将图形限制在某个区域。 这样做是出于效率原因并产生各种效果。 使用剪辑时，我们必须使用`Graphics`对象的副本，或者恢复原始的剪辑属性。 更改剪辑不会影响现有像素； 它仅影响将来的渲染。
+剪裁将图形限制在某个区域。 这样做是出于效率原因并产生各种效果。 使用剪裁时，我们必须使用`Graphics`对象的副本，或者恢复原始的剪裁属性。 更改剪裁不会影响现有像素； 它仅影响将来的渲染。
 
 在以下示例中，我们将图像裁剪为圆形。
 
@@ -156,14 +156,14 @@ Graphics2D g2d = (Graphics2D) g.create();
 
 ```
 
-我们创建`Graphics2D`对象的副本。 因此，更改剪辑不会影响其他在`Graphics2D`对象被重用的 Swing 零件。
+我们创建`Graphics2D`对象的副本。 因此，更改剪裁不会影响其他在`Graphics2D`对象被重用的 Swing 零件。
 
 ```java
 g2d.clip(new Ellipse2D.Double(pos_x, pos_y, RADIUS, RADIUS));
 
 ```
 
-`clip()`方法将现有剪辑与作为参数给出的形状结合在一起。 所得的相交设置为片段。 在我们的例子中，最终的剪辑是圆形。
+`clip()`方法将现有剪裁与作为参数给出的形状结合在一起。 所得的相交设置为片段。 在我们的例子中，最终的剪裁是圆形。
 
 ```java
 if (pos_x < 0) {
@@ -353,7 +353,7 @@ Shape oldClip = g2d.getClip();
 
 ```
 
-由于我们没有创建`Graphics2D`对象的副本，因此我们将存储旧剪辑以供以后使用。 最后，我们必须将剪辑重置为原始剪辑。
+由于我们没有创建`Graphics2D`对象的副本，因此我们将存储旧剪裁以供以后使用。 最后，我们必须将剪裁重置为原始剪裁。
 
 ```java
 Rectangle rect = new Rectangle(0, 0, 200, 80);
@@ -383,17 +383,17 @@ g2d.fill(circle);
 
 ```
 
-在这里，我们将绘图限制为两个形状的交点。 如果它们重叠，则结果形状的内部将充满颜色。 `clip()`方法将初始剪辑（组件的客户区域）与给定的两个形状组合在一起。
+在这里，我们将绘图限制为两个形状的交点。 如果它们重叠，则结果形状的内部将充满颜色。 `clip()`方法将初始剪裁（组件的客户区域）与给定的两个形状组合在一起。
 
 ```java
 g2d.setClip(oldClip);
 
 ```
 
-使用`setClip()`方法，我们在绘制形状之前将剪辑区域重置为旧剪辑。 与`clip()`方法不同，`setClip()`不合并剪切区域。 它将剪辑重置到新区域。 因此，此方法应专门用于还原旧剪辑。
+使用`setClip()`方法，我们在绘制形状之前将剪裁区域重置为旧剪裁。 与`clip()`方法不同，`setClip()`不合并剪切区域。 它将剪裁重置到新区域。 因此，此方法应专门用于还原旧剪裁。
 
 ![Clipping shapes](img/25f4908640340038862ad597c70a482b.jpg)
 
 图：剪裁形状
 
-在 Java 2D 教程的这一部分中，我们讨论了剪辑。
\ No newline at end of file
+在 Java 2D 教程的这一部分中，我们讨论了剪裁。
\ No newline at end of file

docs/graph/27.md

@@ -21,9 +21,9 @@
 游戏背后的一些想法。
 
 *   我们使用计时器类创建游戏周期
-*   绘制四蛋白
+*   绘制四个形状
 *   形状以正方形为单位移动（不是逐个像素移动）
-*   从数学上讲，木板是简单的数字列表
+*   从数学上讲，棋盘是简单的数字列表
 
 我对游戏做了一些简化，以便于理解。 游戏启动后立即开始。 我们可以通过按`p`键暂停游戏。 空格键将把俄罗斯方块放在底部。 `d`键将片段向下一行。 （它可以用来加快下降速度。）游戏以恒定速度运行，没有实现加速。 分数是我们已删除的行数。
 
@@ -756,7 +756,7 @@ private void pieceDropped() {
 
 ```
 
-`pieceDropped()`方法将下降的碎片放入板阵列中。 木板再次保持了所有碎片的正方形和已经落下的碎片的剩余部分。 当一块完成落下时，就该检查是否可以去除板上的一些线了。 这是`removeFullLines()`方法的工作。 然后，我们创建一个新作品。 更准确地说，我们尝试创建一个新作品。
+`pieceDropped()`方法将下降的碎片放入板阵列中。 棋盘再次保持了所有碎片的正方形和已经落下的碎片的剩余部分。 当一块完成落下时，就该检查是否可以去除板上的一些线了。 这是`removeFullLines()`方法的工作。 然后，我们创建一个新作品。 更准确地说，我们尝试创建一个新作品。
 
 ```java
 private void newPiece()  {

docs/graph/28.md

@@ -11,12 +11,12 @@
 *   [简介](cairolib/)
 *   [Cario 定义](cairodefinitions/)
 *   [Cario 后端](cairobackends/)
-*   [基本图纸](basicdrawing/)
-*   [塑造并填充](shapesfills/)
-*   [渐变色](gradients/)
+*   [基本绘图](basicdrawing/)
+*   [形状和填充](shapesfills/)
+*   [渐变](gradients/)
 *   [透明度](transparency/)
 *   [合成](compositing/)
-*   [剪辑和遮罩](clippingmasking/)
+*   [剪裁和遮罩](clippingmasking/)
 *   [转换](transformations/)
 *   [文字](cairotext/)
 *   [Cario 的图片](cairoimages/)

docs/graph/32.md

@@ -357,9 +357,9 @@ cairo_stroke(cr);
 
 线帽是线的端点。
 
-*   CAIRO_LINE_CAP_SQUARE
-*   CAIRO_LINE_CAP_ROUND
-*   CAIRO_LINE_CAP_BUTT
+*   `CAIRO_LINE_CAP_SQUARE`
+*   `CAIRO_LINE_CAP_ROUND`
+*   `CAIRO_LINE_CAP_BUTT`
 
 Cairo 有三种不同的线帽样式。
 

docs/graph/33.md

@@ -339,7 +339,7 @@ int main(int argc, char *argv[])
 
 ```
 
-在此示例中，我们再次绘制了四个矩形。 这次，我们用一些模式填充它们。 我们使用来自 Gimp 图像处理程序的四个图案图像。 我们必须保留这些模式的原始大小，因为我们将对它们进行平铺。
+在此示例中，我们再次绘制了四个矩形。 这次，我们用一些模式填充它们。 我们使用来自 Gimp 图像处理器的四个图案图像。 我们必须保留这些模式的原始大小，因为我们将对它们进行平铺。
 
 我们在`on_draw_event()`功能之外创建图像表面。 每次需要重新绘制窗口时，每次从硬盘读取数据都不是很有效。
 

docs/graph/34.md

-# 渐变色
+# 渐变
 
 > 原文： [https://zetcode.com/gfx/cairo/gradients/](https://zetcode.com/gfx/cairo/gradients/)
 

docs/graph/35.md

@@ -217,7 +217,7 @@ cairo_paint_with_alpha(cr, glob.alpha);
 
 ```
 
-我们使用`cairo_text_path()`方法获得文本的路径。 我们使用`cairo_clip()`方法将绘画限制为当前路径。 `cairo_paint_with_alpha()`方法使用 alpha 值的掩码在当前剪辑区域内的任何地方绘制当前源。
+我们使用`cairo_text_path()`方法获得文本的路径。 我们使用`cairo_clip()`方法将绘画限制为当前路径。 `cairo_paint_with_alpha()`方法使用 alpha 值的掩码在当前剪裁区域内的任何地方绘制当前源。
 
 ```c
 glob.timer = TRUE;

docs/graph/37.md

@@ -138,7 +138,7 @@ cairo_paint(cr);
 
 ```
 
-`cairo_paint()`在当前剪辑区域内的任何地方绘制当前源。
+`cairo_paint()`在当前剪裁区域内的任何地方绘制当前源。
 
 ```c
 glob.image = cairo_image_surface_create_from_png("turnacastle.png");

docs/graph/4.md

@@ -6,7 +6,7 @@
 
 ## 动画
 
-动画是图像序列的快速显示，会产生运动的错觉。 我们将为董事会上的星星设置动画。 我们将以三种基本方式实施这一运动。 我们将使用 Swing 计时器，标准实用程序计时器和线程。
+动画是图像序列的快速显示，会产生运动的错觉。 我们将为董事会上的星星设置动画。 我们将以三种基本方式实现这一运动。 我们将使用 Swing 计时器，标准实用程序计时器和线程。
 
 动画是游戏编程中的一个复杂主题。 Java 游戏有望在具有不同硬件规格的多种操作系统上运行。 线程提供了最准确的计时解决方案。 但是，对于我们简单的 2D 游戏，其他两个选项也可以是一个选项。
 

docs/graph/41.md

@@ -327,7 +327,7 @@ gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_DOCK);
 
 ```
 
-实施此窗口提示会删除窗口边框和装饰。
+实现此窗口提示会删除窗口边框和装饰。
 
 ```c
 gtk_window_set_keep_below(GTK_WINDOW(win), TRUE);

docs/graph/42.md

@@ -10,10 +10,10 @@
 
 *   [简介](introduction/)
 *   [后端](backends/)
-*   [基本图纸](basicdrawing/)
-*   [形状&填充了](shapesfills/)
-*   [渐变色](gradients/)
-*   [剪切&遮罩](clipmask/)
+*   [基本绘图](basicdrawing/)
+*   [形状&填充](shapesfills/)
+*   [渐变](gradients/)
+*   [剪裁&遮罩](clipmask/)
 *   [透明度](transparency/)
 *   [转换](transformations/)
 *   [文字](text/)

docs/graph/46.md

@@ -317,7 +317,7 @@ if __name__ == "__main__":
 
 ```
 
-在此示例中，我们绘制了四个矩形。 这次我们用一些模式填充它们。 我们使用来自 Gimp 图像处理程序的四个图案图像。 我们必须保留这些图案的原始大小，因为我们将它们平铺。
+在此示例中，我们绘制了四个矩形。 这次我们用一些模式填充它们。 我们使用来自 Gimp 图像处理器的四个图案图像。 我们必须保留这些图案的原始大小，因为我们将它们平铺。
 
 我们在`draw()`方法之外创建图像表面。 每次需要重新绘制窗口时，从硬盘读取数据都不会很有效。
 

docs/graph/48.md

@@ -139,7 +139,7 @@ cr.paint()
 
 ```
 
-`paint()`在当前剪辑区域内的任何地方绘制当前源。
+`paint()`在当前剪裁区域内的任何地方绘制当前源。
 
 ![Clipping](img/78b6bd31fc14bda137918717bef26394.jpg)
 
@@ -374,4 +374,4 @@ cr.mask_surface(self.ims, 10, 10)
 
 城堡的图像被设置为绘画的来源。 `mask_surface()`使用表面的 Alpha 通道作为遮罩来绘制电流源。
 
-本章介绍了 PyCairo 中的剪辑和遮罩。
\ No newline at end of file
+本章介绍了 PyCairo 中的剪裁和遮罩。
\ No newline at end of file

docs/graph/49.md

@@ -217,7 +217,7 @@ cr.paint_with_alpha(self.alpha)
 
 ```
 
-我们使用`text_path()`方法获得文本的路径。 我们使用`clip()`方法将绘画限制为当前路径。 `paint_with_alpha()`方法使用 alpha 值的掩码在当前剪辑区域内的任何地方绘制当前源。
+我们使用`text_path()`方法获得文本的路径。 我们使用`clip()`方法将绘画限制为当前路径。 `paint_with_alpha()`方法使用 alpha 值的掩码在当前剪裁区域内的任何地方绘制当前源。
 
 ![Puff effect](img/6494f55b272a96349c1aa2543effb3c4.jpg)
 
@@ -398,7 +398,7 @@ while(i < self.imageHeight):
 
 ```
 
-这是最后一部分。 我们使第二个图像透明。 但是透明度不是恒定的。 图像逐渐淡出。 反射的图像逐行绘制。 `clip()`方法将图形限制为高度为 1 的矩形。`paint_with_alpha()`在绘制图像表面的当前剪辑时会考虑透明度。
+这是最后一部分。 我们使第二个图像透明。 但是透明度不是恒定的。 图像逐渐淡出。 反射的图像逐行绘制。 `clip()`方法将图形限制为高度为 1 的矩形。`paint_with_alpha()`在绘制图像表面的当前剪裁时会考虑透明度。
 
 ![Reflected image](img/177e269863e6b0d27db2c74737acb0b3.jpg)
 

docs/graph/53.md

@@ -295,7 +295,7 @@ self.set_type_hint(Gdk.WindowTypeHint.DOCK)
 
 ```
 
-实施此窗口提示会删除窗口边框和装饰。
+实现此窗口提示会删除窗口边框和装饰。
 
 ```py
 self.set_keep_below(True) 

docs/graph/54.md

@@ -9,7 +9,7 @@
 
 
 *   [简介](introduction/)
-*   [行](lines/)
+*   [直线](lines/)
 *   [形状](shapes/)
 *   [填充](fills/)
 *   [透明度](transparency/)
@@ -17,7 +17,7 @@
 *   [转换](transformations/)
 *   [文字](text/)
 *   [动画](animation/)
-*   [蛇](snake/)
+*   [贪食蛇](snake/)
 
 
 

docs/graph/55.md

@@ -103,7 +103,7 @@ ctx.fillRect(0, 0, 100, 100);
 
 ```
 
-`onload`属性为窗口的加载事件定义事件处理程序。 加载事件在文档加载过程结束时触发。 至此，文档中的所有对象都在 DOM 中，并且所有图像，脚本，链接和子框架均已完成加载。 在我们的例子中，我们调用`draw()`方法，该方法在画布上执行绘制。
+`onload`属性为窗口的加载事件定义事件处理器。 加载事件在文档加载过程结束时触发。 至此，文档中的所有对象都在 DOM 中，并且所有图像，脚本，链接和子框架均已完成加载。 在我们的例子中，我们调用`draw()`方法，该方法在画布上执行绘制。
 
 ```js
 <canvas id="myCanvas" width="250" height="150">
@@ -190,7 +190,7 @@ ctx.shadowColor   = "#888";
 
 以下资源用于创建本教程：
 
-*   [Wikipedia 上的 Canvas 元素](https://en.wikipedia.org/wiki/Canvas_element)文章。
+*   [Wikipedia 上的`canvas`元素](https://en.wikipedia.org/wiki/Canvas_element)文章。
 *   [developer.mozilla.org/zh-CN/docs/Web/API/Canvas_API](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API)
 
 HTML5 画布教程的这一部分是对 HTML5 画布的 JavaScript 编程的介绍。
\ No newline at end of file

docs/graph/56.md

@@ -226,9 +226,9 @@ ctx.setLineDash([4, 4, 1]);
 
 端盖是应用于未封闭子路径和破折线段末端的装饰。 Java 2D 中有三种不同的端盖：`'square'`，`'round'`和`'butt'`。
 
-*   `'butt'`-结束未封闭的子路径和虚线段，不添加任何修饰。
-*   `'round'`-用圆形装饰结束未封闭的子路径和虚线段，该圆形装饰的半径等于笔的宽度的一半。
-*   `'square'`-以方形投影结束未封闭的子路径和虚线段，该方形投影超出段的末端并延伸到等于线宽一半的距离。
+*   `'butt'` - 结束未封闭的子路径和虚线段，不添加任何修饰。
+*   `'round'` - 用圆形装饰结束未封闭的子路径和虚线段，该圆形装饰的半径等于笔的宽度的一半。
+*   `'square'` - 以方形投影结束未封闭的子路径和虚线段，该方形投影超出段的末端并延伸到等于线宽一半的距离。
 
 `line_caps.html`
 
@@ -316,9 +316,9 @@ ctx.lineCap = 'square';
 
 线连接是应用于两个路径段的交点以及子路径端点的交点的修饰。 一共有三种装饰：`'bevel'`，`'miter'`和`'round'`。
 
-*   `'bevel'`-通过将宽轮廓的外角与直线段相连来连接路径段。
-*   `'miter'`-通过扩展路径段的外部边缘直到它们交汇来连接路径段。
-*   `'round'`-通过以线宽一半的半径四舍五入拐角来连接路径段。
+*   `'bevel'` - 通过将宽轮廓的外角与直线段相连来连接路径段。
+*   `'miter'` - 通过扩展路径段的外部边缘直到它们交汇来连接路径段。
+*   `'round'` - 通过以线宽一半的半径四舍五入拐角来连接路径段。
 
 `line_joins.html`
 

docs/graph/60.md

@@ -10,7 +10,7 @@
 
 ## 合成操作
 
-[developer.mozilla.org](https://developer.mozilla.org) 在其[合成和剪辑](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Tutorial/Compositing)一章中列出了 26 种不同的合成操作。 我们在下一个代码示例中展示其中的一些。
+[developer.mozilla.org](https://developer.mozilla.org) 在其[合成和剪裁](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Tutorial/Compositing)一章中列出了 26 种不同的合成操作。 我们在下一个代码示例中展示其中的一些。
 
 假设我们要在画布上绘制两个对象。 绘制的第一个对象称为目标，第二个称为源。 `canvas`上下文的`globalCompositeOperation`属性确定如何将这两个对象混合在一起。 例如，在`source-over`规则（这是默认的构图操作）中，新形状会在现有形状的顶部绘制。
 

docs/graph/7.md

@@ -7,12 +7,12 @@
 ## Java 益智游戏要点
 
 *   使用 Swing 和 Java 2D 图形来构建游戏。
-*   用`Collections.shuffle()`随机播放按钮。
+*   用`Collections.shuffle()`随机打乱播放按钮。
 *   用`ImageIO.read()`加载图像。
 *   用`BufferedImage`调整图像大小。
 *   用`CropImageFilter`裁剪图像。
 *   用`GridLayout`布局按钮。
-*   使用两个`ArrayLists`点检查解决方案。
+*   使用两个点的`ArrayLists`检查解决方案。
 
 ## Java 益智游戏示例
 

docs/graph/SUMMARY.md

@@ -30,7 +30,7 @@
     +   [Cairo 后端](31.md)
     +   [Cairo 基本图形](32.md)
     +   [形状和填充](33.md)
-    +   [渐变色](34.md)
+    +   [渐变](34.md)
     +   [透明度](35.md)
     +   [合成](36.md)
     +   [剪裁和遮罩](37.md)

docs/gui/102.md

@@ -518,7 +518,7 @@ self.Bind(wx.EVT_MENU, self.OnMinimize, mmi)
 
 ```
 
-将创建一个菜单项并将其附加到上下文菜单。 事件处理程序绑定到此菜单项。
+将创建一个菜单项并将其附加到上下文菜单。 事件处理器绑定到此菜单项。
 
 ```py
 self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)

docs/gui/104.md

@@ -6,9 +6,9 @@
 
 ## 定义
 
-事件是来自底层框架（通常是 GUI 工具箱）的应用级信息。事件循环是一种程序结构，用于等待并调度程序中的事件或消息。 事件循环反复查找要处理的事件。调度程序是将事件映射到事件处理程序的过程。 事件处理程序是对事件做出反应的方法。
+事件是来自底层框架（通常是 GUI 工具箱）的应用级信息。事件循环是一种程序结构，用于等待并调度程序中的事件或消息。 事件循环反复查找要处理的事件。调度程序是将事件映射到事件处理器的过程。 事件处理器是对事件做出反应的方法。
 
-事件对象是与事件关联的对象。 通常是一个窗口。事件类型是已生成的唯一事件。事件绑定器是将事件类型与事件处理程序绑定在一起的对象。
+事件对象是与事件关联的对象。 通常是一个窗口。事件类型是已生成的唯一事件。事件绑定器是将事件类型与事件处理器绑定在一起的对象。
 
 ## wxPython `wx.EVT_MOVE`示例
 
@@ -100,8 +100,8 @@ def OnMove(self, e):
 在 wxPython 中使用事件的三个​​步骤是：
 
 *   标识事件绑定程序名称：`wx.EVT_SIZE`，`wx.EVT_CLOSE`等。
-*   创建一个事件处理程序。 生成事件时将调用此方法。
-*   将事件绑定到事件处理程序。
+*   创建一个事件处理器。 生成事件时将调用此方法。
+*   将事件绑定到事件处理器。
 
 在 wxPython 中，我们说将方法绑定到事件。 有时会使用单词钩子。 您可以通过调用`Bind()`方法来绑定事件。 该方法具有以下参数：
 
@@ -110,7 +110,7 @@ Bind(event, handler, source=None, id=wx.ID_ANY, id2=wx.ID_ANY)
 
 ```
 
-`event`是`EVT*`对象之一。 它指定事件的类型。 `handler`是要调用的对象。 换句话说，它是程序员绑定到事件的一种方法。 当我们要区分相同事件类型和不同小部件时，使用`source`参数。 当我们有多个按钮，菜单项等时，将使用`id`参数。`id`用于在它们之间进行区分。 当需要将处理程序绑定到 ID 范围时，例如`EVT_MENU_RANGE`，可以使用`id2`。
+`event`是`EVT*`对象之一。 它指定事件的类型。 `handler`是要调用的对象。 换句话说，它是程序员绑定到事件的一种方法。 当我们要区分相同事件类型和不同小部件时，使用`source`参数。 当我们有多个按钮，菜单项等时，将使用`id`参数。`id`用于在它们之间进行区分。 当需要将处理器绑定到 ID 范围时，例如`EVT_MENU_RANGE`，可以使用`id2`。
 
 注意，方法`Bind()`在类`EvtHandler`中定义。 它是`wx.Window`继承的类。 `wx.Window`是 wxPython 中大多数小部件的基类。 还有一个相反的过程。 如果要从事件中取消绑定方法，请调用`Unbind()`方法。 它具有与上述相同的参数。
 
@@ -200,7 +200,7 @@ else:
 
 事件有两种类型：基本事件和命令事件。 它们的传播方式不同。 事件传播是事件从子窗口小部件到父窗口小部件和祖父窗口小部件的传播。 基本事件不会传播。 命令事件确实传播。 例如，`wx.CloseEvent`是一个基本事件。 此事件传播到父窗口小部件没有任何意义。
 
-默认情况下，在事件处理程序中捕获的事件停止传播。 为了继续传播，我们调用`Skip()`方法。
+默认情况下，在事件处理器中捕获的事件停止传播。 为了继续传播，我们调用`Skip()`方法。
 
 `event_propagation.py`
 
@@ -279,7 +279,7 @@ if __name__ == '__main__':
 
 ```
 
-在我们的示例中，面板上有一个按钮。 面板放置在框架小部件中。 我们为所有小部件定义一个处理程序。
+在我们的示例中，面板上有一个按钮。 面板放置在框架小部件中。 我们为所有小部件定义一个处理器。
 
 ```py
 def OnButtonClicked(self, e):
@@ -455,7 +455,7 @@ self.Bind(wx.EVT_BUTTON, self.OnQuitApp, id=wx.ID_EXIT)
 
 ```
 
-我们将按钮单击事件绑定到`OnQuitApp()`事件处理程序。 `id`参数用于区分按钮。 我们唯一地标识事件的来源。
+我们将按钮单击事件绑定到`OnQuitApp()`事件处理器。 `id`参数用于区分按钮。 我们唯一地标识事件的来源。
 
 ![Standard identifiers](img/2970522f1f2eb32db73c05d5e0c41244.jpg)
 
@@ -762,7 +762,7 @@ self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
 
 ```
 
-我们将两个焦点事件绑定到事件处理程序。
+我们将两个焦点事件绑定到事件处理器。
 
 ```py
 def OnPaint(self, e):
@@ -803,7 +803,7 @@ def OnKillFocus(self, e):
 
 ## `wx.KeyEvent`
 
-当我们按下键盘上的一个键时，会生成一个`wx.KeyEvent`。 此事件发送到当前具有焦点的窗口小部件。 共有三种不同的密钥处理程序：
+当我们按下键盘上的一个键时，会生成一个`wx.KeyEvent`。 此事件发送到当前具有焦点的窗口小部件。 共有三种不同的密钥处理器：
 
 *   wx.EVT_KEY_DOWN
 *   wx.EVT_KEY_UP
@@ -877,7 +877,7 @@ pnl.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
 
 ```
 
-我们将事件处理程序绑定到`wx.EVT_KEY_DOWN`事件。
+我们将事件处理器绑定到`wx.EVT_KEY_DOWN`事件。
 
 ```py
 key = e.GetKeyCode()

docs/gui/106.md

@@ -90,7 +90,7 @@ cbtn.Bind(wx.EVT_BUTTON, self.OnClose)
 
 ```
 
-当我们单击按钮时，将触发`wx.EVT_BUTTON`事件。 我们为事件指定事件处理程序。
+当我们单击按钮时，将触发`wx.EVT_BUTTON`事件。 我们为事件指定事件处理器。
 
 ```py
 def OnClose(self, e):
@@ -238,7 +238,7 @@ rtb.Bind(wx.EVT_TOGGLEBUTTON, self.ToggleRed)
 
 ```
 
-当我们单击`rtb`切换按钮时，将调用`ToggleRed()`事件处理程序。
+当我们单击`rtb`切换按钮时，将调用`ToggleRed()`事件处理器。
 
 ```py
 def ToggleRed(self, e):
@@ -610,7 +610,7 @@ cb.Bind(wx.EVT_COMBOBOX, self.OnSelect)
 
 ```
 
-当我们从组合框中选择一个选项时，将触发`wx.EVT_COMBOBOX`事件。 我们将`OnSelect()`事件处理程序插入此事件。
+当我们从组合框中选择一个选项时，将触发`wx.EVT_COMBOBOX`事件。 我们将`OnSelect()`事件处理器插入此事件。
 
 ```py
 def OnSelect(self, e):
@@ -715,7 +715,7 @@ cb.Bind(wx.EVT_CHECKBOX, self.ShowOrHideTitle)
 
 ```
 
-当我们单击`wx.CheckBox`小部件时，将触发`wx.EVT_CHECKBOX`事件。 在此事件上调用`ShowOrHideTitle()`事件处理程序。
+当我们单击`wx.CheckBox`小部件时，将触发`wx.EVT_CHECKBOX`事件。 在此事件上调用`ShowOrHideTitle()`事件处理器。
 
 ```py
 def ShowOrHideTitle(self, e):
@@ -902,7 +902,7 @@ self.rb1.Bind(wx.EVT_RADIOBUTTON, self.SetVal)
 
 ```
 
-我们将`wx.EVT_RADIOBUTTON`事件绑定到`SetVal()`事件处理程序。
+我们将`wx.EVT_RADIOBUTTON`事件绑定到`SetVal()`事件处理器。
 
 ```py
 self.sb = self.CreateStatusBar(3)

docs/gui/109.md

@@ -536,7 +536,7 @@ dc.DrawLine(155, 130, 155, 250)
 
 图：连接和盖帽
 
-### 渐变色
+### 渐变
 
 在计算机图形学中，渐变是从浅到深或从一种颜色到另一种颜色的阴影的平滑混合。 在 2D 绘图程序和绘图程序中，渐变用于创建彩色背景和特殊效果以及模拟灯光和阴影。
 

docs/gui/112.md

@@ -19,9 +19,9 @@ wxPython 是旨在创建应用的工具包。 还有其他一些旨在创建计
 游戏背后的一些想法：
 
 *   我们使用`wx.Timer`创建游戏周期
-*   绘制四蛋白
+*   绘制四个形状
 *   形状以正方形为单位移动（不是逐个像素移动）
-*   从数学上讲，木板是简单的数字列表
+*   从数学上讲，棋盘是简单的数字列表
 
 `tetris.py`
 

docs/gui/113.md

@@ -20,7 +20,7 @@
 
 ## GTK+ 
 
-GTK+ 是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK+ 也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理程序时创建的。
+GTK+ 是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK+ 也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理器时创建的。
 
 ## 相关教程
 

docs/gui/114.md

@@ -6,7 +6,7 @@
 
 ## GTK+ 
 
-GTK+ 是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK+ 库也称为 GIMP 工具箱。 最初，该库是在开发 GIMP 图像处理程序时创建的。 从那时起，GTK+ 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK+ 中创建的。 GTK+ 是一个面向对象的应用编程接口。 面向对象的系统是使用 Glib 对象系统创建的，该系统是 GTK+ 库的基础。`GObject`还可以为各种其他编程语言创建语言绑定。 存在用于 C++ ，Python，Perl，Java，C# 和其他编程语言的语言绑定。
+GTK+ 是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK+ 库也称为 GIMP 工具箱。 最初，该库是在开发 GIMP 图像处理器时创建的。 从那时起，GTK+ 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK+ 中创建的。 GTK+ 是一个面向对象的应用编程接口。 面向对象的系统是使用 Glib 对象系统创建的，该系统是 GTK+ 库的基础。`GObject`还可以为各种其他编程语言创建语言绑定。 存在用于 C++ ，Python，Perl，Java，C# 和其他编程语言的语言绑定。
 
 GTK+ 本身取决于以下库：
 

docs/gui/116.md

@@ -578,7 +578,7 @@ if (event->type == GDK_BUTTON_PRESS) {
 
 ```
 
-在事件处理程序内部，我们检查按钮按下事件的类型。
+在事件处理器内部，我们检查按钮按下事件的类型。
 
 ```c
 if (bevent->button == RIGHT_CLICK) {      

docs/gui/118.md

@@ -335,7 +335,7 @@ handler_id = g_signal_connect(G_OBJECT(btn), "clicked",
 
 ```
 
-`g_signal_connect()`返回唯一标识回调的处理程序 ID。
+`g_signal_connect()`返回唯一标识回调的处理器 ID。
 
 ```c
 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {

docs/gui/122.md

@@ -212,7 +212,7 @@ g_signal_connect(selection, "changed",
 
 ```
 
-`GtkTreeSelection`的`changed`信号连接到`on_changed()`处理程序。
+`GtkTreeSelection`的`changed`信号连接到`on_changed()`处理器。
 
 ```c
 if (gtk_tree_selection_get_selected(

docs/gui/123.md

@@ -215,7 +215,7 @@ g_signal_connect(buffer, "changed",
 
 ```
 
-更改文本时，我们将调用`update_statusbar()`处理程序。
+更改文本时，我们将调用`update_statusbar()`处理器。
 
 ```c
 g_signal_connect_object(buffer, "mark_set", 

docs/gui/127.md

@@ -440,7 +440,7 @@ if __name__ == '__main__':
 
 ```
 
-如果我们关闭`QtGui.QWidget`，则会生成`QtGui.QCloseEvent`。 要修改小部件的行为，我们需要重新实现`closeEvent()`事件处理程序。
+如果我们关闭`QtGui.QWidget`，则会生成`QtGui.QCloseEvent`。 要修改小部件的行为，我们需要重新实现`closeEvent()`事件处理器。
 
 ```py
 reply = QtGui.QMessageBox.question(self, 'Message',

docs/gui/130.md

@@ -108,9 +108,9 @@ sld.valueChanged.connect(lcd.display)
 
 图：信号和槽
 
-## 重新实现事件处理程序
+## 重新实现事件处理器
 
-PyQt4 中的事件通常通过重新实现事件处理程序来处理。
+PyQt4 中的事件通常通过重新实现事件处理器来处理。
 
 ```py
 #!/usr/bin/python
@@ -159,7 +159,7 @@ if __name__ == '__main__':
 
 ```
 
-在我们的示例中，我们重新实现了`keyPressEvent()`事件处理程序。
+在我们的示例中，我们重新实现了`keyPressEvent()`事件处理器。
 
 ```py
 def keyPressEvent(self, e):

docs/gui/132.md

@@ -460,7 +460,7 @@ def timerEvent(self, e):
 
 ```
 
-每个`QtCore.QObject`及其子代都有一个`timerEvent()`事件处理程序。 为了对计时器事件做出反应，我们重新实现了事件处理程序。
+每个`QtCore.QObject`及其子代都有一个`timerEvent()`事件处理器。 为了对计时器事件做出反应，我们重新实现了事件处理器。
 
 ```py
 def doAction(self):

docs/gui/137.md

@@ -27,7 +27,7 @@ PyQt4 是旨在创建应用的工具包。 还有其他一些旨在创建计算
 *   我们使用`QtCore.QBasicTimer()`创建游戏周期。
 *   绘制四聚体。
 *   形状以正方形为单位移动（而不是逐个像素移动）。
-*   从数学上讲，木板是一个简单的数字列表。
+*   从数学上讲，棋盘是一个简单的数字列表。
 
 该代码包括四个类别：`Tetris`，`Board`，`Tetrominoe`和`Shape`。 `Tetris`类设置游戏。 `Board`是编写游戏逻辑的地方。 `Tetrominoe`类包含所有俄罗斯方块的名称，`Shape`类包含俄罗斯方块的代码。
 

docs/gui/147.md

@@ -152,7 +152,7 @@ void KeyPress::keyPressEvent(QKeyEvent *e) {
 
 ```
 
-在 Qt4 中使用事件的一种方法是重新实现事件处理程序。 `QKeyEvent`是一个事件对象，其中包含有关发生的情况的信息。 在我们的例子中，我们使用事件对象来确定实际按下了哪个键。
+在 Qt4 中使用事件的一种方法是重新实现事件处理器。 `QKeyEvent`是一个事件对象，其中包含有关发生的情况的信息。 在我们的例子中，我们使用事件对象来确定实际按下了哪个键。
 
 `main.cpp`
 

docs/gui/150.md

@@ -652,7 +652,7 @@ int main(int argc, char *argv[]) {
 
 图：形状
 
-## 渐变色
+## 渐变
 
 在计算机图形学中，渐变是从浅到深或从一种颜色到另一种颜色的阴影的平滑混合。 在 2D 绘图程序和绘图程序中，渐变用于创建彩色背景和特殊效果以及模拟灯光和阴影。
 
@@ -903,7 +903,7 @@ class Puff : public QWidget {
 
 ```
 
-在头文件中，我们定义了两个事件处理程序：绘图事件处理程序和计时器处理程序。
+在头文件中，我们定义了两个事件处理器：绘图事件处理器和计时器处理器。
 
 `puff.cpp`
 

docs/gui/155.md

@@ -405,7 +405,7 @@ if __name__ == '__main__':
 
 ```
 
-如果我们关闭`QtGui.QWidget`，则会生成`QCloseEvent`。 要修改小部件的行为，我们需要重新实现`closeEvent()`事件处理程序。
+如果我们关闭`QtGui.QWidget`，则会生成`QCloseEvent`。 要修改小部件的行为，我们需要重新实现`closeEvent()`事件处理器。
 
 ```py
 reply = QtGui.QMessageBox.question(self, 'Message',

docs/gui/158.md

@@ -90,9 +90,9 @@ sld.valueChanged.connect(lcd.display)
 
 图：信号和槽
 
-## 重新实现事件处理程序
+## 重新实现事件处理器
 
-PySide 中的事件通常通过重新实现事件处理程序来处理。
+PySide 中的事件通常通过重新实现事件处理器来处理。
 
 ```py
 #!/usr/bin/python
@@ -141,7 +141,7 @@ if __name__ == '__main__':
 
 ```
 
-在我们的示例中，我们重新实现了`keyPressEvent()`事件处理程序。
+在我们的示例中，我们重新实现了`keyPressEvent()`事件处理器。
 
 ```py
 def keyPressEvent(self, e):

docs/gui/160.md

@@ -454,7 +454,7 @@ def timerEvent(self, e):
 
 ```
 
-每个`QtCore.QObject`及其子代都有一个`timerEvent()`事件处理程序。 为了对计时器事件做出反应，我们重新实现了事件处理程序。 我们更新`self.step`变量，并为进度栏小部件设置一个新值。
+每个`QtCore.QObject`及其子代都有一个`timerEvent()`事件处理器。 为了对计时器事件做出反应，我们重新实现了事件处理器。 我们更新`self.step`变量，并为进度栏小部件设置一个新值。
 
 ```py
 def doAction(self):

docs/gui/165.md

@@ -25,7 +25,7 @@ PySide 是旨在创建应用的工具包。 还有其他一些旨在创建计算
 *   我们使用`QtCore.QBasicTimer()`创建游戏周期。
 *   绘制四聚体。
 *   形状以正方形为单位移动（而不是逐个像素移动）。
-*   从数学上讲，木板是一个简单的数字列表。
+*   从数学上讲，棋盘是一个简单的数字列表。
 
 ```py
 #!/usr/bin/python

docs/gui/169.md

@@ -275,7 +275,7 @@ bind .fr.lb <<ListboxSelect>> { setLabel [%W curselection]}
 
 ```
 
-当我们在列表框中选择一个项目时，将生成`<<ListboxSelect>>`事件。 我们将`setLabel`过程绑定到此事件。 我们还向过程发送参数。 当前所选值的索引。 `%W curselection`返回索引。 `%W`是有关小部件的处理程序，`curselection`是在此小部件上执行的命令。
+当我们在列表框中选择一个项目时，将生成`<<ListboxSelect>>`事件。 我们将`setLabel`过程绑定到此事件。 我们还向过程发送参数。 当前所选值的索引。 `%W curselection`返回索引。 `%W`是有关小部件的处理器，`curselection`是在此小部件上执行的命令。
 
 ```tcl
 proc setLabel { idx } {

docs/gui/183.md

@@ -17,7 +17,7 @@
 *   [对话框](dialogs/)
 *   [拖放](dragdrop/)
 *   [绘图](painting/)
-*   [蛇](snake/)
+*   [贪食蛇](snake/)
 
 
 

docs/gui/185.md

@@ -270,7 +270,7 @@ button.Click += new EventHandler(OnClick);
 
 ```
 
-此代码行将事件处理程序插入`Click`事件。 当我们单击按钮时，将调用`OnClick()`方法。
+此代码行将事件处理器插入`Click`事件。 当我们单击按钮时，将调用`OnClick()`方法。
 
 ```cs
 button.MouseEnter += new EventHandler(OnEnter);

docs/gui/191.md

@@ -89,7 +89,7 @@ button.MouseMove += new MouseEventHandler(OnMouseMove);
 
 ```
 
-我们为按钮插入了三种不同的鼠标处理程序。 它们实现了拖放过程的三个不同阶段。 当我们单击按钮时，过程开始。 这由`OnMouseDown()`方法处理。 第二部分是机芯。 这是当我们将对象移动到新位置时。 它以`OnMouseMove()`方法处理。 最后一部分是过程停止的时间。 当我们释放鼠标按钮时会发生这种情况。 适当的任务委托给`OnMouseUp()`方法。
+我们为按钮插入了三种不同的鼠标处理器。 它们实现了拖放过程的三个不同阶段。 当我们单击按钮时，过程开始。 这由`OnMouseDown()`方法处理。 第二部分是机芯。 这是当我们将对象移动到新位置时。 它以`OnMouseMove()`方法处理。 最后一部分是过程停止的时间。 当我们释放鼠标按钮时会发生这种情况。 适当的任务委托给`OnMouseUp()`方法。
 
 ```cs
 private void OnMouseDown(object sender, MouseEventArgs e) 

docs/gui/192.md

@@ -272,7 +272,7 @@ g.FillRectangle(hb, 10, 15, 90, 60);
 
 图：通口
 
-## 渐变色
+## 渐变
 
 在计算机图形学中，渐变是从浅到深或从一种颜色到另一种颜色的阴影的平滑混合。 在 2D 绘图程序和绘图程序中，渐变用于创建彩色背景和特殊效果以及模拟灯光和阴影。 （answers.com）
 

docs/gui/195.md

@@ -12,7 +12,7 @@
 
 Java Gnome 是 Java 编程语言的 GTK+ 和 Gnome 的包装。
 
-GTK+  是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK+ 库也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理程序时创建的。 从那时起，GTK+ 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK+ 中创建的。 GTK+ 是面向对象的应用编程接口。 有几种其他编程语言的绑定。 存在用于 C++ ，Python，Perl，Java，C# 和其他编程语言的语言绑定。
+GTK+  是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK+ 库也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理器时创建的。 从那时起，GTK+ 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK+ 中创建的。 GTK+ 是面向对象的应用编程接口。 有几种其他编程语言的绑定。 存在用于 C++ ，Python，Perl，Java，C# 和其他编程语言的语言绑定。
 
 GNOME 是一个桌面环境，是在计算机操作系统之上运行的图形用户界面。 这是一个国际项目，包括创建软件开发框架，为桌面选择应用软件，以及开发用于管理应用启动，文件处理以及窗口和任务管理的程序。 GNOME 是 GNU Project 的一部分，可以与各种类似 Unix 的操作系统一起使用。 （wikipedia.org）
 

docs/gui/208.md

@@ -131,7 +131,7 @@ cr.save();
 
 图：多纳圈
 
-## 渐变色
+## 渐变
 
 在计算机图形学中，渐变是从浅到深或从一种颜色到另一种颜色的阴影的平滑混合。 在 2D 绘图程序和绘图程序中，渐变用于创建彩色背景和特殊效果以及模拟灯光和阴影。 （answers.com）
 

docs/gui/21.md

@@ -432,7 +432,7 @@ if __name__ == '__main__':
 
 ```
 
-如果我们关闭`QWidget`，则会生成`QCloseEvent`。 要修改小部件的行为，我们需要重新实现`closeEvent()`事件处理程序。
+如果我们关闭`QWidget`，则会生成`QCloseEvent`。 要修改小部件的行为，我们需要重新实现`closeEvent()`事件处理器。
 
 ```py
 reply = QMessageBox.question(self, 'Message',

docs/gui/219.md

@@ -21,7 +21,7 @@
 
 ## GTK
 
-GTK 是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK 库也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理程序时创建的。 从那时起，GTK 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK 中创建的。 语言绑定适用于 C++ ，Python，Perl，Java，C# ，JavaScript，PHP 和其他编程语言。
+GTK 是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK 库也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理器时创建的。 从那时起，GTK 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK 中创建的。 语言绑定适用于 C++ ，Python，Perl，Java，C# ，JavaScript，PHP 和其他编程语言。
 
 [Tweet](https://twitter.com/share) 
 

docs/gui/220.md

@@ -293,7 +293,7 @@ Gtk.main
 
 ```
 
-在示例中，我们将`Gtk::Button`小部件放置在窗口上。 我们将处理程序附加到`clicked`信号。
+在示例中，我们将`Gtk::Button`小部件放置在窗口上。 我们将处理器附加到`clicked`信号。
 
 ```rb
 button = Gtk::Button.new :label => "Quit"

docs/gui/229.md

@@ -6,7 +6,7 @@
 
 ## GTK+ 
 
-GTK+  是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK+ 库也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理程序时创建的。 从那时起，GTK+ 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK+ 中创建的。 GTK+ 是面向对象的应用编程接口。 面向对象的系统是使用 Glib 对象系统创建的，该系统是 GTK+ 库的基础。 `GObject`还可以为其他各种编程语言创建语言绑定。 存在用于 C++ ，Python，Perl，Java，C# 和其他编程语言的语言绑定。
+GTK+  是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK+ 库也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理器时创建的。 从那时起，GTK+ 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK+ 中创建的。 GTK+ 是面向对象的应用编程接口。 面向对象的系统是使用 Glib 对象系统创建的，该系统是 GTK+ 库的基础。 `GObject`还可以为其他各种编程语言创建语言绑定。 存在用于 C++ ，Python，Perl，Java，C# 和其他编程语言的语言绑定。
 
 GTK+ 本身取决于以下库。
 
@@ -23,7 +23,7 @@ Gnome 和 XFce 桌面环境已使用 GTK+ 库创建。 SWT 和 wxWidgets 是使
 
 ## GTK# 
 
-GTK# 是针对 C# 编程语言的 GTK+ 的包装。 该库有助于使用 Mono 或任何其他兼容的 CLR 构建图形 GNOME 应用。 Gtk# 是一个事件驱动的系统，就像任何其他现代的窗口库一样，其中应用中的每个小部件都具有处理程序方法，这些处理程序方法在发生特定事件时被调用。 使用 Gtk# 构建的应用将在许多平台上运行，包括 Linux，Microsoft，Windows 和 Mac OSX。GTK# 是 Mono 计划的一部分。 Mono 中基本上有两个窗口小部件工具箱：Winforms 和 GTK# 。 GTK# 被认为是 Linux/Unix 操作系统的本机。
+GTK# 是针对 C# 编程语言的 GTK+ 的包装。 该库有助于使用 Mono 或任何其他兼容的 CLR 构建图形 GNOME 应用。 Gtk# 是一个事件驱动的系统，就像任何其他现代的窗口库一样，其中应用中的每个小部件都具有处理器方法，这些处理器方法在发生特定事件时被调用。 使用 Gtk# 构建的应用将在许多平台上运行，包括 Linux，Microsoft，Windows 和 Mac OSX。GTK# 是 Mono 计划的一部分。 Mono 中基本上有两个窗口小部件工具箱：Winforms 和 GTK# 。 GTK# 被认为是 Linux/Unix 操作系统的本机。
 
 ## 编译 GTK# 应用
 

docs/gui/230.md

@@ -161,7 +161,7 @@ DeleteEvent += new DeleteEventHandler(OnDelete);
 
 ```
 
-这是另一种方式，我们如何将事件处理程序插入事件。 只是有点冗长。
+这是另一种方式，我们如何将事件处理器插入事件。 只是有点冗长。
 
 ```cs
 void OnDelete(object obj, DeleteEventArgs args)
@@ -171,7 +171,7 @@ void OnDelete(object obj, DeleteEventArgs args)
 
 ```
 
-这是删除事件的事件处理程序。
+这是删除事件的事件处理器。
 
 ![Icon](img/e5af2c2cf8196372e49aba585fbd7138.jpg)
 

docs/gui/234.md

@@ -117,7 +117,7 @@ class SharpApp : Window {
 
 ```
 
-在前面的示例中，我们已将委托或方法插入事件。 在 GTK# 中，许多事件已经具有处理程序方法。 在这种情况下，我们可以覆盖该方法。 在我们的代码示例中就是这种情况。
+在前面的示例中，我们已将委托或方法插入事件。 在 GTK# 中，许多事件已经具有处理器方法。 在这种情况下，我们可以覆盖该方法。 在我们的代码示例中就是这种情况。
 
 ```cs
 protected override bool OnConfigureEvent(Gdk.EventConfigure args)
@@ -198,9 +198,9 @@ button.ModifyBg(StateType.Prelight, new Gdk.Color(220, 220, 220));
 
 我们获取按钮小部件并修改其背景颜色。
 
-## 断开事件处理程序
+## 断开事件处理器
 
-我们可以从事件断开处理程序方法。 下一个代码示例演示了这种情况。
+我们可以从事件断开处理器方法。 下一个代码示例演示了这种情况。
 
 `disconnect.cs`
 
@@ -258,7 +258,7 @@ class SharpApp : Window {
 
 ```
 
-在代码示例中，我们有一个按钮和一个复选框。 当我们单击按钮并且复选框处于活动状态时，我们在控制台中显示“单击”文本。 该复选框可将处理程序方法与按钮`Clicked`事件连接或断开连接。
+在代码示例中，我们有一个按钮和一个复选框。 当我们单击按钮并且复选框处于活动状态时，我们在控制台中显示“单击”文本。 该复选框可将处理器方法与按钮`Clicked`事件连接或断开连接。
 
 ```cs
 CheckButton cb = new CheckButton("connect");
@@ -278,7 +278,7 @@ if (cb.Active) {
 
 ```
 
-这些行根据复选框小部件的状态连接或断开事件处理程序。
+这些行根据复选框小部件的状态连接或断开事件处理器。
 
 ![Disconnect](img/41431b0d3761a6122e24c9b4a7893cb0.jpg)
 

docs/gui/236.md

@@ -317,7 +317,7 @@ red.Clicked += OnRed;
 
 ```
 
-`ToggleButton`小部件已创建。 我们将其大小设置为`80x35`像素。 每个切换按钮都有其自己的处理程序方法。
+`ToggleButton`小部件已创建。 我们将其大小设置为`80x35`像素。 每个切换按钮都有其自己的处理器方法。
 
 ```cs
 darea = new DrawingArea();

docs/gui/24.md

@@ -90,9 +90,9 @@ sld.valueChanged.connect(lcd.display)
 
 图：信号和槽
 
-## 重新实现事件处理程序
+## 重新实现事件处理器
 
-PyQt5 中的事件通常通过重新实现事件处理程序来处理。
+PyQt5 中的事件通常通过重新实现事件处理器来处理。
 
 `escape.py`
 
@@ -141,7 +141,7 @@ if __name__ == '__main__':
 
 ```
 
-在我们的示例中，我们重新实现了`keyPressEvent()`事件处理程序。
+在我们的示例中，我们重新实现了`keyPressEvent()`事件处理器。
 
 ```py
 def keyPressEvent(self, e):

docs/gui/241.md

@@ -100,7 +100,7 @@ for (int i = 0; i < 36; i++) {
 
 图：多纳圈
 
-## 渐变色
+## 渐变
 
 在计算机图形学中，渐变是从浅到深或从一种颜色到另一种颜色的阴影的平滑混合。 在 2D 绘图程序和绘图程序中，渐变用于创建彩色背景和特殊效果以及模拟灯光和阴影。 （answers.com）
 
@@ -505,7 +505,7 @@ cr.Paint();
 
 ```
 
-背景充满了渐变色的油漆。 涂料是从黑色到深灰色的平滑混合。
+背景充满了渐变的油漆。 涂料是从黑色到深灰色的平滑混合。
 
 ```cs
 cr.Translate(0, 2 * imageHeight + gap);

docs/gui/244.md

@@ -107,7 +107,7 @@ AddHandler Me.DeleteEvent, AddressOf Me.OnDeleteEvent
 
 ```
 
-我们将处理程序插入`DeleteEvent`。
+我们将处理器插入`DeleteEvent`。
 
 ```vb
 Me.Show

docs/gui/246.md

@@ -451,7 +451,7 @@ AddHandler redb.Toggled, AddressOf Me.OnToggled
 
 ```
 
-`ToggleButton`小部件已创建。 我们将其大小设置为`80x35`像素。 每个切换按钮具有相同的处理程序方法。
+`ToggleButton`小部件已创建。 我们将其大小设置为`80x35`像素。 每个切换按钮具有相同的处理器方法。
 
 ```vb
 darea = New DrawingArea

docs/gui/252.md

@@ -24,7 +24,7 @@ PyGTK 已过时，请参阅 [Python Gtk 教程](/python/gtk/)。
 *   [Pango II](pangoII/)
 *   [使用 Cario 绘图](drawing/)
 *   [使用 cairo II](drawingII/) 绘制
-*   [蛇](snake/)
+*   [贪食蛇](snake/)
 *   [自定义小部件](customwidget/)
 
 

docs/gui/253.md

@@ -24,7 +24,7 @@ PyGTK 由几个模块组成。
 
 ## GTK+ 
 
-![](img/953782da5a9817d9d1f8249b3cec49e7.jpg) GTK+  是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK+ 库也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理程序时创建的。 从那时起，GTK+ 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK+ 中创建的。 GTK+ 是面向对象的应用编程接口。 面向对象的系统是使用 Glib 对象系统创建的，该系统是 GTK+ 库的基础。 `GObject`还可以为其他各种编程语言创建语言绑定。 存在用于 C++ ，Python，Perl，Java，C# 和其他编程语言的语言绑定。
+![](img/953782da5a9817d9d1f8249b3cec49e7.jpg) GTK+  是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK+ 库也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理器时创建的。 从那时起，GTK+ 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK+ 中创建的。 GTK+ 是面向对象的应用编程接口。 面向对象的系统是使用 Glib 对象系统创建的，该系统是 GTK+ 库的基础。 `GObject`还可以为其他各种编程语言创建语言绑定。 存在用于 C++ ，Python，Perl，Java，C# 和其他编程语言的语言绑定。
 
 Gnome 和 XFce 桌面环境已使用 GTK+ 库创建。 SWT 和 wxWidgets 是使用 GTK+ 的众所周知的编程框架。 使用 GTK+ 的著名软件应用包括 Firefox 或 Inkscape。
 

docs/gui/258.md

@@ -8,7 +8,7 @@
 
 事件是从 X 服务器到应用的消息。 当我们单击按钮小部件时，单击的信号将以发出。 有所有小部件都继承的信号，例如销毁，有特定于小部件的信号，例如在切换按钮上切换。
 
-程序员使用信号处理程序来响应各种信号。 这些处理程序在 GTK 程序员中称为回调。
+程序员使用信号处理器来响应各种信号。 这些处理器在 GTK 程序员中称为回调。
 
 ```py
 handler_id = button.connect("clicked", self.on_clicked)
@@ -17,7 +17,7 @@ handler_id = button.connect("clicked", self.on_clicked)
 
 在这里，我们使用`GObject`类的`connect()`方法（（`GtkButton`是`GObject`））将回调`on_clicked()`连接到名为`clicked`的信号。
 
-`connect()`方法返回一个处理程序 ID，用于唯一标识回调方法。 该 ID 可以与以下方法一起使用：
+`connect()`方法返回一个处理器 ID，用于唯一标识回调方法。 该 ID 可以与以下方法一起使用：
 
 ```py
 def disconnect(handler_id)
@@ -28,7 +28,7 @@ def handler_unblock(handler_id)
 
 ```
 
-这些方法使处理程序可以与`GObject`断开连接，也可以对其进行阻止/取消阻止。
+这些方法使处理器可以与`GObject`断开连接，也可以对其进行阻止/取消阻止。
 
 ## 信号与事件
 
@@ -38,7 +38,7 @@ def handler_unblock(handler_id)
 
 信号就是回调机制。 如果一个对象希望收到有关另一对象的动作或状态更改的通知，它将注册一个回调。 当对象发出信号时，它会在已向其注册的回调列表中查找并调用特定信号的回调。 它可以选择发送一些预定义的数据。
 
-信号是一个通用的通知框架。 它们不仅用于有关 UI 更改的通知。 它们可用于有关应用状态更改的通知。 信号是通用的，有力的，其用途非常广泛。 任何`GObject`都可以发射和接收信号。 一个类型可以具有一个或多个信号，每个信号可以具有一个参数列表和返回值。 然后可以将处理程序连接到该类型的实例。 在实例上发出信号时，将调用每个连接的处理程序。
+信号是一个通用的通知框架。 它们不仅用于有关 UI 更改的通知。 它们可用于有关应用状态更改的通知。 信号是通用的，有力的，其用途非常广泛。 任何`GObject`都可以发射和接收信号。 一个类型可以具有一个或多个信号，每个信号可以具有一个参数列表和返回值。 然后可以将处理器连接到该类型的实例。 在实例上发出信号时，将调用每个连接的处理器。
 
 信号和事件之间的唯一联系是信号用于从 X 服务器发送有关事件的通知。
 
@@ -196,7 +196,7 @@ gobject.signal_new("z_signal", Sender, gobject.SIGNAL_RUN_FIRST,
 
 ```
 
-我们注册一个新对象和一个新信号。 `signal_new()`功能为发件人对象注册一个名为`z_signal`的信号。 `SIGNAL_RUN_FIRST`参数意味着接收信号的对象的默认处理程序称为“第一”。 最后两个参数是返回值类型和参数类型。 在我们的示例中，我们不返回任何值，也不发送任何参数。
+我们注册一个新对象和一个新信号。 `signal_new()`功能为发件人对象注册一个名为`z_signal`的信号。 `SIGNAL_RUN_FIRST`参数意味着接收信号的对象的默认处理器称为“第一”。 最后两个参数是返回值类型和参数类型。 在我们的示例中，我们不返回任何值，也不发送任何参数。
 
 ```py
 sender.connect('z_signal', self.report_signal)
@@ -243,9 +243,9 @@ gobject.type_register(Sender)
 
 我们还可以使用`__gsignals__`类属性来注册新信号。
 
-## 预定义的信号处理程序
+## 预定义的信号处理器
 
-PyGTK 中的对象可能具有预定义的信号处理程序。 这些处理程序以`do_*`开头。 例如`do_expose()`，`do_show()`或`do_clicked()`。
+PyGTK 中的对象可能具有预定义的信号处理器。 这些处理器以`do_*`开头。 例如`do_expose()`，`do_show()`或`do_clicked()`。
 
 `move.py`
 
@@ -293,7 +293,7 @@ gtk.main()
 
 当我们移动窗口或调整窗口大小时，X 服务器将发送配置事件。 然后将它们转换为`configure-event`信号。
 
-在我们的代码示例中，我们在标题栏中显示窗口左上角的 x，y 坐标。 我们可以简单地将信号处理程序连接到`configure-event`信号。 但是我们采取了不同的策略。 我们重写默认的类处理程序，在其中实现所需的逻辑。
+在我们的代码示例中，我们在标题栏中显示窗口左上角的 x，y 坐标。 我们可以简单地将信号处理器连接到`configure-event`信号。 但是我们采取了不同的策略。 我们重写默认的类处理器，在其中实现所需的逻辑。
 
 ```py
 __gsignals__ = {
@@ -313,7 +313,7 @@ def do_configure_event(self, event):
 
 ```
 
-在这里，我们将覆盖预定义的`do_configure_event()`方法。 我们将窗口的 x，y 坐标设置为窗口的标题。 另请注意最后一行。 它显式调用超类`do_configure_event()`方法。 这是因为它做了一些重要的工作。 尝试对此行添加注释以查看发生了什么。 调整窗口大小无法正常工作。 如果重写默认处理程序，则可能会或可能不会调用超类方法。 就我们而言，我们必须这样做。
+在这里，我们将覆盖预定义的`do_configure_event()`方法。 我们将窗口的 x，y 坐标设置为窗口的标题。 另请注意最后一行。 它显式调用超类`do_configure_event()`方法。 这是因为它做了一些重要的工作。 尝试对此行添加注释以查看发生了什么。 调整窗口大小无法正常工作。 如果重写默认处理器，则可能会或可能不会调用超类方法。 就我们而言，我们必须这样做。
 
 ![Configure signal](img/735c97985e070bb1c681c5ad8b089c8c.jpg)
 
@@ -421,9 +421,9 @@ def emit_signal(self):
 
 我们发出`button-release-event`信号。 它以`Event`对象为参数。 应用启动后，我们应该在控制台窗口中看到“已发布”文本。 当我们点击按钮时，所有三个信号都被触发。
 
-## 阻止事件处理程序
+## 阻止事件处理器
 
-我们可以阻止信号处理程序。 下一个示例显示了这一点。
+我们可以阻止信号处理器。 下一个示例显示了这一点。
 
 `block.py`
 
@@ -480,14 +480,14 @@ gtk.main()
 
 ```
 
-在代码示例中，我们有一个按钮和一个复选框。 当我们单击按钮并且复选框处于活动状态时，我们在控制台中显示“已单击”文本。 复选框从按钮`clicked`信号中阻止/取消处理程序方法。
+在代码示例中，我们有一个按钮和一个复选框。 当我们单击按钮并且复选框处于活动状态时，我们在控制台中显示“已单击”文本。 复选框从按钮`clicked`信号中阻止/取消处理器方法。
 
 ```py
 self.id = button.connect("clicked", self.on_clicked)
 
 ```
 
-`connect()`方法返回处理程序 ID。 此 ID 用于阻止和取消阻止处理程序。
+`connect()`方法返回处理器 ID。 此 ID 用于阻止和取消阻止处理器。
 
 ```py
 def toggle_blocking(self, checkbox, button):

docs/gui/26.md

@@ -463,7 +463,7 @@ def timerEvent(self, e):
 
 ```
 
-每个`QObject`及其子代都有一个`timerEvent()`事件处理程序。 为了对计时器事件做出反应，我们重新实现了事件处理程序。
+每个`QObject`及其子代都有一个`timerEvent()`事件处理器。 为了对计时器事件做出反应，我们重新实现了事件处理器。
 
 ```py
 def doAction(self):

docs/gui/260.md

@@ -310,7 +310,7 @@ red.connect("clicked", self.onred)
 
 ```
 
-`ToggleButton`小部件已创建。 我们将其大小设置为`80x35`像素。 每个切换按钮都有其自己的处理程序方法。
+`ToggleButton`小部件已创建。 我们将其大小设置为`80x35`像素。 每个切换按钮都有其自己的处理器方法。
 
 ```py
 self.darea = gtk.DrawingArea()

docs/gui/265.md

@@ -80,7 +80,7 @@ darea.connect("expose-event", self.expose)
 
 ```
 
-我们都使用作为`expose-event`信号处理程序的方法进行绘制。
+我们都使用作为`expose-event`信号处理器的方法进行绘制。
 
 ```py
 cr = widget.window.cairo_create()

docs/gui/266.md

@@ -96,7 +96,7 @@ for i in range(36):
 
 图：多纳圈
 
-## 渐变色
+## 渐变
 
 在计算机图形学中，渐变是从浅到深或从一种颜色到另一种颜色的阴影的平滑混合。 在 2D 绘图程序和绘图程序中，渐变用于创建彩色背景和特殊效果以及模拟灯光和阴影。 （answers.com）
 
@@ -478,7 +478,7 @@ cr.paint()
 
 ```
 
-背景充满了渐变色的油漆。 涂料是从黑色到深灰色的平滑混合。
+背景充满了渐变的油漆。 涂料是从黑色到深灰色的平滑混合。
 
 ```py
 cr.translate(0, 2 * self.imageHeight + self.gap)

docs/gui/269.md

@@ -21,7 +21,7 @@
 
 ## GTK
 
-GTK 是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK 库也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理程序时创建的。 从那时起，GTK 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK 中创建的。 存在用于 C++ ，Python，PHP，Perl，Java，C# 和其他编程语言的语言绑定。
+GTK 是用于创建图形用户界面的库。 该库是用 C 编程语言创建的。 GTK 库也称为 GIMP 工具包。 最初，该库是在开发 GIMP 图像处理器时创建的。 从那时起，GTK 成为 Linux 和 BSD Unix 下最受欢迎的工具包之一。 如今，开源世界中的大多数 GUI 软件都是在 Qt 或 GTK 中创建的。 存在用于 C++ ，Python，PHP，Perl，Java，C# 和其他编程语言的语言绑定。
 
 ## 相关教程
 

docs/gui/306.md

@@ -17,7 +17,7 @@
 *   [拖放](dragdrop/)
 *   [绘图](painting/)
 *   [绘图 II](paintingII/)
-*   [蛇](snake/)
+*   [贪食蛇](snake/)
 *   [俄罗斯方块](tetris/)
 
 ## Winforms

docs/gui/308.md

@@ -259,7 +259,7 @@ btn.Click += self.OnClick
 
 ```
 
-此代码行将事件处理程序插入`Click`事件。 当我们单击按钮时，将调用`OnClick()`方法。
+此代码行将事件处理器插入`Click`事件。 当我们单击按钮时，将调用`OnClick()`方法。
 
 ```py
 btn.MouseEnter += self.OnEnter

docs/gui/31.md

@@ -27,7 +27,7 @@ PyQt5 是旨在创建应用的工具包。 还有其他一些旨在创建计算
 *   我们使用`QtCore.QBasicTimer()`创建游戏周期。
 *   绘制四聚体。
 *   形状以正方形为单位移动（而不是逐个像素移动）。
-*   从数学上讲，木板是一个简单的数字列表。
+*   从数学上讲，棋盘是一个简单的数字列表。
 
 该代码包括四个类别：`Tetris`，`Board`，`Tetrominoe`和`Shape`。 `Tetris`类设置游戏。 `Board`是编写游戏逻辑的地方。 `Tetrominoe`类包含所有俄罗斯方块的名称，`Shape`类包含俄罗斯方块的代码。
 

docs/gui/315.md

@@ -71,7 +71,7 @@ button.MouseMove += self.OnMousMove
 
 ```
 
-我们为按钮插入了三种不同的鼠标处理程序。 它们实现了拖放过程的三个不同阶段。 当我们单击按钮时，过程开始。 这由`OnMousDown()`方法处理。 第二部分是机芯。 这是当我们将对象移动到新位置时。 它以`OnMousMove()`方法处理。 最后一部分是过程停止的时间。 当我们释放鼠标按钮时会发生这种情况。 适当的任务委托给`OnMousUp()`方法。
+我们为按钮插入了三种不同的鼠标处理器。 它们实现了拖放过程的三个不同阶段。 当我们单击按钮时，过程开始。 这由`OnMousDown()`方法处理。 第二部分是机芯。 这是当我们将对象移动到新位置时。 它以`OnMousMove()`方法处理。 最后一部分是过程停止的时间。 当我们释放鼠标按钮时会发生这种情况。 适当的任务委托给`OnMousUp()`方法。
 
 ```py
 def OnMousDown(self, sender,  event):

docs/gui/317.md

@@ -248,7 +248,7 @@ image.SetPixel(i, j, Color.FromArgb(lum, lum, lum))
 
 我们修改像素。
 
-## 渐变色
+## 渐变
 
 在计算机图形学中，渐变是从浅到深或从一种颜色到另一种颜色的阴影的平滑混合。 在 2D 绘图程序和绘图程序中，渐变用于创建彩色背景和特殊效果以及模拟灯光和阴影。 （answers.com）