终于把糟糕的本科毕业了，现在在新加坡国立大学上研究生，主要研究方向是软件工程，知识工程。

以后会发一些英文自己翻译的文章。

摘要：本文讨论 MSHTML，这是对 Internet Explorer 中分析和展现引擎的 HTML 扩展，它允许直接在浏览器内编辑 Web 页。

现在，您可以直接将 Microsoft(R) Internet Explorer 复杂的 HTML 编辑功能合并到 Web 页中！Microsoft 的 HTML 编辑器是对 Internet Explorer 中 HTML 分析和展现引擎的内置扩展。从 Internet Explorer 4.0 开始，MSHTML 编辑器已经为主机应用程序提供了开发基于 HTML 的文本编辑器和 Web 创作应用程序的 HTML 编辑平台。但是，在以前的版本中，只有当文档处在“设计”模式时，才能启用编辑器。使用 Internet Explorer 5.5，您可以将文档或文档中的单个元素声明为可以在运行时编辑，这就使得 Web 创作者能够完全支持浏览器内的 WYSIWYG（所见即所得）HTML 编辑权。

MSHTML 编辑器提供了简单而又功能强大的脚本编辑模式，该模式支持对文本和窗体的最常用的编辑功能。这样，就有可能开发出高级的联机编辑应用程序、创建允许用户输入格式化文本或图象等的统一窗体、或使 Web 站点上的页面成为每个用户都能用自己的内容对其定制。Web 创作者可能使用文本编辑功能来开发联机文本编辑器，或者使用窗体编辑功能来编写联机明信片应用程序。

文本编辑功能

下面的文本编辑功能已经在以前版本的 Internet Explorer 中得到支持，在 Internet Explorer 5.5 中同样支持这些功能。除键盘快捷键外（它们始终处于启用状态），所有这些功能都有可以在脚本中执行的对应命令。

• 文本格式：
  
  
  
  • 字体（例如，Times Roman、Arial、Courier 等）
    
    
  • 字体大小
    
    
  • 文本样式和装饰（斜体、粗体、下划线、加删除线、上标、下标）
    
    
  • 文本颜色
    
    
  • 背景颜色
• 段落格式：
  
  
  
  • 缩进
    
    
  • 伸出
    
    
  • 左、右、居中以及页边对齐
    
    
  • 文本方向（右到左，或左到右）
• 列表编辑：
  
  
  • 带编号的列表
    
    
  • 带项目符号的列表
    
    
  • 嵌套到任何等级
• 选定服务：
  
  
  
  • 通过拖动鼠标选定范围
    
    
  • 通过双击选定单词
    
    
  • 通过三次单击选定段落
    
    
  • 基于键盘的选定（Shift + 箭头、Home 和 End 键）
• 自动检测超级链接和书签（使它们可以导航）
  
  
• 无限等级的撤消和恢复
  
  
• 文本输入模式：
  
  
  • 插入
    
    
  • 改写
• 支持标准键盘快捷键：

Internet Explorer 5.5 中的新功能

当然，Internet Explorer 5.5 中最棒的新编辑功能之一，就是能够在浏览器运行时启用编辑功能，但我们将在后面讨论它。现在我们讨论 Internet Explorer 5.5 中其它一些新的和经过改进的功能，尤其是文本编辑：

• 垂直文本编辑
  
  
• 双向编辑
  
  
• 批撤消和恢复
  
  
• 自动检测的撤消
  
  
• 在剪切、复制和粘贴操作中保持格式
  
  
• 在空行中保持格式

垂直编辑是 Internet Explorer 5.5 中首次出现的功能。该功能主要针对那些使用中文或日文进行编辑的用户，但它在纯 ASCII 文本中也能很好地工作。使用西文字体的字符可以向右旋转，这样，在显示文本时仿佛整段文本都被顺时针旋转。Internet Explorer 5.5 中，双向文本支持也得到极大改进。该功能主要用于希伯来和阿拉伯的文本。虽然经常会有一些英文的单词和词组，或者其他基于拉丁文的单词或词组，被插入到希伯来和阿拉伯的文本中。在 Internet Explorer 5.5 中，当遇到拉丁文字符集时，主要的定位方向将自动切换为从左到右，而当检测到希伯来文或阿拉伯文字符集时又会自动切换为从右到左。

批撤消和恢复使用户可以立刻删除和还原整个句子，而不是一次一个字符。现在，如果由于某些原因用户不想让某个链接处于活动状态，则可以使用 BACKSPACE 键撤消自动检测到的链接。

在复制和粘贴文本时，该编辑器现在可以很好地保持格式。例如，如果复制了格式为粗体、红色宋体格式的文本，然后将它粘贴到格式为粗体 Times Roman 的文本段中，那么所粘贴的文本将保持其粗体、红色宋体格式。现在，格式还能在空行上保持。如果将某行的格式设置为 16 点、斜体、Haettenschweiler，并数次点击 RETURN，当您返回这些空行并在其中键入字符时，文本将以 16 点、斜体、Haettenschweiler 格式输入，而不再是文档的默认字体。

Web 创作功能

Internet Explorer 中的 HTML 编辑器一贯支持下面这些基本的 Web 创作功能，未来仍将继续支持。

• 插入：
  
  
  • 控件
    
    
  • IFrames
    
    
  • 图象
    
    
  • 字幕
    
    
  • 水平线
    
    
• 控件选定
  
  
• UI 激活

控件、IFrames、图象、字幕、水平线和表格全都有一些共同之处。每个元素都有各自的布局。所谓具有布局，基本上表示着对象呈矩形。（实际上，只要为任何元素指定宽度和高度，或使它 contentEditable，就可以使它具有布局。）如果布局元素包含有内容，则其内容的布局是由界定其范围的矩形来决定。

可以与选择文本一样，按住鼠标左键并在其上拖动鼠标，就可以选定具有布局的元素。但是，当布局元素位于可编辑容器内部时，也可以通过单击或按 TAB 键对它进行控制选定。当元素被控制选定时，将在框定它的矩形角和每个边的中点上显示“抓取手柄”。当元素被控制选定时，可以将其作为单个单位拖动（或删除），连带它的所有内容。还可以用鼠标拖动它的抓取手柄来调整其大小。元素被控制选定时，单击它或点击 ENTER 键将使它成为被激活的 UI。当元素成为活动的 UI 时，（除非它是不能有内容的元素，如图象或水平线，）将在它的周围出现晕线边框，并且可以编辑它的内容。

Internet Explorer 5.5 中的新功能

Internet Explorer 5.5 拥有窗体编辑器的所有功能，此外，它还支持一些很棒的新功能，这些新功能使得创建窗体和 Web 页成为轻松并充满乐趣的工作。这些新功能包括：

• 2D 绝对定位
  
  
• 现场调整大小
  
  
• 多项选定
  
  
• 不可选定的 UI 元素

使用 2D 绝对定位，用户只需进行拖放操作，就可以把元素放到页面的任何位置上。（再也不用创建以前那些复杂的表格，就可以得到希望的准确布局了！）

现场调整大小功能让用户在调整元素大小时获得现场的 WYSIWYG 反馈。用户不用在拖动鼠标的同时描绘外边框，并在松开鼠标按钮时让元素自行调整大小，元素将随着用户拖动它的抓取手柄实时地调整大小。

多项选定让用户能够一次选定多个元素，并同时拖动它们或调整其大小。

新的“不可选定”属性使您能够为 Web 页创建用户界面元素，它们不会在用户单击时使当前选定内容遭到破坏。这对创建更改当前选定内容格式的控件非常有用，这一点我们随后就会谈到。

激活编辑器

激活编辑器的方法有两种。第一种方法是将整个文档设置为设计模式。第二种方法可以在浏览模式中使用，来使各个元素可在运行时编辑。如果想让整个文档可在浏览时进行编辑，则可以在文档正文上设置 contentEditable 属性。

将文档设置为设计模式

要将整个文档设置为设计模式，可以对文档对象本身设置 designMode 属性。当文档处于设计模式时，将不运行脚本。这样，似乎在文档内设置一个按钮来打开或关闭设计模式是个好注意，但这样做没有作用。当用户打开它后，它将保持在设计模式状态。当他们下次单击此按钮时，它将被选定而不是被单击，他们再次单击它，将能够编辑它的值。这就是为什么如果要使用设计模式最好对框架或 IFrame 中的文档设置 designMode 属性的原因。下例展示如何为 IFrame 中的文档打开设计模式：

<script for="btnDesign" event="onclick">
  targetDoc = document.frames(0).document;
  if (targetDoc.designMode == "On")
    targetDoc.designMode = "Off";
  else
    targetDoc.designMode = "On";
</script>
<button id=btnDesign>DesignMode</button>
<iframe src="blank.htm" style="border: black thin; width:100%; height:200px"></iframe> 

designMode 属性的值始终以首字母大写格式存储，即时它最初是以全部小写设置的。请在测试它的值时一定记住这点。designMode 属性的默认值是“Inherit”。

在浏览模式中使元素可以编辑（或在设计模式中不可编辑）

在 Internet Explorer 5.5 中，可以针对每个元素激活编辑器，而同时，文档本身处于浏览模式中。只要将 contentEditable 属性设置为 True，就能使元素在浏览时可被编辑。下例展示如何说明性地设置该属性，并创建行为类似文本框的跨距：

<span contentEditable=true style="width:150; border:lightgrey 3px inset"></span>

要使元素在全部脚本过程中可被编辑是非常容易实现的。下面的范例显示如何在脚本中对 ID 为“foo”的元素设置 contentEditable 属性：

foo.contentEditable=True;

要防止元素在设计模式中处于可编辑状态，可以将 contentEditable 属性设置为 False。但这将使元素具有布局，这样，当它在设计模式中时，用户将能够对它进行控制选定、拖动、调整大小等：

foo.contentEditable=False;

contentEditable 元素的继承和嵌套

contentEditable 属性是被继承的，所以，如果您说明元素具有 contentEditable 属性，则默认情况下它的所有子元素都将是可编辑的。（contentEditable 属性的默认值是“Inherit”。

通过将其 contentEditable 属性设置为 False，可以使 contentEditable 元素的后代成为不可编辑的，但这样之后，请记住设置元素的 contentEditable 属性将导致元素具有自己的布局。无论元素的 contentEditable 属性被设置为 True 或 False，都要发生这样的情况。还要记住，当有布局的元素处在可编辑的容器中时，一旦用户单击它的内部，它将被控制选定。当它被控制选定时，将显示抓取手柄，并且用户可以拖动该元素或调整其大小。这并不表示不应当在可编辑的元素内嵌套不可编辑的元素，只不过要加以注意罢了。

判断元素是否是可编辑的

要判断元素是否是可编辑的，只检查 contentEditable 属性的值是不够的。元素可能根本没有 contentEditable 属性，但仍然可能已经从它的某个祖先那里继承了内容可编辑性。或者，它可能是默认时可编辑的元素，如文本框。或者，包含它的文档可能处于设计模式中。确定元素是否可编辑的唯一完全可靠的方法是检查 isContentEditable 属性。isContentEditable 属性综合了所有这些因素。该属性是只读的，其结果为布尔值。下例展示如何判断 ID 为“foo”的元素是否可以被编辑：

