VeryTag http://blogger.org.cn/blog/blog.asp?name=breeze 清风细雨的博客 blogger.org.cn W3CHINA Blog webmaster@blogger.org.cn <![CDATA[XHTML1.0 Element Comparison by DTD]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2940 breeze 2005/2/18 16:06:22 .no {font-weight: bold;background:red;} .center {text-align:center}

Element	Strict	Transitional	Frameset
<!-->	Yes	Yes	Yes
<!DOCTYPE>	Yes	Yes	Yes
<a>	Yes	Yes	Yes
<abbr>	Yes	Yes	Yes
<acronym>	Yes	Yes	Yes
<address>	Yes	Yes	Yes
<applet>	No	Yes	Yes
<area />	Yes	Yes	Yes
<b>	Yes	Yes	Yes
<base />	Yes	Yes	Yes
<basefont>	No	Yes	Yes
<bdo>	Yes	Yes	Yes
<big>	Yes	Yes	Yes
<blockquote>	Yes	Yes	Yes
<body>	Yes	Yes	No
<br />	Yes	Yes	Yes
<button>	Yes	Yes	Yes
<caption>	Yes	Yes	Yes
<center>	No	Yes	Yes
<cite>	Yes	Yes	Yes
<code>	Yes	Yes	Yes
<col>	Yes	Yes	Yes
<colgroup>	Yes	Yes	Yes
<dd>	Yes	Yes	Yes
<del>	Yes	Yes	Yes
<dfn>	Yes	Yes	Yes
<dir>	No	Yes	Yes
<div>	Yes	Yes	Yes
<dl>	Yes	Yes	Yes
<dt>	Yes	Yes	Yes
<em>	Yes	Yes	Yes
<fieldset>	Yes	Yes	Yes
<font>	No	Yes	Yes
<form>	Yes	Yes	Yes
<frame>	No	No	Yes
<frameset>	No	No	Yes
<h1> to <h6>	Yes	Yes	Yes
<head>	Yes	Yes	Yes
<hr />	Yes	Yes	Yes
<html>	Yes	Yes	Yes
<i>	Yes	Yes	Yes
<iframe>	No	Yes	Yes
<img />	Yes	Yes	Yes
<input>	Yes	Yes	Yes
<ins>	Yes	Yes	Yes
<kbd>	Yes	Yes	Yes
<label>	Yes	Yes	Yes
<legend>	Yes	Yes	Yes
<li>	Yes	Yes	Yes
<link>	Yes	Yes	Yes
<map>	Yes	Yes	Yes
<menu>	No	Yes	Yes
<meta>	Yes	Yes	Yes
<noframes>	No	No	Yes
<noscript>	Yes	Yes	Yes
<object>	Yes	Yes	Yes
<ol>	Yes	Yes	Yes
<optgroup>	Yes	Yes	Yes
<option>	Yes	Yes	Yes
<p>	Yes	Yes	Yes
<param>	Yes	Yes	Yes
<pre>	Yes	Yes	Yes
<q>	Yes	Yes	Yes
<s>	No	Yes	Yes
<samp>	Yes	Yes	Yes
<script>	Yes	Yes	Yes
<select>	Yes	Yes	Yes
<small>	Yes	Yes	Yes
<span>	Yes	Yes	Yes
<strike>	No	Yes	Yes
<strong>	Yes	Yes	Yes
<style>	Yes	Yes	Yes
<sub>	Yes	Yes	Yes
<sup>	Yes	Yes	Yes
<table>	Yes	Yes	Yes
<tbody>	Yes	Yes	Yes
<td>	Yes	Yes	Yes
<textarea>	Yes	Yes	Yes
<tfoot>	Yes	Yes	Yes
<th>	Yes	Yes	Yes
<thead>	Yes	Yes	Yes
<title>	Yes	Yes	Yes
<tr>	Yes	Yes	Yes
<tt>	Yes	Yes	Yes
<u>	No	Yes	Yes
<ul>	Yes	Yes	Yes
<var>	Yes	Yes	Yes

]]> <![CDATA[针对不可访问 Web 页的文本选择]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2866 breeze 2005/2/16 11:36:37 发布日期： 12/21/2004 | 更新日期： 12/21/2004

Microsoft Corporation

摘要：描述如何使用 XML 和 XSLT 来提供同一 Web 页的多个视图。当一些用户需要不太复杂的或纯文本的 Web 页视图时，或者当其他用户想要更复杂或更高带宽的版本时，这种方法是很有用的。要用一组数据做到这一点，本文中所包含的代码示例展示如何确定要显示的视图、创建 XSLT 参数列表、加载 XML 和相应的 XSLT，以及如何执行转换。

本页内容

	简介
	可选文本技术

简介

不同用户可能需要相同 Web 页的不同版本。有些用户需要不太复杂的或纯文本的 Web 页视图，而其他用户可能需要更复杂或更高带宽的版本，对于这些情况，XML 和 XSLT 能有效提供同一 Web 页的多个视图。

能够适应两类用户需求的传统方法是维护两组包含相同数据的不同页面 — 一组是丰富视图，另一组是纯文本视图。这种方法明显的弊端是，只要公用内容更新，两组页面就都必须更新。

本文中描述的技术提供一组既带有丰富的、复杂的视图（包括 DHTML、图形和复杂的表），又带有纯文本视图（没有 DHTML、图形、表或格式设置）的数据。由于该组数据不是重复的，因此更新站点只需更改一组数据页。这意味着我们可以使用以 XML 编写的一个源，并提供两个不同的、用户可选的 XSLT，以便为用户提供他们所选择的 Web 页视图。

注有残疾的用户将获益于能够访问不带有格式设置和布局的站点的所有数据和功能。对于 Web 站点提供者也有显而易见的好处，其获益程度取决于当前体系结构上的工作负荷、站点内容更新的频率，以及站点的大小。

可选文本技术

Microsoft Enable Web site 使用该技术为用户提供两种版本：

•	带有图形和复杂表的格式化的、高带宽的版本（图 1）
•	线性的、纯文本的版本（图 2）。图 1. 格式化的、图形丰富的视图图 2. 线性的、基于文本的视图

用户可以选择他们想要浏览的版本。选定的版本的上下文在用户在 Web 站点内的整个会话期间或在他们选择更改上下文之前得到维护。

所需视图（目前只有文本或格式化的）是通过 HTTP 查询字符串中的一个值对来指定的。该方法实现为使用户能够对任一视图设置书签，并随后维护该上下文或状态。具体说来，对于这个实现，变量“v”可以有值“t”(text) 或“f”(formatted)。当找不到任何值或输入了一个无效值时，格式化的版本用作默认版本。

下面的代码示例展示如何：

•	确定要显示哪个视图
•	构建 XSLT 参数列表
•	加载 XML 和适当的 XSLT
•	执行转换

当加载一个页面时，我们用示例 1 中提供的代码确定要显示哪个视图。

代码示例 1. 检测显示方法

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >

<script language="C#" runat="server">

void Page_Load(Object sender, EventArgs e) 
{
// get version
version = GetVersion(Request.QueryString["v"]);

// Load the XML document to transform.
   Transform(Server.MapPath("default.xml"),Server.MapPath("/enable/incl
udes/" + version));
}
private string GetVersion(string qs)
{
   if ((qs != "t") && (qs != "f"))
   {
      qs = "f";
   }
   return "enablefilter_ASPX_" + qs + ".xsl";
}

下一步，我们添加其他参数，以便构建版权声明、上次修改的数据以及该页的电子邮件联系数据，如示例 2 中所示。

代码示例 2. 站点信息代码

private void Transform(string sXmlPath, string sXslPath)
{    
   try
   {            
      FileInfo fi = new FileInfo(sXmlPath);
      DateTime modified = fi.LastWriteTime;
      DateTime copyrightYear = DateTime.Now;   
            
      XsltArgumentList args = new XsltArgumentList();         
      
   args.AddParam("dateModified","",modified.ToLongDateString());
      args.AddParam("filePath","",Request.Url);
      args.AddParam("copyrightYear","",copyrightYear.Year);

最后，示例 3 中提供的代码基于显示格式确定执行转换。

代码示例 3. 转换页面显示

//load the Xml doc
      XmlDocument myXmlDoc = new XmlDocument();
      myXmlDoc.Load(sXmlPath);

      //load the Xsl doc
      XslTransform myXslTrans = new XslTransform();
      myXslTrans.Load(sXslPath);

      //do the actual transform of Xml
      myXslTrans.Transform(myXmlDoc,args, Response.OutputStream);
   }
   catch(Exception e)
   {
      string msgError = "Exception: ";
      Response.Write(msgError + e.Message);
   }
}
static string version = "";
</script>

显示结果

本节包括来自一个 XML 源文档的示例、两个执行两个转换的 XSLT，以及两组结果（一个是富内容版本，另一个是纯文本版本）。

代码示例 4. 源 XML

<table border="5" cellpadding="5" cellspacing="5" bordercolor="#ffffff" 
bgcolor="#ff9900" width="75">
   <tr>
      <td width="70">
         <img border="0" src="/enable/images/photos/man.jpg" 
width="70" height="70" alt="Man with laptop"/>
      </td>
   </tr>
   <tr>
      <td width="70">
         <img src="images/photos/hand.jpg" width="70" height="70" 
border="0" alt="Hand on keyboard"/>
      </td>
   </tr>
   <tr>
      <td width="70" align="middle">
         <img src="images/photos/braille_fingers.gif" width="65" 
height="91" valign="absmiddle" alt="Fingers feeling Braille text" 
border="0"/>
      </td>
   </tr>
</table>

如果用户已经选择了格式化的视图，就会应用示例 5 中提供的 XSLT 代码。

代码示例 5. XSLT 格式化代码

<xsl:template match="table | TABLE | Table">
   <table>
      <xsl:copy-of select="@*" />
      <xsl:apply-templates />
   </table>
</xsl:template>
<xsl:template match="tr | TR">
   <tr>
      <xsl:copy-of select="@*" />
      <xsl:apply-templates />
   </tr>
</xsl:template>
<xsl:template match="th | TH">
   <th>
      <xsl:copy-of select="@*" />
      <xsl:apply-templates />
   </th>
</xsl:template>
<xsl:template match="td | TD">
   <td>
      <xsl:copy-of select="@*" />
      <xsl:apply-templates />
   </td>
</xsl:template>
<xsl:template match="img | IMG | Img">
   <img>
      <xsl:copy-of select="@*" />
      <xsl:apply-templates />
   </img>
</xsl:template>

在这种情况下，转换产生示例 6 中提供的 HTML。

代码示例 6. 得到的格式化显示

<table border="5" cellpadding="5" cellspacing="5" bordercolor="#ffffff"
bgcolor="#ff9900" width="75">

<tr><td width="70"><img border="0" src="/enable/images/photos/man.jpg"
width="70" height="70" alt="Man with laptop"></td></tr>

<tr><td width="70"><img src="images/photos/hand.jpg" width="70"
height="70" border="0" alt="Hand on keyboard"></td></tr>

<tr><td width="70" align="middle"><img
src="images/photos/braille_fingers.gif" width="65" height="91" 
valign="absmiddle" alt="Fingers feeling Braille text" 
border="0"></td></tr>
</table>

另一方面，如果用户已经选择了页面的纯文本视图，就会应用该 XSLT 代码，如示例 7 中所示。

代码示例 7. XSLT 纯文本代码

<xsl:template match="table | TABLE | Table">
   <div>
      <xsl:apply-templates />
   </div>
</xsl:template>
<xsl:template match="tr | TR">
   <div>
      <xsl:apply-templates />
   </div>
</xsl:template>
<xsl:template match="th | TH">
   <div>
      <xsl:apply-templates />
   </div>
</xsl:template>
<xsl:template match="td | TD">
   <div>
      <xsl:apply-templates />
   </div>
</xsl:template>
<xsl:template match="img | IMG | Img">
   <xsl:if test="not(ancestor::banner) and not(ancestor::BANNER) and 
not(ancestor::Banner)">
      <xsl:for-each select="@*">
         <xsl:if test="((name()='alt') or (name()='ALT') or 
(name()='Alt')) and (normalize-space(.)!='')">
            [image: <xsl:value-of select="." />]
         </xsl:if>
      </xsl:for-each>            
      <xsl:apply-templates />
   </xsl:if>
</xsl:template>

示例 8 产生一个简单得多的数据视图。

代码示例 8. 得到的纯文本显示

<div>
   <div>
      <div>
         [image: Man with laptop]
      </div>
   </div>
   <div>
      <div>
         [image: Hand on keyboard]
      </div>
   </div>
   <div>
      <div>
         [image: Fingers feeling Braille text]
      </div>
   </div>

正如您能看到的，表已由 DIV 替换，图像和格式设置已移除，而且每个图像的 ALT 属性替换了该图像。

上面所描述的技术提供了一组既带有丰富视图又带有纯文本视图的数据。由于数据不是重复的，因此更新站点只需更新一组数据页面。

转到原英文页面

]]> <![CDATA[PHP Google PageRank Retriever]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2849 breeze 2005/2/15 10:32:08 from GoogleCommunity.com
pagerank-source.php:

PHP:



<?php 
// PHP Google PageRank Calculator Script 
// ------------------------- August 2004 
// Contact author: pagerankscript@googlecommunity.com 

// for updates, visit: 
// http://www.googlecommunity.com/scripts/google-pagerank.php 

// provided by www.GoogleCommunity.com 
//  an unofficial community of Google fans 
// --------------------------------------- 

// Instructions 
//  Upload pagerank.php to your server 
//  Call it like this: http://www.example.com/pagerank.php?url=http://www.yahoo.com/ 
//   example.com is your website. yahoo.com is the website to get the PR of 
//  The code below displays the PR for $url 

/* 
    This code is released unto the public domain 
*/ 
//header("Content-Type: text/plain; charset=utf-8"); 
define('GOOGLE_MAGIC', 0xE6359A60); 
  
//unsigned shift right 
function zeroFill($a, $b) 
{ 
    $z = hexdec(80000000); 
        if ($z & $a) 
        { 
            $a = ($a>>1); 
            $a &= (~$z); 
            $a |= 0x40000000; 
            $a = ($a>>($b-1)); 
        } 
        else 
        { 
            $a = ($a>>$b); 
        } 
        return $a; 
} 
  
  
function mix($a,$b,$c) { 
  $a -= $b; $a -= $c; $a ^= (zeroFill($c,13)); 
  $b -= $c; $b -= $a; $b ^= ($a<<8); 
  $c -= $a; $c -= $b; $c ^= (zeroFill($b,13)); 
  $a -= $b; $a -= $c; $a ^= (zeroFill($c,12)); 
  $b -= $c; $b -= $a; $b ^= ($a<<16); 
  $c -= $a; $c -= $b; $c ^= (zeroFill($b,5)); 
  $a -= $b; $a -= $c; $a ^= (zeroFill($c,3));    
  $b -= $c; $b -= $a; $b ^= ($a<<10); 
  $c -= $a; $c -= $b; $c ^= (zeroFill($b,15)); 
    
  return array($a,$b,$c); 
} 
  
function GoogleCH($url, $length=null, $init=GOOGLE_MAGIC) { 
    if(is_null($length)) { 
        $length = sizeof($url); 
    } 
    $a = $b = 0x9E3779B9; 
    $c = $init; 
    $k = 0; 
    $len = $length; 
    while($len >= 12) { 
        $a += ($url[$k+0] +($url[$k+1]<<8) +($url[$k+2]<<16) +($url[$k+3]<<24)); 
        $b += ($url[$k+4] +($url[$k+5]<<8) +($url[$k+6]<<16) +($url[$k+7]<<24)); 
        $c += ($url[$k+8] +($url[$k+9]<<8) +($url[$k+10]<<16)+($url[$k+11]<<24)); 
        $mix = mix($a,$b,$c); 
        $a = $mix[0]; $b = $mix[1]; $c = $mix[2]; 
        $k += 12; 
        $len -= 12; 
    } 
  
    $c += $length; 
    switch($len)              /* all the case statements fall through */ 
    { 
        case 11: $c+=($url[$k+10]<<24); 
        case 10: $c+=($url[$k+9]<<16); 
        case 9 : $c+=($url[$k+8]<<8); 
          /* the first byte of c is reserved for the length */ 
        case 8 : $b+=($url[$k+7]<<24); 
        case 7 : $b+=($url[$k+6]<<16); 
        case 6 : $b+=($url[$k+5]<<8); 
        case 5 : $b+=($url[$k+4]); 
        case 4 : $a+=($url[$k+3]<<24); 
        case 3 : $a+=($url[$k+2]<<16); 
        case 2 : $a+=($url[$k+1]<<8); 
        case 1 : $a+=($url[$k+0]); 
         /* case 0: nothing left to add */ 
    } 
    $mix = mix($a,$b,$c); 
    /*-------------------------------------------- report the result */ 
    return $mix[2]; 
} 
  
//converts a string into an array of integers containing the numeric value of the char 
function strord($string) { 
    for($i=0;$i<strlen($string);$i++) { 
        $result[$i] = ord($string{$i}); 
    } 
    return $result; 
} 
  
function getrank($url) { 
    $url = 'info:'.$url; 
    $ch = GoogleCH(strord($url)); 
    $file = "http://www.google.com/search?client=navclient-auto&ch=6$ch&features=Rank&q=$url"; 
    $data = file($file); 
    $rankarray = explode (':', $data[2]); 
    $rank = $rankarray[2]; 
    return $rank; 
} 
  
echo 'PageRank: '.getrank($url).'<br /><small>provided by <a href="http://www.googlecommunity.com/" target="_blank">Google Community.com</a></small>'; 
  
?>

]]> <![CDATA[The Google Pagerank Checksum Calculator]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2848 breeze 2005/2/15 10:22:05 DEMO:
http://alex.vort-x.net/google/
Source:

PHP:



<?php 
/* 
    This code is released unto the public domain 
*/ 
header("Content-Type: text/plain; charset=utf-8"); 
define('GOOGLE_MAGIC', 0xE6359A60); 
  
//unsigned shift right 
function zeroFill($a, $b) 
{ 
    $z = hexdec(80000000); 
        if ($z & $a) 
        { 
            $a = ($a>>1); 
            $a &= (~$z); 
            $a |= 0x40000000; 
            $a = ($a>>($b-1)); 
        } 
        else 
        { 
            $a = ($a>>$b); 
        } 
        return $a; 
}  
  
  
function mix($a,$b,$c) { 
  $a -= $b; $a -= $c; $a ^= (zeroFill($c,13));  
  $b -= $c; $b -= $a; $b ^= ($a<<8);  
  $c -= $a; $c -= $b; $c ^= (zeroFill($b,13)); 
  $a -= $b; $a -= $c; $a ^= (zeroFill($c,12)); 
  $b -= $c; $b -= $a; $b ^= ($a<<16); 
  $c -= $a; $c -= $b; $c ^= (zeroFill($b,5));  
  $a -= $b; $a -= $c; $a ^= (zeroFill($c,3));   
  $b -= $c; $b -= $a; $b ^= ($a<<10);  
  $c -= $a; $c -= $b; $c ^= (zeroFill($b,15)); 
   
  return array($a,$b,$c); 
} 
  
function GoogleCH($url, $length=null, $init=GOOGLE_MAGIC) { 
    if(is_null($length)) { 
        $length = sizeof($url); 
    } 
    $a = $b = 0x9E3779B9; 
    $c = $init; 
    $k = 0; 
    $len = $length; 
    while($len >= 12) { 
        $a += ($url[$k+0] +($url[$k+1]<<8) +($url[$k+2]<<16) +($url[$k+3]<<24)); 
        $b += ($url[$k+4] +($url[$k+5]<<8) +($url[$k+6]<<16) +($url[$k+7]<<24)); 
        $c += ($url[$k+8] +($url[$k+9]<<8) +($url[$k+10]<<16)+($url[$k+11]<<24)); 
        $mix = mix($a,$b,$c); 
        $a = $mix[0]; $b = $mix[1]; $c = $mix[2]; 
        $k += 12;  
        $len -= 12; 
    } 
  
    $c += $length; 
    switch($len)              /* all the case statements fall through */ 
    { 
        case 11: $c+=($url[$k+10]<<24); 
        case 10: $c+=($url[$k+9]<<16); 
        case 9 : $c+=($url[$k+8]<<8); 
          /* the first byte of c is reserved for the length */ 
        case 8 : $b+=($url[$k+7]<<24); 
        case 7 : $b+=($url[$k+6]<<16); 
        case 6 : $b+=($url[$k+5]<<8); 
        case 5 : $b+=($url[$k+4]); 
        case 4 : $a+=($url[$k+3]<<24); 
        case 3 : $a+=($url[$k+2]<<16); 
        case 2 : $a+=($url[$k+1]<<8); 
        case 1 : $a+=($url[$k+0]); 
         /* case 0: nothing left to add */ 
    } 
    $mix = mix($a,$b,$c); 
    /*-------------------------------------------- report the result */ 
    return $mix[2]; 
} 
  
//converts a string into an array of integers containing the numeric value of the char 
function strord($string) { 
    for($i=0;$i<strlen($string);$i++) { 
        $result[$i] = ord($string{$i}); 
    } 
    return $result; 
} 
// http://www.example.com/ - Checksum: 6540747202 
$url = 'info:'.$_GET['url']; 
$ch = GoogleCH(strord($url)); 
$url='info:'.urlencode($_GET['url']); 
$curl = curl_init("http://www.google.com/search?client=navclient-auto&ch=6$ch&ie=UTF-8&oe=UTF-8&features=Rank&q=$url"); 
curl_setopt ($curl, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; GoogleToolbar 2.0.110-big; Windows 2000 5.0)"); 
curl_exec($curl); 
?>

Format:
http://www.google.com/search?client=navclient-auto&ch=63860912239&features=Rank&q=info:http://bbs.z4.cn

Related link:
http://www.mobileread.com/forums/sh...p?threadid=1670
short :http://alex.vort-x.net/google/googlehash-source.php
readable :http://alex.vort-x.net/google/googl...able-source.php
http://forums.seochat.com/t12316/s.html
http://www.top25web.com/pagerank.php
http://www.abakus-internet-marketin...rts/seotest.htm
http://www.zenitram.th4y.com/pagerank/?url=bbs.z4.cn
http://cgi.ebay.com/ws/eBayISAPI.dl...ssPageName=WDVW
also:
http://pagerank-checksum.homelinux.com/

http://www.zenitram.th4y.com/pagerank/?url=bbs.z4.cn]]> <![CDATA[XHTML的模块化]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2782 breeze 2005/2/6 16:39:02

简介
1. 本教程适合我吗？
2. 本教程的内容
3. 工具
4. 本教程中使用的约定
5. 关于作者

模块化概述
1. 为什么要模块化？
2. 目标设备
3. 模块化体系结构

一致性
1. 一致性及其原因
2. XHTML 主机语言
3. XHTML 集成集合
4. 做选择

摘要模块
1. 该模块的用途
2. 设计目的
3. 源数据
4. 约定
5. 组和最小内容模型
6. 摘要模块

Qname 模块
1. 该模块的用途
2. 创建文件
3. DTD 条件节
4. 名称空间处理
5. 元素和属性
6. Qname 模块（代码）
7. Qnames 集合

声明模块
1. 该模块的用途
2. 声明元素和属性
3. 添加名称空间属性
4. 声明模块（代码）

内容模型模块
1. 该模块的用途
2. 定义结构
3. 内容模型模块（代码）

DTD 驱动程序
1. 该模块的用途
2. 链接到 XHTML
3. XHTML 框架
4. 包括新模块
5. DTD 驱动程序（代码）

构建 MemoryML 文档
1. 基本文档
2. 为新元素添加前缀
3. 为所有元素添加前缀

XHTML 模块化结束语
1. 结束语
2. 参考资料

------------------------------------------------------------------------

简介

本教程适合我吗？

本教程是为需要了解 XHTML 的模块化的用户设计的，帮助他们使用 XHTML 的子集或添加他们自己的标记来创建他们自己的标记语言变体。

您应该已经十分了解 XML，并且至少对 XHTML 及其使用有基本了解。您还应该了解 XML 验证并熟悉“文档类型定义（Document Type Definition (DTD)）”和名称空间。参考资料页提供了至一些教程的链接，这些教程可帮助您迅速掌握所有这些方面的知识。

您不需要有任何编程技巧就可理解本教程。

本教程的内容

本教程演示了“内存标记语言（Memory Markup Language）”（或 MemoryML）的创建，它被设计成通过嵌入在一个设备（如摄像机、录像机或 DVD 播放器）中虚构的浏览器来查看。

XHTML 的模块化允许开发人员选择要在一个应用程序中支持哪些 XHTML 模块。开发人员可以对那些模块进行补充，使创建与 XHTML 无缝结合的新标记语言成为可能。

工具

本教程演示了 XHTML 模块的构建。要实际构建这些模块，只需要一个文本编辑器。

要更进一步测试新模块，需要一个验证解析器，如 XML 处理的 Java API（Java API for XML Processing(JAXP)）或 Xerces。参考资料页列出了几种验证解析器。

本教程中使用的约定

本教程使用几个约定，使手边的资料更便于阅读：

monospace 字体用于文件和路径名。
用 bold monospace 字体显示需要输入的文本。在一些代码示例中，使用粗体来提醒您注意在附带的文本中正在引用的标记或元素。
着重／斜体提醒您注意窗口、对话框和特性名。
本教程中，省略与讨论无关的代码段并用省略号（...）替代。

关于作者

Nicholas Chase 一直参与多家公司的网站开发工作，包括 Lucent Technologies、Sun Microsystems、Oracle Corporation 和 Tampa Bay Buccaneers。Nick 曾是一名高中物理教师、低水平放射性废物设施经理、在线科幻小说杂志编辑、多媒体工程师和 Oracle 讲师。最近，他是佛罗里达州 Clearwater 的 Site Dynamics Interactive Communications 的首席技术官。他还是包括 Java and XML From Scratch（Que）在内的有关 Web 开发的三本书的作者。他乐于倾听读者的意见，可以通过 nicholas@nicholaschase.com 与他联系。

模块化概述

为什么要模块化？

HTML 的第一个正式版本，HTML 2.0，只有不到 50 个标记在其中。经过几年的发展，标记数已翻了几倍，以至于甚至在最流行且最受支持的浏览器中完全支持所有这些标记也是十分困难的。何况小型移动电话或 PDA 呢？

当独立设备开始连接到 Web 时，开发人员面临进退两难的局面。如果他们不能支持所有这些标记，那么他们应该如何决定要支持哪些标记呢？内容供应商将如何知道哪些标记是受支持的呢？

本教程通过将该语言分割成可以以标准方式混合并匹配的标准模块来解决这一问题。例如，XHTML Basic 是为如移动电话、寻呼机和 PDA 等设备设计的特定子集。想要创建 XHTML Basic 内容的开发人员应该清楚地知道哪些标记是受支持的。同样，如果一个设备支持特定的 XHTML 模块，则开发人员可以将内容针对它们。

然而，模块化的用途还远远不止这些。它还允许以标准化方式添加特定标记，这样便有可能创建新的派生标记语言，以为特定目的提供服务。

目标设备

本教程记录了新标记语言的创建，它跟踪记录在录像带、DVD 和其它介质上的数据。该语言可以由制作、存储并重放这些记录的设备使用。

这些设备，其内存和处理能力可能非常小，可能有一个内置浏览器用于显示信息，如已经出现在类似设备上的菜单（象 VCR 上的设置菜单）。这些菜单可以方便地用 XHTML Basic 显示出来。然而，如果信息作为更具描述性的 XML 的一部分显示，则它还可以用来控制该设备。

考虑一下作为摄像机、VCR 和 DVD 之间的控制器的设备。控制器可能会遇到如下所示的一小段 XML 代码：


<video tapeid="A323">
   <media mediaid="A323" type="VHS"/>
   <start>0:00:00</start>
   <end>32:12:45</end>
   <subdate>2001-05-23</subdate>
   <donor>John Baker</donor>
   <subject>Pitching a tent</subject>
   <location><description>Outside in the woods</description></location>
</video>

控制器可能会将该主题作为菜单的一部分显示。另外，如果用户选择了这一片段，那么控制器还将完全知道向 VHS 机器发信号以插入编号为 A323 的录像带，从起始处开始并播放 32 分钟 12 秒。

将这些标记合并到与 XHTML 集成的新标记语言可允许内容供应者根据一个标准编辑内容。

模块化体系结构

创建一个新的标记语言实际上涉及到几个以一种特定方式组合起来的相关模块。

摘要模块：实际上任何应用程序都不读取这个可选文件，而是提供一种半形式化的、可供人们阅读的描述，包括任何元素分组的文字描述。
Qname 模块：Qname 模块，或限定名模块，定义一系列表示实际元素名的参数实体。可在其它模块中引用这些实体。
声明模块：该模块为元素及其属性提供实际声明。
内容模型模块：该模块为整个模块和现在将要有“新”元素作为子元素的XHTML 元素定义内容模型，而不是为新元素定义。
Qnames 集合：该文件将 Qname 模块链接在一起。
DTD 驱动程序：这是在验证 XML 文件时实际引用的文件。它包含对其它模块的引用，以便它们都可用于验证。

一致性

一致性及其原因

如果没有标准方式支持功能的标准集合，那么它们对于要支持的应用程序没有任何好处。例如，假设浏览器通过将标记显示为其余内容中的小文本而不是它自己的一大块文本来“支持”它。即使假设它们是受支持的，Web 作者也不会知道如何使用这些功能。

一致性同时为应用程序和语言的类型定义了特定需求的集合。例如，声称是 XHTML 用户代理（如浏览器）的应用程序必须，除其它事情之外，以某种方式处理文档中的空白并且忽略未知标记同时继续处理其内容。

在定义 XHTML 语言中，有两组不同的一致性需求：XHTML 主机语言和 XHTML 集成集合。

XHTML 主机语言

XHTML 主机语言是基于 XHTML 的新标记语言，它遵循与传统 XHTML 页面相同的结构规则。例如，它必须将 <html> 作为其根元素。XHTML 主机语言一致性要求：

W3C 认可的实现中的定义：目前，这意味着必须通过 DTD 定义模块，但模块化的 W3C XML Schema 版本目前正在完成中，其它实现也是有可能的。
在 DTD 的 PUBLIC 标识符的公共文本描述的开始处使用“XHTML”：例如，-//COMPANY NAME//ELEMENTS XHTML Memory Language 1.0//EN。
包含 XHTML 结构、超文本、文本和列表模块：还可以包括其它模块，但任何使用的模块都必须包括在其整体中。一个新的 DTD 可以通过添加新属性或内容来扩展元素。然而，XHTML 中所需的任何属性或最小的内容模型都是新语言所需的，不能除去它们。
使用单独的 XML 名称空间：这是添加到语言的任何附加元素或属性所需的。

语言不必始终符合所有这些需求。

XHTML 集成集合

并非所有标记语言必须是 XHTML 主机语言。在某些情况下，语言只需要描述内容，但决不是一定要独立使用 — 否则它最终可能会使用不同于 XHTML 页面的结构。这些语言只需要符合 XHTML 集成集合。

XHTML 集成集合一致性与 XHTML 主机语言一致性是基本相同的，除了以下两个例外：

当 XHTML 必须出现在 DTD 的 PUBLIC 标识符的公共文本节中时，它必须不是第一个。例如：-//COMPANY NAME//ELEMENTS Memory Information XHTML 1.0//EN。
XHTML 结构模块不是必需的。然而，超文本、文本和列表模块仍是必需的。

做选择

在决定是构建 XHTML 主机语言还是构建 XHTML 集成集合语言时，主要因素应该是将如何使用新的标记语言。例如，XHTML 主机语言可以独立使用，而 XHTML 集成集合语言通常与主机语言结合使用。

将主机语言用作扩展的基础可能也很方便，因为集成集合语言可能容易缺少在任何环境中独立使用所需的结构，更不用说基于 XHTML 的了。

在本教程中为内存标记语言选择路径时，请考虑将如何使用它。将读取它的设备（如控制器）没有 XHTML 的其它知识，所以它们需要构建在语言中的某种结构。

当然，并没有规定它的结构必须与 XHTML 的结构相同。该语言可以方便地使用

另一方面，假设控制器是可用于 Web 的，并允许在 Web 上从浏览器访问它，那怎么办呢？在这种情况下，当然是使用 XHTML 主机语言更好，因为在浏览器中“页面”至少是可理解的。（并且通过添加样式表来控制新元素的显示，它看上去可能会更好。）

本教程演示了将内存标记语言构建成为 XHTML 主机语言。

摘要模块

该模块的用途

标记语言的定义涉及了几个模块（也称为子模块）的创建，大多数模块由解析器处理以验证文档。摘要模块是这一规则的例外。

摘要模块为读者理解语言结构提供必需的信息，而不必通过多个文档提供。它列出了可能的元素、它们可能携带的属性以及可能存在的任何逻辑分组。

摘要模块使读者清晰地了解语言的总体结构。

设计目的

在创建内存标记语言中，请考虑下列目的：

MemoryML 应该：

对记录内容的描述进行编码
支持同时通过专用和非专用的浏览器应用程序来浏览
是人类可阅读的
支持通过非浏览器应用程序（如软件）的处理来控制设备

开始确定结构的一个方法是创建样本数据。

源数据

语言的实际设计是可能包括十分专门化技巧的研究领域，而一点常识和深谋远虑对确定语言基础大有帮助。

MemoryML 实际上基于“千年内存项目（Millennium Memory Project）”的数据，它收集从新千年开始的每天生活的记录。每个清单都包括有关记录所包含的内容以及可在何处找到它的信息。例如：


<?xml version="1.0"?>
<memories>
   <video tapeid="A323">
      <media mediaid="A323" type="VHS"/>
      <start>0:00:00</start>
      <end>32:12:45</end>
      <subdate>2001-05-23</subdate>
      <donor>John Baker</donor>
      <subject>Pitching a tent</subject>
      <location><description>Outside in the woods</description></location>
   </audio>
   <memory tapeid="C531">
      <media mediaid="C531" type="DVD"/>
      <start>12:09:23</start>
      <end>58:34:51</end>
      <subdate>2001-05-18</subdate>
      <donor>Elizabeth Davison</donor>
      <subject>Baseball Game</subject>
   </memory>
</memories>

（在生产环境中，实际需要多得多的信息。为了简单起见，本教程使用这种结构。）

该样本数据只显示将添加到新语言的扩展。请记住，还包括了结构、超文本、文本和列表模块。

描述这些关系不需要特定格式，但存在某些约定。

约定

虽然摘要模块的格式化没有正式要求，但有时使用了某些约定，那些阅读文档的人也期望使用一些约定。许多都与 DTD 本身使用的约定和修饰语相似或相同。

例如，?、+ 和 * 在 DTD 中有特殊含义— 分别特别地表示 0 个或 1 个实例、1 个或多个实例以及 0 个或多个实例。在摘要模块中也遵循这些约定。类似地，要求用逗号列出的元素名以特定次序排列，用| 符号隔开的那些元素名是另一个选项。使用圆括号的分组也以它在 DTD 中相同的方式起作用。

然而，在摘要模块中使用的一些约定未包括在 DTD 中。例如，要表示正在扩展一个元素以包括新属性（与从头开始创建的相反），名称的后面跟一个 &，如 title& 中。

属性可能也有特殊需求。必需的属性应该后跟一个星号，如 tapeid* 中。也可以指定可允许的值，并用一个星号指定缺省值，如下所示：

type("VHS" | "DAT" | "DTD" | "DVD" | "8mm"*)

与特定值对比，属性可能需要特殊数据类型，如 tapeid(CDATA) 中，或固定值，如 license(="free") 中。

除了这些约定外，还可以添加文字节来描述最小内容模型。

组和最小内容模型

在许多情况下，将元素或属性分组在一起，以便更容易地表示许多不同的属性或元素在特殊位置中是适当的。例如，即使列出每个 XHTML 元素可用的核心属性也是极其不便的；而只查看对 Common 的引用是很常见的。

同样，为了方便起见，可以将元素分组到表示特殊最小内容模型的表达式中。例如：

Heading
h1 | h2 | h3 | h4 | h5 | h6

通过这种方式，只引用 Heading 表达式要比单独列出元素方便。同样的事情可适用于定制标记。考虑一下 MemoryML 示例。为记录创建一组描述符可能很方便：

VideoInfo
media | start | end | subdate | donor | subject | location

这创造了第二个优势。现在可以说 video 元素将 VideoInfo 内容模型作为其子元素，还可以方便地描述 audio 元素的子元素，它们由所有的video 子元素（除了 location）组成。摘要模块可以使用以下命令来表示这种关系：

VideoInfo - location

将这些约定与上一页中的那些约定组合起来可提供用于创建摘要模块的工具。

摘要模块

将这些技术合并到 MemoryML 的单一摘要模块中可以为内存扩展模块创建一个可理解的描述。

元素        属性                      最小内容模型
memories                                      (audio | video)*
video          tapeid(IDREF)                  VideoInfo
audio          tapeid(IDREF)                  VideoInfo - location
start                                         PCDATA
end                                           PCDATA
subdate                                       PCDATA
donor                                         PCDATA
subject                                       PCDATA
location                                      place | description
description                                   PCDATA
place                                         PCDATA
media          mediaid(ID),                   EMPTY
               type("VHS" | "DAT" | "DTD"
                         | "DVD" | "8mm"*)
该模块还定义了最小内容模型 VideoInfo：
media、media、start、end、subdate、donor、subject、location

现在，设置好了结构，该开始创建实际的 DTD 模块了。

Qname模块

该模块的用途

Qname 或限定名，是还包括任何可应用的名称空间别名的元素或属性的名称。例如，对于元素

<mem:subject>Baseball game</mem:subject>

该元素的限定名是 mem:subject，其中 mem 是名称空间别名。

然而，不是总显示别名或前缀。在某些情况下，可能完全禁用添加前缀，或可能仅对 XHTML 的扩展启用。

通过用参数表示定义，XHTML 的模块化使这成为可能。换言之，不是将元素的名称定义为 subject 或 mem:subject，而是模块将参数实体定义为：

<!ENTITY % Memory.subject.qname "%Memory.pfx;subject" >

因此，如果索引是打开的，则 %Memory.pfx; 的值将是 mem:，并使 %Memory.pfx;subject 的值等于 mem:subject。如果索引是关闭的，则 %Memory.pfx; 的值将是空的，并使 %Memory.pfx;subject 的值只保留为 subject。

Qname 模块为所有元素名称提供了可修改的定义。

创建文件

与创建新标记语言有关的每个模块（和因此包含它的文件），除了有实际定义外，还应该有使之易于使用的文档。该信息可能包括有关该文件的“正式”版本所在位置的信息，或应该用来引用它的 PUBLIC 标识符。

既然开发人员熟悉这个布局，就让我们把 W3C 中的一个样本文件作为起点。下面的示例显示了 Qname 模块文件的开始部分：

<!-- ...................................................................... -->
<!-- MemoryML Qname module ................................................ -->
<!-- file: memory-qname-1.mod
     PUBLIC "-//MY COMPANY//ELEMENTS XHTML MemoryML Qnames 1.0//EN"
     SYSTEM "http://www.my.org/DTDs/memory-qname-1.mod"
     xmlns:memory="http://www.my.org/namespaces/MemoryML"
     ...................................................................... -->

请注意所有信息都包括在注释中。它仅供那些可能要查找它以获得实现帮助的开发人员使用。

实际名称不重要，但开发人员期望某些约定。例如，Qname 模块通常命名为 MODULENAME-qname-1.mod，而定义模块本身将是 MODULENAME-1.mod。

PUBLIC 标识符必须遵循XHTML 主机语言中提到的一致性规则，但 SYSTEM 信息则由您自己决定。要知道，Qname 文件应该始终可用于 URI，这些 URI 是作为不识别PUBLIC 标识符的那些应用程序的 SYSTEM 标识符列出的。

为了符合 XHTML 主机语言需求，所有附加元素都必须包含在它们自己的名称空间中。这是在上面的示例中提到的名称空间，所以它在所有文件中必须是一致的。

是否将名称空间信息视作每个元素的前缀由 DTD 的条件节（conditional sections）确定。

DTD 条件节

虽然 DTD 不是实际编程的平台，但可以包括或忽略节，以有效地更改文档类型的定义。例如：

<![IGNORE[
    <!ELEMENT memory (video)*>
]]>
<![INCLUDE[
    <!ELEMENT memory (video | audio)*>
]]>

在这个示例中，memory 元素可以包括 video 或audio，因为包括了该节，而忽略了前一节。交换下列值

<![INCLUDE[
    <!ELEMENT memory (video)*>
]]>
<![IGNORE[
    <!ELEMENT memory (video | audio)*>
]]>

产生只可包含 video 的 memory 元素。

还可包括或排除实体定义，但有一个附加复杂因素：实体的第一个定义是在任何给定情况中使用的那个定义。因此，示例

<![INCLUDE[
    <!ENTITY % prefixed "TRUE" >
]]>
<!ENTITY % prefixed "FALSE" >

导致 %prefixed 的值为 TRUE，因为该定义先包括在文档中。

另一方面，如果处理的另一个 DTD 首先为 %prefixed 提供了一个值，那么不管在这里指定了什么，都将使用该值。也可能在 DTD 的内部子集中提供该值，以作为实际文档的一部分。

当值的这种传播打开和关闭添加前缀，并涉及到其它名称空间处理问题时，理解它是至关紧要的。

名称空间处理

使用 MemoryML 创建文档的开发人员应该能够打开和关闭添加前缀，但不应该被要求那么做。所以，Qname 模块需要定义一个参数实体，如果需要这个参数实体的话，它可以被设置，但如果不需要的话，则已经有一个值。

<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % Memory.prefixed "%NS.prefixed;" >

这种方式参数是可用的，但如果没有显式地设置它，那么它采用值 %NS.prefixed，它是在 XHTML 框架内实际定义的。开发人员可以选择将 %NS.prefixed 设置为INCLUDE，以有效地打开所有添加前缀，或者可以将%Memory.prefixed 设置为 INCLUDE，仅为内存模块打开添加前缀。如果两个都没有设置，则都保持 IGNORE。

下一步，定义实际名称空间和前缀：

<!ENTITY % Memory.xmlns "http://www.my.org/namespaces/MemoryML" >
<!ENTITY % Memory.prefix "memory" >

一旦确定了这些值，就为实际文档创建名称空间声明：

<![%Memory.prefixed;[
<!ENTITY % Memory.pfx "%Memory.prefix;:" >
<!ENTITY % Memory.xmlns.extra.attrib
    "xmlns:%Memory.prefix;   %URI.datatype;  #FIXED  '%Memory.xmlns;'" >
]]>
<!ENTITY % Memory.pfx "" >
<!ENTITY % Memory.xmlns.extra.attrib "" >

这种方式，如果打开 %Memory.prefixed;，则%Memory.xmlns.extra.attrib 的值变成：

xmlns:memory %URI.datatype; #FIXED 'http://www.my.org/namespaces/MemoryML'

（%URL.datatype 是在 XHTML 框架中定义的。）

当然，如果无法将其返回到实际文档，则创建这个值无任何意义。幸运的是，XHTML 框架定义了将信息传播回文档的参数实体：

<!ENTITY % XHTML.xmlns.extra.attrib "%Memory.xmlns.extra.attrib;" >

一旦完成了名称空间处理，就准备好可以添加实际元素了。

元素和属性

前几页的所有技巧旨在允许方便地创建（或排除）元素的名称空间前缀。象添加前缀信息一样，这些元素在 Qname 模块中用参数表示。例如：

<!ENTITY % Memory.subject.qname "%Memory.pfx;subject" >

其余的模块构建过程将该元素称为 %Memory.subject.qname。因此，无论添加前缀是开（使它成为 memory:subject）还是关（使它成为 subject），它都将是正确的。

实际模块名，本例中为 Memory，用在该模块的所有参数实体的开始，这样不仅将它们与 XHTML 实体区分，还将它们与稍后可能添加的附加扩展区分开来。

集中在一起完成 Qname 模块。

Qname 模块（代码）

<!-- ...................................................................... -->
<!-- MemoryML Qname module ................................................ -->
<!-- file: memory-qname-1.mod
     PUBLIC "-//MY COMPANY//ELEMENTS XHTML MemoryML Qnames 1.0//EN"
     SYSTEM "http://www.my.org/DTDs/memory-qname-1.mod"
     xmlns:memory="http://www.my.org/namespaces/MemoryML"
     ...................................................................... -->
<!-- Declare the default value for prefixing of this module's elements -->
<!-- Note that the NS.prefixed will get overridden by the XHTML Framework or
     by a document instance. -->
<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % Memory.prefixed "%NS.prefixed;" >
<!-- Declare the actual namespace of this module -->
<!ENTITY % Memory.xmlns "http://www.my.org/namespaces/MemoryML" >
<!-- Declare the default prefix for this module -->
<!ENTITY % Memory.prefix "memory" >
<!-- Declare the prefix and any prefixed namespaces that are required by 
     this module -->
<![%Memory.prefixed;[
<!ENTITY % Memory.pfx "%Memory.prefix;:" >
<!ENTITY % Memory.xmlns.extra.attrib
    "xmlns:%Memory.prefix;   %URI.datatype;  #FIXED  '%Memory.xmlns;'" >
]]>
<!ENTITY % Memory.pfx "" >
<!ENTITY % Memory.xmlns.extra.attrib "" >
<!ENTITY % XHTML.xmlns.extra.attrib "%Memory.xmlns.extra.attrib;" >
<!ENTITY % Memory.memories.qname "%Memory.pfx;memories" >
<!ENTITY % Memory.video.qname "%Memory.pfx;video" >
<!ENTITY % Memory.audio.qname "%Memory.pfx;audio" >
<!ENTITY % Memory.start.qname "%Memory.pfx;start" >
<!ENTITY % Memory.end.qname "%Memory.pfx;end" >
<!ENTITY % Memory.subdate.qname "%Memory.pfx;subdate" >
<!ENTITY % Memory.donor.qname "%Memory.pfx;donor" >
<!ENTITY % Memory.subject.qname "%Memory.pfx;subject" >
<!ENTITY % Memory.location.qname "%Memory.pfx;location" >
<!ENTITY % Memory.description.qname "%Memory.pfx;description" >
<!ENTITY % Memory.place.qname "%Memory.pfx;place" >
<!ENTITY % Memory.media.qname "%Memory.pfx;media" >

当仅有一个模块时，该文件会照管所有限定名。但如果有多个模块呢？

Qnames 集合

可以绑在一起的文件的数目没有限制，但添加多个模块会引入一种另外的复杂情况。Qnames 模块包含定义：

<!ENTITY % XHTML.xmlns.extra.attrib "%Memory.xmlns.extra.attrib;" >

最终文档使用 %XHTML.xmlns.extra.attrib 来为外部模块添加任何额外的名称空间。困难在于，如果定义了多个模块，则每个模块重新定义 %XHTML.xmlns.extra.attrib，以便只包括它的信息。

要解决该问题，可以创建一个 Qnames 集合模块。该文件只是将所有名称空间信息合并到一个单一实体中。例如，如果有一个称为 MemoryExtensions 的附加模块，则 Qnames 集合模块将包含：

<!-- ...................................................................... -->
<!-- MemoryML/MemoryExtensions Qname Collection Module .................... -->
<!-- file: memory-qnames.mod  ............................................. -->
<!-- Bring in both sets of Qnames in order to access their entities -->
<!ENTITY % Memory-qname.mod
              PUBLIC "-//MY COMPANY//ELEMENTS XHTML MemoryML Qname Collection 1.0//EN"
              SYSTEM "http://www.my.org/DTDs/memory-qnames.mod" >
%Memory-qname.mod;
<!ENTITY % MemoryExtension-qname.mod
        SYSTEM "memoryextension-qname-1.mod" >
%MemoryExtension-qname.mod;
<!-- Add both as an extension to XHTML -->
<!ENTITY % XHTML.xmlns.extra.attrib
         "%Memory.xmlns.extra.attrib;
          %MemoryExtension.xmlns.extra.attrib;" >

可以将任何数目的名称空间添加到整个语言中，只要它们以这种方式绑在一起。

本教程只处理内存模块，因此 Qname 集合包含：

<!-- ...................................................................... -->
<!-- MemoryML Qname Collection Module ..................................... -->
<!-- file: xhtml-memory-qname-1.mod  ...................................... -->
<!-- Bring in the MemoryML qualified names -->
<!ENTITY % Memory-qname.mod
         PUBLIC "-//MY COMPANY//ENTITIES XHTML MemoryML Qnames 1.0//EN"
         "memory-qname-1.mod" >
%Memory-qname.mod;
<!-- Define the xmlns extension attributes -->
<!ENTITY % XHTML.xmlns.extra.attrib
         "%Memory.xmlns.extra.attrib;" >

现在您已经得到了它们的名称，该定义实际元素了。

声明模块

该模块的用途

既然已经声明了所有元素名，该声明元素本身了。

声明元素就象创建 DTD 一样，除了不使用元素名称的直接引用外，结构引用了参数化名称。以这种方式，声明模块定义了元素及其内容模型。

声明模块还通过添加名称空间属性包括每个元素的名称空间信息。

首先，需要声明实际元素。

声明元素和属性

声明元素和属性的最容易的方法是先构建传统的 DTD ，然后将声明更改为参数。因此

<!ELEMENT memories ( audio | video )* >

变成

<!ELEMENT %Memory.memories.qname;
     ( %Memory.audio.qname; | %Memory.video.qname; )* >
<!ATTLIST %Memory.memories.qname;
       %Memory.xmlns.attrib;
>

额外属性定义了添加到元素的名称空间信息。确定名称空间信息的方法与名称空间处理中的非常象。

添加名称空间属性

实际包含在 %Memory.xmlns.attrib; 中的信息取决于先前所做的名称空间定义和添加前缀决定：

<![%Memory.prefixed;[
<!ENTITY % Memory.xmlns.attrib
    "%NS.decl.attrib;"
>
]]>
<!ENTITY % Memory.xmlns.attrib
    "%NS.decl.attrib;
     xmlns  %URI.datatype;  #FIXED '%Memory.xmlns;'"
>

%NS.decl.attrib; 的值表示全局名称空间属性信息，它是由 XHTML 框架 DTD 中的条件确定的。如果添加前缀是打开的，则只有该信息需要出现在每个元素上，因为该前缀引用该元素的细节。然而，如果添加前缀是关闭的，则元素还需要模块的特定名称空间信息。

所有元素都必须将 %Memory.xmlns.attrib; 作为属性引用。如果元素已经有一个属性，则另外加上名称空间信息，如下所示：

<!ATTLIST %Memory.media.qname;
       mediaid  ID      #REQUIRED 
       type     CDATA   #IMPLIED
       %Memory.xmlns.attrib;
 >

声明模块（代码）

<!-- ...................................................................... -->
<!-- Memory Elements Module ............................................... -->
<!-- file: memory-1.mod
     PUBLIC "-//MY COMPANY//ELEMENTS XHTML MemoryML Declaration 1.0//EN"
     SYSTEM "http://www.my.org/DTDs/memory-1.mod"
     xmlns:memory="http://www.my.org/namespaces/MemoryML"
     ...................................................................... -->
<!-- Memory Module
memories 
    audio
        media
        start
        end
        subdate
        donor
        subject
    video
        media
        start
        end
        subdate
        donor
        subject
        location
            description | place
-->
<!-- Define the global namespace attributes -->
<![%Memory.prefixed;[
<!ENTITY % Memory.xmlns.attrib
    "%NS.decl.attrib;"
>
]]>
<!ENTITY % Memory.xmlns.attrib
    "%NS.decl.attrib;
     xmlns  %URI.datatype;  #FIXED '%Memory.xmlns;'"
>
<!ELEMENT %Memory.memories.qname;
     ( %Memory.audio.qname; | %Memory.video.qname; )* >
<!ATTLIST %Memory.memories.qname;
       %Memory.xmlns.attrib;
>
<!ELEMENT %Memory.video.qname;
     ( %Memory.media.qname;, %Memory.start.qname;, 
       %Memory.end.qname;, %Memory.subdate.qname;, 
       %Memory.donor.qname;, %Memory.subject.qname;, 
       %Memory.location.qname;) >
<!ATTLIST %Memory.video.qname;
       tapeid IDREF #REQUIRED
       %Memory.xmlns.attrib;
>
<!ELEMENT %Memory.audio.qname;
     ( %Memory.media.qname;, %Memory.start.qname;, 
       %Memory.end.qname;, %Memory.subdate.qname;, 
       %Memory.donor.qname;, %Memory.subject.qname;) >
<!ATTLIST %Memory.audio.qname;
       tapeid IDREF #REQUIRED
       %Memory.xmlns.attrib;
>
<!ELEMENT %Memory.media.qname; EMPTY >
<!ATTLIST %Memory.media.qname;
       mediaid  ID      #REQUIRED 
       type     CDATA   #IMPLIED
       %Memory.xmlns.attrib;
 >
                   
<!ELEMENT %Memory.start.qname; (#PCDATA) >
<!ATTLIST %Memory.start.qname;
       %Memory.xmlns.attrib;
>
<!ELEMENT %Memory.end.qname; (#PCDATA) >
<!ATTLIST %Memory.end.qname;
       %Memory.xmlns.attrib;
>
<!ELEMENT %Memory.subdate.qname; (#PCDATA) >
<!ATTLIST %Memory.subdate.qname;
       %Memory.xmlns.attrib;
>
<!ELEMENT %Memory.donor.qname; (#PCDATA) >
<!ATTLIST %Memory.donor.qname;
       %Memory.xmlns.attrib;
>
<!ELEMENT %Memory.subject.qname; (#PCDATA) >
<!ATTLIST %Memory.subject.qname;
       %Memory.xmlns.attrib;
>
<!ELEMENT %Memory.description.qname; (#PCDATA) >
<!ATTLIST %Memory.description.qname;
       %Memory.xmlns.attrib;
>
<!ELEMENT %Memory.place.qname; (#PCDATA) >
<!ATTLIST %Memory.place.qname;
       %Memory.xmlns.attrib;
>
<!ELEMENT %Memory.location.qname;
      ( %Memory.place.qname; | %Memory.description.qname;) >
<!ATTLIST %Memory.location.qname;
       %Memory.xmlns.attrib;
>

内容模型模块

该模块的用途

就象 DTD 为新模块定义结构一样，整个标记语言有一个结构。例如，memory 元素可以包含 video 和 audio 元素，但此刻没有可以包含 memory 元素的 XHTML 元素，所以无法将它添加到页面！

内容模型模块定义这些结构化元素。因为 XHTML 已参数化，所以可以改变其每个元素的定义。只要记住：一致性要求所有必要的元素都保持必要的，并且可选元素保持可用的。

例如，将 subject 添加为 li 元素的潜在子元素涉及重新定义li 的内容模型，如 XHTML 核心模块中定义的那样：

<!ENTITY % li.content
     "( #PCDATA | %Flow.mix; | 
     %Memory.subject.qname;
     )*"
>

乍一看，似乎只有正在扩展的元素才需要重新定义 — 毕竟，原始定义仍存在。不幸的是，它并不那样简单。

在最终的 DTD 驱动程序文件中，将首先列出内容模型模块，所以其定义将取得优先。因而，当处理该文件时，还未定义如%Flow.mix; 这样的参数。

这意味着，为了将 subject 添加到 li，需要定义 %Flow.mix; 参数实体和标记 %Flow.mix; 的所有实体。

定义结构

必须做的第一个决定确定了（相对与旧元素）新元素将出现的位置。这很大程度取决于将如何使用数据。subject 应该作为超文本链接（<a>）的一部分出现吗，或者它应该只作为列表项（<li>）的一部分出现并且当选中它时表现为超文本链接吗？正常情况下，数据将如何出现在页面上？

在某些情况下，同时考虑这两种使用方法是有意义的。例如，构建在视频控制器中的浏览器可能知道 subject 应该作为超文本链接，但用于访问 Web 上控制器的浏览器可能不知道，所以有必要将它添加到一个正常的链接标记中。

为了本教程，假设下列情况：

subject 可能作为列表项（li）或链接（a）的一部分出现。
memory 可能出现在页面本身的主体上。

生产环境很可能需要将元素添加到所有块元素的集合中。为了方便起见，本示例将它们直接添加到这些元素。

这些决定有助于形成内容模型模块。

内容模型模块（代码）

<!-- ............................................................. -->
<!-- XHTML Memory Model Module  .................................. -->
<!-- file: xhtml-memory-model-1.mod
     SYSTEM "xhtml-memory-model-1.mod"
     ................................................................ -->
<!-- Define the content model for Misc.extra -->
<!ENTITY % Misc.class
     "| %script.qname; | %noscript.qname;  ">
<!-- ....................  Inline Elements  ...................... -->
<!ENTITY % HeadOpts.mix  
     "( %meta.qname; )*" >
<!ENTITY % I18n.class "" >
<!ENTITY % InlStruct.class "%br.qname; | %span.qname;" >
<!ENTITY % InlPhras.class
     "| %em.qname; | %strong.qname; | %dfn.qname; | %code.qname; 
      | %samp.qname; | %kbd.qname; | %var.qname; | %cite.qname; 
      | %abbr.qname; | %acronym.qname; | %q.qname;" >
<!ENTITY % InlPres.class
     "| %tt.qname; | %i.qname; | %b.qname; | %big.qname; 
      | %small.qname; | %sub.qname; | %sup.qname;" >
<!ENTITY % Anchor.class "| %a.qname;" >
<!ENTITY % InlSpecial.class "| %img.qname; " >
<!ENTITY % Inline.extra "" >
<!-- %Inline.class; includes all inline elements,
     used as a component in mixes
-->
<!ENTITY % Inline.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %Anchor.class;
      %InlSpecial.class;"
>
<!-- %InlNoAnchor.class; includes all non-anchor inlines,
     used as a component in mixes
-->
<!ENTITY % InlNoAnchor.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %InlSpecial.class;
      
       | %Memory.subject.qname;
      "
>
<!-- %InlNoAnchor.mix; includes all non-anchor inlines
-->
<!ENTITY % InlNoAnchor.mix
     "%InlNoAnchor.class;
      %Misc.class;"
>
<!-- %Inline.mix; includes all inline elements, including %Misc.class;
-->
<!ENTITY % Inline.mix
     "%Inline.class;
      %Misc.class;"
>
<!-- .....................  Block Elements  ...................... -->
<!ENTITY % Heading.class 
     "%h1.qname; | %h2.qname; | %h3.qname; 
      | %h4.qname; | %h5.qname; | %h6.qname;" >
<!ENTITY % List.class "%ul.qname; | %ol.qname; | %dl.qname;" >
<!ENTITY % Blkstruct.class "%p.qname; | %div.qname;" >
<!ENTITY % Blkphras.class 
     "| %pre.qname; | %blockquote.qname; | %address.qname;" >
<!ENTITY % Blkpres.class "| %hr.qname;" >
<!ENTITY % Block.extra "
       | %Memory.video.qname; | %Memory.audio.qname;
      " >
<!-- %Block.class; includes all block elements,
     used as an component in mixes
-->
<!ENTITY % Block.class
     "%Blkstruct.class;
      %Blkphras.class;
      %Blkpres.class;
      %Block.extra;"
>
<!-- %Block.mix; includes all block elements plus %Misc.class;
-->
<!ENTITY % Block.mix
     "%Heading.class;
      | %List.class;
      | %Block.class;
      %Misc.class;"
>
<!-- ................  All Content Elements  .................. -->
<!-- %Flow.mix; includes all text content, block and inline
-->
<!ENTITY % Flow.mix
     "%Heading.class;
      | %List.class;
      | %Block.class;
      | %Inline.class;
      %Misc.class;
      
       | %Memory.subject.qname;
      "
>

DTD驱动程序

该模块的用途

现在，所有代码段都有了，该将它们全都放入可由 XML 文档调用的单一 DTD 中了。

该文件不仅合并在前面示例中创建的文件，而且还合并支持文件（如 XHTML 框架本身）和一致性所需的个别模块（如结构、超文本、文本和列表模块）。驱动程序还可以包括任何其它模块。

链接到 XHTML

要开始构建 DTD 驱动程序，需要添加版本参数以标识标记语言：

<!ENTITY % XHTML.version  "-//MY COMPANY//DTD XHTML MemoryML 1.0//EN" >

下一步，开始将文件链接在一起，产生把这两个名称空间的信息合并在一起的文件。以 Qnames 集合文件开始，它链接两个名称空间：

<!ENTITY % xhtml-qname-extra.mod
     SYSTEM "xhtml-memory-qname-1.mod" >

还产生实际将两个结构绑在一起的内容模型：

<!ENTITY % xhtml-model.mod
     SYSTEM "xhtml-memory-model-1.mod" >

下一步，将添加 XHTML 框架本身。

XHTML 框架

单一文件包含 XHTML 框架，但在为它创建设置时涉及到几个参数。

首先，添加 %XHTML.profile 实体，它是在 XHTML 概要可用时为与它们一起使用而保留的。虽然它实际上还没有用于任何事情，但在其它文件内部引用它并且可以想象出在内容模型中引用它，所以必须在内容模型之前定义它。

<!ENTITY % XHTML.profile  "" >

下一步，禁用双向文本支持，因为将不使用它。（该参数实际上包括除去双向支持的节，因此是奇怪的语法。）

<!ENTITY % XHTML.bidi  "INCLUDE" >

最后，产生 XHTML 框架本身：

<!ENTITY % xhtml-framework.mod
     PUBLIC "-//W3C//ENTITIES XHTML Modular Framework 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-framework-1.mod" >
%xhtml-framework.mod;

下一步，将包括所有模块。

包括新模块

有了适当的框架，该开始添加模块了。首先，添加包括在 MemoryML 中的 XHTML 模块：

<!-- Text Module (Required)  ............................... -->
<!ENTITY % xhtml-text.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Text 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-text-1.mod" >
%xhtml-text.mod;
<!-- Hypertext Module (required) ................................. -->
<!ENTITY % xhtml-hypertext.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Hypertext 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-hypertext-1.mod" >
%xhtml-hypertext.mod;
<!-- Lists Module (required)  .................................... -->
<!ENTITY % xhtml-list.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Lists 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-list-1.mod" >
%xhtml-list.mod;
<!-- Document Structure Module (required)  ....................... -->
<!ENTITY % xhtml-struct.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Document Structure 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-struct-1.mod" >
%xhtml-struct.mod;

最后，但的确相当重要，不要忘记添加 MemoryML 模块！

<!-- Memory Module   ........................................ -->
<!ENTITY % Memory-elements.mod
     SYSTEM "memory-1.mod" >
%Memory-elements.mod;

添加了这些代码之后，驱动程序文件是完整的并且准备使用。

DTD 驱动程序（代码）

<!-- .................................................................... -->
<!-- Memory Extension DTD  .............................................. -->
<!-- file: xhtml-memory-1.dtd -->
<!-- This is the DTD driver for Memory extension 1.0.
     Please use this formal public identifier to identify it:
         "-//MY COMPANY//DTD XHTML MemoryML 1.0//EN"
     And this namespace for extension-unique elements:
         xmlns:Memory="http://www.my.org/namespaces/MemoryML"
     
-->
<!ENTITY % XHTML.version  "-//MY COMPANY//DTD XHTML MemoryML 1.0//EN" >
<!-- Define the xhtml qualified names module to be ours -->
<!ENTITY % xhtml-qname-extra.mod
     SYSTEM "xhtml-memory-qname-1.mod" >
<!-- reserved for use with document profiles -->
<!ENTITY % XHTML.profile  "" >
<!-- Define the Content Model for the framework to use -->
<!ENTITY % xhtml-model.mod
     SYSTEM "xhtml-memory-model-1.mod" >
<!-- Disable bidirectional text support -->
<!ENTITY % XHTML.bidi  "INCLUDE" >
<!-- Bring in the XHTML Framework -->
<!ENTITY % xhtml-framework.mod
     PUBLIC "-//W3C//ENTITIES XHTML Modular Framework 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-framework-1.mod" >
%xhtml-framework.mod;
<!-- Text Module (Required)  ............................... -->
<!ENTITY % xhtml-text.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Text 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-text-1.mod" >
%xhtml-text.mod;
<!-- Hypertext Module (required) ................................. -->
<!ENTITY % xhtml-hypertext.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Hypertext 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-hypertext-1.mod" >
%xhtml-hypertext.mod;
<!-- Lists Module (required)  .................................... -->
<!ENTITY % xhtml-list.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Lists 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-list-1.mod" >
%xhtml-list.mod;
<!-- Document Structure Module (required)  ....................... -->
<!ENTITY % xhtml-struct.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Document Structure 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-struct-1.mod" >
%xhtml-struct.mod;
<!-- Memory Module   ........................................ -->
<!ENTITY % Memory-elements.mod
     SYSTEM "memory-1.mod" >
%Memory-elements.mod;

构建 MemoryML 文档

基本文档

根据我们已经定义的结构，使用新元素并将它们合并到一个 XHTML 页面的简单文件看起来如下：

<?xml version="1.0"?>
<!DOCTYPE html SYSTEM "xhtml-memory-1.dtd">
<html>
<head><title>Sample Page</title></head>
<body>
<p><a href="newpage.mml"><subject>Pitching a tent</subject></a></p>
<ul>
<li><subject>Pitching a tent</subject></li>
<li><subject>Baseball game</subject></li>
</ul>
   <video tapeid="A323">
      <media mediaid="A323" type="VHS"/>
      <start>0:00:00</start>
      <end>32:12:45</end>
      <subdate>2001-05-23</subdate>
      <donor>John Baker</donor>
      <subject>Pitching a tent</subject>
      <location><description>Outside in the woods</description></location>
   </video>
   <audio tapeid="C531">
      <media mediaid="C531" type="DAT"/>
      <start>12:09:23</start>
      <end>58:34:51</end>
      <subdate>2001-05-18</subdate>
      <donor>Elizabeth Davison</donor>
      <subject>Baseball Game</subject>
   </audio>
</body>
</html>

注意，该页面使用新的 DTD。在这种情况下，不提供名称空间信息，因为这不是必需的。

为新元素添加前缀

某些情况可能需要提供名称空间信息。因为内部 DTD 子集始终优先，所以很容易使用它来打开添加前缀。记得 %Memory.prefixed; 吗？在这里打开它，而它会覆盖任何其它设置。

<?xml version="1.0"?>
<!DOCTYPE html SYSTEM "xhtml-memory-1.dtd"[
    <!ENTITY % Memory.prefixed "INCLUDE">
    <!ENTITY % Memory.prefix "mem">
]>
<html xmlns:mem="http://www.my.org/namespaces/MemoryML>
<head><title>Sample Page</title></head>
<body>
<p><a href="newpage.mml"><mem:subject>Pitching a tent</mem:subject></a></p>
<ul>
<li><mem:subject>Pitching a tent</mem:subject></li>
<li><mem:subject>Baseball game</mem:subject></li>
</ul>
   <mem:video tapeid="A323">
      <mem:media mediaid="A323" type="VHS"/>
      <mem:start>0:00:00</mem:start>
      <mem:end>32:12:45</mem:end>
      <mem:subdate>2001-05-23</mem:subdate>
      <mem:donor>John Baker</mem:donor>
      <mem:subject>Pitching a tent</mem:subject>
      <mem:location><mem:description>Outside in the woods</mem:description></mem:location>
   </mem:video>
   <mem:audio tapeid="C531">
      <mem:media mediaid="C531" type="DAT"/>
      <mem:start>12:09:23</mem:start>
      <mem:end>58:34:51</mem:end>
      <mem:subdate>2001-05-18</mem:subdate>
      <mem:donor>Elizabeth Davison</mem:donor>
      <mem:subject>Baseball Game</mem:subject>
   </mem:audio>
</body>
</html>

还必须注意，该文件中的前缀不同于在原始 Qnames 模块中指定的前缀。这不是问题。象前缀开关一样，该值优先于任何其它值。

一种类似的方法打开所有添加前缀。

为所有元素添加前缀

打开所有添加前缀与更改缺省添加前缀设置一样简单：

<?xml version="1.0"?>
<!DOCTYPE xhtml:html SYSTEM "xhtml-memory-1.dtd"[

           <!ENTITY % NS.prefixed "INCLUDE">
      
    <!ENTITY % XHTML.prefix "xhtml" >
    <!ENTITY % Memory.prefix "mem">
]>
<xhtml:html xmlns:xhtml="http://www.w3.org/1999/xhtml"
            xmlns:mem="http://www.my.org/namespaces/MemoryML">
<xhtml:head><xhtml:title>Sample Page</xhtml:title></xhtml:head>
<xhtml:body>
<xhtml:p><xhtml:a href="newpage.mml"><mem:subject>Pitching a tent</mem:subject></xhtml:a></xhtml:p>
<xhtml:ul>
<xhtml:li><mem:subject>Pitching a tent</mem:subject></xhtml:li>
<xhtml:li><mem:subject>Baseball game</mem:subject></xhtml:li>
</xhtml:ul>
   <mem:video tapeid="A323">
      <mem:media mediaid="A323" type="VHS"/>
      <mem:start>0:00:00</mem:start>
      <mem:end>32:12:45</mem:end>
      <mem:subdate>2001-05-23</mem:subdate>
      <mem:donor>John Baker</mem:donor>
      <mem:subject>Pitching a tent</mem:subject>
      <mem:location><mem:description>Outside in the woods</mem:description></mem:location>
   </mem:video>
   <mem:audio tapeid="C531">
      <mem:media mediaid="C531" type="DAT"/>
      <mem:start>12:09:23</mem:start>
      <mem:end>58:34:51</mem:end>
      <mem:subdate>2001-05-18</mem:subdate>
      <mem:donor>Elizabeth Davison</mem:donor>
      <mem:subject>Baseball Game</mem:subject>
   </mem:audio>
</xhtml:body>
</xhtml:html>

还应该注意，因为 %Memory.prefixed; 继承 %NS.prefixed; 的值，所以不需要单独设置它。

XHTML模块化结束语

结束语

本教程演示了通过使用 XHTML 的模块化构建一个新的基于 XHTML 的标记语言所需的方法和过程。

该过程涉及了创建参数化的定义文件，甚至还允许定制实例文档本身。然后，充当实例文档的 DTD 的单一 DTD 驱动程序文件将这些文件结合在一起。

必需的和可选的 XHTML 模块通过几个创建新内容模型和名称空间设置的文件加入到扩展中。

更多信息

有关 XML 的基本背景知识，请阅读 Introduction to XML 教程。
有关“文档对象模型（Document Object Model）”的信息和 XML 名称空间的基本信息，请阅读 Understanding DOM 教程。
有关创建“文档类型定义（DTD）”的信息，请阅读 XML Validation教程。
请阅读 W3C 的 Modularization of XHTML 建议书（Recommendation）。
要查看用多个扩展模块创建语言，请阅读 Shane McCarron 著的 XHTML Modules and Markup Languages -- How to create XHTML Family modules and markup languages for fun and profit。
有关 XML 编程的介绍，请尝试 Doug Tidwell 的 XML programming in Java 教程。
订购 Nicholas Chase 著的 XML and Java from Scratch。它涵盖了 XML 和 Java 的一般性使用。它还涵盖了 XML 的其它以数据为中心的观点，例如 XML Query，以及 XML 的其他使用，例如 SOAP。另外，它就是由这个极佳教程的作者编写的。

下载

IBM Centre for Java Technology Development 提供了用于在一系列平台上创建和测试 Java applet 和应用程序的 developer kits。
下载 JAXP 1.1，XML 处理的 Java API。
从 Apache XML 项目下载 Xerces parser for Java。
从 Apache XML 项目下载 Xerces parser for C++。
从 Apache XML 项目下载 Xerces parser for Perl。
下载 IBM 的 XMI Toolkit，以通过使用 XML 来共享您的 Java 对象、生成 DTD 并转换 Java、UML 和 Rational Rose 之间的设计和代码。

]]> <![CDATA[利用CSS改善网站可访问性]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2769 breeze 2005/2/5 16:29:37 作者： BUILDER.COM
来源： www.BUILDER.COM
类型：翻译

最近，我不得不对我的一个客户的旧网站进行更新，使得它能够达到可访问性的标准。对三四年前的旧代码进行挖掘的想法根本没有吸引力，主要是因为我曾经使用的很多编程惯例已经不再适用，特别是从可访问性上来讲。我曾经使用绝对的字体大小，固定的页面宽度和表格来做版面设计和空间分配。

像那时建构的很多网站一样，我的客户的网站使用了Cascading Style Sheets (CSS)来格式化文本。它没有使用任何CSS的更加强有力的版面设计功能，也没有允许HTML设备独立，而这是CSS可访问性的主要优点之一。

问题是如何出现的？

在我概述使网站更加具有可访问性的方法之前，了解现今众多的访问性问题的起因也许是很有帮助的：

对HTML肤浅的理解：在1990年代的互联网大发展时期中，所有人都开始建构网站。WYSIWYG编辑器使得几乎每个人都可以很容易地建构一个网站，而不用费心去学习HTML。但不幸的是，这种在使用上的便利带来了一些蹩脚的代码，对可访问性造成了妨碍。

HTML在设计方面的局限性：开发者和设计者经常会故意错用HTML标签，特别是<table>标签，来克服HTML在版面和设计上的局限性。这种设计方式也会带来妨碍可访问性的代码。

什么使得CSS更具有访问性？

CSS在1996年出现，用来解决上述的问题。通过使用CSS，你可以将一个HTML文件的内容与有关它的表现形式或风格的信息分离开来。这就使你可以应用准确的格式化并达到想要得到的版面设计，而无需使用可能会让屏幕阅读器和专门的浏览器软件产生困惑的HTML代码。

例如，虽然HTML表格是用来排列表格式数据的，但他们也经常被用来排列对齐一个页面上的元素的。但是阅读器和例如语音合成器的软件要求有效的HTML代码。因此当他们遇到一个页面错误地使用了诸如一个表格的元素，产生的结果就会让使用者感到莫名其妙。

CSS的另一个可访问性的优点就是它允许使用者定义他们自己的风格单，这个风格单可以与网站的风格单共同工作。因此，例如一个使用者可以设定，所有通过<p>标签定义的文本都应该是1.5em Arial，即使这个网站的风格单表示它应该是18px Verdana Bold。

要注意用户定义的风格只有在用户的风格名称与HTML页面中的标签相符时才会起作用，这是很重要的。这就将确保兼容性的责任交到了开发者的手中。例如，如果用户的风格单指定<p>标签应显示1.5em Arial文本，但是HTML页面并不使用<p>标签来从风格单中调用一个风格（也许它使用<font class=”bodytext”>），用户对于<p>标签定义的风格将会被忽略。因此要确保你对你的标题和段落使用标准的HTML标签，这将减少用户定义的风格单被忽略的机会。

开始

如果你是从头开始建构一个新的网站，那么通过CSS来改善可访问性就会很容易。但你仍然可以轻松地将现有的网站转变为CSS形式。

步骤1：检查现有代码

为了更好地说明，我将用在表A中这个简单的HTML代码来代表一个使用CSS的页面。这个例子假设页面还没有使用CSS，不过你也可以使用相似的方法来评价一个基于CSS的站点。主要的不同点就是大多数的改变将发生在CSS文件中而不是HTML文件中。

步骤2：从HTML中去掉所有特殊风格标签

要在这个页面中加入CSS，我首先需要去掉所有要控制内容表现的标签。样本代码使用了字体标签来定义字体外观，风格和颜色。去掉这些元素使得样本代码如表B所示。

步骤3：从HTML中去掉并替换任何错用的标签

现在我要去掉任何错用的HTML标签。在样本代码之中，一个表格用来在页面的内容创建一个15象素的边缘，代码还使用<br>标签来创建段落。

在我去掉表格和<br>标签之后，我将他们替换为适当的标签。例如，我对页面标题使用<h2>标签，用<p>标签来显示段落。使用这些标准HTML标签使得之后的CSS的应用变得非常容易，而且与用户定义的风格单更加兼容。现在的样本代码如表C所示。

步骤4：建构一个CSS文件来覆盖风格信息

现在我已经从HTML文件中去掉了所有风格信息，我需要将这些信息转移至一个CSS文件中。CSS文件仅仅是一个存为.css扩展名的文本文件，因此它可以在任何一个文本编辑器中进行创建。我使用的是Dreamweaver MX。

为了使在HTML中应用CSS文件变得容易，我使用了名为p和h2的风格来对应标准HTML标签。我使用了可变的字体大小，使得用户可以轻松地在浏览器中增大或缩小字体大小。使用绝对大小可以防止浏览器对字体进行大小的调整（除了Netscape 6或以后的版本之外，它将不考虑绝对字体大小）。我还在需要的地方指定了字体的种类，重量和颜色。

要重新产生由HTML标记代码创建的版面，我需要将<p>和<h2>标签设置宽度为780象素。然而，由于我们的目的是将可访问性最大化，因此我将去掉宽度设置使得页面能符合浏览器窗口的大小。而且我将让HTML页面使用浏览器的缺省边缘，而不是用原始代码的<table>标签来重新创建15象素的空白，这也使得其它例如打印机等的设备来使用它的缺省边缘设置。

表D显示了我创建的CSS文件。我将它命名为Mystylesheet.css并将它放置在网站根目录下的一个风格文件夹之中。

步骤5：在HTML文件上附加新的风格单

在创建了CSS文件之后，我在HTML文件中插入了它的风格。因为HTML文件已经包括了所有在CSS文件中引用的标签(<h2>和<p>)，所以我只需要连接到HTML文件头部的风格单上就可以了。HTML文件从CSS文件中获得风格并将他们应用到<h2>和<p>标签当中，如表E所示。

步骤6：验证代码

整个过程的最后一个步骤就是验证HTML代码的可访问性。如果你对于CSS来说是个新手的话，你最好对CSS代码也进行验证。有很多种的工具都可以帮你对二者进行验证。

我使用Dreamweaver MX来检查我的样本代码的可访问性。你可以通过在文件菜单中选择Check Page然后选择Check Accessibility来实现。任何错误或是警告都会显示出来，还包括出现位置的行号以及对问题简要的解释。你可以在Dreamweaver MX的Reference工具中找到更多关于这些错误和警告的内容。你只要从Dreamweaver的Windows菜单中选择Reference然后从Book菜单中选择UsableNet Accessibility Reference就可以了。

此外，World Wide Web Consortium (W3C)提供了超过30个的可访问性评估工具的链接。W3C还提供了针对HTML和CSS的基于Web的免费验证器。

可访问性和简单的管理

虽然这里给出的例子是很简单的，但它说明了利用CSS使你的站点更加具有可访问性是非常容易的。而且，对于CSS的使用不止这一个优点而已。

基于CSS的网站要比仅仅只有HTML的网站要好管理得多。CSS文件中的风格上的变化可以应用到整个网站中而不需要改变网站中任何的HTML文件。而且CSS的使用缩小了每一个HTML文件的整体文件大小，因为所有的风格信息都存储在了CSS文件之中。

因此如果你想要改善可访问性的话，将其视为一个机会，而不是一个障碍。要了解更多关于CSS和可访问性的内容，你可以去看一看World Wide Web Consortium中的Web Accessibility Initiative (WAI)。

]]> <![CDATA[为什么要使用 CSS?]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2768 breeze 2005/2/5 16:03:21 自从 Dreamweaver MX 2004 发布以来，我曾经无数次向 Dreamweaver 的新老用户演示它的新特征和新功能。每次进行产品演示，我很快就会极力称赞 Dreamweaver MX 2004 设计和呈现 CSS（或层叠样式表）的新功能。

然而最近某位新用户问了一个问题，说实话，这个问题一下子让我张口结舌。这位用户只是问：“我为什么要使用 CSS?”当时我意识到，尽管我们这些每天与 HTML 和 CSS 打交道的人非常了解 CSS 的优点，但仍有很多人并不了解。或者说并不完全了解 CSS 所能提供的所有优点。本文是我对上面那位新用户的书面回答。

CSS 起源

回顾 CSS 的优点之前，我要先介绍一下它的历史。Web 管理组织 W3C 在 1996 年 11 月推荐使用 CSS，并批准了 CSS 1 级规范。CSS 1 级规范说明了用于 HTML 页面的属性。这些属性代替了传统的字体标签和其他“样式”标记，例如颜色和边距。1998 年 5 月，W3C 批准了 CSS 2 级规范，将一些附加功能添加到 1 级规范，并引进了定位属性。这些属性代替了表格标签普遍（但是错误）的用法，用来设计页面元素的表示。CSS 规范的最新版本是 CSS 2.1，它改进了某些属性，并删除了在当前浏览器里没有作用或作用很小的属性。

不幸的是，就像很多新技术一样，CSS 经历了漫长的过程才被广泛采纳。其中的重要原因在于浏览器，以及为这些浏览器建立站点的 Web 设计者们。CSS 批准期间，Netscape Navigator (NN) 仍然是主导浏览器，而该浏览器基本上不支持 CSS。Microsoft 在其第 3 版浏览器中添加了对 CSS 非常有限的支持，但当时大多数的 Web 设计者（本人在内）仍然将 NN 作为首选平台进行页面编码。

很多年来，每发行一个新版本，浏览器制作者们都扩展了对 CSS 的支持。今天，Internet Explorer 6、Netscape Navigator 7、Mozilla、Opera 和 Safari 都全面支持 CSS。但这并不意味着我们作为 Web 设计者和开发者的生涯不存在问题。尽管上述所有浏览器都支持 CSS Level 2，它们的兼容程度仍然各不相同。而且在某些情况下，特定属性仍然会带给你很多麻烦。也就是说，您仍然需要遵守老的信条“测试再测试”。但如果您坚持使用 CSS 规范的核心属性，您将能够正确地呈现页面。

但是为什么 W3C 认为需要创建 CSS 规范呢？当我创建基于 HTML 的 Web 站点和应用程序时，这一切对我又意味着什么呢？我认为，我们需要使用 CSS 的理由以及它带来的优势可以分为以下三个主要方面：灵活性、呈现性和可访问性

灵活性

我确定几乎每个 Web 设计者和开发者都经历过这样的痛苦时刻：当您小心地布置好页面，完成所有嵌套的表格后，客户要求进行一点“小小的”更改。这小小的更改可能只是“能不能把那个图形稍稍往左移动一点？”，也可能非常富有戏剧性：“我不喜欢这些标题，能把它们的字体弄大一点吗？改字体的时候，顺便把颜色也改了，怎么样？”如果只需要处理有限的几个页面，您可以深吸一口气，花上大半个小时做那些让人恼火的改动。但如果涉及到较大的站点（而这已经很常见），一个简单的更改无论如何也简单不了。

这样的情形为什么会如此痛苦呢？因为定义页面外观的标记本身就是页面的一部分。要看到实例，您只需到任何站点的任何页面上去数一下 font 和 table 标签的数量。只要您能够从实际页面的流程（或代码）中删除这些标记，或者采用更好的办法，即将其外置，您就可以进行集中更改。而这就是 CSS 所能做的。

如果使用一个或多个外部样式表，通过修改样式表然后将修改后的版本上载，您就可以将更改应用到站点。

想象一下，在传统的基于表格的布局中，将站点浏览从页面左侧移到页面右侧将有多么困难。这需要几个小时重复而乏味的工作。但是，如果您选择使用 CSS 的定位属性（通常称作 CSS-P）来设计页面，只需更改外部样式表中的“浮动”或“位置”属性，即可更新页面。而且还有以下附加优势：您更新了站点中使用该样式的所有页面。

呈现性

由于宽带的广泛使用，很多开发者已经不再考虑在浏览器中呈现页面所花费的时间。但是，你们应该记住，很多目标用户仍然在使用拨号连接。传统的基于表格的布局是页面下载速度慢的主要原因。因为浏览器从服务器接收页面时，必须首先检查并“理解”一系列复杂的镶嵌式表格。它必须先找到镶嵌在最里面的内容，然后小心地逐步处理代码，直至到达最外层的容器，即 body 标签。完成以上所有过程后，浏览器才能开始在屏幕上呈现内容。

如果使用 CSS，浏览器从服务器接收内容后，立刻就可以开始呈现过程，因为页面中没有或只有很少的显示标记。

使用外部样式表还有一个潜在的呈现方面的好处。在传统的基于表格的方法中，浏览器必须检索、分析并单独呈现每个页面。也就是说，浏览器在您的站点上显示第 30 页时耗费的工作和显示第 1 页时一样多。

但是，如果使用外部样式表进行显示，站点的第一页将提示浏览器将页面使用的已链接样式表文件缓存起来。这意味着站点中所有使用上述样式表的后继页面下载速度会更快，因为浏览器已经缓存了样式表。

最后一个与呈现有关的优点让我想起电影《莫扎特》。电影中，莫扎特问国王对自己的歌剧有什么看法。国王说很好，但是很沉闷。莫扎特一再追问，国王解释说，问题就在于“音符太多”。Web 设计也可能有同样的问题，当然这里的音符指的是实际 HTML 代码。代码越多，浏览器理解页面所花的时间就越长。

大家也许都听说过有关官方应用程序的传言，它们编写了非常糟糕的代码，满是复杂的信息，然而文档页面却无法呈现。作为 Dreamweaver 的用户，你们不会遇到这样的问题，但是如果编写了太多代码，你们也会感到内疚。典型的基于表格的设计就是一个很好的例子。

在设计中使用 CSS 后，您将减少客户需要下载的代码的数量。仅仅减少某些页面中的字体标签就可以大大减少代码的数量。在很多情况下，如果完全使用 CSS-P 进行设计，代码的数量最多可以减少 50% 甚至更多。代码减少就意味着页面下载的速度加快。

可访问性

如今我经常听到人们谈论可访问性。大多数开发者知道自己必须考虑建立更多可访问站点的问题，但在更大的程度上，只有为政府或教育机构建立站点的开发人员才被迫真正做到了这一点。考虑到可访问性的问题时，大多数开发人员认为这仅仅意味着需要将 alt 属性添加到图形中。但实际上，提高可访问性有很多工作可做，CSS 使您可以轻松建立可访问站点。

可访问性的主要问题（也是使用 CSS 能够解决的问题）在于辅助技术（例如屏幕阅读器）怎样“阅读”页面。传统的基于表格的环境下，屏幕阅读器面临一个巨大的挑战，那就是决定怎样阅读页面。想想吧，当屏幕阅读器遇到镶嵌很深的表格时该有多么困惑，它应该阅读内容，还是跳过内容？跳过内容后，以后怎样返回内容？

当您点击页面时，您会很快看到页面中自己感兴趣的内容，而忽略页面顶部的导航和其他内容。视力不太好的人却做不到这一点。他必须等待屏幕阅读器分析完页面顶部和他感兴趣的内容之间所有复杂的信息。

当然，有的技术能够使屏幕阅读器跳过导航，但这需要在导航条或其他内容的图像中添加链接。这些技术的运行可能会造成混乱，而且访问站点的其他人也能够看到它们。使用 CSS，您能够在页面中完整定义不可视元素（对于其他站点访问人员和您的鼠标不可视）。屏幕阅读器可以使用这些元素快速导航，有效处理文档。

由于 CSS 没有显示标记，屏幕阅读器所遇到的唯一问题就是实际内容。另外，当您使用 CSS-P 进行设计时，您将专注于内容的实际“流”。您开始考虑它在页面上的逻辑顺序。

当您阅读本文档时，您理解了信息“流”。但在镶嵌型表格的示例中，如果您使用多栏布局，本段落将很可能位于页面的右上角。那样，屏幕阅读器无法知道它应该在文章末尾阅读本段落。

使用 CSS-P 后，浏览器可能仍将本段落显示在浏览器窗口的右上角，但当您查看文档的源代码时，段落在文档的 html 中仍然是您现在所看到的位置。这使页面更容易访问。

总结和计划

以上就是我的答案。我希望我解释了使用 CSS 进行 Web 设计的独特优势。显然，要学习的内容很多。因此，我鼓励您阅读 Macromedia 开发者中心关于 CSS 的其他文章*，它们将帮助您更好地了解 CSS 的优点，并教会您在设计中使用 CSS 的整个过程。以后的几个星期以及几个月当中，我将带回来更多的 CSS 教程。就写到这里，希望您愉快使用我们的样式。

关于作者

Greg Rewis 是 Macromedia Web 技术最主要的宣传者。 Greg 是 Macromedia 的公众代言人，代言 Web 上发行的 Macromedia 软件套件和 Web 应用程序开发服务器，同时他又代表公司成千上万顾客的利益，与产品开发部门进行沟通。Greg 十分了解 Macromedia 客户的想法，　因为每年他有 200 天都“在路上”，他与客户交谈，在商品展览会、研讨会和各种会议中进行产品展示，组织高级培训会议专门介绍 Macromedia 生产线。Greg 总是在世界各地飞来飞去，但工作之余他在 Arizona 沙漠中享受生活，打高尔夫球，教他的两个儿子“在游泳池中放松身心”的艺术。

]]> <![CDATA[键盘用户界面设计指南]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2756 breeze 2005/2/4 21:05:24 发布日期： 12/20/2004 | 更新日期： 12/20/2004

Microsoft Corporation

适用于： Microsoft Win32 应用程序
Microsoft Active Accessibility

摘要：本文描述设计用于 Microsoft Windows 应用程序的键盘用户界面的指南。

本页内容

	概述
	键盘 UI 在可访问性方面的角色
	键盘 UI 设计基础
	设计键盘 UI
	输入焦点位置
	用于键盘 UI 的 Windows 系统参数
	其他资源
	Windows 快捷键

概述

本文描述设计用于 Microsoft® Windows® 应用程序的键盘用户界面 (UI) 的指南。键盘 UI 让用户可以通过只使用键盘或结合使用鼠标（或者另一个指针设备）来浏览应用程序并操作 UI 元素。遵循这些指南将有助于设计一个使您的应用程序对残疾人来说更易于访问的键盘 UI。

键盘 UI 在可访问性方面的角色

设计良好的键盘 UI 是软件可访问性的一个重要方面。它使盲人用户或有某种行动障碍的用户能够浏览应用程序并与其功能交互。这类用户可能不能够操作鼠标，并且可能依赖于辅助技术（例如，键盘增强工具、屏幕键盘、屏幕放大器、屏幕阅读器和语音输入工具），所有这些技术都要依靠应用程序的键盘 UI。

许多辅助技术以编程方式使用键盘 UI，即使用户没有使用标准键盘输入设备也是如此。尽管一些辅助技术可能有能够使操作更简单的自定义键盘快捷键，但是在键盘 UI 设计上（针对辅助技术以及用于可访问性的所有方面），一致性和标准化对避免使用户产生混淆是很重要的。

Windows UI 设计最大化了输入灵活性。控制面板中的辅助功能选项 (Accessibility Options) 提供了增强键盘功能的工具，如粘滞键、筛选键、切换键和鼠标键。这些工具可以帮助用户用键盘操作应用程序。但是，它们不会取代由设计良好的键盘 UI 提供的辅助功能。

键盘 UI 设计基础

设计良好的应用程序包括两个基本要求：

•	即使当键盘是唯一的输入设备时它们也必须是可使用的。
•	它们还必须是实用而且用户友好的。

以下几节提供了在您开始设计键盘 UI 前应该熟悉的信息。

键盘 UI 设计规则

要设计一个有效的键盘 UI，请使用下列设计规则：

•	提供对所有功能的键盘访问，并且为键盘界面提供文档。建议键盘能够执行与鼠标设备相同的任务。在产品手册以及联机帮助中提供键盘 UI 的文档。确保输入焦点位置（在 UI 中，输入在该点被定向）以编程方式直观地提供。有关更多信息，请参阅输入焦点位置。
•	保持键盘导航快速简单。提供简单的键盘导航方法。键盘导航方法应该像鼠标导航方法一样简单易懂。为普通和重复的任务提供可编程的、可自定义的快捷方法。进行关于应用程序键盘 UI 设计的可用性研究，不使用鼠标而确保易于使用。有关更多信息，请参阅设计键盘 UI。
•	避免意外的键盘 UI 更改。某个任务所需的击键不应该意外变更。例如，无论选择或者其他模式状态如何，一个命令的下划线访问键应该是相同的。
•	提供一个一致的键盘导航模型。应用程序应该与基本的键盘导航一致以避免系统问题。避免输入焦点中的意外的更改。有关更多信息，请参阅符合标准键盘导航。
•	提供一致的键盘快捷键。应用程序间一致的键盘 UI 帮助用户了解新应用程序并与之交互。应用程序一定不能影响系统范围内的任何快捷键（用于执行某一命令的一个键或一个键组合），如打开 Start 菜单的 Windows 徽标键 ( )。应用程序还必须遵循公认的快捷键分配，例如，用于复制的 CTRL+C 和用于撤消的 CTRL+Z。尽管如此，这并不意味着所有快捷键都需要被标准化或者应用程序必须总是被强制去支持相同的快捷键。例如，不是所有的应用程序都需要支持 CTRL+P 用于打印。有关更多信息，请参阅分配快捷键和 Windows 快捷键。
•	避免同时发生多个键输入。除了修改键 SHIFT、CTRL、ALT 和 Windows 徽标键，应用程序不应该要求用户同时按多个键。Windows 操作系统中的粘滞键辅助功能可以通过允许用户按连续顺序按键来模拟键组合。唯一原始设备制造商 (OEM) 功能键（如便携机键盘上的 Fn 键）是不作为组合键被支持的。
•	避免妨碍 Windows 支持的辅助功能选项或模拟输入设备。应用程序不能妨碍 Windows 支持的键盘和鼠标辅助功能选项，如粘滞键、筛选键、切换键和鼠标键。来自模拟输入设备的输入必须与标准设备的输入相同。应用程序必须能够接受来自键盘或鼠标模拟设备的输入，如用一个屏幕键盘或者串行键设备。有关更多信息，请参阅GetAsyncKeyState 和检索键的状态。

常见键盘 UI 设计错误和限制

理想情况下，所有应用程序功能都必须可以通过键盘访问。但是，这可能不总是可行的。有时，对一个功能的键盘访问强制用户遵循难以使用的或复杂的步骤。或者要通过该键盘 UI 来实现一个功能可能是编程方式上的一种挑战。

下面的列表描述了与创建键盘 UI 相关联的问题和挑战。

•	对话框中不一致的导航顺序。导航顺序必须是合乎逻辑的并且是按照语言的阅读方向的。当一个新控件添加到一个现有的对话框中时，这个顺序经常遭到破坏。在一组控件中，每个控件之间的导航必须是连续并且有序的。
•	输入焦点在每个单个的选项按钮上停顿。输入焦点必须只在选定的项上，而且用户必须能够通过使用箭头键选择其他选项。
•	窗格和视图之间的导航不一致或丢失。窗格和视图用于划分单个窗口以显示多个信息视图。窗格和视图之间的导航必须是合乎逻辑并且对键盘用户可用的。
•	自定义树控件中不一致的导航。树控件是 Windows 中的一种导航模型，键盘模型通常通过公用控件库可用。自定义树控件必须是合乎逻辑的并且遵循标准的导航模型。
•	设计欠佳的自定义控件。通过结合不同的控件并保持与现有控件相似的外观来开发一个新的控件也许更容易。必须使输入焦点既对用户直观可用又对开发人员以编程方式可用。在开发控件时，请使用 Microsoft Active Accessibility® 动态批注 API。
•	键盘 UI 冲突。您可以通过使用标准键和组合键的组合以多种方法分配快捷键。但是，这会导致与为专有功能提供全局键序列的应用程序冲突，与许多辅助技术也会冲突。为避免冲突，不要使用 Windows 全局键序列或用于快捷键的常见序列。键盘 UI 在辅助技术间变化很大，并且可能与某一应用程序的快捷键冲突。因此，只为重要的击键提供自定义快捷键，并且避免常用键。例如，在许多屏幕阅读器中，用户按 CTRL 键来停止语音评述过程。因此，您应该对最近分配的快捷键和可自定义快捷键进行可用性研究，来避免与系统和其他应用程序冲突。
•	用于鼠标操作的键盘 UI。用户可以使用其他通过键盘或用另一个输入设备模拟鼠标操作的工具。但是，这些工具不会替换一个设计良好的键盘界面。例如，一个简单的拖放操作可能需要超过 40 次复杂的击键，而一个盲人用户可能会发现要用击键来执行视觉操作是困难或者不可能的。一个需要广泛使用鼠标的应用程序可以通过使用逻辑绘图对象和控制命令提供一个有效的键盘 UI。应用程序会通过对选定对象使用诸如 Rotate、Flip 和 Move 等命令提供有效且合乎逻辑的导航，而非在一个像素接一个像素的基础上操作控件。

关于常用快捷键的更多信息，请参见 Windows 快捷键。

设计键盘 UI

在您了解了设计键盘 UI 的基本规则后，您可以开始考虑用户将如何使用键盘 UI 来浏览您的应用程序并与其功能及 UI 元素交互。

符合标准键盘导航

用于创建一个设计良好的键盘界面的优秀实践是，让其模仿用户已经熟悉的界面，以及与其他常用应用程序和控件兼容的界面。下面一节描述在设计键盘 UI 时要牢记的标准键盘导航实践。

以合乎逻辑的顺序浏览

用户移动或浏览一个 UI 的元素的顺序必须合乎逻辑，并且与用于编写该 UI 的自然语言一致。在一个设计良好的 UI 中，导航顺序从最常用的控制开始并按语言被阅读的方向流动。例如，在一个用英语编写的 UI 的对话框中，导航顺序从左到右、从上到下移动。

在 Windows 应用程序中，用户通过按 TAB 键将输入焦点从一个 UI 元素移动到另一个来进行浏览。他们按 SPACEBAR 或 ENTER 键来选择当前选定的活动区域，或者激活一个控件或命令。按 SHIFT+TAB 键组合反转导航顺序，将输入焦点经由那些元素向后移动；按箭头键将输入焦点按指定的方向在一组元素内移动。关于输入焦点的更多信息，请参阅输入焦点位置。

下面的图 1 阐释了通过一组控件的导航顺序。它有两个选项按钮：Default Printer 和 File；以及两个命令按钮：OK 和 Cancel。File 选项按钮是一个独立控件，而文本框是一个依赖控件，这意味着只有当 File 按钮已经被选定时才可使用。

这类控件的导航顺序总是从选定的选项按钮（如 File）开始，然后按其依赖控件的顺序进行。接着它移动到到窗体中的其它控件，如 OK 命令按钮。正确地分配导航顺序以确保所有控件在正确的时间以一个合乎逻辑的序列可用是很重要的。

atg_keyboardshortcuts_01

图 1. 通过一组控件的导航顺序

直观导航顺序通过禁用（变灰）所有当前依赖于未选定的选项按钮被强制使用。当一个选项按钮被选定时，其所有的依赖控件跟着被启用。要避免使用户产生混淆，当一个用户选择某一有依赖控件的选项按钮时，输入焦点绝对不能自动移动到第一个依赖控件。

在 Windows 窗格间浏览

当一个窗口被划分为两个或更多个窗格时，键盘用户可以通过按 TAB 键或 SHIFT+TAB 键组合在它们之间移动。它们可以按箭头键来在一个单窗格中的一组元素内移动输入焦点。如果某一窗口有许多活动的 UI 元素，考虑分层排列每个窗格。

下列击键用于在一个窗口内的窗格之间移动：

•	只有在 TAB 键没有被窗口内的任何其他控件使用时，它才将输入焦点移动到活动窗格的下一个区域。
•	CTRL+TAB 快捷键或 F6 功能键将输入焦点移动到下一个窗格或调色板。
•	CTRL+F6 组合将输入焦点移动到一组相关窗口中或多文档界面 (MDI) 窗口间的下一个窗口。

始终为分层导航的快捷键提供文档，它们是应用程序专用的并且提供一个唯一的键盘界面。

在字段内浏览

通过对话框或窗体上的控件的导航应该是连续且无障碍的，而且不会导致用户更改值或接收到错误消息，这是很重要的。对于在无论何时用户离开它们时验证其内容的控件来说，这可能是困难的。在这些实例中，窗体或控件必须遵循下列约定之一：

•	在导航期间决不要求用户更改控件的初始值。所有在退出时验证的控件必须以有效值开始。例如，用户必须能够在不应用新值的情况下在控件间移动输入焦点，直到他们按 Submit 按钮为止。
•	只在控件值改变并且用户试图将输入焦点移出该控件时验证控件值。定位到（或者离开）一个字段不会更改其值。
•	当用户选择 OK 或提交更改的等效命令时，更改以验证字段。这种情况下，您必须允许用户取消操作或选择一个命令来恢复默认的值。

通过匹配字符导航

应用程序必须为使用匹配导航在一个项列表中移动输入焦点的用户提供反馈。在匹配导航中，用户通过键入匹配列出的项的前几个字母的字符定位一个列表。有两种方法来向用户展示匹配字符串缓冲区中的字母：

•	当用户将输入焦点移动到一个基于部分匹配的项时，输入焦点指示符是在匹配字符而不是整个项的周围，来展示已经键入的是什么。
•	一个工具提示在输入焦点附近打开以展示匹配字符串缓冲区内容。

应用程序必须提供反馈以帮助用户正确地完成匹配导航。要确保应用程序提供这种类型的反馈，请使用下列指南：

•	当匹配字符串缓冲被清除（在一段时间没有输入后或当用户按 BACKSPACE 键）时，输入焦点指示符围绕在整个项周围。
•	如果缓冲区内容没有任何项，该缓冲被清除并且 PlaySound 函数被调用。这会播放一个指示无效输入的默认声音。
•	用户执行另一个操作时（如单击鼠标或按一个非打印字符来离开一个控件，或者手动将输入焦点移动到另一个项），缓冲必须被清空。

关于匹配导航的更多信息，请参阅提供自动完成。

与 UI 元素交互

设计良好的键盘 UI 允许用户与所有 UI 功能和元素交互。下一节描述当考虑如何为您的应用程序提供键盘访问时要牢记的功能和任务。

访问菜单和对话框

菜单和对话框是 Windows 操作系统中两个最常见和最标准化的 UI 元素。菜单将相关命令分组到列表内，对话框将重要功能分组到窗口中。要确保键盘用户能够通过按 ALT 键进入和退出菜单。为了防止菜单变得太长且难以使用，对其进行配置以便多数命令从视图看是隐藏的，除非用户要求访问完整的列表。

拆分窗口

许多应用程序支持拆分条，它允许用户将一个窗口拆分成多个窗格。确保用户能够使用键盘命令定位并调整拆分块。实现这一点的一个常见方法是提供用于添加、移动及重新定位拆分条的菜单命令。将这些命令放在 Window 或 View 菜单下，或者放在一个快捷菜单中。例如，在 Microsoft Word 中，用户可以通过使用 Window 菜单中的 Split 命令定位或删除拆分条。

调整元素的大小和位置

多数窗口都有允许用户调整 UI 元素和对象的位置和大小的 Move 和 Size 命令。这些命令位于 System 或 Control 菜单中。可以使用 ALT+SPACEBAR 键组合访问 Control 菜单，这个菜单出现在标题栏的左端。它使用户能够使用键盘来执行 Control 菜单操作。这些命令也可以提供给菜单栏或对象的快捷菜单上的应用程序特定的对象。

如果 Size 命令能够以逻辑或数字方式完成，它会更加强大。例如，在 Microsoft Excel 中，用户可以使用 Format 菜单来以逻辑或数字方式更改列或行的宽度。在列表视图中，数字键盘上的快捷键 CTRL+ (+) 键调整所有列宽以装下单元格的内容。

控制复杂属性

一个设计良好的键盘界面还允许用户通过调整对象属性表上的值来操作对象。例如，图 2 展示了出现在 Microsoft Visual Basic® 窗体旁边的属性表。想要调整 OK 按钮的左边缘的用户可以使用键盘来更改属性表中的 Left 属性的值。

atg_keyboardshortcuts_02

图 2. Visual Basic 属性表

访问工具栏

对鼠标用户来说，工具栏是一个强大的 UI 解决方案，但是它对键盘用户通常是不可访问的。确保您的应用程序通过使用菜单、键盘快捷键或工具按钮包含相等或相似的工具栏功能。例如，打印功能可以使用工具栏上的 Print 按钮或者 CTRL+P 快捷键来完成。

Microsoft Office 有一个能够被自定义并且使键盘可访问的扩展工具栏界面。

访问选项卡控件

当对话框有大量选项或 UI 元素时，您可以使用选项卡控件通过分类来组织它们。如图 3 所示，选项卡控件可以将控件划分到几个页面，通过快捷键（如 CTRL+TAB、CTRL+PAGE UP 和 CTRL+ PAGE DOWN）来访问。通常，选项卡控件在活动 UI 元素的导航顺序内。当输入焦点在控件上时，用户可以通过使用箭头键浏览不同的元素。访问每个元素的顺序必须是合乎逻辑的，这样用户才不会感到困惑。

图 3. 选项对话框选项卡控件

设置定时控件

键盘 UI 必须为调整计时、禁用超时或共享计时的系统范围设置提供选项。这使不能快速响应的用户能够访问这些控件。

用户可以通过控制面板设置几个不同的键盘行为，如 Keyboard Properties 和 Accessibility Options。基于 Windows 的应用程序必须支持由其用户设置的键盘选项。使用 SystemParametersInfo 函数来读取设置。

有关更多信息，请参阅用于键盘 UI 的 Windows 系统参数。

显示工具提示

工具提示是当用户将光标定位在按钮或 UI 控件上时出现的一个文本批注框。工具提示包含必须显示给键盘用户的重要信息。当用户将输入焦点保持在一个 UI 控件上一段时间时，使用相同的鼠标计时标准 (SPI_GETMOUSEHOVERTIME) 来使工具提示显示出来。

创建快捷键和访问键

键盘用户可以使用单个键和键组合作为快捷键来跳过菜单并执行命令。这些键被称为快捷键和访问键，即便是鼠标用户也发现使用它们比使用鼠标单击屏幕对象会更快捷并且更不易疲劳。下列指南描述如何创建快捷键和访问键。

分配快捷键

快捷键是一个单个键或者键组合，它让用户能够通过使用键盘快速访问频繁执行的操作。例如，应用程序键 (

) 让用户能够显示快捷菜单来移动或复制项。如图 4 所示，当输入焦点在 Windows 资源管理器中的一个文件夹上时按这个键，将打开一个使用户能够将文件有效率地移动或发送到其他位置的快捷菜单。这与拖放鼠标的操作相似。

atg_keyboardshortcuts_04

图 4. Windows 资源管理器和快捷菜单

在创建快捷键时，CTRL+ 字母组合和功能键（F1 到 F12）通常是最好的选择。例如，对 Cut、Copy 和 Paste 命令的键盘替代快捷键分别是 CTRL+X、CTRL+C 和 CTRL+P。

国与国之间的键盘设计不同，所以应该避免使用不能跨不同语言使用的字符或者由系统保留的快捷键组合中的字符。建议国际应用程序中的快捷键是可自定义的，这是因为记忆关联在一些语言中可能是没有用的，比如用 CTRL+B 设置粗体。

使用下列指南来设计快捷键：

•	分配简单并且一致的键组合。
•	使快捷键可以自定义。
•	对表示大范围影响的操作，使用带有 CTRL 键的快捷键，如用于保存当前文档的 CTRL+S。
•	对扩展或补充标准快捷键操作的操作使用 SHIFT+ 键组合。例如，ALT+TAB 快捷键显示正在运行的应用程序的主窗口。或者，SHIFT+ALT+TAB 键组合允许您向后浏览前面已经访问过的当前运行中的应用程序。
•	使用 SPACEBAR 键作为控件的默认操作，如按一个按钮控件或切换复选框控件的状态。这与单击鼠标的左键或主键是相似的。
•	使用 ENTER 键（如果可用）作为对话框的默认操作。
•	使用 ESC 键来停止或撤消一个操作。
•	避免将已修改字母或区分大小写的字母用作快捷键。
•	避免将下列字符用作快捷键：@ ?ï¿_ $ {} [] \ ~ \| ^ ' < >
•	避免 ALT+ 字母组合，这是因为它们可能与访问键冲突。此外，系统将很多特殊键组合用作专用输入，例如，ALT+~ 调用一个日语输入编辑器。
•	避免 CTRL+ALT 组合，这是因为在一些语言版本中系统将这个组合解释为生成字母数字字符的 ALTGR 键。
•	避免分配由系统保留或定义的组合，或者其他应用程序经常使用的组合。
•	不要将 Windows 徽标键作为组合键用于非系统级的功能。

关于快捷键的更多信息，请参阅 Windows 快捷键。

选择访问键

访问键是与 ALT 键一起使用以激活控件的字母数字键。如图 5 所示，访问键是常见而高度可视的，并且显示为菜单或 UI 控件上的带下划线的字母。

atg_keyboardshortcuts_05

图 5. 菜单访问键

随着用户开始熟悉一个应用程序，他们更可能去使用访问键来加速常见操作。这个趋势在辅助技术用户中更为常见。例如，屏幕阅读器依次显示 UI，这样用户可以阅读或倾听以发现系统选择了什么 UI 元素。访问键在这个复杂过程中是很有用的，尤其是在一个组有很多控件的时候。

在 Microsoft Win32® 应用程序中，您可以通过在分配给访问键的字母前放置一个“&”符为公共控件分配访问键。例如，用于已经分配了 &Settings 的按钮控件的访问键是 S。在 HTML 文档或应用程序中，您可以通过指定 ACCESSKEY 和 TABINDEX 属性指定快捷键和导航顺序。

下列设计规则帮助确保访问键提供一个固定的可访问性解决方案：

•

使访问键可发现。

访问键必须是用户容易找到的。为访问键选择尽可能靠近标签开头的字母 — 例如，Settings。下面是一些好的字母选择：

•	标签的第一或第二个单词开头的字母。
•	标签中与众不同的辅音或元音字母。
•	宽度较宽的字母，如 w、m 和大写字母。

避免使用当它们被分配为访问键时难以看清的字母。这些字母包括：

•	带下伸的字母，如 p、g、q 或 y。
•	在带下伸的字母旁边的字母。
•	只有一个像素宽的字母，如 i 或 l。

•

避免重复访问键。

使访问键分配保持唯一；重复的访问键会使用户产生混淆。如果绝对有必要，您可以分配一个重复的访问键，但是要确保它不会妨碍用户的键盘操作。一些控件允许输入焦点在相同范围内的带有重复访问键的控件之间移动，如标准菜单和列表视图控件。

如果标签中没有字符可用，您可以重命名控件或者在标签末尾附加一个用括号括起来的访问键 — 例如，Next (>)。或者，您可以省略一些分配给一些 UI 控件的访问键，这取决于命令的使用频率。

•

不要将访问键用于默认按钮或对话框模板中的按钮。更具体一些注意事项有：

•	不要将访问键分配给 OK、Finish 或 Cancel 命令按钮。OK 或 Finish 通常被分配给 ENTER 键用于对话框默认操作，而 Cancel 被分配给 ESC 键。
•	不要将访问键分配给对话框模板中的按钮（如 OK、Cancel 和 Apply 按钮）。不允许它们与特定页面上的那些控件冲突。

将这些按钮按对话框的 TAB 键顺序定位，或将默认和取消操作分配给 ENTER 和 ESC，是可以接受的解决方案。

带下划线的访问键

在 Microsoft Windows 2000 之前的 Windows 版本中，带下划线的访问键在任何时候都可见。在 Windows 2000 和以后的版本中，如果用户不使用它们，就可以将其隐藏。

如果您的应用程序正在使用标准菜单和对话框，这个行为就是自动的。但是，绘制其自己的自定义控件的应用程序（如菜单和对话框）必须适当地显式处理这一点。当您正在决定到哪里为访问键设置下划线时，请牢记下面的情形：

•

设置系统参数以显示访问键的下划线。

用户可以通过控制面板调整下划线的默认设置。如果系统参数指示访问键总是带有下划线的，那么应用程序将始终在访问键下面显示下划线。（默认设置隐藏下划线。）

关于这些设置的更多信息，请参阅 Platform SDK 中的 SystemParametersInfo 函数的 SPI_GETMENUUNDERLINES 或 SPI_SETMENUUNDERLINES 参数。

•

通过使用键盘与菜单或对话框交互。

用户可以做下面的事情：

•	通过按一个键组合（如 ALT、F10 或 SHIFT+F10）调用某一菜单。
•	通过使用鼠标调用某一菜单，但随后使用键盘在菜单间浏览。在用户通过使用键盘与某一菜单交互后，直到菜单关闭为止，所有访问键都必须带有下划线。
•	按一个键来激活另一个控件，如按 TAB 键时将输入焦点移动到另一个控件或按 SPACEBAR 键时选择一个选项控件。下划线必须保持显示，直到用户关闭对话框或容器。

提供可自定义的键盘 UI

要适应不同的可访问性需要，应用程序必须有一个易于自定义的键盘 UI。您可以通过在键盘 UI 中包括下列功能来提供这种可自定义能力：

•

自定义快捷键。

这使用户可以为频繁使用的命令分配新的快捷键。用户也可以更改默认快捷键，以便其不会与辅助技术冲突。

•

自定义菜单。

这些菜单允许用户添加他们自己的命令。另外，它们可以为用户提供一个选择：有多个级别的菜单。

•

用于自定义宏的键盘快捷键。

应用程序可以允许用户为自定义宏分配个人键盘快捷键。从而，用户可以通过使用单一击键执行多个命令。

系统范围控件（如组合框或列表视图）自动支持完整的键盘辅助功能。但是，当您在做下列工作时，确保提供自定义键盘界面：

•	创建自定义窗口类或控件。
•	改变标准窗口或控件的正常行为。
•	在窗口或控件（如对话框）中分配键盘导航。
•	将语音识别技术用于用户输入或命令。
•	通过使用标记语言创建控件。
•	将客户端脚本或插件用于用户输入或命令。

自定义键盘 UI 必须与相似的应用程序的 UI 一致并进行彻底测试。更改过的控件必须支持等同于标准控件行为的键盘行为。

定位并扩展选择

设计良好的键盘 UI 使键盘用户能够做扩展选择，如在一个列表选择两个或更多项或突出显示几段文字。扩展选择的初始点叫做定位点。输入焦点的最终点叫做终点。当用户做出扩展选择时（如通过按住 SHIFT 键并移动光标突出显示一段文字），在定位点和终点间的所有项将会处在选定状态。通常，除非按住 CTRL 键，否则所有其他项将不会被选定。

一个单个可选择控件可能需要支持 SPACEBAR、CTRL + 箭头键或者箭头键。在一个多列表视图控件中，SPACEBAR 键与修改键以及箭头键的组合是选择、输入焦点和定位点导航所需的。

如需更多信息，请参阅对话框和公共控件快捷键。

线性扩展选择示例

用户可以做出的扩展选择的一种类型是线性扩展选择。Windows 资源管理器的详细视图模式是线性或单一维度中的多选列表的一个示例。图 6 展示一个由 5 个文件夹（标记为 A 到 E）组成的多选列表视图。下面的过程阐释当浏览图 6 中展示的列表时，定位点和扩展选择的行为：

1.	通过只选择文件夹 A 定位初始输入焦点。
2.	按向下箭头键。文件夹 A 变成未选定，文件夹 B 变成已选定，并且收到定位点和输入焦点。
3.	按 SHIFT+ 向下箭头键。文件夹 B 保持选定并保留定位点，同时文件夹 C 变成已选定并获得输入焦点。（定位点没有移动，这是因为用扩展选择操作选定了文件夹 C）。
4.	按 CTRL+ 向下箭头键。文件夹 B 和 C 保持选定并且 B 保留定位点。文件夹 D 获得输入焦点。（因为按了 CTRL 键，所以文件夹 D 没有被选定）。
5.	按 CTRL+ 向下箭头键。文件夹 B 和 C 保持选定，文件夹 B 保留定位点，文件夹 E 获得输入焦点。
6.	按 SHIFT+SPACEBAR 以扩展选择。文件夹 B、C、D 和 E 变成选定，文件夹 B 保留定位点，文件夹 E 保有输入焦点。
7.	按 CTRL+SPACEBAR 来取消选定文件夹 E。文件夹 B、C 和 D 保持选定，但是定位点移动到保留了输入焦点的文件夹 E。
8.	按 CTRL+ 向上箭头键两次。文件夹 C 获得输入焦点，文件夹 E 保留定位点，文件夹 B 到 D 保持选定。
9.	按 SHIFT+SPACEBAR。选择从定位点位置（未选定的文件夹 E）扩展到文件夹 C。文件夹 C、D 和 E 变为选定，但是文件夹 B 变为未选定。

列表视图是灵活的，而且与键盘 UI 和辅助技术兼容。虽然多选列表框与扩展选择列表框在视觉上没有区分，您可以考虑将它们设计成显示为所有者描述的复选框的可滚动列表（如图 6 中图像右侧所示）。复选框对键盘用户来说有时更容易浏览和选择。您可以将由公共控件（如 LVS_EX_CHECKBOXES）支持的窗口样式用于列表视图。或者您可以使用 Microsoft Active Accessibility 来包含额外的所有者描述的图形的信息。

atg_keyboardshortcuts_06

图 6. 多选列表

二维扩展选择的示例

用户可以做的扩展选择的另一种类型是二维扩展选择。下面的表阐释一个由 3 行 4 列组成的数组。


(1,1)	(1,2) 定位点：按 CTRL 时，输入焦点开始。	(1,3)	(1,4)
(2,1)	(2,2)	(2,3) Input focus is moved here using CTRL+ arrow keys.	(2,4)
(3,1)	(3,2)	(3,3)	(3,4)

下列过程阐释选择单元格（1，2），并扩展选择以包含单元格（2，3）的两种方法：

•

选择定位点和当前输入焦点（单元格（1，2）、（1，3）、（2，2）和（2，3）将被选定）之间的矩形区域中的所有项。在某行的右边缘没有连接到下一行的左边缘的情况下使用这种方法（比如在表网格控件中）。

•

选择从定位点到当前输入焦点的所有项，按逻辑顺序读取（在以英文编写的对话框中从左到右，从上到下）。单元格（1，2）、（1，3）、（1，4）、（2，1）、（2，2）和（2，3）将被选定。在右箭头键从某行的右边缘折到下一行的左边缘的情况下使用这种方法。对大多数编辑控件来说这是典型的行为，虽然一些控件可能支持与线形扩展选择示例相似的块选定。

非法的多选操作

任何对创建一个不受支持的扩展选择或不连贯选择的尝试（如在一个列表的最后项之外滚动）都必须激活一个生成警告声音的错误事件。此外，当前的选择绝对不能通过操作以任何方式更改。例如，在应用程序中，如果用户在只有两项被允许的时候试图选择第三个项，就必须发生一个错误事件。

一些应用程序忽略旨在使选择扩展或不连贯的修改键。对可用性来说这是很关键的，由于残疾或者项被滚出了视图，用户不能察觉到视觉反馈，因此他们可能没有意识到选择是无意的。

要避免非法多选操作，请遵循这些指南：

•

在列表末端提供反馈。

当用户在一个项列表（如列表视图中的图标，或对话框中的列表控件）中导航时，该用户需要知道它们什么时候已经到达了列表的末端。

如果用户试图在列表中的最后项之外浏览，应用程序绝对不能移动输入焦点，并且必须调用 PlaySound 函数来播放通常发出信号表示无效输入的默认声音。通常，最好在停止时给以反馈。将输入焦点移回到列表中的第一个对象而没有反馈可能会有问题。例如，盲人或低视力用户可能没有意识到它们已经回到了列表的起点。

•

激活警告事件。

只要用户按了一个无效的键或者导航键不能移动输入焦点，应用程序必须激活警告事件。例如，当插入点在一个文本字段的左端并且用户按左箭头键试图将输入焦点移动到字段外时，应用程序必须激活警告事件。当激活该警告事件时，调用 PlaySound 函数来播放默认声音。

提供自动完成

自动完成是当用户从键盘输入一个文本字符串时，自动完成它或者建议可能匹配的文本字符串的一种功能。如果您的应用程序提供自动完成，请确保它符合下列标准：

•	应用程序不应该试图完成一个字符串，除非有足够的信息在可用值或预定义值中标识该字符串。
•	在字符串已经标识之后，字符串剩余的部分应该以一种选定的状态紧接在已经输入的部分之后显示。因此，用户键入的任何其他字符将替换由自动完成功能建议的文字。在该点，将会建议另外的文字。它也能表现得恰如在一个编辑控件中有一个部分选定的字符串一般。

检索键的状态

除非绝对必要，否则请避免使用 GetAsyncKeyState 函数检索一个键或者一个鼠标按钮的状态。GetAsyncKeyState 查询硬件驱动程序来确定物理键或按钮的状态，但是忽略任何被人为按下或被辅助功能模拟的键。

如果可能，您必须使用 GetKeyState 函数，它正确地反映任何模拟输入。不过，可以在某些情况下调用 GetAsyncKeyState，如当用户击一个键来中断一个需时较长的处理任务时。

在处理鼠标拖操作时，您必须避免用 GetAsyncKeyState 函数检测鼠标按钮何时被放开。相反，您必须使用 SetCapture 函数并等待一个键抬起消息。

如果您使用 GetAsyncKeyState 函数，那么结果可能与使用其他 Windows 函数和消息获得的结果不同。这会导致您的应用程序与系统上的其他软件行为不一致。

输入焦点位置

大多数辅助技术需要了解输入焦点的位置。例如，屏幕阅读器用它来确定用户正在使用的文本或对象，屏幕放大实用工具用它来确定要对哪些对象取景并放大。其他实用工具，如屏幕键盘，用它来重新安排窗口以避免覆盖选定的对象。

对辅助功能来说，应用程序既将输入焦点对用户一致显示又将其对开发人员以编程方式显示是很重要的。基于 Windows 的应用程序中的标准控件对输入焦点已经有了相应的支持，而且通常不需要额外工作。但是，所有者描述的自定义控件可能需要额外的工作来公开附加信息或最新添加的行为。

在设计键盘 UI 时，关于输入焦点，请使用下列指导原则：

•	使输入焦点显而易见。以一种明显、直观并且易于看到的方法使输入焦点在视觉上可区分。避免使用不明显的指示器，或者提供一个选项来用高度可视的指示器替换它们。在 Microsoft Windows XP 中，系统输入焦点矩形的大小是可调的，设置值存储在 SPI_GETFOCUSBORDERWIDTH 和 SPI_GETFOCUSBORDERHEIGHT 中。对于自定义控件，调用 DrawFocusRect 函数，或按系统参数设置的大小画线。
•	显示输入焦点指示器。在窗口首次打开或变为活动时，显示输入焦点指示器。关于这个指南的例外情况，请参阅输入焦点例外。
•	只在活动窗口显示输入焦点。当窗口丢失输入焦点时，应用程序必须隐藏任何输入焦点指示器。如果输入焦点到了一个屏幕外的控件，该窗口控件必须滚入一个可以显示输入焦点的视图中。
•	每次只显示一个输入焦点指示器。任何时候输入焦点都只能在一个位置。如果一个窗口有单独的窗格，必须只有一个窗格有输入焦点。其他窗格中的输入焦点指示器必须隐藏。在没有输入焦点的窗口或窗格中显示不活动的选择通常是很重要的。但是该输入焦点指示器必须从不显示在不活动的窗口或窗格中。
•	输入焦点和选择之间的区别。设计您的 UI 从而使输入焦点和选择分别显示 — 即使它们可能通常被链接起来。这允许应用程序在需要时支持多选或不连贯选择，并且能够允许应用程序在没有输入焦点的窗口或窗格中显示不活动的选择。例如，在列表视图中，用一个围绕它的虚线矩形突出显示选定的项。

以编程方式公开输入焦点

Windows 公共控件自动公开输入焦点，但是您必须使用 Microsoft Active Accessibility 来为您应用程序中的自定义控件或窗口内容公开输入焦点位置。使用下列过程来在您的应用程序中以编程方式公开输入焦点：

1.	当输入焦点移动到一个不是整个窗口的对象时，调用 NotifyWinEvent。
2.	当用来查询输入焦点对象时，处理 WM_GETOBJECT 消息。
3.	支持与 Microsoft Active Accessibility IAccessible COM 界面一起显示的自定义 UI 元素的 IAccessible::get_accFocus 属性。有关更多信息，请参阅 Microsoft Active Accessibility

输入焦点例外

在下列情况下，选定的窗口不必显示输入焦点指示器：

•

击键应用于整个窗口区域，如当唯一有效的操作是要激活一个菜单时。

•

窗口第一次打开，只要按 TAB 键就会使输入焦点显示在窗口中的第一个对象上。这在下列情况中不适用：

•	设置了键盘首选项标志。
•	输入焦点正在返回一个窗口，该窗口先前在一个对象上显示了输入焦点。
•	按 TAB 键导致输入焦点移动到窗口中的第二个项。

输入焦点变化

有时扩展或不连续的选择让确定输入焦点位置很困难。您应该考虑输入焦点独立于选择，即便是当它们定位在相同的位置时。下列主题提供有助于阐明这个区别的示例。

文本中的插入条

当用户在文本中移动插入条时，它通常显示为一个被称为系统光标的闪动的垂直条，如图 7 所示。该光标可以被放置在屏幕上的任何位置，做成任何形状或大小，而且如果需要，可以使其不可见。当应用程序画出其自己的插入条，它必须仍不可见地移动光标，跟踪可视指示器的位置和边框。

图 7. 带有闪动光标的文本

Windows 2000 操作系统及更高版本支持系统参数通过 SPI_GETCARETWIDTH 指定光标的宽度。用户可以通过控制面板中的 Accessibility Options 更改设置。绘制其自己插入点的应用程序必须遵循为系统指定的设置。

光标必须从基插入点向选定文本方向加宽。这个方向可能会随编辑框的方向或用户正在键入的语言而改变。在支持从右到左语言的 Microsoft Windows 和 Office 中，一个小指示器显示插入点的方向。

光标必须被调整大小并定位以覆盖屏幕元素的边框，这样屏幕放大工具就能够放大对象的任何部分。这帮助用户和辅助功能工具查找正确的标签和大小。

调整系统光标的大小和形状

1.	调用 CreateCaret 函数来设置焦点大小和形状。
2.	调用 SetCaretPos 函数来将光标移动到可视输入焦点指示器所在的位置，如突出显示的单元格、图标或按钮。
3.	如果需要，调用 ShowCaret 函数来使光标可见。应用程序可以通过不调用 ShowCaret 函数保持光标不可见。
4.	当输入焦点被移动到一个不同大小的对象时，应用程序必须调用 DestroyCaret 函数，并从 CreateCaret 函数重新开始来调整大小并定位其新的输入焦点位置。

当窗口不再是活动的或者没有可视输入焦点指示器时，应用程序必须删除可视指示器并调用 DestroyCaret 函数。

输入焦点和对象选择

当用户作出扩展选择时，选择的一个结尾是活动的或者移动的结尾。这表示最终输入焦点位置。

应用程序必须始终在选择的活动结尾显示一个可见插入点以指示输入焦点位置，如图 8 所示。

图 8. 在选择的活动结尾显示可见插入点的文本

当用户将输入焦点移动到一个对象（如图标或带有有邻近标签的位图）时，应用程序必须定位系统插入标记或在该对象上的不可见光标以及可视指示器。

如果输入焦点是在一组可多选图形对象内，应用程序必须用突出显示指示选定的对象，以及带有虚线的焦点的对象。被选定并有输入焦点的对象必须与其他没有焦点但可能既有突出显示又有虚线属性的选定对象区分开来。要以编程方式定位输入焦点，应用程序必须定位不可见系统光标以覆盖对象。

不连贯选择通常在不连续项中被支持，且有时在一个文档中被支持。输入焦点可以被定位在一个对象上，而且可见输入焦点必须与选择明确地区分开来。选定的项可以被定位在选择内或选择外。

自定义无窗口控件上的输入焦点

当应用程序有一个没有其自己的窗口句柄的自定义控件（如无窗口的自定义命令按钮）时，输入焦点与整个控件关联。一个不可见系统光标必须完全覆盖输入焦点。如果此类控件包含多个表现为单个控件的 UI 组件，那么输入焦点就必须充分定位在单个子组件上。

如果控件有其自己的窗口句柄，可能就没有必要通过使用系统光标来标识位置了。如果控件是一个无窗口控件，则使用来自 Microsoft Active Accessibility 的工具来测试输入焦点。

有关更多信息，请参阅复合自定义控件中的输入焦点和输入焦点验证。

复合自定义控件中的输入焦点

复合控件（如列表框）在更大控件内的单个元素上定位输入焦点。在复合控件中，应用程序必须将输入焦点的位置显示为有输入焦点的元素的边框。即使应用程序可能认为项的集合是一个单一控件，但为了公开输入焦点，每个项必须被作为一个单独的控件元素来处理。

下拉列表是一个典型的带有编辑框和列表框的复合控件。当控件打开下拉列表时，焦点被定位在列表中突出显示的项上，如图 9 所示。

atg_keyboardshortcuts_09

图 9. 下拉列表框

网格控件或电子表格中的输入焦点

在电子表格或网格控件内，输入焦点通常放在一个单元格上，而不是放在在编辑栏中。粗的单元格边框指示输入焦点，而且应用程序必须将输入焦点位置显示为选定单元格上的边框。如果用户开始编辑一个单元格的内容，应用程序必须视内容文字或图形而相应地指示输入焦点。

在只对鼠标设备可用的对象上的输入焦点

虽然应用程序必须提供对所有功能的键盘访问，但是一些对象只能使用鼠标来操作。只要鼠标选择对象而且对象能接收键盘输入，应用程序必须用相应的系统输入焦点显示边框。当输入焦点被移动到可能获取未来键盘输入的另一个对象时，应用程序可以释放输入焦点。

输入焦点验证

有可用于验证输入焦点位置和大小的测试工具。在 Microsoft Active Accessibility SDK 中，Inspect Objects (Inspect.exe) 和 Accessible Event Watcher (AccEvent.exe) 可以被用来测试系统输入焦点的位置和被显示辅助技术的光标。

Microsoft 放大镜也使一个用于检查输入焦点和光标可用性的有用工具，但并不是始终都提供详细的信息。对于官方应用程序测试，建议使用在 Microsoft Active Accessibility SDK 中可用的测试工具。这些工具可以显示来自输入焦点的准确位置和事件。

关于 Inspect Objects 和 Accessible Event Watcher 测试工具的更多信息，请参阅测试工具。关于相关编程接口，请参阅 Active Accessibility 用户界面服务。

用于键盘 UI 的 Windows 系统参数

Windows 操作系统支持许多在应用程序和系统本身之间共享系统范围选项设置的系统参数。应用程序可以通过调用带有指定 SPI 值的 SystemParametersInfo 函数访问系统范围的设置。使用这些设置的应用程序必须监视 WM_SETTINGSCHANGE 消息以响应或充分地调整配置。

有许多键盘 UI — 在操作系统中可用的相关系统参数。，虽然由于大多数系统参数是通过控制面板来控制的，应用程序通常只读取那些设置，但许多系统参数值都有通过 API 的读写过程。系统参数及其相应的 API 名称和描述展示在下表中。

键盘 UI — 相关系统参数
系统参数	SPI 值	描述
键盘首选项	SPI_GETKEYBOARDPREF	获得用户键盘界面首选项的设置。
访问键下划线	SPI_GETKEYBOARDCUES SPI_GETMENUUNDERLINES	获得访问键下划线的设置。获得访问键下划线的设置。
焦点矩形边框	SPI_GETFOCUSBORDERHEIGHT SPI_GETFOCUSBORDERWIDTH	获得焦点边框高度的设置。获得焦点边框宽度的设置。
光标宽度	SPI_GETCARETWIDTH	获得系统光标宽度的设置。
Windows 辅助功能选项和键盘重复率	SPI_GETFILTERKEYS SPI_GETMOUSEKEYS SPI_GETSTICKYKEYS SPI_GETTOGGLEKEYS SPI_GETKEYBOARDDELAY SPI_GETKEYBOARDSPEED	获得筛选键选项的设置。获得鼠标键选项的设置。获得粘滞键选项的设置。获得切换键选项设置。获得键输入的延迟时间的设置。获得键输入重复率的设置。
工具提示	SPI_GETMOUSEHOVERTIME	获得要显示工具提示的延迟时间的设置。

注SPI_GETSERIALKEYS 没有在这里列出，这是因为它只在早期的 Windows 平台（Windows 版本 9.x）中被支持。来自串行键设备的输入必须被应用程序以与接收来自标准键盘或鼠标输入设备的输入相同的方式接收。

关于键盘首选项标志

在键盘首选项标志 (SPI_GETKEYBOARDPREF) 被设置时，通常隐藏一些键盘 UI 元素或省略一些键盘机制的应用程序必须完全显示它们。该标志（由用户在控制面板中设置）忠告应用程序 — 用户对键盘的依赖胜于鼠标，所以在适当的时候必须提供额外的支持。

其他资源

关于 UI 设计和开发的更多信息，请参阅用户界面和 Microsoft Windows 用户体验 (Microsoft Press；ISBN： 0-7356-0566-1)。

关于以名称和类别分类的关于辅助技术工具的更多信息，请参阅搜索辅助技术。

Windows 快捷键

正如在设计键盘 UI 一节中说明的，对应用程序来说，在使用快捷键时与其它应用程序保持一致是很重要的。本节介绍一系列在 Windows 中使用的快捷键。为了与其他基于 Windows 的应用程序一致，建议您以一种相似的方法映射快捷键。如需更多信息，请参阅应用程序通用快捷键。

注本节是关于常用快捷键的概述。如果您通过 Microsoft 终端服务客户端连接到 Windows，视您的配置而定，一些快捷键可能会有变化。一些键盘快捷键可能要求 Microsoft Natural® Keyboard（人体工程学键盘）或者另外的包含 Windows 徽标键 (

和应用程序键 (

)) 的兼容键盘。

系统范围的快捷键

按来

显示或隐藏 Start 菜单。

CTRL+ESC

显示或隐藏 Start 菜单（与

相同）。

CTRL+ALT+DELETE

显示 Windows 安全屏幕或 Windows 任务管理器。

+BREAK

显示 System Properties 对话框。

+D

显示桌面。

+B

将焦点设置在通知上。

+M

最小化所有窗口。

+Shift+M

恢复已经最小化的窗口。

+E

用 Windows 资源管理器打开“我的电脑”。

atg_keyboardshortcuts_11

<![CDATA[XSLT 是什么类型的语言？]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2670 breeze 2005/2/2 13:34:00 分析和概述

Michael H. Kay (mhkay@iclway.co.uk)

2001 年 2 月

XSLT 是什么类型的语言，其用途是什么，为什么要这样设计它？这些问题可以有许多不同的答案，初学者往往会感到困惑，因为这种语言与他们以前习惯使用的语言之间有很大差别。本文尝试说明 XSLT。本文并不试图教您编写 XSLT 样式表，它将说明这种语言的起源，它擅长什么，以及您为什么应该使用它。

我撰写本文的初衷是为一篇关于 Saxon 的技术文章提供必要的背景知识，打算提供在传统 XSLT 处理器中使用的实现技巧内幕，从而帮助用户使其样式表的性能达到最大化。但 developerWorks 的编辑们劝说我：这篇介绍应该吸引更广泛的读者，值得作为 XSLT 语言的独立说明而单独发表。

什么是 XSLT？
XSLT 语言由万维网联盟 (W3C) 定义，并且该语言的 1.0 版本在 1999 年 11 月 16 日作为“推荐书”发布（请参阅参考资料）。我已经在拙作 XSLT Programmers' Reference 中提供了全面的规范和用户指南，因此我不打算在本文中涵盖相同内容。确切地讲，本文的目的只是使读者理解 XSLT 适合大规模事物的哪些位置。

XSLT 的角色
XSLT 的最初目的是将信息内容与 Web 显示分离。如其最初定义那样，HTML 通过按抽象概念（如段落、重点和编号列表）定义显示来实现设备独立性。随着 Web 变得越来越商业化，出版人希望其输出质量能达到与印刷品相同的质量。这逐渐导致越来越多地使用具体显示控件，如页面上材料的明确字体和绝对位置。然而不幸的是完全可以预料其副作用，即将相同的内容传递到替代设备，如数字电视机和 WAP 电话（印刷业的行话再现效果）将会变得日益困难。

由于吸收了印刷业使用 SGML 的经验，在 1998 年初定义了一种标记语言 XML，它用于表示独立于显示的结构化内容。与 HTML 使用一组固定概念（如段落、列表和表）不同，XML 标记中使用的标记完全是用户定义的，其用意是这些标记应该与所关注的对象（如人、地点、价格和日期）相关。尽管 HTML 中的元素本质上都是印刷样式（虽然处于抽象级别），而 XML 的目标是元素应该描述实际对象。例如，清单 1 显示了表示足球锦标赛结果的 XML 文档。

清单 1. 表示足球锦标赛结果的 XML 文档

<results group="A"> <match> <date>10-Jun-1998</date> <team score="2">Brazil</team> <team score="1">Scotland</team> </match> <match> <date>10-Jun-1998</date> <team score="2">Morocco</team> <team score="2">Norway</team> </match> <match> <date>16-Jun-1998</date> <team score="1">Scotland</team> <team score="1">Norway</team> </match> <match> <date>16-Jun-1998</date> <team score="3">Brazil</team> <team score="0">Morocco</team> </match> <match> <date>23-Jun-1998</date> <team score="1">Brazil</team> <team score="2">Norway</team> </match> <match> <date>23-Jun-1998</date> <team score="0">Scotland</team> <team score="3">Morocco</team> </match> </results>

如果要通过 Web 浏览器显示这些足球赛的结果，不要指望系统会产生合理的布局。需要其它一些机制来告诉系统如何在浏览器屏幕、电视机、WAP 电话或真正在纸张上显示数据。这就是使用样式表的目的。样式表是一组说明性的规则，它定义了应如何表示源文档中标记标识的信息元素。

W3C 已经定义了两个系列的样式表标准。第一个是在 HTML 中广泛使用的 CSS（级联样式表），当然它也可以在 XML 中使用。例如，可以使用 CSS 来表示何时显示发票，应支付的总额应该用 16 点 Helvetica 粗体字显示。但是，CSS 不能执行计算、重新整理或排序数据、组合多个源码中的数据或根据用户或会话的特征个性化显示的内容。在这个足球赛结果的例子中，CSS 语言（即使是最新版本 CSS2，尚未在产品中完全实现）的功能还不够强大，不能处理这项任务。由于这些原因，W3C 已着手开发更强大的样式表语言 XSL（可扩展样式表语言），并采纳了 SGML 社区中开发的 DSSSL（文档样式、语义和规范语言）中许多好的构思。

在 XSL 的开发过程中（这在 DSSSL 中已有所预示），发现在准备 XML 文档以备显示的过程中执行的任务可以分成两个阶段：转换和格式化。转换是将一个 XML 文档（或其内存中的表示法）转换成另一个 XML 文档的过程。格式是将已转换的树状结构转换成两维图形表示法或可能是一维音频流的过程。XSLT 是为控制第一阶段“转换”而开发的语言。第二阶段“格式化”的开发工作还是进行中。但实际上，大多数人现在使用 XSL 将 XML 文档转换成 HTML，并使用 HTML 浏览器作为格式化引擎。这是可行的，因为 HTML 实际上只是 XML 词汇表的一个示例，而 XSLT 可以使用任何 XML 词汇表作为其目标。

将转换成一种语言和格式化成另一种语言这两个操作分离经证实的确是一种好的决策，因为转换语言的许多应用程序经证明无法向用户显示文档。随着 XML 日益广泛地用作电子商务中的数据互换语法，对于应用程序将数据从一个 XML 词汇表转换成另一个 XML 词汇表的需求也在不断增加。例如，某个应用程序可能从电视收视指南中抽取电视节目的细节，并将它们插入按次付费客户的月帐单中。同样，还有许多实用的数据转换，在这些转换中源词汇表和目标词汇表是相同的。它们包括数据过滤，以及商务操作，如施行涨价。因此，随着在系统中开始越来越多地以 XML 语法的形式使用数据，XSLT 就逐渐成为由于处理这些数据的随处可见的高级语言。

在拙作中，我做了这样一个比喻：XSLT 与 XML 的关系，就好象 SQL 与表格化数据的关系一样。关系模型的强大功能并非来自用表存储数据的思想，而是源于 SQL 中可行的基于关系运算的高级数据操作。同样，XML 的层次化数据模型对应用程序开发者的帮助实际上也非常小。正是因为 XSLT 作为 XML 数据的高级操作语言提供了如此强大的功能。

XSLT 作为语言
就某些方面而言，XSLT 作为一种语言来说是非常古怪的。我不打算在本文中讨论已做出的设计决策的基本原理，尽管可以通过它们在逻辑上追溯到语言设计者确定的对 XSLT 的要求。如需更完整的说明，请参阅拙作的第 1 章。

以下概述了 XSLT 语言的部分主要特性。

XSLT 样式表是一个 XML 文档。通过使用 XML 的尖括号标记语法来表示文档的结构。这种语法在某种程度上是比较笨拙的，而此决策可以使该语言变得更罗嗦。但是，它确实有好处。它表示可以自动使用 XML 的所有词汇设备（例如，Unicode 字符编码和转义，使用外部实体等等）。它表示很容易使 XSLT 样式表变成转换的输入或输出，使该语言可以作用于自身。它还使将期望的 XML 输出块嵌入样式表变得很容易。实际上，许多简单的样式表基本上可以写作期望输出文档的模板，并且可以将一些特殊指令嵌入文本中，以便插入输入中的变量数据或计算某个值。这就使 XSLT 在这个简单的级别上非常类似于许多现有的专用 HTML 模板语言。

基本处理范例是模式匹配。在这方面，XSLT 继承了文本处理语言（如 Perl）的传统，这种传统可以一直追溯到 1960 年代的语言，如 SNOBOL。XSLT 样式表包括一组模板规则，每条规则都使用以下方式：“如果在输入中遇到此条件，则生成下列输出。”规则的顺序是无关紧要的，当有几条规则匹配同一个输入时，将应用冲突解决算法。然而，XSLT 与串行文本处理语言的不同之处是 XSLT 对输入并非逐行进行处理。实际上，XSLT 将输入 XML 文档视为树状结构，每条模板规则都适用于树中的一个节点。模板规则本身可以决定下一步处理哪些节点，因此不必按输入文档的原始顺序来扫描输入。

XSLT 处理器的操作
XSLT 处理器使用树状结构作为其输入，并生成另一个树状结构作为输出。图 1 中显示了这一点。

图 1. XSLT 输入和输出的树状结构
XSLT 处理器的操作

常常通过对 XML 文档进行语法分析来生成输入树状结构，而输出树状结构通常被串行化到另一个 XML 文档中。但 XSLT 处理器本身操作的是树状结构，而不是 XML 字符流。这个概念最初给许多用户的感觉是不切实际的，结果却对理解如何执行更复杂的转换起了关键作用。首先，它表示 XSLT 处理器可以理解源文档中与树状结构无关的特殊之处。例如，无论属性是包括在单引号中还是在双引号中，都不可能应用不同的处理，因为会将这两种形式视为同一个基本文档的不同表示方法。更深入地看，它表示处理输入元素或生成输出元素是一个原子操作。不可能将处理元素的开始标记和结束标记分成单独的操作，因为一个元素会自动表示成树模型的单节点。

XSLT 使用叫作 XPath 的子语言来引用输入树中的节点。XPath 本质上是与具有层次结构的 XML 数据模型相匹配的查询语言。它可以通过按任何方向浏览树来选择节点，并根据节点的值和位置应用谓词。它还包括用于基本字符串处理、数字计算和布尔代数的工具。例如，XPath 表达式 ../@title 选择当前节点的父代元素的标题属性。XPath 表达式用于选择要进行处理的输入节点、在条件处理期间测试条件，以及计算值以便插入结果树中。模板规则中还使用了 XPath 表达式的简化形式“模式”来定义特定模板规则适用于哪些节点。XPath 在单独的 W3C 推荐书中定义，它允许使用在其它上下文中再使用的查询语言，特别是用于定义扩展超链接的 XPointer。

XSLT 以传统语言（如 Lisp、Haskell 和 Scheme）中的功能性编程的概念为基础。样式表由模板组成，这些模板基本上是单一功能 -- 每个模板将输出树的一部分定义成一部分输入树的功能，并且不产生副作用。使用无副作用的规则受到严格控制（除了转义成用类似 Java 的语言编写的外部代码）。XSLT 语言允许定义变量，但不允许现有变量更改它的值 -- 即没有赋值语句。这个策略使许多新用户感到困惑，其目的是为了允许逐步应用样式表。其原理是如果语言没有副作用，那么对输入文档做很小的改动时，不必从头执行整个转换就应该可以计算出对输出文档的最后更改。目前必须说这只是理论上的可能，任何现有 XSLT 处理器还不能实现。（注：虽然 XSLT 以功能性编程概念为基础，但它还不是一个完整的功能性编程语言，因为它缺少将函数当作一级数据类型进行处理的能力。）

示例样式表
在这个阶段，使用示例会使语言变得更清楚。清单 2 显示了列出足球赛结果的简单样式表。

清单 2. 足球赛结果的基本样式表

<xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <xsl:template match="results"> <html> <head><title> Results of Group <xsl:value-of select="@group"> </title></head> <body><h1> Results of Group <xsl:value-of select="@group"> </h1> <xsl:apply-templates> </body></html> </xsl:template> <xsl:template match="match"> <h2> <xsl:value-of select="team[1]"> versus <xsl:value-of select="team[2]"> </h2> <p>Played on <xsl:value-of select="date"></p> <p>Result: <xsl:value-of select="team[1] "> <xsl:value-of select="team[1]/@score">, <xsl:value-of select="team[2] "> <xsl:value-of select="team[2]/@score"> </p> </xsl:template> </xsl:transform>

这个样式表包括两个模板规则，一个匹配 <results> 元素，另一个匹配 <match> 元素。<results> 元素的模板规则输出页面的标题，然后调用 <xsl:apply-templates>，这是一个 XSLT 指令，它将处理当前元素的所有子代，对于每个子代都使用其适当的模板规则。在本例中， <results> 元素的所有子代都是 <match> 元素，所以会用第二个模板规则来处理它们。规则输出了一个标识比赛的次级 HTML 标题（以 "Brazil versus Scotland" 的形式），然后生成 HTML 段落，给出了比赛的日期和两队的比分。

该转换的结果就是一个 HTML 文档，该文档在浏览器中的表示如图 2 所示。

图 2. 清单 2 中样式表的结果
以上样式表的结果

这是一种非常简单的表示信息的方法。然而，XSLT 的功能比这要强大得多。清单 3 包含了另一个可以操作相同源数据的样式表。这次，样式表计算一个比赛名次表，用来显示锦标赛结束时各队的名次。

清单3. 计算球队名次表的样式表

<xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <xsl:variable name="teams" select="//team[not(.=preceding::team)]"> <xsl:variable name="matches" select="//match"> <xsl:template match="results"> <html><body> <h1>Results of Group <xsl:value-of select="@group"></h1> <table cellpadding="5"> <tr> <td>Team</td> <td>Played</td> <td>Won</td> <td>Drawn</td> <td>Lost</td> <td>For</td> <td>Against</td> </tr> <xsl:for-each select="$teams"> <xsl:variable name="this" select="."> <xsl:variable name="played" select="count($matches[team=$this])"> <xsl:variable name="won" select="count($matches[team[.=$this]/@score > team[.!=$this]/@score])"> <xsl:variable name="lost" select="count($matches[team[.=$this]/@score < team[.!=$this]/@score])"> <xsl:variable name="drawn" select="count($matches[team[.=$this]/@score = team[.!=$this]/@score])"> <xsl:variable name="for" select="sum($matches/team[.=current()]/@score)"> <xsl:variable name="against" select="sum($matches[team=current()]/team/@score) - $for"> <tr> <td><xsl:value-of select="."></td> <td><xsl:value-of select="$played"></td> <td><xsl:value-of select="$won"></td> <td><xsl:value-of select="$drawn"></td> <td><xsl:value-of select="$lost"></td> <td><xsl:value-of select="$for"></td> <td><xsl:value-of select="$against"></td> </tr> </xsl:for-each> </table> </body></html> </xsl:template> </xsl:transform>

这里没有足够的篇幅来完整地说明这个样式表，简而言之，它为球队声明了一个变量，变量值是一个节点集合，其中每个参赛球队都有一个实例。然后它计算每支球队的胜、平或负的比赛场次总数，以及球队进球或失球的总数。图 3 显示了它在浏览器中的最终输出结果。

图 3. 清单 3 中名次样式表的结果
以上样式表的结果

这个示例的目的是说明 XSLT 不单单能够对源文档中出现的文本指定字体和布局。它是一个完整的编程语言，能够以任何方式转换源数据以供显示，或者输入另一个应用程序。

XSLT 的优点
您为什么考虑使用 XSLT？

XSLT 给了您传统高级声明编程语言的所有好处，特别是对于转换 XML 文档的任务。

高级语言带来的实际好处是开发生产力。但实际上，真正的价值源自于更改的潜力。与使用低级 DOM 和 SAX 接口编码的过程性应用程序相比，用于转换 XML 数据结构的 XSLT 应用程序更能适应对 XML 文档细节的更改。在数据库世界中，这种特性叫做数据独立性，正是由于数据独立性导致了诸如 SQL 之类声明性语言的成功，并使旧的引导性数据访问语言走向衰亡。我坚信在 XML 世界中也会这样。

当然与所有声明性语言一样，XSLT 也会降低性能。但是对于大多数应用程序，今天的 XSLT 处理器的性能已经完全能够满足应用程序的需要，并且它会变得越来越好。在我的第二篇文章中，我将讨论 XSLT 处理器中使用的一些优化技巧，如我自己的 Saxon 产品。

结束语
我想要在本文中展示的是 XSLT 是一种用于操作 XML 文档的完整高级语言，就如同 SQL 是操作关系表的高级语言一样。应该注意到 XSLT 不仅是一种样式设计语言，它比 CSS（或者甚至 CSS2）的功能更强大。

我见到过一些应用程序，它们的所有商务逻辑都用 XSLT 编码。在一个三层在线银行系统中，我看到：

从后端操作系统以 XML 消息的形式检索所有数据。
在联机会话的持续时间内，用户的帐户数据在内存中以 XML DOM 形式表示。
所有给用户的信息首先封装成 XML 消息，然后用服务器或客户机附带的 XSLT 转换根据浏览器的性能将这些消息转换成 HTML。

该应用程序的数据都是 XML 格式的，并且逻辑（包括数据访问逻辑、商务逻辑和显示逻辑）都由 XSLT 来实现。我建议每个项目都采用那种体系结构，但这还需要很长时间，我认为我们会在几年之内见到那种系统。

作为一种编程语言，XSLT 有许多特性 -- 从它使用 XML 语法到其功能性编程原理的基础 -- 还不为一般 Web 程序员所熟悉。那意味着一条陡峭的学习曲线和通常遇到许多挫折。当初对于 SQL 也是如此，所有这些表示 XSLT 与以前的编程语言有着本质的区别。但不要放弃：它是功能非常强大的技术，值得努力学习。

参考资料

同一个作者撰写的 Wrox 书籍 XSLT Programmer's Reference。XSLT 语言的综合指南。
W3C 出版的 XSLT 1.0 Recommendation。XSLT 语言的权威性规范。
W3C 出版的 XPath 1.0 Recommendation。XSLT 样式表中使用的 XPath 表达式语法的权威性规范。
XSL-List，一个有关 XSLT 所有事物的繁忙邮件列表，它附带有可搜索档案，由 MulberryTech 进行管理。
www.xslinfo.com，一个很好的网络中央页面，带有到 XSLT 资源的链接，内容包括软件、书籍、教程和其它内容。

关于作者
Michael Kay 在 XML 界非常著名，他是 Saxon XSLT 处理器和 Wrox 书籍 XSLT Programmer's Reference 的作者。多年以前，他就获得了博士学位，他的研究领域是数据库技术。自那时起，他设计了 Codasyl 数据库、关系数据库、面向对象数据库和自由文本数据库软件。

在写作时，Michael 还兼了几份工作（并没有休息）。他刚结束了在 ICL（一家英国 IT 服务公司）24 年的工作，并投奔 Software AG 成为体系结构小组的一员，该小组负责掌控未来 XML 产品的方向。

作者选择这张照片来证明他并非总是象他在 Wrox 书籍中所表现得那样严肃。

]]> <![CDATA[使用XML/HTC/DHTML模拟标准Windows菜单]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2669 breeze 2005/2/2 13:16:37 随着internet的发展，XML作为一种跨平台的通用结构化数据描述语言越来越得到人们的重视，并已经得到了广泛应用，如MicroMedia公司出品的Dreamweaver、Flash以及游戏抢滩登录等软件都利用了XML文件作为数据存储方式，而且Microsoft.NET也是架构在XML上面的。目前出现的取代HTML语言的下一代网页制作语言XHTML（可扩展超文本标记语言），就是建立在XML基础上，因此掌握XML技术是未来网页制作者必备技能。

本文通过一个模拟标准Windows菜单程序来介绍有关XML技术应用。

一、程序原理
考虑到层叠菜单复杂性，为使程序简化，只模拟到二级子菜单。下面我们来看看标准windows菜单过程：鼠标移入菜单时突出显示，移出时回复原状，点击则菜单凹陷显示并打开子菜单，鼠标点击子菜单则完成相应功能。当子菜单打开后移动鼠标，则移入菜单凹陷显示并打开相应子菜单，移出菜单则回复原状并隐藏相应子菜单，若鼠标并不是移动到另外菜单而是在页面其它地方，则移出菜单仍凹陷显示，相应子菜单也不隐藏，只有当在非菜单处点击时才恢复原状并隐藏子菜单。标准Windows菜单一个重要特点就是子菜单打开后，在鼠标移出菜单时并不隐藏或者在文档中非菜单处任意单击时才隐藏。目前很多网页菜单程序都做不到这点，一般都是移入菜单时打开子菜单，移出菜单时隐藏子菜单。采用IE5.0中新提供的鼠标捕获技术就可以完全解决这个问题。所谓鼠标捕获，就是与鼠标相关的所有事件都由设定鼠标捕获的对象进行处理，而无论这些事件是否由该对象触发。

由于xml文档非常适合描述结构化数据，故我们使用xml文档存储菜单及一级子菜单的有关信息。

为便于在其它页面使用模拟标准Windows菜单，我们并不使用代码功能重用性能比较差的外部脚本包含文件方法，而是采用IE 5.0新引入的DHTML行为(Behavior)技术将菜单功能代码封装在一个HTML 行为组件(HTC)内。 HTML行为组件封装了页面上特定的功能或动作，当把某个行为组件附加到页面上的标准HTML元素(对象)时，将增强该元素(对象)的默认功能，使得该元素(对象)含有行为的属性、方法或事件，这使代码重用变得十分容易，并简化了页面的HTML代码，提高了页面的可管理性。

因篇幅所限，有关xml文档及HTML行为组件的更多细节请参阅有关资料，本文不予详述。

二、程序实现

1.主页面(index.htm)
我们首先在主页面中定义充当菜单容器的Div元素，并使用CSS中的behavior属性附加行为组件(Menu.htc)，这样就可以使用元素扩充的属性xmlsrc来指定存储菜单信息的数据文件(Menu.xml)以及使用onMenuClick来捕获组件触发的新事件并调用相应事件处理函数。

此外为简化程序，在主页面中定义了突出(Up_Menu)、凹陷(Dn_Menu)、原状(Menu)三种菜单外观样式，在实际应用时应在组件中定义菜单显示外观，这样更符合组件开发原则。

2.菜单组件(Menu.htc)
模拟标准Windows菜单的功能主要由菜单组件提供。菜单由以下Html元素组成：充当菜单容器的Div元素(在主页面定义)、用于一级菜单项的span元素(初始化菜单时创建)、包含二级菜单项的Div元素(单击一级菜单时建立)、二级菜单项的Div元素(单击一级菜单时建立)。在该组件中定义了用于指定菜单数据文件的xmlsrc属性、点击二级菜单时触发的onMenuClick事件。

当主页面解析完毕后触发ondocumentready事件，组件捕获这个事件并调用事件处理MenuInit()函数初始化一级菜单。当触发鼠标事件时，如onmouseover、onmouseout、onmouseclick等，组件将分别捕获这些事件并调用相应的事件处理函数MenuOver()、MenuOut()、MenuClick()。在这些处理函数中首先通过Event.srcElement属性确定触发事件的对象，然后依据对象type类型(如parentMenu、subMenu或其它)分别做相应处理，如更改菜单显示外观、打开或隐藏子菜单、触发新事件等。

在一级菜单触发有关鼠标事件后，打开二级菜单并通过setCapture()方法对一级菜单对象设置鼠标捕获。此后所有在该菜单或者文档任意位置触发的onmouseover、onmouseout、onmouseclick鼠标事件都由该菜单对象负责处理，但event.srcElement属性仍是触发鼠标事件的对象而不是设置鼠标捕获的对象。当在二级子菜单或文档中非菜单处任意单击时，隐藏二级菜单并通过releaseCapture()方法释放鼠标捕获。

单击二级菜单时，其事件处理函数onmouseclick通过createEventObject方法创建一个event(事件)对象，再通过fire方法触发新事件，并利用event对象的有关属性传递信息(如event.menuId返回所选定的菜单ID)，然后由容器捕获这个事件，并调用相应事件处理函数HanderSubMenu ()。在主页面中定义函数HanderSubMenu ()能够使菜单组件更具通用性。

3.菜单数据文件(Menu.xml)
Item节点存储一级菜单信息，SubItem节点存储二级菜单信息，每个节点都含有两个属性：value(菜单ID)、name(菜单名称)。

该程序必须在IE5.0及以上版本浏览器运行，运行结果如图。怎么样？象不象标准Windows菜单。

附：模拟标准Windows菜单源代码(在Win98+IE5.0下通过)

附：模拟标准Windows菜单源代码(在Win98+IE5.0下通过)

index.htm文件：

<Html> <Head> <Title>菜单组件示例</Title> <style>  </style> <script> function HanderSubMenu(){//选择子菜单后相应处理 switch(event.menuId){ case event.menuId: alert(event.menuId); break; } } </script> </Head> <Body style="background-color:#CCCCCC;"> <TABLE style="font-size:12px;"> <TBODY><TR height="10" > <TD Align="center" height=25 style="border-top:2px groove;border-bottom:2px groove;"> <div id="Menu" style="behavior:url(Menu.htc)" xmlsrc="Menu.xml" onMenuClick="HanderSubMenu()"></div> </TD> </TR> </TBODY> </TABLE> </Body> </Html>

Menu.htc文件：

<PUBLIC:COMPONENT> <PUBLIC:PROPERTY Name="xmlsrc" PUT="putxmlsrc"/> <PUBLIC:EVENT Name="onMenuClick" ID="menuClick" /> <PUBLIC:ATTACH EVENT="ondocumentready" For="element" ONEVENT="MenuInit()" /> <PUBLIC:ATTACH EVENT="onmouseover" for="element" ONEVENT="MenuOver()" /> <PUBLIC:ATTACH EVENT="onmouseout" for="element" ONEVENT="MenuOut()" /> <PUBLIC:ATTACH EVENT="onclick" for="element" ONEVENT="MenuClick()" /> <Script language="JavaScript"> var xmldoc=null;// xml文档对象变量 var activeMenu=null;//打开子菜单的父菜单对象变量 var menuContainer=null;//包含子菜单项容器对象变量 function putxmlsrc(str){//载入菜单数据文件 xmldoc= new ActiveXObject("Microsoft.XMLDOM");//创建xml文档对象 xmldoc.async=false; xmldoc.load(str);//载入菜单数据 } function MenuInit(){//初始化菜单 var parentMenuItems = xmldoc.selectNodes("//Itemlist/Item"); //读取一级菜单数据 var xmlElement = parentMenuItems.nextNode(); var newElement; while (xmlElement != null){ newElement = document.createElement("span"); //创建菜单元素 newElement.type = "parentMenu"; with (newElement){ innerHTML = xmlElement.getAttribute("name"); id=xmlElement.getAttribute("value"); className="Menu"; } with (newElement.style){ position="relative"; width= 60; cursor="default"; } element.appendChild(newElement); //element指附加行为的元素 xmlElement = parentMenuItems.nextNode(); } } function MenuOver(){ var EventSource=event.srcElement;//捕获触发事件的对象 switch(activeMenu){//判断子菜单是否存在 case null://不存在子菜单 if(EventSource.type=="parentMenu")EventSource.className="Up_Menu"; break; default: switch(EventSource.type){//判断触发事件对象类型 case "parentMenu"://移入到一级菜单 if(activeMenu!=EventSource){//判断是否移入到新一级菜单 removeSubMenu();//删除原有子菜单 buildSubMenu(EventSource.id);//建立新子菜单 EventSource.setCapture();//对新菜单设置鼠标捕获 activeMenu.className="Menu"; activeMenu=EventSource; //更新打开子菜单的父菜单对象变量 activeMenu.className="Dn_Menu"; } break; case "subMenu"://移入到子菜单 EventSource.style.color="#FF0000"; EventSource.style.textDecoration="underline"; break; } break; } } function MenuOut(){ EventSource=event.srcElement switch(activeMenu){ case null: if(EventSource.type=="parentMenu")EventSource.className="Menu"; break; default: if(EventSource.type=="subMenu"){ EventSource.style.color="#000000"; EventSource.style.textDecoration="none"; } break; } } function MenuClick(){ EventSource=event.srcElement switch(EventSource.type){ case "parentMenu": if(activeMenu!=EventSource){ removeSubMenu(); buildSubMenu(EventSource.id); EventSource.setCapture(); EventSource.className="Dn_Menu"; activeMenu=EventSource; } break; case "subMenu": removeSubMenu(); activeMenu.className="Menu"; activeMenu.releaseCapture();//释放鼠标捕获设置 activeMenu=null; var eventObject = createEventObject();//创建事件对象 eventObject.menuId = EventSource.id;//通过事件对象属性传递所选子菜单ID menuClick.fire(eventObject);//将事件触发到容器页面 break; default: removeSubMenu(); if(activeMenu!=null){ activeMenu.releaseCapture(); activeMenu.className="Menu"; activeMenu=null; } break; } } function buildSubMenu(EventSourceid){//建立子菜单 menuContainer = document.createElement("div"); with (menuContainer.style){ position="absolute"; left=0; top=15; color="#000000"; cursor="default"; } eval(EventSourceid).appendChild(menuContainer); var subMenuItems = xmldoc.selectNodes("//Item[@value='"+EventSourceid+"']/SubMenu"); var xmlElement = subMenuItems.nextNode(); var newElement; while (xmlElement != null){ newElement = document.createElement("div"); newElement.type = "subMenu"; with (newElement){ innerHTML ="□ "+xmlElement.getAttribute("name"); id=xmlElement.getAttribute("value"); } with (newElement.style){ width=75; height=18; } menuContainer.appendChild(newElement); menuContainer.className="Up_Menu"; xmlElement = subMenuItems.nextNode(); } } function removeSubMenu(){//删除子菜单 if(menuContainer!=null)menuContainer.removeNode(true); } </Script> </Component>

Menu.xml文件：

<?xml version="1.0" encoding="gb2312" ?>//xml处理指令指明为中文编码,若不指明则不支持中文 <Itemlist> <Item value="file" name="文件" > <SubMenu value="New" name="新建"></SubMenu> <SubMenu value="Open" name="打开"></SubMenu> <SubMenu value="Save" name="保存"></SubMenu> <SubMenu value="Print" name="打印"></SubMenu> <SubMenu value="Exit" name="退出"></SubMenu> </Item> <Item value="Edit" name="编辑" > <SubMenu value="Cut" name="剪切"></SubMenu> <SubMenu value="Copy" name="复制"></SubMenu> <SubMenu value="Paste" name="粘贴"></SubMenu> <SubMenu value="Del" name="删除"></SubMenu> </Item> <Item value="Help" name="帮助"> <SubMenu value="Topic" name="主题"></SubMenu> <SubMenu value="About" name="关于"></SubMenu> </Item> </Itemlist>

关于作者
刘筱，对Dhtml、Xml有浓厚兴趣，在中国《微电脑世界》发表有关Dhtml应用文章多篇。可以通过 liuswin@hotmail.com与作者联系。

]]> <![CDATA[XHTML：两种语言的力量]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2667 breeze 2005/2/2 12:56:27 可扩展超文本标记语言是用 XML 对 HTML 4 的改良

Sathyan Munirathinam（sat_hyan@yahoo.com）
软件工程师，Aztec Software
2002 年 7 月

本文从实用角度对 XHTML 进行了研究，它是有效地结合 HTML 的简单性和 XML 的可扩展性的一种标记语言。本文还涵盖了各种风格的 XHTML 的基本特性，并包括对语言和大量实际应用程序的讨论。

作为一名 Web 开发人员是项很艰苦的工作。您不仅必须每天避开流行浏览器引起的陷阱和缺陷，还必须至少留意可能（或不可能）对您的工作产生影响的众多技术上的新发展。您可能刚刚掌握了样式表和 DHTML，而新的技术又要求您关注。您需要立刻学哪一个呢？现在可以放弃哪一个呢？随着可扩展超文本标记语言（Extensible Hypertext Markup Language，简称 XHTML）的出现，最终可能让传统的 HTML 马放南山了。

XHTML 概述

XHTML 是 HTML 和 XML 的混合物，它是为网络设备显示（包括 Web 浏览器、PDA 设备和移动电话）而特别设计的。2002 年 1 月 26 日标志了 XHTML 1.0 作为 Web 标记的正式 W3C 推荐的第二个生日。但是，XHTML 仍然要蹒跚学步，学着用微笑和大喊大叫来引起大多数 Web 设计人员的注意。

W3C 主管 Tim Berners-Lee 这样评价 XHTML：“XHTML 1.0 连接了现在的 Web 和将来的 Web …… 它为页面和网站作者提供了进入结构化数据 XML 世界的桥梁，同时仍然能够保持与支持 HTML 4 的用户代理的可操作性。"

XHTML 是非常严格的标记语言。它的规则很简单，并且事实上，它的可扩展性很小 — 即，不能编写您自己的定义来表示语言如何动作；您必须遵循其规则。XHTML 1.0 采用 HTML 4.0 中引入的概念，这些概念在其生效之前，需要按结构化的和方法论的行为进行处理。

XHTML 可以与级联样式表（CSS）一起使用以完成显示目的。XHTML 还允许您将可扩展样式表（Extensible Stylesheet Language (XSL)）用于转换。通过使用这个基于 XML 的样式技术，您实际上可以将一个文档从一种类型转换成另一种类型 — 例如，从 HTML 文档转换成 PDF 文档。

为什么要使用 XHTML？

通常，您可能为新增功能或者因为已经修正了以前版本的问题而将技术更新到新的版本。但就标记功能而言，XHTML 是非常类似于 HTML 4 的副本，所以不要期望存在任何新奇的标记。

W3C 声称 XHTML 的主要优点是可扩展性和可移植性：

可扩展性

XML 文档要求格式良好（元素嵌套正确）。使用 HTML，添加新的元素组需要更改整个 DTD。在基于 XML 的 DTD 中，新的元素组只需要内部一致并且格式良好，就可以添加到现有的 DTD 中。这极大地简化了新元素集合的开发和集成。

可移植性

越来越频繁地使用非台式设备来访问因特网文档。在大多数情况下，这些设备不具备台式计算机的计算能力，并且不象标准桌面浏览器那样可适用于格式差的 HTML。实际上，如果这些非桌面浏览器没有接收到格式良好的标记（HTML 或 XHTML），它们可能根本无法显示文档。

XHTML 文档结构

XHTML 文档由三个主要部分构成：

DOCTYPE
Head
Body

基本文档结构是：

<!DOCTYPE ...> <html ... > <head> ... </head> <body> ... </body> </html>

<head> 区域包含关于文档的信息，如所有权、版权和关键字；而 <body> 区域包含要显示的文档内容。

清单 1 向您显示实际中如何使用这个结构：

清单 1. XHTML 示例

1. <?xml version="1.0"?> 2. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "DTD/xhtml1-transitional.dtd"> 3. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> 4. <head> <title>My XHTML Sample Page</title> </head> 5. <body bgcolor="white"> <center><h1>Welcome to XHTML !</h1></center> </body> 6. </html>

第 1 行：由于 XHTML 是以 XML 文档表示的 HTML，所以它必须在文档的顶部包括初始 XML 声明 <?xml version="1.0"?>。

第 2 行：XHTML 文档必须由三组标准规则的其中一组来标识。这些规则存储在一个称为“文档类型声明（Document Type Declaration (DTD)）”的单独文档中，并且使用这些规则验证 XHTML 文档结构的准确性。准确地说，DTD 的目的是描述 XHTML 中允许的语言和语法。

第 3 行：XHTML 文档中的第二个标记必须包括带有由 xmlns=http://www.w3.org/1999/xhtml 属性标识的 XML 名称空间的开始 <html> 标记。XML 名称空间标识 XHTML 文档使用的标记的范围。它用来确保一个 DTD 使用的名称不与用户定义的标记或其它 DTD 中定义的标记冲突。

第 4 行：XHTML 文档必须包括完整的头部区域。这个区域包含开始 <head> 标记和标题标记（<title></title>），然后以结尾 </head> 标记结束。

第 5 行：XHTML 文档必须包含开始和结尾 <body></body> 标记。在这些标记中，您可以放置传统的 HTML 编码标记。要与 XHTML 符合，这些标记的编码必须是格式良好的。

第 6 行：最后，使用结尾 </html> 标记结束 XHTML 文档。

XHTML DTD

在创建 XHTML 文档时，在该文档的顶部声明了它应符合的 DTD。每个 DTD 可能由一个称为正式公共标识（Formal Public Identifier，简称 FPI）的唯一标号识别。字 PUBLIC 后面的文字文本或引用文本是表示 W3C 的 XHTML 1.0 DTD 的 FPI。

目前，有三种 XHTML 文档类型：

Strict
Transitional
Frameset

Strict DTD

<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "DTD/xhtml1-strict.dtd">

当您想要真正清晰的标记、避免表示上的混乱时，将此与 CSS 一起使用。已经从该语言中除去了几个标记（如 <center>），甚至还除去了其它标记的某些属性（如 H1 标记的 align 属性）。

Transitional DTD

<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "DTD/xhtml1-transitional.dtd">

当您需要利用 HTML 的表示特性时，使用它；您的许多读者都没有能理解 CSS 的最新浏览器。过渡的 DTD 支持大部分标准的 HTML 4 标记和属性。

Frameset DTD

<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "DTD/xhtml1-frameset.dtd">

这使您能够使用 HTML 框架将浏览器窗口分成两个或更多框架。这个 DTD 保存框架集定义。

XHTML 验证规则

XHTML 文档必须是格式良好的 XML。它必须符合基本 XML 语法：

必须用小写书写标记和属性名称。

HTML XHTML

<TD BGCOLOR="#ffcc33"> <td bgcolor="#ffcc33">

元素必须嵌套；而不能交错。对于 XML 和 XHTML，您需要以逆序关闭标记 — 换言之：后开先关。

HTML XHTML

<p>Be <b>bold!</p></b> <p>Be <b>bold!</b></p>

所有非空元素必须是关闭的。例如，对于 HTML，许多人使用 <p> 标记分段。这个标记设计用于标记一段的开始和结尾（使用结尾 </p> 标记）。这使它成为非空标记，因为它包含段文本。

HTML XHTML

First paragraph<p> Second paragraph<p> <p>First paragraph</p> <p>Second paragraph</p>

受影响的元素：<basefont>、<body>、<colgroup>、<dd>、<dt>、<head>、<html>、<li>、<p>、<tbody>、<thead>、<tfoot>、<th>、<td> 和 <tr>。

必须终止空元素。所有空元素必须使用 XML 空标记语法，在右括号前有一个结尾的正斜杠（例如，<br> becomes <br />）。请注意元素文本后面的空格和结束定界符 />。这是为了与当前浏览器兼容。

HTML XHTML

<hr> <hr />

<br> <br />

<input ... > <input ... />

<param ... > <param ... />

<img src="valid.gif"> <img src="valid.gif" />

受影响的元素：<area>、<base>、<br>、<col>、<frame>、<hr>、<img>、<input>、<isindex>、<link>、<meta>、<option> 和 <param>。

属性值必须加引号。不再有 <img ... border=0> 了。现在，您需要给每个属性加引号，即使它是数字。

HTML XHTML

<img ... border=0> <img ... border="0" />

不能最小化属性值对。不允许单独属性（也称为最小化的属性）。例如，<option selected> 不再有效了。而您必须使用 <option selected="selected">。

内联标记不能包含块级别标记。例如，锚点标记不能括起表。

脚本编制元素引起了 XHTML 兼容性问题。XML 解析器将脚本解析成 XML 文档，除非您将脚本封装入 CDATA 块中。因此，JavaScript 元素现在将类似于：

<script type="text/javascript"> <![CDATA[ alert("hello"); ]]> </script>

这对于大多数的当前浏览器来说，可能都有问题，因为它们不喜欢 CDATA 块。目前，唯一的解决方案是从外部文件调用 JavaScript。例如：

<script language="JavaScript" type="text/javascript" src="main.js"></script>

对于服务器端程序员，当动态修改 JavaScript 时，这会产生问题。对您的 JavaScript 使用独立的文件源会阻止您动态地更改 JavaScript。因为 JavaScript 包括在客户机端，所以服务器端不能接触到它。当使用 ASP、JSP 或 PHP 脚本编制修改 JavaScript 时使用脚本声明的标准 HTML 方法。这正是在使 JSP 或 ASP 100% 与 XHTML 兼容时最可能产生问题的地方。不过，请记住，目的并不是与 XHTML 100% 兼容，而是在可行的情况下开始结合 XHTML，使得需要时允许快速和简单的过渡。那时，应该可以使用新的兼容浏览器，您将开始跨越到 100% 兼容性。

代替 CHTML 和 WML 的 XHTML Basic

对于想创建网站移动版本的开发人员来说，根本问题是他们当前必须用 HTML 将页面格式化以便进行桌面浏览，对于 WAP 设备，可以用无线标记语言（Wireless Markup Language (WML)）；对于 iMode 设备可以用压缩 HTML（Compact HTML (CHTML)）。这已经产生了一个新的行业，致力于将现有的网站转换成 WML 或 CHTML。WML 基于 XML，并且取代了快过时的手持设备标记语言（Handheld Device Markup Language (HDML)），而 CHTML 是基于 HTML 的。虽然这些标记语言很相似，但它们之间的区别使得 WAP 和 iMode 设备都不能看见 Web 页面。而所有设备都将理解 XHTML Basic，并且它将成为一种通用标记语言。

可以获取多种格式的完整 XHTML Basic 英文规范（请参阅参考资料），这些格式包括 HTML、纯文本、PostScript 和 PDF。可以预见 XHTML Basic 代替诸如 HDML 和 WML 的语言将是不可避免的。但是，重要的是记住 WML 和 HDML 还定义操作和内容。目前，这些在 XHTML 中还没有等价定义。因此，至少在短期内，WML 和 HDML 将不会消失。看谁会最终胜出将很有意思。在某种程度上计划支持所有这三种标记语言。

XHTML 中的未来工作

XHTML 中仍在开发的一方面是设备概要，也称为复合能力首选项概要文件（Composite Capability Preference Profiles (CCPP)）。CCPP 允许诸如移动电话之类的设备向 Web 服务器标识自己、描述其限制并只下载其能够显示的信息。因为可以将 XHTML 文档分割成能够被单独下载的多个模块，所以 CCPP 能起作用。

W3C 正在与 WAP Forum 等合作开发 CCPP。2001 年夏季，开始 XHTML 2.0 开发，它是结合 HTML 和 XML 的最后一步。XHTML 2.0 是前瞻性的，因为它是几种 XML 技术的结合体，例如 XLink、XPointer、XPath 和 XInclude — 所有这些技术当前处于开发过程中或者最近由 W3C 发布（请参考资料中的路标）。

结束语

XHTML 开辟了 Web 的新领域，为作者提供了在其 Web 页面上混合和匹配各种基于 XML 的语言和文档的方法。它还为非传统 Web 访问设备（从烤箱到电视机）提供了框架以向 Web 服务器标识它们自己及其能力，只要下载那些设备能显示的信息。多亏有了 XHTML，您可以继续使用您已经熟悉和喜爱的 HTML 编写。可能只需要稍微整理一下。我猜测 XHTML 2.0（请参阅参考资料）将具体地整理 HTML 标记及其用法。

总之，XHTML 简化了可以让各种新设备浏览的文档的创建。另外，经过少许学习，您可以创建比以往功能强大得多的页面。最后，XHTML 是通向 XML — 因特网的未来语言的桥梁。

请通过单击本文顶部或底部的讨论来参与本文的论坛。
查看 W3C XHTML 1.0 规范，它将 HTML 4 的改造定义成一种 XML 1.0 应用程序，并且定义了三个与 HTML 4 定义的 DID 相应的 DTD。
查看 XHTML.org 以获取关于 XHTML 的新闻和信息。
请阅读 XHTML 的简介和概述，它包括对 XHMTL 和 HTML 4 之间区别的说明。
查找关于 XHTML Basic 的更多信息。
查看 HTML Working Group Roadmap，它描绘了 XHTML 未来发展的清晰蓝图，包括关于 XHTML 2.0 的信息。
查看 Encyclozine.com，它是用 XHTML 构建的站点示例。
要验证 XHTML 页面，请尝试 W3C HTML 验证服务。
在 developerWorks XML 技术专区中查找更多 XML 参考资料。
在 developerWorks 网站架构主题中查找更多 Web 参考资料。
获取 IBM WebSphere Studio Application Developer，它是一个易于使用的集成开发环境，用于构建、测试和部署 J2EE 应用程序，包括从 DID 和模式生成 XML 文档。
查看如何成为 XML 和相关技术的 IBM 认证开发人员。

关于作者
author Sathyan Munirathinam 拥有 Madurai Kamaraj 大学计算机科学学士学位和计算机应用硕士学位。作为 Aztec Software 的一名软件工程师，他有两年多的信息技术工作经验。他的专业兴趣是数据库系统和联网，他的个人兴趣是阅读技术期刊，入侵网络系统和打板球。可以通过 sat_hyan@yahoo.com 与他联系。

]]> <![CDATA[XHTML 1.0：标记新的开端]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2665 breeze 2005/2/2 12:15:22 新标准的 -- 熟悉 -- 和入门

Molly Holzschlag
作家、讲师及 Web 设计人员
2000 年 10 月

还在用 HTML 编写文档？如果是的话，就不符合当前标准了。2000 年 1 月 26 日，XHTML 1.0 成为万维网联盟 (W3C) 的建议。根据 W3C，HTML 不再是 Web 标记标准。取而代之，XHTML 1.0 已替代旧宠儿，标志着通信技术令人兴奋的新时代已经来临。

那么，XHTML 1.0 到底是什么？对 Web 开发人员来说，它意味着什么？下面从 W3C 的描述讲起：XHTML 1.0 是 XML 应用程序的 HTML 再形成。这意味着，如果用 XHTML 1.0 编制文档，则将 XML 固有的规则和概念应用到 Web 标记。很自然，还有个摇摆的问题：现在可以用 XHTML 1.0 标记 Web 文档吗？答案很明确：“是的”。所要做的全部只是学会正确组织文档结构，选择所需的正确文档类型定义 (DTD)，以及学会几种管理代码开发的新方法。

但是，XHTML 1.0 怎么会如此轻易上手呢？在编写文档时，您将看到，它使用您所熟悉的 HTML 作为其词汇。在方法上有较小的变化，而在思路上有主要的不同，XHTML 1.0 允许 Web 作者依据标准进行编码，并开始改变有关未来发展和更改的观点。

为什么需要另一种标记语言？
HTML 使用起来相当好。确实，我们一直受到提出确实管用的跨浏览器、跨平台解决方案的挑战。但是，在 Web 从 90 年代的早期形式发展到今天我们所知的充满活力的活动 Web 的过程中，也意味着在前进途中消耗、破坏甚至制造了新的 HTML 规则。

学过 HTML 4.0 准则的开发人员都知道，在 HTML 4.0 标准出现时，已经确定了改进 HTML 准则的最终目标。HTML 4.0 的一些主要考虑包括：

通过将基本格式化与样式分离，来整理文档
反对使用随心所欲或有问题的元素
要求声明文档类型（并希望在声明中，作者遵循 HTML 4.0 的三个 DTD 中的规则）

这些原则都在 XHTML 1.0 中存在，但是它们与 XML 中的概念组合在一起，这些概念帮助改进标记超出只加强其基本语法的作用。XHTML 1.0 的目标很多，但是，包括以下几个：

提供 Web 标记中可扩展性的基础
通过过去、现在和将来的浏览器，提供相同或更好的互操作性
通过即将来临的 XHTML 版本、其它 XML 应用和刚刚出现的技术（如无线和新型设备开发），使作者为不断发展的机遇作好准备。

采用 XHTML 1.0 最有说服力的理由恐怕是：开发人员（特别是通过 HTML 自学、或依靠可视设计工具来实现其目标的开发人员)可以通过学习该标准，来轻易地移至其它 XML 应用。然后，他们就可以看到 XML 和可扩展性的力量。因为过程相似：即 HTML 词汇加上一些新的结构和语法方法，所以，XHTML 1.0 使 XML 及其应用的领域不再令人畏惧。

通过使用熟悉的语言和一些新的概念，很容易转入不太熟悉的领域。例如，XHTML 1.0 的知识可以简化转移到即将出现的 XHTML 版本以及无线和其它应用的相关 XML 技术的过程（如 WML（无线标记语言）、SMIL（同步多媒体语言）和 SVG（可伸缩矢量图形））。

探询根源
探询 XHTML 根源有助于理解 XHTML 的基本原理及指引它的规则。XML 和 HTML 的根源相同，都是 SGML，即标准通用标记语言 (Standardized General Markup Language)。有一点很重要：SGML 本身不是一门语言。它是人们所知的元语言 -- 即包含开发其它语言所依据规则的语言。

XML 与其根源 SGML 一样，也是元语言。正如这样，其规则用于创建 XML 应用。而 XHTML 是将另一门 SGML 语言，HTML，用作其词汇的 XML 应用。

如果关系看起来有些复杂，那是因为它确实有些复杂。SGML 首先产生 HTML，然后是 XML。当觉察到 HTML 的担心和限制时，XML 规则就很明显地可以使 HTML 成长为帮助开发人员脱离这些限制的标记语言。

首先，需求
为了使 XHTML 1.0 文档符合其元语言 (XML)，必须考虑几个需求和规则。如下所示：

建议、但不要求使用 XML 声明将 XHTML 1.0 文档声明成 XML 文档。
要求 XHTML 1.0 文档包含一个 DOCTYPE，指明这是 XHTML 1.0 文档，并指出该文档所用的 DTD。
XHTML 1.0 文档有一个根元素 <html>。该 HTML 元素的开始标记应该包含 XML 名称空间 xmlns 和该名称空间的合适值。
文档的语法和结构必须符合 XHTML 语法规则。

实现该目标的第一步是正确组织 XHTML 1.0 文档的结构。将从添加正确的声明和文档信息开始。

文档声明、类型和名称空间
XHTML 1.0 文档可以包含几个结构元素，以便被认为是正确的：一个 XML 声明、一个 DOCTYPE 声明，并包括名称空间。XML 声明允许作者将其文档声明成 XML，并包括文档所用的编码。

<?xml version="1.0" encoding="UTF-8"?>

如前面提到的，建议使用此声明，但这不是必需的。不强制使用的部分原因是：如果使用，则某些浏览器（包括 IE 4.5 for Mac 和 Netscape 4.0 for Windows）将显示不正确的 XHTML 页面。因此，大多数对互操作性感兴趣的 XHTML 1.0 作者不使用它。但是，因为编码信息在很多情况下很重要（特别在使用国际化文档时），所以，如果不使用 XML 声明，则鼓励在 meta 标记中添加编码信息（在后面的清单 2 中显示）。

在 XML 文档声明的下面 - 如果选择不使用它，则位于文档顶部 - 必须放置 DOCTYPE 声明。DOCTYPE 允许作者声明所用的文档类型。在本例中，文档类型是 XHTML 1.0，该文档要符合的特定 XHTML 1.0 DTD 为 strict。

XHTML 1.0 中只有三种 DTD。它们来自 HTML 4.0，其内容如下：

Strict：Strict 遵循最严格的 XHTML 规则。在以该类型编写的文档中，只允许出现当前元素、属性和字符实体。不允许出现 HTML 4.0 所反对的元素（如 font 或 center）。也不允许过时的元素。Strict 声明如下：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

Transitional：transitional XHTML 1.0 文档更宽容一些，它允许作者使用所反对的和当前的方法。可以在 transitional 文档中使用 font 或 center，或任何其它所反对的标记，只要文档本身标记正确即可。不应该使用过时的元素。如果在用 XHTML 1.0 编写 transitional 文档，将包括以下声明：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

Frameset: frameset DTD 只为 frameset 文档保留。符合该 DTD 的 frameset 文档可以使用 strict 或 transitional 标记。要以 XHTML 1.0 创建 frameset 文档，在文档顶部包括这个 DOCTYPE：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">

确定了是否使用 XML 声明，并且添加了定义要遵循的标记规则的 DOCTYPE 声明之后，需要将 HTML 根添加到文档，并相应设置 XHTML 名称空间：

<html xmlns="http://www.w3.org/1999/xhtml">

此时，要添加一些必需的结构元素，如 head、title 和 body。清单 1 显示包括 XML 声明的 XHTML 1.0 transitional 文档外壳。在清单 2 中，将看到不带 XML 声明的 transitional 文档，但是，有一个 meta 标记来声明所用字符集。

清单 1：带有 XML 声明的 Transitional DTD 格式的 XHTML 1.0 文档

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Transitional Document with XML Declaration</title>
</head>
<body>

</body> </html>

在清单 2 中，将看到不带 XML 声明的 transitional 文档，但是，有一个 meta 标记来声明所用字符集。

清单 2：不带 XML 声明的 Transitional DTD 格式的 XHTML 1.0 文档

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Transitional Document without XML Declaration</title>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
</head>
<body>

</body>
</html>

语法事项
一旦 XHTML 文档包含必需的声明和结构信息，就可以检查由 XML 在 Web 标记上的影响而导致的语法更改。这些语法更改包括是否区分大小写、正确格式的标记元素、空和非空元素，以及引号的使用。

大小写
如您所知，HTML 不区分大小写。这意味着，HTML 元素和属性名称可以是大写、小写或大小写混合的。因此，可以写成：

<body background="my.gif">

或

<BODY BACKGROUND="my.gif">

甚至

<BoDy background="my.gif">

所有这些示例的功能相同。另一方面，XML 却是区分大小写的。因此，XHTML 要求有特定的大小写。在 XHTML 1.0 中，所有元素和属性名称必须是小写的：

<body background="my.gif">

除元素和属性名称之外，其它不必遵循 XHTML 1.0。请注意，属性值（例如 "my.gif"）可以是大小写混合的。如果文件所在服务器的文件系统是区分大小写的，或者在应用中使用大小写混合的代码（例如那些用 Microsoft 的活动服务器页面 (ASP)、ASP+ 或 ColdFusion 编写的代码），则尤其如此。

良好的格式
虽然很多 HTML 浏览器很宽容，但是，很多 HTML 工具不符合标准。就这样，某些作者养成了坏习惯，如不正确的标记嵌套。下例在很多浏览器中可以使用：

<b><i>Welcome to MySite.Com</b></i>

在宽容的浏览器中，它将显示粗体和斜体。但是，如果拿起笔来，从粗体的开始标记到其结束标记画一个弧，然后，再从斜体的开始标记到其结束标记画一个弧，将看到，两条弧线相交。这展示了不正确的标记嵌套，我们认为，这是坏格式。

在 XHTML 1.0 中，不接受这样的坏格式标记。必须在“每个元素必须正确嵌套”方面符合良好格式的概念。前面示例用 XHTML 1.0 表示为：

<b><i>Welcome to MySite.Com</i></b>

现在，再画弧，将看到，弧线不再相交。这些标记以正确顺序放置，并被认为是正确的格式。

非空和空元素
非空元素包含一个元素和一些内容：

<p>This is the content within a non-empty element.</p>

相反，空元素没有内容，只有元素及其属性，如 <hr>、<br> 和 <img>。

XML 规则指出，空元素和非空元素必须完全关闭。在 HTML 中，可以看到非空元素通常有一些可选的结束标记。上段可以这样写：

<p>This is the content within a non-empty element.

在 HTML 中，认为这是正确的。XHTML 1.0 要求，非空元素要完全关闭。另一个例子是 <li>（列表项）元素。在 HTML 中，可以写成：

<li>The first item in my list. <li>The second item in my list.

或

<li>The first item in my list. </li> <li>The second item in my list. </li>

在 XHTML 1.0 中，只允许后一种方法。

在 XML 中，用斜杠终止空元素。因此，<br> 变成 <br>。由于某些习惯于解释 HTML 的浏览器在使用该方法时有问题，所以，引入了替代方法，即在斜杠之前添加一个空格： <br >。

这是一个图像元素的 XHTML 示例，它是空元素：

<img src="my.gif" height="55" width="25" border="0" alt="picture of me" >

其它要注意的空元素是 meta 和 link。

引号
HTML 中的引号是任意的，即，可以在属性值前后使用引号，也可以不使用，并且不会导致太多麻烦。没有规则说：不用引号将值括起为非法。下例在 HTML 中完全可接受：

<table border=0 width="90%" cellpadding=10 cellspacing="10">

尽管有些属性值用引号括起，有些没有，但浏览器将正确显示该标记。但是，如果要遵循 XHTML 1.0，则必须将所有属性值用引号括起。

<table border="0" width="90" cellpadding="10" cellspacing="10">

如您可见，这些更改都不大。还有点儿烦，是的，但是，一旦开始使用这种方法，将会发现，这种标记要方便得多。一致性是使 XHTML 1.0 如此吸引人的原因之一 -- 它提供了构建未来结构的坚实基础。

XHTML 的未来
既然 XHTML 如此易用，为什么这么长时间才被采用呢？这是很多关心标准的人在问的问题。该问题的部分原因可能是宣传得不够 -- 没有太多人了解 XHTML 1.0。甚至即使听说过，也可能没意识到：现在使用它有多简单。

另一个原因是：目前用于 HTML 开发的软件工具（如 Adobe GoLive、Macromedia Dreamweaver、Microsoft FrontPage 等）不支持 XTHML，很多喜爱这些工具或必须在工作中使用这些工具的 Web 作者对此感到担心。

但是，尽管有这些困难，XHTML 1.0 正在前进。事实上，下一版本，XHTML 1.1，已经相当完善，并包含 Web 标记作者某些新的、不同的概念。模块化（将语言分成彼此独立的模块）是 XHTML 1.1 的主要部分。而且，更多类似于 XML 的优势在发挥作用。例如，为 XHTML 文档编写自己的 DTD 或者使用模式 (schema) 的能力将带来真正的可扩展性。

XHTML 1.0 是当今的 Web 标记标准。如果还没使用它，至少应该好好尝试一下。在与 XML 相关的技术领域发生的进展（特别是无线领域）强有力而令人信服地表明：标记语言的作者越灵活，其前景就越被看好。XHTML 1.0 是开阔您眼界的极佳方法。够熟悉，就有意义；够强大，可以帮助您创建适用于今天、更为明天激动人心的机遇作好准备的稳定、可互操作的 Web 站点。

参考资料

World Wide Web Consortium XHTML Recommendation。这是 W3C 站点上详细解释 XHTML 1.0 的标准文档
XHTML 1.1。正在讨论中，XHTML 的这个下一版本涉及到 XHTML 1.0 的模块化方面。
可以在这里找到 Chuck Musciano 所著的 Web Review series on XHTML 1.0。
Mozquito.Com 是 Mozquito Technologies 的 Web 站点，他专为 XHTML 制作软件产品。还可以在他们的站点找到很好的教程和大量资源链接。

关于作者
作为作家、讲师和设计人员，Molly E. Holzschlag 将其观点和热情带入书籍、杂志和 Web 站点。被 Webgrrls 评为 Web 上最有影响的 25 位女性之一，Molly 在联机世界已工作 10 年之久。她写了 15 本关于 HTML 和 Web 设计与开发主题方面的书籍，包括即将出版的 Que 的 Special Edition Using XHTML 1.0、最畅销的 Special Edition Using HTML 4.0 和得到国际上普遍赞誉的 Web by Design。她的流行栏目，Integrated Design，每月出现在 WebTechniques 杂志。她还是 Web Review 的执行编辑，也是 Adobe Magazine、Builder.Com、DesignShops.com、Digital Chicago、Digital New York、IBM developerWorks、MacWorld、MSDN、PlanetIT 的作家，还是其它开发人员资源的成员之一。可以造访她的 Web 站点 http://www.molly.com/。

]]> <![CDATA[Web 的未来：XHTML 2.0]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2663 breeze 2005/2/2 12:07:29 变更概述

Nicholas Chase（nicholas@nicholaschase.com）
总裁，Chase & Chase, Inc.
2003 年 1 月

多年以来，HTML 只是在不断变大，却从未变小，因为新版本必须维护向后兼容性。这一情况将得以改变。XHTML 2.0 的第一个工作草案于 2002 年 8 月 5 日发布，一大新闻就是取消了向后兼容性；该语言终于得以继续发展。那么，作为一名开发人员您将得到什么回报呢？健壮的表单和事件表现如何呢？它们是研究不需要大量 JavaScript 的框架以及甚至层次结构菜单的更佳方法。

本文概述了 XHTML 2.0 中的新增功能以及将来可能会如何使用它。读者应该熟悉 HTML 和／或 XHTML 1.0。熟悉级联样式表（Cascading Style Sheet (CSS)）是有帮助的，但不是必需的。

告别向后兼容性，引入结构

当万维网联盟（World Wide Web Consortium (W3C)）于 2002 年 8 月 5 日发布 XHTML 2.0 的第一个工作草案时，最让人吃惊的是：与其先前的版本不同，它不是向后兼容的。对于先前的发行版，如从 HTML 4.01 转到 XHTML 1.0 以及后来从 XHTML 1.0 到 XTHML 1.1，变化都是添加一些内容；可以读取 XHTML 1.0（过渡的）文档的浏览器也可以理解 HTML 4.01 文档。而 XHTML 2.0 不是那样的。

如果您在两年前宣布我们今天将研究不带 img 标记或 bold 标记的 HTML 版本，那么大多数 Web 开发人员都会用怀疑的眼光看着您。然而，现在就是这样。除了彻底替换表单和框架外，XHTML 2.0 还除去了 b、i 和 img 标记（以及 big、small 和 tt），甚至不赞成使用 br，以准备从将来的发行版中除去它。但这是为什么呢？

原因在于大多数标记都是表示性的。它们的唯一目的就是给予浏览器指令，规定有关其内容应该如何显示，但却完全未提供有关其内容是什么的信息。例如，请考虑下面两个句子：



Presentational elements are, <i>for the most part</i>, <b>gone</b>.

和



Presentational elements are, <em>for the most part</em>, <strong>gone</strong>.

在没有样式表的情况下，这两个句子在浏览器中看起来是一样的，但只有第二个句子提供了有关原因的信息。事实上，从一开始 em（强调）和 strong 标记就出现在 HTML 中了，但多年以来作者们基本上已经忽略了它们，而专注于表现形式，这是以牺牲内容为代价的。

但这并不意味着只要您想使某些内容变成粗体或斜体，就应该将它们硬塞进这两个标记中。相反，除去表示性元素的整个目的是设法完成 CSS 的发明者的初衷，即应该根据内容所表示的东西来标记内容，而样式表应该用于美化内容。例如，清单 1 使用类别（class）来指出内容类型。

清单 1. 使用类别指定内容类型



<html>

<head><title>Employee Notice</title>

<style type="text/css">

    .duedate { color: red;

               font-weight: bold; }

    .holiday { color: green;

               font-style: italic }

</style>

</head>

<body>

<h1>Notice</h1>

<p>Employees should take note of the following important dates:</p>

<ul>

    <li class="duedate">8/28/2002 (Progress reports due)</li>

    <li class="holiday">9/1/2002 (Labor Day)</li>

    <li class="duedate">10/28/2002 (Final reports due)</li>

</ul>

</body>

</html>

在该页面中，日期类型可以由内容本身来确认，浏览器可以使用类别信息来决定如何为其设计样式，如图 1 中所示。

图 1. 类别可以确定显示哪一类内容，样式表可以对它进行适当的格式化。

用这种观点研究它：断开（br）标记的目的无外乎是为了显示，因为实际上它并无任何内容。XHTML 2.0 不赞成使用 br 标记，而提倡使用 line 标记。line 标记指定一种特殊的内容：通常是以后跟换行和回车这种方式呈现的一行文本或其它内容。例如，文本：



<p>

public class HelloWorld {<br />

public static void main (String[] args){<br />

System.out.println("Hello world!");<br />

}<br />

}

</p>

变成



<p>

<line>public class HelloWorld {</line>

<line>public static void main (String[] args){ </line>

<line>System.out.println("Hello world!"); </line>

<line>}</line>

<line>}</line>

</p>

这样，文档就有了一个表示行的实际对象，同样，段（p）标记表示一段内容。

为什么所有这些都很重要呢？因为 Web 不仅正日益成为人与人之间通信的场所，而且还日益成为软件应用程序（如服务器和搜索引擎索引器）之间进行通信的场所。而且，每个人（或者说几乎每个人）都使用相同浏览器的时代已经一去不复返了。开发人员正不断为不同设备（如 PDA 和移动电话）重新设计内容。语音触发的（voice-activated）系统已经离我们不远了。内容的结构意义正变得几乎与内容本身一样重要。

节
因此，XHTML 2.0 添加了节（section）和标题（heading）。HTML 一直都包含编号的标题 — h1 到 h6，直到 2002 年 8 月 5 日的工作草案，还未将其撤消，但这只是一个时间问题。而 XHTML 2.0 使用通用标题和节。例如，可以嵌套节，从而赋予标题含义。以前用编号标题呈现的文档（清单 2）：

清单 2. 文档中的编号标题





<html>

<head><title>Adding sections</title></head>

<body>

   <h1>The Web's future: XHTML 2.0</h1>

   <p>by Nicholas Chase</p>

   <h2>Good-bye backward compatibility, hello structure</h2>

   <p>Why backward compatibility is over.</p>

   <h3>Presentation versus Structure</h3>

   <p>Using style sheets rather than presentational elements.</p>

   <h3>Lines</h3>

   <p>Line breaks are deprecated.</p>

   <h2>Sections</h2>

   <p>Creating more reasonable sections.</p>

   <h2>Navigation lists and menus</h2>

   <p>Hierarchical menus.</p>

   <h2>Links, links, everywhere</h2>

   <p>Adding links.</p>

</body>

</html>

可以用通用标题和节替换（清单 3）：

清单 3. 通用标题和节





<html>

<head><title>Adding sections</title></head>

<body>

   <section>

      <h>The Web's future: XHTML 2.0</h> 

      <p>by Nicholas Chase</p>

      <section>

         <h>Good-bye backward compatibility, hello structure</h>

         <p>Why backward compatibility is over.</p>

         <section>

            <h>Presentation vs. Structure</h>

            <p>Using style sheets rather than presentational elements.</p>

         </section>

         <section>

             <h>Lines</h>

             <p>Line breaks are deprecated.</p>

         </section>

      </section>

      <section>

         <h>Sections</h> 

         <p>Creating more reasonable sections.</p>

      </section>

      <section>

          <h>Navigation lists and menus</h>

          <p>Hierarchical menus.</p>

      </section>

      <section>

          <h>Links, links, everywhere</h>

          <p>Adding links.</p>

      </section>

   </section>

</body>

</html>

这种结构有两个优点。首先，应用程序（如搜索引擎 crawler）能够更容易地了解内容的相对重要性，其次，节是自包含的。在 HTML 中，节以其标题开始，所以在标题的前面不会出现内容（如介绍性内容）。section 元素取消了这种约束，因为其内部的任何内容都是节的一部分。

导航列表和菜单

增加了一个会让 Web 开发人员大大受益的结构，那就是导航列表。由 nl 标记指定的导航列表的工作原理与其“表亲”有序列表（ol）和无序列表（ul）非常相似，但有一点不一样：导航列表的项仅在列表激活时才出现。因此，导航列表与层次结构的弹出菜单十分相似，这种弹出菜单很受欢迎，因为它们提供了许多导航信息，而且不会占据太多的屏幕空间。例如，肥皂剧站点可能有以下菜单（清单 4）：

清单 4. 使用导航列表



<nl>

   <name>Character Options</name>

   <li href="stay.html">Stay</li>

   <nl>

      <name>Leave</name>

      <li href="newjob.html">Job transfer</li>

      <li href="divorce.html">Divorce</li>

      <li href="fataldisease.html">Fatal disease</li>

   </nl>

   <li href="backburner.html">Back Burner</li>

</nl>

当用户激活名称（Character Options）时，出现列表项。关于当用户激活主列表时子列表（如 Leave 菜单）是否会出现，还是用户必须激活子列表项本身以使其出现，工作草案并未说清楚。最终作者可能通过样式或事件来控制这一行为。在任何情况下，当输入焦点从主元素移开时，列表项就会消失。

链接，链接无处不在

您可能已经注意到：即使打算将前一个示例作为菜单，但它没有锚（a）标记。而 href 属性已经被正确放在了 li 元素上。这不是导航列表的特性，而是 XHTML 2.0 的新特性。与超文本相关的属性（如 href、target 和 accesskey）现在是公共属性集合（Common Attribute Collection）的一部分，它包括核心属性（class、id 和 title）、国际化属性（xml:lang，它替换了 XHTML 1.1 中的 lang）和事件属性，事件属性来自 XML Events 建议书，正如您将在下面看到的。

这意味只要将 href 属性添加到任何元素，就可以将它转换成链接，而不一定要用锚标记包围单个元素。

这是否表示经过四年的努力，XLink 已经被 XHTML 2.0 采用了吗？总而言之，没有。事实上，XLink 和 XHTML 2.0 中规定的链接之间的差异是那些正从事各自建议书的开发人员之间争论的根源，所以在这个最初的公开工作草案和最后的建议书之间可能会做些更改。同时，可以组合使用该功能、导航列表、link 元素，以及资源描述框架（Resource Description Framework (RDF)）来复制 XLink 的大多数功能。

XForms 是一个与 XML 相关的建议书，并确实已经成为 XHTML 2.0 的一部分。

XForms

XML 表单语言（XML Forms Language (XForms)）是研究表单的一种全新方法 — 它象 XHTML 的其余部分一样 — 内容、结构和表现是完全独立的。XForms 页面指定一个模型，该模型拥有有关表单自身的信息，然后，可以在页面周围散布表单元素，而不是被局限于单个表单元素。这意味着，您甚至可以在页面的同一区域中合并不同表单的元素。可以通过实例文档填充表单，实例文档是从表单元素上的 XPath 表达式引用的。表单元素自身也代表了特殊类型的对象，而不是描述在页面上它们是如何显示的。当更新表单元素中的数据时，会更新实例文档。当用户提交表单时，实际发送的是实例文档。例如，采用下面的简单表单（清单 5）：

清单 5. 简单的 HTML 表单





<html xmlns="http://www.w3.org/1999/xhtml">

<head>

    <title>Preference Form</title>

</head>

<body>



<h1>Preferences Form</h1>

<form action="myformprocessor.jsp">

<p> 

    Username: <input type="text" name="userid" />

    <br />

    Password: <input type="password" name="pass"/>

</p>



<p>

    Area preference:

        <select name="seatingpreference">

             <option value="1">One</option>

             <option value="2">Two</option>

             <option value="3">Three</option>

        </select>

</p>

<p>

    <input type="submit" />

</p>

</form>

</body>

</html>

清单 6 显示了 XForms 版本的表单：

清单 6. XForms 版本的表单





<html xmlns="http://www.w3.org/1999/xhtml" 

      xmlns:xforms="http://www.w3.org/2002/01/xforms">

<head>

    <title>Preference Form</title>



    <xforms:model>



        <xforms:submitInfo method="postxml"/>



        <xforms:instance xmlns="">

            <preferences>

                <person userid="">

                    <password></password>

                </person>

                <seatingpreference></seatingpreference>

            </preferences>

        </xforms:instance>

    </xforms:model>



</head>

<body>



<h1>Preferences Form</h1>



<p> 

    <xforms:input ref="preferences/person@userid">

        <xforms:caption>Username: </xforms:caption>

    </xforms:input>



    <br />



    <xforms:secret ref="preferences/person/password">

        <xforms:caption>Password: </xforms:caption>

    </xforms:secret>

</p>



<p>



    <xforms:selectOne ref="preferences/seatingpreference" selectUI="listbox">

        <xforms:caption>Area preference:   </xforms:caption>

        <xforms:item>

            <xforms:value>1</xforms:value>

            <xforms:caption>One</xforms:caption>

        </xforms:item>

        <xforms:item>

            <xforms:value>2</xforms:value>

            <xforms:caption>Two</xforms:caption>

        </xforms:item>

        <xforms:item>

            <xforms:value>3</xforms:value>

            <xforms:caption>Three</xforms:caption>

        </xforms:item>

    </xforms:selectOne>



</p>

<p>

    <xforms:submit>

        <xforms:caption>Submit Report</xforms:caption>

    </xforms:submit>

</p>



</body>

</html>

术语说明：XForms 建议书特别说明了不存在单个表单的 XForms。它是多个 XForms 页面，不再是单个 XForm 页面。

表单一般需要进行验证。换句话说，数据字段必须包含有效数据等。XForms 使用 XML 模式来约束所提交的数据。另外，可以通过添加 XML Events（它也包括在 XHTML 2.0 中）来进一步增强 XForms 页面的功能。

XML Events

您可能已经熟悉了通过添加如 onclick 和 onmouseover 之类的事件在 Web 页面上使用事件。不会再有了。这些熟悉的属性已经被集成到 XHTML 2.0 中的 XML Events 模块所替代。XML Events 提供了一种通用的方法来指定事件发生时应该采取的操作。它的优点是您不受限于如鼠标单击之类的预定义事件。相反，可以定义您自己的事件以及触发它们时会发生什么。

XML Events 包含下列组件。如鼠标单击之类的事件可以作为目标。例如，在清单 7 所示的页面中：

清单 7. 要单击的页面





<html>

  <head><title>Rides</title></head>

  <body>

     <ul id="ridelist">

        <li href="monorail.html">Monorail</li>

        <li href="Matterhorn.html">Matterhorn</li>

        <li href="coaster.html">Roller coaster</li>

     </ul>

  </body>

</html>

用户可能单击第二个 li 元素 Matterhorn。当这发生时，鼠标单击事件从文档根行进到目标（li）并再次返回。顺序是：



(root) -- html -- body -- ul -- li -- ul -- body -- html -- (root)

向下行进到目标称为捕捉（capture）阶段，而再次向上行进称为冒泡（bubbling）阶段（并不是所有的事件都会冒泡）。在行进期间的任何时候，事件都可以传递已经被注册为观察器的对象（这表示它正在观察特定的事件），如果它看到事件，则执行特定操作。侦听器创建观察器。例如，在下面的序列中：



<ev:listener observer="ridelist" event="mousedown" handler="#myscript"/>

侦听器使 ul 元素（或者更准确一点说，是整个列表）成为观察器，因而，当用户单击任何列表项目时，观察器（ridelist）执行 myscript（但仍必须确定调用任意脚本的机制）。

XFrames
广受指责的框架也在 XHTML 2.0 中被替换了。XFrames 的第一个工作草案于 2002 年 8 月 6 日初次登场，此前一天 XHTML 2.0 宣布它将使用 XFrames 并试图解决传统 HTML 框架出现的问题。大多数问题是有关难于创建书签和刷新页面，以及不支持框架的搜索引擎无法索引适当内容。

在 XFrames 文档中，所包含内容的 URI 成为整个文档 URI 的一部分。例如，下面清单 8 中的页面可能表示带三个框架的 HTML 页面：

清单 8. XFrames 页面



<html>

<head><title>XFrames</title></head>

<body>

<row>

    <frame id="header" />

    <column>

        <frame id="menu"/>

        <frame id="content"/>

    </column>



</row>

</body>

</html>

请注意，没有指定每个框架的 URI，但每个框架都有其自己唯一的标识符。因此，这个文档的 URI 可能是：



site.xfm#frames(header=header.xhtml,menu=menu.xhtml,content=main.xhtml)

然后，理解 XFrames 的浏览器将每个框架的内容与适当的 URI 相关联。当用户单击链接并更改个别框架的内容时，页面的整个 URI 都会更改，所以它始终显示用户正在查看的实际内容，“收藏”和“后退”按钮提供了准确的内容。

图像作为对象

2002 年 8 月 5 日工作草案的最后一个主要的更改包括除去了 img 标记并用 object 标记替代它。object 标记实际上在 HTML 4.01 中就已经出现，但开发人员主要将它用于嵌入多媒体和 Java applet。然而，它一直都能支持图像。使用 object 标记的主要优点在于，它被设计成向下级联。换句话说，如果浏览器不能显示一个特定对象，那么它将显示该对象的内容。例如，遇到下列代码片断的浏览器首先试图装入电影。如果装入电影失败，则装入图像。如果装入图像失败，那么它只显示文本。



<object data="rides.mpeg" type="application/mpeg">

    <object data="rollercoaster.jpg" type="image/jpg">

        Jack tries to expand his horizons on the racing coasters.

    </object>

</object>

后续步骤

2002 年 8 月 5 日的 XHTML 2.0 工作草案中唯一可以确定的事就是不能确定任何事情。在现在的草案和被作为建议书采纳的过程中，几乎可以肯定它将在某些方面发生变化，但强调结构和语义的目标不可能变化。出于这个原因，最好研究您现在构建的页面，并开始养成适当使用结构和样式的习惯。使用标记来指定某些事物是什么，而不是如何显示它们，并使用 CSS 来完成其余工作。总的来说，更多地考虑文档的结构以及您想要它们干什么，而不必太多地考虑它们将如何显示。

请参阅 XHTML 2.0 的最新版本，以了解它目前包含哪些内容。
请查找有关如何用 XML Events 控制页面和任何 XML 文档中事件的信息。
请阅读使用 XForms 的下一代 Web 表单。
请阅读文章“Get ready for XForms”（developerWorks，2002 年 9 月），学习有关 XForms 的更多知识。
请快速阅读 XFrames。
请阅读 Modularization of XHTML 或阅读 developerWorks Web 体系结构专区上的 XHTML的模块化教程（2001 年 10 月），了解 XHTML 2.0 是如何构造的。
请在 XHTML 2.0 The Latest Trick 中参考 Kendall Grant Clark 有关 XHTML 2.0 以及 Semantic Web 的注释。
请在 XLink: Who Cares? 中阅读 Bob DuCharme 有关 XLink 及其前景的想法。
下载 X-Smiles，它是一种 XForms 浏览器。

关于作者

Nicholas Chase 曾参与过很多公司（如 Lucent Technologies、Sun Microsystems、Oracle 和 Tampa Bay Buccaneers 等）的网站开发。Nick 曾是一名高中物理教师、低辐射废物设备管理人员、在线科幻杂志编辑、多媒体工程师和 Oracle 讲师。最近，他成为 Site Dynamics Interactive Communications（位于佛罗里达州的 Clearwater）的 CTO，而且还是三本有关 Web 开发书籍的作者，包括 Java and XML from Scratch (Que) 和即将出版的 Primer Plus XML Programming (Sams)。他乐意听取读者意见，可以通过 nicholas@nicholaschase.com 与他联系。

]]> <![CDATA[侵入Body转换器]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2213 breeze 2005/1/22 13:15:50 Invasion of the Body Switchers
侵入Body转换器

作　　者：Andy Clarke 和 James Edwards
原文地址：发表在 A List Apart http://www.alistapart.com/articles/bodyswitchers/
发表日期：2004年11月19日
翻　　译：Breeze
翻译日期：2004年12月11日

［注意］无论是否涉及商业，您可以任意转载和引用这篇文章，可以删除“翻译：Breeze”字样，但请别修改。本文首次发布在ChinaUI.com论坛的“技术交流”板块。

　　从2001年首次发布直到现在，Paul Sowden的样式表切换器已经被成千上万的设计和开发人员下载，并且有了像鱼卵一样多的客户端和服务器端修改版本。

　　在众多的工程上使用了Paul的脚本后，我开始怀疑样式转换器有多少可能被延伸给使用者甚至带来更多的选择或者亲和力提高，因此，我求助于我的好朋友Brothercake来让我的想法成为一个事实，“侵入Body转换器”这篇文章就这样产生了。

　　回顾原始的样式转换器

　　执行起来捕风捉影地简单，Paul的脚本除了灾祸外什么都没有。

　　触发开关动作的锚普遍地呈现于标记中，如果JavaScript不可用的话将会出现问题，并且和那普遍使用的“#”一样是一个不必要的烦恼。

<a href="#" onclick="setActiveStyleSheet('default');return false;">Switcher</a>

　　原始的解决方案同样依赖于多重的样式表，利用<link/>元素和"stylesheet" / "alternate stylesheet"语义－这样增加了额外的服务器响应，但是更重要的是，它没有考虑到被选择的不同媒体样式是独立于其他的。

　　如果我们不使用任何物理标记而只用一份JavaScript和CSS文件来实现它，这难道不是在幻想吗？如果我们能独立的以媒体类型作为目标，依据选择的参数来为用户提供一个普通的UI，而且所有参数都保存在cookie中直到它被改变，这难道不是更加的荒谬吗？

　　现在我们做到了，进入我们的Body 转换器。

　　概念

　　“侵入Body转换器”这个技术能够无限扩展和操作任何数量的选项和媒体类型，这一切只需要一份JavaScript和CSS文件。原理是为页面的<body>标签添加一个或者更多的唯一的类名（class），然后使用派生选择器来定义样式。

　　我们的方法要求放弃传统的“stylesheet”和“alternate style-sheet”语义，但这些没有使我们感到烦恼，因为：

　　1.许多浏览器不执行本地的样式表转换；
　　2.选出的预备样式表不能够持续。

　　制造菜单

　　在我们开始前，让我们先看看最终的结果。

　　如果你现在下载这些文件，你能像我们一样查阅并且仔细检查他们的每个构成：

　　XHTML

　　首先插入一些空的转换容器，这里我们用一个<div>标签来容纳转换器：

<div id="screen-switcher"></div>

　　你可以为每个附加的转换器添加一个额外的容器。例如，一个附加的打印样式转换器：

<div id="screen-switcher"></div>
<div id="print-switcher"></div>

　　或者甚至是投影样式：

<div id="screen-switcher"></div>
<div id="print-switcher"></div>
<div id="projector-switcher"></div>

　　转换工具被创建并放入这些容器仅当脚本是可用、离开语义的中立和当容器非空的时候。

　　脚本

　　脚本的设定很普通。首先创建一个新的转换格式—定义容器的id和标签文本：

var screenSwitcher =
  new bodySwitcher(
  'screen-switcher',
  'Screen styles'
);

　　然后你可以添加任何数量的类以及他们的标签，然后将它们应用到转换器控制上：

screenSwitcher.defineClass('default','Normal contrast');
screenSwitcher.defineClass('high','High contrast');

　　添加新的媒介类型

　　为了使用户在没有动人的屏幕展示情况下能在不同的打印样式中有个选择，在脚本中添上了打印选项。

var printSwitcher =
  new bodySwitcher(
    'print-switcher',
    'Print styles'
  );
printSwitcher.defineClass(
  'default','Default'
);
printSwitcher.defineClass(
  'small-sans','Small sans'
);
printSwitcher.defineClass(
  'large-serif','Large serif'
);

　　额外的媒体类型也能被包含进去，例如手持或者投影设备。

var projectionSwitcher =
  new bodySwitcher(
    'projection-switcher',
    'Projection styles'
  );
etc.

var handheldSwitcher =
  new bodySwitcher(
    'handheld-switcher',
    'Handheld styles'
  );
etc.

　　仅有的限制是所有类名必须唯一，即使跨过了不同的媒体类型。

　　样式表

　　一个单一的样式表能够包含所有的选项和由用户选择的媒体类型。任何CSS规则可以适用于这个样式表，只需简单的在附加的<body>类名上使用派生选择器，我们已经在前面讨论过了。

　　屏幕样式范例

@media screen
{
body {
background : #fff;
color : #666;
}

body.high {
color : #000;
}

body.highvisibility {
background : #000;
color : #ff0;
}
}

　　打印样式范例

@media print
{
body {
font: 100% "Lucida Sans Unicode",verdana,sans-serif;
}

body.small-sans {
font: 80% "Lucida Sans Unicode",verdana,sans-serif;
}

body.large-serif {
font: 120% "Times New Roman",times,serif;
}
}

　　如果需要的话另外的媒体类型样式也可以添加。

@media projection {
etc.
}

@media handheld {
etc.
}

　　转换控制花样

　　转换控制基于具备亲和力、语义的标签并且能依照任何站点的设计来样式化。HTML看起来像是可适合于每个设备。我将让你来决定这些样式。

<form action="">
<fieldset>
<label for="select-screen-switcher">
<span>Screen styles</span>
<select id="select-screen-switcher">
<option value="default">Normal contrast</option>
<option value="high">High contrast</option>
<option value="highvisibility">High visibility</option>
</select>
</label>
</fieldset>
</form>

　　快要结束了

　　就是它！让我们再看看最终的结果－一个新潮的能够进行不同媒体类型独立转换的样式转换器，并且它为你的网页输出给予了使用者非常棒的控制。

　　这个原理是无限可扩展的，而且你能更深入的细化它，为字体、颜色、布局或定位提供单独的参数选择。

　　警告

　　“侵入Body转换器”在Mac的IE5下无法工作（它被温柔的降级了）。

]]> <![CDATA[元数据框架]]> http://blogger.org.cn/blog/more.asp?name=breeze&id=2212 breeze 2005/1/22 13:09:40 　　１简介

