第四部分 A ctiveX 控件

第 8 章使用 ActiveX 控件

ActiveX 控件是可执行组件，设计它们的目的是将其嵌入窗口或 Web 页中，来实现一些完备的功能。对于用户来讲，它们与我们在前一章中遇到的普通的W indows 控件十分相像，这些普通控件是通过对话编辑器或 Gallery 添加到程序的。但与普通控件不同的是， ActiveX 控件在 Web 页上或在对话框中是相同的，它使开发者可以同时接触两个明显不同的市场。

如果你对 ActiveX 控件感兴趣 ( 作为一个开发者，你理应如此 )，那么，你可能就是因为想使用它们或想编写它们。 Visual C++ 可以帮助你实现这两个目的。本章所涉及的是这一主题的前半部分，介绍如何在叫做包容器的客户应用程序中使用ActiveX 控件。第 9 章和第 10 章将涉及后半部分，介绍编写 ActiveX 控件的两种不同方法。本章将展现有关 ActiveX 控件的介绍性信息，因此，如果你愿意了解有关这一主题的入门知识的话，应该首先阅读这一章。

为了使讨论的长度适中，这些章中的范例程序使用了 MFC 。 MFC 框架管理了几百个 ActiveX 编程的详细资料，它使得编写包容器或 ActiveX 控件不再比W indows 中其他编程项目更为困难。编写使用现有的 ActiveX 控件的 MFC 包容器应用程序通常需要很少的或者根本就不需要什么基础知识。尽管在编写

ActiveX 控件时使用 MFC 有一些争论 ( 完全是因为大小的问题，我们将在下一章讨论 )，但是，当应用到包容器的时候，这些争论就不那么有效了。 MFC 将客户

/服务器之间的交互过程包装得非常完全，以致于如果没有 MFC 类库或类似支持的帮助，就难以编写一个包容器应用程序。不过，如果你不愿意使用 MFC ，Active Template Library(ATL )提供了另一种方案。 Visual C++ 包括一个叫做 AtlCon 的范例项目，它演示了如何使用 ATL 编写包容器应用程序。源文件位于文件夹MSDN\Samples\Vc98\ATL\AtlCon 之中。第 10 章为包容器应用程序的开发仔细讨论了 ATL 所提供的类型支持。

尽管本章和随后两章所讨论的是 ActiveX 控件的需求和内部操作，对于这样一个大主题，它们所介绍的也仅仅是基础知识。本章重点介绍一些方法，应用这些方法， Visual C++ 将使程序员在处理 ActiveX 控件时更加得心应手，无论你正在编写的是一个控件，还是使用该控件的包容器应用程序。如果想了解本领域内可能对 Internet 编程来说十分重要的内容，请参考专业资料，例如 Kraig Brockschmidt 的 Inside OLE （ OLE 内幕）第二版。你可以在 M S D N 在线帮助中找到完整的文本。

背景知识简介

ActiveX 这个名字是新的，但是，它的技术是成熟的。ActiveX 控件形成了 M icrosoft

的 ActiveX 技术的唯一组成部分，它们是建立在 Component Object Model( 组件对

象模型，C O M )和 OLE 的基础之上。OLE 用于代表 Object Linking and Embedding

（对象链接与嵌入），但是，因为对象嵌入很早就是 OLE 能力中的很小的一部分，所以 M icrosoft 已经抛弃了这个缩略语。目前， OLE 已经有了新的含义，不再具有版本号了。它已经从为特定目的而创建的一门技术，转化到了一种作为其他技术 ( 其中包括 ActiveX )基础的一般结构。 OLE 定义了为创建和连接包括叫做OLE 自定义控件在内的多种程序组件定义了一个标准的蓝图。至少，它们过去被称作 OLE 控件， M icrosoft 现在叫它们为 ActiveX 控件。

那么，什么是 OLE/ActiveX 控件呢 ? 简单的答案是 OLE/ActiveX 控件是一个动态链接库，它是作为基于 COM 的服务器进行操作的，并且可以嵌入在包容器宿主应用程序之中。详细的答案就是本章的内容。在深入介绍它的工作方式之前，让我们来回顾一下 OLE 控件的历史。

吸引 W indows 开发者注意的第一种类型的组件软件可能是 Visual Basic Extension 模型的自定义控件。自定义控件就是人们所熟悉的 VBX ，它是为添加到控件名之后的三字母扩展名而命名的。VBX 结构允许开发者向 Visual Basic 程序创建有效的和可重使用的附加物，它们可以作为自己组件放置在窗口之中，在 Visual Basic 中叫做表单。 VBX 控件的优点有三方面：

VBX 能够实现虚拟显示并与用户交互。
Viusal Basic 应用程序能够通过叫做方法的由 VBX 导出的

函数来编程

VBX 。

作为一个动态链接库，VBX 控件可以以二进制的形式代
替源代码重新使用。

正如我们将要看到的， ActiveX 控件可以提供相同的优点。

VBX 控件还允许程序员对从 Visual Basic 中继承下来的一些局限性进行补偿。例如，既然 VBX 控件通常是用 C 或汇编语言编写的，那么，它们就可以使用 Visual Basic 中没有的指针来帮助应用程序进行大量的指针操作，例如散列和分类。VBX 模型的一个问题是，它不是为向其他语言和平台完美地进行移植而设计的。例如，一个 C++ 程序员不能很容易地创建一个 VBX 派生物，因为 VBX 不是由类表示的。更进一步来说， VBX 模型是一个捆绑在 Intel 处理器分段结构之上的 16 位标准。不过， VBX 控件活跃的市场已经证明了，组件软件可以在 W indows 开发中充当很重要的角色。

OLE 控件标准是设计用来满足下一层次的要求的，它将 VBX 类型控件的优点带给了具有 W in32 编程功能的所有语言。这些语言包括 Access Basic; Visual Basic for Applications(VBA), WordBasic 和 Visual Basic Scripting(VBScript) 。

考虑到 VBX 取名的方法， OLE 控件通常被叫作 OCX ，这是因为 OCX 扩展名称通常添加到文件名的后面。有了 OCX 和 VBX 共有的约定，就足以说明其中一个是如何从另一种中演化的。例如， M icrosoft 从 VBX 术语中借用了三个接口类型，它们定义了 OLE 控件和它的客户、包容器应用程序之间的通信。

M ethod s（方法）： OLE 控件展现给包容器应用程序的函

数，允许客户调用该控件。
Properties( 属性 )：控件和包容器内部的公共数据，它

可以用来向对方描述自己。在启动期间，一个控件可以读取该包容器的属性，并且调整它的初始化过程，以便它与包容器的外观和特性相配。当控件处于活动状态的时候，包容器可以读取该控件的属性，来了解它当前的状态，如果控件允许的话，还可以重写属性，以改变控件的行为。
Events (事件 )：控件发送给包容器的通知，本章稍后将

详细介绍这个问题。一个事件通知是通过调用包容器中的一个函数来发生的，也就是众所周知的 “ 点燃 ” 事件。

就在人们已经注意到 16 位 VBX 的局限的时候， OLE (那些日子是叫 OLE2) 已逐渐趋于成熟，从逻辑上来说，它已成为以 OLE 控件形式存在的 VBX 的接任者，现在叫做 ActiveX 控件。

控件包容器

ActiveX 控件是服务器，包容器应用程序是客户。 ActiveX 控件最好从客户端实现，因此本节一开始是讨论包容器是如何通过现有的 ActiveX 控件扩展其能力，

我们通过几个例子和实验来进行演示。幸运的是，现成的样本非常多，我们可以从中进行选择。Visual C++ 和 Internet Explorer 随带一个免费特许的 ActiveX 控件集，其中的一部分在图 8-1 的 Gallery 对话中列出。如果想打开 Gallery 对话，请从 Project（项目）菜单中选择 Add To Project （添加到项目）命令，并单击次级菜单上的 Components And Controls （组件和控件）。然后双击 Registered ActiveX Controls 文件夹来显示控件列表。

第四部分 A ctiveX 控件 - 图1

图 8-1 Gallery 中的 ActiveX 控件

表 8-1 列出了 M icrosoft 提供的免费特许的 ActiveX 控件。如果在 Gallery 中选中了一个控件图标， More Inf o（其他信息）按钮是启用的，那么，这就意味着该控件可以通过在线帮助来描述自己。单击 More Info 按钮可以查看该控件的资料。

表 8-1 一些可以从 M icrosoft 中提供的 ActiveX 控件文件名说明

AniBtn32.ocx Animated button （动画按钮）：使用位图或元文件来创建一个带有变化的图像的按钮

BtnMenu.ocx M enu （菜单）：显示一个按钮和一个弹出式菜单，如图 8-2 所示。

DBGrid32.ocx Grid （网格）：以标准网格样式显示单元格的电子表控件。用户可以选定单元格 ( 与老的 G rid32 控件不同 )，并直接将数据输入单元格。还可以由包容器通过编程来填充单元格，或为了自动更新而捆绑到记录集

IELabel.ocx label（标签）：以一定角度或沿指定的曲线显示文字

续表

IEMenu.ocx Pop-up menu （弹出式菜单）：显示一个弹出式菜单，如图 8-2 所示

IEPopWnd.ocx IEPrld.ocx

Pop-up windo w（弹出窗口）：在弹出式窗口中显示

M T M L 文档

Preloade r（预加载器）：下载指定 URL 的内容，并将它存储在高速缓存中。完成下载之后，该控件将触发一个事件

IEStock.ocx stock ticker（股市自动接收机）：以指定的固定周期下载和显示 URL 的内容。正如它的名字所暗示的，该控件对于显示连续变化的数据时特别有用，如图 8-2 所示

IETimer.ocx Time r（计时器）：一个不可见的控件，以一定的周期触发一个事件

keySta32.ocx Key （键）状态：显示并有选择地修改 Cap Lock, Num Lock,Insert 和 Scroll Lock 键的状态

续表

M arquee.ocx M arquee （大屏幕）：水平或垂直方向滚动 H T M L 文件中的文字，可以被配置成改变滚动的数量和延迟时间

MCI32.ocx Multimedia （多媒体）：管理 M edia Control Interface(MC I，媒体控制接口 ) 设备的多媒体文件的录音和播放。该控件可以显示一套用于将 M C I 命令传向设备的推压式按钮，这些设备包括音频板、M IDI 序列发生器、 CD-ROM 驱动器、音频 CD 播放器、视频光盘播放器以及视频磁带录音机和播放器。该控件还支持 Video for Windows AVI 文件的播放

MSCal.ocx Calenda r（日历）：在屏幕上显示的日历，用户可以从中选择日期。

续表

MSChart.ocx Char t（图表）：一个高级的图表控件，它接收数字数据，然后显示几种图表类型之一，包括线、条和栏形图表。该控件的绘制以两维或三维形式显示，见图 8-2 和图 8-3

MSComm32.oc x

Comm （通信）：为串行通信提供支持，处理发送到串行口和从串行口接收的数据传输

MSMask32.ocx M asked edit（掩码编辑）：一个增强的编辑控件，它可以确保输入符合预先定义好的格式。例如，一个 “ ##:##?? ” 的约束将输入限制为时间格式。例如 “ 11:18 AM ”

PicCLP32.ocx Picture cli p（图片剪辑）：显示位图中剪下的矩形区域，可以根据指定的行数和列数将位图划分为网格

在表 8-1 中，一些文件名的“ IE ”前缀代表 Internet Explorer, 用来表明该控件是那个程序所包括的。 OCX 文件可以位于系统之上的任何地方，但通常都放在W indows\OCCache 和 W indows\System 子文件夹中。如果由于某种原因，你没有了这些文件，并且想沿着本章的演示继续下去，请从本书配套光盘的 OCX 文件

夹中将这些文件复制到你的 OCCache,System 或 System32 文件夹中。不过，不要假定这个小小的样本就代表了 ActiveX 控件中的最新词汇。市场上每天都有新控件出现，你可以在自己的应用程序中免费使用它们的演示版。如果你想浏览Internet 寻找一些控件，如下两个地址可以提供免费下载，并且提供了到应用程序开发者感兴趣的 Wes 站点的链接：

http://www.mcirosoft.com/com/ http://www.actrvex.com

第四部分 A ctiveX 控件 - 图2

图 8-2 几个在包容器上出现的 M icrosoft ActiveX 控件

当你从配套光盘或另一个来源向自己的硬盘复制控件文件的时候，请使用在vc98\Bin 于文件夹中找到的 RegSvr32.exe 实用程序对其进行注册。 RegSvr32 调用该控件的自注册函数，该函数将有关这个控件的信息写入系统注册表。在注册控件之前，包容器应用程序一般是没有办法来为嵌入而定位它的。单击 Start 按钮，并从 Run 对话中执行 Regsvr32 ,在命令行中指定一个 ocx 文件：

regsvr32\windows\occache\anibtm32.ocx

如果你的系统 PATH 语句没有包括 VC98\Bin 文件夹，那么，请在键入 regsvr32 的时候指定正确的路径。如果想解除对 ActiveX 控件的注册 ( 也就是说，从注册表中删除它的条目 )，请按照相同的方式再运行一遍 RegSvr32 ,但是要在文件名前包括开关 “ /u ”。解除对控件的注册并不从磁盘上删除它的 ocx 文件。

你还可以通过单击 Tools （工具）菜单上的 Register Contro l（注册表控件）命令来从 Visual C++ 中运行 Regsvr32 。不过，在默认状态下，该命令假定你想在结构之下注册一个控件，因此，它仅仅注册项目目标文件。第 13 章将解释如何修改像 Register Contro l（注册表控件）这样的工具，以便你可以将任何文件指定为命令行参数，而不仅仅是当前项目中一个文件。

向 Web 页添加 ActiveX 控件

在向项目插入 ActiveX 控件之前，你可能想先看一看控件。你只需一个文本编辑

器和一个支持 ActiveX 的浏览器即可，一个用于创建 H T M L 文档，另一个用于查看它。 H T M L 代表 Hypertext Markup Language( 超文本标记语言 )，它定义了一个简单的约定，以创建在各种书和文章中说明良好的 Web 页。仅仅通过几分钟的学习，你就可以了解到有关 H T M L 的许多知识。Visual C++ 文本编辑器可以编辑 H T M L 文件，在这方面，它的能力有限，但可以在显示窗口中为标记和其他文档元素加上颜色。

为了在 H T M L 文档中使用 ActiveX 控件，你必须首先找到该控件的 32 个数字的类标符号码。我们将在下一章中更加详细地介绍 CLSID ，现在，你只需知道如何查看该号码即可。注册表编辑器为找到控件的 CLSID 提供了一种方法。单击 Start 按钮，并在 Run 对话中键入 regedit 或 regedit32 ,究竟键入哪个，需取决于系统是W indows 95 还是 W indows NT 。单击注册表编辑器 Edit 菜单上的 Find 命令，然后键入该控件的文件名。

例如，在注册表编辑器中，搜索 ietimer.ocx ，将找到注册表中的如下层次：

第四部分 A ctiveX 控件 - 图3

位于窗口底部的 32 位数字的号码代表 Timer ActiveX 控件的 CLSID 。用相同的方式搜索 ielabel.ocx 将显示代表 Label ActiveX 控件的 CLSID ：

99b42120-6ec7-11cf-abc7-00aa00a47dd2

应用手头的这两个号码，你可以编写一个简单的 H T M L 文档，使用 Timer 和 Label

控件来显示文本，它们不停地翻滚，永无休止地从彩色框底部弹出：

第四部分 A ctiveX 控件 - 图4

如果想看动画，请使用 Internet Explorer 这样的浏览器，或任何可察知 ActiveX

的创作工具，来打开本书配套光盘 Code\chapter.08 文件夹的 Tumble.htm 文档。在 Internet Explorer 3.0 及以后版本中，单击 Open 命令，并找到该文档，然后双击打开它。列表 8-1 显示了 Tumble.htm 文档的内容。

列表 8-1 Tumble.htm 文档

classid="clsid:99b42120-6ec7-11cf-a6c7-00aa00a47dd2"

id=label

width=150

height=150

Test Containe r实用程序

Visual C++ 提供了一个名为 Test Container 的工具，正如它的名字所暗示的那样，利用它，你不用创建自己的包容器应用程序，便可加载和试验已注册的 ActiveX 控件。单击 Tool s（工具）菜单上的 ActiveX Control Test Containe r（ AvtiveX 控件

测试包容器）命令，来启动 Test Container，如图 8-3 所示，它带有两个典型的AciveX 控件，分别叫做 Button Menu 和 Microsoft Chart ，在配套光盘中均有提供。该程序的可执行文件是 Tstcon32.exe ,在 Common\Tools 子文件夹中。

如果想在 Test Container 中加载控件，请从 Edit（编辑）菜单中选择 Insert New Contro l（插入新控件）命令，或者单击工具栏上的 New Contro l（新建控件）按钮，然后从 Insert Contro l（新建控件）对话中显示的列表中选择所需要的控件，在 Text Containe r（文本包容器）窗口中，一个控件可以首次仅仅作为小框出现；如果是这样的话，请通过拖动一角来调整控件。控件的初始尺寸取决于该控件从包容器中申请的启动尺寸 ( 如果有的话 ) 。下一章中的一个范例项目演示了用 MFC 编写的 ActiveX 控件是如何调用 ColeControl::SetInctialSize 函数来建立它的启动尺寸的。如图 8-3 所演示的帮样，几个控件可以在 Test Container 中同时运行；在每个控件窗口所圈定的矩形框内单击，可以从活动控件中进行选择。当一个控件被选中之后，尺寸控制柄将出现在它的边框之上， Test Container 工具栏上Invoke Methods and Properties （调用方法和属性）工具成为可以启用的。

第四部分 A ctiveX 控件 - 图5

图 8-3 通过 Tools （工具）菜单调用的 Test Container 实用程序

第四部分 A ctiveX 控件 - 图6

被选中的 ActiveX 控件可以通过它的方法函数编程。单击 Invoke Method s（调用方法），或从 Control 菜单中选择相应的命令，来打开如图 8-4 所示的 Invoke M ethods 对话。 M ethod Nam e（方法名）组合框的下拉式列表将所有控件方法归类，大致可分为普通方法和属性方法两类。普通方法在下拉式列表中被标为M ethod 。属性方法被标为 PropGet 或 PropPut ，究竟标记为哪一个，主要取决于它们所对应的是检索属性值的“ 获取 ” 方法，还是写属性值的“ 放置 ” 方法。例如图 8-4 显示了 Button Menu 控件导出了两种方法类型，允许包容器通过获取和放置方法读或写该控件的 Caption 属性 ( 就是出现在按钮上的文字 )。

第四部分 A ctiveX 控件 - 图7

图 8-4 通过 Test Container 的 Invoke Methods（调用方法）对话对控件编程

为了向 Button Menu 控件的弹出式菜单中添加一个项目，包容器调用 AddItem 方法。我们可以使用 Invoke Method s（调用方法）对话框做相同的事情。在 Method Name 框中选择 AddItem ,然后在标签为 Parameter Value（参数值）的编辑框中键入所需求的文字。当你单击 Invoke 按钮的时候， Test Container 将调用 AddItem 方法，将文字添加到控件的菜单命令列表之中。为了看到新命令，可以关闭 Invoke M ethods（调用方法）对话，并单击 Button Menu 控件。

当为一个整数类型的属性选中放置方法的时候，你必须还在 Parameter Type（参数类型）框中做出像 VT_14 这样的选择。通过先调用相应的获取方法，并记下返回值，或者在 Parameter Type（参数类型）框中选择 VT_UNKNOWN ，可以确定正确的参数类型。如果放置方法有多个参数，请依次在 Parameters 列表框中选中每个变量，在键入值后单击 Set Value（设置值）按钮。当所有的值都在 Value 列中正确出现之后，单击 Invoke 来将参数传递给方法。

像 BackColor 这样的颜色属性是 24 位 COLORREF 值，它可以表示为 VT_14 整数类型。 COLORREF 值的三个字节对应于整个颜色的红、绿和蓝组件，请参阅第 5 章中 Color 范例项目。尽管 COLORREF 值作为像 OXFF 这样的十六进制数来表达更为容易， Invoke Method 对话仅仅能识别以十进制格式键入的值。如果想在对话中输入一个新颜色值，可键入 16 ， 711 ， 680 来代表深蓝， 65, 280 代表深绿， 255 代表深红。在 Parameter Type（参数类型）框中选择 VT_COLO R ，将启用标签为 Choose Colo r（选择颜色）的按钮显示范例颜色的种类。不过，该选项目前不能将选择的颜色正确转换成有效的方法参数。

第四部分 A ctiveX 控件 - 图8

许多控件提供它们自己的属性表，Test Contain e（r 测试包容器）可以通过 Properties

工具按钮访问它们。单击工具将导致 Test Container 向控件发布一条OLEIVERB_PROPERTIES 命令，告诉它显示属性表 ( 如果有的话 )。双击控件的边框还可以调用该命令，其功能与从 Text Container 的 Edit （编辑）菜单中选择Properties 一样。

通过可移动的分隔条，可以把 Test Container 窗口分成两个水平的窗格。底部视窗一般显示所选中控件触发事件的实时记录。记录也叫做事件日志，可以重新确定路线，方法是从 Test Container 的 Option s（选项）菜单中选择 Loggin g（记录）命令。在 ActiveX 控件开发期间，利用事件日志，可以节省开发人员的时间，让你快速测试控件事件是否已被正确触发。在下一章，当我们测试范例 ActiveX 控件时，我们还会看到事件日志的功能。

向对话框添加 ActiveX 控件

尽管从 CWnd 中派生出来的任何类都可以嵌入一个 ActiveX 控件， MFC 还需为对话包容器进行优化。这是很好的，因为 ActiveX 控件与普通控件一样，通常也是在对话框中出现的。这种优化是在 Visual C++ 中反映出来的，它提供了许多特征，可以帮助你为第 6 章介绍的基于对话的类 ( 就是 CDialog, CPropertyPage, CFormView, CRecordView 或 CDaoRecordView )使用的 ActiveX 控件创建包容器应用程序。向对话添加已经注册的类仅需单击几下鼠标即可，先是在 Gallery 中，然后是在 Visual C++ 对话编辑器中。

在某些方面，对话编辑器为 ActiveX 控件比 Test Container 实用程序提供了更为方便的测试区。其中之一便是，即使控件没有提供它自己的属性表，对话编辑器也将显示一个 Properties （属性）框。例如，如果你双击了 Test Container 窗口中Button Menu 控件的边框，将会出现一个消息框，说 “ Property Page are not supporte d（属性页未支持）”。但是，如果你在对话编辑器中为相同的命令调用了Properties （属性）命令，那么编辑器将向它的一般的 Properties（属性）框添加一个标签为 A ll（所有）的颜色选项卡，它列出了该控件的属性，并允许你进行编辑。A ll 选项卡比在 Test Container 实用程序中引用方法所包含的过程提供了到控件属性的更为方便的访问。

下面查看对话框中正在工作的 ActiveX 控件的方法：无需任何编程。对话编辑器自己作为控件客户，在这里，我们以 Animate Button ActiveX 控件为例进行演示。

如果你愿意在这些步骤中用完整的项目练习，请打开本书配套光盘上的Code\Chapter.08\AniButtn 文件夹中的 Dewo.dsw 文件。运行 Demo.exe ，并单击Help 菜单上的 About 命令。

步骤 1 ：创建一个空项目

使用 AppWizard 创建一个空项目，为它取一个喜欢的名字，并接受所有的默认设置。在默认状态下， AppWizard 通过在步骤 3 中打开 ActiveX Controls 复选框，来使得每个应用程序都成为 ActiveX 控件包容器：

第四部分 A ctiveX 控件 - 图9

选择 ActiveX Controls 选项，将运行大量的其他代码，来支持控件包容方式，但是，由框架来管理每件东西。在表面上，该选项只是把这行添加到应用程序类InitInstance 函数：

AfxEnableControlContainer();

将这行添加到 StdAfx.h 文件：

#indude<afxdisp.h> //MFC OLE automation classes.

如果你有一个 MFC 项目想转化为控件包容器，请使用文本编辑器来手工实现上述改变。如果想得到相同的结果，还可以将位于 Gallery 的 Visual C++ Components 文件夹的 ActiveX Control Containment 组件添加到项目中。

步骤 2 ：插入 ActiveX 控件

当 AppWizard 完成创建项目之后，请从 Proje c （t 项目）菜单中选择 Add To Project

（添加到项目）命令，然后单击次级菜单上的 Components And Controls 命令来显示 Gallery 对话。在 Registry ActiveX Controls 文件夹中选择 Anibutton Control 图标，并单击 Insert 按钮。接受 Confirm Classes（确认类）对话中的默认设置，然后退出 Gallery 。

因为你还可以从对话编辑器中向项目添加 ActiveX 控件，所以，进入 Gallery 不

是必需的。当对话编辑器的工作区域出现 ( 在下一步中介绍 ) 的时候，请右击工作区中的任何地方，并从上下文菜单中选择 Insert ActiveX Contro l。该操作将打开与 Gallery 对话中显示的相同的注册控件列表。只需单击列表中的一个控件，便可以将它添加到对话中去。

步骤 3 ：向对话添加控件并初始化

从技术上讲，对话包容器不是 ActiveX 控件的父窗口，而仅仅提供一个站点（ C O M 这样称呼它），这个词不应该从字面上来理解。站点的作用是嵌入式对象及其包容器之间的中间人，在这种情况下，是处理 ActiveX 控件和对话窗口之间的通信。任何对话都可以为实现演示的目的而做到过一点，甚至是项目的 About （关于）框也是如此。我们甚至不需要为使用新控件而创建项目。我们所需要的只是一个站点，以及对话编辑器中模拟的 Abou t（关于）框。

双击 Workspac e（工作空间）窗口 ResourceView 窗格中的 IDD_ABOUTBOX ，来启动对话编辑器，并加载 Abou t（关于）框。当编辑器的窗口出现的时候，它的控件窗口就具有了一个新按钮，用来代表插入的 Anibutton 控件。

第四部分 A ctiveX 控件 - 图10

这个工具并不是在工具栏上永久存在，它是仅仅为这个项目而使用的。如果想向另一个项目添加 Anibutton 组件，你必须再返回步骤 2 去插入一个控件。至于使控件进入对话工作区，没有特殊的处理要求。只需像你对任何控件工具操作的那样，把它拖入对话框，然后右击对话中选中的控件，并且单击上下文菜单上的

Properties ，来调用该控件的 Properti e（s 属性）对话。图 8-5 显示了 Anibutton Control

Properties 对话的 Control 选项卡，这就是我们将开始初始化控件的地方。

第四部分 A ctiveX 控件 - 图11

图 8-5 Anibuton Control Properties 对话的 Control 选项卡

注意：如果注册表中的某个条目丢失了，Visual C++ 将显示一条消息，说 Animated Button 控件需要一个设计时间许可证。如果你按照这里列出的步骤操作时出现了这条消息，这就表明，你要么装了只具有 USER 权限的 Visual C++，或者是注

册表已经崩溃了。重新安装 Visual C++ 好象是唯一的解决方案。如果想了解这个问题，以及其他 ActiveX 控件的列表，请访问这个 Knowedge Base 站点：

http://support.microsoft.com/support/kb/articles/Q155/0/59.asp

如下的列表将引导你完成演示程序所需要的初始化设置。这些设置是在

Properties （属性）对话的五个选项卡中完成的。

Contro l（控件）选项卡 ：在 Control 选项卡中单击组

合框，并选中如图 8-5 所示的条目。
General 2 （常规 2 ）选项卡 ：如果想指定在控件窗

口中显示的数字，请在 Captain （标题）框中键入 Click Here! 。将复选框设置为H ideFocusBox ，这可以防止在控件具有焦点的时候点线矩形出现在标

题文字的周围。

Frame Settin g（帧设置）选项卡 ： Anibuton 控件可以保
持大量充当按钮图像的位图。对于我们的演示，任何位图均可行，其中也包括W indows 文件夹中的系统墙纸图像文件。单击 Load 按钮，并找到

W indows 文件夹来显示 B M P 文件列表，这些文件具有像 Black Thatch, BlueRivets, Sandstone 以及 Triangles 这样的名字。从列表中选中一个文件，并单击 Insert 按钮。再次单击 Load 按钮，并重复上述过程，直至已经向控件添加了五六个不同的位图。完成之后，你可以通过移动滚

动条来检查每个位图条目。

Fonts （字体）选项卡 ：这是你为按钮上出现的标

题选中字体的地方。图 8-6 中的字体是 Times New Roman, 斜体，磅值为 32 。
Colors （颜色）选项卡 ：因为位图图像是填充控件

窗口的，所以，背景颜色无关紧要。通过从 Property Name 文本框中选定 ForeColor，并单击白色块来设置标题文字的前景颜色。

在本章前面的章节中，已经提到了，并不是所有的 ActiveX 控件都提供自己的属性表，但 Anibuton 控件就是这样。上面列出的属性页是在 AniBtn32.ocx 可执行文件中包含的资源，对话编辑器选取并添加自己的 General 和 All 选项卡，以形成如图 8-5 所示的完整的 Propertie s（属性）对话。这就意味着，你无需与两个对话进行交互，这两个对话一个由控件提供，而另一个由对话编辑器提供。

步骤 4 ：测试控件

通过拖动尺寸控制柄在对话工作区内扩大控件，然后，在对话框的中心重新定位控件窗口。打开 D ialog （对话）工具栏上的编辑器测试模式开关：

第四部分 A ctiveX 控件 - 图12

在新 ActiveX 控件窗口内部单击几次，循环显示位图图像，其中一个如图 8-6 所示。单击对话的 O K 按钮来返回到编辑模式。

第四部分 A ctiveX 控件 - 图13

图 8-6 典型对话中的 Anibutton ActiveX 控件

既然我们对 ActiveX 控件可以实现的许多形式已经有了一定的了解，那么，让我

们来分析其中的一个，看看它是如何工作的。

在包容器和 ActiveX 控件之间进行通信

ActiveX 控件服务器可以非常有效地与一个客户进程关联起来。一个 ActiveX 控件通常在作为动态链接库工作，这就意味着该控件在客户进程的地址空间执行，但这并非一定如此。由于这个原因， ActiveX 控件通常称为进行中的服务器。包容器程序在加载普通 DLL 的时候，并不是通过调用 LoadLibrary API 函数来加载这个 ActiveX 控件。相反，它调用 CoCreateInstance 来申请 Component Object Model 框架的运行时间服务来加载库，并在客户和控件服务器之间建立初始通信点。这个通信点叫做接口。包容器所调用的一个接口，一般在图中用一个小圈来表示，如图 8-7 所示。在服务器中，实现对正确函数的调用。请注意该图，一旦初始接口就位之后，所有对象就将开始彼此之间的对话，图中没有包括 COM 。

第四部分 A ctiveX 控件 - 图14

图 8-7 将 Activex 控件连向包容器

每个接口都是一个指向 Activex 控件导出的函数的指针数组。这个数组一般叫做

V 表，因为它十分像指向虚拟函数的指针的 C++ 表。因为仅有接口的单一间接步

骤处于客户和运行的服务器之间，所以，调用 ActiveX 控件实际上和调用一个普通的动态链接库一样迅速。

并不是所有的 C O M 服务器都处于运行状态，服务器 EXE 应用程序在它自己的地址空间中运行，或者是与客户相同的机器，或者是通过网络附加到另一台机器上。在这种情况下，客户和服务器都是通过处理边界进行分隔的，并不能直接进行通信。对于进程之外的服务器， C O M 为了处理通信而加载两个动态链接库。第一个库叫做代理，被映射到服务器空间。当客户调用代理的接口的时候，代理将函数参数打包，通过远程过程调用 (RPC )将它们发送到 Stub 。 Stub 将包中的信息转换回参数列表，并调用服务器中的目标函数。从服务器回到客户的通信的是同一个路径。通过代理和存根库连接客户和服务器的过程叫做编组。正如你所希望的那样，编组比客户和 ActiveX 控件之间更加直接的交互更慢，因为运行的服务器并不依赖远程过程调用来与客户进行通信，除非通信是线程之间的，否则也不需要编组。第 10 章将详细讨论线程内的编组。

通信在 ActiveX 控件和它的包容器间的两个方向运行，因此，包容器应用程序必须提供它自己的一套接口，才能从控件处接收呼叫。 M icrosoft 发布了指定包容器应该支持的最小接口集的指导方针。该指导方针在在线帮助中有说明，可以通过 MSDN Library 窗口的 Index 选项卡进行访问。从 Visual C++ 的 Help 菜单选择Index 命令，然后键入 required interface 来定位该标题的文章。

通过支持这些接口，包容器应用程序可以确保与遵守该指导方针的任何 ActiveX

控件融在一起。表 8-2 介绍了包容器为了遵守 OLE/ActiveX 技术规范而应该支持的八个接口。

表 8-2 中的头三个接口提供复合文档包容器，而不是控件包容器。用 MFC 编写包容器程序，可以使你不必担心接口支持的详细情况。正如本章以前曾经介绍的，在 AppWizard 中，为一个包容器项目选择 ActiveX 控件支持，将向源代码添加一个对框架的 AfxEnableControlContainer 函数的调用。该函数用于建立表 8-2 中列出的所有接口。一旦这些接口就位之后， ActiveX 控件和它的包容器之间的通信就可以通过事件、方法和属性来发生了。

事件

尽管 ActiveX 控件是完备的，它仍然可以通过触发事件使包容器应用程序了解到控件内部的行为。对于某个控件触发的事件，控件开发者便认为包容器应用程序想知道有关控件的事情。例如，控件可以为了响应控件窗口内的鼠标单击，或者在控件有焦点的时候，向包容器传递任何收集到的键盘输入来触发一个事件。一个触发事件可能发送信号，来表明类似于定位 URL 、下载数据或分类列表这样的任务已经完成。我们可以把事件触发和普通控件向它的父窗口发送诸如CBN_DROPDROWN 或 BN_DOUBLECLICKED 之类的通知消息做一个类比，我们可以看到，除了 ActiveX 控件是通过调用包容器中的一个函数，而不是通过发送消息来触发事件的之外，两者是很相似的。

表 8-2 包容器应该支持的遵守 OLE/ActiveX 技术规范的接口接口说明

IOle ClientSite 嵌入式对象用来查询包容器有关客户站点的大小以及用户接口的特性。IOleClientSite 接口还提供了诸如 RequestNewObject Layout 函数之类的服务，控件可以通过这个函数来为它的站点申请新的大小

IAdviseSink 由对象使用，用来将对象数据中的改变通知给包容器

IOleInPlaceSite 用于管理包容器和对象站点之间的交互

IOleControlSite 为嵌入式 ActiveX 控件提供各种服务。例如， Translate Accelerator 函数用来请求包容器处理指定的键击， OnFocus 函数用来告诉控件它是否具有输入焦点

IOleInPlaceFram e

续表

ActiveX 控件用来统治像组成菜单这样的资源的显示

IOleContainer 允许控件强制它的包容器保持在运行状态，或访问其他嵌入在同一文档或窗口中的其他控件

IErrorInfo 支持双重接口包容器所需要的 ( 请参阅第 10 章 )

IDispatch 控件用来访问包容器的外部层性，并调用该包容器的事件处理程序函数。该包容器为属性和事件实观独立的 Idispatch 接口