result=foo.isContentEditable;

执行编辑命令

Internet Explorer 5.5 中的大多数基本编辑功能可通过发出命令来访问。MSDN Online 上的文档列出了可用的命令，并说明了要使用哪些参数。

要执行编辑命令，可调用 document.execCommand，并传递对应于命令 ID 的字符串。另外还有可选的第二个参数，该参数指定如果可以应用的话是否显示此命令的用户界面。传递整数 1 将显示用户界面，整数 0 将跳过它。这个参数通常不用于编辑命令。因为默认值为 0，所以假如您没有使用第三个参数（在这种情况下，还必须为第二个参数传递值），一般可以不管它。第三个参数也是可选的，在可应用的情况下，使用它来将任何所需参数传递给该命令。

例如，要打开多项选择功能，应当调用 document.execCommand("MultipleSelection")。 要打开现场调整大小功能，只需调用 document.execCommand("LiveResize")。要打开 2D 定位，请调用 document.execCommand("2D-Position")。

注意 2D 定位只能对 CSS 样式已设置为 position:absolute 的元素有效。

下例（见图 1）使用了 contentEditable 属性、unselectable 属性和三个可执行的命令来创建一个可在 Web 页上使用的简单的小文本编辑器。很重要的一点是，div 语句在另一个 div 语句中，而外层 div 底部有三个按钮。按钮使用 document.execCommand 方法来格式化当前选定内容的样式。内部 div 具有 contentEditable 属性，而外部 div 和按钮是不可选定的。由于它们是不可选定的，所以用户可以单击它们而不会破坏当前的选定内容。这对按钮尤其有用，因为用户可以选定 contentEditable 区域中的一些文本，然后单击粗体按钮、斜体按钮和下划线按钮，而不必重新选定文本：

<div align=center>
<div unselectable="on" align=center 
 style="height:300; width:400; background-color:powderblue; border:outset powderblue">  
  <br>  
  <div id=foo contenteditable align=left    
   style="height:250; width:350;background-color:white; font-face:Arial; padding:3;    
   border:inset powderblue; scrollbar-base-color:powderblue; overflow=auto;">  
  </div>  
  <br>  
  <button unselectable="On" onclick='document.execCommand("Bold");foo.focus();'   
   style="width:80; background-color:powderblue; border-color:powderblue">   
   <B>粗体</B></button>  
  <button unselectable="On" onclick='document.execCommand("Italic");foo.focus();'    
   style="width:80; background-color:powderblue; border-color:powderblue">   
   <B><I>斜体</I></B></button>  
  <button unselectable="On" onclick='document.execCommand("Underline");foo.focus();'    
   style="width:80; background-color:powderblue; border-color:powderblue;">   
   <B><U>下划线</U></B></button>
</div>
</div>

图 1 中值得申明的另一点是，现在可以指定滚动条的颜色了！（这是 Internet Explorer 5.5 的另一个新功能）。

图 1. 创建文本编辑器

保持可编辑的内容

如何保持可编辑的内容由您决定。如果您正在使用 Active Server Pages (ASP)，您可以在窗体中包括可编辑的元素，之后使用 Post 方法将它们张贴到 ASP 页，然后以任何方式将它们存储在服务器上。有关 ASP 页的内容包含在 ASP SDK 中，这里不作详细说明。另一个方法，也可能是更有趣的方法，是使用 UserData 行为将数据保持在客户端。

UserData 行为

UserData 行为是将 contentEditable 元素中的内容保持在用户计算机的某个存储区中的最好方法。行为是 Internet Explorer 5.0 中引入的一种封装可重用脚本和/或 HTML 的方法。行为存在于它自己的、称为 HTC（HTML 组件）文件中，该文件被位于客户端文档的文件头中的 CSS 样式段加以引用。将行为应用到元素所用的方法与应用 CSS 样式相同。一旦行为与某个元素相关联，则属于该行为的所有方法都将被调用到该元素上。

UserData 是行为具有强大功能的极好范例。通过为在 Save 和 Load 方法中所指定的 UserData 存储指定不同的名称，可以使用 UserData 行为来将多个元素的内容保持在单个页面上。唯一的限制是每页不能存储超过 64KB，每个域的限制则为 640KB。下一个范例展示如何保持单个 contentEditable 元素中的内容。

该范例中的元素是一个名为“foo”的 contentEditable div 语句。注意，在文件头的样式说明中，说明了 UserData 行为。通过说明元素的类为“userData”，行为被附加到 contentEditable 元素上。这样，可以访问由 UserData 行为显露的方法，如 setAttribute、getAttribute、Load 和 Save，就好象它们是元素自身的方法一样。（只要属性名在 getAttribute 和 setAttribute 方法中是一致的，而存储名在 Load 和 Save 方法中是一致的，就可以以任何名称命名用来保持数据的存储和属性。）