　　随着Internet的不断发展，网络信息资源也日趋丰富。作为一个即能够有针对性地描述网络信息资源，又不需要有专业技术的专业人员的，一个即简单，又在网络中为各种团体所接受的标准化元数据元素集DC (Dublin Core, 全称 Dublin Core Metadata Elements Set) 正在为Internet上各类用户接受。作为学科间信息资源描述的首要候选者，DC也已得到国际间的广泛承认。作为数字图书馆的一个重要技术，DC得到越来越多的应用。

　　生命科学学科信息门户作为中国科学数字图书馆的一个重要组成部分，采用DC元数据作为网络信息资源的描述标准。包括：

　　DC元数据集（Dublin Core Metadata Elements Set，DCMS）
　　http://dublincore/documents/dces/
　　DC修饰词（Dublin Core Qualifiers，DCQualifiers）
　　http://dublincore/documents/dcmes-qualifiers/
　　DCMI类型词汇表（DCMI Type Vocabulary，DCMIType）
　　http://dublincore/documents/dcmi-type-vocabulary/

　　由于DC元数据在不断地更新和发展，我们将密切注意DC的发展，随时选用成熟技术。在具体应用的过程中，如已有的标准不能满足生命科学学科网络信息资源的描述，我们将提交相应的描述方法，供有关工作组参考。