接收触发事件的包容器中的函数是回调类型的函数。如果包容器应用程序想被通知一个特殊的控件事件，它必须提供一个函数 ( 也就是众所周知的事件处理函数或事件实现函数 ) 来接收调用。包容器在一个 IDispatch V 表 ( 也就是事件接收端 ) 中存储到它的事件处理程序的指针列表。这个事件接收端将每个事件与它自己的处理程序函数连接起来。这个包容器应用程序不必要为该控件触发的每个事件提供处理程序函数，也不是每个 ActiveX 控件都触发事件。

OLE/ActiveX 标准预定义了大量的库存事件，它们将控件窗口中所发生的事情通

知给包容器。例如，当鼠标在控件窗口内部单击的时候，为了将这个库存事件通知给包容器，一个使用 MFC 的控件可以通过 EVENT_STOCK_CLICK 宏建立Click 事件：

BEGIN_EVENT_MAP(CDemoCtrl, COleControl)

//{{AFX_EVENT_MAP(CDemoCtrl) EVENT_STOCK_CLICK()

//}}AFX_EVENT_MAP

END_EVENT_MAP()

因为由框架来负责感知鼠标移动和触发事件，所以，该控件不需要其他代码。如果包容器想知道鼠标单击在控件窗口中是何时发生的，它可以为 click 事件提供一个处理程序函数，可以在匹配事件接收端映射中引用它。

BEGIN_EVENTSINK_MAP(CDemoContainer,Cdialog)

//{{AFX_EVENTSINK_MAP(CDemoContainer) ON_EVENT(CDemoContainer, IDC_CTRL,DISPID_CLICK,

OnClick,VTS_NONE)

//}}AFX_EVENTSINK_MAP END_EVENTSINK_MAP()

在上面的代码段中， ON_EVENT 宏的参数可能需要解释一下。 CDemoContainer 是该包容器的类，它是从 CDialog 中派生的。常数 IDC_CTRL 用来标识类对话窗口中的控件。DISPID_CLICK 是 Click 事件的调度标识符 ( 简写为 dispid)。用于库存事件的调度标识符在 O leCtl.h 文件中定义，每个标识符都具有一个 DISPID_ 前缀。所有的非库存事件都叫自定义事件， OLE 可以为它分配一个正的调度标识符，而为库存事件保留负的标识符。该宏的第四个参数指向用于处理事件的包容器成员函数。本例中，该成员函数的名字是 OnClick 。VTS_NONE 参数用于指定 Click 事件没有参数。

表 8-3 列出了由 OLE/ActiveX 技术规范定义的库存事件的函数原型。除了 Error 之外，所有库存事件者仅仅在 ActiveX 控件具有输入焦点时发生。事件原型好像可以暗示单一函数的存在，事实上，通常至少包括三个函数，如图 8-8 所示。在较低层次上，一个控件通过调用包容器的 IDispatch:Invoke 方法，并传递给它适于该事件的参数来触发一个事件。但是，在更高的层次上，存在着两个其他的函数，一个位于 ActiveX 控件中用包装对 IDispatch::Invoke 的调用，另一个位于包容器中用于处理调用。两个函数共享同一个参数表，而在效果上是单一的函数，隐藏了发生在它们之间的低级的 IDispatch 行为。函数名是任意的。 MFC 通过向

事件名前添加前缀 Fire ，来形成触发函数的名字，例如 FireClick 函数触发的是

Click 事件。

第四部分 A ctiveX 控件 - 图15

图 8-8 触发一个典型的事件

表 8-3 由 OLE/ActiveX 定义的库存事件事件原型当时触发事件

void FireClick() 在控件窗口中单击了任何鼠标按钮 ( 左，中或右 )， MouseDown 和MouseUp 库存事件在 Click 之前触发

void FireDblClick() 在控件窗口中双击了任何鼠标按钮

void FireError(SCODE scode, LPCSTR lpszDescription, UNIT nHelpID=0)

控件检测到错误

void FireKeyDown(short* pnChar, short nShiftState)

控件接收到

WM_SYSKEYDOWN 或

W M _ K E Y D O W N 消息

void FireKeyPress(short* pnChar) 控件接收到 W M _ C H A R 消息

void FireKeyUp(short* pcChar, Short nShiftState )

void FireMouseDown(short nButton,

short nShiftState, float x, float y)

void FireMouseMove(short nButton,

续表

控件接收到 WM_SYSKEYUP 或

MW_KEYUP 消息

按下任何鼠标按钮 ( 左、中或右 ) ，生成一条WM_xBUTTONDOWN 消息

控件接收到 W M _ M O U S E M O V E

消息

short nShiftState, float x, float

void FireMouseUp(short nButton,

short nShiftState, float x, float

任何鼠标按钮被释放，生成一个

WM_xBUTTONUP 消息

方法

方法与事件处理函数刚好相反。事件处理函数位于包容器之中，并由控件调用，方法则位于控件之中，由包容器调用。包容器可以调用方法来了解条件，或申请控件完成一些操作。

OLE/ActiveX 预定义了三个库存方法，分别叫做 DoClick ， Refresh 和 ActiveX ，它们中没有一个具有参数或返回值。Doclick 导致控件触发它的 Click 库存事件 ( 如果支持它的话 )， Refresh 方法告诉控件使它的窗口失效，并自己重绘， AboutBox 告诉该控件去显示一个信息丰富的对话框。 ActiveX 控件导入的任何其他方法都叫做自定义方法，它们是由控件的作者设计的。对于包容器而言，方法是作为由动态链接库导出的普通函数出现的，带有一个可选的参数表，最多可带有 15 个参数，并返回任何类型的值。

属性

属性是包含在包容器和控件内部并可以互相展示的公共数据。OLE/ActiveX 定义了四类属性，分别叫做库存的、自定义的、环境的和扩展的。库存和自定义属性属于控件，环境和扩展属性属于包容器。

库存和自定义属性

库存属性用于指定由 ActiveX 标准定义的典型控件特性，例如控件的前景和背景颜色，在窗口中显示的文字，以及用于文字的字体。自定义属性是控件设计者想展现给包容器的所有其他数据。包容器通过调用 MFC 中作为 Get 和 Set 方法的函数来读写控件的属性，这些方法是由该控件导出的。在使用 Test Container 的Invoke Methods 对话的时候，我们曾经遇到过相同的 get/put 属性方法。不同之处是名称方面的差异， WFC 以前缀 Get 和 Set 作为方法名的开头，而 COM 术语使用 get 和 put( 小写形式 )。一般说来，每个属性都有一个对应的 Get/Set 方法对，但控件可以不为它导出 Set 方法，来阻止包容器改变控件属性。第 6 章将演示这是如何实现的。

表 8-4 显示了控件中的库存属性和包容器为读取该属性而调用的函数之间的链接。对于在表中第三列列出的每个获取方法，都存在一个具有与其相匹配的名字对应的 Set 方法。 Set 方法没有返回值，只有一个类型与 Get 方法的返回值相同的参数。 GetAppearance 和 SetAppearance 的原型说明了 Get/set 函数的样式：

short GetAppearance( ) //Returns a property of type short void SetAppearance( short n ) //Passes a property of type short

表 8-4 由 OLE/ActiveX 定义的库存控件属性

属性控件中调度映射项由包容器调用的 Get

函数

Appearance DISP_STOCKPROP_APPEAR

ANCE

short GetAppearance()

BackColor DISP_STOCKPROP_BACKCO

LOR

OLE_COLOR

GetBackColor()

BorderStyle DISP_STOCKPROP_BORDER

STYLE

short GetBorderStyle()

Caption DISP_STOCKPROP_CAPTION BSTR GetText()

Enabled DISP_STOCKPROP_ENABLE

BOOL GetEnabled()

Font DISP_STOCKPROP_FONT LPFONTDISP

GetFont()

续表

ForeColor DISP_STOCKPROP_FORECO

LOR

OLE_COLOR

GetForeColor()

hWnd DISP_STOCKPROP_HWND OLE_HANDLE

GetHwnd()

Text DISP_STOCKPROP_TEXT BSTR GetText()

ReadyState DISP_STOCKPROP_READYS

TATE

long GetReadyState()

环境和扩展属性

环境和扩展属性属于客户站点，不能被控件改变。扩展属性是与嵌入的控件相关的数据，但由包容器进行实现和管理。环境属性用于描述包容器本身。例如，它的当前背景颜色或字体。通过阅读它的包容器的环境属性，控件可以对它的外观和行为进行剪裁，以与包容器相匹配。控件通过调用带有用于所要求属性的调度标识符的 COleControl:GetAmbientProperty 函数来查询环境属性：

LPFONTDISP fontdisp;

GetAmbientProperty(DISPID_AMBIENT_FONT,VT_FONT,&fontdisp);

对于由 OLE/ActiveX 技术规范预定义的标准环境属性，一个控件可以更加方便地调用由 COleControl 提供的相关帮助器函数，例如 AmbientFont:

LPFONTDISP fontdisp=AmbientFont();

表 8-5 列出了包容器所支持的标准环境属性。 ActiveX 控件通过调用使用表的第二列中列出的调度标识符之一的 GetAmbientProperty ，或者通过调用第三列中等价的帮助器函数，来确定环境属性的值。如果你使用 AppWizard 来创建包容器应用程序，那么，对标准环境属性的支持就已经在内部创建了，而不需进行特殊的操作。调用 SetFont 或 SetTextColor 在包容器中设置字体或前景颜色，将自动在对话中为站点设置环境属性。当 ActiveX 控件调用 AmbientFont 或AmbientForeColor 函数的时候，它接收到用于当前对话的环境数据。

编写包容器应用程序

包容器开发者是如何事先知道一个 ActiveX 控件所提供的事件、方法和属性，以及你的包容器应用程序应包含哪些处理程序函数呢？ Gallery 和 ClassWizard 可以为你完成这项工作。在你的包容器程序中，使用现有的控件取决于单个的许可证协议 ( 这是下一章将要涉及的主题 )，但是，你可以从 Gallery 中选择一个 ActiveX

控件，并将它作为任何其他组件添加到你的项目中。Visual C++ 自动扫描注册表，来定位在系统上注册的所有控件，因此，向 Gallery 添加 ActiveX 控件仅仅是注册它的事情。

表 8-5 标准的包容器环境属性

属性调度标识符控件调用的函数

BackColor DISPID_AMBIENT_BACKC

OLOR

OLE_COLOR

AmbientBackColor()

D isplayName DISPID_AMBIENT_DISPLA

Y N A M E

CString AmbientDisplayName()

Font DISPID_AMBIENT_FONT LPFONTDISP

AmbientFont()

ForeColor DISPID_AMBIENT_FORECO

LOR

OLE_COLOR

AmbientForeColor()

LocaleID DISPID_AMBIENT_LOCALE

LCID AmbientLocaleID()

ScaleUnits DISPID_AMBIENT_SCALEU

NITS

CString AmbientScaleUnits()

续表

ShowGrabHa ndles

DISPID_AMBIENT_SHOWG RABHAN-DLES

BOOL

AmbientShowGrabHandl es()

ShowHatchin g

DISPID_AMBIENT_SHOWH ATCHING

BOOL

AmbientShowHatching()

TextAlign DISPID_AMBIENT_TEXTAL

IGN

short AmbientTextAlign()

UIDead DISPID_AMBIENT_UIDEAD BOOL AmbientUIDead()

UserMode DISPID_AMBIENT_USERM

ODE

BOOL

AmbientUserMode()

当 Gallery 在你的包容器项目中放置 ActiveX 控件的时候，它将检查该控件的可执行图像中包含的类型库，以获得由该控件所导出的事件、方法和属类的一个列表。从这个信息中， Gallery 可以创建一个完整的包装类，该类中包含有 Get/Set 属性函数和方法调用，包容器可以通过它们获得到控件数据的访问。如果想在控件中获得或设置属性 ( 例如背景颜色 )，包容器将调用包装类中的一个函数：

OLE_COLOR CDemoCtrl::GetBackColor()

{

OLE_COLOR result; GetProperty(DISPID_BACKCOLOR,VT_I4, (void*)&result); return result;

}

void CDemoCtrl::SetBackColor(OLE_COLOR propVal)

{

SetProperty(DISPID_BACKCOLOR,VT_I4,propVal);

}

既然事件处理程序属于包容器的类，通常由 CDialog 这样的类中派生出来，那么，

Gallery 就不为事件处理程序函数添加源代码。在控件被添加到对话之中，这项

工作留给 ClassWizard 完成。

最后，举例来说明这个过程。本节创建了一个叫做 Hour 的简单包容器应用程序，它使用本书配套光盘中包括的一个 ActiveX 控件。该控件与以前在 Tumber.htm 文档中使用的是同一个 IETimer.ocx 定时器控件。在 Gallery 的 Registered ActiveX Control 文件夹中名称 Timer Object 下列出的控件之中，你可以找到这个 IETimer 控件。这个文件夹中的控件列表可能还包括另一个定时器 ActiveX 控件，它是由名为 Time Control 的样本项目中创建的 (Time Control 的源文件位于文件夹MSDN\Samples\VC98\MFC\Controls\Time 之中 ) 。两个定时器控件导出相同的方法，并实现相同的功能，因此， Hour 项目使用哪一个都无所谓。

与 Anibutton 和 Calendar 这样的 ActiveX 控件不同的是，Timer Object 不是一个可见的控件。在包容器内，它不作为窗口显示，而只是以指定的周期触发一次事件，为包含程序起到定时器的作用。Hour 程序使用定时器事件来管理如图 8-9 所示的三个进程指示器。这个进程控件以分秒和十分之一秒的形式来显示剩余时间。Hour 程序的名称来源于这种事实：当 M inutes 进程控件满 60 分钟之后，三个控件便会复位。

第四部分 A ctiveX 控件 - 图16

图 8-9 Hour 程序

从开始到结束创建 Hour 项目只需五步。

步骤 1 ：用 AppWizard 创建 Hour 项目

从环境的 File 菜单选择 New ，在 Projects 选项卡中选中 MFC AppWizard(exe) 图标，键入 Hour 作为项目名。Hour 是基于对话的应用程序，因此，单击 AppWizard 步骤 1 中的 D ialog Based （基于的对话）单选按钮，并确保步骤 2 中的 ActiveX Controls 复选框已经打开：

第四部分 A ctiveX 控件 - 图17

单击 Finish 按钮创建该项目。

步骤 2 ：将 Time r Objec t控件插入项目

现在，你应该很熟悉这一步骤了。使用 Project 菜单上的 Add To Project 命令来打

开 Gallery 。并显示如图 8-1 所示的 ActiveX 控件列表。水平滚动并选择 Timer Object 或 Timer Control 图标，然后单击 Insert 按钮。该操作将把 CIeTimer 或CTimerCtrl 类的源代码添加到 Hour 项目，究竟是哪一个类取决于所选定的控件。当 Confirm Classes 对话出现的时候单击 OK ，然后关闭 Gallery 对话。

如果 Timer Object 没有在对话显示中列出，那么，该控件就还没有注册。如果想注册 Timer Object 控件，请将 IETimer.ocx 文件从配套光盘中复制到W indows\OCCache 文件夹，并运行 RegSvr32 实用程序。当控件成功注册了自己之后，当你下次打开对话时，它将在 Gallery 列表中出现。

步骤 3 ：在 Hour 对话中放置 Time r Ob jec t控件

第四部分 A ctiveX 控件 - 图18

在 Visual C++ 的早期版本中，你必须双击 ResourceView 窗格中的IDD_HOUR_DIALOG 标识符，来启动对话编辑器，并加载主对话。通过选中对话工作区中的 “ to do ” 静态文字控件和 Cancel 按钮，并按 Del 键来删除它们。将 Progress, Static Text 和 Timer Object 工具从 Controls 工具栏拖到工作区之上，

并对其进行排列，使它看上去与下图类似：

第四部分 A ctiveX 控件 - 图19

由于 Timer Object ActiveX 控件在程序运行的时候没有创建自己的窗口，所以，你把它放在对话中的什么地方都可以。展现每个控件的 Properties 框，并键入屏幕图像上显示的标题，以及在表 8-6 中第二列列出的标识符。

表 8-6 Hour 程序中的控件标识符

控件	标识符	变量名
分钟进度指示器	IDC_PROGRESS_MIN	progMin
秒钟进度指示器	IDC_PROGRESS_SEC	progSec
十分之一秒进度指示器	IDC_PROGRESS_MIN	progTen
顶端 “ x ” 静态控件	IDC_MINUTES	strMin
中间 “ x ” 静态控件	IDC_SECONDS	strSec
底部 “ x ” 静态控件	IDC_TENTHS	strTen
时间控件	IDC_TIMER1	time

应用程序类 CHourDlg 需要代表每个对话控件的成员变量，你可以通过ClassWizard 来添加它。在对话编辑器仍处于活动状态的时候，单击 View 菜单上的 ClassWizard 命令来调用第 6 章中介绍的 MFC ClassWizard 。在 Member Variables

（成员变量）选项卡中，选中 Control IDs 框中的每个新类，并单击 Add Variable

（添加变量）按钮，来显示 Add Member Variable （添加成员变量）对话。在标

签为 M ember Variable Name（成员变量名）的文本框中，键入表 8-6 中第三列列出的控件变量。图 8-10 显示了最后的结果。

我们还需要一个函数来处理由 Timer Object 控件触发的事件。在 ClassWizard 的M essage Map s（消息映射）选项卡中，选中 IDC_TIMER1 ，并从 M essages 框中选中 Timer，然后单击从 Object IDs 框中的 Add Function （添加函数）按钮。ClassWizard 添为名为 OnTimerTimer1 的事件处理程序函数添加存根代码。

第四部分 A ctiveX 控件 - 图20

“ E ” 前缀用来将 OnTimeTimer1 指定为一个事件处理程序函数。单击 O K 来关闭 ClassWizard 对话。

第四部分 A ctiveX 控件 - 图21

图 8-10 向 CHourDlg 类添加成员函数

步骤 4 ：向 Hou r.cpp 和 Hou r.h 文件添加代码

如果想查看一下 ClassWizard 已经添加到 HourDlg.h 头文件的变量和函数声明，请单击位于 WizardBar 最右端的箭头按钮：

第四部分 A ctiveX 控件 - 图22

并从下拉式菜单中选择 Go To Class Definition （转向类定义）。 Visual C++ 将在文本编辑器中自动打开 HourDlg.h ，并将插字符定位在 CHourDlg 声明的开始处，在这里添加新控件变量。

// Dialog Data

//{{AFX_DATA(CHourDlg)

enum { IDD = IDD_HOUR_DIALOG };

CProgressCtrl progTen;

CProgressCtrl progSec;

CProgressCtrl progMin;

CString strMin;

CString strSec;

CString strTen;

CIeTimer time;

//}}AFX_DATA

ClassWizard 还可以为 OnTimerTimer1 事件处理程序函数添加原型：

afx_msg void OnTimerTimer1(); DECLARE_EVENTSINK_MAP()

CHourDlg 类声明仅需两行：

class CHourDlg : public CDialog

{

像以前一样，阴影部分表示你必须在文本编辑器中键入的附加代码。

变量 iM in 和 iSec 用于保持已经过去的分和秒的计数情况，它们被写到对话框中与进程指示器相邻的静态控件之中。对于消逝的十分之一秒，不需要类似的计数器，因为 IDC_PROGRESS_TEN 进程指示器的位置在由 Timer Object 控件触发的每个事件之前。过一会，当我们向事件处理程序添加代码的时候，这一切就会变得很清楚。

对源代码的最后修改是在 CHourDlg::OnInitDialog 函数中进行的。在 W izardBar 的 M embers 框内任何地方单击，来显示成员函数的下拉列表，并从如图所示列表中选择 OnInitDialog。

第四部分 A ctiveX 控件 - 图23

Visual C++ 在文本编辑器中打开 HourDlg.cpp 源文件，并且自动将插字符放在

OnInitDialog 定义的开始处。在该函数的 “ to do ” 行添加阴影文字，如下所示：

// TODO: Add extra initialization here

这些指令用于初始化进程指示器控件。指令：

time.SetInterval(100)； //Set timer interval to 1/10 second

调用 Time Object 中的一个方法，告诉控件开始每隔 100 毫秒触发一次事件。使用 W izardBar 向下到 CHourDlg::OnTimerTimer1 函数，并添加如下阴影行：

void CHourDlg::OnTimerTimer1()

{

// TODO: Add your control notification handler code here

progMin.SetPos( 0 );

}

else

progMin.StepIt ();

iSec = 0;

progSec.SetPos( 0 );

strMin.Format( "%d", iMin );

SetDlgItemText( IDC_MINUTES, strMin );

}

else

progSec.StepIt ();

i = 0;

progTen.SetPos( 0 );

strSec.Format( "%d", iSec );

SetDlgItemText( IDC_SECONDS, strSec );

}

strTen.Format( "%d", i );

SetDlgItemText( IDC_TENTHS, strTen );

}

每隔十分之一秒， OnTimerTimer1 实现函数接收到该控件的触发事件，并将IDC_PROGRESS_TEN 进程指示器提前一步。当 Tenths 进程指示器达到最大值之后，该指示器被复位到零， Seconds 指示器加 1 。按照同样的方式，在 60 秒过去之后， Seconds 指示器被复位到零， M inutes 指示器加 1 。当一个小时过去之后，

整个过程再重新开始。

步骤 5 ：创建和测试项目

在 Build 工具栏上选中 W in32 Release 配置，然后创建 Hour.exe 程序的发行版本。单击 Build 菜单上的 Execute 命令来运行完成后的程序。请注意， Hour 运行得有点儿慢，它是依靠系统定时器资源的一个典型的 W in32 程序。尽管你可以把它作为一个煮蛋定时器使用，但 Timer Object 控件并不适合于需要精确定时的应用程序。

下一章将介绍名为 Game 的另一个包容器项目，它与 Hour 十分相似。不同之处是 Game 使用你自己编写的而不是由 M icrosoft 提供的自定义 ActiveX 控件。

在没有对话编辑器的情况下工作

利用 Visual C++ 对话编辑器，就可以很容易地向对话框添加控件。但是，当想在窗口而不是对话中放置一个控件时，可能就要花些时间了。不存在任何技术上的障碍 ( 只是因为常规控件可以在框架化的窗口中出现，因此 ActiveX 控件也能 )，但你必须走在对话编辑器服务的前面。本节将解释如何向非对话窗口添加ActiveX 控件，通过将 Button Menu 控件放入应用程序的客户区来演示这点。

这里所介绍的 Button 项目仅需要键入一些东西即可；否则，你可以在配套光盘上找到所有的源文件。请注意，该项目没有使用对话编辑器，因此，在开发期间从来都不用例子来说明 Button Menu 控件。本节中介绍的技术可以克服一些控件在设计阶段所存在的创建错误。任何 ActiveX 控件都可以按照这些步骤放在窗口之中，应用程序将正确地进行编译。但是，这里可以进行真正的许可保护，因为未经许可的应用程序不能在运行时实例化一个受保护的控件。下一章当我们讨论有关许可的问题时，就会清楚这一点了。

步骤 1 ：创建 Button 项目

运行 AppWizard 开始项目，在 AppWizard 的第一屏中选中 Single Documen t（单文档）选项。在 AppWizard 完成之后，打开 Gallery 中的 Registered ActiveX Controls 文件夹，并双击标签为 BtnMenu Object 的图标。接受提出的新控件类名 Cpmenu ，然后关闭 Gallery 。

步骤 2 ：向 CButtonView 类添加控件

我们的目的是在应用程序的主窗口视图内放置 Button Menu 控件，因此，开始在Button View 源文件中进行编码。首先，向位于 ButtonView.h 头文件的 CButtonView 类声明中添加 Cpmenu 对象：

class CButtonView : public CView

{

}

下一步是编写初始化 btnmenu 对象的代码。这项工作最好在CButtonView::OnInitialUpdate 函数中完成，以确保该应用程序仅仅在视图刚出现的时候创建控件。 ClassWiard 可以生成该函数的初始代码；只需在 ClassWizard

的 M essage Maps 选项卡中的 Class Name 框中选中 CButtonView ，然后双击M essages 框中的 OnInitialUpdate 即可。通过 Edit Code 按钮退出 ClassWizard ，该操作将在文本编辑器中自动打开 ButtonView.cpp 源文档，并将插字符定位在新OnInitialUpdate 函数。向该函数添加如下所示的初始化代码：

void CButtonView::OnInitialUpdate()

{

CView::OnInitialUpdate();

// TODO: Add your specialized code here and/or call the base class

	v = 2L; btnmenu.AddItem( "Menu item #2", v	);
	v = 3L;
	btnmenu.AddItem( "Menu item #3", v v = 4L;	);
}	btnmenu.AddItem( "Menu item #4", v	);

v = 3L;

btnmenu.AddItem( "Menu item #3", v

v = 4L;

);

}

btnmenu.AddItem( "Menu item #4", v

);

Cpmenu 是从 Cwnd 派生出来的，它提供了 Create 函数的两个版本，这两个版本在 Pmenu.h 文件中都有原型。出于简化的考虑，这里所列出的代码段使用了 CRect 对象将该控件在主窗口中的尺寸和位置固定下来。 Cpmenu::AddItem 函数用于向该按钮的弹出式菜单添加命令字符串，根据函数的第二个参数所给定的VARIANT 值，来组织菜单中的命令。本例中的 OnInitialUpdate 函数，只是为了保持 VARINT 值而创建一个 ColeVariant 对象，以及为了插入一个有代表性的菜单命令列表而四次调用 AddItem s。

如果你这时编译并运行 Button 应用程序，那么，它将在主窗口中正确地显示

Button Menu 控件。尽管单击该控件可以调用它的弹出式菜单，但是，当选中并单击菜单中的命令的时候，应用程序本身并不能做出响应。这是因为我们还没有添加函数来处理 Button Menu 控件在用户交互期间触发的事件。那是下一步的工作。

步骤 3 ：处理事件

我们现在仍然不知道 Button Menu 控件触发的是什么事件。该信息被作为类型库资源的一部分存储在控件的 OCX 文件之中。但是， ClassWizard 却不能读取这个数据，原因是它对控件或 Cpmenu 类一无所知。Visual C++ 提供了一个实用程序，你可以应用它来探究一个控件的类型库，来了解该控件可以触发的事件，以及处理程序函数所需要的参数列表。该程序的名字叫 OleView.exe，是通过单击 Tools 菜单上的 OLE/COM Object Viewer 调用的。利用 Object Viewer 的 File 菜单上的View TypeLib 命令，你可以打开 BtnMenu.ocx 文件，并显示它的类型库。它表明Button Menu 仅能触发两个事件，分别叫做 Click 和 Select。库脚本显示了包容器应用程序如何必须声明处理程序函数，以便正确地接收事件触发：

第四部分 A ctiveX 控件 - 图24

这是我们为事件编写处理程序函数所需要的所有信息。但是对于提供了许多不同事件的控件来说，浏览类型库还有更容易的方法，即将该控件的存在简单地通知给 ClassWizard 。然后， ClassWizard 可以承担从控件读取类型信息的所有工作，为存根处理程序函数生成代码，并向事件接收端映射添加它们的条目。所需要的仅仅是项目类数据库的一点消息，以及向 CButtonView 类声明添加一点儿东西。步骤如下：

首先，在文本编辑器中打开 Button.clw 文件，并为一个对话框添加新的资源条目：

ResourceCount=3

Resource1=IDR_MAINFRAME Resource2=IDD_ABOUTBOX

Resource3=IDD_FAKEDL G

在第一行中一定要把资源数目增加到 3 。在文件的底部添加新对话资源的一个声明。

[DLG:IDD_FAKEDLG]

在项目中没有这样的对话 ( 及标识符名 )，但是， ClassWizard 并不需要知道这一点。该条目将告诉 ClassWizard ，一个标识为 IDD_FAKEDLG 的对话资源属于CButtonView 类；并且包含有由 CLSID 号进行标识的 Button Menu 控件。

下一步，返回到 ButtonView.h 文件，并修正我们以前添加的代码，为IDD_FAKEDLG 标识符添上 #define 语句，并在 CButtonView 类声明中声明该值。新条目是用特殊的 AFX_DATA 注释进行标记的，使得对话框标识符对于第 6 章中解释的标识符来说是可以识别的。结果应该与下面类似：

#include "pmenu.h"

#define IDC_BTNMENU 1001

class CButtonView : public CView