<html>
<head>
<style> .userData {behavior:url(#default#userdata);} </style>
<script for=window event=onload>
 DoLoad();
</script>
<script for=window event=onbeforeunload>
  DoSave();
</script>
<script>
function DoSave(){
  foo.setAttribute("content", foo.innerHTML);
  foo.save("EditContent");
}
function DoLoad(){
  foo.load("EditContent");
  content = foo.getAttribute("content");
  if (content != null) foo.innerHTML=content; 
}
function DoClear(){
  foo.innerHTML = "";
}
</script>
</head>
<body>
<p align=center>
  <button onClick='DoSave()'>保存</button>
  <button onClick='DoClear()'>清除</button>
  <button onClick='DoLoad()'>加载</button>
</p>
<div id=foo class=userData contentEditable=true style="width:100%;height:90%">
</div>
</body>
</html>

图 2 展示了一个 contentEditable div 语句和三个按钮，它们允许用户保存 div 的内容、加载所保存的内容和清除当前的内容。另一个好的技巧是，当用户转到其它页时，window.onBeforeUnload 事件处理程序将自动存储用户输入的内容。然后，当他们返回时，window.onLoad 事件处理程序将自动还原它。当用户返回您的 Web 页并发现他们上次留下的相同内容仍然存在，他们一定非常吃惊。

图 2. 使用 UserData 行为保持数据

元素行为和编辑

元素行为是一个完全自我约束的自定义元素，可以将它当作固有的 HTML 控件。在前面有关保持的内容中，我们看到了 UserData 行为，该行为可以与任何元素关联。与标准行为相比，元素行为有其自己的元素标记，并且它不能应用到其它任何元素。行为不能脱离元素本身。

“viewlinked”元素行为：无需将生成该 UI 的 HTML 插入到调用它的文档中，其用户界面即可在浏览时显示。当用户查看 Web 的源文件时，他们只能看到代表该元素的标记，用户永远无法看见导致元素外观和动作的源文件。只有元素行为可以是 viewlinked。

有关元素行为的另一个重要情况是，无论元素标记什么时候可见于分析程序，行为都是可用的。永远不会出现元素在那里，而行为还没有加载的二者分离的情形。所有这些优点，使得元素行为成为创建可随时随地重复使用的、您自己的 HTML 控件的最好方法。

一个简单的例子

在该范例中，将获得简单的小文本编辑器（图 1），另外添加几个按钮使它更有趣，将它封装在一个 HTC 文件中，并添加几条线以告诉分析程序将它当作 viewlinked 元素行为。之后，我们将看见如何在 HTML 文件中创建该组件的实例。

HTC 文件

下面的代码是一个 HTC 文件，该文件包含了定义组件的源。注意，在顶部的 public:component 说明中包括了标记名称（在这里是“editBox”）。当新组件被插入 HTML 文件中时，这就是用来标识该新组件的名称。在 public:component 说明中的其它说明是 public:defaults viewLinkContent 说明， 它指定该元素行为是 viewlinked 的。将这些说明添加到文件顶部，并用 .htc 扩展名保存该文件，这样就完成了把新创建的 DHTML 转换成元素行为的全部操作。在这里，我们将该文件命名为“editBox.htc”。（并不是一定要将文件命名为与元素本身相同的名称，这样做只是为了便于记忆。）

<public:component tagName=editBox>
<public:defaults viewLinkContent/> 
</public:component>
 
<div unselectable="on" align=center style="height:250; width:425;

 background-color:powderblue; border:outset powderblue">
  <br>
  <div id=foo contenteditable align=left 
   style="height:200; width:370;background-color:white; font-face:Arial; padding:3; 
   border:inset powderblue; scrollbar-base-color:powderblue; overflow=auto;">
  </div>
  <br>
 
  <button unselectable="On" onclick='document.execCommand("Bold");foo.focus();'
   style="background-color:powderblue; border-color:powderblue" title="粗体">
   <B>B</B></button>
  <button unselectable="On" onclick='document.execCommand("Italic");foo.focus();'    
   style="background-color:powderblue; border-color:powderblue" title="斜体">
   <B><I>I</I></B></button>
  <button unselectable="On" onclick='document.execCommand("Underline");foo.focus();'
   style="background-color:powderblue; border-color:powderblue;" title="下划线">
   <B><U>U</U></B></button>
<button unselectable="On" onclick='document.execCommand("StrikeThrough");foo.focus();'
   style="background-color:powderblue; border-color:powderblue; text-decoration=line-through"
   title="删除线">
   <B>S</B></button>
  &nbsp;&nbsp;
 
  <button unselectable="On" onclick='document.execCommand("SuperScript");foo.focus();'
   style="background-color:powderblue; border-color:powderblue" title="上标">
   <B>^</B></button>
  <button unselectable="On" onclick='document.execCommand("SubScript");foo.focus();'
   style="background-color:powderblue; border-color:powderblue" title="下标">
   <B>_</B></button>
  &nbsp;&nbsp;
 
  <button unselectable="On" onclick='document.execCommand("InsertOrderedList");foo.focus();'
   style="background-color:powderblue; border-color:powderblue" title="已排序列表">
   <B>OL</B></button>
  <button unselectable="On" onclick='document.execCommand("InsertUnorderedList");foo.focus();'
   style="background-color:powderblue; border-color:powderblue" title="未排序列表">
   <B>UL</B></button>
  <button unselectable="On" onclick='document.execCommand("Outdent");foo.focus();'
   style="background-color:powderblue; border-color:powderblue" title="突出">
   <B>&lt;&lt;</B></button>
  <button unselectable="On" onclick='document.execCommand("Indent");foo.focus();'
   style="background-color:powderblue; border-color:powderblue" title="缩进">
   <B>&gt;&gt;</B></button>
  &nbsp;&nbsp;
 
  <button unselectable="On" onclick='document.execCommand("JustifyLeft");foo.focus();'
   style="background-color:powderblue; border-color:powderblue" title="左对齐">
   <B>|&lt;</B></button>
  <button unselectable="On" onclick='document.execCommand("JustifyRight");foo.focus();'
   style="background-color:powderblue; border-color:powderblue" title="右对齐">
   <B>&gt;|</B></button>
  <button unselectable="On" onclick='document.execCommand("JustifyCenter");foo.focus();'
   style="background-color:powderblue; border-color:powderblue" title="居中">
   <B>&gt;|&lt;</B></button>
  &nbsp;&nbsp;
  <br>
 
  <button unselectable="On" onclick='document.execCommand("Cut");foo.focus();'
   style="background-color:powderblue; border-color:powderblue"><B>剪切</B></button>
  <button unselectable="On" onclick='document.execCommand("Copy");foo.focus();'
   style="background-color:powderblue; border-color:powderblue"><B>复制</B></button>
  <button unselectable="On" onclick='document.execCommand("Paste")'
   style="background-color:powderblue; border-color:powderblue"><B>粘贴</B></button>
  &nbsp;&nbsp;
  <button unselectable="On" onclick='document.execCommand("Overwrite");foo.focus();'
   style="background-color:powderblue; border-color:powderblue"><B>覆盖</B></button>
</div>

HTML 文件

现在既然已经看过了 HTC 文件，接着让我们来看看 HTML 文件。在该文件中与任何其它 HTML 文件唯一不同的内容是位于文件顶部的 html 说明中的 namespace 属性，另一个不同是处理指导 (PI)，它告诉分析程序在哪里找到 editBox 元素的执行文件。当碰巧名称相同的单独 HTC 文件中有两个不同的元素行为时，就必需要有 namespace 属性。namespace 提供了分辨它们的方法。导入语句简单地告诉分析程序当它看见标记名有前缀“x”时，它应当在指定的执行文件中查找该标记的定义。所以，无论什么时候使用用于新组件的标记，都必须用在 PI 中已经说明的 namespace 来给该标记加上前缀。（与在 XML 中的 namespaces 不同，这个 namespace 不是“统一资源名 (URN)”，并且它与标记本身没有固有关联。namespace 由 HTML 文件的创作者定义，并且对说明它的文件来说，它位于本地。它类似于在特殊 XML 文件中与 XML namespace 相关联的前缀。）

<html xmlns:x>

<head>

< import namespace=x implementation="editBox.htc" />

</head>

<body>

<x:editbox>

</body>

</html>

图 3. Viewlinking 元素行为

摘要

在了解如何创建简单的文本编辑器作为元素行为后，您就可以轻松地对它进行扩展了，方法是添加持久性、使用前面介绍的 UserData 行为、添加用于选择字体和字体大小的控件。还可以对它进一步扩展，比如将菜单或下拉框添加到 UI 以便插入控件、图象和字幕，以及支持 2D 绝对定位、多项选定和现场调整大小。（无疑，还可以制作出更好看的用户界面！）通过合并使用浏览时编辑功能、UserData 持久性和元素行为，要想创建很棒的编辑组件几乎不受任何限制！

当然，并不是说您必须执行元素行为才能创建可编辑的 Web 页。Viewlinking 只是提供绝佳的方法来压缩及重复使用您所建立的行为（这样可以避免泄露您的 HTML 源文件）。

在了解 Internet Explorer 5.5 中所有最棒的新编辑功能之后，剩下的事就看您的了。相信您将会成为您公司中第一个提供实时、“所见即所得”可编辑 Web 页的人！（您的同事一定非常羡慕又嫉妒。）

引用地址:http://www.microsoft.com/china/msdn/Archives/workshop/createwp.asp#createwp_topic6

输入法编程相关资源汇集－欢迎补充
本文可以任意转载，转载时请务必以超链接形式标明文章原始出处
在这里向一些付出工作的同志们和网站站长抱歉，有些资源是我直接保存的，

现在有些网站打不开让我不能够贴上链接了，如果发现有损你们的利益，

给我来信说明，我会及时改正

IME输入法编程，关于函数，接口等等等等，偶入门时读的，后来还一直在查
http://forum.mywuzhen.com......art=0&trange=15

输入法编程指南（貌似论文）：
http://www.cnblogs.com/Files/realfun/输入法编程指南.rar

汉字输入法软件设计技术辅导站：
http://wwsys.51.net/
很多有用的内容，可惜很久不更新了，还有一些链接不可用

输入法的安装：
http://www.cnblogs.com/Files/realfun/输入法安装制作原理.rar

其他的资源有：

键盘扫描码：http://www.cnblogs.com/Files/realfun/键盘扫描码.rar

Unicode：有人可能会编写可以在各个系统包括韩文、日文、英文系统下的输入法，参见：
 1、chedong的站点：
  版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明 
  http://www.chedong.com/tech/hello_unicode.html
 2、CharlezPetzold 那本 windows编程里面关于Unicode那章介绍
 3、Unicode编程入门：http://www.vckbase.com/document/viewdoc/?id=642
繁体和简体：谈到Unicode，还有的是要考虑繁体和简体的转换问题：
经典 用API作简繁体转换.rar

然后，就是freepy，几乎所有输入法编写者都要从此开始，感谢他的无私付出：
http://www.cnblogs.com/Files/realfun/freepydoc_cn.rar
http://www.cnblogs.com/Files/realfun/freepy31.zip

小键盘（软键盘）的编码：
http://www.cnblogs.com/re......hive/2005/03/28/127174.aspx

一些链接：
输入法编程指南(根据msdn翻译)：http://wwsys.51.net/wwwboard/messages/253.html
Windows 输入法编程： http://blog.csdn.net/dengting/archive/2002/08/17/14638.aspx
中文输入法论坛：http://www.petrocn.com/cgi-bin/leoboard.cgi
输入法单步跟踪调试：http://www.cnblogs.com/re......hive/2005/08/29/225153.aspx

Windows 95输入法编辑器（IME）
原著：Microsoft
翻译：TBsoft Software Studio
一、关于Windows 95混合语言IME
    在Windows 95中，IME是一个动态链接库（DLL），与Windows 3.1远东版本IME不同的是，每一个运行的IME相当于混合语言键盘布局中的一种。与Windows 3.1 IME相比较，Windows 95混合语言IME提供下列增强功能：
    ●运行时相当于混合语言环境的一个部件
    ●为每一个应用程序任务提供多重输入上下文
    ●为每一个应用程序线程提供一个活动的IME
    ●通过应用程序消息循环给应用程序提供信息（消息顺序不能改变）
    ●为无IME支持应用程序和部分IME支持应用程序提供有力的支持
    要得到全部的增强功能，应用程序需要支持Windows 95 IME应用程序I／F。
    本文档描述了Windows 95 IME体系结构的应用程序I／F。

1、IME的结构
    Windows 95 IME必须提供两个部件：IME转换接口和IME用户接口。IME转换接口由一组IME模块引出函数提供，这些函数被IMM（输入法管理器——译者注）调用。
    IME用户接口由一组窗口提供，这些窗口接收消息并提供IME的用户界面。

2、IME支持应用程序（IME感知应用程序——译者注）
    应用程序有下列类型：
●无IME支持应用程序：这种应用程序不控制IME，然而，如果应用程序接受DBCS字符，用户可以通过IME在应用程序中输入DBCS字符。
●部分IME支持应用程序：这种应用程序只控制不同的IME上下文，例如打开和关闭IME、写作窗口等等，但是不重新显示任何IME用户界面。
●完全IME支持应用程序：这种应用程序负责管理通过IME显示给应用程序的任何信息。
    在Windows 95中，一个无IME支持应用程序有一个缺省的IME窗口和一个缺省的输入上下文。
    部分IME支持应用程序使用预定义的“IME”类创建自己的IME窗口，可以管理或者不管理自己的输入上下文。
    完全IME支持应用程序自己管理输入上下文，显示输入上下文给出的任何需要的信息，不使用IME窗口。
二、IME用户界面
    IME用户界面包括IME窗口、用户界面（UI）窗口以及UI窗口的部件。

1、特征
    IME类是实现IME用户界面部分的预定义全局窗口类。“IME”类与预定义的公共控制窗口类有许多相同的特点，IME窗口实例与静态控制一样通过CreateWindowEx函数创建，IME类窗口自己不响应用户输入，取而代之的是接收不同类型的控制消息实现全部IME用户接口。应用程序可以使用IME类创建自己的IME窗口，还可以使用ImmGetDefaultIMEWnd函数获取缺省IME窗口。创建自己的IME窗口或者使用缺省IME窗口的应用程序被称为IME支持应用程序，具有以下优点（与对应的Windows3.1应用程序比较）：

●包括候选字列表窗口（候选窗口），每一个应用程序可以有自己的用户界面窗口实例，使得用户可以在任何输入过程的中途停止并切换到另一个应用程序。在Windows 3.1日文版本中，用户切换到另一个应用程序是必须放弃当前输入过程。
●因为IME用户界面窗口包括应用程序窗口句柄，IME用户界面窗口可以为应用程序提供缺省行为。例如当应用程序移动时IME用户界面窗口自动移动，自动跟随窗口中的插入符号位置，为每一个应用程序标示模式等等。
    即使系统仅仅只提供一个IME类，IME窗口仍然有两种类型。一种类型是系统为无IME支持应用程序创建的IME窗口，DefWindowProc函数为该窗口处理消息，DefWindowProc函数的IME用户接口被线程的所有无IME支持窗口共享，在文档中，这种窗口称为缺省IME窗口。另一种类型是IME支持应用程序创建的IME窗口，在文档中，IME支持应用程序创建的IME窗口称作应用程序IME窗口。

2、缺省和应用程序IME窗口
    当线程初始化时系统创建缺省IME窗口，这就是说，线程自动获取缺省IME窗口。缺省IME窗口为无IME支持应用程序提供IME用户界面，当IME或者IMM生成一个IME消息（WM_IME_*）时，无IME支持应用程序传递该消息到DefWindowProc函数，DefWindowProc函数发送需要的消息到为应用程序提供缺省IME用户界面的缺省IME窗口。IME支持应用程序当不从IME获取消息时也可以使用缺省IME窗口，需要时可以使用自身的IME窗口。

3、IME类
    IME类是Windows 95远东版本预定义的窗口类，就像Edit是预定义的窗口类一样。预定义的IME类实现全部的IME用户接口，处理所有来自IME和包含IMM函数的应用程序的消息，应用程序使用IME类创建自己的IME窗口。系统IME类不能被被任何IME替换。
    窗口过程与IME类通过WM_IME_SELECT消息交互，该消息包括新选中的IME的键盘布局，IME类使用键盘布局查找到每一个IME定义的类名。使用类名，IME类为当前活动的IME创建IME用户界面窗口。

4、IME UI类
    每一个IME必须向系统注册自己的用户界面（UI）类，UI类提供IME相关功能。当IME附加在进程上时IME注册自己的UI类，这就是说，当DLLEntry函数被调用DLL_PROCESS_ATTACH功能时，IME必须在对ImeInquire函数的调用过程中指定UI类名。UI类应该使用CS_IME窗口风格注册以使得每一个应用程序都可以使用UI类。
    UI类名（包括空终结符）可以使用16位的TCHAR字符，这个限制可能延续到Windows的未来版本。
    当注册一个UI类时，应该指定8个字节的窗口附加数据（这就是说，设置WNDCLASSEX类的cbWndExtra成员的值为2*sizeof(LONG)），系统使用该窗口附加数据。
    IME可以在为应用程序执行任务时注册任何类和创建任何窗口。

    下面的实例显示了怎样注册IME窗口类：

BOOL WINAPI DLLEntry ( HINSTANCE hInstDLL, DWORD dwFunction, LPVOID lpNot)
{
    switch (dwFunction)
      {
        case DLL_PROCESS_ATTACH:
        hInst= hInstDLL;
        wc.style = CS_MYCLASSFLAG | CS_IME;
        wc.lpfnWndProc = MyUIServerWndProc;
        wc.cbClsExtra = 0;
        wc.cbWndExtra = 2 * sizeof(LONG);
        wc.hInstance = hInst;
        wc.hCursor = LoadCursor( NULL, IDC_ARROW);
        wc.hIcon = NULL;
        wc.lpszMenuName = (LPSTR) NULL;
        wc.lpszClassName = (LPSTR) szUIClassName;
        wc.hbrBackground = NULL;
        if(!RegisterClass((LPWNDCLASS)&wc))
        return FALSE;
        wc.style = CS_MYCLASSFLAG | CS_IME;
        wc.lpfnWndProc = MyCompStringWndProc;
        wc.cbClsExtra = 0;
        wc.cbWndExtra = cbMyWndExtra;
        wc.hInstance = hInst;
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hIcon = NULL;
        wc.lpszMenuName = (LPSTR) NULL;
        wc.lpszClassName = (LPSTR) szUICompStringClassName;
        wc.hbrBackground = NULL;
        if(!RegisterClass((LPWNDCLASS)&wc))
        return FALSE;
        break;
        case DLL_PROCESS_DETACH:
        UnregisterClass(szUIClassName,hInst);
        UnregisterClass(szUICompStringClassName,hInst);
        break;
     }
   return TRUE;
}

5、UI窗口
    IME类对应的IME窗口被应用程序或者系统创建，当IME窗口被创建时，IME自身提供的UI窗口被创建并被IME窗口所拥有。每一个UI窗口有一个当前的输入上下文，当UI窗口接收到IME消息（WM_IME_*）时，可以通过调用GetWindowLong函数和指定IMMGWL_IMC索引值查找到输入上下文，UI窗口可以根据输入上下文处理消息，UI窗口可以在除响应WM_CREATE消息以外的任何时间查找到输入上下文。
    IME不允许改变UI窗口的窗口附加数据，如果UI窗口的某个实例需要窗口附加数据，可以使用IMMGWL_PRIVATE参数值调用SetWindowLong和GetWindowLong函数，IMMGWL_PRIVATE参数值提供为UI窗口的某个实例存取附加数据中LONG类型值的能力，如果需要大于LONG类型值的附加数据，可以保存一个内存块的句柄到IMMGWL_PRIVATE域。
    UI窗口过程可以使用DefWindowProc函数，但是UI窗口不允许传递IME消息给DefWindowProc函数，即使某个IME消息没有被处理，UI窗口也不允许传递该消息给DefWindowProc函数。
LRESULT UIWndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
HIMC hIMC;
HGLOBAL hMyExtra;
switch(msg){
case WM_CREATE:
// Allocate the memory bloack for the window instance.
hMyExtra = GlobalAlloc(GHND,size_of_MyExtra);
if (!hMyExtra)
MyError();
// Set the memory handle into IMMGWL_PRIVATE
SetWindowLong(hWnd, IMMGWL_PRIVATE, (LONG)hMyExtra);
.
.
.
break;
case WM_IME_xxxx:
// Get IMC;
hIMC = GetWindowLong(hWnd,IMMGWL_IMC);
// Get the memory handle for the window instance.
hMyExtra = GetWindowLong(hWnd, IMMGWL_PRIVATE);
lpMyExtra = GlobalLock(hMyExtra);
.
.
.
GlobalUnlock(hMyExtra);
break;
.
.
.
case WM_DESTROY:
// Get the memory handle for the window instance.
hMyExtra = GetWindowLong(hWnd, IMMGWL_PRIVATE);
// Free the memory block for the window instance.
GlobalFree(hMyExtra);
break;
default:
return DefWindowProc(hWnd, msg, wParam, lParam);
}
}
    UI窗口必须在当前选定的输入上下文中执行动作，当一个窗口被激活时，UI窗口接收到提供当前输入上下文的消息，此后，UI窗口运行在当前选中的输入上下文上。输入上下文必须包括UI窗口显示写作窗口、状态窗口等需要的所有信息。
    UI窗口要求输入上下文，但是窗口不必自己更新输入上下文。当UI窗口需要更新输入上下文时，应该调用IMM函数，因为输入上下文由IMM函数管理，当输入上下文更新时，IMM和IME接收到通知消息。
    例如，有时UI窗口当鼠标单击时需要改变输入上下文的转换模式，为了设置转换模式，UI窗口调用ImmSetConversionMode函数，该函数为NotifyIME生成一个通知消息并发送WM_IME_NOTIFY消息到UI窗口，如果UI窗口改变转换模式的显示，UI窗口会等待处理WM_IME_NOTIFY消息。

6、UI窗口的部件
    UI窗口可以根据输入上下文注册和显示写作窗口和状态窗口，UI窗口的部件类的窗口风格必须包括CS_IME。UI窗口的一个窗口实例从当前输入上下文接收例如写作字符串、字体、位置等信息，当应用程序的一个窗口获得焦点时，系统获取该窗口自己的输入上下文并将当前输入上下文传递给UI窗口，系统发送WM_IME_SETCONTEXT消息和输入上下文的句柄给应用程序，应用程序传递该消息给UI窗口。如果当前输入上下文被更新，UI窗口应该重新绘制写作窗口，无论何时输入上下文改变，UI窗口都应该显示正确的写作窗口，可以保证IME的状态。
    UI窗口可以创建子窗口或者弹出式窗口显示状态、写作字符串或者候选字列表，这些窗口必须是UI窗口的附属窗口，而且必须创建为不可接收输入（Disable）窗口，任何IME创建的窗口都不应该获取焦点。

三、输入上下文

1、缺省输入上下文
    缺省情况下系统给每个线程一个输入上下文，该输入上下文被线程的所有无IME支持窗口共享。

2、输入上下文与窗口的交互
    应用程序的一个窗口可以使用窗口句柄与输入上下文交互以维护任何IME状态，包括中间写作字符串。一旦应用程序使得输入上下文与窗口句柄交互，无论何时窗口被激活，系统自动选中输入上下文。使用这个特点，应用程序可以轻松地完成Windows 3.1下必须的复杂切换处理。

3、使用输入上下文
    当应用程序或者系统创建新的输入上下文时，系统准备新的输入上下文，新的输入上下文已经包括IMCC，这个IMC的部件由hCompStr、hCandInfo、hGuideLine、hPrivate和hMsgBuf组成。IME基本上不需要创建输入上下文和输入上下文的部件，不过IME可以改变它们的大小，可以通过锁定它们查找到部件的指针。
　
⑴存取HIMC
    为了存取输入上下文，IME必须调用ImmLockIMC函数以查找到输入上下文的指针，ImmLockIMC函数给IMC增加imm锁定计数，ImmUnlockIMC函数减少之。

⑵存取HIMCC
    为了存取输入上下文中的一个部件，IME必须调用ImmLockIMCC函数获取IMCC的指针，ImmLockIMCC函数给IMCC增加imm锁定计数，ImmUnlockIMCC函数减少之，ImmReSizeIMCC函数可以修改IMCC的大小以指定新的大小。
    某些情况下，IME可能需要自己创建输入上下文的一个部件，这种情况下，IME可以调用ImmCreateIMCC函数获取IMCC的句柄，这个IMCC可以是INPUTCONTEXT结构的成员（hCompStr、hCandInfo、hGuideLine、hPrivate或者hMsgBuf）。
    ImmDestroyIMCC清除输入上下文的一个部件。

⑶怎样使用输入上下文
    下面的实例显示了怎样使用输入上下文
LPINPUTCONTEXT lpIMC;
LPCOMOSITIONSTRING lpCompStr;
HIMCC hMyCompStr;
if (hIMC) { // It is not NULL context.
lpIMC = ImmLockIMC(hIMC);
if (!lpIMC) {
MyError( "Can not lock hIMC");
return FALSE;
}
// Use lpIMC->hCompStr.
lpCompStr = (LPCOMPOSITIONSTRING) ImmLockIMCC(lpIMC->hCompStr);
// Access lpCompStr.
ImmUnlockIMCC(lpIMC->hCompStr);
// ReSize lpIMC->hCompStr.
if (!(hMyCompStr = ImmReSizeIMCC(lpIMC->hCompStr,dwNewSize)) {
MyError("Can not resize hCompStr");
ImmUnlockIMC(hIMC);
return FALSE;
}
lpIMC->hCompStr = hMyCompStr;
ImmUnlockIMC(hIMC);
}

四、生成消息
    IME需要生成IME消息。当IME开始转换时，IME必须生成WM_IME_STARTCOMPOSITION消息，如果IME改变了写作字符串，IME必须生成WM_IME_COMPOSITION消息，IME引发的事件导致生成消息给与输入上下文进行交互的窗口。IME基本上使用ImeToAsciiEx函数参数提供的lpdwTransKey缓冲区生成消息，当ImeToAsciiEx函数被调用时IME存储消息到lpdwTransKey缓冲区中，不过即使ImeToAsciiEx函数没有
被调用，IME也可以生成消息给使用输入上下文的消息缓冲区与输入上下文交互的窗口。输入上下文有一个内存块的句柄作为消息缓冲区，IME存储消息到被消息缓冲区句柄提供的内存块中，以后IME调用ImmGenerateMessage函数，ImmGenerateMessage函数发送保存在消息缓冲区中的消息到适当的窗口。

1、在ImeToAsciiEx函数中使用消息缓冲区
    下面的实例显示了怎样通过传递缓冲区到ImeToAsciiEx函数生成消息：
UINT ImeToAsciiEx(uVirKey, uScanCode, lpbKeyState, lpdwTransBuf,
fuState , hIMC )
{
DWORD dwMyNumMsg = 0;
.
.
.
// Set the messages that the IME needs to generate.
*lpdwTransBuf++ = (DWORD) msg;
*lpdwTransBuf++ = (DWORD) wParam;
*lpdwTransBuf++ = (DWORD) lParam;
// Count the number of the messages that the IME needs to generate.
dwMyNumMsg++;
.
.
.
return dwMyNumMsg;
}
    系统提供lpdwTransBuf参数指定的缓冲区，IMEToAsciiEx函数可以一次存储所有的消息到该缓冲区中，缓冲区的第一个双字给出存储在缓冲区中的消息个数。如果ImeToAsciiEx函数需要生成比这个给定的个数更多的消息，函数可以存储所有的消息到输入上下文的hMsgBuf域中，然后函数ImeToAsciiEx返回消息个数。当ImeToAsciiEx函数的返回值大于lpdwTransBuf中指定的值时，系统不从lpdwTransBuf中取出消息，系统查找作为ImeToAsciiEx函数参数传递的输入上下文中的hMsgBuf域。

2、使用消息缓冲区
    下面的实例显示了怎样使用消息缓冲区：
MyGenerateMesage(HIMC hIMC, UINT msg, WPARAM wParam, LPARAMlParam)
{
LPINPUTCONTEXT lpIMC;
HGLOBAL hTemp;
LPDWORD lpdwMsgBuf;
DWORD dwMyNumMsg = 1;
// Lock the input context.
lpIMC = ImmLockIMC(hIMC);
if (!lpIMC)
// Error!
// re-allocate the memory bloack for the message buffer.
hTemp = ImmReSizeIMCC(lpIMC->hMsgBuf,
(lpIMC->dwNumMsgBuf + dwMyNumMsg) * sizeof(DWORD) * 3);
if (!hTemp)
// Error!
lpIMC->hMsgBuf = hTemp;
// Lock the memory for the message buffer.
lpdwMsgBuf = ImmLockIMCC(lpIMC->hMsgBuf);
if (!lpdwMsgBuf)
// Error!
lpdwNumMsgBuf += 3 * lpIMC->dwNumMsgBuf.
// Set the number of the messages.
lpIMC->dwNumMsgBuf += dwMyNumMsg;
// Set the messages that the IME needs to generate.
*lpdwMsgBuf++ = (DWORD) msg;
*lpdwMsgBuf++ = (DWORD) wParam;
*lpdwMsgBuf++ = (DWORD) lParam;
// Unlock the memory for the message buffer and the input context.
ImmUnlockIMCC(lpIMC->hMsgBuf);
ImmLockIMC(hIMC);
// Call ImmGenerateMessage function.
ImmGenerateMessage(hIMC);
}

3、WM_IME_COMPOSITION消息
    当IME生成WM_IME_COMPOSITION消息时，IME指定lParam参数为GCS位。GCS位的意义是COMPOSITIONSTRING结构中的有效成员，即使IME没有更新，成员目前仍然有效，IME也会设置GCS位。
    为IME定义服务
    当IME生成WM_IME_COMPOSITION消息时，IME可能会立刻改变字符串、属性以及子句信息。IME使用下列定义：
GCS_COMP
GCS_COMPREAD
GCS_RESULT
GCS_RESULTREAD

五、关于ImeSetCompositionString函数

1、ImeSetCompositionString函数能力
    如果IME没有ImeSetCompositionString函数能力，IME将不能在IMEINFO结构中指定任何SCS能力。如果IME可以处理ImeSetCompositionString函数，IME设置SCS_COMPSTR位。如果IME可以通过写作字符串生成解释（本文中的“解释”是单词“reading”的直译，真正意义可能是“原始输入的”，例如输入的汉语拼音字母字符串，下同）字符串，IME可以设置SCS_CAP_MAKEREAD位。
    如果IME有SCS_CAP_COMPSTR能力，ImeSetCompositionString函数将被调用，IME从应用程序获取新的写作字符串并生成WM_IME_COMPOSITION消息。
    如果IME有SCS_CAP_MAKEREAD能力，IME可以通过写作字符串建立解释字符串。

2、关于SCS_SETSTR
    如果ImeSetCompositionString函数的dwIndex参数值为SCS_SETSTR，IME可以清除hIMC中的COMPOSITIONSTR结构中所有的域。
如果IME需要，IME可以更新候选信息并生成候选消息IMN_OPENCANDIDATE、IMN_CHANGECANDIDATE或者IMN_CLOSECANDIDATE。
    如果ImeSetCompositionString函数的lpRead参数有效，IME应该通过lpRead参数中的解释字符串建立写作字符串，另外IME为新的写作字符串和lpRead参数中的解释字符串建立属性和子句信息，IME生成lParam参数为（GCS_COMP|GCS_COMPREAD）的WM_IME_COMPOSITION消息。有时IME需要自动确定建立上述信息，这种情况下，IME可以生成lParam参数以（GCS_RESULT|GCS_RESULTREAD）代替GCS_COMPxxx的消息。
    如果ImeSetCompositionString函数的lpComp参数有效，IME应该通过lpComp参数中的写作字符串建立写作属性和子句信息，IME生成lParam参数为GCS_COMP的WM_IME_COMPOSITON消息。如果IME有SCS_CAP_MAKEREAD能力，IME应该同时建立解释字符串，IME生成lParam参数为（GCS_COMP|GCS_COMPREAD）的WM_IME_COMPOSITION消息。有时IME需要自动确定建立上述信息，这种情况下，IME可以生成lParam参数以（GCS_RESULT|GCS_RESULTREAD）代替GCS_COMPxxx的消息。
    如果lpRead参数和lpComp参数同时有效，IME应该建立写作字符串和解释字符串，这时IME不需要完全按照lpRead参数和lpComp参数。如果IME不能建立应用程序指定的lpRead参数和lpComp参数之间的关系，IME应该修正写作字符串，IME为新的写作字符串和lpRead参数指定的解释字符串建立属性和子句信息，IME生成lParam参数为（GCS_COMP|GCS_COMPREAD）的WM_IME_COMPOSITION消息。有时IME需要自动完成建立上述信息，这种情况下，IME可以生成lParam参数以（GCS_RESULT|GCS_RESULTREAD）代替GCS_COMPxxx的消息。

3、关于SCS_CHANGEATTR
    SCS_CHANGEATTR只影响属性信息，IME不应该更新写作字符串、写作字符串的子句信息、写作字符串的解释以及写作字符串的解释子句信息。
首先IME检查新的属性并判断新的属性是否可用，然后IME设置属性到hIMC中的COMPOSITIONSTRING结构中，最后IME生成WM_IME_COMPOSITION消息。
    如果需要，IME可以更新候选信息并生成候选消息IMN_OPENCANDIDATE、IMN_CHANGECANDIDATA、IMN_CLOSECANDIDATE。IME不能确定写作字符串。
    如果ImeSetCompositionString函数的lpRead参数有效，IME使用lpRead参数中的新属性。IME也应该为当前写作字符串建立写作字符串的新属性，这时子句信息不被修改。
    写作字符串、属性、子句信息、解释字符串、解释属性和解释子句信息必须有效。IME生成lParam参数为（GCS_COMP|GCS_COMPREAD）的WM_IME_COMPOSITION消息，如果IME不能接受lpComp参数中的新属性，IME不需要生成任何消息并返回FALSE。
    如果ImeSetCompositionString函数的lpComp参数有效，IME使用lpComp参数中的新属性，这时子句信息不被修改。
    如果IME有SCS_CAP_MAKEREAD能力，并且解释字符串有效，IME应该为当前写作字符串的解释建立写作字符串的解释的新属性。
    如果lpRead参数和lpComp参数同时有效，并且如果IME能够接受新的信息，IME设置新的信息到hIMC中的COMPOSITION结构中并生成lParam参数为（GCS_COMP|GCS_COMPREAD）的WM_IME_COMPOSITION消息。

4、关于SCS_CHANGECLAUSE
    SCS_CHANGECLAUSE影响写作字符串和写作字符串的解释的字符串和属性。
    如果需要，IME可以更新候选信息并生成候选消息IMN_OPENCANDIDATE、IMN_CHANGECANDIDATA、IMN_CLOSECANDIDATE。IME不能确定写作字符串。
    如果ImeSetCompositionString函数的lpRead参数有效，IME使用lpRead参数中的解释子句信息。IME必须修正写作字符串的解释的属性，IME可以更新写作字符串、属性和写作字符串的子句信息，IME生成lParam参数为（GCS_COMP|GCS_COMPREAD）的WM_IME_COMPOSITION消息。
    如果ImeSetCompositionString函数的lpComp参数有效，IME使用新的子句信息。IME必须修正写作字符串和写作字符串的属性，IME可以更新解释属性和解释的子句信息，IME生成lParam参数为（GCS_COMP|GCS_COMPREAD）的WM_IME_COMPOSITION消息。
    如果lpRead参数和lpComp参数同时有效，并且如果IME能够接受新的信息，IME设置新的信息到hIMC中的COMPOSITION结构中并生成lParam参数为（GCS_COMP|GCS_COMPREAD）的WM_IME_COMPOSITION消息。

六、软键盘

1、关于软键盘
    一些IME有特殊的解释字符，例如一个IME可能使用注音符号作为解释字符（这里指台湾中文版Windows 95，即CWin95中的注音符号，PWin95中可能指汉语拼音字母或者音调符号——译者注），另一个IME使用了一些字根符号（原文单词是“radials”，但实际可能是“radicals”——译者注）作为解释字符，IME可以提供一个软键盘显示这些特殊解释字符使得用户不必逐键记忆解释字符。
    IME需要根据不同的变换状态改变键表示的解释字符，使用软键盘可以通知用户键的改变。在选择候选字时，IME可以只显示那些选择键给用户。

2、使用软键盘
    IME可能需要为软键盘创建一个更好的用户界面，或者可能需要系统预定义的软键盘，如果IME需要使用系统预定义的软键盘，IME需要在调用ImeInquire函数时将IMEINFO结构的fdwUICaps成员指定为UI_CAP_SOFTKBD。
    IME可以调用ImmCreateSoftKeyboard函数为软键盘创建窗口，还可以调用ImmShowSoftKeyboard函数显示或者隐藏软键盘。软键盘窗口是UI窗口的一个组件，所以软键盘窗口应该附属于UI窗口。
    IME可能需要决定是否在无论何时焦点移走的情况下删除窗口，软键盘可能占有一些系统资源（可能需要释放——译者注）
    软键盘有不同的类型，一种类型可能是为特定的国家或者特定的目的设计的。为每一种类型的软键盘改变解释字符的方式可能不同，有两种改变解释字符的方式：使用IMC_SETSOFKBDSUBTYPE或者IMC_SETSOFKBDDATA。不同类型的软键盘有不同的窗口过程并存在不同的用户界面给用户。
　
七、IME接口
    在Windows 95中，IME与设备驱动程序一样是动态链接库（DLL），输入法管理器（IMM）应该处理所有安装的IME。因为IME在运行时是可以改变的，不需要重新启动系统，IMM有一个结构用于维护每一个IME的所有入口点。IME函数列表是所有远东版本Windows 95公共IME功能函数的描述，这些函数不应该在应用程序中直接调用。
　
    UI窗口中的IMM函数
    下面是可以在UI窗口中调用的IMM函数：
ImmGetCompositionWindow
ImmSetCompositionWindow
ImmGetCandidateWindow
ImmSetCandidateWindow
ImmGetCompositionString
ImmSetCompositionString
ImmGetCompositionFont
ImmSetCompositionFont
ImmGetNumCandidateList
ImmGetCandidateList
ImmGetGuideLine
ImmGetConversionStatus
ImmGetConversionList
ImmGetOpenStatus
ImmSetConversionStatus
ImmSetOpenStatus
ImmNotifyIME
ImmCreateSoftKeyboard
ImmDestroySoftKeyboard
ImmShowSoftKeyboard

2、输入法编辑器应用
2．1 处理WM-IME-COMPOSITION消息
处理WM_IME_COMPOSITION消息的程序测试lParam参数的位数和调用ImmGetCompositionString函数检索指示串或数据。下例检查结果串，为串指派足够的内存，并从IME中检索结果串。
HIMC hIMC;
HWND hWnd;
DWORD dwSize;
HGLOBAL hstr;
LPSTR lpstr;

case WM_IME_COMPOSITION:
    if (lParam & GCS_RESULTSTR)
    {
        hIMC = ImmGetContext(hWnd);

        If (!hIMC)
            MyError(ERROR_NULLCONTEXT);

        // Get the size of the result string.
        dwSize = ImmGetCompositionString(hIMC, GCS_RESULTSTR, NULL, 0);

        // increase buffer size for NULL terminator,
        //   maybe it is in UNICODE
        dwSize += sizeof(WCHAR);

        hstr = GlobalAlloc(GHND,dwSize);
        if (hstr == NULL)
             MyError(ERROR_GLOBALALLOC);

        lpstr = GlobalLock(hstr);
        if (lpstr == NULL)
             MyError(ERROR_GLOBALLOCK);

        // Get the result strings that is generated by IME into lpstr.
        ImmGetCompositionString(hIMC, GCS_RESULTSTR, lpstr, dwSize);
        ImmReleaseContext(hWnd, hIMC);

        // add this string into text buffer of application

        GlobalUnlock(hstr);
        GlobalFree(hstr);
    }
2．2 输入法编辑器和Unicode
微软® Windows NT ®/2000 和微软® Windows® 98两种平台均为IME支持Unicode接口，当然还有从Windows95起，就支持的ANSI接口。Windows98支持除ImmIsUIMessage以外的所有Unicode函数。此外Windows98中的所有消息均是基于ANSI的。既然Windows98不支持Unicode消息，程序可以利用ImmGetCompositionString从Win98中基于IME的Unicode中检索Unicode字符。
有两个问题涉及Unicode句柄和IME。一个是IME例行程序的Unicode版本返回缓存字节的大小，而不是16位Unicode字符；另一个是IME通常在WM_CHAR 和WM_IME_CHAR消息中返回Unicode字符（不是DBCS）。
用RegisterClassW使WM_CHAR和 WM_IME_CHAR消息在wParam参数中返回Unicode字符而不是DBCS字符。此法仅在Windows NT/2000中可用。在win95/98中不可用。
2．3  复原IME
在Windows 98/2000中，IME具有复原的新特征。通常情况下，IME仅限于由键入来决定备择列表。复原允许IME依照其所在的句子（上下文）来决定备择的字符（或仅一个备择字符）。复原有三种类型：简单，正常和高级。
当用户在文件中发现录入错误时，复原是很有用的。此时，用户选出错误，并在菜单中选择复原，则IME用上下文来确定最佳替代。ImmSetCompositionString可用来支持复原的使用。
2．4 开发IME-aware多线程应用程序。
当前的输入法管理器（IMM）结构不支持访问IMM句柄的异步工具。
Windows 2000的IMM包含线程确认检查，用来确认调用的线程是否是指定输入法上下文句柄（hIMc）或视窗句柄（hWnd）的创建者。若不是，则函数调用失败并从GetLastError函数中返回ERROR_INVALID_ACCESS
这一过程须要开发者遵循以下原则：
⑴一个线程不应该同由其它线程创建的输入上下文。
⑵一个线程不应连接输入上下文和其它线程创建的视窗，或反之。
2．5、Windows 2000中的IME
Windows 2000为任何地方的语言版本均提供IME的所有特性。因此，可以在Windows 2000的任何版本中安装和使用IME，而不仅是仅为亚洲语言设计的Windows 2000。
然而，仅当用户在Win 2000上安装了亚洲语言包，IMM方可被激活。基于IME的程序， 用SM_IMMENABLED调用GetSystemMetrics函数来判定IMM是否被激活。

　　本文将对如何在Windows应用程序中动态的控制输入法的技术进行探讨。在DELPHI中许多控件都有控制输入法的属性，用户在设计时只要设置好这个属性就可以了，但在VC中并不直接提供对输入法的控制，要在VC应用中实现这种功能必须调用Windows API。在本文中我将用一个类将与输入法操作有关的Windows API函数进行封装，读者可以直接将这个类导入项目工程中，通过操作这个类来实现对输入法的控制，这样更适合于面向对象的开发。

　　要想控制输入法，首先要解决的问题是如果获得系统已安装的输入法信息。在Windows平台下，每个安装的输入法都在注册表中注册了相关信息。在“HKEY_CURRENT_USER\keyboard layout\preload”键下就可以找到这些信息，键下由以1为基的递增数字做为值名（暂取名为数字号），其值的内容是一个由八个数字组成的字符串（暂取名为代号，如"e0040804"）,其中左4位是设备代码(device identifier)，右4位是语言代码(language identifier)。例如上面：左e004指智能ABC,右0804指大陆中文。在MSDN中对所有代码做了详细的说明，如感兴趣请浏览MSDN相关内容。另外要说明一点的是在Windows98版本中输入法注册信息与上面说明略有不同，它是将已安装的输入法的数字号做为…\Preload下面的子键，而Windows2000将数字号做为…\Preload键下的值。

　　　通过读取注册表中的输入法信息，可以列出所有已安装的输入法，但得到的输入法信息只是一些让人难懂的数字串，如何将这些数字串翻译成易懂的文字说明呢？同样，　在HKEY_LOCAL_MACHINE:"System\CurrentControlSet\Control\Keyboard Layouts\"键下注册了这些信息，它的子键名为输入法代号(keyboard layout)，内容为该输入法的ime文件，名称等信息。到此，我们已经了解了Windows系统控制输入法的原理知识，下面我们开始着手创建一个控制输入法的C++类，主要步骤如下：

　　1． 创建一个新类，新类名为：CInputLanguage

　　2． 新建一个保存输入法信息的结构。当加载系统已安装的输入法信息时，用一个此结构的链表来保存输入法信息。

struct IL{
　char ilID[15]; //输入法代号。
　char szName[100];//输入法的说明文字。
　IL* pNext;
}; 

　　3． 加入一个私有的成员变量

　　　IL* m_pILHead;

　　4． 加入加载输入法列表信息的成员函数

//此函数只针对Windows2000以上版本，如要在Windows98版本的代码请与笔者联系。

BOOL CInputLanguage::LoadInputLanguage()
{
　HKEY hKey,hKey1;
　DWORD cp=16;
　char lp[15];
　CString szID;
　CString szKeyName,szKeyName1;
　szKeyName = "Keyboard Layout\\Preload";
　szKeyName1 = "System\\CurrentControlSet\\Control\\Keyboard Layouts\\";

　int i=1;
　szID.Format("%d",i);

　DWORD lpT=REG_SZ;
　if(::RegOpenKey(HKEY_CURRENT_USER,szKeyName,&hKey)==ERROR_SUCCESS )
　{
　　While( ::RegQueryValueEx(hKey,szID,NULL,&lpT,(LPBYTE)lp,&cp) == ERROR_SUCCESS )
　　{
　　　CString szTempName;
　　　szTempName = szKeyName1 + (LPCTSTR)(LPTSTR)lp;
　　　if(RegOpenKey(HKEY_LOCAL_MACHINE,szTempName,&hKey1)==ERROR_SUCCESS )
　　　{
　　　　char lpD[100];
　　　　DWORD lpS=100; //DataSize
　　　　if(RegQueryValueEx(hKey1,"Layout text",NULL,&lpT,(LPBYTE)lpD,&lpS)==ERROR_SUCCESS)
　　　　{
　　　　　IL* p1,*p2;
　　　　　p1 = m_pILHead;
　　　　　p2 = new(IL);
　　　　　strcpy(p2->ilID,lp);
　　　　　strcpy(p2->szName,lpD);
　　　　　p2->pNext = NULL;
　　　　　if( p1 )
　　　　　{
　　　　　　while( p1->pNext ){ p1 = p1->pNext ; }
　　　　　　p1->pNext = p2;
　　　　　}
　　　　　else
　　　　　{
　　　　　　m_pILHead = p2;
　　　　　}
　　　　}
　　　}
　　　::RegCloseKey(hKey1);
　　　i++;
　　　szID.Format("%d",i);
　　}
　}

　::RegCloseKey(hKey);
　return (m_pILHead != NULL );

}
 

　　5． 加入选择输入法成员函数

BOOL CInputLanguage::SelectInputLanguage(IL *pIL)

{
　if( !pIL ) return FALSE;
　　HKL hkl;
　　hkl=LoadKeyboardLayout(pIL->ilID,KLF_ACTIVATE);//装载输入法
　　if(hkl==NULL) return FALSE;
　　else{
　　　ActivateKeyboardLayout(hkl,KLF_SETFORPROCESS);//激活输入法
　　}
　　return TRUE;

}
 

　　6． 其它部分

CInputLanguage::CInputLanguage()

{
　m_pILHead = NULL;
　LoadInputLanguage();

}

CInputLanguage::~CInputLanguage()

{
　Clear();
}

//消除链表内存。

void CInputLanguage::Clear()

{
　IL* p1,*p2;
　p1 = m_pILHead;

　while( p1 )
　{
　　p2 = p1;
　　p1 = p1->pNext;
　　delete(p2);
　}
　m_pILHead = NULL;

}

//获得输入法信息链表头结点指针。

IL* CInputLanguage::GetInputLanguageList()

{
　return m_pILHead;
}

　　使用此类时，只要将其头文件包括到要调用的文件中，调用GetInputLanguageList函数可以得到输入法信息链表的头结点指针，通过遍历此链表得到所有已安装的输入法的信息；通过SelectInputLanguage函数可以自由的控制输入法了

2.加notifyicon控件notifyIcon1，为控件notifyIcon1的属性Icon添加一个icon图标。

3.添加窗体最小化事件(首先需要添加事件引用)：

// this.SizeChanged += new System.EventHandler(this.Form1_SizeChanged);

//上面一行是主窗体InitializeComponent()方法中需要添加的引用

private void Form1_SizeChanged(object sender, EventArgs e)
{
if (this.WindowState==FormWindowState.Minimized)
{
this.Hide();
this.notifyIcon1.Visible=true;
}

}
4.添加点击图标事件(首先需要添加事件引用)：

private void notifyIcon1_Click(object sender, EventArgs e)
{
this.Visible = true;

this.WindowState = FormWindowState.Normal;

this.notifyIcon1.Visible = false;
}

5.可以给notifyIcon添加右键菜单：

主窗体中拖入一个ContextMenu控件contextMenu1，点中控件，在上下文菜单中添加菜单，notifyIcon1的ContextMenu行为中选中contextMenu1作为上下文菜单。

(可以在子菜单中添加行为)

鼠标的控制可以应用于图形模式和文本模式。在初始图形模型时,首先调用initgraph(),从文本模式切换到图形模式。在初始时，将用到DETECT 宏，它将令initgraph()函数自动选择最高的图形支持模式。关于图形模式请参考其它书籍，这里不是重点。

鼠标的调用是通过调用中断51实现的，而它的状态控制是通过AX寄存器实现的。

中断码	控制字	行为
51	0	初始化鼠标获得其状态  调用：AX = 0  返回： AX = FFFFh 不支持 鼠标                      Ax = 0  支持鼠标
51	1	显示鼠标箭头  调用：AX = 1    返回：空
51	2	隐藏鼠标箭头  调用： AX = 2  返回： 空
51	3	获取鼠标位置和状态   调用：AX = 3   返回： BX = 鼠标状态    值          状态   0     没有按键按下   1     左键按下   2     右键按下   3     中键按下  CX = x 坐标  DX = y 坐标
51	4	设置鼠标位置  调用： AX = 4  CX = x 坐标  DX = y 坐标  返回： 空
51	7	设定x轴移动范围  调用： AX = 7  CX = 最小 x 坐标  DX = 最大 x 坐标  返回: 空
51	8	设定y轴移动范围   调用： AX = 8  CX = 最小 y 坐标  DX = 最大 y 坐标  返回： 空

给出两个例子：

例一：

 #include<graphics.h>
       #include<stdio.h>
       #include<conio.h>
       #include<dos.h>
       union REGS in,out;

       int callmouse()
       {
              in.x.ax=1;
              int86(51,&in,&out);
              return 1;
       }
       void mouseposi(int &xpos,int &ypos,int &click)
       {
              in.x.ax=3;
              int86(51,&in,&out);
              click=out.x.bx;
              xpos=out.x.cx;
              ypos=out.x.dx;
        }
       int mousehide()
       {
              in.x.ax=2;
              int86(51,&in,&out);
              return 1;
       }
      void setposi(int &xpos,int &ypos)
      {
             in.x.ax=4;
             in.x.cx=xpos;
             in.x.dx=ypos;
             int86(51,&in,&out);
      }
     int main()
      {
             int x,y,cl,a,b;
             clrscr();
             int g=DETECT,m;
             initgraph(&g,&m,"c:\tc\bgi");
             a=100;
             b=400;
             setposi(a,b);
             callmouse();
             do
             {
                    mouseposi(x,y,cl);
                    gotoxy(10,9);
                    printf("\n\tMouse Position is: %d,%d",x,y);
                    printf("\n\tClick: %d",cl);
                    printf("\n\tPress any key to hide the mouse");
             }while(!kbhit());
             getch();
             mousehide();
             printf("\n\n\tPress any key to Exit");
             getch();
     }

例二

#include<graphics.h>
         #include<stdio.h>
         #include<conio.h>
         #include<dos.h>
         union REGS in,out;

         int callmouse()
          {
                 in.x.ax=1;
                 int86(51,&in,&out);
                 return 1;
          }
         void restrictmouseptr(int x1,int y1,int x2,int y2)
          {
                 in.x.ax=7;
                 in.x.cx=x1;
                 in.x.dx=x2;
                 int86(51,&in,&out);
                 in.x.ax=8;
                 in.x.cx=y1;
                 in.x.dx=y2;
                 int86(51,&in,&out);
          }
         int main()
          {
                 int x,y,cl,a,b;
                 clrscr();
                 int g=DETECT,m;
                 initgraph(&g,&m,"c:\tc\bgi");
                 rectangle(100,100,550,400);
                 callmouse();
                 restrictmouseptr(100,100,550,400);
                 getch();
          }

-Codebee

隐藏桌面

在隐藏桌面，任务栏，开始按钮，都可以通过windows API 函数 FindWindow() 和
ShowWindow()实现。

隐藏任务栏，你可以使用下面的代码：

ShowWindow(FindWindow("Shell_TrayWnd", NULL), SW_HIDE);

隐藏开始菜单按钮，你首先要获得按钮的ID,然后使用下面的代码：

ShowWindow(GetDlgItem(FindWindow("Shell_TrayWnd", NULL),0x130), SW_HIDE);

Shell_TrayWnd 是任务栏的类
0x130 是开始按钮的ID

这些都是通过VC++6.0 下面的Spy++ 工具捕获到的。同理，你可以捕获任何一个你想要的窗口或者按钮。

屏蔽窗口不想隐藏，可以把ShowWindow() 函数换为 EnableWindow()。

如此，当你按下Win键仍然会弹出开始菜单，下面我们来屏蔽热键。

屏蔽系统热键

在Win9x/ME 可以用下面的代码：

SystemParametersInfo(SPI_SETSCREENSAVERRUNNING, TRUE, &bOldState, 0);

当然Windows2000 和 Windows XP 是不适合这种方法的。

屏蔽系统热键，在Windows2000 和 Windows XP 是用钩子函数来实现的

首先，在程序中安装一个钩子：
SetWindowsHookEx():

hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, KeyboardProc, hInstance, 0);

KeyboardProc() 函数是一个CallBack类型的，也就是说一旦有按键按下系统都会调用此函数。

 LRESULT KeyboardProc(...)
  {
     if (Key == VK_SOMEKEY)
    return 1;             // 屏蔽热键

    return CallNextHookEx(...); // 返回
  }

释放钩子时：

UnhookWindowsHookEx(hKeyboardHook);

当然这里是安装的系统级的钩子(关于钩子可以参看Blog里的另外一篇转的文章[C++与WIN32与MFC]利用钩子函数来捕捉键盘响应的windows应用程序.(转))。

Ctrl+Alt+Del  的屏蔽

Ctrl+Alt+Del Windows 不会把它放入键盘钩子的消息中(关于键盘钩子也请参看上面的文章)

在这里说说我的方法，主要是屏蔽任务管理。
首先获得系统所以的进程(请参考Blog里的 通过Toolhelp API 查看本地进程的程序(VC 6.0 编译通过）)。

然后使用 Bool TerminateProcess (HANDLE hProcess,UINT fuExitCode);完成。

如果大家有更好的方法可以和我交流。

int main()
{
 HANDLE hSnap=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); //建立进程快照
 PROCESSENTRY32 pe;                                 //定义一个PROCESSENTRY32结构
 pe.dwSize = sizeof(pe);       //初始化
 BOOL bNext=Process32First(hSnap, &pe);    //得到第一个进程

 while (bNext)
 {
 printf("\n%-20s%d",pe.szExeFile,pe.th32ProcessID); //显示
 bNext= Process32Next(hSnap, &pe);     //得到下一个进程
 }
 return 0;
 }

你也许一直对金山词霸的屏幕抓词的实现原理感到困惑，你也许希望将你的键盘，鼠标的活动适时的记录下来，甚至你想知道木马在windows操作系统是怎样进行木马dll的加载的…..其实这些都是用到了windows的钩子函数。因此本文将对钩子函数的相关知识进行阐述。当然，本文的目的并不是想通过此程序让读者去窃取别人的密码，只是由于钩子函数在windows系统中是一个非常重要的系统接口函数，所以想和大家共同的探讨，当然本文也对怎样建立动态连结库（DLL）作了一些简单的描述。（本文的程序为vc6.0的开发环境，语言是：C和win32 api）。

二：钩子概述：

微软的windowsX操作系统是建立在事件驱动的机制上的，也就是通过消息传递来实现。而钩子在windows操作系统中，是一种能在事件（比如：消息、鼠标激活、键盘响应）到达应用程序前中途接获事件的机制。而且，钩子函数还可以通过修改、丢弃等手段来对事件起作用。
Windows 有两种钩子，一种是特定线程钩子（Thread specific hooks），一种是全局系统钩子(Systemwide hooks)。特定线程钩子只是监视指定的线程，而全局系统钩子则可以监视系统中所有的线程。无论是特定线程钩子，还是全局系统钩子，都是通过SetWindowsHookEx ()来设置钩子的。对于特定线程钩子，钩子的函数既可以是包含在一个.exe也可以是一个.dll。但是对于一个全局系统钩子，钩子函数必须包含在独立的dll中，因此，当我们要捕捉键盘响应时，我们必须创建一个动态链接库。但是当钩子函数在得到了控制权，并对相关的事件处理完后，如果想要该消息得以继续的传递，那么则必须调用另一个函数：CallNextHookEx。由于系统必须对每个消息处理，钩子程序因此增加了处理的负担，因此也降低了系统的性能。鉴于这一点，在windows ce中对钩子程序并不支持。所以当程序完成并退出时，应当释放钩子，调用函数：UnhookWindowsHookEx。
下面我们将举一个例子（捕捉键盘）来详细的讲解钩子函数的程序设计。

三：程序的设计：

I:设置钩子

设置钩子是通过SetWindowsHookEx ()的API函数.
原形: HHOOK SetWindowsHookEx(int idHook,HOOKPROC lpfn,HINSTANCE hMod,DWORD dwThreadId)
idhook:装入钩子的类型.
lpfn: 钩子进程的入口地址
hMod: 应用程序的事件句柄
dwThreadId: 装入钩子的线程标示

参数：
idHook:
这个参数可以是以下值：
WH_CALLWNDPROC、WH_CALLWNDPROCRET、WH_CBT、WH_DEBUG、WH_FOREGROUNDIDLE、WH_GETMESSAGE、WH_JOURNALPLAYBACK、WH_JOURNALRECORD、WH_KEYBOARD、WH_KEYBOARD_LL、WH_MOUSE、WH_MOUSE_LL、WH_MSGFILTER、WH_SHELL、WH_SYSMSGFILTER。
对于这些参数，我不想一一加以解释，因为MSDN中有关于他们的详细注解。我只挑选其中的几个加以中文说明。
WH_KEYBOARD：一旦有键盘敲打消息（键盘的按下、键盘的弹起），在这个消息被放在应用程序的消息队列前，WINDOWS将会调用你的钩子函数。钩子函数可以改变和丢弃键盘敲打消息。
WH_MOUSE：每个鼠标消息在被放在应用程序的消息队列前，WINDOWS将会调用你的钩子函数。钩子函数可以改变和丢弃鼠标消息。

WH_GETMESSAGE：每次当你的应用程序调用一个GetMessage()或者一个PeekMessage()为了去从应用程序的消息队列中要求一个消息时，WINDOWS都会调用你的钩子函数。而钩子函数可以改变和丢弃这个消息。

II:释放钩子

钩子的释放使用的是UnhookWindowsHookEx（）函数
原形：BOOL UnhookWindowsHookEx( HHOOK hhk )
UnhookWindowsHookEx（）函数将释放的是钩子链中函数SetWindowsHookEx所装入的钩子进程。
hhk: 将要释放的钩子进程的句柄。

III：钩子进程

钩子进程使用函数HookProc;其实HookProc仅仅只是应用程序定义的符号。比如你可以写成KeyBoardHook.但是参数是不变的。Win32 API提供了诸如：CallWndProc、GetMsgProc、DebugProc、CBTProc、MouseProc、KeyboardProc、MessageProc等函数，对于他们的详细讲解，可以看MSDN我在此只讲解一下KeyBoardHook的含义。
原形：LRESULT CALLBACK KeyBoardHook (int nCode, WPARAM wParam, LPARAM lParam)
说明：钩子进程是一些依附在一个钩子上的一些函数，因此钩子进程只被WINDOWS调用而不被应用程序调用，他们有时就需要作为一个回调函数（CALLBACK）。

参数说明：
nCode:钩子代码，钩子进程使用钩子代码去决定是否执行。而钩子代码的值是依靠钩子的种类来定的。每种钩子种类都有他们自己一系列特性的代码。比如对于WH_KEYBOARD，钩子代码的参数有：HC_ACTION，HC_NOREMOVE。HC_ACTION的意义：参数wParam 和lParam 包含了键盘敲打消息的信息，HC_NOREMOVE的意义：参数wParam 和lParam包含了键盘敲打消息的信息，并且，键盘敲打消息一直没有从消息队列中删除。(应用程序调用PeekMessage函数，并且设置PM_NOREMOVE标志)。也就是说当nCode等于HC_ACTION时，钩子进程必须处理消息。而为HC_NOREMOVE时，钩子进程必须传递消息给CallNextHookEx函数，而不能做进一步的处理，而且必须有CallNextHookEx函数的返回值。 
wParam:键盘敲打所产生的键盘消息，键盘按键的虚拟代码。
lParam:包含了消息细节。

注意:如果钩子进程中nCode小于零，钩子进程必须返回(return) CallNextHookEx(nCode,wParam,lParam);而钩子进程中的nCode大于零，但是钩子进程并不处理消息，作者推荐你调用CallNextHookEx并且返回该函数的返回值。否则，如果另一个应用程序也装入WH_KEYBOARD 钩子，那么该钩子将不接受钩子通知并且返回一个不正确的值。如果钩子进程处理了消息，它可能返回一个非零值去阻止系统传递该信息到其它剩下的钩子或者windows进程。所以最好在钩子进程的最后都返回CallNextHookEx的返回值。 

IV:调用下一个钩子函数

调用下一个钩子函数时使用CallNexHookEx函数。
原形：LRESULT CallNextHookEx( HHOOK hhk, int nCode, WPARAM wParam, LPARAM lParam )
CallNexHookEx()函数用于对当前钩子链中的下一个钩子进程传递钩子信息，一个钩子进程既可以在钩子信息处理前，也可以在钩子信息处理后调用该函数。为什么使用该函数已在iii钩子进程中的“注意”中，加以了详细的说明。
hhk: 当前钩子的句柄
nCode: 传送到钩子进程的钩子代码。
wParam:传送到钩子进程的值。
lParam:传送到钩子进程的值。
参数：
hhk: 当前钩子的句柄. 应用程序接受这个句柄，作为先前调用SetWindowsHookE函数的结果 
nCode: 传送到钩子进程的钩子代码，下一个钩子进程使用这个代码以此决定如何处理钩子信息 
wParam:传送给钩子进程的wParam 参数值 ，参数值的具体含义与当前钩子链的挂接的钩子类型有关
lParam : 传送给钩子进程的wParam 参数值 ，参数值的具体含义与当前钩子链的挂接的钩子类型有关 
返回值：返回值是链中下一个钩子进程返回的值，当前钩子进程必须返回这个值，返回值的具体含义与挂接的钩子类型有关，详细信息请参看具体的钩子进程描述。

V 建立一个动态连接库（DLL）

当我们熟悉了以上的各个函数后，现在我们开始编写一个动态连接库（DLL）。在这儿我采用的是WIN32 DLL,而不是MFC DLL。而且以下所有的程序也都是采用C语言去编写。这主要是因为使用WIN32 API能够更详细、更全面的控制程序的如何执行，而使用MFC，一些低级的控制是不可能实现的(当然，仅对该程序来说，也是可以使用MFC的)。

1：建立一个动态连接库的.cpp文件。比如我们现在建立一个名为hookdll.cpp的文件。在hookdll.cpp的文件中加上如下内容：
#include <windows.h>
#include "string.h"
#include "stdio.h" 

HINSTANCE hInst;

#pragma data_seg("hookdata")
HHOOK oldkeyhook=0;
#pragma data_seg()

#pragma comment(linker,"/SECTION:hookdata,RWS")

#define DllExport extern "C"__declspec(dllexport)

DllExport LRESULT CALLBACK KeyBoardProc(int nCode,WPARAM wParam, LPARAM lParam );
DllExport void InstallHook(int nCode);
DllExport void EndHook(void);

BOOL WINAPI DllMain(HINSTANCE hInstance,ULONG What,LPVOID NotUsed)
{
switch(What)
{
case DLL_PROCESS_ATTACH:
hInst = hInstance;
break;
case DLL_PROCESS_DETACH:
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break; 

}
return 1;
}

void InstallHook(int nCode)
{
oldkeyhook = SetWindowsHookEx(WH_KEYBOARD,(HOOKPROC)KeyBoardProc,hInst,0);
}

DllExport LRESULT CALLBACK KeyBoardProc(int nCode,WPARAM wParam, LPARAM lParam )
{
WPARAM j;
FILE *fp;
if(lParam&0x80000000)
{
j = wParam;
fp=fopen("c:\\hook\\key.txt","a"); 
fprintf(fp,"%4d",j);
fclose(fp);
}
return CallNextHookEx(oldkeyhook,nCode,wParam,lParam);
}
void EndHook(void)
{
UnhookWindowsHookEx(oldkeyhook);
}
这个动态连接库的源代码hookdll.cpp包含了键盘处理函数，设置钩子，退出钩子函数。并将键盘敲下的键以值的格式存入到c:\hook\key.txt文件中。以下是对该文件的详细的解释。
使用包含在DLL的函数，必须将其导入。导入操作时通过dllimport来完成的，dllexport和dllimport都是vc（visual C++）和bc（Borland C++）所支持的扩展的关键字。但是dllexport和dllimport关键字不能被自身所使用，因此它的前面必须有另一个扩展关键字__declspec。通用格式如下：__declspec(specifier)其中specifier是存储类标示符。对于DLL，specifier将是dllexport和dllimport。而且为了简化说明导入和导出函数的语句，用一个宏名来代替__declspec.在此程序中，使用的是DllExport。如果用户的DLL被编译成一个C++程序，而且希望C程序也能使用它，就需要增加“C”的连接说明。#define DllExport extern "C"__declspec(dllexport)，这样就避免了标准C++命名损坏。（当然，如果读者正在编译的是C程序，就不要加入extern “C”,因为不需要它，而且编译器也不接受它）。有了宏定义，现在就可以用一个简单的语句就可以导出函数了，比如：DllExport LRESULT CALLBACK KeyBoardProc(int nCode,WPARAM wParam, LPARAM lParam )；DllExport void InstallHook(int nCode);DllExport void EndHook(void);
第一个#pragma 语句创造数据段，这里命名为hookdata。其实也可以命名为您喜欢的任意的一个名称。#pragma 语句之后的所有初始化的变量都进入hookdata段中。第二个#pragma语句是数据段的结束标志。对变量进行专门的初始化是很重要的，否则编译程序将把它们放在普通的未初始化的段中而不是放在hookdata中。
但是链接程序必须直到有一个hookdata段。我们可以在Project Setting（vc6.0） 对话框中选择Link选项，选中HOOKDLL时在Project Options域（在Release 和Debug配置中均可），包含下面的连接语句：/SECTION:hookdata,RWS字母RWS是表明该段具有读、写、和共享属性。当然，您也可以直接用DLL源代码指定链接程序就像HOOKDLL.c那样：#pragma comment(linker,"/SECTION:hookdata,RWS")。
由于有些DLL需要特殊的启动和终止代码。为此，所有的DLL都有一个名为DllMain()的函数，当初始化或终止DLL时调用该函数。一般在动态连结库的资源文件中定义此函数。不过如果没有定义它，则编译器会自动提供缺省的形式。
原型为：BOOL WINAPI DllMain(HINSTANCE hInstance,ULONG What,LPVOID NotUsed)
参数：
hInstance：DLL实例句柄
What:指定所发生的操作
NotUsed:保留参数
其中What的值可以为以下值：
DLL_PROCESS_ATTACH:进程开始使用DLL
DLL_PROCESS_DETACH:进程正在释放DLL
DLL_THREAD_ATTACH:进程已创建一个新的线程
DLL_THREAD_DETACH:进程已舍弃了一个线程
总的来说，无论何时调用DllMain()函数，都必须根据What的内容来采取适当的动作。这种适当的动作可以什么都不做，但不是返回非零值。 
DllMain()接下来的便是设置钩子，键盘处理，和释放钩子。

2：建立头文件
正如应用程序所使用的其它任何库函数一样，程序也必须包含dll内的函数的原型。所有得Windows程序都必须包含windows.h的原因。所以我们现在建立一个头文件hookdll.h如下：
#define DllImport extern"C"__declspec(dllimport)
DllImport void InstallHook(int nCode);
DllImport LRESULT CALLBACK KeyBoardProc (int nCode,WPARAM wParam, LPARAM lParam );
DllImport void EndHook(void);
使用dllimport主要是为了使代码更高效，因此推荐使用它。但是在导入数据时是需要dllimport的。当完成了上面的程序后，建一个项目工程，不妨为hookdll，然后将hookdll.c插入导项目工程中，编译，则可以生成了hookdll.dll和hookdll.lib。

3：建立程序主文件
我们在上面作的所有得工作都是为现在的主程序打得基础。其实当我们完成了Dll文件后，剩下的就是调用设置钩子函数：InstallHook 。如果你对windows编程十分的熟悉，那么你可以在你任何需要的时候来调用InstallHook。但是在你必须记住在你退出程序的时候你需要调EndHook以便释放你所装入的钩子函数。现在我在建立了一个hookspy.cpp，并将生成好的hookdll.dll和hookdll.lib拷贝到从一个目录下，并建立一个hookspy的项目工程。将hookspy.cpp,hookdll.dll,hookdll.lib,hookdll.h插入到项目工程中去。然后在建立windows窗口时就将钩子设置，在退出程序时退出钩子函数。比如：
case WM_CREATE:
InstallHook(TRUE);
break;
case WM_DESTROY: //terminate the program
EndHook();
PostQuitMessage(0);
break;

刚上大学学习了c，小试牛刀的得了学院c程序设计的第一名。幸哉~！

到了大二，学了c++，这次参加学校比赛又得了第一，进入了学校的程序训练队。

进入已后，发现意思不大，毅然退出。错误？？

现在，在学Win32API,MFC,头都大了，不是难，是熟练很难。

这几天在做钩子程序，写了WIN32API的，又要写基于MFC。

我相信熟能生巧这个道理。

现在缺的，是时间...