　　2 DC元数据应用方案

　　2.1 几点说明

　　DC修饰词中的编码格式除了选用DC推荐的相关编码格式外，还选用了国内权威的有关编码格式标准和与生命科学学科有关的编码格式标准。

　　除了采用DCMI2000年7月11日发布的DC修饰词，考虑到有些元素值要用中、英文作为描述元素的语言，以及DC-4的Canberra Qualifier中一些对元素值描述的限定词比较符合现在的常用方法。我们将结合这两种限定词的使用。Canberra Qualifier的限定词为LANG（语言）、SCHEME（模式）、TYPE（类型）。

　　LANG是各个元素值共用的限定，遵循RFC1766的规定，使用ISO639的两个字母的语言代码。在以后的元素限定词中不再一一说明。

(RFC1766: http://lcweb.loc.gov/standards/iso639-2/langhome.html)
(ISO639: http://www.ietf.org/rfc/rfc1766.txt)

　　2.2 DC元数据应用

　　● 元素：Title
　　名字：资源名
　　标识：Title
　　定义：由创作者或出版者赋于资源的名称
　　注解：一般而言，这一名称指的是资源对象的正式公开的名称。
　　必备，不可重复。

　　DCQualifiers的修饰词
　　交替题名（alternative）
　　名称: 交替题名（alternative）
　　标识: Alternative
　　定义: 任何一种用作其它题名的题名形式或资源正式题名以外的任何题名。
　　注释: 该修饰词可以包括缩写题名和翻译题名。
　　可选，可重复。

　　DCQualifiers的编码格式（新增）
　　中国文献编目规则（1996年版）
　　中国机读目录格式使用手册（1995年版）

　　● 元素：Creator
　　名字：创建者
　　标识：Creator
　　定义：对于创建资源的知识内容负有主要责任的个人或组织。
　　注解：创建者的实例包括一个个人，一个组织或一个服务。一般而言，用创建者的名字来标识这一条目。
　　必备，不可重复。

　　DCQualifiers的编码格式（新增）
　　中国文献编目规则（1996年版）
　　中国机读目录格式使用手册（1995年版）
　　Canberra Qualifier限定
　　SCHEME：中国文献编目规则（1996年版）
　　中国机读目录格式使用手册（1995年版）

　　Canberra Qualifier限定
　　TYPE： DC.Creator.PersonalName
　　个人作者名
　　DC.Creator.CorporateName
　　团体作者名，包括会议名称等
　　DC.Creator.PersonalName.Address
　　个人作者的地址，包括任何形式的地址描述，比如电子邮件地址等
　　DC.Creator.PersonalName.Date
　　与个人作者相关的日期描述，如作者的生卒年月等，描述方式可采用中
　　国文献编目规则（1996年版）的相关规定
　　DC.Creator.CorporateName.Address
　　团体作者的地址
　　DC.Creator.CorporateName.Date
　　与团体作者相关的日期描述
　　可选，可重复。
　
　　● 元素：Subject
　　名字：主题和关键词
　　标识：Subject
　　定义：有关资源内容的主题描述。表示为描述资源的主题或内容的关键词或词组。
　　注解：一般而言，一个主题和关键词通常采用描述资源内容的关键词，短语或分类号。推荐主题和关键词最好是取自于一个受控词表或是一个规范的分类体系。
　　必备，可重复。
　
　　DCQualifiers的编码格式
　　MESH
　　名称: MESH
　　标识: MeSH
　　定义: 医学主题词表
　　参见：http://www.nlm.nih.gov/mesh/meshhome.html

　　DDC
　　名称: DDC
　　标识: DDC
　　定义: 杜威十进分类法
　　参见：http://www.oclc.org/dewey/index.html

　　DCQualifiers的编码格式（新增）
　　中国图书馆分类法（第4版）
　　中国科学院图书馆图书分类法（第3版）
　　汉语主题词表
　　中国分类主题词表

　　Canberra Qualifier限定
　　SCHEME：自由词（关键词）
　　可选，可重复。

　　● 元素：Description
　　名字：说明
　　标识：Description
　　定义：对资源内容的说明。
　　注解：说明元素可以包括但不限于以下部分：文摘,目录，对以图形来表示内容的一个参照或者一个有关内容的自由文本描述。
　　可选，可重复。
　
　　DCQualifiers修饰词
　　目次（Table Of Contents）
　　名称: tableOfContents
　　标识: Table Of Contents
　　定义: 资源内容的组成单元的列表。
　　可选，可重复。

　　文摘（Abstract）
　　名称: abstract
　　标识: Abstract
　　定义: 资源内容的摘要
　　可选，可重复。

　　Canberra Qualifier限定
　　SCHEME：URL（统一资源地址，为对该资源进行描述的文献地址）
　　URN（统一资源名称，为对该资源进行描述的文献地址）
　　可选，可重复。

　　● 元素：Publisher
　　名字：出版者
　　标识：Publisher
　　定义：负责使资源能够以现有形式被获得的实体。
　　注解：出版者的实例包括一个个人，一个组织，或一种服务。一般而言，用出版者的名字来标识这一条目。
　　可选，可重复。
　
　　DCQualifiers的编码格式（新增）
　　中国机读目录格式使用手册（1995年版）

　　Canberra Qualifier限定
　　SCHEME：中国机读目录格式使用手册（1995年版）
　　TYPE： DC.Publisher.personalName
　　DC.Publisher.CorporateName
　　DC.Publisher.personalName.Address
　　DC.Publisher.personalName.Date
　　DC.Publisher.CorporateName.Address
　　DC.Publisher.CorporateName.Date
　　解释参见Creator的CQ限定
　　可选，可重复。

　　● 元素：Contributor
　　名字：其他责任者
　　标识：Contributor
　　定义：在创建者（Creator）元素中没有指明的、对资源内容创建作出贡献的其他责任者。
　　注解：其他责任者的实例包括一个个人，一个组织或一个服务。一般而言，用其他责任者的名字来标识这一条目。

　　Canberra Qualifier限定
　　SCHEME：中国机读目录格式使用手册（1995年版）
　　TYPE： DC.Contributor.PersonalName
　　DC.Contributor.CorporateName
　　DC.Contributor.PersonalName.Address
　　DC.Contributor.PersonalName.Date
　　DC.Contributor.PersonalName.Role
　　个人其他责任者的责任方式，如编辑、校勘、装订、翻译、评论、编目、赞助、联系人等。
　　DC.Contributor.CorporateName.Address
　　DC.Contributor.CorporateName.Date
　　DC.Contributor.CorporateName.Role
　　同个人其他责任者的描述
　　其他解释参见Creatorde的CQ限定
　　可选，可重复。

　　● 元素：Date
　　名字：日期
　　标识：Date
　　定义：与资源本身生命周期中的一个事件相关的日期。
　　注解：一般而言，日期应与资源的创建或出版日期相关。建议采用的日期格式应符合ISO8601 (http://www.3w.org/TR/NOTE-datetime) 规范，并使用YYYY-MM-DD（年-月-日）的格式。
　　可选，可重复。

　　DCQualifiers修饰词
　　创建（Created）
　　名称: created
　　标识: Created
　　定义: 资源创建的日期。
　　可选，可重复。

　　生效（Valid）
　　名称: valid
　　标识: Valid
　　定义: 资源生效的日期（通常是一个时间段）。
　　可选，可重复。

　　可获得（Available）
　　称: available
　　标识: Available
　　定义: 资源将提供或已经提供的日期（通常是一个时间段）。
　　可选，可重复。

　　发布（Issued）
　　名称: issued
　　标识: Issued
　　定义: 资源发布（例如出版）的日期。
　　可选，可重复。

　　修改（Modified）
　　名称: modified
　　标识: Modified
　　定义: 资源被改变的日期。
　　可选，可重复。

　　DCQualifiers的编码体系:
　　DCMI Period
　　名称: period
　　标识: DCMI Period
　　定义: 对于时间间隔的限定规范
　　参见: http://purl.org/dc/documents/dcmi-period

　　W3C-DTF
　　名称: W3CDTF
　　标识: W3C-DTF
　　定义: W3C对日期和时间的编码规则，基于ISO 8601
　　参见: http://www.w3.org/TR/NOTE-datetime
　
　　● 元素：Type
　　名字：类型
　　标识：Type
　　定义：有关资源内容的特征和类型。
　　注解：资源类型包括描述资源内容的分类范畴，功能，特性或集合层次的术语。描述资源的物理或数字化表现形式，请使用格式（FORMAT）元素。
　　可选，可重复。

　　DCQualifiers的编码体系:
　　DCMI Type Vocabulary
　　名称: DCMIType
　　标识: DCMI Type Vocabulary
　　定义: 用于根据资源的内容特征或自然属性而区分的类型描述。
　　参见: http://purl.org/dc/documents/dcmi-type-vocabulary

　　DCQualifiers的编码格式（新增）　　
　　国家科学数字图书馆学科信息门户资源类型词表
　
　　● 元素：Format
　　名字：形式
　　标识：Format
　　定义：资源的物理或数字化的表现形式。
　　注解：一般而言，形式可以包括资源的媒体形式或尺寸。形式元素可以用来决定对资源进行操作或显示所需的软件和硬件。例如有关大小及时长的标注。建议采用来自于受控词表中的值（例如，因特网媒体类型表[MIME]定义了计算机媒体的格式）。
　　可选，可重复。

　　DCQualifiers的修饰词:
　　范围（Extent）
　　名称: extent
　　标识: Extent
　　定义: 资源的大小或持续时间。
　　可选，可重复。

　　媒体（Medium）
　　名称: medium
　　标识: Medium
　　定义: 资源的物理载体或组成材料。
　　可选，可重复。

　　DCQualifiers的编码体系:
　　IMT
　　名称: IMT
　　标识: IMT
　　定义: 资源的因特网媒体类型。
　　参见:
　　http://www.isi.edu/in-notes/iana/assignments/media-types/media-types

　　● 元素：Identifier
　　名字：资源标识符
　　标识：Identifier
　　定义：用来唯一标识资源的字符串或数字。
　　注解：建议对资源的标识采用一个符合正式标识体系的字符串及数字组合。例如正式的标识体系包括统一资源标识符(URI)，统一资源定位符(URL),数字对象标识符 (DOI)和国际标准书号 (ISBN)。
　　必备，可重复。

　　DCQualifiers的编码体系:
　　URI
　　名称: URI
　　标识: URI
　　定义: URI统一资源标识符
　　参见: http://www.ietf.org/rfc/rfc2396.txt
　
　　● 元素： Source
　　名字：来源
　　标识：Source
　　定义：对一个资源的参照，而当前资源是源自这一参照资源。
　　注解：当前资源可能部分或全部源自来源所标识的资源。本元素即可包含有关该资源的元数据。建议对这一资源的标识采用一个符合正式标识系统的字符串及数字组合。
　　可选，可重复。

　　DCQualifiers的编码体系:
　　URI
　　名称: URI
　　标识: URI
　　定义: URI统一资源标识符
　　参见: http://www.ietf.org/rfc/rfc2396.txt

　　Canberra Qualifier限定
　　SCHEME：自由文本
　　ISBN
　　IISN
　　可选，可重复。
　
　　● 元素：Language
　　名字：语种
　　标识：Language
　　定义：描述资源知识内容的语种。
　　注解：建议本元素的值采用RFC 1766中所定义的语种代码规范，此标准定义了一个2个英文字母的语言代码（取自于ISO 639标准），作为一个可选项，也可以在其后加上一个2个英文字母的国家代码（取自于ISO 3166标准）。例如，en为英语，fr为法语，或者使用en-uk表述为英国英语。
　　可选，可重复。

　　DCQualifiers的编码体系:
　　ISO 639-2
　　名称: ISO639-2
　　标识: ISO 639-2
　　定义: ISO 639-2: 语种名称代码。
　　参见: http://lcweb.loc.gov/standards/iso639-2/langhome.html http://lcweb.loc.gov/standards/iso639-2/langhome.html

　　RFC 1766
　　名称: RFC1766
　　标识: RFC 1766
　　定义: 因特网RFC 1766 '语种识别标识'从 ISO 639抽取的两字母代码，可接着选从ISO 3166抽取的两字母国家代码。
　　参见: http://www.ietf.org/rfc/rfc1766.txt
　
　　● 元素：Relation
　　名字：关联
　　标识：Relation
　　定义：对相关资源的参照。
　　注解：此元素用于揭示相关资源之间的联系。建议对关联的标识采用一个符合正式标识体系的字符串及数字组合。
　　可选，可重复。

　　DCQualifiers的修饰词:
　　Is Version Of
　　名称: isVersionOf
　　标识: Is Version Of
　　定义：所描述的资源的其他版本，其不同是内容的改变而不是形式的改变。
　　可选，可重复。

　　Has Version
　　名称: hasVersion
　　标识: Has Version
　　定义：所描述的资源的其他版本
　　可选，可重复。

　　Is Replaced By
　　名称: isReplacedBy
　　标识: Is Replaced By
　　定义: 所描述的资源被相关资源替代
　　可选，可重复。

　　Replaces
　　名称: replaces
　　标识: Replaces
　　定义: 所描述的资源替代了相关资源
　　可选，可重复。

　　Is Required By
　　名称: isRequiredBy
　　标识: Is Required By
　　定义：所描述的资源需要被相关资源在物理或逻辑上的参照
　　可选，可重复。

　　Requires
　　名称: requires
　　标识: Requires
　　定义：所描述的资源需要相关资源在功能，发送或内容上一致的支持
　　可选，可重复。

　　Is Part Of
　　名称: isPartOf
　　标识: Is Part Of
　　定义：所描述的资源在物理或逻辑上是相关资源的一部分
　　可选，可重复。

　　Has Part
　　名称: hasPart
　　标识: Has Part
　　定义：所描述的资源在物理或逻辑上包括相关资源
　　可选，可重复。

　　Is Referenced By
　　名称: isReferencedBy
　　标识: Is Referenced By
　　定义：所描述的资源被相关资源参考，引用或表明
　　可选，可重复。

　　References
　　名称: references
　　标识: References
　　定义: 所描述的资源参考，引用或表明了相关资源
　　可选，可重复。

　　Is Format Of
　　名称: isFormatOf
　　标识: Is Format Of
　　定义:所描述的资源的另外一种形式
　　可选，可重复。

　　Has Format
　　名称: hasFormat
　　标识: Has Format
　　定义:所描述的资源以前的另外一种形式
　　可选，可重复。

　　DCQualifiers的编码体系:
　　URI
　　名称: URI
　　标识: URI
　　定义: URI统一资源标识符
　　参见: http://www.ietf.org/rfc/rfc2396.txt

　　● 元素：Coverage
　　名字：覆盖范围
　　标识：Coverage
　　定义：资源内容所涉及的外延与覆盖范围。
　　注解：典型的覆盖范围包括空间位置描述（一个地名或地理坐标）、时间段描述（一个时间标识，日期或一个日期范围）、或者权限描述（比如命名的授权实体）。推荐覆盖范围最好是取自于一个受控词表（例如地名词库[TGN]），并应尽可能地使用由数字表示的坐标或日期区间来描述地名与时间段。
　　可选，可重复。

　　DCQualifiers的修饰词:
　　空间（Spatial）
　　名称: spatial
　　标识: Spatial
　　定义：资源主要内容的空间特征
　　可选，可重复。

　　空间（Spatial）的编码体系:
　　DCMI Point
　　名称: Point
　　标识: DCMI Point
　　定义: The DCMI Point 标识了一个地理位置点
　　参见: http://purl.org/dc/documents/dcmi-point

　　ISO 3166
　　名称: ISO3166
　　标识: ISO 3166
　　定义: ISO 3166 编码用于表示国际名称
　　参见: http://www.din.de/gremien/nas/nabd/iso3166ma/codlstp1/index.html

　　DCMI Box
　　名称: Box
　　标识: DCMI Box
　　定义: The DCMI Box标识了一个地理位置区域
　　参见: http://purl.org/dc/documents/dcmi-box

　　TGN
　　名称: TGN
　　标识: TGN
　　定义: The Getty Thesaurus of Geographic Names
　　参见: http://shiva.pub.getty.edu/tgn_browser/

　　DCQualifiers的修饰词:
　　时间（Temporal）
　　名称: temporal
　　标签: Temporal
　　定义: 资源主要内容的时间特征
　　可选，可重复

　　时间（Temporal）的编码体系:
　　DCMI Period
　　名称: Period
　　标识: DCMI Period
　　定义: 对于时间间隔的限定规范
　　参见: http://purl.org/dc/documents/dcmi-period

　　W3C-DTF
　　名称: W3CDTF
　　标识: W3C-DTF
　　定义: W3C对日期和时间的编码规则，基于ISO 8601
　　参见: http://www.w3.org/TR/NOTE-datetime
　
　　● 元素：Rights
　　名字：权限管理
　　标识：Rights
　　定义：有关资源本身所有的或被赋予的权限信息。
　　注解：一般而言，权限管理元素应包括一个对资源的权限管理声明，或者是对提供这一信息的服务的参照。权限管理一般包括知识产权(IPR)，版权或其他各种各样的产权。如果没有权限管理元素的标注，不可以对与资源相关的上述或其他权利的情况作出任何假定。
　　可选，可重复
　
　　可能值为：
　　空白（Null）
　　无限制（No Restriction on Reuse）
　　对资源的权限管理声明，或者是对提供这一信息的服务的参照。

]]>