{

private:

Cpmenu btnmenu;

//}}AFX_DAT A

保存该文件。现在，当你调用 ClassWizard 的时候，如果 ClassName 中 CButtonView 类被选中的话，IDC_BTNMENU 标识符将在 Message Maps 选项卡中对象列表的底部显示出来。选中 IDC_BTNMENU 条目来显示 M essages 框中的两个事件，然后双击 Select 事件来添加名为 OnSelectBtnmenu 的处理程序函数。无论何时用户单击了控件弹出式菜单中的一个命令，该处理程序函数前将赢得控制权。

在 Member Functio n（s 成员函数）框中选定了新处理程序函数之后，单击 Edit Code

（编辑代码）按钮，来重新打开 ButtonView.cpp 文件。将代码添加到OnSelectBtnmenu 函数，无论何时，该控件触发了它的 Select 事件，该函数都将做出反应：

void CButtonView::OnSelectBtnmenu(long item)

{

// TODO: Add your control notification handler code here

CStrin g str;

创建 Button 程序并运行它。每次你单击如图 8-11 所示控件菜单中的一个项目时，你都应该能看到一个消息框。

第四部分 A ctiveX 控件 - 图25

图 8-11 在框架窗口中放置的 ActiveX 控件

第 9 章使用 MFC 编写 Ac tiveX 控件

第 8 章演示了在使用 MFC 的情况下，创建 ActiveX 控件并不特别需要理解 OLE 和 COM 基础结构。很显然，在编写 ActiveX 控件时亦是如此。MFC 可以处理诸多的细节，你不必关心它太多复杂的基础信息，便可以编写控件。如果你决定不用 MFC 来编写自己的 ActiveX 控件 ( 这个想法的理由很充足 )，那么，你对项目的实现就更加有信心了。根据你的方法和控件的复杂性，你可能需要仔细地了解ActiveX 和 Component Object Model 的原理。

本章继续前一章的内容。它从服务器而不是客户的角度来检查 ActiveX 控件，介绍了 Visual C++ 帮助想编写而不只是使用 ActiveX 控件的开发者的一些方法。Visual C++ 提供了三个不同的工具来帮助建立 ActiveX 控件项目：

对 ActiveX 控件的 MFC 支持。
BaseCtl 框架。
Active Template Library 。

用于创建 ActiveX 控件的 Visual C++ 工具

MFC 提供了创建 ActiveX 控件的最容易的方法。以前在 M icrosoft Developer Network 上提供的 Control Development kit 已经作为一套工具并入 Visual C++ 中，该套工具包括已经重命名了的 MFC Active ControlWizard ： Test Container 和ControlWizard 。正如本章稍后用例子所演示的那样，ControlWizard 将生成包含有原始代码的源文件，该代码使用 MFC 来管理几乎所有的 C O M 详细资料。生成的源代码可以处理串行方式，显示控件的属性表，并为程序员和用户提供其他许多方便之处。你仅仅需要添加必要的代码来画出该控件，对用户的输入做出反应和触发事件。

使用 MFC 编写 ActiveX 控件可以使 OCX 文件相当小，但是，这是一种误导，因为该控件永远依靠两个大文件的存在而存在。这是 MFC 的缺点。如果控件的 OCX 文件在用户的计算机上不可用，该用户的浏览器程序必须下载这个文件，才能显示它，因此，小的可执行文件尺寸对于用于 Web 页的控件来说就特别重要。一个 ActiveX 控件不能与 MFC 静态链接起来，这就意味着，如果用户硬盘上不存在 MFC 库 DLL 文件的正确版本，那么该文件必须随控件一起传输。更为糟糕的是， MFC 需要 C 运行时间库，因此 Msrcrt.dll 文件也可能需要下载。当用户首先遇到一个显示依靠 MFC 的 ActiveX 控件的 Web 页的时候，将自动传输库文件。尽管对于用户通过快速网络连向的内部 Web 站点来说，这是很合理的，但是对于 Internet 来说却是不现实的。既然 MFC 的大小大约为 1 兆字节，因此，使通

过快速快速调制解调器下载该文件，也要花上几分钟的时间。

BaseCtrl 框架也就是人们所熟知的 ActiveX Controls 框架，是 MFC 的一个简便的替代方案。尽管 BaseCtrl 为开发者提供的支持比 MFC 少得多，但它却提供了更大的灵活性。从 BaseCtrl 中创建的 ActiveX 控件既不需要 MFC ，也不需要 C 运行时间库。因为框架仅仅提供了最少的代码，因此该控件比它的 MFC 同伴占用更少的内存。但是 BaseCtrl 的优点是要付出代价的，使用 BaseCtrl 需要对你的组件做更多的工作，并且要对 C O M 和 ActiveX 的原理有更深入的理解。例如，你必须十分适应持久的接口，例如 Istream ， IPersistPropertyBag 和 IPersistStream 。框架通过三个主类提供了核心功能，这三个主类的名字分别为CAutomationObject， ColeControl 和 CPropertyPage 。

BaseCtrl 过去常常需要 Visual Basic 4.0 来开始一个项目，但现在不需要了。你现在可以运行一个由 Visual C++ 提供的 NMake 实用程序来开始一个项目，第一次生成库文件，再次为新类生成存根源文件。在 BaseCtrl 提供的 RendMe.txt 文件中解释了这个过程。在安装 Visual C++ 时，如果你申请包括范例代码，那么ReadMe.txt 文件和几个范例 BaseCtl 项目的源代码将位于文件夹MSDN\Samples\VC98\SDK\COM\AativeXC\BaseCtrl 之中。如果想得到 BaseCtl 的最近更新版本，请从如下站点下载 ActiveX 开发工具箱：

http:www.microsoft.com/intdev/sdk

目前并不常使用 BaseCtl ，原因是 Active Template Library(ATL )提供了一种创建小

ActiveX 控件的高级工具。尽管结果 OCX 文件比依赖于 MFC 的类似控件要大，但通过 ATL 创建的控件通常占用更少的内存，原因是它不需要其他辅助文件的存在。除了为你实现许多标准接口的智能模板代码库之外，ATL 还提供了一个可以生成初始源文件的向导，这就大大简化了 ActiveX 控件项目的早期阶段。与用ControlWizard 和 MFC 创建 ActiveX 控件相比，用 ATL 创建相同的控件需要更多的工作，但对于创建用 Internet 上使用的 ActiveX 控件来讲， ATL 是一个很好的选择。

你可能听说过 ATL 不适合于编写 ActiveX 控件，但自从该库的 2.0 发行之后，这种说法就不再正确了。不过， ATL 不是一个简单的主题，直到下一章才能涉及到更加详细的讨论。本章将介绍创建 ActiveX 控件的 MFC 方法。 MFC 提供了试验ActiveX 编程的最好方法，并提供了充足的信息。除了可以为你节省大量的编码之外，使用 MFC 编写 ActiveX 控件，还可以提供许多有帮助的 Visual C++ 特征，例如 ClassWizard 和 ControlWizard 。正如我们将要在下面看到的那样， ControlWizard 为 ActiveX 控件项目提供了一个很好的起点。

ControlWizard

应用与 AppWizard 为 MFC 应用程序创建项目相同的方法，ControlWizard 可以为ActiveX 控件创建一个项目。在 ControlWizard 帮助下创建的控件使用 MFC ，因此也就具有前一节所介绍的优点和缺点。 ControlWizard 是 AppWizard 的自定义的形式， ControlWizard 项目以和普通 AppWizard 项目相同的方式开始。从 File

菜单中选择 New 命令打开 New 对话，在 Projects 选项卡中单击代表 MFC ActiveX ControlWizard 的图标。图 9-1 说明了这些步骤。

第四部分 A ctiveX 控件 - 图26

图 9-1 用 ControlWizard 开始一个 ActiveX 控件项目

在创建项目之前， ControlWizard 将引导完成两个步骤。本节将检查这个向导所提供的选项，并讨论一个选项何时对于你的 ActiveX 控件来说是合适的，以及它为什么合适。

图 9-2 显示了 ControlWizard 的打开屏幕，它首先询问你项目中控件的数量。与VBX 自定义的控件类似，一个 OCX 文件可以包含不止一个 ActiveX 控件组件。请在对话顶部的文本框中指定你想要的控件数量。以后，在项目开发期间，你还可以添加控件。使用 ControlWizard 屏上的下一个选项，可以通过许可来限制控件的使用。尽管许可支持选项在默认状态下是关闭的，对于一般用途的许多控件，应该具有简短描述的许可保护。

第四部分 A ctiveX 控件 - 图27

图 9-2 ControlWizard 的步骤 1

步骤 1 中的最后一个选项用于指导 ControlWizard 为控件生成帮助文件。对项目帮助文件的申请，所添加的帮助支持种类与从 AppWizard 中得到的相同。如果想获得所生成的帮助文件的说明，请参阅第 2 章开始部分的讨论。

ControlWizard 的第二屏 ( 图 9-3) 展现了决定控件如何与包容器进行交互的选项。第二步中的选项需要解释一下，因此，下面详细对它们说明。

第四部分 A ctiveX 控件 - 图28

图 9-3 ControlWizard 的步骤 2

Activates when Visible （可见时激活）：决定当控件可
见时，包容器是否应自动激活它。对于 ActiveX 控件，通常需要立即激活，尽管选中

Activates When Visible 选项仅仅作为包容器应用程序的线索，它可能忽略申请。如下的讨论有很多是与此选项有关的。

Invisible At Run-Time （运行时不可见）：如果选中了
该选项， ControlWizard 将不把 OnDraw 函数添向控件类。可以为那些不需要与用户进行交互的控件使用该选项，例如第 8 章中介绍的 Timer Object

控件。

**Available In Insert Object Dialo g（在插入对象对话中可用
）**：与从 Test Container 工具到 M icrosoft Office 应用程序的许多包容器应用程序提供的 Insert Object 对话 ( 或等价物 ) 相关。不选中该选项，将通知包容器，

它不应该在包容器的 Insert Object 对话中包括这个新控件。

Has An About Box （有一个 About 框）： ControlWizard 将为

About 方法生成源代码，为常用 About 框生成资源。
**Acts As A Simple Frame Contro l（作为一个简单的框架控件

）**：为IsimpleFrame- Site 接口添加支持。该选项将设置控件，来充当框架，用来包围包容器窗口中其他 ActiveX 控件，将控件分组，并允许它们

一起移动。并不是所有的包容器都支持简单的框架。

W indow Subclassin g（窗口细分类）：通过对诸如编辑
框或进程指示器之类的普通 W indows 控件进行细分类，来建立控件项目。

在默认状态下， ControlWizard 仅仅打开上面列出的两个选项 Activates when Visible 和 Has An About Box 。取消选中 Activate when Visible 复选框，将清除掉该控件的 OLEMISC_ACTIVATEWHENVISIBLE 状态标志，该标志是控件通过MFC 的 AfxOLeRegisterControlClass 全局函数放置在它的注册表数据之中的。嵌入控件的包容器可以通过调用控件的 IOleObject::GetMiscStatus 方法来确定该标志的状态。清楚的标志将向包容器传递信号，当控件可见时，它应该保持非激活状态，这样，将延迟对控件窗口的创建，直至用户需要它。对于 ActiveX 控件，这将节省创建窗口这一不必要的操作。第 10 章将详细讨论 ActiveX 控件状态标志，例如 OLEMISC_ACTIVATEWHUENVISIBLE 。

你可能还想考虑关闭 About Box 选项，因为对 About 框添加的支持将增大完成之后的 ActiveX 控件的容量。例如由 ControlWizard 生成的标准 About 框将向完成之后的 OCX 文件添加大约 2KB 的额外代码和资源文件。如果想了解有关最小化资源数据的其他方法，请参考第 4 章的最后一节，这对 ActiveX 控件来说是特别重要的。

如果选中了 Available In Insert Object Dialog 复选框，那么，该控件的自我注册过程将向控件的 CLSID 注册表层次添加名为 Insertable 的 Registry 键。Insertable 键将通知包容器 ActiveX 控件可以充当被动嵌入的对象。这样，包容器就能够通过

OLE Documents 接口创建 ActiveX 控件的对象。这些用 IOle 前缀标识的接口包括IOleCache, IOleClientSite, IOleContainer, IOleInplaceObject 和 IOleInPlaceSite 。可以在包容器文档中嵌入对象的应用程序为寻找具有 Insertable 键的对象而扫描注册表，并在标准的 Object 对话中列出了一个对象列表。例如，为了在 M icrosoft Word 中看到这个列表，请单击 Word 的 Insert 菜单上的 Object 命令。仅仅当Available In Insert Object Dialog 复选框打开的时候，使用 ControlWizard 创建的ActiveX 控件才能出现在列表之中。不支持包容器文档的应用程序将忽略Insertable 键。例如，我们在第 8 章中所遇到的 Test Container 实用程序中的 New Contro l，将显示一个所有注册控件的列表，而不管它是否标记为可插入的。

如果你想让 ActiveX 控件对标准或普通 W indows 控件进行细分，那么请单击图9-3 中屏幕底部显示的框。该下拉窗口将显示一个列表，其范围从按钮到树状视图的 16 个 W indows 控件。从该列表中选中一条目，将导致 ControlWizard 为对选中的 Windows 控件进行细分的 ActiveX 控件生成源代码。使用该选项可以生成只有某个 W indows 控件的特性的 ActiveX 控件，但是，为了添加所需要的效果，你可能还要进行修改。

在 ControlWizard 的步骤 2 中单击 Advanced 按钮，来打开如图 9-4 所示的 Advanced ActiveX Features 对话。该对话提供了用来设置或清除由 ColeControl::ControlFlags 枚举集定义的位标志，该枚举集描述了控件被激活时的行为特性。设置任何复选框都将导致 ControlWizard 添加超越 ColeControl::GetControlFlags 方法的代码，该方法的作用是将 ControlFlags 设置通知给包容器。为了在现有的控件项目中添加

超越代码，请设置特定的位标志，例如下面的 W indowlessActivate:

DWORD CDemoCtrl::GetControlFlags()

{

return COleControl::GetControlFlags() | windowlessActivate;

}

在 Advanced ActiveX Features 对话中的复选框标签看上去很简洁，但是，略加解释之后是可以很容易理解它的。下面的列表说明了标志的含义。如果想了解有关ControlFlags 设置，以及它们是如何影响到控件动作的更为详细的信息，请查阅题目为 “ ActiveX Controls::Optimization ” 的帮助文章，通过索引条目 Optimizing ActiveX Controls 可以找到它。

第四部分 A ctiveX 控件 - 图29

图 9-4 通过单击 ControlWizard 的 Advanced 按钮调用 Advanced ActiveX Features 对话

W indowless Activation (无窗口激活 ) ：通知包容器，控

件在激活时不创建自己的窗口。下面的讨论有许多是关于无窗口激活的。
Upclipped Device Context（不剪辑设备上下文）：申请不

要剪辑控件

的显示，这样处理会更快。不过，控件必须确保不在站点边界之外显示。

Flicker-Free Activatio n（激活时不闪烁）：要求包容器
要在控件切换状态时不要使控件窗口无效。该操作将阻止控件在成为活动或不活动的时候重绘自己，这样也就清除了可能发生的轻微的闪烁。该选项仅仅

适合于不管状态如何而以同一种方式绘制自己的控件。

Mouse Pointer Notification s（鼠标指针通知）：要求包容
器在控件不处于活动状态对 ActiveX 控件发送鼠标消息。如果包容器满足了要求，那么，非活动的控件将继续接收与控件窗口上鼠标活动有关的

WM_SETCURSOR 和 W M _ M O U S E M O V E 消息。选中该选项将启用IPointerInactive 接口，包容器将把这些属于控件的消息委托给这个接口。 IPointerInactive 接口为控件窗口调整每条消息的鼠标坐标，并且通过控件的消息映射分派消息。通过这项功能，控件甚至可以在非活动状态实现拖放目标的功能。

Optimized Drawing （优化的绘制）：通过允许控件的
OnDraw 方法在返回时不恢复用于设备上下文的原始 GDI 对象，来提高绘制的速度。仅仅当包容器支持优化的绘制时，该选项才起作用，而包容器是否支

持优化的绘制，由控件通过调用 COleControl::IsOptimizedDraw 函数来确定。返回值 TRUE 意味着该控件不必在完成绘制之后不必选中诸如

钢笔和刷子之类的原始 G D I 对象，便可回到设备上下文之中。

Load Properties Asynchronously （异步加载属性）：该选
项可以提高ActiveX 控件的响应性，而且这种控件需要大量属性数据。异步加载将允许控件在 Web 页上尽可能地成为活动状态，即使在浏览器在后台连

续不断地通过调制解调器加载该控件的数据时也是如此。例如，该控件这样便可以立即播放音频或视频片断，而无需等待完整的数据集。不过，控件必须不对尚未到达的数据进行操作。异步加载为控件增添了负担，因此，应该仅仅为可以从中受益的控件使用该选项。

W indowless Activation 选项与前面介绍的 Invisible At Run-Time 标记不是同一件事情。无窗口激活仅仅意味着控件不提供它自己的窗口。通过不创建窗口，控件优化了创建的速度，同时稍微降低了一点儿可执行文件的大小。如果包容器支持无窗口对象的话，该控件可以自由使用包容器的窗口服务。这种支持需要IOleInPlaceObjectWindowless 接口来将用户输入消息反应到无窗口控件。通过覆盖包容器的窗口，无窗口控件可以带有真正透明的背景，对于显示自己矩形窗口的普通 ActiveX 控件来说，达到这种效果是不可能的。不过，使用第 4 章中介绍的使背景透明的想法，一个窗口控件通常可以将它自己的窗口颜色与包容器的背景颜色相匹配，来模拟透明背景。正如在前一章中所提到的那样，控件可以通过调用 ColeControl::AmbientBackColor 来确定包容器周围的当前颜色：

OLE_COLOR ContainerBkGrnd = AmbientBackColor();

并非所有的包容器都支持 ColeControl 的 Ambient 函数。在调用诸如

AmbientBackColor 之类的函数之后。一个 ActiveX 控件应该检查有效返回值。

许可

放置在流行 Web 上的 Active 控件不久便可以在全世界的计算机上出现，在数以千计的浏览器上查看。这种简单重复使用 ActiveX 控件的能力可能是该项技术最吸引人的特征和最大的优点。不过，这样的话，便引起了有关程序员的知识产权的潜在问题。为了更清楚地认识这一问题，请考虑一下 ActiveX 控件是如何传过Author、 Webmaster 和 User 这迥然不同的三方面的。

收取一定的费用，Author 便允许 Webmaster 在 Web 页上安装 ActiveX 控件。User 通过 Internet 访问 Webmaster 的站点，结果，ActiveX 控件将从 Webmaster 的计算机复制到 User 的计算机；在 User 的浏览器程序中出现。到此为止，每件事情都如期进行，控件的使用像 Author 所期望的那样。但是，如果不采取一些安全措施的话，拥有这个 ActiveX 控件的其他程序员就可以在自己的应用程序中使用它。许多开发者不愿意在未经授权的情况下，他们的产品用这种方式被重用，特别是在可以得益的商品应用程序之中使用。

要防止未经授权使用 ActiveX 控件，最常用的措施是包含一个许可证。许可证不仅将我们的范例中的 Author 标识为作为控件版权的所有者，而且还可以阻止没

有从 Author 处收到许可证的开发者随便重用控件。 OLE/ActiveX 控件标准的设计考虑到了许可证。该标准定义了 IClassFactory2 接口，包容器可以通过该接口来创建控件对象的一个实例，并证明它自己已获得了使用该控件的许可证。仅仅当包容器满足了有效许可证存在的控件的时候，才能完成控件对象的创建。

许可证已成为 ActiveX 控件普遍采用的方法，因此，详细检查一下 ControlWizard 的许可证方案还是十分值得的。在这个主题上花费时间的另一个原因是， Visual C++ 在线文档中的许可证说明不十分清楚，这主要是因为当可能涉及到几个包容器的时候，这个文档将说 “ the container（这个包容器）”。记住，任何程序都是可以创建 ActiveX 控件的一个实例，并为之提供站点的包容器，这一点是很重要的。第 8 章演示了可以在不同环境下嵌入 ActiveX 控件的几个不同的包容器：

Internet Explorer 或另一个可察知 Active 的浏览器，它通
过由 H T M L

文档中的 OBJECT 标记指定的类标识符来定位控件。

Visual C++ 对话编辑器，当它被放入开发环境下的一个

对话中时，创建控件的一个实例。
Hour 程序这样的包容器应用程序，它可以在运行时嵌

入一个 ActiveX

控件。

许可证方案可以阻止包容器应用程序未经授权便使用控件，但是，阻止哪一个包容器呢 ? 在我们的方案中，当 User 连同显示 Author 的控件的 H T M L 指令一起下

载该控件的时候， User 的浏览器必须能够自由运行该控件，而不必使用许可证。访问应该仅仅限制到列表中的其他两种类型的包容器：也就是开发程序 ( 像 Visual C++ ) 和以及它们所创建的包容器应用程序 ( 像 Hour) 。

当 Webmaster 决定开发使用 Author 的 ActiveX 控件的时候。应该考虑一连串的事件。为了创建应用程序， Webmaster 运行一个 Windows 开发程序，例如 Visual C++ 或 Visual Basic 。这个程序设计要求应用程序在对话框中显示控件，因此， Webmaster 使用对话编辑器本身就是包容器创建控件的一个实例，并在该对话中显示它。这个时候，叫做设计阶段，许可证问题便出现了。在创建控件实例的过程中，开发程序将调用该控件的 IClassFactory2::CreateInstanceLic 方法，其中的参数为 NULL ，控件通过仅仅在确认许可证存在之后返回到接口的一个指针来响应该函数 ( 过一会儿，我们将看到是如何响应的 )。

既然 Webmaster 被授权可以在应用程序中使用该控件，那么许可证验证将获得成功，对话编辑器可以创建该控件的一个实例。 Webmaster 完成应用程序的开发，并将可执行文件的副本出售给 User。作为软件包的一部分， Webmaster 提供一个安装程序，用来在 User 的硬盘上放置 Author 的 ActiveX 控件的副本，并注册它。尽管 User 从来没有与 Author 一起签订过许可证协议，新的包容器应用程序将在运行时成功地创建控件对象的一个实例 ( 这个处理过程过一会再解释 )。这叫做许可证验证的运行阶段。

现在，让我们来考虑一下当 User( 恰好又是程序员 ) 试图创建嵌有 Author 控件的另

一个包容器应用程序的时候，会有什么事情像以前一样发生。User 的开发程序调用控件的 IClassFactory2::CreateInstanceLic 方法，但这次，控件检测到 User 没有拥有许可证，因此也就不允许这一创建企图。有决心的 User 可以在没有对话编辑器的帮助下开发应用程序，但是，完成之后的应用程序不再能够创建该控件的一个实例。未经授权的控件中的许可证验证代码既在设计时使用，又在运行时使用。

ControlWizard 添向控件项目的代码可以实现类似刚才介绍的许可证方案。下一节将解释该方案是如何工作的。

Control W izard 许可证支持

如图 9-2 所示，ControlWizard 的初始屏幕提供了对许可证协议的支持。如果你为新控件要求运行时间许可证，那么， ControlWizard 将生成额外的源代码和文本文件，它们一起可以保证使你的控件将只被经过授权的人使用。文本文件是带有LIC 扩展名的文档，包含如下文字。

Warning: This product is licensed to you pursuant to the terms of the

license agreement included with the original software, and is protected by copyright law and international treaties. Unauthorized reproduction or distribution may result in severe civil and criminal

penalties, and will be prosecuted to the maximum extent possible under the law.

在许可证的第一行中，单词 author 代表你的用户名或公司名。像这样一个由

ControlWizard 实现的基于文件的许可证方案，当包容器应用程序在设计时添加该控件的时候，需要 LIC 文档与控件 OCX 文件存在于同一目录之中。由于这个原因，Author 必须向 Webmaster 分发这个 LIC 文本文件，以便 Webmaster 可以创建使用该控件的包容器应用程序。但许可证的期限阻止了 Webmaster 将该文档重新分发给别人。用户不需要 LIC 文件便可运行 Webmaster 的应用程序，并或在浏览 ControlWizard 在主项目文件夹中放置 LIC 文件的主副本。当 Visual C++ 创建这个 OCX 文件的时候，它将这个 LIC 文件从主文件夹复制到 OCX 文件驻留的Release 或 Debug 文件夹，因此，最终一个项目可能有两三个许可证文件的副本。在创建 OCX 文件之前，应当制订文件主副本的更改方案，以便所有的副本保持最新。

ControlWizard 添加到项目的源代码由两个函数组成，一个叫做 GetLicenseKey，

它可以从该控件的 OCX 文件中检索到一个独一无二的密码或关键字，另一个函数叫做 VerifyUserLicense ，它为许可证文本文件的存在检查用户磁盘的指定位置。一个名为 License 什么都不做的项目，演示了 ControlWizard 是如何把这两个函数添加到控件的类源代码之中的。你没有必要自己创建 License 项目，因为不在这里开发控件。它的作用仅仅是使得如下讨论更加容易，同时用来阐述ControlWizard 的许可证方案。

下面是这两个函数的源代码清单，它取自该项目的 LicenseCtl.cpp 实现文件 ( 第三行上的 _s2LicString 文字根据系统不同而有所不同 )。

static const TCHAR BASED_CODE _szLicFileName[] = _T("License.lic");

/////////////////////////////////////////////////////////////////////////////

// CLicenseCtrl::CLicenseCtrlFactory::VerifyUserLicense -

// Checks for existence of a user license

BOOL CLicenseCtrl::CLicenseCtrlFactory::VerifyUserLicense()

{

return AfxVerifyLicFile(AfxGetInstanceHandle(), _szLicFileName,

_szLicString);

}

/////////////////////////////////////////////////////////////////////////////

// CLicenseCtrl::CLicenseCtrlFactory::GetLicenseKey -

// Returns a runtime licensing key

BOOL CLicenseCtrl::CLicenseCtrlFactory::GetLicenseKey(DWORD dwReserved, BSTR FAR* pbstrKey)

{

if (pbstrKey == NULL) return FALSE;

*pbstrKey = SysAllocString(_szLicString);

return (*pbstrKey != NULL);

}

在设计时，当开发程序企图将一个 ActiveX 控件插入到包容器项目时，也就是当对话编辑器向正在开发中的对话添加控件的时候， VerifyUserLicense 和GetLicenseKey 函数均被调用。当开发完成，而且包容器应用程序已经建立并执行的时候，它在运行时创建控件实例的企图，会导致了再调用该控件的GetLicenseKey 函数。让我们分别考查一下这两种情形，首先看一看在设计时控件是如何为开发程序验证许可证的存在的。

设计时间许可证验证

通过调用控件的 IClassFactory2::CreateInstanceLic 方法，开发程序事实上是在说： “ 如果有效许可证存在，就创建控件的一个新实例，并返回一个指向该实例接口的指针 ”。该控件的工作便是验证许可证的存在。当 CreateInstanceLic 被调用的时候，框架将调用路由到控件的 VerifyUserLicense 函数，该函数用来确认 LIC 许可证文件与控件 OCX 文件存在于同一目录之中，而且，该文件的第一行与

_szLicString 参数的内容相匹配。_szLicString 参数就是人们所熟知的许可证关键字。

如果 LIC 文件存在，并且包含正确的许可证关键字，那么， VerifyUserLicense 将返回值 TRU E ，允许开发程序为正在开发之中的包容器应用程序创建 ActiveX 控件的实例。开发程序下一步调用控件的 IclassFactory2::RelestLickey 方法。这个调用以 GetLicenseKey 结束，该函数是 ControlWizard 向控件源代码添加的两个函数中的第二个。 GetLicenseKey 将返回控件的 _szLicenseKey 关键字的一个副本，开发程序将它嵌入在包容器应用程序的可执行文件之中。当我们谈到运行时间许可证的时候，我们还将看到为什么包容器需要它自己的关键字副本。

如果控件没有在与 OCX 文件相同的目录中找到 LIC 文件，或者，如果该许可证文件的第一行已经被改变了，那么 VerifyUserLicense 将返回 FALSE ，在这种情况下，开发程序将显示一条解释该问题的错误信息。例如，下面是当 LicenseLic 文件被改变或重命名之后，Visual C++ 是如何处理这种情形的 ( 如果你想自己试一试，一定要在包含 OCX 文件的子文件夹中改变 LicenseLic 文件，因为在控件创建之后，改变项目文件夹中的主副本是没有任何效果的 )。假定你正在开发一个叫做 DemoContainer 的包容器应用程序，并且希望把 License ActiveX 控件添加到DemoContainer 的 About 框，请在对话编辑器中加载 About 框资源，并在工作区内右击来显示该编辑器的上下文菜单。从上下文菜单中选择 Insert ActiveX Control 命令，然后从图 9-5 所示的列表中选择 License Contro l。

第四部分 A ctiveX 控件 - 图30

图 9-5 向包容器项目插入 License 控件

对话编辑器企图创建 License 控件的一个实例，这导致了一系列的函数调用。编辑器首先调用控件的 IClassFactory2::CreateInstanceLic 方法，该方法依次调用控件的 VerifyUserLicense 函数，该函数调用框架的 A fxVerifyLicFile 函数。这个 MFC 函数读取由 szLicenseName 字符串 ( 这里是 LicenseLic) 来标识的文件，如果该文件存在的话，将它的第一行与包含在 _szLicString 中的许可证关键字进行比较。如果文件不存在，或第一行与许可证关键字不匹配， A fxVerifyLicFile 将返回值FALSE ，来禁止对象创建。结果会出现 Visual C++ 的一条错误信息，来解释为何失败：

第四部分 A ctiveX 控件 - 图31

运行时间许可证

如果许可证文件存在，并且， VerifyUserLicense 函数返回了值 TRUE ，那么开发程序将成功地创建控件实例，并将控件类的源文件插入到包容器项目之中。直到包容器应用程序被创建并成为可执行程序之后，才发生下一次有效许可证的验证。

当包容器应用程序运行，并试图创建 ActiveX 控件的一个实例的时候，它还调用该控件的 IClassFactory2:: CreateInstancelic 方法。但是与开发程序在设计时间为第四个参数传递的 NULL 值不同，应用程序提供了一个指向它的许可证关键字副本的指针。这个字符串与开发程序从控件的 GetLicensekey 函数获得并放在应用程序的数据之中的字符中是相同的。对 CreateInstanceLic 的调用即：“ 创建控

件的一个新实例，这里是证明我是一个经过授权的包容器的证据。” 控件将

_szlicString 中它自己的许可证关键字副本与包容器递交的副本进行比较，验证匹配，并允许创建操作。在这种情况下，框架不调用 VerifyUserLicense 函数，这就是当应用程序在 User 的机器上运行时，为什么不需要 LIC 文件的原因。仅仅是Webmaster 机器上的开发程序而不是完成后的包容器应用程序过需要许可证。

为了获得更多的保护，改变许可证 LIC 文件的第一行，使文字更具体些。但是要对源代码中的 _szLicString 字符数组做出相同的改变，否则， VerifyUserLicense 将识别不了这个文本文件。你还可能考虑修改这里介绍的基于文件的许可证方案来依靠系统注册表中而不是 LIC 文本文件的关键字。这将需要为搜索注册表简单地重写一下 VerifyUserLicense 函数，而且，还要假定已经安装了程序，来为授权的许可证注册关键字。

例 1 ：什么都不做的 ActiveX 控件

在开始 ActiveX 控件的开发之前，我们应该清楚地了解 ControlWizard 对项目的巨大贡献。最好的办法是运行 ControlWizard ，并从生成的源文件中创建一个什么都不做的控件。正如我们将要在下一节中所看到的，创建一个有用的 ActiveX 控件需要做一些工作，并且需要进行一定数量的讨论，所有这些都使得在开始编写代码之前， ControlWizard 已经为工作控件生成了所有必要的源文件这一事实不那么明朗了。留给开发者的任务通常只是装饰一下现有的控件，其工作已不如

创建 ActiveX 控件那样多了。从一开始 , ControlWizard 创建就可以在一个包容器中运行，显示它自己的窗口，当它的窗口被移动或调整之后，做出合适的反应，显示 About 框，并显示它的属性表的模型。不过，该控件所执行的没有一件是有用的工作，因为它没有触发事件，导出自定义方法或包含属性。

第四部分 A ctiveX 控件 - 图32

图 9-6 由 ControlWizard 创建的默认 ActiveX 控件

创建如图 9-6 所示的 ActiveX 控件不需要任何编程。如果你愿意进行实验，可以像以前解释的那样通过运行 MFC ControlWizard 来创建一个空项目，将项目的配置改为 W in32 Release ，从所生成的源文件中创建控件。像任何 ActiveX 控件一样，结果可能只通过像第 8 章中介绍的 Test Container 实用程序这样的执行包容器来加载。从 Tools 菜单中启动 Test Container，调用它的 New Control 工具，为新的 ActiveX 控件搜索列表。该控件与项目具有相同的名字，作为 Demo 控件或某些类似的东西出现在列表之中。将该控件插入 Test Containe r，然后通过双击该控件的窗口边框或通过单击 Test Container 的 Properties 按钮，来打开如图 9-6 所示的默认属性表。如果想显示控件的 About 框，请选中 Invoke Method 工具，并单击 Invoke 按钮。完成实验之后，退出 Test Container 并关闭项目。注册表中的控件条目可以永远保持，而不受损害，但在从系统中删除一个 ActiveX 控件之前，最好是清理一下注册表。运行第 8 章中介绍的 Regsrv32 实用程序，并包括 /u 开关来取消对该控件的注册：

regsvr32/u \demo\release\demo.ocx

第四部分 A ctiveX 控件 - 图33

该实用程序通过显示一个消息框来指示成功：

第四部分 A ctiveX 控件 - 图34

当控件被成功地取消注册之后，就可以删除项目文件了。

一个名为 ColeControl::OnDraw 的过载成员函数用于绘制如图 9-6 所示的控件窗口。与由 ControlWizard 所生成的一样，OnDraw 函数在白色矩形内部显示一个椭圆：

void CDemoCtrl::OnDraw(

CDC* pdc, const Crect& rcBounds, const CRect& rcInvalid)

{

pdc->FillRect(rcBounds, CBrush::FromHandle(HBRUSH)GetStockObject(WHITE_BRUSH)));

pdc->Ellipse(rcBounds);

}

当你开发使用 Control Wizard 创建的 ActiveX 控件的时候，这个函数是你开始的首选位置之一。我们使用一个范例函数，演示了如何重写 O rDraw 函数，来显示

一个含义更加丰富的控件窗口。

例 2 ： Tower ActiveX 控件

本节将对前一节的内容进行扩展，展示了一个简单的项目，用来说明如何从ControlWizard 开始，来开发一个有用的 ActiveX 控件。我已经将其命名为 Towe r，因为它是汉诺塔（ Tower of Hanoi ）难题的变种，这个难题由十九世纪法国数学家 Edouard Lucas 提出。图 9-7 显示了 Tower 控件出现在对话中的情形，它显示为分为三层的矩形窗口。游戏的目的是一个接一个地从第一个窗格中拖动几个新块，并将其重新安装在第三个窗格之中。你可以从任何一个窗格向另一个窗格移动单个新块，但不能把大块放在小块之上。

尽管仅仅是个游戏，但是 Tower 控件显示了一个典型 ActiveX 控件的所有标志。Tower 包含库存和自定义属性，可以导出方法，以及触发事件，来让包容器应用程序知道游戏的当前状态。在本章稍后，我们将使用 Text Container 实用程序来在控件发生时监视它们的状态。

第四部分 A ctiveX 控件 - 图35

图 9-7 嵌入典型的对话中的 Tower ActiveX 控件

如果你愿意自己创建 Tower ActiveX 控件，可按如下步骤进行，其中解释了操作。不过，讨论不是专门针对 Tower 项目的，而且同时也搜索了你在建立自己的ActiveX 控件项目时可能想考虑的一些替代方法。第一步是运行 ControlWizard 创建项目，后四步是使用 ClassWizard 向 Tower 项目添加属性、方法、事件和消息处理程序函数。第六步是为控件创建一个简单的属性页。在 ClassWizard 的存

根代码就位之后，第七步是展示如何为了运行第八步中创建和测试的控件而用其他代码来充实程序。图 9-7 中显示的 Game 程序是一个简单的包容器，编写它的目的只是为了演示 Tower。它是在 AppWizard 的帮助下创建的基于对话的应用程序，与前一章中介绍的 Hour 程序有些类似。因为我们已经研究过了这种类型的程序，所以，本节仅仅简单提及一下 Game 。你将在本书配套光盘的Code\Chapter.oq 文件夹中找到 Tower 和 Game 包容器程序的源代码。

步骤 1 ：创建 Towe r项目

Tower 项目是通过 ActiveX ControlWizard 诞生的。通过单击 File 菜单上的 New 命令激活 ControlWizard ，然后单击 Projects 选项卡，并选择如图 9-1 所示的 MFC ActiveX ControlWizard 图标。键入 Tower 作为项目名，并接受 ControlWizard 第二步中的默认设置。

步骤 2 ：添加属性

Tower 控件有五个属性，名字分别为 Caption ， Font， ForeColor， BackColor 和CurnentBlock 。头四个用于确定在 Tower 窗口的顶部显示的标题文字和外观的库存属性。在启动的时候，控件将标题文字初始化为 “ Tower ”。但是，如果需要的话，包容器可以在 Caption 属性中指定新文字。 CurrentBlock 是包含有代表被拖动块的整数值的 Cursor 属性。 CurrentBlock 中整数值的范围是从代表最小块的 0

到代表最大块的 6 。因为包容器没有理由改变这个值，所以 Tower 将 Currentblack

作为只读属性来保持。

在像 Tower 这样的 MFC ActiveX 控件中指定属性，需要各种宏的精确放置和取名，因此，这项工作最好留给 ClassWizard 去做。在 ClassWizard 的 Automation 选项卡中，单击 Add Propert y（添加属性）按钮来打开 Add Property 对话 ( 图 9-8)，然后单击 External Name（外部名称）框中的箭头来显示一个库存属性列表。通过从列表中选中它，来向项目添加库存属性。如果想指定 Custom 属性，请键入库存名字列表之中没有的任何外部名字。

第四部分 A ctiveX 控件 - 图36

图 9-8 从 Automation 选项卡中调用的 ClassWizard 的 Add Property 对话

利用 Implementation （实现）组框中的 Stock 单选按钮，可以明确地指定一个属

性是库存的，还是自定义的。但是，当你选中库存属性的时候，该按钮是默认设置的。标签为 Member Variable 和 Get/Set Methods 的单选按钮仅用于自定义属性，为控件将自定义属性展现给包容器应用程序提供了两个选择。如果你想使客户到该属性的访问不受限制，请在 Member Variable 单选按钮处进行设置。ClassWizard 将为客户可以通过属性页改变的属性创建一个变量，并且还可以在包容器改变了属性的时候，产生一个简单的通知来让控件知道。如果你的控件不需要这个通知，可以清除文本框，以阻止函数的生成，这样可以减少开销量。

为了对包容器如何 ( 或何时 ) 可以读或写自定义属性进行最大限度的控制，请单击Get/Set Methods 单选按钮。该操作将指示 ClassWizard 为一对包容器可以为了读或写属性而调用的方法生成源代码。如果想检索属性的当前值，包容器可以调用相应的获取方法；如果想设置新值，包容器可以调用 Set 方法。你可以通过省略Set 方法将属性设为只读，或通过省略 Get 方法，而将属性设为只读。不过，打开 Get/Set Methods 单选按钮至少需要定义一种方法，来使得该属性对于包容器来说是可见的。

我们可以接受 ClassWizard 为 Tower 的库存属性所做的默认设置。如图 9-8 所示。选中 Caption 库存属性将自动打开 Stock 单选按钮，并导出函数 GetText 和SetText ，以允许包容器读和写 Tower 的当前标题。这是 MFC 帮助进行 ActiveX 控件轻松编程的几种方法之一： GetText 和 SetText 方法是框架的 COleControl 对象的成员，因此，我们只需要单击它，随后，便可以忽略它们。框架承担了维护Caption 属性，并通过 GetText 和 SetText 函数导出到容器的所有工作。这两个函

数从 Text 库存属性中获取它们的名字，在该属性中， Caption 仅仅是一个别名）。单击 O K 按钮将 Caption 属性添加到 Tower 控件，然后，重复相同的步骤来添加Fon t， ForeFont 和 BackColor 库存属性。

如果仅仅添加 Tower 的自定义属性，请第五次进入 Add Property 对话框，并且键入 CurrentBlock 作为外部名字，为它分配 short 类型。不是接受建议的通知函数OnCurrentBlockChanged ，而是单击 Get/Set Methods 单选按钮。 ClassWizard 将自动分配名为 GetCurrentBlock 和 SetCurrentBlock 的函数。但是，既然CurrentBlockCustom 属性对于包容器来说应呈现为只读，因此应清除 Set Function 框，以便不再将 SetCurrentBlock 添加到控件类。嵌入了 Tower 的包容器应用程序现在已没有办法改变 CurrentBlock ，尽管它可以在任何时候调用GetCurrentBlock ，查询控件，找出属性的当前值。

单击 Add Property 对话中的 O K 按钮，将导致 ClassWizard 在 TowerCtl.cpp 文件中为 GetCurrentBlock 函数编写存根代码。图 9-9 显示了在指定了五个属性之后的 ClassWizard 对话的样子。靠近外部名字的 “ S ”和 “ C ” 代码用来指示该属性是库存的，还是自定义的。

第四部分 A ctiveX 控件 - 图37

图 9-9 向 Tower ActiveX 控件添加属性

步骤 3 ：添加方法

从技术上讲，我们已经向 Tower 项目添加了一种方法。在前一节中生成的GetCurrentBlock 函数就是一种方法。也就是说，它是包容器可以通过接口调用的导出函数。在这里，我们将添加另一个名为 Reset 的方法。 Reset 函数为包容器指示控件去重启动游戏提供了一种方法。图 9-7 中的 Game 程序演示了应用程序是如何使用该特征的，当用户单击对话的 Reset 按钮时，将调用 Tower 的 Reset 方法。

还是在 ClassWizard 的 Automation 选项卡中，单击 Add Method 按钮，并键入 Reset 作为外部名字。选择 Void 为返回类型，因为 Reset 不返回值。Reset 也没有参数，但如果有的话，将通过双击的标签为 Parameter List( 参数列表 ) 的框的 Name 列，并键入函数参数来指定，每行一个参数。在下节中，当我们添加 Tower 的事件时，还要做类似的工作。

单击 O K 返回 ClassWizard 对话，该对话现在在外部名字列表中列出了 Reset 方法。“ M ” 前缀将 Reset 作为一种方法来进行标识。

步骤 4 ：添加事件

下面介绍 ClassWizard 对话的 ActiveX Events （ ActiveX 事件）选项卡，并单击

Add Event 按钮，来打开如图 9-10 所示的 Add Event 对话框。我们还要向 Tower 控件添加一个库存事件和四个 Custom 事件，它们共同使包容器应用程序能够了解 Tower 控件中所发生的事情。库存事件是 Click ，可以从 Add Event 对话 External Name 框中的下拉式列表中选中它。Click 事件用于通知包容器 Tower 窗口什么时候以及在哪里发生了鼠标单击。单击 O K 按钮，然后第二次打开 Add Event 对话，并为该控件的第一个 Custom 事件键入外部名字 FromPanel。无论何时用户选中面板中的一块， Tower 控件都将通过调用 FireFromPanel 函数来触发 FromPanel 事件。 FireFromPanel 调用客户中的事件处理程序函数，向它传递一个从 0 到 2 的单一参数，这一参数是用来标识从中拖出块的面板。通过双击标签为 Parameter List 的列表框中的蓝色区域展现新条目框来指定函数的参数。在新条目框中，键入代表参数名的 nPanel，并接受默认的类型 short，如图 9-10 所示。

下一个 Custom 事件叫做 ToPanel ，它与 FromPanel 类似，有一个类型为 short 的单一参数 nPane l。当用户放下块的时候， Tower 触发 ToPanel 事件，通过 nPanel 参数表明三个面板中哪一个接受了放置操作。第三个自定义事件叫做 Error，当用户企图在小块上面放置大块的时候， Tower 将触发它，来通知包容器这是无效的移动。 Error 没有参数表，因此，只需在 External Name 框中键入它，并单击O K ，返回到主 ClassWizard 对话即可。

第四部分 A ctiveX 控件 - 图38

图 9-10 为 Tower ActiveX 控件指定自定义事件及其参数

Error 是包括在外部名字下拉式列表之中的库存事件的名字。在 External Name 框中键入它，而不是从列中选中它，表明 classWizard 应该把这个事件视为自定义的。这就演示了如何可以使用库存事件名以及它的调度标识符用于自定义事件。因为 Error 库存事件至少需要七个参数，因此，通过使用自定义事件，而不是库存事件，可以简化用于控件及其包容器的代码。

第四个也就是最后一个自定义事件是 W inner，它用来通知包容器，用户已成功地将最后一块移入了控件的第三个面板，从而赢得了这场游戏。与自定义 Error 事件类似， W inner 没有参数表。

图 9-11 显示了在添加了 Tower 的五个事件之后对话的 ActiveX Events 选项卡的样子。

正如在前一章中所提及的，包容器不需要为 ActiveX 控件触发的所有事件提供处理程序函数。例如， Game 包容器程序将忽略 Tower 的 Click 库存事件，而仅仅处理自定义事件，来在事件发生的时候更新状态窗口。控件设计者必须预料到包容器可能需要的信息类型，并且提供事件来传达该信息，同时允许同一个包容器忽略某些事件。

第四部分 A ctiveX 控件 - 图39

图 9-11 向 Tower ActiveX 控件添加事件

步骤 5 ：添加消息处理程序函数

在 Tower 中，用户使用拖放方式在面板中移动块。当用户按下左鼠标按钮的时候，箭头将变为十字形状，从而提供反馈，来指示拖动操作起作用了。当鼠标按钮被释放的时候，系统将把鼠标恢复为原来的箭头形状。在本练习的步骤 6 中编写代码的时候，我们将详细说明处理的过程，但目前，我们仅仅需要使用ClassWizard 来为鼠标消息创建存根处理程序函数。

在 ClassWizard 的 M essage Map 选项卡中，从 Messages 框中选中W M _ L B U T T O N D O W N 消息，并单击 Add Function 按钮来创建 On_ButtonDown 处理程序函数。为 W M _LBUTTONUP 消息做相同的操作，接受默认的函数名OnButtonUp 。对于第三个消息处理程序函数，从 M essages 框选中PreCreateWindow ，并单击 Add Function 按钮。这将生成 CWnd 虚拟函数的超越存根，为 Tower 最后几分钟的初始化提供一个方便的位置。

图 9-12 显示了在添加需要的函数之后 ClassWizard 的 M essage Maps 选项卡的外观 (Tower Ctrl 类的其他成员函数，例如 OnDraw 和 OnResetState ，已在前面由ControlWizard 生成 )。完成之后，单击 O K 按钮退出 ClassWizard 。我们还必须编写代码来填充 ControlWizard 和 ClassWizard 已经添加到项目中的所有存根代码，但是，还有一个更艰巨的任务，需要 Visual C++ 对话编辑器的服务来完成。

第四部分 A ctiveX 控件 - 图40

图 9-12 向 Tower ActiveX 控件添加消息处理程序函数

步骤 6 ：创建属性表

我们以前曾经看到， ControlWizard 向项目添加一个普通的属性页资源 ( 见图 9- 6)。本节将解释如何修正该资源，它最终将扩展进入一个可以使用的属性表，该属性表允许用户在设计时查看和改变 Tower 的属性。第一步是在对话编辑器中修改普通的属性页。通过双击 Workspace 窗口 ResourceView 窗格中的IDD_PROPPAGE_TOWER 标识符来加载资源。选中对话工作区中的 “ to do ” 静态文字控件，并删除它，用如下所示的静态标签和编辑框来代替它。

第四部分 A ctiveX 控件 - 图41

选中对话工作区中的编辑框，单击 View 菜单上的 Properties，给该框一个标识符

值 IDC_EDIT_CAPTION 。属性页本身的大小无关紧要。我们一会儿将要看到， MFC 为属性页提供颜色和字体库存属性，它们决定了完成之后的属性表对话的大小。

在编辑框中输入的文字成为 Caption 属性的新值，它被存储在一个字符串变量之中。通过最后一次进入 ClassWizard ，并单击 ClassWizard 的 M ember Variables 选项卡，来创建该字符串变量。在 Class Name 框中，确定 CTowerPropPage 是当前类，并且在 Control IDs 框中已经选中了 IDC_EDIT_CAPTION 。单击 Add Variable 按钮，并将新成员变量命名为 strCaption 。类别应该是 Value，变量类型应该是“ CString ”。单击 O K 按钮退出 Add Member Variable 对话。最好是通过对话数据验证 ( 请参阅第 6 章 )，来限制基于文本的属性 ( 例如 strCaption) 的长度。通过在M ember Variable 选项卡的顶部文本框中键入一个值，可以设置字符串限制：

第四部分 A ctiveX 控件 - 图42

单击 O K 按钮退出 ClassWizard 。用户现在已经可以在设计时通过调用属性页并键入新字符串来改变 Tower 的标题了。在下一节中，我们将看到这些工作是如何完成的。

步骤 7 ：添加源代码

从 ControlWizard 和 ClassWizard 之间，已经生成了 500 多行源代码。但是，如果我们现在就创建 Tower 控件的话，它看上去还是有点像前面所介绍的什么都没做的 Demo 控件。该练习的第七步将向 TowerCtl.cpp 和 TowerCtl.h 文件添加源代码，充实在前面步骤中添加的存根函数。本节最后将对 TowerPpg.cpp 文件和 Tower.rc 脚本文件进行微小的修改。

TowerCtl.h

TowerCtl.h 头文件只需稍微改动一下。在文本编辑器中加载该文件，并像下面那样对其进行修正，添加阴影行。

// TowerCtl.h : Declaration of the CTowerCtrl ActiveX Control class.

/////////////////////////////////////////////////////////////////////////////

// CTowerCtrl : See TowerCtl.cpp for implementation. class CTowerCtrl : public COleControl

{

DECLARE_DYNCREATE(CTowerCtrl)

private:
short	nPanel[3][NUM_BLOCKS];	// Panel contents
short	nBlockNdx, nFromPanel;	// nPanel index of moved block
BOOL	bMoving;	// Flag is set when dragging
COLORREF	color[NUM_BLOCKS];	// Block colors

// Constructor public:

CTowerCtrl();

以后，当我们讨论实现代码的时候，将遇到 CTowerCtrl 类的六个成员变量。表

提供了这些变量的简要说明。

表 9-1 CTowerCtrl 类的成员变量

变量说明

nPanel 一个 3 × 7 的数值，其作用是反映任何时刻三个面板的内容。数组元素值 0 到 6 意味着该位置被一个彩色块所占据， 0 代表最小的块， 6 代表最大的块。元素值为

7 意味着该位置是空闲的。例如，当块整齐地堆在第一个面板的时候， nPanel 数组应该是这样的

nPanel[0][]={0,1,2,3,4,5,6,}; //Panel 1

nPanel[1][]={7,7,7,7,7,7,7,}; //Panel 2

nPanel[]2[]={7,7,7,7,7,7,7,}; //Panel 3

nBlockNdx 正在拖动的块的辅助数组索引

nFormPanel 正在拖动的块的主数组索引

bMoving 当用户拖动块时被设置为 TRUE 的 Boolean 值

续表

Color 包含有块的颜色的 COLORREF 值的数组。颜色是按照块尺寸递增的顺序安排的，最小块的颜色放在数组的第一个值中

hCrossHairs 系统十字箭头的一个句柄。当用户拖块一个块时，该光标应为十字形状

TowerCtl.cpp

下一个是 TowerCtl.cpp 类实现文件。通过单击 W izardBar 上的棍棒图标打开这个文件，并滚动到在这里显示的属性页映射。按照阴影行中指示的那样做出修改，为颜色和字体属性添加由 MFC 框架提供的属性页：

/////////////////////////////////////////////////////////////////////////////

// Property pages

BEGIN_PROPPAGEIDS(CTowerCtrl, 3)

PROPPAGEID(CTowerPropPage::guid)

END_PROPPAGEIDS(CTowerCtrl)

在映射第一行的 BEGIN_PROPPAGEIDS 宏中，将页数设置为 3 ，这是十分重要的。如果你以后在属性表中添加或删除了页，应该对页数进行调整，以反映出改变。通过使用对话编辑器创建其他的资源，并且将每个页的新条目插入属性页映射，可以向控件的属性表添加更多的自定义页面。这个过程很少会用到，因此，直到本章最后一节，才讨论附加属性页的问题。

图 9-13 显示了完成之后的 Tower 属性表的样子。该表的顺序是前三页 ( 标签为Caption;Colors 和 Fonts) 对应于属性页映射中三个条目的顺序。剩下的修改影响到后半个 TowerCtl.cpp 实现文件，这里列出的文件以类构造器开头。该清单被分为几部分，每部分之后跟着一段注释，用来解释阴影行中所添加的代码的目的。

/////////////////////////////////////////////////////////////////////////////

// CTowerCtrl::CTowerCtrl - Constructor

CTowerCtrl::CTowerCtrl()

{

InitializeIIDs(&IID_DTower, &IID_DTowerEvents);

}

/////////////////////////////////////////////////////////////////////////////

// CTowerCtrl::~CTowerCtrl - Destructor

CTowerCtrl::~CTowerCtrl()

{

}

类构造器用块颜色初始化 color 数组，并调用 Reset 方法来初始化 nPanel 数组。对 COleControl::SetInitialSize 函数的调用为 Tower 控件分配了一个 200 × 75 像素的默认窗口尺寸。在创建站点时，许多包容器程序超越控件的初始尺寸，因此，对 ActiveX 控件来说，调用 SetInitialSize 通常是没有用的。当你在 Test Container 实用程序中打开控件的时候，该函数的目的就很明显了，它接受控件为自己所建立的任何一个初始尺寸。正如我们在第 8 章中所看到的那样，有些 ActiveX 控件

( 例如 Button Menu 控件 ) 在 Test Container 中是作为小方框出现的，为了展现控件窗口，用户必须对其进行调整。对 Tower 并不发生这种情形，因为它通过SetInitialSize 为自己设置默认窗口尺寸。

// CTowerCtrl::OnDraw - Drawing function void CTowerCtrl::OnDraw(

CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)

{

COLORREF colorBack = TranslateColor( GetBackColor() );

int i, j, k, yCaption, iPanelWidth, iPanelHeight;

// Paint control background

brush.CreateSolidBrush( colorBack );

pdc->FillRect( rcBounds, &brush );

pdc->SetBkMode( TRANSPARENT );

pdc->SetTextColor( TranslateColor( GetForeColor() ) );

SelectStockFont( pdc );

// Display caption

::CopyRect( &rect, rcBounds );

pdc->DrawText( InternalGetText(), -1, &rect, DT_CENTER | DT_TOP );

pdc->GetTextMetrics( &tm ); // Compute height

yCaption = tm.tmHeight + tm.tmExternalLeading; // of Caption area,

iPanelWidth = rcBounds.Width()/3; // width and height

iPanelHeight = rcBounds.Height() - yCaption; // of a panel

// Draw column dividers

pen.CreatePen( PS_SOLID, 1, TranslateColor( GetForeColor() ) );

pOldPen = pdc->SelectObject( &pen );

pdc->MoveTo( rcBounds.left+iPanelWidth, rcBounds.top+yCaption );

pdc->LineTo( rcBounds.left+iPanelWidth, rcBounds.bottom );

pdc->MoveTo( rcBounds.left+iPanelWidth*2, rcBounds.top+yCaption );

pdc->LineTo( rcBounds.left+iPanelWidth*2, rcBounds.bottom );

// Save current brush

pOldBrush = (CBrush*) pdc->SelectStockObject( NULL_BRUSH );

// Outer loop: for each panel...

for (i=0; i < 3; i++)

{

rect.top = rcBounds.top + yCaption;

rect.bottom = rect.top + iPanelHeight/NUM_BLOCKS;

// Inner loop: for each colored block in panel...

for (j=0; j < NUM_BLOCKS; j++)

{

if (nPanel[i][j] != EMPTY)

{

// Determine left and right edges of colored block

k = NUM_BLOCKS - 1 - nPanel[i][j];

rect.left = rcBounds.left + iPanelWidth*i +

(iPanelWidth*k)/(2*NUM_BLOCKS) + 1;

rect.right = rect.left +

iPanelWidth*(nPanel[i][j]+1)/NUM_BLOCKS - 1;

// Fill rectangle with block's color

brush.CreateSolidBrush( color[nPanel[i][j]] );

pdc->SelectObject( &brush );

pdc->FillRect( &rect, &brush );

}

rect.top = rect.bottom;

rect.bottom += iPanelHeight/NUM_BLOCKS;

}

下一步，需在该类的 OnDraw 函数中修改源代码，无论何时， Tower 的窗口失效时都将执行这个函数。我们以前曾经看到 ControlWizard 编写 OnDraw 的简单版本。在白色矩形中显示普通的椭圆。在这里，我们来修改一下这个函数，在 Tower 的三个面板中绘制彩块的当前排列情况。无论何时用户移动了一个块，窗口都将重画自己，以反映出改变。

OnDraw 首先用控件的 BackColor 属性的当前值来画窗口背景。该函数从ColeControl::GetBackColor 函数中检索到属性，通过 COleControl::TranslateColor 将它转换为 COLORREF 值，并创建一个刷子，用它来填充窗口矩形 (rcBounds 参数提供了 Tower 窗口相对于包容器窗口原点的坐标 ) 。类似地，该函数使用ForeColor 属性的当前值来设置设备上下文的文字颜色，并使用 Font 属性设置当前的字体。OnPraw 然后编写包含在 Caption 属性之中的字符串，将文字在 Power 窗口的顶部居中显示：

pdc → DrawText(InternalGetText(),-1,&rect,DT_CENTER | DT_TDP);

从 Tower 窗口的高度中减去标题文字的高度便是面板的高度，这个值被存储在

iPanelHeight 之中。每个彩块的高度 ( 厚度 )是面板高度的七分之一，因此，七个块堆起来正好从面板底部堆到顶部。每个面板的宽度是整个窗口宽度的三分之一。有了这些尺寸之后， OnDraw 就开始准备在面板中显示彩块了。

每个块的当前位置被存储在一个 3 × 7 的 nPanel 数组之中。使用为每个面板重复的外循环和为每个块重复的内循环，该函数可以遍历所出现的 21 个槽中的每一个，并在每一步读取 nPanel 数组的一个元素。EMPTY 元素值意味着该槽没有包含一个块。如果一个元素具有从 0 到 6 的值， OnDraw 将使用 Color 数组中相应的颜色为槽中的块上色。一个名为 rect 的 RECT 结构用于保持当前块的坐标。

/////////////////////////////////////////////////////////////////////////////

// CTowerCtrl::DoPropExchange - Persistence support

void CTowerCtrl::DoPropExchange(CPropExchange* pPX)

{

ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor)); COleControl::DoPropExchange(pPX);

}

/////////////////////////////////////////////////////////////////////////////

// CTowerCtrl::OnResetState - Reset control to default state

void CTowerCtrl::OnResetState()

{

COleControl::OnResetState(); // Resets defaults found in DoPropExchange

}

/////////////////////////////////////////////////////////////////////////////

// CTowerCtrl::AboutBox - Display an "About" box to the user

void CTowerCtrl::AboutBox()

{

CDialog dlgAbout(IDD_ABOUTBOX_TOWER); dlgAbout.DoModal();

}

尽管 Tower 没有改变类的 DoPropExchange 函数，但是，简单考虑一下该函数还是值得的。属性交换允许 ActiveX 控件保存嵌入物之间的自定义属性。例如，每当它启动的时候， Tower 控件总是初始化游戏，并在第一个面板中安装彩块堆。通过属性交换，我们可以增强 Tower，以便在关闭的时候保存被中断了的游戏，并且在下次包容器嵌入该控件的时候，重新创建同一个块位置。在运行之间保存和恢复的属性具有持久性。

由框架管理的库存属性自动具有持久性。为了使自定义属性具有持久性，应向DoPropExchange 函数添加合适的属性交换函数，当该控件被加载以及当它再次中止时，该函数便可执行。属性交换函数是用 PX_ 前缀后面跟着由函数系列化的数据类型来进行标识的。例如， PX_Bool, PX_Font 和 PX_String 函数使得Boolean 、字体和 CString 属性具有持久性。如果想获得这些及其他属性交换函数的说明，请参考在线帮助。

/////////////////////////////////////////////////////////////////////////////

// CTowerCtrl message handlers

short CTowerCtrl::GetCurrentBlock()

{

retur n nPanel[nFromPanel][nBlockNdx] ;

}

GetCurrentBlock 函数是在第二步中建立的方法，在此，包容器想了解哪一个块正在移动 ( 尽管 ClassWizard 向代码中添加标题，但 GetCurrentBlock 不是消息处理函数 )。可以在任何时候调用这个函数，但是，如果包容器对 GetCurrentBlock 所提供的信息感兴趣的话，它可能将调用该函数来响应 FromPanel 事件，这个事件宣布一个块正在被移动。GetCurrentBlock 的 EMPTY 的返回值意味着用户当前没有拖动块。可以回想一下第二步过程，因为包容器没有理由改变属性，所以，Tower 不为 CurrentBlock 属性导进相应的 Set 方法。

void CTowerCtrl::Reset()

{

int i;

for (i=0; i < NUM_BLOCKS; i++) // Initialize panel array

{	nPanel[0][i] =	i;	// Panel 0	=	0,1,2,3,4,5,6
	nPanel[1][i] =	EMPTY;	// Panel 1	=	7,7,7,7,7,7,7
}	nPanel[2][i] =	EMPTY;	// Panel 2	=	7,7,7,7,7,7,7

nBlockNdx = 0; // Ndx of block being moved

nFromPanel = 0;

InvalidateControl();

}

利用 Reset 方法，包容器应用程序可以重新开始游戏。例如，当用户单击如图 9-7 所示的 Reset 按钮的时候， Game 程序将调用 Reset 方法。 TowerCtrl 类构造器还调用 Reset，以在启动时初始化 nPanel 数组，在第一个面板中堆起七个块，并将其他两个面板中的所有位置标记为空。 Reset 调用 COleControl::InvalidateControl 函数来触发对 OnDraw 的一次调用，刷新控件窗口。为了使自己失效，基于COleControl 的 ActiveX 控件应调用 InValidateControl 函数，而不是 InValidate API 函数。

BOOL CTowerCtrl::PreCreateWindow(CREATESTRUCT& cs)

{

return COleControl::PreCreateWindow(cs);

}

Tower 通过监视左鼠标按钮来模拟拖和放操作。当用户在 Tower 窗口之中按下鼠

标按钮的时候，控件将把箭头改为系统十字形状，以为用户提供简单而形象的反馈，表明拖操作起作用了。当包容器第一次嵌入 Tower 控件时调用的PreCreateWindow 函数将加载十字箭头，并将该句柄存储在 hCrosHairs 之中。该函数还调用 ColeControl::SetText 来初始化 Caption 属性。

void CTowerCtrl::OnLButtonDown(UINT nFlags, CPoint point)

{

COleControl::OnLButtonDown(nFlags, point);

}

当用户在 Tower 窗口中的某处按下鼠标左按钮的时候， OnLButtonDown 函数将处理产生的 WM_LBUTTONDOWN 消息。该函数首先检查 point 参数中的单击坐标，然后确定单击发生在哪个面板之中。如果面板为空，单击将被忽略。否则， OnLButtonDown 将把箭头改为十字形状，并触发 FromPanel 事件，来将正在移动块的消息通知包容器。

因为仅有面板中最小的块才能被移动，因此， OnLButtonDown 只需确定单击发生在哪个面板之中，而不必确定发生在哪个块上。尽管这可以大大简化帮助器GetPanel 函数中测试的次数，它同时还具有为一个块启动拖动操作的作用，即使单击没有精确地落在该块上面。

void CTowerCtrl::OnLButtonUp(UINT nFlags, CPoint point)

{

short i=0, nToPanel;

nToPanel = GetPanel( point.x ); // Panel in which block is dropped

if (bMoving && nToPanel != nFromPanel)

{

while (nPanel[nToPanel][i] == EMPTY && i < NUM_BLOCKS-1)

i++; // i=ndx of panel's smallest block

// Is dragged block smaller than smallest block in panel?

if (nPanel[nFromPanel][nBlockNdx] < nPanel[nToPanel][i])

{

if (nPanel[nToPanel][i] != EMPTY)

--i;

nPanel[nToPanel][i] = nPanel[nFromPanel][nBlockNdx];

nPanel[nFromPanel][nBlockNdx] = EMPTY;

FireToPanel( nToPanel ); // Tell container

if (i == 0 && nToPanel == 2 // If we've filled

{ // the third panel,

FireWinner (); // fire Winner event

Reset (); // and reset game

}

InvalidateControl();

}

else // If invalid drop,

COleControl::OnLButtonUp(nFlags, point);

}

当用户在面板中释放左鼠标按钮来放下块时， OnButtonUp 函数接收控制。该函数比它的同伴 OnLButton Down 有更多的工作要做。除了确定放置操作发生哪一个面板中之外，OnLButtonUp 还必须确定该面板中的块均不小于所放置的块。如果有的话，OnButtonUp 将触发 Error 事件通知包容器，说用户企图进行非法放置。如果放操作是合法的，OnLButtonUp 将触发 ToPanel 事件，来宣布放操作的结束。如果块正在被拖入第三个面板最上面的槽中，那么游戏结束，OnLButtonUp 将触发 Winner 事件。

释放鼠标按钮很方便，但也有副作用，即在 OnLButtonUp 没有采取任何动作的情况下，光标便恢复到以前的形状。因为 Tower 不处理 WM_SETCURSOR 消息，所以，当用户释放鼠标按钮的时候，系统将自动恢复原来的窗口光标。

TowerPpg.cpp

在步骤 6 中，我们通过添加一个允许用户重写 Caption 属性的文本框，来修改Tower 的普通属性。 Tower 在 StrCaption 变量中存储该文本框的内容，该变量是一个用 ClassWizard 创建的 CString 对象。在 setCaption 字符串和 Caption 库存属性之间需要一个链接，以便当用户在 Tower 的属性表中改变 strCaption 的时候，控件可以把改变转发给埋藏在框架之中的库存属性。

可以通过 DDP_ 前缀来识别 MFC 的属性数据传输函数的目的。 Tower 所需要的函数是 DPP_Text 函数，它可以将文字以字符串变量 (strCaption) 中复制到字符属性 (Caption)。如果想添加 DDP_Text 调用，请在文本编辑器中打开 TowerPpg.cpp 实现文件，并插入如下所示的阴影行：

void CTowerPropPage::DoDataExchange(CDataExchange* pDX)

{

//{{AFX_DATA_MAP(CTowerPropPage)

DDP_Text(pDX , IDC_EDIT_CAPTION , strCaption , _T("Caption" ) ) ; DDX_Text(pDX, IDC_EDIT_CAPTION, strCaption);

DDV_MaxChars(pDX, strCaption, 25);

//}}AFX_DATA_MAP

DDP_PostProcessing(pDX);

}

Tower.rc

在默认状态下， ControlWizard 将普通属性页标为 General ，将该标签作为字符串资源存储在 Tower.rc 脚本文件之中。如果想改变该选项卡标签，请在文本编辑器中打开 Tower.rc 文件，并在如下所示的阴影行中将 “ Genera l” 改为 “ Caption ”：

STRINGTABLE DISCARDABLE BEGIN

IDS_TOWER "Tower Control"

IDS_TOWER_PPG "Tower Property Page"

END

你还可以使用第 4 章中介绍的 Visual C++ 字符串编辑器实现相同的修改。图 9-13

显示了修改后的结果。

步骤 8 ：创建和测试 Tower ActiveX 控件

如果你正在从源代码中创建 Tower 控件，首先应将文件 Tower.ico 和 TowerCtl.bmp 从 Code\chapter.o9\Tower 文件夹复制到项目文件夹。第一个文件提供了在控件的About 框中出现的独一无二的图标资源。第二个文件包含有一个位图，包容器可以在嵌入控件时从这个位图中创建一个个性化的工具按钮。正如我们在前一章中所看到的那样， Visual C++ 自己利用该控件的位图。当一个 ActiveX 控件通过Gallery 添加到项目的时候，对话编辑器将从该控件的资源文件中展开位图，并使用这个图像在 Controls 工具栏上画新的工具按钮：

第四部分 A ctiveX 控件 - 图43

对于这种目的，一个图标一般来说太大了，因此， ActiveX 标准建议，在控件的资源数据中包括 16 × 16 位图图像。提供这种资源的控件通过类的注册表数据中的 ToolboxBitmap32 键来宣告自己。在下一章中，我们还要遇到这个键。

将项目配置设为 W in32 Release ，并且从 Build 菜单选择 Build 命令。当源码成功编译和链接之后， Visual C++ 将自动注册这个控件。如果你想不将 Tower 作为项目创建便拿它做试验，那么，在使用它之前你必须注册该控件。如果想注册Tower ，首先应将 Tower.ocx 文件复制到硬盘（如果必要的话），然后运行 RegSvr32 实用程序：

regsvr32 path\tower.ocx

其中， path 代表 Tower.ocx 文件在硬盘上的位置。

本书配套光盘上的 Game 程序为试验新的 Tower 控件提供了最方便的方法。Game 具有用于显示 Tower 的 About 框、复位游戏以及列出游戏规则的按钮。程序还可以连续不断地显示游戏状态，这是通过监视 Tower 的 FromPanel， ToPanel, Error 和 W inner 事件来实现的。 Test Container 实用程序提供了另一种方法来用 Tower 控件做试验，并且能够比 Game 程序展现该控件更多的内部工作过程。正确注册了控件之后，运行 Test Containe r，单击 New Control 按钮，从如下的列表中选中Tower 控件：

第四部分 A ctiveX 控件 - 图44

Insert Control 对话响应键盘条目，让你通过按控件名的第一个字母来快速滚动列表。例如，按下 T 可以立即把选择条放在 Tower 控件条目上。

通过双击控件边框，可以试一试 Tower 的属性表。 MFC 框架已经添加了属性页，你可以在里面修改用于在 Tower 窗口中显示标题的控件和字体。图 9-13 显示了在控件的属性表中展现的 Font 页。在对话的其他三个选项卡中， Caption 选项卡

用于显示在步骤 6 中修改的属性页。当你为标题键入新文字的时候，变化立即在控件的窗口中反映出来。

第四部分 A ctiveX 控件 - 图45

图 9-13 Tower Control Properties 属性表

Test Container 可以显示 Tower 事件的实时记录，当你调试一个 ActiveX 控件的时候，这是非常宝贵的。向上移动分隔栏，以为事件日志展现更多的空间，然后从Tower 的第一个面板中拖动一个块，并把它放到另一个面板之中。作为对拖放操作的响应， Tower 触发 ClickFromPanel 和 ToPanel 事件，当它们发生的时候，在事件日志中均有记录。如图 9-14 所示，日志中的每个条目均以下一个用来指示事件在哪个控件发生的标签作为开头。既然 Test Container 可以嵌入多个控件，那么，利用标签，在事件很多时，日志条目仍可以保持直观。

第四部分 A ctiveX 控件 - 图46

图 9-14 在 Test Container 中监视事件

向 ActiveX 控件项目添加属性页

正如我们在开发 Tower 控件时所看到的，ControlWizard 可以为 ActiveX 控件生成一个单一属性页，来补充 MFC 提供的库存页。对于 Tower 项目，一页就足够了，原因是 Caption 是需要自定义属性页的唯一一个可修改的属性。不过，带有多个属性数据的 ActiveX 控件可能需要其他的页来将数据展现给用户。每个附加页都需要在属性页映射中具有它自己的对话资源类和条目。最后一节列出了向ActiveX 控件项目添加新属性页的必要步骤，使用 Tower 控件作为例子。

在项目处于打开状态的时候，单击 Insert 菜单上的
Resource 命令，并双击列表中的 D ialog 来启动对话编辑器。你还可以展开对话资源列表，并选中 IDD_OLE_PROPPAGE_LARG E。和以前一样，新属性页的大小并不重要。按照你所希望的那样设计新属性页，然后在工作区中选中对话窗口，并单击 View 菜单上的 Properties 命令，来展现 D ialog Properties 框。在 Styles 选项卡中，关闭 Titlebar 复选框，将对话样式设为 Child ，禁用边框。如果你选中了 IDD_OLE_PROPPAGE_LARGE ，来启动对话编辑器，这些设置就已经为你做好了。Styles 选项卡应该是下图的样子：

第四部分 A ctiveX 控件 - 图47

按 Ctrl+S 来保存新对话资源，然后单击 View 菜单中的
ClassWizard 命令。当询问你是否愿意为对话资源创建一个新类的时候，单击 O K 按钮表示接受。为新类键入一个名字，选择 COlePropertyPage 作为基类：

第四部分 A ctiveX 控件 - 图48

为新页添加所需要的所有成员变量，然后退出
ClassWizard 。在TowerCtl.cpp 实现文件中，为 ClassWizard 刚刚创建的属性类头文件添加一条 #include 语句，如下：

# includ e "TowerPPG2.h" .

正确的文件名出现在 New Class 对话的 File Name 框中，在 TowerCtl.cpp 文件中，还要为新页的属性页映射添加一个条目。对于 Tower 控件，添加部分应该是这个样子：

BEGIN_PROPPAGEIDS(CTowerCtrl, 4)

PROPPAGEID(CTowerPropPage::guid)

PROPPAGEID(CTowerPropPage2::guid ) PROPPAGEID( CLSID_CColorPropPage )

PROPPAGEID( CLSID_CFontPropPage )

END_PROPPAGEIDS(CTowerCtrl)

记住，要在映射第一行中的 BEGIN_PROPPAGEIDS 宏中增加页数。新页数是 4 。

在文本编辑器或字符串编辑器中打开项目的 RC 文件，
并添加两个字符串资源。第一个字符串用来标识系统注册表中已注册的属性页，第二个字符串用来保持在属性表对话中出现的选项卡标签：

STRINGTABLE DISCARDABLE BEGIN

IDS_TOWER "Tower Control"

IDS_TOWER_PPG "Tower Property Page"

IDS_TOWER_PPG_CAPTION "Caption"

END

如果你在上一步中使用文本编辑器来创建新字符串资
源，那么请向Resource.h 文件为 IDS_TOWER_PPG2 和IDS_TOWER_PPG_NEWPAGE 常数添加定义：

如果你在上一步中使用的是字符串编辑器，那么添加这些行就不是必要的了，因为 Visual C++ 在你保存字符串资源的时候会自动写下定义。

在文本编辑器中，打开 ClassWizard 为新属性页类创建的
实现 CPP 文件。搜索这里的源代码，在每个阴影行中，用字符串标识符代替 0 参数。

BOOL CTowerPropPage2::CTowerPropPageFactory

::UpdateRegistry(BOOL bRegister)

{

if (bRegister)

return AfxOleRegisterPropertyPageClass( AfxGetInstanceHandle(), m_clsid, IDS_TOWER_PPG2);

else

return AfxOleUnregisterClass(m_clsid, NULL);

}

CTowerPropPage2::CTowerPropPage2(): COlePropertyPage(IDD,IDS_TOWER_PPG_NEWPage)

{

在做出这些改变之后，重建 Tower ActiveX 控件可以向控件资源添加新属性页。这里是新属性页的一个例子，这主要取决于你在本练习的第一

步中的设计。

第 10 章用 ATL 编写 ActiveX 控件

第 9 章演示了使用 MFC 轻松地编写 ActiveX 控件，但需要指出的是，其方便性的代价是，可执行部分过于庞大。对于 ActiveX 控件来说，它适于小文件，特别是在万维网上应用程序时，这点非常重要。幸运的是， Visual C++ 在 MFC 之外还提供了其他工具。这一章就是要讨论一个非常流行的 MFC 替代工具，叫做Active Template Library （活动模板库）。

Active Template Library 通常简称为 ATL ，它提供了一套范围很广的 C++ 类模板

（注： C++ 类模板也叫做参数化的类型，它是一种高级的宏格式，编译器根据传递到模板的参数，扩展为正常的类定义。模板与使用 #define 语句创建的宏不同，它扩展为普通的类型，使它们成为类型安全的类。编译器可以监视程序模板化的类的使用，就像它对普通的类一样，而且，可以正确识别出任何不一致类型的情况），用于开发可嵌入在 C O M 应用程序中的服务器目标。在 ATL 的第 3 版中， ATL 辅助编写各种类型的 COM 目标，甚至可帮助生成包容器程序；在这一章里，

主要讨论怎样使用	ATL 开发 ActiveX 控件。这里的目的是继续说明第	9	章所讨
论的问题，说明用	MFC 之外的方法来开发制作 ActiveX 控件。

MFC 简化了 ActiveX 控件的开发，但不可避免地会出现大量的 MFC 库 DLL ，这

对于制作网页是不合适的。为了解决这个问题， Microsoft 已经增强了 ATL ，其方法是为 ActiveX 控件添加特殊的支持。当前，选择开发 ActiveX 控件项目所使用的工具一般要遵守的原则是：

在开发如第 9 章所述的 Game 程序的一般包容器应用程

序时，考虑使用 MFC 。当包容器本身同 MFC 有较强的联系时， MFC 作为开发工具是很有吸引力的，因为控件不负责加载库。也就是说，它早已做出了补偿。
应用在 Internet 的 ActiveX 控件则使用 ATL 。

这一章将比前两章更详细地讨论 COM ，还详细地介绍使用 ATL 编写复杂的ActiveX 控件，而不把更多的精力放在 C O M 上。 ATL 不像 MFC ，它让开发者离C O M 的表面更近，而不是在它下面。

ATL 和包容器应用程序

尽管 ATL 不是本章的主题，但它对包容器编程的支持值得说两句。ATL 在 C O M 编程中的作用比较突出，但它倾向于对服务器的开发，而不是客户。库提供两类模板，分别叫做 CComPtr 和 CComQIPtr ，这两类模板证明对编写客户端代码非常有用。这些模板生成灵活的接口指针，可设计来保证客户正确地释放控制接

口，即使有异常错误打断了正常的运行流程。

首先看问题，再看解决方案。包容器用控件的 QueryInterface 方法去调用控件的QueryInterface 方法，来请求控件提供的接口指针。唯一的限制是当完成使用接口时，包容器就需要调用接口的 Release 方法，通知控件这个接口已不需要了。不能执行 COM 这一基本规则，将导致控件目标在系统的内存池中保存，甚至在包容器终止之后仍然存在。使用一个代码段可以演示包容器如何需要指向控件接口的指针，以 IOleObject 为例：

void Function1(Iunknown* pUnk)

{

IOieObject *pOleObj;

pUnk->QueryInterface(IID_OleObject,(PVOID*) &pOleObj );

. // Use the IOleObject interface

pOleObj->Release(); //When finished,release it

}

如果在最后一行调用 IO leObject::Release 让该接口终止前，有一个异常错误让程序结束的话，这段编码就会出现麻烦。如果把 pOleObj 当作智能指针就会解决这一潜在问题，因为这一指针的破坏程序调用该接口的 Release 方法，当 IOleObject 在使用中时，即使程序突然中止，它仍能够运行。

void Function1(Iunknown* pUnk)

{

CComPtr<IOleObject> pOleObj; pUnk-> QueryInterface(&pOleObj );

. // Use the IOleObject interface

} // Release called automatically

两个程序段的明显区别是，修改过的版本在停止使用 IOleObject 时，没有明确调用 IO leObject::Release 。当 pOleObj 脱离作用域时，因为 Function1 正常返回或出

现错误，指针的破坏程序就承担起释放接口的任务。

把 pOleObj 当作智能指针还有另外的优点。现在，检索接口指针 pUnk 将更简单，原因是 CComPtr 提供其本身的 QueryInterface 函数，从 pOleObj 中推出接口的标识符。通过确保标识符 (IID_OleObject) 和目标指针 (pOleObj) 指向同一接口(IOleObject) ，它使编码更方便，也增加了安全性。可避免犯以下这样可笑的错误：

pUnk-> QueryInterface( IID_ThisObject, (PVOID*) &pThatObject);

CcomPtr::QueryInterface 能够通过应用程序 __uuidof 运算符让接口标识符不指向指针 (UUID 为 universally unique identifier( 通用唯一标识符 ) 的缩写 )。在编译时确定标识符， __uuidof 取消了多余的编码同定义标识符的程序间的链接。总的效果是减少了运行大小。例如，在前面 Function1 的第一个版本中，可以用以下两行的任意一行 __uuidof 代替调用 QueryInterface 。

pUnk-> QueryInterface(__uuidof(IOlebject),(PVOID*)&pOleObj); pUnk-> QueryInterface(__uuidof(pOleObj), (PVOID*)&pOleObj);

Iunknown 是客户最终很少需要的接口，但它是客户能肯定 ActiveX 控件可支持的唯一接口。获得一个接口可分两个步骤：首先调用程序得到一个 Iunknown 指针（在分段代码中的 pUnk ），然后调用 Iunknown::QueryInterface 检索实际需要的接口指针。 ATL 提供另一个智能指针把这两个步骤合二为一。 CComQIPtr 模板

在构造器包含对 Iunknown::QueryInterface 的调用。以下是一个 ATL 的 CComQIPtr 模板的简要列表，显示构造器怎样得到所要的接口指针和破坏程序在以后如何释放它。

template <class T, const IID* piid = &_unidof(T)> class CComQIPtr

{

public:

T* P;

CComQIPtr(Iunknown* lp)

{

p = NULL;

if (lp != NULL)

lP-> QueryInterface( * piid, (void ** )&p );

}

～ CComQIPtr()

{

if (p)

p->Release();

}

CComQIPtr 模板为调用程序提供了一个更为简洁的方法从控件得到一个接口指

针。如果控件不支持所需接口，指针类的 p 成员为 NULL 。

CComQIPtr <IOleObject> pOleObj; pOleObj = pUnk;

if (pOleObj.p)

{

. // Use the IOleObject interface

}

调用程序可使用 CComQIPtr 为除了 IUnknown 之外的任何接口生成指针。要为

Iunknown 接口生成指针可使用 CComPtr 。

CComQIPtr 和 CcomPtr 模板受到 Standard Template Library （标准模板库）中的auto_ptr 智能指针类的启发，它确保了通过 new 分配的目标返回到程序的空闲空间。尽管模板主要对使用 ActiveX 控件的客户应用程序有好处，它们也可很容易地为控件本身服务，特别是控件聚集或包含另一个控件时。本章稍后会介绍一个

例子，来说明 ActiveX 控件如何利用智能指针。

ATL 对客户编程的支持是非常被动的，它只包括项目中的源代码文件。这些文件可通过其 A tl 前缀识别，存储在 VC98\ATL\Include 文件夹中。例如，一个使用CComQIPtr 和 CcomPtr 的包容器项目访问 MSDN 的 Samples\VC98\ATL 文件夹中的 A tlCon 项目。ATL 对开发类似 ActiveX 控件的服务程序的帮助远不止这些，本章其余部分将集中介绍 ATL 的这一方面。

ATL 和 ActiveX 控件

从技术上说， ActiveX 标准对控件的能力要求不高。作为 ActiveX 控件运行，一个组件只需要实现 Iunknow n，可嵌入，而且可以自我注册。其他诸如属性、方法和事件均是可选的。由于过于微小，而且是隐性的，一个 C O M 目标在学术之外没有讨论的价值。实际上，一个 ActiveX 控件维持一组数据；激发事件；并支持足够的接口，让用户应用程序和它交互。 ActiveX Test Container（ ActiveX 测试包容器）功能对于 ActiveX 控件来说就像是石蕊试纸。本章开发的两个控件项目能够成功地在 Test Container 中运行，因为它们插入了在表 10-1 描述的接口。所列的接口是 ActiveX 控件为同公布的 M icrosoft 指南相兼容所必须提供的支持。比较表 10-1 和表 8-2 ，其中列出了要嵌入 ActiveX 控件，一个包容器必须支持的接口。

如果希望 ATL 很容易地创建一个只有几 K 大小的 ActiveX 控件，一定会很失望。库提供了几种方法来减少运行量，但实现表 10-1 所列的接口会加入大量的编码。创建短小编码的唯一方法就是直接使用 C O M 编程，而不借助于 ATL 和其他支持库（ Visual C++ 的 Samples\VC98\ATL 文件夹中有一个叫做 M inimal 的 ATL 项目范例，创建了一个小 C O M 服务器程序只有 5600 个字节。M inimal 服务器缺少几个基本特征，并不是为了创建真正的 ActiveX 控件）。与 MFC 一样， ATL 带来了方便，也带来了大量冗长无用的编码。做一些额外的工作，就可以得到一个简单的无窗口的 ActiveX 控件，例如只有 40KB 大小或更小。本章稍后会介绍几种帮助减少用 ATL 控件大小的方法。

表 10-1 ActiveX 控件必须支持的接口，以同指南相兼容接口说明

IOleObject 与控件的客户站点通信所需要的，事件除外。

事件通过 IConnectionPointContainer 接口进行处理，在下面将说明

IOleInPlaceObject 通过在适当位置激活的控件来实现，并提供它

们自己的用户接口。需要 IOleObject 的支持

IOleInPlaceActiveObj ect

只有在控件提供用户接口，而且支持

IOleInPlaceObject 的情况下才需要

IDataObject 以某种方式传送数据到包容器的控件需要

它，如共享内存或文件。IDataObject 提供 COM 的 Uniform Data Transfe r（统一数据传输）的手段，这是一种协议，用于为任何数据类型的交换建立规则

IViewObject2 通过显示窗口的可见控件来实现

续表

IDisPatch 具有定制方法或客户可以通过

Idispatch::Invoke 来访问的控件需要它

IConnectionPointCont ainer

启动事件的控件需要它。这个接口为客户枚举控件目标可以启动的事件

IConnectionPoint 支持 IconnectionPointContainer 的控件需要

IProvideClassInfo 由包含类型库信息的控件实现，这意味着大多

数 ActiveX 控件。通过其 GetClassInfo 方法，接口提供了到 ITypeInfo 实现

的指针，从中，客户可以抽取控件的类型信息。类似的

续表

IProvideClassInf

接口是一个扩展接口，它扩充了 GetGUID 方法，这样，客户便可以为控件的默认事件来检索到标识符的指针

IPersistStorage 可以保存和从包容器提供的 Istorage 实例加载

的控件需要它

IClassFactory 实例化一个要求的类目标，将返回给它一个指

针。此目标是通过在系统注册表中注册的类标识符来进行标识

IClassFactory2 与 IClassFactory 相同，但是，它还增加了许可

证的支持（参见第 9 章的 “ 许可证 ” 一节）

另一方面，当考虑到与控件有关的大量 MFC 库 DLL 时，用 ATL 编写的 ActiveX 控件比用 MFC 编写的相应的 ActiveX 控件要小得多。用 ATL 库构造的 ActiveX 控件可使用 MFC ，但这样用 ATL 就没有意义。如果计划用 MFC 编写控件，可以首选 MFC ControlWizard ，只有在创建智能指针类 CComQIPtr 和 CcomPtr 才会使用 ATL 。使用 ATL 的主要好处是，它所创建的组件不需要 MFC 和 C 运行库。

这样的组件可放在 Internet 上独立存在，而不用依靠用户机器上的支持文件。

与 MFC 一样， ATL 为控件包含的每一个目标创建单一的代表性的类。这些类来源于目标支持的所有接口，这是 MFC 通过嵌套类玩的一个小把戏。 ATL 可通过使用多样继承更灵活地达到同样的效果，这些继承是几个基类发展出来新的类，新类从每个类继承了成员数据和函数。基类列表叫做继承列表，看起来像以下的类声明：

class CMyClass: public CClass1, public CClass2, public IInterface1,

public IInterface2,

{

ATL 为开发 ActiveX 控件提供最重要的服务是许多库的实现代码，这些代码用于控件通常支持的许多 COM 接口。以类模板的形式，有了库代码，就不用再编写程序来支持通用的接口了。 ATL 为列在表 10-1 中的每一个接口提供了模板化的实现代码，并以接口名加上 Impl 后缀来命名该模板。例如， IQuickActiveImpl 模板为 IQuickActive 方法提供如 SetExtent 和 GetExtent 这样的代码。与 COM 要求的那样，一个支持接口的所有方法都列出来，但不一定使用。许多方法只叫做ATLTRACENOTIMPL 宏，为 Visual C++ Output（输出）窗口的 Debug 选项卡编写很少的记录信息，并把 E_NOTIMPL 返回给调用程序。如果想让 ActiveX 控件提供这样的方法，则必须自己添加代码。

除了代码库外， ATL 还提供 AppWizard ，以开始创建一个服务器项目，还有另一个向导，用来帮助生成 ActiveX 控件所需的类代码。你会感觉到，使用 ATL 并不比使用 MFC 困难， ATL 需要编程人员比使用 MFC 时多注意项目细节，并处理更多的 COM 问题。在展示 ATL 的演示项目前，先停顿一下，了解一下后面会遇到的有关 ATL3 个方面的背景信息：接口映射，目标映射和线程模型。

接口映射

接口映射是大多数 QueryInterface 函数的通用模式。C O M 目标的所有接口都支持这一函数，让包容器应用程序在任何接口中调用 QueryInterface ，并接收其他任何接口的指针。如果控件不支持所需的接口，它返回的值为 E_NOINTERFACE 。

以下程序段演示了一个典型的 QueryInterface 函数在不使用 ATL 时看起来会是什么样。参数 riid 指调用程序所需的接口标识符，参数 ppvObject 接收接口指针：

STDMETHODIMP CMyClass::QueryInterface( REFIID riid,PVOID *ppvObject )

{

switch( riid)

{

case IID_UNKNOWN:

case IID_IInterface1:

*ppvObject = (IInterfacel*) this; break;

case IID_IInterface2:

*ppvObject = (IInterface2* this;

break;

case IID_IInterface3:

*ppvObject = (IInterface3*) this; break;

default:

*ppvObject = 0;

return E_NOINTERFACE;

}

(IUnknown*) *ppvObject->AddRef(); return S_OK;

}

这类重复的模式很容易用宏来实现，了解宏，便可对接口映射的物理分布有清楚的认识。当用户调用类目标的 QueryInterface 方法时，接口映射通过 ATL 的CComObjectRootBase::InternalQueryInterface 函数来确定调用的路线，在 AtlCom.h 文件中，如下处理：

static HRESULT WINAPI InternalQueryInterface(PVOID pThis, const_ATL_INTMAP_ENTRY *pEntries,REFIID riid, PVOID *ppvObject)

同以前一样， riid 确认接口， ppvObject 接收它的指针。该函数的第二个参数pEntries 指向接口映射的开始，它包含 _ATL_INTMAP_ENTRY 数组结构，数组中的每一个结构包含一个接口标识符，一个 DWORD 变量，还有一个函数指针：

struct _ALT_INTMAP_ENTRY

{

const IID*	piid;	//Interface iedntifier
DWORD	dw;	//Offset
_ATL_CREATORARGFUNC*	pFunc;	Function pointer

};

pFunc 的值决定 InternalQueryInterface 如何解释 dw 的值。如果 pFunc 是ATL_SIMPLEMAPENTRY( 定义为 1) ， dw 则包含类目标的偏移值，允许InternalQueryInterface 完成类似以下的调用：

*ppvObject=pThis+pEntries->dw;

*ppvObject->AddRef();

PEntries 已经增加值，以指向数组中接口 _ATL_INTMAP_ENTRY 结构。如果

pFunc 的值大于 1 ，则 InternalQueryInterface 调用函数，把 dw 作为参数。

Pentries->pFunc( pThis, riid, ppvObject, pEntries->dw);

所调用的函数负责编写所需的指向 *ppvObject 的接口指针。

Pfunc 成员也可为 NULL 。这个特殊值为数组中最后的 _ATL_INTMAP_ENTRY 结构所保留，作为接口映射的结尾标记。你没有必要过分担心这一部分， ATL 通过特殊的宏来确保最后的结构。另外，在安排映射数组的

_ATL_INTMAP_ENTRY 结构方面没有限制。以下是前面所引述的 CmyClass 的接口映射。注意，一个空的 _ATL_INTMAP_ENTRY 结构是如何结束数组的：

{&IID_Interface1, 0, 1}

{&IID_Interface 2, 4, 1}

{&IID_Interface 3, 8, 1}

{0, 0, 0 }

在使用 ATL 的代码中，接口映射由一系列的 COM_INTERFACE 宏构成，每个宏扩展为一个 ATL_INTMAP_ENTRY 结构。 ATL 提供 17 种不同的COM_INTERFACE 宏，通过其后缀 _ENTRY 和 _TEAR_OFF 来表明宏要处理的接口类型。宏的名称由 COM_INTERFACE 加上后缀字符串构成。表 10-2 将描述COM_INTERFACE 宏，并解释什么时候使用它们。为简明起见，第一列只列宏后缀名。要想详细了解宏，请参阅在线帮助 “ COM_INTERFACE_ENTRY M acros ”。

表 10-2 ATL 的 COM_INTERFACE 宏

COM_INTERFACE 说明

宏

_ENTRY 暴露衍生类的接口

_ENTRY_IID 与 COM_INTERFACE_ENTRY 相同，但是，

压指定接口的标识符

_ENTRY2 对于从两个或多个双接口衍生的类，要解析其

接口的不明确性，应当提供到 Idispatch 接口的指针。双接口在本章的后面介绍

_ENTRY2_IID 与 COM_INTERFACE_ENTRY2 相同，但是，

它指定接口的标识符

_ENTRY_IMPL 是 COM_INTERFACE_ENTRY 的另一种方法

续表

_ENTRY_IMPL_IID 与 COM_INTERFACE_ENTRY_IMPL 相同，

但是，它指定接口的标识符。此宏和

COM_INTERFACE_ENTRY_IMPL 在 ATL 版

本 3 中是过时的，要使用

COM_INTERFACE_ENTRY

_ENTRY_FUNC 在 ATL 处理 QueryInterface 时，指定获得控件

的挂钩函数。挂钩函数可以忽略此进程，方法是返回

E_NOINTERFACE ，这样，便可以隐藏 ATL

要返回的接口

_ENTRY_FUNC_BLI N D

与 COM_INTERFACE_ENTRY_FUNC 相同，

只是要查询引起挂钩函数调用的所有接口

_ENTRY_TEAR_OF F

_ENTRY_CACHED

_TEAR_OFF

_ENTRY_AGGREGA TE

续表

为快用（ tear-off ）接口声明 C O M 映射项，这种接口只有在客户通过 QueryInterface 请求时，才进行实例化。这种接口只在需要时才占用内存，这使它更适合于 ISupportErrorInfo 这样的接口，因为在控件的生存期，这样的接口也可以不使用。其缺点是，它比常规接口的开销要稍大些

实现这种接口的类必须从CComTerzaOffObjectBase 衍生出来，而且具有自己的 C O M 映射

与 COM_INTERFACE_ENTRY_TEAR_OFF 宏

相同，不同的是，在第一个实例后，保存此接口数据。如果快用接口是实例化的，则有效地缓存可以将它转换为常规接口

为聚合目标提供的接口声明 COM 映射。此宏查询转发到聚合目标的 IUnknown 接口的接口标识符。本章的后面将讨论有关聚合的问题

_ENTRY_AGGREGA TE_BLIND

_ENTRY_AUTO- AGGREGATE

续表

与 COM_INTERFACE_ENTRY_AGGREGATE

相同，不同的是，所有查询都转发到指定的

Iunknown 接口

如果提供 IUnknown 指针，则与

COM_INTERFACE

_ENTRY_AUTOAGGREGATE 相同，否则，此宏自动插件由给定的类标识符指出的聚合

__ENTRY_AUTO-

AGGREGATE_BLIN D

与

COM_INTERFACE_ENTRY_AUTOAGGREG

ATE 相同，除非提供了 IUnknown 指针，在这样的情况下，所有查询都转发到 Iunknown 接口，如果 Iunknown 指针没有提供，则宏创建由给定的类标识符指出的聚合

续表

_ENTRY_CHAIN 允许继续处理指定的基本类的 COM 映射。基

本类必须在当前类的继承性列表中出现。也就是说，它必须是当前类的基础。COM_INTERFACE_ENTRY_CHAIN 不能是

C O M 映射中的第一项

_ENTRY_BREAK 在请求指定的接口时，调用 DebugBreak。使用

此宏来触发调试器断点（调试器在第 11 章中介绍）

_ENTRY_NOINTER- FACE

在查询指定的接口时，返回E_NOINTERFACE ，并结束 C O M 映射处理。此宏禁用此接口，防止它被 COM 映射后的任何 COM_INTERFACE 宏进行处理

ATL 指作为 C O M 映射的源代码的宏系列，这一名称常常和宏所创建的接口映射混用。在 ATL 中， C O M 映射以调用 BEGIN_COM_MAP 宏开始，以END_COM_MAP 宏结束。在它们之间有一系列的 COM_INTERFACE 宏，都有类支持的接口。

BEGIN_COM_MAP(CMyClass) COM_INTERFACE_ENTRY(IMyClass) COM_INTERFACE_ENTRY(IDispatch)

COM_INTERFACE_ENTRY2(IPersist, IpersistStreamInit)

END_COM_MAP()

映射从 MFC 的标准消息映射中借鉴了许多方法（ MFC 提供自己的宏来创建接口映射，这一点在第 9 章没有叙述。在 MFC 中，接口映射以 BEGIN_ INTERFACE_MAP 宏开始，以 END_INTERFACE_MAP 宏结束）。 COM 映射的结构顺序并不重要，列表中的第一个接口必须使用简单的映射项，例如COM_INTERFACE_ENTRY 或其他 COM_INTERFACE 宏，用

ATL_SIMPLE_MAPENTRY 的 pFunc 值扩展至 ATL_INTMAP_ENTRY 结构。这个需求阻止了 ATL 使用映射中的第一个接口来响应目标的 IUnknown 接口的请求。

目标映射

个 ActiveX 控件可能包含几个目标，每个目标都通过一
个类来表示，提供自己的接口映射。图 10-1 显示了控件、控件所包含的目标和目标实现的接口之间的层

第四部分 A ctiveX 控件 - 图49

图 10-1 ActiveX 控件的元素

次关系。同接口映射的概念一样，目标映射记录了一个控件的目标和目标相关的类标识符（ CLSID ）。 ATL 把目标映射安排成一个 _ATL_OBJMAP_ENTRY 结构数组，每一个定义一系列求助功能。以下是一个简单的 _ATL_OBJMAP_ENTRY 结构数组：

struct _ATL_OBJMAP_ENTRY

{

HRESULT UpdateRegistry( BOOL bRegister );

HRESULT GetClassObject( void* pv, REFIID riid,PVOID* ppv); HRESULT CreateInstance( void* pv, REFIID riid,PVOID* ppv); LPCTSTR GetObjectDescription();

HRESULT RevokeClassObject();

HRESULT RegisterClassObject( DWORD dwClsContext,DWORD dwFlags);

};

当客户第一次请求一个类目标时，便调用 GetClassObject 函数，生成一个目标实例，向调用程序提供了一个指针，来指向所需要的 IClassFactory 或 IClassFactory2 接口。函数在目标映射结构中存储类工厂（ class factory ）指针，让下一个调用类目标新实例的需求尽快完成。因为类目标在栈和堆上进行实例化，而不是在控件的静态数据中，所以，用 ATL 构造的 ActiveX 控件不需要同 C 运行库进行链接。不使用 C 运行库和静态构造器，可以保证最终控件的可执行尺寸很少，不用对链接的 C 库进行额外的初始化。

线程模型

ATL 支持四种线程模型，分别名为单一（ single ）、公寓（ apartmen t）、自由（ free ）和两种（ both ）。线程模型描述了一个控件实现的线程安全类型和程度，尽管对于任何客户应用程序，无论线程安排是怎么样的，都可安全地进入任何线程模型生成的控件。如果客户的线程与任何线程模型都不兼容，则 C O M 便会在二者之间实现自身，以保证线程的安全通信。有了这个保证，为自己的控件选择哪种线程模型就会很简单了。对于每一种选择，都有其各自的优缺点，通常，性能与代码的大小是相对的，效率与简化是相对的。ATL 添加到项目中的代码支持用户选择的线程，所以，你只需要保证自己编写的代码也与所选择的模型相符。在本节中，将解释 4 种模型之间的不同之处，以帮助你决定哪一种最适合你的项目。

从客户的角度来看，很容易想象线程是怎样的。开始，我们来看看应用程序于包容器的线程模型，然后，检查每种线程模型对应用程序嵌入的 ActiveX 控件的影响如何。线程模型并不难以理解，但是，其中的规则却有些不好理解。在本章的后面，有一个示例项目，它应用这里讨论的一些理论，并说明一种控件在不同的线程模型下是如何起作用的。

单一线程

单一线程模型是四种线程中最简单的，因为它不需要任何控件来防卫其数据的模拟使用，即使是静态数据。这种模型允许客户创建一个控件项目的任何数目的实

例，但是，它限制在一个线程中，所有客户都访问这些实例。单一线程不限制客户可以运行的线程数目，而且，确实， ActiveX 控件应当假定其许多客户都是多线程的。这种模型只是指示对目标接口的所有调用都从客户的线程中产生，这个线程是第一次调用 CoInitializeEx 来初始化 C O M 框架的线程。由于 ActiveX 控件不需要耗费其他精力来保证线程对其接口或其他数据的访问是安全的，所以，单一的线程是在四种线程模型中尺寸最小的。只要客户符合此模型的限制条件，在客户和服务器之间进行通信就是直接而快速的。

但是，考虑一下，在客户使用相同的 AvtiveX 控件时，在两个线程之间会发生什么。线程 A ，它不是客户的主线程，通过 CoInitializeEX 来初始化 C O M ，然后调用 CoCreateInstance ，来创建控件目标的一个实例。线程 B 随后需要此控件的服务，与线程 A 一样，它创建一个新的线程实例。但是，在这一次， COM 不像线程 A 调用 CoCreateInstance 那样，返回直接指向控件代码的接口指针。而是，返回的指针引用一个在线程 B 上运行的不可见的代理服务目标。在客户使用指针从

线程 B 来调用一种方法时，代理服务便会发送一条消息给线程 A 上运行的存根目标。存根依次直接调用到相同线程上的 ActiveX 控件，然后，通过另一条消息传递返回值给代理服务。消息的交换在线程之间进行，而且保证 ActiveX 控件总是在线程 A 的环境中执行，也就是第一次初始化 COM 的线程。

从一个线程中重新确定一个调用的路线，并在另一个线程中完成它，这便是线程间调度，从概念上来说，它与第 8 章讨论的进程间调度类似。主要的不同是代理服务和执行线程间调度的存根目标是由 C O M 设置的隐藏目标，而不是在单独的进程中安装的动态链接库。窗口之间的消息传送与远程过程调用类似，它在客户进程内的代理服务和进程外的存根之间来回传递。线程之间的调度通常要比进程之间的要快，但是，与直接调用目标相比，交换消息和切换线程的环境还会大大减慢对目标实例的访问速度。每次客户从线程 B 调用控件的一种方法时，为了调度到对线程 A 的调用，还要重复相同的繁琐过程。最糟糕的是，线程 A 可能会非常忙，没有在其消息循环中，这样，代理服务提出的消息就必须进行等待，直到其抽取和路由到存根。对线程 A 生成的客户的所有方法调用，都直接到控件中，而且不进行调度，这使得线程 A 具有了特殊的权限，而其他使用此控件的线程都没有授予此权限。只有在客户从不是第一个通过 CoInitializeEx 用 C O M 注册自身的线程调用控件时，单一线程模型才会得到性能上的损失。

公寓线程

公寓线程模型为了消除线程间的调度，做了很多的工作。在这种安排方法下，所有的客户线程都享有特权，而且能够直接与 ActiveX 控件的实例交互，而不需要首先通过代理服务和存根服务。换句话说，每个公寓线程都像是前面讨论的线程A ，没有一个线程像线程 B 那样。需要控件服务的每个线程都首先调用CoInitializeEx，与以前一样，然后调用 CoCreateInstance ，来创建一个控件实例。在此公寓线程中，返回的接口指针直接指向接口实例化目标中的 V 表，而且不

进入代理服务。每个线程都具有自己的目标实例，只要线程只访问它创建的实例，就不会有调度发生。

有时，人们会产生混淆，这是因为有两类公寓线程。 ATL 所说的 “ 公寓 ” 模型更像是单一线程的公寓模型，通常缩写为 STA 。这种模型在前面已经介绍了：每个线程都有一个目标实例，每个线程都调用自己的实例。多线程的公寓模型，即M TA ，就是 ATL 称之为自由模型的公寓模型，稍候我们将介绍这种模型。公寓是一个抽象的概念，它与现实世界进程和线程的处理方法的关系不大，所以，不要浪费很多时间来试图将它可视化。可以这样来看，一个进程就像是一个建筑物，其中，线程表示单独的房间。这种模型将一个目标的单一实例与可以直接安全调用到那个实例的一个或多个线程进行折衷。

尽管我们通常要讲到 STA 或 M TA 客户应用程序，模型的指定可以更精确地应用到应用程序中的线程，因为进程可以包含 STA 和 M TA 线程。在客户线程调用CoInitializeEx 时，它将传递一个值，这个值指定此线程是为哪种公寓模型而设计的。 COINIT_APARTMENTTHREADED 的值在 STA 模型下注册线程，也就是单一线程公寓的方法。 COINIT_MULTITHREADED 的值注册线程作为多线程公寓的一部分。一个进程可以包含任何数目的单一线程公寓，但只能包含一个多线程的公寓，在多线程公寓中，任意数目的线程都可以属于它。在公寓内部调用线程时，从目标检索的接口指针不进行调度，但是，在使用其他公寓中的线程时，总是要进行调度。在谈到单一线程公寓模型时，公寓和线程这两个词经常互换使用，不会引起混乱，但是，在实际应用程序中，在应用到多线程公寓模型中时，

这就不对了，下面将讨论这个问题。自由线程

自由线程是多线程公寓模型的另一个名称。在多线程公寓中的线程可以安全地共享目标的单一实例所提供的接口指针，而不管创建实例的线程是什么。 COM 在此方法中不起作用，而且，在公寓的限制内，不发生调度调用。然而，与在单一线程模型中一样的是，在线程调用到在另一个公寓中实例化的目标时，还需要进行调度。

这似乎是足够了，但是，自由线程将重大的责任都放到了开发者身上。选择支持自由线程模型意味着，在任何时间，要编写任意数目的线程安全访问的代码。下一节将介绍每个线程对 ActiveX 控件施加影响的一些需求。

为 ActiveX 控件选择线程模型

理解 C O M 的客户端口的线程模型，便可以选择最适于 ActiveX 控件的线程模型。幸运的是，服务器中的线程涉及到更到的代码，而且，理论概念更少。你只需要为自己的控件选择一种线程模型，并根据情况来编写代码，保证 C O M 将通过调度来解决任何不匹配的问题。客户线程与 STA 或 M TA 模型是一致的，但是， ActiveX 控件采用了前面列出的四种模型之一：单一（非线程），公寓（ STA ），自由（ MTA ）或两种。两种线程模型意味着 STA 和 M TA ，也就是说，必须写控件来适应客户线程的两种可能模型，而不需要 C O M 来调度其交互作用。

我们已经看到了，在调用 CoInitializeEx 时，客户线程如何对 COM 识别其模型，但是， ActiveX 控件的主线程是接收客户调用的线程，它并不需要注册自身。这是很有意义的，因为毕竟我们讲过，只有一个线程沿着程序逻辑流从客户到ActiveX 控件，而且再回来，而不通过调度程序进行传递。控件通过其系统注册表中的条目来来识别其线程模型，这些条目可能是 apartment( 公寓 ), free（自由）或 bot h（两种）。如果这个条目不存在， C O M 就假定控件符合单一线程模型。本章中以后的项目演示了 ActiveX 控件如何在注册表中指定其线程模型。

学完了线程模型这些难以理解的内容后，我们至少可以处理一种非常重要的问题了： ActiveX 控件如何提前知道客户使用的哪种线程模型？答案相当简单：它并不知道，而且，它也不需要知道。你为控件选择的线程模型告诉 COM 客户设计用来处理的客户线程的种类，而不需要进行调度。 COM 识别何时发生调度，并且，只有在发生任何调度时，才透明地设置调度。例如，实例化控件的 STA 客户线程标记 apartmen t（公寓），直接与控件实例进行交互。然而，在 MTA 线程实例化控件时， COM 必须调度所有的调用，以保证客户和控件在相同的线程上运行。在注册公寓线程模型时，控件已经通知 COM ，每个实例只可以适应单一线程上的调用。调度可以保证所发生的事情。表 10-3 概括了在什么条件下 C O M 调度客户及其嵌入的控件之间的调用。

表 10-3 COM 在客户和控件之间调度的条件控件

哪种线程模型最适于控件取决于你提前使用的客户应用程序的种类，以及你要承担多少额外的工作，以保证线程的访问安全。为了实现线程安全，单一的非线程模型根本不需要额外的代码，因为只有一个客户线程可以直接访问控件的所有实例。另一方面，自由线程模型最适于这样的情况：你提前知道 M TA 应用程序将独占使用控件。然而，很少能够得到这样的保证，除非是你自己编写客户程序。现在，由于大量的客户应用程序都符合 STA 线程，所以，对于设计用来服务于许多不同的客户的 ActiveX 控件来说，公寓模型通常是最佳选择。Internet Explorer 和 Netscape Navigator 是 STA 应用程序，使用 MFC 的包容器程序也是，另外，还有使用 Visual Basic 5 及以后版本编写的程序也是。M icrosoft Transaction Server 也符合 STA 的规则，所以，控件如果支持 MTS ，则应当使用公寓模型。

线程安全性是在公寓模型下易于编程的，它仅需在安全保护下不同时写静态数据，通常通过关键区域或一些类似的机制。如果你要确保快速访问控件而不管客户机的线程模型，选择两种（ both ）模型。顺从 STA 和 MTA 访问而不配置额外工作，特别是运行在多线程下的控件。要研究一下 MTA 线程的复杂性，细读 David Platt 在 M icrosoft Systems Journal 第 12 卷第 8 页的文章即可。在目录标签的期刊条目下的 M S D N 在线帮助中可找到此文章。

示例 1 ： Pulse ActiveX 控件

在本节中提出的 Pulse 控件说明了如何使用 ATL 来生成简单的 ActiveX 控件。

Pulse 是选择性的，它从库中获取。这里的目的不仅仅是演示 ATL ，还要给出减少控件大小的方法，而且不修改 ATL 源代码，或者，采取直接的 C O M 指令。通过结果，你应当理解在使用 ATL 创建时，一个 ActiveX 控件的尺寸可以达到多小。

Pulse 只是一个计时器，在编程时，它以一定的间隔来启动事件，这样，它的作用就很像是我们在建立 Hour 程序时使用的 IETimer 控件。与 IETimer 一样的是， Pulse 是完全自给自足的，它既不使用 MFC ，也不使用 C 运行库。但是，在 37KB ， Pulse 没有 IETimer.ocx 的一半大小，而且还提供相同的服务。 Pulse 这样小的一个主要原因是，如果不显示窗口的话，它运转起来是不可见的。

Pulse 控件包含一个有名为 CPulseCtl 的类控制的单一目标。除了实现表 10-1 中列出的接口外，此目标还提供了这些控件元素：

包含脉冲间隔的适当的变量，以毫秒为单位。
允许包容器启动和结束事件启动的方法。
每次间隔过去时通知包容器的事件。

在这里介绍了 10 步，来演示 Pulse 项目如何获取格式。本讨论采用常规的方法来使用 ATL 创建 ActiveX 控件项目，而且，并不专门针对不可见的控件，如 Pulse 。这些不要使你感觉到我们在这里所做的事情有多么困难。使用 ATL 创建简单的

ActiveX 控件非常简单。

步骤 1 ：运行 ATL COM AppW izard

使用 ATL 创建的 ActiveX 控件项目开始总是使用 ATL 的向导， ATL COM AppWizard 。单击 File （文件）菜单上的 New （新建）命令，选择 ATL COM AppWizard ，如图 10-2 所示，并输入项目名 Pulse 。

第四部分 A ctiveX 控件 - 图50

图 10-2 启动 ATL COM AppWizard

在出现一个对话框列出控件选项时（图 10-3 ），单击 Finish （完成）按钮，来接受默认设置。这些设置指定新的控件作为不使用 MFC 的动态链接库来运行。对于标签为 Allow Merging Of Proxy/Stub Code（允许代理和存根代码的合并），它只对 DLL 服务器类型可用。选择这个选项告诉 COM AppWizard ，来设置项目来链接调度代码到控件的可执行映像中，产生一个单一的 DLL 文件，其中包含控件及其代理 /存根指令。清除选项告诉 COM AppWizard 来编写调度代码到单独的名为 DllData.c 文件，这样，可以减少最终可执行文件的整个大小。在本练习的第 5 步中，我们将更多地讨论控件的代理和存根代码。

第四部分 A ctiveX 控件 - 图51

图 10-3 在 COM AppWizard 中选择一个项目

C O M 和 ATL 都引用进程中的 ActiveX 控件作为动态链接库。在第 9 章中，我们已经看到， ActiveX 确实是一个动态链接库，但是，具有特殊的格式。在随后的步骤中，你可以在源代码中看到，要记住，“ DLL ” 引用我们正在创建的 Pulse ActiveX 控件。

在设置 ActiveX 控件项目中， COM AppWizard 生成了几个源文件，其中包含必要的代码。 Pulse.cpp 文件实现 D llM ain 函数，在第一次加载库时，操作系统便调用这个函数，还有附加的四个服务于 C O M 的函数。由于 COM 不提供这些函数，所以， Pulse 这样的进程内 ActiveX 控件就必须自己导出它们：

D llGetClassObject：在客户第一次请求 C O M 在内存中实例

化控件目标时，从 CoGetClassObject 调用。此函数通过创建类工厂（ class factory ）的实例，并返回到 IClassFactory 或 IClassFactory 接口的指针，来处理这个调用。
DllCanUnloadNow ：在客户使用控件服务器完成时，

从CoFreeUnusedLibraries 中调用。此函数通知调用程序是否 ActiveX 控件管理的任何目标还处于服务状态，这是通过控件未决目标的内部引用计数来指出的。如果对于所有的接口这个计数值为 0 ，则DllCanUnloadNow 函数便返回 S_OK ，以允许 COM 从内存中卸载控件。
DllRegisterServe r：实现有关 ActiveX 控件的信息到系统注

册表中。在控件的注册表数据中最重要的数据是HKEY_CLASSES_ROOT\CLSID 下的项，它指定控件的可执行文件的位置。包容器应用程序只给出控件的类标识符， C O M 扫描 CLSID 文件夹，来定位控件，这样，它就可以将它加载到内存中。此安排允许ActiveX 控件驻留在硬盘或网络上的任何地方，与普通的 DLL 文件通常必须要限制在由操作系统可以识别的特定位置不同。
D llUnregisterServe r：对每个控件目标，都删除由 D

llRegisterServer 实现的注册表数据。

这四个函数是简短的包装器（ wrapper ），每个只有一行。它们都调用到一个名为 _Moldule 的目标中，这便是 ATL 的 CComModule 类的实例。它是 _Module 目标，为函数提供主要的实现。

COM AppWizard 提供完成的控件，具有 DLL 扩展名，而不是 OCX 扩展名，它不提供选择文件扩展名的选项。你可能会感觉到 DLL 文件太多了，ActiveX 控件应当具有 OCX 扩展名，以允许用户推断出文件的目的。如果是这样的话，此时就需要进行一些编辑工作，来更改文件的扩展名。暂时关闭项目的工作控件，在文本编辑器中打开 Pulse.dsp 文件，并使用Replace 命令，来重新命名所有的“ .dll”为 “ .ocx ”。然后重新打开项目，并在 Project Settings（项目设置）对话框的 Link （链接）选项卡中更改

文件的扩展名。如果控件在 M icrosoft Transaction Server 环境中运行的话，就不要这样做。

COM AppWizard 创建一个项目梗概，但是，不要为 ActiveX 类目标本身添加源代码。在运行 COM AppWizard 后，下一步是为目标的类实现代码，这要使用 ATL 的第二个向导，名为 ATL Object Wizar d（ ATL 目标向导）。

步骤 2 ：运行 ATL Object W izard

ATL 的 Object Wizard 生成一个类的声明，以及为目标类实现函数的存根，使它与 MFC 的 ClassWizard 有些一致之处。运行 Object Wizard ，如图 10-4 所示，方法是从 Insert（实现）菜单中选择 New ATL Object （新建 ATL 目标）命令，或者是在 ClassView 窗格中右击项目名，并从上下文菜单中选择这个命令。 WizardBar 菜单也提供了到相同命令的访问。

第四部分 A ctiveX 控件 - 图52

10-4 调用 ATL Wizard 支持的常用方法

对于 17 种不同的目标类型，Object Wizard 自动添加 ATL 代码到项目中，其中的一些在表 10-4 中列出。在开发 ActiveX 控件项目时，通常选择 Full Contro l（完全控制）选项，但是，此选项假定控件将显示一个窗口，并以属性表来支持这种方法，而且还有一个表达图标。对于小的不可见的控件。例如 Pulse ，通常，从那里选择一种更简单的组件类型，并建立它，而不是以后再删除不必要的代码，这样更合适。Pulse 项目不需要许多启动程序所使用的代码，所以，在向导对话框的左窗格中选择 Objects ，并双击标签为 Simple Object（简单目标）的图标，如图 10-5 所示。

第四部分 A ctiveX 控件 - 图53

图 10-5 ATL Object Wizard 对话

表 10-4 ATL Object Wizard 支持的常用目标类型目标类型说明

Simple Objec t（简单目标）创建一个主干 C O M 目标。此接口支持

必须手工添加

Add-in Object（附加目标）创建一个简单的附加目标，它连接到

Developer Studio 的 IApplication 接口。第 13 章更详细地解释了 Developer Studio

Internet Explorer Object

（ Internet Explorer 目标）

创建一个 COM 目标，它支持 Internet Explorer 所期望的接口，但是，没有用户界面的附加支持

ActiveX Server Component

（ ActiveX 服务器组件）

为 OnStartPage 和 OnEndPage 添加支持，具有 ASP 接口的指针，例如Irequest, Iresponse 和 Iserver

M icrosoftTransactionServer

（ M icrosoft 事务服务器）

Component Registrar （组件记录器）

续表

创建一个概略的实现文件，它包括事务服务器所需要的 M tx.h 头文件

通过 ATL 的 Registrar 来访问系统注册表，通过 Iregistrar 接口来实现

Lite Contro l（真正的控件）使用可以嵌入到 Internet Explorer 中的

用户界面来创建一个控件，但是，它并不支持由许多其他包容器所需要的接口。提供指针到客户的IOleInPlaceWindowless, IOleClientSite 和 Iadivise

Sink 接口

Full Contro l（完全控件）创建一个控件，可以嵌入到所有符合

ActiveX 规则

Composite Control（混合控件）

续表

的 7 中。提供相同的指针作为 Lite Control 到站点接口

创建一个类似对话框的控件，它可以包含其他 ActiveX 控件和常规控件

Property Page（属性页面）添加属性页面目标到控件项目中。只

为每个属性页面选择一次此选项

D ialog （对话）对目标添加一个常规对话资源

Provide r（提供者）创建一个目标，来执行 OLE DB 提供

者的数据转换服务

接下来， Object Wizard 显示 Properties 对话（参见图 10-6 ），它查询控件的特性。在 Names 选项卡中，键入短名 PulseCtl ，从中， Object Wizard 使用适当的条目填充其他编辑框。 Class 编辑框包含 CpulseCtl 类的名称，它可以实现控件的目标。此类非常重要，原因是它从 Pulse 控件支持的所有接口继承而来。

第四部分 A ctiveX 控件 - 图54

图 10-6 为 ATL Object Wizard Properties 对话中的对象指定名称

Object Wizard 编写 CPulseCtl 类源代码到指出的 H 和 CPP 文件。 CoClass 编辑框

中容纳字控件的组件类的名称，它作为类型库，等效于对象类。 CPulseCtl 类和PulseCtl 组件类引用相同的目标，但是，定义对象的位置有所不同。 CPulseCtl 引用到实现此对象的 C++ 源代码，而 PulseCtl 组件类引用到此对象在控件的类型库中的定义。 Interface 框显示接口的名称，在这个接口中，控件将其定制的方法和属性展示出来。标有 Type and ProgID 的编辑框容纳字符串，它描述了 CPulseCtl 对象，及其编程的标识符。

如图 10-6 所示，一些名称作为系统注册表中的条目，由 Pulse 的 DllRegisterServer 函数放置在那里。例如，编程的标识符 PulseCtl.PulseCtl 和 PulseCtl.PulseCtl.1 分别成为 VersionIndependentProgID 和 ProgID 注册表键下面的字符串。在这两个标识符之间，唯一的不同是，在此情况下，后者包含控件的版本号 1 。人们可以识别这两个字符串，它们是控件的标识符的另一种形式，它提供了一种手段，使包容器应用程序可以请求控件对象，而不必使用 CLSID 字符串。例如， MFC 的CWnd::CreateControl 函数按如下的方法接收编程的标识符：

CreateControl( “ PulseCtl.PulseCtl.1 ” ,NULL, 0 &rect,

pParentWnd,IDC_PULSECTL);

类似地， Visual Basic 或 VBA 容器可以传递标识符到 CreateObject 函数：

Dim PulseCtl As Object

PulseCtl = CreateObject ( “ PulseCtl.PulseCtl.1 ”)

客户仅为控件控制变成的标识符，它可以确定对应的类标识符，方法是调用 OLE

函数 CLSIDFromProgID 。函数 ProgIDFromCLSID 执行相反的转换。

第四部分 A ctiveX 控件 - 图55

图 10-7 ATL Object Wizard Properties 对话框

在 Attributes（属性）选项卡中，选择标有 Support Connection Points （支持连接

点）的复选框，如图 10-7 所示。对于诸如启动事件的 Pulse 这样的 ActiveX 来说，连接点是必要的。此选项卡还显示单选按钮，来确定控件的线程模式、接口类型，以及是否它支持聚合特征。我们已经查看了 ATL 支持的线程模型，但是，双接口和聚合特征也应当详细说明。

双接口：在第 8 章中，我们已经看到， Microsoft 已经扩
展了 OLE 的设计，以支持定制的控件，使这样的组件作为 VBX 组件的 32 位方式。然而，由于这种方式传递函数参数，所以，版本 4 之前的 Visual Basic 不能直接调用控件方法。为了解决这个问题， M icrosoft 在 OLE 中合并了 Idispatch 接口，以提供必要的链接。现在， Idispatch 通常作为客户脚本编程的通信管道，例如 VBScript 和 JavaScrip t，使它们可以通过 Idispatch::Invoke 函数的服务，来调用控件的方法，它可以转换参数，并返回值到客户的本机数据类型，或者，返回客户本机数据类型的值。尽管这种解决方案可行，但是，额外的转换和间接调用 Invoke ，将会减慢包容器与控件之间的交互。

对于 Web 页面，以及以前的 Visual Basic 客户， Idispatch 是一个必要的折衷方法。然而，在 C++ 这样的语言中编写的包容器应用程序可以直接访问控件的方法，其方法是通过指针进行调用。 Idispatch::Invoke 及其耗时的转换都不再需要了。为了适应支持除了 Variant 数据类型的客户， OLE 支持双接口技术。双接口方法函数要么通过Idispatch::Invoke 间接进行调用，要么通过调用到方法的指针来直接访

问，这样，不管包容器应用程序是使用什么语言编写的，所有包容器应用程序都可以得到适当的服务。

聚合：通过聚合，另一个对象可以在其调用程序中出
现，以具有 Pulse 控件加上第二个对象提供的新服务的能力。聚合对象通常叫做包含或外部对象，它嵌入 Pulse 控件的方式与包容器应用程序的相同。然后，外部控件选择性地从其客户中 1QueryInterface 请求，为 IPulseCtl 接口将请求传递给 Pulse 。外部对象的客户接收需要的指针，并调用到 Pulse 中，它不知道现在是 Pulse ，而不是聚合它的对象正在提供服务。

在 Obejct Wizard Properties 对话中，聚合选择不确定控件是否聚合另一个对象，是否控件本身是聚合的。

如果你的控件不打算服务于以前的 Visual Basic 应用程序，或者，在 Web 页或Active Server Page 上进行脚本编程，在此对话框中选择 Custom （定制）单选按钮。这样做的好处是，它可以稍微减少最终控件的大小，因为每个实现的接口都没有合并 Idispatch 的四个方法。尽管具有客户接口的控件可以在 H T M L 文档中出现，但是，它并不能通过脚本进行编程。脚本解释器必须在控件对象上找到Idispatch ，或者，它不能访问此控件。

对于 Pulse 控件，接收默认的设置，来启用公寓模型线程，并添加双接口支持，但是，没有聚合特征。在深思熟虑之后，可以通过在 Aggregation （聚合）组中选择 N o 单选按钮，来使 Pulse 成为非聚合的。这便对 CPulseCtl 类定义添加了一

行，如下所示：

DECLARE_NOT_AGGREGATABLE(CPulseCtl)

尽管聚合通常被认为是 ActiveX 控件的一个有用的特性，但是支持聚合使控件的执行空间增加了大约 2KB 。由于这本书的一个目的是说明如何用 ATL 创建控件，从而减小控件的大小，因而放弃聚合似乎是一种合理的折衷方案。

这个折衷方案并不像表面上看起来的那么严重，因为聚合并不是 ActiveX 控件在使用另外一种技术时所必须使用的唯一技术。任何原因都不能阻止一个控件像一个客户一样动作，而且可以嵌入在 Pulse 控件中。这项技术被称为包容，包容控件提供了运行 Pulse 自己的方法函数，并通过它自己的类库公布这种方法。当一个客户应用程序要求某项 Pulse 服务时，包容控件（我们称之为 Outer（外部对象））将这个调用传递给 Pulse 。当 Pulse 启动这个事件后，控件回到 Oute r（外部对象）处理程序函数，它将通过启动它的客户应用程序来传递事件。当使用聚合时，客户应用程序并不知道另一个控件正在提供这项服务。但与聚合不同的是，包容器减少了 Pulse 和客户应用程序之间的通信，因为 Outer（外部对象）控件必须作为二者之间的中介而存在。

不要选中标有 “ Free Threaded Marshaler（自由线程调度器）” 的复选框。这个选项将把自由线程调度器这个对象加入到项目中，自由线程调度器说明如下。

自由线程调度器

在 ATL Object Wizard （对象向导）中选中 “ Free Threaded Marshale r（自由线程调度器）”复选框，将产生对 COM 的 CoCreateFreeThreadedMarshaler 函数的调用。

Hresult FinalConstruct()

{

return CoCreateFreeThreadedMarshaler(

GetControllingUnknown(), &m_pUnkMarshaler.p);

}

这个函数将创建一个称为自由线程调度器的对象，它将与控件聚合并监督调度操作。它的主要目的是，当一个包容器应用程序使用嵌入到使用两个线程模型的某个 ActiveX 控件中的单线程公寓模型时，来提高性能。为了理解自由线程调度器如何改善这样一个控件的性能，应仔细研究一个典型的运行两个 STA 线程的客户，在这样的客户中，线程 B 必须调用线程 A 所拥有的对象实例。线程 A 首先调用 CoMarshalInterThreadInterfaceInStream ，返回时收到一个指向流的指针（流只是一个数据的集合）。线程 A 将流指针传递给线程 B ，线程 B 利用流指针调用CoGetInterfaceAndReleaseStream ，收到一个指向代表理想实例的代理的指针，线

程 B 现在可以安全地调用代理，来对对象接口的方法进行访问，即使实例在不同的公寓中创立。

如果一个同时使用两个线程模型的 ActiveX 控件可以安全地处理从任何公寓来的直接调用，甚至来自于不同的 STA 公寓，通过一个调度器整理来自客户的线程 B 的调用所浪费的时间是不必要的，因为客户可以直接正确（而且更加有效）地从线程 B 中调用对象实例。客户不能安全地假定这个选项存在，所以必须通过CoGetInterfaceAndReleaseStream 应用一个代理。但是，因为这个控件是用于对不同 STA 线程上同时进行安全的访问，它通过自由线程调度器调用CoCreateFreeThreadedMarshaler 以进行它自身的用户调度。这个对象就像一个存根一样，将一个指向接口的指针拷贝到流中，而这个接口正是客户通过CoGetInterfaceAndReleaseStream 所申请的。结果就是线程 B 得到了它的接口指针，而不用切换线程，或者遍历 C O M 调度器的路径。客户无法了解这个差别，除非因为调用实例是直接访问方法，而不是通过代理码进行，使得调用实例更快一些。可是一个采用这项技术的控件必须确保对象可以处理同时调用。

单击 O K 按钮可以关闭 ATL Object Wizard （ ATL 对象向导）对话框，此时向导将产生三个文件：

PulseCtl.h 和 PulseCtl.cpp ：新 CpulseCtl 类的定义和执行码。
PulseCtl.rgs：包括控件的注册信息脚本的文本文件。

RGS 文件中的注册脚本是包含在控件执行文件资源数据中的一部分， DllRegisterServer

函数将其读出，并安装在 Registr y（注册表）中。 Object Wizard（对象向导）在项目的 RC 文件中加入一行，来引用注册脚本：

IDR_PULSECTL REGISTRY DISCARDABLE “PulseCtl.rgs”

并在 Resource.h 中为 IDR_PULSECTL 常量插入一个 #define 语句。

Object Wizar d（对象向导）也在 StdAfx.cpp 和 StdAfx.h 文件中插入了几个 #include 语句。这些语句将带给项目所必须的 ATL 源文件，例如 AtlImpl.cpp ， AtlCtl.cpp 和 AtlWin.cpp 。尽管 StdAfx 文件的名字看起来与 MFC 项目类似，它们只在选择了步骤 1 中的 MFC 选项后才引用 MFC 头文件。

对于加入到控件中的每一个对象， Object Wizard（对象向导）在控件对象映射中加入一个入口。 Pulse 仅包含一个 CPulseCtl 对象，所以在向导结束后， Pulse.cpp 文件中的对象映射看起来是这样的：

BEGIN_OBJECT_MAP(ObjectMap) OBJECT_ENTRY(CLSID_PulseCtl,CpulseCtl)

END_OBJECT_MAP()

最后， ATL Object Wizar d（对象向导）对项目的 IDL 文件进行必要的修改，控件

的类库就是从 IDL 文件中产生的。 IDL 代表接口描述语言，而 IDL 文件作为M icrosoft IDL 编译工具 MIDL 的输入。当增加 Pulse 的事件函数时，就能看见这个项目的 IDL 文件的详细资料。

步骤 3 ：加入 nInterva l属性

Pulse 有唯一的一个用户属性，称为 nInterval ，它包括以毫秒为单位的控件启动事件的速度。为了在接口上加入这个属性，在 ClassView 窗口中展开 Pulse 类列表，用鼠标右键单击 IPulseCtl 的入口，然后选择 Add Propert y（加入属性）命令：

第四部分 A ctiveX 控件 - 图56

这将激活 Add Property To Interface （为接口加入属性）对话框，如图 10-8 所示，它与第 9 章中所遇到的类向导的 Add Property （加入属性）对话框所要求的信息是一样的。

第四部分 A ctiveX 控件 - 图57

图 10-8 对 Pulse ActiveX 控件增加 nInterval 用户属性

键入 nInterval 作为 Pulse 属性的名字，给定它的属性类型为 Long （这个属性为short 时将简单一些，但是，那将限制最大时间间隔为一分钟多一点）。属性的获取 /放置方法的默认 IDL 类型出现在对话框的底部：

[propget, … ]

HRESULT nInterval ( [out, retval ] long *pVal); [propput, … ]

HRESULT nInterval ([in] long newVal);

C O M 的获取 /放置方法与 MFC 的获取 /设置函数是低级等价的，它为包容器提供了读写控件属性数据的方法。当 MIDL 编译器编译项目的 IDL 文件时，它将通过在属性名字前加入 get_ 和 put_ 来定义接口的两个方法。获取函数的 pVal 参数指向属性的当前值；而放置函数的 newVal 参数包含了一个取代旧属性值的新属性值。如果控件的获取 / 放置方法需要一个更大的扩展参数列表，在对话框参数框中增加变量数。对话框将任何增加的变量插入到 pVal 和 newVal 参数之前，并使它们可以被获取和放置方法公用。如果不想让两个函数具有相同的列表，必须在稍后用文本编辑器手工编辑 IDL 文件。可以自由改变 ID L 文件中参数的顺序或者名字，但是，在参数列表的最后，必须留下 pVal 和 newVal 参数，以及它们的 [out,retval] 和 [in]属性。

Put Function （放置函数）复选框与两个标有 PropPut 和 ProPutRef 的单选钮是同时出现的。 PropPutRef 与默认的 PropPut 选项是类似的，除了它告诉包容器，属性的放置函数靠引用而不是靠值来得到 newVal 参数。在这种情况下，包容器将通过调用 IDispatch::Invoke 设置属性，并用 DISPATCH_PROPERTYPUTREF 标志取代 DISPATCH_PROPERTYPU T。例如对于 VB 的用户，用 set 关键字来表示一个属性通过引用而不是通过值进行赋值：

Set PulseCtl.nInterval=x

清除图 10-8 中的 Put Function（放置函数）复选框，目的是防止 MIDL 编译器为nIterval 属性产生一个放置方法入口。不能允许一个包容器改变 nInterval 属性，清除对话框内的 Put Function （放置函数）复选框将使变量是只读的。控件的另一种方法为客户提供了一个更加符合逻辑的设置 nInterval 属性的方法。

对话框的 Attributes （属性）按钮打开了一个对话框，其中可以选择属性特征，例如调度标识符，一个可选的描述和特殊标志。所选择的属性将出现在 IDL 文件中，并最终出现在类型库中，在那里，它们向将来使用的包容器描述属性。单击图 10-9 中的组合框，将显示出一张可用的属性设置列表，如表 10-5 所示。要牢记，属性的确定要引用属性的获取 / 放置函数，而不要引用属性变量自身。在C O M 中，字的属性通常被用作获取 /放置方法的速记形式，它可以让一个客户访问属性。

第四部分 A ctiveX 控件 - 图58

图 10-9 在 Edit Attributes （编辑属性）对话框中选择属性

属性描述

表 10-5 属性

id 为属性的获取或者放置方法指定一个调度标识符（ DISPID ）

helpstring 指定一个短文本串，用以描述属性。包容器可以通过控件的ITypeInfo::GetDocumentation 方法提取这个串。尽管这个帮助文本作为控件类信息的一部分储存在控件内部，在 Edit Attribute （编辑属性）对话框内删除 helpstring 入口，并不能减小控件的执行映像的大小

续表

bindable 用组合数据使属性与数据库中的特定域联系在一起。它的意思是，任何时候当属性值改变时，控件通知数据库，并要求所联系的记录域进行放置，以反映新的值。为得到关于这个非常有用的概念的进一步信息，请参考标题为 “ ActiveX Controls: Using Data Binding in an ActiveX Contro l（ ActiveX 控件：在一个 ActiveX 控件中使用组合数据）”的 MSDN 文章。可以用复选框设置 Search Titles Only （仅按标题搜索）在 MSDN 的 Search （搜索）选项卡中搜索这篇文章

续表

call_as 使客户可以用不同的名字访问属性的获取 / 放置函数。这对于有大量的 “ nonremotable （非远程）”参数类型的函数是非常有用的，例如 int 或者 void 。一个非远程的变量对于不同机器上的操作系统来说并不是完全相同的。例如，因为 COM 并不保证每一台机器

（或者每一个客户）为变量分配相同的空间，所以一个 int 值并不是远程的。相反，由于每一台机器认为 short 和 long 变量占据 2 和 4 个字节，所以它们是远程的。由于这个原因，在 Object Wizard

（对象向导）中的变量类型列表包括 short 和 long 类型，而没有

int，这对于 COM 是非常不明确的。

单个非远程参数也可以通过 represent_as 和 transmit_as 属性进行规定。当时对于使用几个非远程类型变量的获取 /放置函数来说， call_as 比 represent_as 和 transmit_as 更为方便和有效。对属性函数规定一个 call_as 属性，意味着控件可以一步进行所有必要的转换，而不是用几步完成，每一步进行一个变量的转换。

用非远程函数参数，对于像 ActiveX 控件这样的进程内

续表

服务器的效率是非常低的，应为它强迫通过代理 /存根代码对调用call_as 函数进行调度。必须为处理非远程参数的包容器的代理DLL 提

供一个对话例程，而且为控件中的存根提供另一个例程，以接受调用。在一个 ActiveX 控件中的所有函数参数全部使用远程类型，将确保从包容器可以不经过调度而直接访问控件

defaultbind 指明可绑定的最代表控件对象的属性。只有控件的一个属性可以具有 defaultbind 标志，而且它必须具有 bindable 标志。Defaultbind 标志允许一个包容器绑定在整个控件对象上，而不是单个属性

defaulcollelem 允许用 Visual Basic for Applications 编写的客户直接访问属性的获取 /放置函数

displaybind 指示包容器绑定的属性必须显示给用户。这个属性同样必须具有

bindable 标志

续表

helpcontext 规定一个 32 位数字，以识别控件的属于某个属性的帮助文件中的信息

hidden 要求包容器不向用户显示属性

immediatebind 要求在放置属性后，立即通知数据库，而不是等到控件失去输入焦点之后。这个属性同样必须具有 bindable 标志

local 规定 MIDL 编译器必须仅仅产生接口头文件，而不产生存根代码。 local 标志与类似 Pulse 这样的过程内 ActiveX 控件没有关系

nonbrowsable 要求包容器不要包含包容器属性浏览器中的属性

续表

requestedit 表示在改变属性值之前，控件将向包容器查询是否允许改变。通过 IpropertyNotifySink::OnRequestEdit 函数可以申请许可，这个函数将通知包容器属性将被改变，而且对象正在申请允许，以继续进行。从 OnRequestEdit 的返回值 S_FALSE 将拒绝这个申请；而返回值 S_OK 将允许改变属性值。在收到 S_OK 后，如果属性也具有 bindable 标志，则控件必须调用 IPropertyNotifySink::On Changed

restricted 规定属性的获取 /放置方法不能从宏中调用

source 说明获取 /放置函数返回一个对象或者 Variant 作为某事件源的变化。source 很少用在属性中，但是我们将在 Pulse 的接口列表中使用它

vararg 说明这个属性的获取 / 放置方法可以接收数目不同的参数。这个方法的最后一个参数必须是一个可靠的 Variant 类型数组，其中包含了每一个未规定的参数的默认值

步骤 4 ：加入方法

关闭 Add Property To Interfac e（为接口加入属性）对话框，将在 IDL 文件中写入属性信息。下一步是加入三个名为 StartPulse, EndPulse 和 _OnTimer 的方法。通过调用 StartPulse 方法，包容器告诉 Pulse 开始节拍性的事件启动过程。这个函数参数以毫秒为单位，规定了包容器接收事件通知的事件间隔。在控件停止激活后，包容器调用 EndPulse 停止事件启动过程，这样将不占用 CPU 时间。_OnTimer 函数由 CTimer 类使用，在步骤 6 中进行说明。对于每一种方法，像以前一样用鼠标右键单击 ClassView 窗格中的 IPulseCtl 接口，但这一次选择 Add Metho d（加入方法）命令：

第四部分 A ctiveX 控件 - 图59

StartPulse 的 nRate 参数是 nInterval 属性的新值。这解释了在前面的步骤中，我们决定一个客户不需要访问一个 put_nInterval 函数，因为调用 StartPulse 可以达到同样的目的。在图 10-10 中所示的 Add Method To Interfac e（为接口加入方法）对话框中键入函数和参数名称，然后单击 O K 关闭对话框。重复以上步骤，以加入 EndPulse 和 _OnTimer 方法。EndPulse 和 _OnTimer 都没有参数，所以使参数框空着。关闭 Add Method To Interfac e（为接口加入方法）对话框，此时 Visual C++ 将把对应 3 种方法的适当代码加入到 Pulse.idl 文件中。它还将为方法写出存根函数，加入到 Pulse.cpp 文件中，我们将在为控件加入一个事件函数后，对其进行编辑。

第四部分 A ctiveX 控件 - 图60

图 10-10 Add Method to Interface 对话框

步骤 5 ：加入 Pulse 事件

在我们开始编码之前，为项目添加的最后一个部分是 Pulse 事件，它将在每一个时间间隔到来时启动。在 ATL 以前的版本中，在控件中增加一个事件需要一点手动操作，包括产生一个事件接口的 GUID 标识符，编辑 IDL 文件和运行一个称为 ATL Proxy Generator 的工具。但随着库的第三版的发布，这个过程变得更加简单和友好。现在为控件增加事件和增加方法和属性一样容易，仅仅需要一点时间对项目的 IDL 文件进行编译。

在我们将讨论发生在屏幕之后的事情之后，下面给出了产生新事件代码过程中所需要的步骤列表。图 10-11 说明了 4 个步骤。

用鼠标右键单击 ClassView 窗格中的 _IPulseCtlEvents 入口

，并从菜单中选择 Add Method （加入方法）命令。在 Add Method To Interfac e（为接口加入方法）对话框中，选择 void 返回类型，将事件函数命名为Pulse ，然后单击 OK 关闭对话框。
找到 Workspace 窗口中的 FileView 窗格，用鼠标右键单击

Pulse.idl 入口，然后选择 Compile （编译） Pulse.idl 命令。这将启动 M IDL 编译器，它将产生类型库文件 Pulse.tlb ，并加入到项目中。
当 MIDL 编译器结束工作后，切换回 ClassView 窗格，然后

用鼠标右

键单击 CPulseCtl 入口。从菜单中选择 Implement Connection Poin t（实现连接点）命令，以显示同名字的对话框。

设置标有 _IpulseCtlEvents 的复选框，并单击 O K 关闭对
话框。

项目的 IDL 文件底部一半的地方列出了名为 PULSELib 的 library 块，它将向M IDL 编译器描述新 Pulse 事件。当为一个控件的方法和属性搜索类型库时，某些包容器应用程序仅仅读出 library 块，所以通常要小心地编辑 IDL 文件，以移动最前的两个缩进代码块到 library 块。第一个块由方括号 [] 组成，包括 IPulseCtl 接口的标志；

第四部分 A ctiveX 控件 - 图61

图 10-11 为 ATL ActivX 项目加入一个事件

第二个块用花括号括起来，包含有接口的方法列表。列表 10-1 表示了在重新安排代码之后应该有的结果。如果按照这些步骤建立 Pulse 项目，你自己的 ID L 文件的 GUID 数目与列表中所显示的将不会相同。

importlib 指令从 OLE 类型库 StdOle32.tlb 和 StdOle2.tlb 中带入预编译类型信息，这两个类型库通常位于 Windows 系统或者 System32 目录中。尽管并非必要，接口名字 _IPulseCtlEvents 仍然以下划线开始。这个约定将通知接口浏览器，

_IPulseCtlEvents 接口属于控件，而且浏览器不能将接口显示给用户。

列表 10-1 改正后的 Pulse.idl 文件

[

uuid(3B365F9D-C3AE-11D1-BEC9-E0F4E352507A),

version(1.0),

helpstring("Pulse 1.0 Type Library")

]

library PULSELib

{

importlib("stdole32.tlb");

importlib("stdole2.tlb");

// **********************************************************

// ...to here:

[

object,

uuid(3B365FA9-C3AE-11D1-BEC9-E0F4E352507A),

dual,

helpstring("IPulseCtl Interface"),

pointer_default(unique)

]

interface IPulseCtl : IDispatch

{

[propget, id(1), helpstring("property nInterval")] HRESULT nInterval([out, retval] long

*pVal);

[id(2), helpstring("method StartPulse")] HRESULT StartPulse(long nRate);

[id(3), helpstring("method EndPulse")] HRESULT EndPulse();

[id(4), helpstring("method _OnTimer")] HRESULT _OnTimer();

};

// **********************************************************

[

uuid(3B365FAA-C3AE-11D1-BEC9-E0F4E352507A),

helpstring("_IPulseCtlEvents Interface")

]

dispinterface _IPulseCtlEvents

{

properties:

methods:

[id(1), helpstring("method Pulse")] void Pulse();

};

[

uuid(8C9BABDD-BCE5-11D1-BEC9-D43CA8CB2F51),

helpstring("PulseCtl Class")

]

coclass PulseCtl

{

[default] interface IPulseCtl;

然而，并不是所有的浏览器都遵守这个约定。

[default] interface IPulseCtrl;

[default, source] dispinterface _IPulseCtlEvents;

下面这几行规定 IPulseCtl 为控件的默认调度接口，而 _IPulseCtlEvents 作为控件的默认源接口，通过这些包容器接收控件的事件通知信息。source 告诉 M ID L 编译器，包容器而不是控件，将为 _IPulseCtlEvents 提供 IDispatch 实现。这个控件是 _IPulseCtlEvents 接口中调用的源，而且包容器的事件 IDispatch 是事件的接收器。

下面的这一行通过内部名字规定了控件的事件，而且将事件与唯一的由 id 关键字规定的调度标识符值联系在一起：

[id(1), helpstring("method pulse")] void Pulse();

这个控件并不直接调用 Pulse 函数来启动事件，而是调用一个名为 Fire_Pulse 的由 ATL 加入到项目中的封装函数。这个封装函数称为代理，依次调用包容器的IDispatch::Invoke 方法，提供调度标识符号码，以识别启动的事件。以上就是一个代理如何得到它的名字的过程。 Fire_Pulse 函数作为包容器事件处理程序函数的替身或者代理，当启动一个事件时，作为控件调用的现场，而不用担心调用最终如何到达客户的细节。代理函数是单一代理类的成员，单一代理类作为导出CPulseCtl 的基类，允许控件在 CPulseCtl 实现的任何地方启动事件。代理类的角色与 C O M 所设置的用于调度线程间调用的代理对象是不同的。类和调度对象通常被简称为 “ proxy ”，所以有时候很容易混淆它们。但它们不是同一件事。

在执行 Implement Connection Poin t（实现连接点）命令时，我们在项目内增加了IConnectionPoint 接口的实现，通过这个接口包容器可以决定 ActiveX 控件支持哪一个连接点。这个命令检查控件的类型库文件，从中提取接口名字

_IPulseCtlEvents 和 IPulseCtl 以创立代理类。一个 ActiveX 控件通常在控件的可执行文件中作为原始数据包含它自己的类型库，并允许类型浏览器如ClassWizard 来访问数据。然而，在控件的开发阶段，类型库以 TLB 文件的形式独立存在。

ATL 的 IConnectionPointImpl 模板为新 CProxy_IPulseCtlEvents 代理类定义了一个基准。这个类的代码驻留在 PulseCP.h 文件中，以子函数的形式包含了 Pulse 的单个事件代理：

template <class T>

class CProxy_IPulseCtlEvents : public IConnectionPointImpl<T, &DIID__IPulseCtlEvents,

CComDynamicUnkArray>

{

//Warning this class may be recreated by the wizard. public:

VOID Fire_Pulse()

{

T* pT = static_cast<T*>(this); int nConnectionIndex;

int nConnections = m_vec.GetSize();

for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++)

{

pT->Lock();

CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex); pT->Unlock();

IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p); if (pDispatch != NULL)

{

DISPPARAMS disp = { NULL, NULL, 0, 0 };

pDispatch->Invoke(0x1, IID_NULL, LOCALE_USER_DEFAULT,

DISPATCH_METHOD, &disp, NULL, NULL, NULL);

}

};

注意， Fire_Pulse 代理函数的类型是 void 。事件与方法不同，它从不返回值。

通过它的基类， CProxy_IPulseCtlEvents 为由第二个模板参数识别的接口实现了连接点。在我们的例子中，接口是 _IPulseCtlEvents ，而它的调度接口标识符是DIID_IPulseCtlEvents ，由 Pulse_i.c 文件进行定义。第三个模板参数规定了处理连接的 ATL 类。这个默认的 CComDynamicUnkArray 类允许的连接数目不限；而可选的 CComUnkArray 类只允许数目固定的连接。

步骤 6 ：加入 CTimer 类

Pulse 可以捕获 WM_TIMER 消息来激活它的事件启动过程，但是那样将需要创

立一个窗口来接收消息。窗口将消耗系统资源，需要时间来建立和关闭，而且，向 Pulse 这样的流型 ActiveX 控件应尽可能避免创立窗口。幸运的是，Visual C++ 中所包含的 AtlButton 例子项目包含了一个简单的安全线程 CTimer 类，这个类正是我们所需要的。由于代码不是由 ATL 向导产生的，列表 10-2 中列出了它的全部内容。

列表 10-2 Timer.h 文件

HRESULT TimerOn( DWORD dwTimerInterval ) // Arm the timer

{

Derived* pDerived = ((Derived*) this);

m_dwTimerInterval = dwTimerInterval;

if (m_bTimerOn) // If already on, just change interval

return S_OK;

m_bTimerOn= TRUE;

m_dwTimerInterval = dwTimerInterval;

m_pStream = NULL;

HRESULT hRes = CoMarshalInterThreadInterfaceInStream(

*piid, (T*)pDerived, &m_pStream );

// Create thread and pass the thread proc the this ptr

m_hThread = CreateThread(NULL, 0, &_Apartment,

(PVOID) this, 0, &m_dwThreadID);

return S_OK;

}

void TimerOff() // Disable the timer

{

if (m_bTimerOn)

{

m_bTimerOn = FALSE;

AtlWaitWithMessageLoop( m_hThread );

}

// Implementation

private:

static DWORD WINAPI _Apartment( PVOID pv )

{

CTimer<Derived, T, piid>* pThis = (CTimer<Derived, T, piid>*) pv;

pThis->Apartment();

return 0;

}

D W O R D Apartment()

{

CoInitialize(NULL);

HRESULT hRes;

m_spT.Release();

if (m_pStream)

hRes = CoGetInterfaceAndReleaseStream(

m_pStream, *piid, (PVOID*) &m_spT );

// Main timer loop that periodically calls _OnTimer

while(m_bTimerOn)

{

Sleep( m_dwTimerInterval );

if (!m_bTimerOn)

break;

m_spT->_OnTimer();

}

m_spT.Release(); // When TimerOff function sets

CoUninitialize(); // m_bTimerOn = FALSE, unregister

return 0; // and quit

}

public:

DWORD m_dwTimerInterval;

BOOL m_bTimerOn;

private:

HANDLE m_hThread;

DWORD m_dwThreadID;

LPSTREAM m_pStream;

CComPtr<T> m_spT;

} ;

通过列表，可以看出 CTimer 分为几步，其原因还不是立即就可以看出来。类通过它的 TimerOn 函数封装了计时器，这个函数将创立一个新线程，以调用 Sleep 函数，以在需要时进入休眠。当线程被唤醒时，它调用我们在步骤 4 中加入的

_OnTimer 方法，以表明间隔已经结束。线程然后再次回到休眠，这个过程在一个循环中不断重复，直至 TimerOff 函数被调用。这个类是非常有趣的，因为它执行自己的线程之间的用户调度，确保 _OnTimer 函数不是从新线程受到调用，而是从启动计时器的原始线程受到调用。在我们的例子中，这是 Pulse 控件的主线程，从这里 _OnTimer 可以安全的启动 Pulse 事件。调度回到主线程对于像 Pulse 一样的公寓线程控件是必要的一步，因为 COM 的规则指出一个对象必须在客户的公寓内启动事件。也就是说，在与使对象实例化的同一个客户 STA 线程上。

如果作为新项目创立 Pulse ，简单地从公司 CD 上拷贝 Timer.h 文件到自己的项目文件夹中。这个文件是一个头文件，所以没有必要用 Add To Project（加入到项目中）命令将其加入到项目中。

步骤 7 ：编辑 PulseCtl.h 文件

在步骤 2 中，选择最简单的可以从 ATL Object Wizar d（对象向导）中得到的对象类型，这将设置 CPulseCtl 类，以便仅仅继承 3 个基类和 2 个接口。一个真正的ActiveX 控件必须实现比这些更多的接口，所以，在这一步，我们将扩展类的继

承列表，以包含一个典型包容器希望一个控件所实现的附加接口。

在文本编辑器打开 PulseCtl.h 文件，然后加入下面灰色所示的两个 #include 语句，一个用于我们在前面的步骤中创立的 CTimer 类，而另一个用于引入项目所需要的附加接口实现：

#include "resource.h" //main symbols #include "PulseCP.h"

然后，在 CPulseCtl 继承列表中增加下列内容。这些行的实际顺序并不重要，但是，注意列表中的所有入口都有一个逗号结尾，最后一个例外。

class ATL_NO_VTABLE CPulseCtl :

public CComObjectRootEx<CComSingleThreadModel>, public CComCoClass<CPulseCtl, &CLSID_PulseCtl>, public IConnectionPointContainerImpl<CPulseCtl>,

public IDispatchImpl<IPulseCtl, &IID_IPulseCtl, &LIBID_PULSELib>,

public CProxy_IPulseCtlEvents< CPulseCtl >

{

尽管 Pulse 控件是不可见的（而不是无窗口），然而， CpulseCtl 类必须从IOleInPlaceObjectWindowlessImpl 中导出（复习第 9 章内容，无窗口控件取决于显示服务的控件）。这是 ATL 对于像 Pulse 这样的不可视控件不进行优化的例子。ATL 没有提供我们的控件所需要的 IOleInPlaceObject 接口的单独实现，而是仅仅提供了 IOleInPlaceObjectWindowless，这是对 IOleInPlaceaObject 的扩展，这将增加对窗口信息的支持和拖放操作。 Pulse 并不需要这些额外的方法，但是必须包含它们，以实现 IOleINPlaceObject。

按照类继承列表，为 FinalRElease 子函数加入原型，这个子函数在卸载 Pulse 控件时，被 ATL 的 CComObject 调用：

public:

HRESUL T FinalRelease() ;

CPulseCtl()

{

}

注意 CPulseCtl 并没有声明一个类析构函数。这是因为析构函数在从 CPulseCtl 导出的 ATL 基类中是不可视的，所以类并不能确实地假定它的析构函数将永远不会被调用。一个使用 ATL 的 ActiveX 控件类执行在 FinalRelease 函数中的任何必要的清除功能，这将在对象实例被破坏之前被调用。它的必然结果是一个控件必须将它的初始化任务限定在 FinalConstruct 函数中。本章后面出现的第 2 个项目说明了 FinalConstruct 的用法。为了与 CPulseCtl 继承性列表内的接口模板匹配，必须为类的 C O M 映射加入相应的入口，如下所示：

BEGIN_COM_MAP(CPulseCtl)

COM_INTERFACE_ENTRY_IMPL(IConnectionPointContainer) COM_INTERFACE_ENTRY(IPulseCtl) COM_INTERFACE_ENTRY(IDispatch) COM_INTERFACE_ENTRY(IConnectionPointContainer)

COM_INTERFACE_ENTRY(IObjectWithSite)

COM_INTERFACE_ENTRY(IViewObjectEx)

COM_INTERFACE_ENTRY(IViewObject2)

COM_INTERFACE_ENTRY(IViewObject)

COM_INTERFACE_ENTRY(IOleInPlaceObjectWindowless)

COM_INTERFACE_ENTRY(IOleInPlaceObject)

COM_INTERFACE_ENTRY2(IOleWindow, IOleInPlaceObjectWindowless)

COM_INTERFACE_ENTRY(IOleControl)

COM_INTERFACE_ENTRY(IOleObject)

COM_INTERFACE_ENTRY(IPersistStreamInit)

COM_INTERFACE_ENTRY2(IPersist, IPersistStreamInit)

COM_INTERFACE_ENTRY(IPersistStorage)

END_COM_MAP()

IProvideClassInfo2 是新的 OLE 接口，替换了旧的 IProvideClassInfo 。一些包容器不认识 IProvideClassInfo2 ，所以映射包含了 IProvideClassInfo 的入口。因为IProvideClassInfo2 代表旧接口，所以加入的内容不会增加 Pulse 的代码大小。IProvideClassInfo 和 IProvideClassInfo2 支持 Pulse 的事件启动。两个接口都提供了 GetClassInfo 方法，它将提供属于 PulseCtl 组件类对象的类型信息。这个类型信息来自控件的类型库，将告诉客户如何为 Pulse 事件建立它的处理程序函数。

除了建立 Uniform Data Transfer（统一数据传送）的核心之外， IDataObject 接口提供了向客户通知数据变化的方法。一个实现 IAdviseSink 接口的客户调用控件的 IDataObject::Advise 方法在控件的数据被改变时，开始接收通知。这并不适用于 Pulse ，而且控件可以在不支持 IDataObject 的情况下正常工作。然而，一些客户，例如 Test Container 实用程序要求接口建立通知连接。

确保 C O M 映射包含 IConnectionPointContainer 的入口：

COM_INTERFACE_ENTRY_IMPL(IConncetionPointContainer)

如果没有在步骤 2 中的 Object Wizar d（对象向导）中选择 Support Connection Points

（支持连接点）选项，在 COM 映射中键入入口，并在类继承性列表中增加IConnectionPointContainerImpl。一个包容器通过它的 IConnectionPointContainer 接口来查询对象，以了解对象支持哪些接口，在我们的例子中是事件接口

_IpulseCtlEvents 。包容器的事件接收器与对象的连接和断开将通过对象的IConnectionPoint 接口进行。 C O M 映射不需要单独的 IConnectionPoint 接口，因为 IConnectionPointContainer 提供了 FindConnectionPoint 方法，它将向 ATL 的代表 _IPulseCtlEvents 的 IConncetionPoint 返回一个指针。图 10-12 说明了包容器如何将它的事件接收器挂接在 Pulse 的事件函数上的步骤。

第四部分 A ctiveX 控件 - 图62

图 10-12 包容器如何建立连接以接收事件启动消息

FindConnectionPoint 和它的姊妹方法 EnumConnectionPoints 读入一个数组，这个数组被称为连接点映射，它包含了控件提供的每一个连接点的接口标识符列表。

Pulse 仅仅支持 _IPulseCtlEvents 的一个连接点，这将在 COM 映射后面的连接点映射中规定：

BEGIN_CONNECTION_POINT_MAP(CPulseCtl)

CONNECTION_POINT_ENTRY(DIID__IPulseCtlEvents) END_CONNECTION_POINT_MAP()

在连接点映射下面，加入如下所示的属性映射。这个映射是空的，因为 Pulse 不支持属性工作表，但是，加入到 CPulseCtl 类中的一些接口实现要求映射存在：

步骤 8 ：编辑 PulseCtl.cpp 文件

在 PulseCtl.cpp 文件中加入下面灰色部分所示的指令，以完成存根函数：

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// CPulseCtl

STDMETHODIMP CPulseCtl::get_nInterval( long *pVal )

{

*pVa l = m_dwTimerInterval ; return S_OK;

}

STDMETHODIMP CPulseCtl::StartPulse( long nRate )

{

if (!m_bTimerOn )

}

STDMETHODIMP CPulseCtl::EndPulse()

{

return S_OK;

}

STDMETHODIMP CPulseCtl::_OnTimer()

{

Fire_Pulse() ; return S_OK;

}

get_nInterval

方

法

通

知

调

用

者

当

前

的

计

时

器

间

隔

，

它

被

存

储

在

CTimer::m_dwTimerInterval 成员变量中。因为我们在步骤 2 中规定 nInterval 属性为只读，所以没有匹配的放置函数。StartPulse 和 EndPulse 实现控件的两个方法，启动和停止计时器。当包容器在结束控件后，没有调用 EndPulse 时，FinalRelease 函数调用 EndPulse ，以确保计时器的工作线程在控件结束前是正确的。

步骤 9 ：编辑 Pulse.rgs文件

早些时候，我们了解到项目的 RGS 文件中包含脚本信息，这是由控件的

D llRegisterServer 函数写入到系统 Registr y（注册表）内的。在步骤 2 中选择 Simple Objec t（简单对象）选项将是 ATL Object WiaZzrd （对象向导）丢失某些一般ActiveX 控件需要的 Registr y（注册表）信息，例如 OLEMISC 标志列表。稍后的附加内容详细讨论了标志，但现在我们仅仅需要在 Pulse 的注册数据上增加一个值，以规定在 M iscStatus Registry 键内所需要的标志。在文本编辑器中打开Pulse.rgs 文件，并增加下列内容：

ForceRemove {8C9BABDD-BCE5-11D1-BEC9-D43CA8CB2F51} = s 'PulseCtl Class'

{

ProgID = s 'Pulse.PulseCtl.1' VersionIndependentProgID = s 'Pulse.PulseCtl' ForceRemove 'Programmable'

InprocServer32 = s '%MODULE%'

{

val ThreadingModel = s 'Apartment'

}

'TypeLib' = s '{3B365F9D-C3AE-11D1-BEC9-E0F4E352507A}'

}

控件入口将 Pulse 作为一个可嵌入的 ActiveX 控件。 M iscStatus 的值 148624 代表

5 个标志的组合值： OLEMISC_SETCLIENTSITEFIRST, OLEMISC_INSIDEOUT, OLEMISC_CANTLINKINSIDE,OLEMISC_INVISIBLEATRUNTIME 和OLEMISC _NOUIACTIVATE ，这些都在稍候的附加内容上有说明。

般地， ATL Object Wizard（对象向导）为控件项目增加了
一个默认位图，但对于像 Pulse 这样的简单对象类型不是这样。如果想增加一个小位图，以增强 Pulse 控件的功能，下面将告诉你处理方法。我们已经看见一些包容器，例如 Visual C++ 对话框编辑器，如何向用户显示代表一个控件的工具按钮上的一幅位图。包容器

从 ActiveX 控件的自身资源数据中提取位图图像，图像由系统 Registr y（注册表）内的控件的 ToolboxBitmap32 键识别。为了插入 ToolboxBitmap32 键，在 Pulse.rgs 文件中连同其他加入的部分一起加入下面的一行：

ForceRemov e 'ToolboxBitmap32 ' = s '%MODULE% , 1 '

个控件的位图是完全可选的，但是，为那些控件加入
一个专业的方法，是市场所需要的。位图的大小是 16 × 15 像素，所以一幅 16 色位图占据了空间资源数据

段的 512 个字节。从 Inser （t 插入）菜单中选择 Resourc e（资源）命令，选择 Bitmap

（位图），然后按下 A lt+Enter，以打开 Bitmap Propertiers （位图属性）对话框。改变工作区域的尺寸到 16 × 15 ，并指定 ToolboxBitmap32 键的资源标识符的值与ForceRemove 语句中给定的值一样。在我们的例子中，这个值是 1 ：

第四部分 A ctiveX 控件 - 图63

OLEMISC 标志

个 ActiveX 控件注册了一组 OLEMISC 位标志，并作为一个
32 位值存储在系统 Registry （注册表）中。标志包括控件的信息，通知包容器控件的特性，运行首选项和功能。将这个信息公布在 Registry （注册表）中，意味着将来的包容器不需要首先将控件嵌入，以了解它的要求和功能。如果一个控件需要包容器无法提供的服务，包容器可以在不浪费加载控件所需的时间和资源的情况下决定匹配是不合适的。

为决定控件的 OLEMISC 标志的设置，包容器可以调用 IOleObject::GetMiscStatus

函数。这个调用并不会将控件载入，因为 OLE 为这个函数提供了默认的实现，

OLEMISC_ACTIVATEWHENVISIBLE ─ ─ 当对象可视时，对象想要被

激活。
OLEMISC_SETCLIENTSITEFIRST ─ ─ 仅仅在使用 ActiveX 控件时使用

，这个标志指出，控件优先使用 IOleObject::SetClientSite 作为它的初始化函数，甚至在调用 IPersiststreamInit::InitNew 或者IPersistStorage::InitNew ，以从磁盘上提取控件的属性数据之前就是如此。这将允许控件在从永久存储加载信息之前，访问包容器的环境属性。注意 O leCreate, OleCreateFromData, OleCreateFromFile, OleLoad 的当前实现和默认处理程序的当前实现并不理解这个值。希望兑现这个标志的控件包容器必须在当前实现这些函数自己的版本，目的是为控件建立正确的初始化顺序。
像 Pulse 这样的不可视控件一般为

OLEMISC_ACTIVATEWHENVISIBLE 设置两个标志：

OLEMISC_INVISIBLEATRUNTIM E─ ─ 通知包容器，控件没有用

户接口，而且不需要显示在屏幕上。
OLEMISC_NOUIACTIVATE - 控件不需要共享用户接口元素，例

如菜单，而且运行时不需要输入焦点。

如果控件有 Objec t Wizard （对象向导）设置的标志所无法识别的其他实时要求，

步骤 10 ：建立和测试 Pulse ActiveX 控件

最后的一步将监督完成 Pulse 项目，并提出如何检查新控件的方法。首先我们选择一个建立的目标。ATL COM AppWizard 按照 4 种公布的配置建立一个 ATL 项目：

配置		预处理定义
释放	M inSize	_ATL_DLL
释放	M inDependency	_ATL_STATIC_REGISTRY

Unicode 释放 M inSize _UNICODE, _ATL_DLL

Unicode 释放

M inDependency

_UNIDOCE,

_ATL_STATIC_REGISTRY

对于 ANSI 和 Unicode 控件项目， M inSize 和 M inDependency 目标为 ATL 服务提供一种选择机会，即控件依赖于一个辅助的实时文件，或者将它所需要的全部代码合并到它自己的可执行文件内。这是在减小文件大小和减小运行时相关性之间进行选择，非常类似在 MFC 项目中，必须在与 MFC 库静态或者动态链接之间进行选择。

M inSize 配置将控件动态链接在 A tl.dll 上，这是 Visual C++ 安装在W indows\System 文件夹下的一个 54KB 的库文件，从而减小控件的大小。当控件运行时，它为控件所要求的服务函数而调用 A tl.dll 。这种安排的结果是，当有几个链接在 Atl.dll 上的 ActiveX 控件一起运行时，将使内存的利用效率最高。在这

种情况下， M inSize 目标也可以在通过网络或者 Internet 传送控件时，减小下载时间，这是因为控件的组合文件大小被减小了 ─ ─ 即使考虑加上 A tl.dll 也是如此， Atl.dll 将与控件一起传送。

M inDependency 配置将设置控件项目，使编译器扩展类模板到整个类，而不是调用 Atl.dll 的存根函数。在这种配置下，控件自身包括它需要的接口实现代码，就像 ATL 服务被静态链接一样（这仅仅是一个类比，因为对于 ATL 没有像 MFC 那样的静态库 LIB 文件）。产生的 ActiveX 控件并不依赖与 A tl.dll 文件，它用较大的执行映像换来了独立性。M inDependency 目标最好用于那些不会与其他 ATL 控件一起运行的单个的控件。因为 Pulse 符合这样的条件，所以在 Build 工具栏中选择 Release MinDependency 配置：

第四部分 A ctiveX 控件 - 图64

从配套光盘上安装的项目文件将目标名字简化为 M inSize 和 M inDep，这样可以是文件夹名字小于 8 个字母。如果没有比在系统注册表中减小它们所占的空间更重要的原因，你最好为你自己的 ATL 项目选择短目标名字。为了修正 C O M AppWizard 所设置的目标名字，暂时关闭工作空间，然后在文本编辑器中打开项目的 DSP 文件。用 Replac e（替换）命令，用“ M inDep ”替换所有存在的“ Release M inDependency ”和“ ReleaseMinDependency ”。按照类似的步骤，缩短 M inSize 目标的名字。将 DSP 文件存盘，并重新打开项目。你就可以看见在 Buil d（建立）工具栏中列出的新目标名字。

至今为止，我们还没有讨论编译器优化，那是第 12 章的内容，但是， Visual C++ 优化器可以增加执行速度，或者减小代码大小。后者通常是 ActiveX 控件的最佳选择，所以 COM AppWizard 为你预先选择了小代码空间优化设置。如果这不是你需要的，改变 Project Setting（项目设置）对话框的 C++ 选项卡的选项。在你

选择目标配置之后，单击 Build （建立）菜单上的 Build Pulse.dll 命令，编译和链接 Pulse 控件。如果所有编译和链接步骤成功结束， Visual C++ 将运行RegSvr32.exe 来注册控件，并在 Outpu t（输出）窗口中显示结果：

Registering ActiveX Control…

Regvr32: DllRegisterServer in .\MinDep\Pulse.ocx succeeded

注意：如果你的 ActiveX 控件需要 C 实时服务，首先除去阻止链接到运行库的预处理定义。在 Project Setting （项目设置）对话框的 C++ 选项卡内，删除标有Preprocessor Definitions （预处理定义）的框内的常量 _ATL_MIN_CRT 。

列表 10-3 所列出的 Tumble2.htm 文档展示了新控件。如果你按照这里所描述的步骤创立 Pulse 控件，则它的一个类标识符与配套光盘上的 Pulse.ocx 控件所用的不同。在这种情况下，你必须在 Tumble2.htm 文档中放置对 Pulse 对象的 classid 语句：

<OBJECT

classid="clsid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" id=pulse1

项目的 IDL 文件提供了你所需要的新类标识符。从 Pulse.idl 文件中最后一行的uuid 语句将标识符拷贝到剪贴板内，然后将其粘贴在 Tumble2.htm 文档内，以改变 classid 的值。尽管 Tumble2 使用不同的计时器，它的动画显示与原始 Tumble 文档相同。

width=150

height=150

</OBJECT>

第四部分 A ctiveX 控件 - 图65

图 10-13 在 Test Container 中测试 Pulse ActiveX 控件

Test Containe r（测试包容器）实用程序也可以成功地嵌入我们的新控件，就像图

10-13 中说明的那样。启动 Test Container（测试包容器），然后选择 New Control

（新控件）工具，并双击列表中的 PulseCtl 类入口，加载 Pulse 控件（列表是按照阿拉伯字母排列的；在键盘上按下 P ，将自动滚动到以 P 打头的第一个控件处）。一旦控件被加载到 Test Containe r（测试包容器）内，单击 Invoke Methods

（激活方法）工具，按照图 10-13 所示，在 M ethod Name Box （方法名称框）中选择 StartPulse 方法，将 nRate 参数设置为 2000 ，然后单击 Invok e（激活）按钮。这将使控件每 2 秒启动它的 Pulse 事件， Test Container（测试包容器）将为事件日志增加一个新入口而检查这一点。激活 EndPulse 方法结束启动。

如果想了解 Pulse.ocx 如何被嵌入到一个普通的包容器中应用程序中，运行配套光盘上文件夹 Code\Chapter.10\Hour2 。 Hour2 使用 Pulse 控件作为它的计时器，而不是 IETimer 控件，除了这一点之外， Hour2 与第 8 章 Hour 程序相同。

例子 2 ： TowerATL ActiveX 控件

Pulse 项目证明 ATL 可以帮助你创立比利用 MFC 产生的控件更小的 ActiveX 控件，但是，对 ATL 和 MFC 的精确比较，只有通过利用两种工具建立同样的控件才能进行。这正是我们在这一章所讲述的内容。正如标题所指出的那样， ToweerATL 控件复制第 9 章的 Tower 项目，输出相同的属性、方法和事件。但是， TowerATL 是完全利用 ATL 的服务创立的，没有用到 MFC 。

TowerATL 是一个比 Pulse 更复杂的 ActiveX 控件，包含有栈属性、属性工作表和一个 About 框。尽管如此，这个项目看起来比较容易，因为讨论更加紧凑，而且我们在 Pulse 项目中所注意过的部分占据较小篇幅。现在已经排除了大多数的不相关的东西，这个项目更加精确地反映了用 ATL 创立一个典型 ActiveX 控件所需要的时间和努力。

步骤 1 ：创立 TowerATL 项目

再次运行 ATL COM AppWizard ，这一次将项目命名为 TowerATL 。单击 Finis h（结束）按钮接受默认设置，这将是 TowerATL 控件成为一个不需要 MFC 的动态链接库。当 COM AppWizard 结束后，从 Inser t（插入）菜单中选择 New ATL Object

（新 ATL 对象），启动 ATL Object Wizard （对象向导）。选择对话框的第一个列表内的控件，然后双击标有 Full Contro l（完整控件）的图标。 TowerATL 支持比Pulse 更多的接口，我们将需要像 IQuickActivate 和 ISpecifyPropertyPages 这样的接口，它们由 Full Control （完整控件）选项加入到源代码中。

注意，在对话框中， ATL 将控件的属性页作为一个单独的对象。在结束这个项目之前，返回到 Object Wizard（对象向导），以增加一个属性页对象。在 Properties

（属性）对话框的 Names （名称）选项卡中键入 TowerCtl 作为短名字，接受其他框内的默认名字。在 A ttribute s（属性）选项卡内，与我们在 Pulse 项目中一样，选择 Support Connection Points（支持连接点）复选框。接受选项卡内的其他默认

设置，启用公寓线程、双接口和聚合。

M iscellaneous（杂项）选项卡包括设置各种 OLEMISC 标志的开关。例如，选择Acts Like Butto n（按钮功能）复选框，设置 OLEMISC_ACTSLIKEBUTTON 标志，这将告诉包容器，控件将对鼠标单击作出响应，并通常作为一个按钮动作。 Acts Like Labe l（选项卡功能）复选框设置 OLEMISC_ACTSLIKELABEL 标志，这将通知包容器，这个控件作为按选项卡顺序紧跟其后的控件的选项卡使用，就是在包容器的 RC 脚本内列出的下一个控件。 Invisible At Runtim e（运行时不可见）复选框将打开 OLEMISC_INVISIBLEATRUNTIME 标志，这适合像 Pulse 这样的在激活时仍然不可视的控件。

跳过 M iscellaneous 选项卡，接受它的默认设置，并进入 Stock Propertie s（栈属性）选项卡。与 Tower 的 MFC 版本类似， TowerATL 控件包括 4 个栈属性，名字为BackColor, ForeColor, Caption 和 Fon t。在列表中选择每一个属性，并单击 > 按钮，就可以在 Supported （支持）框内增加这些属性，如图 10-14 所示（ BackColor 和ForeColor 属性在列表中标为 Background Color 和 Foreground Color ）。单击 O K 按钮，关闭 ATL Object Wizard （对象向导）对话框。

第四部分 A ctiveX 控件 - 图66

图 10-14 在 ATL Object Wizard （对象向导）内选择栈属性

步骤 2 ：加入 nCurrentBlock 用户属性

与 4 个栈属性一起，TowerATL 具有一个称为 nCurrentBlock 的用户属性，这个属

性保留了一个数，用于识别正在被拖动的块。从技术上讲，它是由通过get_nCurrentBolck 方法显露这个属性的对象所继承的 ITowerCtl 接口。为了给ITowerCtl 接口加入这个用户属性，在 ClassView 窗口中展开 TowerATL 类列表，用鼠标右键单击 ITowerCtl 入口，然后选择 Add Property （加入属性）命令，以激活 Add Property To Interface （为接口加入属性）对话框。选择 short 作为属性类型，并键入 nCurrentBolck 作为属性的名字。就像我们在第 9 章中所做的一样，使 cCurrentBlock 属性具有只读特性，以阻止一个包容器应用程序改变它的值。清除标有 Put Functio n（放置函数）的单选钮，以告诉 Object Wizard（对象向导）不要为这个属性产生放置方法，然后关闭这个对话框。

步骤 3 ：加入 Rese t方法

TowerATL 导出了一个称为 Reset 的方法函数，包容器应用程序利用这个函数告诉控件再次启动程序，重新启动左面板中的所有块。再次用鼠标右键单击ClassView 中的 ITowerCtl 接口，选择 Add Metho d（加入方法）命令，然后在 Add M ethod To Interfac e（为接口加入方法）对话框中键入 Reset 作为函数名字。这个方法没有参数，所以使参数框保持空白。

单击 O K 关闭 Add Metho d（加入方法）对话框，此时 Visual C++ 将在这个项目的IDL 文件中为这个方法加入适当的代码，并在 TowerCtl.cpp 文件中写入一个存根Reset 函数。在控件中加入消息处理程序和事件之后，我们将编辑这些代码。

步骤 4 ：加入处理程序函数

如果你回忆第 9 章的内容，控件窗口将对 WM_LBUTTONDOWN 消息作出响应，方法是初始化一个拖动操作，在这个操作中，用户将一个彩色块从一个面板移动到另一个。WM_LBUTTONDOWN 消息表示这个块已经被拖动到位。项目的第 4 步非常简单，只需要加入存根函数以处理两条消息。

在 ClassView 窗格中，用鼠标右键单击 CTowerCtl 入口，并从菜单中选择 Add W indow Message Handler （加入窗口消息处理程序）。双击列表中的WM_MOUSEMOVE, WM_LBUTTONDOWN 和 WM_LBUTTONU P ，以将它们

加入到右边的框中，然后关闭对话框。

第四部分 A ctiveX 控件 - 图67

步骤 5 ：加入事件

与原来的 Tower 控件一样，TowerATL 启动 5 个事件，名称分别为 Click, FromPanel, ToPanel, Error 和 W inner 它们共同保证使包容器了解对控件所发生的事件。在项目中加入这些事件的步骤与我们对 Pulse 控件的操作是一样的：

在 ClassView 窗格中用鼠标右键单击 _ITowerCtlEvents 入口
，并从关联菜单中选择 Add Method s（加入方法）命令，然后在对话框中选择 void 返回类型，并键入一个函数名字。对所有 5 个事件函数重复这些操作。只有 FromPanel 和 ToPanel 带有参数，分别为 nFromPanel 和 nToPanel ，这两个参数的类型都是 short 。

第四部分 A ctiveX 控件 - 图68

在 Workspace 窗口的 FileView 窗格中，用鼠标右键单击
TowerATL.idl

的入口，并选择 Compile （编译）命令，以创建这个项目的类型库文

件。忽略来自 MIDL 编译器中的警告信息“ interface does not conform to [oleautomation] attribute ”。这个警告信息是因为编译器认为 pFont 参数

─ ─ 一个指向 IFontDisp 接口的指针 ─ ─ 不是一个兼容 Automation 的类型。但是因为 IFontDisp 来自与 IDispatch ，这是一个合法的Automation 接口，所以这条警告信息是不正确的。

在 ClassView 窗格中，用鼠标右键单击 CTowerCtl ，并从菜
单中选择

Implement Connection Poin t（实现连接点）命令。

设置标有 _ITowerCtlEvents 的复选框，然后单击 O K 关闭
对话框。

在这里，我们为项目加入事件的步骤与我们在前面章节中用 MFC 开发 Tower 控件时所用的步骤是类似的，尽管看起来可能不是这样。在这些操作之后，第 9 章中的 ControlWizard 将创建一个 O D L 文件（与IDL 类似），其中包含了这些指令：

//{{AFX_OLD_EVENT(CTowerCtrl) [id(DISPID_CLICK)] void Click (); [id(1)] void FromPanel (short nPanel); [id(2)] void ToPanel (short nPanel);

[id(DISPID_ERROREVENT)] void Error() ; [id(3)] void Winner();

//}}AFX_ODL_EVENT

从这些信息中， ClassWizard 产生像 FireClick 和 FireWinner 这样的代理函数，它们将调用 MFC 的 COleControl::FireEvent 函数。然后 FireEvent 将调用包容器的IDispatch::Invoke 方法，这些与 ATL 产生的代理函数完全一样。

步骤 6 ：加入属性工作表

第 9 章的 Tower 控件提供了一张属性工作表，这允许用户改变控件的标题，字体和颜色。图 9-13 显示了属性工作表的外观。在这一节，我们将为 TowerATL 创建一个类似的属性工作表。

ATL 将控件的属性工作表的每一页设置为一个独立的对象，通过从 IPropertyPage 导出的一个类来实现。系统的 Msstkprp.dll 库为标有 Font（字体）和 Colors （颜色）的属性页提供默认的类实现，这将允许用户改变 Font, BackColor 和 ForeColor 栈属性。这些栈属性将依次决定显示在 TowerAtl 窗口顶部的标题的字体和颜色。为提供访问 Caption 栈属性的方法，它其中包含了控件标题的文本，我们必须像以前对原来的 Tower 控件的操作一样，多加入一个标为 Caption 的属性页。在控

件中加入一个属性页需要 ATL 的 Object Wizard （对象向导）提供服务，为你想加入的每一页运行 Object Wizard （对象向导）。为加入 TowerATL 的新 Caption 页，在 Object Wizar d（对象向导）的左框中选择 Control s（控件），并双击 Property Page （属性页）图标：

第四部分 A ctiveX 控件 - 图69

当出现 ATL Object Wizard Properties （ ATL 对象向导属性）对话框时，键入

TowerPPG 作为对象的短名字：

第四部分 A ctiveX 控件 - 图70

像以前一样，向导将帮助我们用推荐的名字填充其他框。 Interface （接口）框是灰色的，因为一个属性页对象不需要用户接口。接受 Attributes （属性）选项卡

内的默认设置，并选择 String s（字符串）选项卡。键入 &Caption 作为页的标题，在标有 Doc String （ Doc 字符串）的框内键入 Caption property 。 TowerATL 不会提供帮助文件，所以删除第 3 个编辑框内的文本，并保持空白。

Object Wizard （对象向导）将标题和文档字符串写入项目的 RC 文件，在这里，它们变成控件的字符串资源数据的一部分。标题规定了出现在新属性页的选项卡上的内容。文档字符串被用作选项卡的工具提示文本，它将在鼠标光标移动暂停在选项卡上时，描述这一页的作用，但是这一个字符串并不经常使用，并且不会作为工具提示或者其他的东西出现。这是因为负责创建属性工作表窗口的 OLE 运行 O leCreatePropertyFrame 函数，在 OLE 术语中被称为属性帧，并不支持工具提示。

单击 O K 按钮，关闭对话框，此时 Object Wizar d（对象向导）将在项目中加入这些：

加入 TowerPPG.cpp 和 TowerPPG.h 文件，以实现新 CTowerPPG 类。
在 TowerATL.rc 文件中为标题和工具提示写入字符串资源

：

IDS_TITLETowerPPG "Caption" IDS_DOCSTRINGTowerPPG "Caption property"

为新属性页对象在 TowerATL.idl 文件中追加一个标识符
和 coclass 入口。

[

uuid(05D2BAA4-C471-11D1-BEC9-FB1AF66FCC79),

helpstring("TowerPPG Class")

]

coclass TowerPPG

{

interface IUnknown;

};

加入 Towerppg.rgs 文件，为新对象提供注册表脚本。
在 TowerATL.cpp 文件中的控件对象映射中为页插入一个

入口。

BEGIN_OBJECT_MAP(ObjectMap)

OBJECT_ENTRY(CLSID_TowerPPG, CTowerPPG) END_OBJECT_MAP()

当 Object Wizar d（对象向导）完成这些操作后，将自动出现对话框编辑器，这表示它已经准备好让你开始设计新属性页。用静态和编辑控件工具编辑对话框，使对话框看起来就像这样：

第四部分 A ctiveX 控件 - 图71

你自己的属性页的精确布置并不重要，但是，要像图中那样为编辑框指定一个

IDC_CAPTION 的标识符（为激活 Properties 对话框，选择编辑框，并单击 Edit

（编辑）菜单上的 Properties（属性））。存盘，并关闭对话框编辑器。

此时 TowerATL 控件已接近完成了。剩下的最重要的工作是在 ATL 产生的骨架源文件中加入代码。这是下一步的事情。

步骤 7 ：编辑 Towerppg.h 文件

TowerPPG.h 文件包含对应 CTowerPPG 类的代码，这个类用与处理控件的 Caption 属性页对象。我们仅仅需要在类上加入一些指令，以在用户键入新 Caption 字符串时监视页的编辑框和调用 put_Caption 方法。用鼠标右键单击 ClassView 窗格中的 CTowerPPG 类，并选择 Add Windows Message Handle r（加入窗口消息处理程序）命令。当 New Windows Message （新窗口消息）对话框出现时，在标有Class Or Object To Handle （处理的类或对象）的小框内选择 IDC_CAPTION ，并在列表中双击 EN_CHANG E 。接受 OnChangeCaption 这个名字作为函数名字，并关闭 New Windows Message （新窗口消息）对话框。

当用户在我们前面所加入的属性页的编辑框中键入字符时，将运行OnChangeCaption 函数，这样产生修正 Caption 属性的意图。这个函数仅仅通过传递一个值 TRUE 到 SetDirty 子函数，使对话框的 Apply （应用）按钮可用。单击属性工作表对话框中的 O K 或者 Apply （应用）按钮将运行 Apply 函数，它需要额外的代码。在文本编辑器中打开 TowerPPG.h 文件，并加入这些行：

#include "resource.h" // main symbols

#includ e "TowerAtl.h "

STDMETHOD(Apply)(void)

{

CComQIPtr<ITowerCtl > pTower ( m_ppUnk[0 ] ) ;

m_bDirty = FALSE; return S_OK;

}

LRESULT OnChangeCaption(WORD wNotifyCode, WORD wID,

HWND hWndCtl, BOOL& bHandled)

{

return 0;

}

Apply 函数调用 GetDlgItemText 将新标题字符串从编辑框拷贝到 szCaption 缓冲区中，然后调用控件的 put_caption 方法按照新字符串放置 Caption 属性。put_Caption 方法需要一个 BSTR 参数，所以代码用 ATL 宏 A2BSTR 来将 szCaption 中的 ANSI 字符串转换为 BSTR 类型。正如 Apply 函数所证明的那样，在激活像A2BSTR 这样的转换宏之前，必须包含 USES_CONVERSION 宏。这样做将消除转换所带来的编译器错误。

这段代码也证明一个 ActiveX 控件如何利用 CComQIPtr 灵巧指针模板类。因为

put_Caption 是 CTowerCtl 的一个子函数，而不是 CTowerPPG 的，所以这个函数必须首先通过 QueryInterface 接收一个指向 ITowerCtl 的指针。将 pTower 作为一个灵巧指针，将确保 ITowerCtl::Release 在 GetDlgItemTest 或者 put_Caption 不大可能出现错误的事件中被调用。

步骤 8 ：编辑 TowerCtl.h 文件

完成 TowerATL 项目需要用文本编辑器进行较多的编辑工作，为 Tower 加入与我们在第 9 章中所加入的源代码一样的部分。打开 TowerCtl.h 文件，并找到TowerATL 中彩色显示的以 #define 语句开头的部分：

#include "resource.h" //main symbols #include <atlctl.h>

#include "TowerCP.h"

续表

#define EMPTY NUM_BLOCKS

#define BLACK RGB( 0, 0, 0 )

#define BLUE RGB( 0, 0, 255 )

#define CYAN RGB( 0, 255, 255 )

#define GREEN RGB( 0, 255, 0 )

#define MAGENTA RGB( 255, 0, 255 )

#define RED RGB( 255, 0, 0 )

#define YELLOW RGB( 255, 255, 0 )

#define WHITE RGB( 255, 255, 255 )

#define GRAY RGB( 128, 128, 128 )

然后，在 CTowerCtl 类中为我们在原来的 Tower 项目中使用的相同的子变量加入声明：

class ATL_NO_VTABLE CTowerCtl :

{

public:

HRESULT#FinalConstruct() ; CTowerCtl()

{

}

一个像 CTowerCtl 这样的使用数据的对象必须覆盖 CComObject- RootEx::FinalConstruct 子函数，就像这里说明的一样。与 MFC 的有用的OnInitDialog 函数非常类似，在 ATL 完成设置对象之后，对象被激活之前，将调用 FinalConstruc t。正是在这里，而不是在其他的类操作时，控件必须执行它自己的大部分初始化工作。在 Pulse 控件中已经被说明的匹配的 FinalRelease 函数允许控件执行任何必要的清除工作。

更改属性映射，以建立 Caption, Color 和 Font 在控件的属性工作表中出现的顺序：

BEGIN_PROP_MAP(CTowerCtl)

PROP_PAGE( CLSID_TowerPPG )

PROP_PAGE( CLSID_StockColorPage )

PROP_ENTRY( "Font", DISPID_FONT, CLSID_StockFontPage ) END_PROP_MAP()

这个消息映射包含在步骤 4 中加入的控件的 3 个消息处理程序的入口：

BEGIN_MSG_MAP(CTowerCtl)

MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)

MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown) MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp)

END_MSG_MAP()

当用户按下和松开左鼠标按钮，在面板之间拖动彩色块时， OnLButtonDown 和

OnLButtonUp 函数将进行控制。当鼠标移动时， OnMouseMove 进行控制，它的作用仅仅是当用户拖动一个块时，保证光标保持交叉形状。

所有带有 MESSAGE_HANDLER 宏的在消息映射中列出的函数必须具有相同的参数列表：

LRESULT MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);

最前面的 3 个参数是标准的消息参数。例如， OnLButtonDown 处理程序，接收uMsg 参数中的值 WM_LBUTTONDOWN ， wParam 中的当前键状态和 IParam 中的鼠标光标的坐标。在调用处理程序函数之前， MESSAGE_HANDLER 宏将bHandled 标志设定为 TRUE 。一个不能完全满足消息要求的处理程序在返回之前要清除这个标志：

*bHandled = FALSE

否则， MESSAGE_HANDLER 宏产生的代码将立即返回，向操作系统指出消息已经被完全处理了。

个 ATL 消息映射与在 MFC 中的映射具有一样的形式。 ATL
通过向

W M _ C O M M A N D 和 WM_NOTIFY 消息提供 COMMAND_HANDLER 和

NOTIFY_HANDLER 宏，而进一步与 MFC 匹配。为了用一个函数处理一组不同

的消息，用一个 R A N G E 宏替代： MESSAGE_RANGE_HANDLER, COMMAND_RANGE_HANDLER 或者 NOTIFY_RANGE_HANDLER 。与 MFC

中的 ON_COMMAND_RANGE 和 ON_NOTIFY_RANGE 类似，这些宏为所有在规定值范围内的消息规定一个处理程序函数。 Visual C++ 将函数 OnDraw, OnMouseMove, OnlButtonDown 和 OnlButtonUp 定义为 CTowerCtl 类声明中的内联函数。为了在同一个地方实现代码，并帮助与原来的 Tower 源文件进行比较，将这 4 个函数移动到 TowerCtl.cpp 文件中，我们将在下面讨论它。当然，剪切和粘贴是完全可选的；如果你按照本文创立这个项目，并喜欢将这些函数放在头文件中，只需要按照下一节所讲的内容编辑它们的代码。

在关闭 TowerCtl.h 文件之前，有必要进行最终的检查。在类声明的结尾，一些版本的 Visual C++ 写下了一个名为 m_spFont 的子变量。这个名字必须换为m_pFont ，以防止栈的 Font 页的 ATL 实现产生错误：

CComPtr<IFontDisp>m_pFon t

步骤 9 ：编辑 TowerCtl.cpp 文件

TowerCtl.cpp 的源代码与我们为原来的 Tower 项目的相同文件加入的代码非常相似。事实上，它们相似的程度，使得第 9 章中的代码仍然适用于这个控件的新版本。因为这个文件需要扩充，列表 10-4 列出了完整的编辑后的版本。

控件的 MFC 和 ATL 版本之间的一个重要区别是 TowerCtl.cpp 中如何进行初始化。 Tower 控件使用类构造器和 PreCreateWindow 虚拟函数来初始化它的数据，而现在 TowerATL 使用 ATL 的 FinalConstruct 函数。

按排初始化工作仍然是相同的；只是位置发生了变化。

列表 10-4 TowerCtl cpp 文件

// CTowerCtl

HRESULT CTowerCtl::FinalConstruct()

{

color[0] =BLACK; // Initialize block colors

color[1] =BULE;

color[2] =CYAN;

color[3] =GREEN;

color[4] =MAGENTA;

color[5] =RED;

color[6] =YELLOW;

m_clrBackColor = GRAY; //Default background color,

m_clrForeColor = WHITE; // foreground color,

m_bstrCaption = “ TowerATL ” ; // and caption

m_bAutoSize = FALSE; //Control can be resized

m_sizeExtent.cx =7000; //Init HIMETRIC size for

m_sizeExtent.cy =2500; // 4 x 1.5 width/heiht ratio

Reset(); //Initialize panels

// Cursors for normal (arrow) and dragging (crosshairs)

hArrow = LoadCursor( NULL, IDC_ARROW);

hCrossHairs= LoadCursor( NULL,IDC_CROSS);

return S_OK;

}

HRESULT CTowerCtl::OnDraw( ATL_DRAWINFO& di)

{

RECT& rc=*(RECT*)di.prcBounds;

RECT rect;

TEXTMETRIC tm;

HPEN hPen,hPenOld;

HBRUSH hBrush, hBrushOld;

HFONT hFont, hFontOld;

int I,j,k,yCaption;

USES_CONVERSION;

//Paint control background

hBrush = CreateSolidBrush( m_clrBackColor);

hBrushOld=(HBRUSH) SelectObject(di.hdcDraw,hBrush);

FillRect(di.hdcDraw,&rc,hBrush);

// Set caption color and font

SetBkMode(di.hdcDraw,TRANSPARENT);

SetTextColor(di.hdcDraw,m_clrForeColor);

if (m_pFont)

{

CComQIPtr<Ifont> pFont(m_pFont);

pFont->get_hFont(&hFont);

hFontOld=(HFONT) SelectObject( di.hdcDraw,hFont);

}

else

{

hFont = (HFONT) GetStockObject( SYSTEM_FONT);

hFontOld=NULL;

}

// Display caption

CopyRect( &rect, &rc);

DrawText( di.hdcDraw,OLE2A( m_bstrCaption ), -1,

&rect, DT_CENTER | DT_TOP );

// Compute height of Caption area

GetTextMetrics( di.hdcDraw,&tm);

yCaption = tm.tmHeight + tm.tmExternalLeading;

// Compute width and height of a panel

iLeft = rc.left;

iWidth = (rc.right - rc.left)1/3;

iHeight = rc.bottom - rc.top - yCaption;

// Draw column dividers

hPen = CreatePen( PS_SOLID, 1, m_clrForeColor );

hPenOld = (HPEN) SelectObject( di.hdcDraw, &hPen);

MoveToEx(di.hdcDraw,rc.left+iWidth, rc.top+yCaption, 0 );

LineTo( di.hdcDraw,rc.left+iWidth, rc.bottom );

MoveToEx(di.hdcDraw, rc.left+iWidth*2, rc.top+yCaption, 0 );

LineTo( di.hdcDraw,rc.left+iWidth*2, rc.bottom);

// Outer loop: for each panel

for (i=0 i < 3 i++)

{

rect.top = rc.top + yCaption;

rect.bottom = rect.top + iHeight/NUM_BLOCKS;

// Inner loop: for each colored block in panel…

for (j=0; j <NUM_BLOCKS; j++)

{

if (nPanel [I] [j] != EMPTY)

{

// Determine left and right edges of block

k= NUM_BLOCKS - 1 - nPanel [I] [j] ;

rect.left = rc.left + iWidth*I +

(iWidth*K) /(2*NUM_BLOCKS) + 1;

rect.right = rect.left +

iWidth*(nPanel[I][j]+1)/NUM_BLOCKS - 1;

// Fill rectangle with block ’ s color

hBrush = CreateSolidBrush( color[nPanel[I][j]] );

SelectObject( di.hdcDRAW, &rect,hBrush );

}

rect.top = rect.bottom;

rect.bottom += iHeight/NUM_BLOCKS;

}

SelectObject(di.hdcDraw, &hPenOld );

SelectObject( di.hdcDraw, &hBrushOld );

if (hFontOld)

SelectObject( di.hdcDraw, &hFontOld );

DeleteObject(hPen);

DeleteObject(hBrush);

return S_OK;

}

STDMETHODIMP CTowerCtl::get_nCurrentBlock( short *pVal_

{

*pVal = nPanel[nFromPanel][nBlockNdx];

return S_OK;

}

STDMETHODIMP CTowerCtl::Reset()

{

int I;

for (I=0; I < NUM_BLOCKS; I++) // Initialize panel array

{

nPanel [0][i] = I; // Panel 0 = 0,1,2,3,4,5,6

nPanel[1][i] = EMPTY; // Panel 1= 7,7,7,7,7,7,7

nPanel[2][i] = EMPTY; // Panel 2= 7,7,7,7,7,7,7

}

nBlockNdx =0; // Ndx of block being moved

nFrom Panel =0;

FireViewChange();

return S_OK

}

////////////////////////////////////////////////////////////////////////////////////////////////////

// CTowerCtrl message handlers

LRESULT Ctowertl::OnLButtonDown( UINT uMsg, WPARAM wParam,

LPARAM Lparam, BOOL& bHandled)

{

short i = 0;

int x = LOWORD( Lparam);

nFromPanel = GetPanel( x );

while (nPanel[nFromPanel][I] == EMPTY && i < NUM_BLOCKS)

i++; // i =ndx of smallest block

if (I < NUM_BLOCKS) // Does panel have a block?

{

bMoving = TRUE; // If so, block is moving

nBlockNdx = I; // Save ndx of the block

Fire+FromPanel( nFromPanel); // Tell container panel #

// change cursor to crosshairs while dragging

SetCursor( hCrossHairs);

}

return 0;

}

LRESULT CTowerCtl::OnLButtonUp(UINT uMsg,WPARAM wParam,

LPARAM Lparam,BOOL& bHandled)

{

short i = 0, nToPanel;

int x= LOWORD( Lparam );

nToPanel = GetPanel( x); // Panel where block is dropped

if (bMoving && nToPanel != nFormPanel)

{

while (nPanel[nToPanel][i]==EMPTY && I <NUM_BLOCKS-1)

i ++; // I - ndx of panel’ s smallest block

// Is dragged block smaller than smallest block in panel?

If (nPanel [nFromPanel][nBlockNdx]< nPanel [nToPanel][I])

{

if (nPanel [nToPanel][I] != EMPTY)

--I;

nPanel[nToPanel][I] = nPanel[nFromPanel][nBlockNdx];

nPanel[nFromPanel][nBlockNdx] = EMPTY;

Fire_ToPanel( nToPanel ); // Tell container

if (i== 0 & & nToPanel == 2) // If we’ve filled

{ // the third panel,

Fire_Winner (); // fire Winner event

Reset (); // and reset game

}

FireViewChange();

}

else // If invalid drop,

Fire_Error (); // tell container

}

// Restore original arrow cursor

SetCursor( hArrow);

bMoving = FALSE; // Not moving now

return 0;

}

short CTowerCtrl :: GetPanel ( int x )

{

short I = 0;

x -= iLeft; //Convert x to window coords

if (x > iWidth) //Hit test:

i =1; //I = 0 for first panel

if (x > iWidth*2) // =1 for second panel

i = 2; // = 2 for third panel

return i; // Return panel number

}

步骤 10 ：加入 Abou t框

除了属性页外， ATL Object Wizar d（对象向导）也可将一个对话资源作为一个独立的对象加入到控件项目中。这一节将通过为 TowerATL 项目创立一个 About 框，从而解释如何在 ActiveX 控件中合并对话框对象。许多开发者不愿意在ActiveX 控件中加入 About 框，这是可以理解的，因为即使一个最简单的对话框，也将在 OCX 文件中增加至少 2KB 资源数据。但是，一个 About 框对于你自己的控件可能需要的任何类型的对话框而言，是一个非常好的说明。更重要的是，项

目设计迫使我们尽可能地接近原来的 Tower 控件，原来的 Tower 控件中包括由

MFC ControlWizard 支持的自己的 About 框。

第四部分 A ctiveX 控件 - 图72

图 10-15 为 ATL ActiveX 控件项目加入对话框资源

这一节的内容是自我包容的，与练习的其他部分保持独立性。它将在同一个位置说明包含一个对话框资源的所有必须的步骤，所以如果你希望不影响项目的其余部分，你可用忽略这一节的内容。为了加入 TowerATL 的 About 框，再次允许ATL Object Wizard （对象向导），这一次，在左框中选择 M iscellaneou s，并双击D ialog （对话框）图标。按照图 10-15 命名对象 TowerBox ，并单击 OK ，关闭对话框。

Object Wizar d（对象向导）为类 CTowerBox 产生源代码，它被包含在 TowerBox.cpp 和 TowerBox.h 文件中。如果你想使用在另一个项目中的一个 About 框资源，只需要将对话框脚本合并到 TowerATL.rc 中，并在 Resource.h 文件中加入必要的#define 语句。如果不是这样，在对话框编辑器中设计 About 框，在你关闭 Object W izard （对象向导）时，对话框编辑器将自动启动。下面是对话框可能的样子：

第四部分 A ctiveX 控件 - 图73

这个对话框借用了项目的位图，所以这种装饰图并不代表资源控件的奢侈浪费。首先将 TowerCtl.bmp 文件从 Code\Chapter.10\TowerATL 文件夹内拷贝到你的项目中，覆盖有 ATL Object Wizard （对象向导）提供的相同名字的 B M P 文件。用Picture（图像）工具将图像放在对话框编辑器内，然后弹出 Porpertie s（属性）对话框，并在 Type（类型）框内选择 Bitmap （位图），在 Image （图像）框内选择标识符。最后一行的编辑框是可选的，仅仅为了方便显示控件正在其上运行的线程的标识符。这将使我们可用在独立公寓中运行的时候，确认一个像 TowerATL 这样的公寓线程控件的动作。给编辑框分配一个 IDC_THREAD_ID 标识符，并在 Propertie s（属性）对话框内设置 Read Only （只读）复选框。

在完成设计 About 框后，将对话框资源存盘，然后在 ClassView 窗格中用鼠标右键单击 ITowerCtl ，并选择 Add Metho d（加入方法）命令。如下所示键入 AboutBox 作为新方法的名字。与 Reset 方法类似， AboutBox 没有参数。

第四部分 A ctiveX 控件 - 图74

在文本编辑器中打开 TowerBox.h 文件，并在 OnInitDialog 函数中加入下面灰色显示的指令。在 About 对话框出现之前，代码将从系统中提取线程标识符，并将

其写入到 IDC_THREAD_ID 编辑框中：

LRESULT OnInitDialog(UINT uMsg, WPARAM wParam,

LPARAM lParam, BOOL& bHandled)

{

return 1; // Let the system set the focus

}

然后重新打开 TowerCtl.cpp 文件，并在新 AboutBox 函数中加入这些行：

STDMETHODIMP CTowerCtl::AboutBox()

{

CTowerBo x dlgAbout ;

dlgAbout.DoModal() ; return S_OK;

}

当一个包容器应用程序调用控件的 AboutBox 方法时，这个函数将创立一个CTowerBox 对象，并激活这个对话框。下一节中的 Game2 程序证明了一个应用程序如何通知 TowerATL 显示它的 About 框。

步骤 11 ：建立和测试 TowerATL ActiveX 控件

选择 Release MinDependency （或 M inDep ）配置，并建立 TowerATL 控件，在

Visual C++ 成功编译、链接和注册这个控件之后，你可以在任何 ActiveX 软件包

容器应用程序中测试完成的产品。图 10-16 显示了在 Test Contain e（r 测试包容器）

实用程序中带有属性工作表的 TowerATL 的样子。在将 TowerATL 加入到 Test Containe r（测试包容器）窗口之后，单击 Properties （属性）工具，以显示控件的属性工作表。

第四部分 A ctiveX 控件 - 图75

图 10-16 在 Test Containe r（测试包容器）内显示的 TowerATL 属性工作表

为了说明，可以在 Test Container 中加载另一个 TowerATL 控件的实例，并用 Invoke M ethods（激活方法）工具激活每一个实例的 About 框。你将会发现两个实例中显示在 About 框中的线程标识符是相同的，这证明 Test Container（测试包容器）在一个线程上创建所有的控件实例。另一方面，Internet Explorer 在一个独立的线程上运行每一个窗口，我们可以用显示在列表 10-5 中的简单的 TowerCtl.htm 文档证明这一点。在配套光盘的 Code\Chapter.10\TowerAtl 文件夹下找到这个文档。如果你创建了你自己版本的 TowerATL ，首先用控件的类标识符放置这个文档的classid 入口，从项目的 IDL 文件中拷贝字符串，这就和我们前面对 Tumble2.htm 文档的操作一样。然后按照这些步骤进行试验：

列表 10-5 TowerCtl.htm 文件

<OBJECT

classid="clsid:3B365FBA-C3AE-11D1-BEC9-E0F4E352507A"

id=tower

</OBJECT>

sub tower_Error

.tower AboutBox()

end sub

</SCRIPT>

</BODY >

</HTML >

运行 Internet Explorer，从 File（文件）菜单中选择 Ope n（

打开）命令，然后浏览，并找到 TowerCtl.htm 。如果控件已经正确的注册在你的系统中，打开这个文档，将显示 TowerATL 窗口。
从同样的菜单中选择 New （新建），打开一个显示控件

的复制窗口。
在这两个窗口中的每一个窗口中，拖动一个彩色块到

一个小一些的块，这将启动控件的 Error 事件。在事件启动的任何时候，文档的脚本将激活控件的 About 框。

比较显示在每一个 About 框中的线程标识符（图 10-17 ），可以发现 Internet Explorer 在独立的 STA 公寓中运行每一个控件实例。因为 TowerATL 采用公寓线程模型，所以并不需要在任两个实例之间进行线程间调度，这对于像 Internet Explorer 这样的 STA 客户是理想的。但是我们为 TowerATL 选择了单一非线程模型，因为 COM 将被强迫调度所有与它有关的交互作用，所以控件的第二个实例将比第一个实例运行得慢很多。

第四部分 A ctiveX 控件 - 图76

图 10-17 在分离的 STA 公寓中运行 TowerATL 控件

配套光盘提供了一个名为 Game2 的程序，它是专门为显示新 TowerATL 控件而设计的。 Game2.rc 文件位于 Code\Chapter.10\Game2 文件夹中，引用了 CD 上提供的 TowerATL.ocx 控件的类标识符的值。如果你想要用你自己创立的 TowerATL 版本运行 Game2 ，仍需要从你的 TowerCtl.idl 文件中拷贝正确的类标识符，来替换 Game2.rc 中的标识符字符串。在重建 Game2 程序之前，在对话框脚本的IDC_TOWERATL 语句中粘贴新类标识符字符串：

IDD_GAME2_DIALOG DIALOGEX 0, 0, 295, 125

WS_TABSTOP,5,20,225,100

END

与第 9 章的 Tower 项目相比， TowerATL 需要在 MFC 为我们屏蔽的细节上更加努力和更加注意。所以从这一点说，值得总结我们在用 ATL 代替 MFC 控件时的得失。损失很容易发现：更多的工作量。然而，作为补偿，我们得到了一个小得多的可执行映像，尽管最开始你可能不这么认为。新 TowerATL.ocx 有 70KB ，这是我们在第 9 章中创建的 Tower.ocx 文件大小的 3 倍。但是如果你考虑到Tower.ocx 需要的实时库，控件的 ATL 版本的实际需要的存储器比原来的 MFC 版本小 1 兆多。 TowerATL.ocx 可以在 World Wide Web 上传送，可以在一个用户的浏览器中运行，而不需要与它一起拖动其他文件。

可是，即使通过一个较快的调制解调器，我们可预料 TowerATL.ocx 的下载时间将超过 20s 。这对于用户来说是一个明显的时间投资，而用户的耐心可能已经被

其他巨大的组件和点缀页面的图像所消耗了。 Internet 上的 ActiveX 控件面对唯一的障碍是用户事先通常对要求并不明确，并且可能不愿意在这方面多花时间。可以理解的是，急躁经常可以战胜好奇心。为 Internet 编写一个成功的 ActiveX 控件的诀窍是使它在 Web 页上看起来足够小，并在好奇心被击败之前准备运行。

现在 ATL 提供了编写小 ActiveX 控件，缩短直接 COM 编程的最佳途径。库代表了大小和劳动量之间，以及可能和实际之间的折衷。因为 ATL 用优秀的结果回报了合理的开发努力，所以这个折衷是成功的。

对比组件模型

在结束这本处理 ActiveX 控件的书之前，让我们后退一步，从一个安全的距离来考虑这个主题。当着手一个组件项目时，一个开发者不能仅仅衡量像 ATL 这样的支持技术的正面和负面因素，而必须首先考虑是否使用 ActiveX 控件。像其他软件技术一样， ActiveX 控件对于某些情况是合适的，但并不适用于其他情况。如果组件是作为一个嵌入应用程序单独计划的，并且永远不会在一个 Web 页上应用，那么 ActiveX 需要较高的成本。通过在 C O M 和 ActiveX 服务库中拖动，即使是一个向 Pulse 这样的简单控件将在存储器中安装许多 K B 的代码，而且可能显著地降低调用应用程序的加载进程速度。

有另一种解决方案。将 Pulse 设计为一个一般的动态链接库，而不是一个 ActiveX

控件，这将以一个线程安全的形式保留软件和可用的组件，而不用花费 ActiveX 和 COM 那样的代价。客户应用程序向库在每一个要求的时间间隔结束时调用的回调函数返回一个指针，而不是建立一个处理程序函数来接收事件。既然在新外壳下，一个事件处理程序仅仅是一个回调，那么结果是一样的。如果你想了解一个 Pulse 的 DLL 版本的模样，你可用在配套光盘的 Chapter.10\PulseDLL 文件夹中找到这样的一个项目的源文件。 Pulse 的动态链接库版本的最有趣的特点是它的大小： 3KB ，而 ActiveX 控件版本需要 37K B 。而且 PulseDLL 不需要 COM 。

这个简短的对比的目的仅仅是想说明这个问题的各个方面，提醒大家注意至少在某些情况下，低级动态链接库仍然在世界组件软件中占据一席之地。这并不是建议所有不用于 Internet 的组件必须用动态链接库编写。事实上远非如此， ActiveX 超越动态链接库而提供了显著的方便性，特别是在处理众所周知的“ 版本 ” 问题时更是如此。动态链接库的吸引力由于它的第二版的发布而降低了，而这个问题对 ActiveX 控件的影响并没有那么大。例如，假设我们决定，如果它调用timeSetEvent 和 timeKillEvent 应用程序编程接口函数，而不依赖于系统的 Sleep 计时器的行为， Pulse 将是一个更精确的计时器。放置后的版本将向新客户提供新对象和能力，而像 Hour2 这样的旧客户应用程序将像以前一样嵌入到新 Pulse 中，不需要改变任何东西。甚至用新版本覆盖旧 Pulse.ocx 文件，也不会影响客户应用程序，而不论它们是否利用扩展特性。在利用一个动态链接库的高版本时，这种稳定性是非常难以达到的。

第 四 部 分 A ctiveX 控 件

第 四 部 分 A ctiveX 控 件

第 8 章 使 用 ActiveX 控 件

背 景 知 识 简 介

控 件 包 容 器

表 8-1 一 些 可 以 从 M icrosoft 中 提 供 的 ActiveX 控 件文 件 名 说 明

向 Web 页 添 加 ActiveX 控 件

Test Containe r实 用 程 序

向 对 话 框 添 加 ActiveX 控 件

在 包 容 器 和 ActiveX 控 件 之 间 进 行 通 信

事 件

表 8-2 包 容 器 应 该 支 持 的 遵 守 OLE/ActiveX 技 术 规 范 的 接 口接 口 说 明

表 8-3 由 OLE/ActiveX 定 义 的 库 存 事 件事 件 原 型 当 时 触 发 事 件

方 法

属 性

表 8-4 由 OLE/ActiveX 定 义 的 库 存 控 件 属 性

函 数

编 写 包 容 器 应 用 程 序

表 8-5 标 准 的 包 容 器 环 境 属 性

步 骤 1 ： 用 AppWizard 创 建 Hour 项 目

步 骤 2 ： 将 Time r Objec t控 件 插 入 项 目

步 骤 3 ： 在 Hour 对 话 中 放 置 Time r Ob jec t控 件

表 8-6 Hour 程 序 中 的 控 件 标 识 符

步 骤 4 ： 向 Hou r.cpp 和 Hou r.h 文 件 添 加 代 码

步 骤 5 ： 创 建 和 测 试 项 目

在 没 有 对 话 编 辑 器 的 情 况 下 工 作

步 骤 1 ： 创 建 Button 项 目

步 骤 2 ： 向 CButtonView 类 添 加 控 件

步 骤 3 ： 处 理 事 件

第 9 章 使 用 MFC 编 写 Ac tiveX 控 件

用 于 创 建 ActiveX 控 件 的 Visual C++ 工 具

ControlWizard

许 可

Control W izard 许 可 证 支 持

例 1 ： 什 么 都 不 做 的 ActiveX 控 件

例 2 ： Tower ActiveX 控 件

步 骤 1 ： 创 建 Towe r项 目

步 骤 2 ： 添 加 属 性

步 骤 3 ： 添 加 方 法

步 骤 4 ： 添 加 事 件

步 骤 5 ： 添 加 消 息 处 理 程 序 函 数

步 骤 6 ： 创 建 属 性 表

步 骤 7 ： 添 加 源 代 码

表 9-1 CTowerCtrl 类 的 成 员 变 量

步 骤 8 ： 创 建 和 测 试 Tower ActiveX 控 件

向 ActiveX 控 件 项 目 添 加 属 性 页

第 10 章 用 ATL 编 写 ActiveX 控 件

ATL 和 包 容 器 应 用 程 序

ATL 和 ActiveX 控 件

表 10-1 ActiveX 控 件 必 须 支 持 的 接 口 ， 以 同 指 南 相 兼 容接 口 说 明

接 口 映 射

表 10-2 ATL 的 COM_INTERFACE 宏

宏

目 标 映 射

线 程 模 型

表 10-3 COM 在 客 户 和 控 件 之 间 调 度 的 条 件控 件

示 例 1 ： Pulse ActiveX 控 件

步 骤 1 ： 运 行 ATL COM AppW izard

步 骤 2 ： 运 行 ATL Object W izard

表 10-4 ATL Object Wizard 支 持 的 常 用 目 标 类 型目 标 类 型 说 明

步 骤 3 ： 加 入 nInterva l属 性

表 10-5 属 性

步 骤 4 ： 加 入 方 法

步 骤 5 ： 加 入 Pulse 事 件

步 骤 6 ： 加 入 CTimer 类

步 骤 7 ： 编 辑 PulseCtl.h 文 件

步 骤 8 ： 编 辑 PulseCtl.cpp 文 件

步 骤 9 ： 编 辑 Pulse.rgs文 件

步 骤 10 ： 建 立 和 测 试 Pulse ActiveX 控 件

例 子 2 ： TowerATL ActiveX 控 件

步 骤 1 ： 创 立 TowerATL 项 目

步 骤 2 ： 加 入 nCurrentBlock 用 户 属 性

步 骤 3 ： 加 入 Rese t方 法

步 骤 4 ： 加 入 处 理 程 序 函 数

步 骤 5 ： 加 入 事 件

步 骤 6 ： 加 入 属 性 工 作 表

步 骤 7 ： 编 辑 Towerppg.h 文 件

步 骤 8 ： 编 辑 TowerCtl.h 文 件

步 骤 9 ： 编 辑 TowerCtl.cpp 文 件

步 骤 10 ： 加 入 Abou t框

第四部分 A ctiveX 控件

第四部分 A ctiveX 控件

第 8 章使用 ActiveX 控件

背景知识简介

控件包容器

表 8-1 一些可以从 M icrosoft 中提供的 ActiveX 控件文件名说明

向 Web 页添加 ActiveX 控件

Test Containe r实用程序

向对话框添加 ActiveX 控件

在包容器和 ActiveX 控件之间进行通信

事件

表 8-2 包容器应该支持的遵守 OLE/ActiveX 技术规范的接口接口说明

表 8-3 由 OLE/ActiveX 定义的库存事件事件原型当时触发事件

方法

属性

表 8-4 由 OLE/ActiveX 定义的库存控件属性

函数

编写包容器应用程序

表 8-5 标准的包容器环境属性

步骤 1 ：用 AppWizard 创建 Hour 项目

步骤 2 ：将 Time r Objec t控件插入项目

步骤 3 ：在 Hour 对话中放置 Time r Ob jec t控件

表 8-6 Hour 程序中的控件标识符

步骤 4 ：向 Hou r.cpp 和 Hou r.h 文件添加代码

步骤 5 ：创建和测试项目

在没有对话编辑器的情况下工作

步骤 1 ：创建 Button 项目

步骤 2 ：向 CButtonView 类添加控件

步骤 3 ：处理事件

第 9 章使用 MFC 编写 Ac tiveX 控件

用于创建 ActiveX 控件的 Visual C++ 工具

许可

Control W izard 许可证支持

例 1 ：什么都不做的 ActiveX 控件

例 2 ： Tower ActiveX 控件

步骤 1 ：创建 Towe r项目

步骤 2 ：添加属性

步骤 3 ：添加方法

步骤 4 ：添加事件

步骤 5 ：添加消息处理程序函数

步骤 6 ：创建属性表

步骤 7 ：添加源代码

表 9-1 CTowerCtrl 类的成员变量

步骤 8 ：创建和测试 Tower ActiveX 控件

向 ActiveX 控件项目添加属性页

第 10 章用 ATL 编写 ActiveX 控件

ATL 和包容器应用程序

ATL 和 ActiveX 控件

表 10-1 ActiveX 控件必须支持的接口，以同指南相兼容接口说明

接口映射

目标映射

线程模型

表 10-3 COM 在客户和控件之间调度的条件控件

示例 1 ： Pulse ActiveX 控件

步骤 1 ：运行 ATL COM AppW izard

步骤 2 ：运行 ATL Object W izard

表 10-4 ATL Object Wizard 支持的常用目标类型目标类型说明

步骤 3 ：加入 nInterva l属性

表 10-5 属性

步骤 4 ：加入方法

步骤 5 ：加入 Pulse 事件

步骤 6 ：加入 CTimer 类

步骤 7 ：编辑 PulseCtl.h 文件

步骤 8 ：编辑 PulseCtl.cpp 文件

步骤 9 ：编辑 Pulse.rgs文件

步骤 10 ：建立和测试 Pulse ActiveX 控件

例子 2 ： TowerATL ActiveX 控件

步骤 1 ：创立 TowerATL 项目

步骤 2 ：加入 nCurrentBlock 用户属性

步骤 3 ：加入 Rese t方法

步骤 4 ：加入处理程序函数

步骤 5 ：加入事件

步骤 6 ：加入属性工作表

步骤 7 ：编辑 Towerppg.h 文件

步骤 8 ：编辑 TowerCtl.h 文件

步骤 9 ：编辑 TowerCtl.cpp 文件

步骤 10 ：加入 Abou t框

步骤 11 ：建立和测试 TowerATL ActiveX 控件

对比组件模型