CN1398377A - 提供和呈现可定标web页面的系统和处理 - Google Patents
提供和呈现可定标web页面的系统和处理 Download PDFInfo
- Publication number
- CN1398377A CN1398377A CN01804488A CN01804488A CN1398377A CN 1398377 A CN1398377 A CN 1398377A CN 01804488 A CN01804488 A CN 01804488A CN 01804488 A CN01804488 A CN 01804488A CN 1398377 A CN1398377 A CN 1398377A
- Authority
- CN
- China
- Prior art keywords
- lantern slide
- substep
- document
- text
- browser
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/95—Retrieval from the web
- G06F16/957—Browsing optimisation, e.g. caching or content distillation
- G06F16/9577—Optimising the visualization of content, e.g. distillation of HTML documents
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/103—Formatting, i.e. changing of presentation of documents
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/12—Use of codes for handling textual entities
- G06F40/14—Tree-structured documents
- G06F40/143—Markup, e.g. Standard Generalized Markup Language [SGML] or Document Type Definition [DTD]
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Audiology, Speech & Language Pathology (AREA)
- Computational Linguistics (AREA)
- General Health & Medical Sciences (AREA)
- Health & Medical Sciences (AREA)
- Artificial Intelligence (AREA)
- Databases & Information Systems (AREA)
- Data Mining & Analysis (AREA)
- Information Transfer Between Computers (AREA)
- Document Processing Apparatus (AREA)
- User Interface Of Digital Computer (AREA)
Abstract
一种显示和再显示符合浏览者浏览器限制的HTML文档的系统和处理。所述系统包括浏览器、脚本和文档对象模型(DOM)。脚本包括数据结构和解释码。DOM是一种文档模型，代表Web页面的元素，如文本、图象、URL链接等。所述处理包括用脚本建立描述文档重要信息的文档数据结构，并用解释码以某种方式解释该数据结构，这种方式允许其操作DOM用于在浏览器中呈现该文档的目的。数据结构可以修改，而相应的HTML可在以后根据用户情况再生，因而在初始建立了文档后，文档可作更新以向浏览者浏览器反映变化情况。若浏览者改变浏览器尺寸，页面元素可自动调整尺寸。
Description
版权通告
本专利文档的一部分内容包含了受版权保护的资料。版权所有者并不反对任何人复制该专利文档或专利揭示的内容，这些在专利商标事务所的文档或记录中出现，但仍然保留所有版权。
发明背景
技术领域
本发明一般涉及因特网通信技术，尤其涉及提供与呈现可定标的Web页面的系统和方法。
背景技术
万维网(www)文档的作者都面临着一种普遍而又令人头痛的问题：观看他们文档的浏览者具有非常多样的观看环境—尤其在显示文档的窗口物理尺寸方面。尤其是如果作者希望按特定的布局要求制作文档时，这就越发成问题。超文本链接标示语言(HTML)，即www的文档格式，在可定标页面元素方面提供的办法很少。许多元素，特别是文本，都固定成特定的尺寸。当在浏览器上以大的显示分辨率观看时，与低分辨率显示时相比，文本显得相当小。另外，即便是那些支持某些定标形式的元素，由于提供定标支持的方式还不成熟，所以也难以控制。所有这些原因导致了WWW文档协调布局的进展相当困难。
对文档作者而言，解决该问题的一条途径是应用动态脚本语言，如JavaScript。这类语言可以探测有关浏览者环境的信息，并据此修改文档。不幸的是，这类语言所提供的原文档对象码(DOM)也有相当的问题。在Netscape浏览器4的情况下，不是可以访问所有的页面元素。许多元素都是“只写”或者“只读”，这就无法将原结构作为存贮文档信息的可靠场所。
相反地，因特网浏览器(ie 4&5)的DOM有时过于复杂，因此很难限定文档修改的程度。
给WWW作者增加难度的是，Netscape浏览器与因特网浏览器所使用的DOM，本质上明显不同。要支持这两种浏览器，就要求开发能与各个DOM互作用的不同脚本。
希望研制一种浏览器无关的文档数据结构，使页面作者能自由地访问和修改文档的所有相关方面，而不用担心浏览器DOM的限制。
发明内容
本发明提供的一种系统和处理方法，可以显示和重新显示符合浏览者浏览器局限性的HTML文档，该系统包括浏览器、脚本和文档对象模型(DOM)。脚本包括文档数据结构与解释码。在本发明较佳实施例中，文档数据结构是一种为该系统设计的幻灯片显现数据结构。DOM是一个代表Web页面元素如文本、图象、URL链接等的文档模型。
应用该系统时不用创建HTML文档，Web作者建立起由脚本组成的文档。当该脚本在执行时，就建立文档数据结构，该数据结构描述了该文档的基本信息。解释码以某种方式解释该数据结构，使得它可以操作DOM用于将文档在浏览器中显现。
通过让Web服务器向浏览者的浏览器提供文档数据结构，而不是对该文档进行HTML再现，就能在当拥有建立合适尺寸的文档所需的浏览器信息时，产生该文档的HTML，从而把文档的所有特征相应地定好尺寸。而且，数据结构可作修改，而且随后可响应用户情况再生成相应的HTML，因而，在最初建立后，可对文档作更新以向浏览者的浏览器反映出变化情况。例如，若浏览者改变了浏览器尺寸，则页面元素会自动改变尺寸。
通过建立了浏览器无关的数据结构，页面作者就能自由地访问和修改文档所有相关的方面，而不用担心浏览器DOM的局限性。这种浏览器的无关性还让作者能编制解释该结构的单个脚本，不必编制用于解释不同浏览器DOM所需的两个或多个脚本。
附图说明
图1是说明系统的框图，该系统可显示和再显示符合浏览者浏览器限制的HTML文档；和
图2是示出根据本发明的文档数据结构的层次结构框图。
具体实施方式
参照图1，系统100用于显示和再显示符合浏览者浏览器限制的HTML文档，它包括浏览器110、DHTML文档对象模型(DOM)120和脚本130。
浏览器110可以是任何一类支持脚本语言的Web浏览器，它具有修改显示的Web页面内容的方法(也称为浏览器文档对象模型)。
DHTML DOM 120是一个文档模型，代表Web页面的诸元素，如文本、图象、URL链接等。
脚本130包括文档数据结构140和解释码150。脚本是内联脚本(包含在Web页面文档的源HTML内的脚本)与Web页面文档引用的脚本文件的某种组合。在本发明该较佳实施例中，文档数据结构140是为本系统设计的幻灯片显现数据结构。所述文档数据结构140的层次结构示于图2和表1-8。
使用该系统时，不用建立HTML文档，Web作者建立其由脚本130组成的文档。当该脚本在执行时，就创建了描述该文档基本信息的文档数据结构140。解释码150以某种方式解释文档数据结构140，使得它操作DHTML DOM 120用于在浏览器中显现该文档的目的。
创建文档数据结构的处理方法包括下述步骤：
1.用Web服务器响应浏览者浏览器对文档的请求；
2.以适当的方式检索或创建该文档的内容(这方面的例子是从计算机硬驱动器读取文件里的文档，向数据库查询信息，或用某种算法计算内容)；
3.把文档内容译成脚本码有效块，当被浏览者浏览器执行时，就会建立可访问或处理的数据结构；
4.把脚本代码嵌入返回到客户的HTML文档里；和
5.在浏览者的浏览器里执行该脚本块(一般由浏览器自动完成)。
一旦创建了该文档数据结构，可选择执行任何必要的数据验证。这一步虽非必要，但通常还是要对Web服务器提供的数据进一步格式化、验证或优化。
上述处理的步骤5还包括下述子步骤：
a、设定背景色；
b、创建显现幻灯片层；
c、使所述幻灯片层显示有效；
d、对所述显现与所述幻灯片的地址初始化；
e、对所述幻灯片内部的各种幻灯片元素初始化；
f、建立调节尺寸的处理程序；和
g、把所述幻灯片呈现为HTML，并在所述浏览器中显示所述显现内容。
当幻灯片元素为文本体时，上述处理的子步骤(e)包括下述分子步骤：
(aa)为所述文本体建立地址；
(ab)创建所述文本体层；和
(ac)使所述层的显示有效。
当所述幻灯片元素为图象体时，子步骤(e)包括下述分子步骤：
(ba)为所述图象体建立地址；
(bb)创建所述图象体层；和
(bc)使所述层的显示有效。
当所述幻灯片元素为轮廓(outline)体时，子步骤(e)包括下述分子步骤：
(ca)为所述轮廓体建立地址；和
(cb)对所述轮廓体的轮廓节点初始化。
上述处理的子步骤(g)包括下述分子步骤：
(da)获得客户屏目尺寸；
(db)设定所述幻灯片层的剪裁区；
(dc)显现所述幻灯片内部的各种幻灯片元素；和
(de)将输出刷新所述层。
在子步骤(g)中，当幻灯片元素为文本体时，分子步骤(dc)包括下述次分子步骤：
(a1)设定层色并对齐；
(a2)生成要显示的文本；
(a3)写URL起始标记；
(a4)写样式和所述文本；和
(a5)写URL结束标记。
在子步骤(g)中，当幻灯片元素为图象体时，分子步骤(dc)包括下述次分子步骤：
(b1)设定层背景色；
(b2)若幻灯片可编辑，写空白内容串；
(b3)获得图象源的URL；
(b4)写URL起始标记；
(b5)显现所述图象；和
(b6)写URL结束标记。
在子步骤(g)中，当幻灯片元素为轮廓体时，分子步骤(dc)包括下述次分子步骤：
(c1)建立默认属性；
(c2)创建显现上下文范围并初始化；
(c3)设定起点和有效宽度；
(c4)按所述显现范围显现轮廓节点；和
(c5)隐藏不使用的层。
解释文档数据结构的处理包括下述步骤：
1.识别文档数据结构由Web服务器安排的对象，该对象要求在浏览者的浏览器中显现；
2.确定或创建用于显现该文档的浏览器DOM的元素；
3.为让浏览者特定的浏览器配置适应DOM元素或文档数据结构，应用必要的任何变换或其它变化；
4.生成显现所述对象必需的HTML；和
5.把该HTML应用到DOM元素，让它在浏览器中显示。
上述处理的步骤3包括下述子步骤：
a.设定背景色；
b.创建用于显现的幻灯片层；
c.使所述幻灯片层显示有效；
d.对所述显现与所述幻灯片的地址初始化；
e.对所述幻灯片内的各种幻灯片元素初始化；和
f.建立调节尺寸处理程序。
当幻灯片元素为文本体时，上述处理的子步骤(e)包括下述分子步骤：
(aa)建立所述文本体的地址；
(ab)创建所述文档体的层；和
(ac)使所述层的显示有效。当所述幻灯片元素为图象体时，子步骤(e)包括下述分子步骤：(ba)建立所述图象体的地址；(bb)创建所述图象体的层；和(bc)使所述层的显示有效。当所述幻灯片元素为轮廓体时，子步骤(e)包括下述分子步骤：(ca)建立所述轮廓体的地址；和(cb)对所述轮廓体的轮廓节点初始化。上述处理的步骤4包括下述子步骤：(da)获得客户屏目尺寸；(db)设定所述幻灯片层的剪裁区；(dc)显现所述幻灯片内的各种幻灯片元素；和(de)将输出刷新所述层。当幻灯片元素为文本体时，步骤4下的子步骤(dc)包括下述分子步骤：(a1)设定层色并对齐；(a2)生成要显示的文本；(a3)写URL起始标记；(a4)写样式与所述文本；和(a5)写URL结束标记。当幻灯片元素为图象体时，步骤4下的子步骤(dc)包括下述分子步骤：(b1)设定层背景色；(b2)若幻灯片可编辑，写空白内容串；(b3)获得图象源的URL；(b4)写URL起始标记；(b5)显现所述图象；和(b6)写URL结束标记。当幻灯片元素为轮廓体时，步骤4下的子步骤(dc)包括下述分子步骤：(c1)建立默认属性；(c2)创建显现上下文范围并初始化；(c3)设定起点与有效宽度；(c4)按所述显现范围显现轮廓节点；和(c5)隐藏不使用的层。
在通过Web服务器向浏览者的浏览器提供文档数据结构时，即描述文档的数据结构而不是该文档的HTML再现，当拥有创建合适尺寸文档所必需的浏览器信息时，就能产生该文档的HTML，这样，就能对文档的所有特征相应地进行调整。而且，数据结构可响应用户情况而修改(并随后再生相应的HTML)，因而，在文档初步建立之后，可以对其更新以便把变化反映给浏览者的浏览器。例如，若浏览者改变浏览器的尺寸，页面元素就自动调整尺寸。
因此，通过创建浏览器无关的数据结构，页面作者能自由地访问和修改文档所有相关的方面，而不用担心浏览器DOM的限制。这种浏览器无关性还能使作者为解释该结构开发单个脚本，而不用为解释不同的浏览器DOM而需要两种(或多种)脚本。
其附带好处是可将作者定义的数据结构优化成只包含最重要的信息，使它们比同等的HTML小得多，有利于缩短传输时间，尤其在低带宽的通信线路上更是如此。
文档数据结构和解释码可包含在单个文档内，这使得传送和移植更方便，不过这要求解释码与每个文档一起发送。
文档数据结构与解释码之间的区别，实质上是一种状态对行为(state.vs.behavior)之一。文档数据代表显示文档所必需的状态，与行为很少或没有关联。解释码则提供理解文档数据结构并创建代表它的HTML所必需的行为。
解释码可与文档数据结构码分开，预计这是一种更吸引人的办法，因为这样可让浏览器把解释码缓冲起来供以后在另一相似的文档上使用。
图2的框图示出文档数据结构140的层次结构。第一层为SXPresentation200，是显现数据结构的根对象，它包含处于第二层的SXSlides阵列。
SXSlide 210是代表显现中的单张幻灯片的对象。它包含许多处于第三层的SXContentEntities 220。
SXContentEntity 220是许多种不同类型幻灯片元素之一的抽象表示，这些类型包括：SXText 230、SXOutline 240与SXImage 250。
SXOutline 240又可包含其它子轮廓260。
在显现数据结构中的这些实体中每个都具有各种与其相关的属性，这些属性在下列表中有描述。
该系统支持有限的标记置换功能。表1包括：(1)识别标记，(2)发生置换范围，和(3)被置换的值。
表1.标记置换
| 标记 | 范围 | 值 |
| ％SlideNumber％ | SlideNumber(SXText) | 当前幻灯片索引(从“1”开始) |
| ％SlideCount％ | SlideNumber(SXText) | 显现的幻灯片总数 |
另一些标记应使用“％TokenName％”记号。
标记置换是运用严密的串匹配法来完成，只置换包括围以“％”的字符的文本(该文本与该标记严密匹配)。然而，目前还无法避免(escape)“％”字符，因此，例如，就无法让“％SlideNumber％”串出现在SlideNumber元素中。
表2～8列出不同属性的类型。这种类型描绘了对象的语义类型，在串数据类型中不一定包含数据类型，如zIndex属性，该属性列为“整数”类型。表2列出该类型字段。表2类型字段
| 串 | 含任何有效字母数字字符的值。在Javascript中，应避免“/”与“n”字符。 |
| 整数 | 整数值(如“1234”或“-1234”)。 |
| 浮点 | 浮点值(如“1.234”或“-1.234”)。一般不用指数表示法(不保证能够支持)。 |
| 色彩 | HTML样式色彩值。可以是色彩名称，但常用色码，以“#RRGGBB”表示。 |
| 阵列 | 有序的对象集合。 |
| 散列映射 | 映射的对象集合。 |
表3 SXPresentation
| 属性 | 类型 | 说明 |
| currentSlideIndex | 整数 | 当前显现幻灯片的标引。它是显现中幻灯片的真实标引。 |
| isSample | 布尔 | 用于取样显现为真。 |
| isStyle | 波尔 | 用于样式显现为真。 |
| isTemplate | 波尔 | 用于膜板显现为真。 |
| presentationID | 整数 | 显现的数据库id。 |
| slideCount | 整数 | 显现幻灯片总数。 |
| slides | 阵列 | 构成显现的幻灯片阵列。注：该阵列不保证所有显现的幻灯片完全包括在内，一般仅含单一对象(索引0)。幻灯片实际索引可在currentSlideIndex属性中找到。 |
| SlideTitles | 阵列 | 串阵列，含每张显现幻灯片的标题。当前幻灯片标题可在slideTitles[currentSlideIndex]中找到。 |
| type | 串 | 值：com.iamaze.presentation.SXPresentation. |
表4 SXSlide
| 属性 | 类型 | 说明 |
| contentEntities | 散列映射 | 包括幻灯片内容的SXContentEntities组。 |
| effect | 串 | 显示幻灯片时，所使用的效果类型。值：·向左飞入：幻灯片元素从右侧飞入·向右飞入：幻灯片元素从左侧飞入·向上飞入：幻灯片元素从底部飞入·向下飞入：幻灯片元素从上部飞入·闪烁：幻灯片元素只“闪烁”。(通常只有标题与轮廓元素显现该效果)·建立：每次鼠标点击逐渐露出幻灯片元素。(通常只以每次点击露出一个顶层元素的方式露出当前的轮廓元素-) |
| layoutName | 串 | 该显现所基于的布局名称。 |
| notes | 串 | 用户提供的幻灯片注释(通常不用于任何感兴趣的东西)。 |
| title | 串 | 幻灯片标题。 |
| type | 串 | 值：com.iamaze.presentation.SXSlide |
表5 Abstract SXContentEntity
| 属性 | 类型 | 描述 |
| top | 串 | 这些值规定了实体所占据的矩形 |
| left | 串 | |
| width | 串 | |
| height | 串 | |
| type | 串 | 对象类型—实际上是负责存贮该实体的SXPersistentContentEntity子类的完整java路径名称。值：·com.iamaze.presentation.contenttype.SXText·com.iamaze.presentation.contenttype.SXOutline·com.iamaze.presentation.contenttype.SXImage |
| name | 串 | 元素名称。值：为幻灯片背景元素保留的名称背景。 |
| zIndex | 整数 | 幻灯片中层元素的z排序。背景元素总为索引0(底层)。 |
表6 继承Abstract SXContentEntity所有属性的SXText
表7 继承SXText所有属性的SXOutline实体
表8 继承Abstract SXContentEntity所有属性的SXImage
| 属性 | 类型 | 描述 |
| fontSize | 整数 | 字体磅数 |
| color | 色彩 | 文本色彩 |
| backgroundColor | 色彩 | 背景色 |
| fontFamily | 串 | 字体系列 |
| fontWeight | 串 | 字重；值：粗体 |
| align | 串 | 水平对齐值：左，中，右 |
| text | 串 | 实体内容 |
| verticalAlign | 串 | 垂直对齐值：顶，中，底 |
| url | 串 | 播放期间点击时时所要定位的URL，注：若没有前标“/”或协议(如未预先考虑“http：//”，“http：//”) |
| fontStyle | 串 | 字体；值：斜体 |
| 属性 | 类型 | 说明 |
| align | 串 | 在SXOutline实体中略去 |
| verticalAlign | 串 | 在SXOutline实体中略去 |
| nodeBulletType | 串 | 项目符号(bullet)类型值：文本-符号，文本-字母-小写，文本-字母-大写，文本-数字-单调，文本-数字-嵌套，文本-罗马字-小写，文本-罗马字-大写，图象注：不必需图象与文本数字嵌套型(Uwe，你不用支持这些类型) |
| nodeBulletValue | 串 | 是规定如何看项目符号的值。这要根据nodeBulletType里规定的类型，进行不同地解释，如下：文本-符号：该值是要显示的统一代码字符的十进制数值。这里的零值为出错。文本-字母-小/大写、文本-数字-单调/嵌套和文本-罗马字-小/大写：该值是进入各序列的索引。值0、1、2对应于下述(在逻辑上跟随的后续值)：·文本-字母-小/大写：a、b、c/A、B、C·文本-数字-单调/嵌套：1、2、3/(不必需)·文本-罗马字-小/大写：i、ii、iii/I、II、III注意，这些是基本项目符号。若不规定值，就自动使用前一索引+1。若项目符号是节点阵列中的第一项目符号，则索引默认为0。 |
| nodes | 阵列 | SXOutlines阵列，是该轮廓的产物 |
| 属性 | 类型 | 说明 |
| align | 串 | 水平对齐；值：左、中、右 |
| backgroundColor | 色彩 | |
| scale | 串 | 显示图象时使用的定标模式；值：·配合：图象定标成在边界内准确符合。·宽度：图象定标，保持高宽比，图象宽度在边界内准确配合。·高度：图象定标，保持纵横比，图象高度在边界内准确配合。·分割：图象以其原尺寸分割，以准确地填满图象边界(分割原点左上角)。注：对宽度与高度定标，在图象溢出图象边界时不剪裁。 |
| src | 串 | 显示在该实体内的图象URL |
| url | 串 | 播放期间点击时，要定位的URL。注：若前面无“/”或协议(如未预先考虑“http：//”，“http：//”) |
| verticalAlign | 串 | 垂直对齐。值：上、中、下 |
本系统中，特别对名为“背景”的SXImage实体进行处理。该内容实体描述了幻灯片背景，并按下述方法处理：
其边界总是准确地对应于幻灯片界限。
其z索引始终置零(0)。
表9是JavaScript的程序片段，说明文档数据结构的概貌。在该样本中，文档是显现文档的一张幻灯片。表10是解释该幻灯片数据结构的JavaScript。表11是针对轮廓解释数据结构的JavaScript。表12是Web服务器用来把任意散列映射(如检索自数据库)转换成浏览者浏览器里JavaScript数据结构的Java源代码。表9用于显示文档中一个幻灯片的JavaScript
var presentation＝{
type：′com.iamaze.presentation.SXPresentation′，
isStyle：false，
presentationID：′com.iamaze.presentation.SXPresentation_931181
isTemplate：false，
currentSlideIndex：′5′，
slideCount：′7′，
slides：{
{
contentEntities：{
Subtitlel：{
fontSize：′28′，
top：′13％′，
width：′60％′，
color：′FF9933′，
backgroundColor：null，
fontFamily：null，
fontWeight：null，
height：′6％′，
align：′center′，
text：′As anywhere，street vendors abound′，
verticalAlign：′top′，
url：null，
fontStyle：′italic′，
left：′37％′，
zIndex：′6′，
type：′com.iamaze.presentation.contenttype.SXText′，
name：′Subtitlel′
}，
Outlinel：{
fontSize：null，
top：′20％′，
width：′36％′，
color：null，
backgroundColor：null，
fontFamily：null，
fontWeight：null，
height：′66％′，
align：null，
nodeBulletType：null，
text：null，
verticalAlign：null，
url：null，
fontStyle：null，
nodeBulletValue：null，
<!-- SIPO <DP n="14"> -->
<dp n="d14"/>
nodes：[
{
fontSize：′28′，
top：null，
width：null，
color：′333300′，
backgroundColor：null，
fontFamily：′Georgia，Times New Roman，Times，
serif′，
fontWeight：null，
height：null，
align：null，
nodeBulletType：′text-symbol′，
text：′The Island of Nax′，
verticalAlign：null，
url：null，
fontStyle：null，
nodeBulletValue：′8226′，
nodes：null，
left：null，
zIndex：null，
type：′com.iamaze.presentation.contenttype.SXOutline′，
name：null
fontSize：′28′，
top：null，
width：null，
color：′333300′，
backgroundColor：null，
fontFamily：′Georgia，Times New Roman，Times，
serif′，
fontWeight：null，
height：null，
align：null，
nodeBulletType：′text-symbol′，
text：′When in the Islands，seafood is a must.
You can\′t find any fresher or more delicious octopus anywhere.′，
verticalAlign：null，
url：null，
fontStyle：null，
nodeBulletValue：′8226′，
nodes：null，
left：null，
zIndex：null，
type：′com.iamaze.presentation.contenttype.SXOutline′，
name：null
}
]，
left：′50％′，
zIndex：′7′，
type：′com.iamaze.presentation.contenttype.SXOutline′，
name：′Outline1′
}，
StyleImagel：{
scale：null，
top：′0′，
width：′3％′，
backgroundColor：′9966CC′，
<!-- SIPO <DP n="15"> -->
<dp n="d15"/>
height：′100％′，
align：′center ′，
verticalAlign：′middle′，
url：null，
src：null，
left：′0′，
zIndex：′7′，
type：′com.iamaze.presentation.contenttype.SXImage′，
name：′StyleImagel′
}，
Titlel：{
fontSize：′27′，
top：′5％′，
width：′90％′，
color：′333300′，
backgroundColor：null，
fontFamily：′Georgia，Times New Roman，Times，serif′，
fontWeight：′bold′，
height：′10％′，
align：′center′，
text：′Octopii Vendors′，
verticalAlign：′center′，
url：null，
fontStyle：null，
left：′5％′，
zIndex：′6′，
type：′com.iamaze.presentation.contenttype.SXText′，
name：′Titlel′
}，
Background：{
scale：′fit′，
top：null，
width：null，
backgroundColor：null，
height：null，
align：′center′，
verticalAlign：′middle′，
url：null，
src：′/images/backgrounds-large/Waterlilies-
1024x768_7.jpg′，
left：null，
zIndex：′1′，
type：′com.iamaze.presentation.contenttype.SXImage′，
name：′Background′
}，
Imagel：(
scale：′width′，
top：′20％′，
width：′36％′，
backgroundColor：null，
height：′66％′，
align：′right′，
verticalAlign：′top′，
url：null，
src：′/images/samples/NaxOctopi.jpg′，
left：′10％′，
zIndex：′8′，
type：′com.iamaze.presentation.contenttype.SXImage′，
name：′Imagel ′
<!-- SIPO <DP n="16"> -->
<dp n="d16"/>
effect：null，
layoutName：′lOutline+lImage-2′，
notes：null，
title：′Octopii Vendors′，
old contentEntities：null，
type：′com.iamaze.presentation.SXSlide′
}
]，
slideTitles：[
′＜Travel Destination goes here＞′，
′＜A Title for Photos Below＞′，
′＜Add a Title for the Images＞′，
′＜Third Destination Goes Here＞′，
′The Whitewashes of Greece′，
′Octopii Vendors′，
′Next stop，Indonesia！\n\n\′Til then...\n-Rosie′
]，
isSample：false
}；
表10解释幻灯片数据结构的JavaScript
function CXSlide(){}；
CXSlide.version＝1；
CXSlide.name＝′Slide′；
CXSystem.registerLibrary(CXSlide)；
/**************************/
//
//Global vars
//
//The last width and height of the window(only used on NS4)
var lastWidth＝0，lastHeight＝0；
//Flag for turning DOM validation on and off
var DEBUG_DOM＝false；
debugRegisterFlag(′DEBUG_DOM′)；
//Error string
var WARNING_NO_SLIDE_LAYER＝′Unable to locate the slide layer.A
temporary one will be created but the quality of this page will be
degraded.′；
//The name of the layer that contains the slide
var SLIDE_NAME＝′Slide′；
//The name of the layer that contains the background
var BACKGROUND_NAME＝′Background′；
//The virtual width，height，and diagonal of the slide
var V_WIDTH＝1024；
var V_HEIGHT＝768；
var V_DIAG＝Math.sqrt(V_WIDTH*V_WIDTH+V_HEIGHT*V_HEIGHT)；
<!-- SIPO <DP n="17"> -->
<dp n="d17"/>
//Default strings to show
var DEFAULT_DIRECTIONS＝(ie4)？′Double click′：′Click here and
choose″Properties″′；
var DEFAULT_TEXT_STRING＝′to edit′；
var DEFAULT_IMAGE_STRING ＝′to specify image′；
//Types of content elements
var CLASS_PACKAGE＝′com.iamaze.presentation′；
var PRESENTATION_CLASS＝CLASS_PACKAGE+′.SXPresentation′；
var SLIDE_CLASS＝CLASS_PACKAGE+′.SXSlide′；
var TEXT_CLASS＝CLASS_PACKAGE+′.contenttype.SXText′；
var IMAGE_CLASS＝CLASS_PACKAGE+′.contenttype.SXImage′；
var OUTLINE_CLASS＝CLASS_PACKAGE+′.contenttype.SXOutline′；
//Constants for the ′scale′field of image entities
var SCALE_NONE＝null；
var SCALE_FIT＝′fit′；
var SCALE_WIDTH＝′width′；
var SCALE_HEIGHT＝′height′；
var SCALE_TILE ＝′tile′；
//The path to the shim image
var SHIM_IMAGE＝′/html/images/shim.gif′；
//Define and set variable indicating whether or not the slide can be
edited
var slideIsEditable＝false；
//The layer containing the slide
var slideLayer＝null；
//Flag indicating whether or not this is the first rendition of the
page
var slideIsRendered＝false；
//The width of the client document area
var clientWidth＝V_WIDTH；
var clientHeight＝V_HEIGHT；
//A prefix we use to uniquely name our images
var IMAGE_NAME_PREFIX＝″iamaze″
//The scale factors we use to resize the slide
var xScale＝l.0；
var yScale＝1.0；
var scale＝1.0；
//PENDING(RWK)-Quick patch to get the new data structure working
var slide＝presentation.slides[0]；
var slideContent＝slide.contentEntities；
var resizeTimeout＝null；
var slideResizeInterva ＝null；
/*
*Called during document.onload()
*/
CXSlide.onload＝function() {
if(ns4||！isRenderingEnabled()) setShowingBatched(true)；
//Set the background color if we′re not editing
<!-- SIPO <DP n="18"> -->
<dp n="d18"/>
if (！slideIsEditable &&
slide.contentEntities.Background.backgroundColor){
document.bgColor＝
slide.contentEntities.Background.backgroundColor；
}
//Get the layer containing the slide
slideLayer＝getNamedLayer(SLIDE_NAME)；
if (slideLayer＝＝null){
warning(WARNING_NO_SLIDE_LAYER)；
slideLayer＝newNamecLayer(SLIDE_NAME，null)；
slideLayer，setSize(640，480)；
slideLayer，setOrigin(200，150)；
}
slideLayer.show()；
//Initialize the presentation & slide address
presentation._address＝presentation.presentationID；
setupEntity(presentation.slides[0]，′Slide′，SLIDE_CLASS，
presentation)；
// slideCacheAddress()；
//Init the various slide elements
for (var myName in slideContent){
var myContent＝slideContent[myName]；
setupEntity(myContent，myName，myContent.type，slide)；
}
//Mark the last known width and height for NS resize bug
workaround
// (See comments in slideResize() for more details)
if (ns4){
lastWidth＝window.innerWidth；
lastHeight＝window.innerHeight；
}
// Set up the resize handler
if (！ns4||！slideIsEditable){
window.onresize＝slideResize；
} else {
//PENDING(RWK)-NS4 workaround：In NS4.5/4.7，the resize
event
//doesn′t appear to be getting sent in the edit slide page.
We′ve
//been unable to pin this down to anything more than the page
just
//being pretty complex(layer-wise).To work around this，we
set
//up a timer that to call the resize handler everv second or
so.
//This works because，on Netscape，this handler only does
//something if the window actually changes size.
slideResizeInterval＝setInterval(′slideResize()；′，1000)；
}
//Render the slides
render()；
if (ns4) setShowingBatched(false)；
slideIsRendered＝true；
<!-- SIPO <DP n="19"> -->
<dp n="d19"/>
/*
*The Document Type Definition we use to do some checking of the
integrity
*
*The fields are：
* attributeName，datatype，required/optional，defaultvalue
*
*the defaultValue may be left out，in which case null is used
*/
var dtd＝{
SXPresentation：[
[′currentSlideIndex′， ′number′， ′required′]，
[′presentationID′， ′string′， ′required′]，
[′slideCount′， ′number′， ′required′]，
[′slides′， ′object′， ′required′]，
[′slideTitles′， ′object′， ′required′]
]，
SXSlide：[
[′title′， ′string′， ′optional′]，
[′layoutName′， ′string′， ′optional′]，
[′contentEntities′， ′object′， ′required′]，
[′notes′， ′string′， ′optional′]
]，
SXImage：[
[′align′， ′string′， ′optional′]，
[′backgroundColor′， ′color′， ′optional′]，
[′height′， ′string′， ′optional′]，
[′left′， ′string′， ′optional′]，
[′scale′， ′string′， ′optional′]，
[′src′， ′string′， ′optional′]，
[′top′， ′string′， ′optional′]，
[′verticalAlign′，′string′， ′optional′]，
[′width′， ′string′， ′optional′]，
[′zIndex′， ′number′， ′optional′]
]，
SXText：[
[′align′， ′string′， ′optional′]，
[′backgroundColor′， ′color′， ′optional′]，
[′color′， ′color′， ′optional′]，
[′fontFamily′， ′string′， ′optional′]，
[′fontSize′， ′number′， ′optional′]，
[′fontStyle′， ′string′， ′optional′]，
[′fontWeight′， ′string′， ′optional′]，
[′height′， ′string′， ′optional′]，
[′left′， ′string′， ′optional′]，
[′text′， ′string′， ′optional′]，
[′top′， ′string′， ′optional′]，
[′url′， ′string′， ′optional′]，
[′verticalAlign′，′string′， ′optional′]，
[′width′， ′string′， ′optional′]，
[′zIndex′， ′number′， ′optional′]
]，
SXOutline：[
[′align′， ′string′， ′optional′]，
[′backgroundColor′， ′color′， ′optional′]，
[′color′， ′color′， ′optional′]，
[′fontFamily′， ′string′， ′optional′]，
[′fontSize′， ′number′， ′optional′]，
[′fontStyle′， ′string′， ′optional′]，
[′fontWeight′， ′string′， ′optional′]，
<!-- SIPO <DP n="20"> -->
<dp n="d20"/>
[′height′， ′string′， ′optional′]，
[′left′， ′string′， ′optional′]，
[′nodeBulletType′， ′string′， ′optional′]，
[′nodeBulletValue′， ′any′， ′optional′]，
[′nodes′， ′object′， ′optional′]，
[′text′， ′string′， ′optional′]，
[′top′， ′string′， ′optional′]，
[′url′， ′string′， ′optional′]，
[′verticalAlign′， ′string′， ′optional′]，
[′width′， ′string′， ′optional′]，
[′zIndex′， ′number′， ′optional′]
]
}；
//Run the dom check
setStatus(′Validating DOM′)；
if (presentation.currentSlideIndex) presentation.currentSlideIndex＝
parseInt(presentation.currentSlideIndex)；
validateDOM(presentation)；
setStatus(″)；
/*
* Methods to report an error in the DOM
*/
function domWarning(aProperty，aString){
if (DEBUG_DOM) debugWriteln(′DOM Warning(′+ aProperty+′)：′+
aString)；
}
function domError(aProperty，aString){
debugWriteln(′DOM Error(′+aProperty+′)：′+aString)；
}
/*
*Validate the integrity of the dom
*/
function validateDOM(aNode){
var myConstraints；
//Select which set of constraints we want
if (aNode.type＝＝PRESENTATION_CLASS){
myConstraints＝dtd.SXPresentation；
} else if (aNode.type＝＝SLIDE_CLASS){
myConstraints＝dtd.SXSlide；
} else if (aNode.type＝＝IMAGE_CLASS){
myConstraints＝dtd.SXImage；
} else if (aNode.type＝＝TEXT_CLASS){
myConstraints＝dtd.SXText；
} else if (aNode.type＝＝OUTLINE_CLASS){
myConstraints＝dtd.SXOutline；
} else{
debugWriteln (′DOM Error：Unrecognized type- ′+aNode.type)；
debugObject(aNode)；
return；
}
//Check each property in the constraints
for (var i＝0；i＜myConstraints.length；i++){
var myProperty＝myConstraints[i][0]；
var myType＝myConstraints[i][1]；
var myConstraint＝myConstraints[i][2]；
<!-- SIPO <DP n="21"> -->
<dp n="d21"/>
var valType＝typeof(aNode[myProperty])；
if (valType＝＝UNDEFINED){
domError(myProperty，′Undefined property. Setting to
null.′)；
aNode[myProperty]＝null；
} else{
var myVal＝aNode[myProperty]；
if (myVal＝＝null){
if (myConstraint＝＝′required′){
domError(myProperty，′Required property not set′)；
}
} else{
if (valType！＝myType){
if (myType＝＝′number′){
domWarning(myProperty，′Recasting to′+myType)；
aNode{myProperty]＝myVal*l；
} else if(myType＝＝′string′){
domWarning(myProperty，′Recasting to′+myType)；
aNode{myProperty]＝myVal+′′；
} else if (myType＝＝′color′){
//PENDING(RWK)-Remove this when we no longer
have problems with
//colors being set to unexpected values
if ((myVal＝＝UNDEFINED) ||
((myVal.search(/[^0-9，a-f，A-F]/)＝＝-1) &&
(myVal.length！＝6))){
domError(myProperty，′Bad color value″′+
myVal+′″.Setting to null.′)；
aNode[myProperty]＝null；
} else{
}
} else if (myType！＝′any′){
domError(myProperty，′Can\′t convert to′+
myType)；
}
}
}
}
}
//Go to the next node
if (aNode.type＝＝PRESENTATION_CLASS){
myConstraints＝＝dtd.SXPresentation；
validateDOM(aNode.slides[0])；
} else if (aNode.type＝＝SLIDE_CLASS){
if (aNode.contentEntities！＝null){
for (var myName in aNode.contentEntities){
validateDOM(aNode.contentEntities[myName])；
}
}
} else if (aNode.type＝＝OUTLINE_CLASS){
//PENDING(RWK)-Check for image bullet types and turn them
//into bullets.
//Once we′re confident there aren′t any more image bullets in
//presentations，this can check can be removed.
if (aNode.nodeBulletType＝＝′image′){
aNode.nodeBulletType＝′text-symbol′；
aNode.nodeBulletValue＝9679；
domWarning(myProperty，′Image bullet found.(Converting to
a symbol bullet，but you should do this manually to avoid this
warning in the future.)′)；
<!-- SIPO <DP n="22"> -->
<dp n="d22"/>
}
//Check the subnodes of this node
if(aNode.nodes！＝null){
for(var i＝0；i＜aNode.nodes.length；i++){
validateDOM(aNode.nodes[i])；
}
}
}
//Cache the urls of images that we want to preload
if (aNode.type＝＝IMAGE_CLASS){
CXUtil.preloadImage(aNode.src)；
} else if (aNode.type＝＝OUTLINE_CLASS){
if (aNode.nodeBulletType＝＝′image′){
CXUtil.preloadImage(aNode.nodeBulletValue)；
}
}
/*
*Resize handler to manage resizing of the slide
*/
function slideResize(anEvent){
if (ns4){
//PENDING(RWK)-NS4 workaround：Netscape massacres javascript
//code when the window is resized. We detect actual window
size
//changes and force a complete refresh of the document. (The
//downside of this is that all javascript state is lost.)
if((lastWidth！＝window.innerWidth)||
(lastHeight！＝window.innerHeight)){
if (slideResizeInterval){
clearInterval(slideResizeInterval)；
slideResizeInterval＝null；
}
if(resizeTimeout)clearTimeout(resizeTimeout)；
window.location.href＝window.location.href；
}
} else{
if(！slideIsEditable){
if ((typeof(playbackControls)！＝UNDEFINED) &&
playbackControls.isVisible()){
playbackControls.hide()；
}
render()；
}
}
return false；
}
/*
*This function is called whenever the address needs to be set
*/
function setAddress(myContent，myName，myParent){
//Set the name and address of the content object
myContent._name＝myName；
myContent._subtype＝myContent._name.replace(/[0-9]/g，″)；
if (myContent.type＝＝PRESENTATION_CLASS){
myContent._address＝presentation.presentationID；
<!-- SIPO <DP n="23"> -->
<dp n="d23"/>
} else if (myContent.type＝＝SLIDE CLASS){
myContent._address＝myParent._address+
′.slides[′+presentation.currentSlideIndex+′]′；
} else{
myContent._address＝slide._address+
′.contentEntities[′+myContent._name+′]′；
}
}
/*
* Call this to turn off rendering
*/
function setRenderingEnabled(aFlag){
// NB：this may be set in the html
if {typeof(renderingDisableLevel)＝＝UNDEFINED)
renderingDisableLevel＝0；
if (aFlag && renderingDisableLevel＞0){
renderingDisableLevel--；
} else{
renderingDisableLevel++；
}
}
/*
* Is rendering turned off
*/
function isRenderingEnabled(){
if (typeof(renderingDisableLevel)＝＝UNDEFINED){
return true；
}
return (renderingDisableLevel＜＝0)；
}
/*
* This function runs various setups for a new entity.
* It is only called by newEntity().
//PENDING(HJK) this should maybe be used in slideInit and slideCache
address
*/
function setupEntity(myContent，myName，myClass，myParent){
myContent.type＝myClass；
setAddress(myContent，myName，myParent)；
if (myContent.type＝＝OUTLINE_CILASS) initOutline(myContent)；
if ((myContent.type＝＝TEXT_CLASS )||
(myContent.type＝＝IMAGE_CLASS)){
//Create the layer we′ll need for the object
myContent._layer＝newNamedLayer(myName，slideLayer.layer)；
//Create association between content and layer
myContent._layer._content＝myContent；
//Make the layer visible
myContent._layer.show()；
}
}
//
//Size caching methods
<!-- SIPO <DP n="24"> -->
<dp n="d24"/>
//
/*
* Cache the address information of DOM objects
*/
function slideCacheAddress(){
// Initialize the presentation & slide address
presentation._address＝presentation.presentationID；
slide._address＝presentation._address+
′.slides[′+presentation.currentSlideIndex+′]′；
// Init the various slide elements
for (var myName in slideContent){
var myContent＝slideContent[myName]；
// Set the name and address of the content object
setAddress(myContent，myName，slide)；
if (myContent.type＝＝OUTLINE_CLASS){
outlineCacheAddress(myContent)；
}
}
}
/*
* Update any geometry we′re interested in
*/
function cacheSizes(){
// Use the slide layer width/height to find the scaling factors
if (ns4 && slideIsEditable) {
// PENDING(RWK)-Unfortunately on netscape the Slide layer
// may be clipped(e.g.if the window is really small).
There′s
//know way to know what the layer size is supposed to be.
//So，to make sure the elements are shown at the proper size
//during editing(the only time this is really a problem)
//we hard code the size here.
clientWidth＝560；
clientHeight＝420；
} else{
var myBounds＝slideLayer.getBounds()；
clientWidth＝myBounds.width；
clientHeight＝myBounds.height；
}
/* PENDING(RWK)-Code to use the window dimensions as the slide size
if (ns4) {
clientWidth＝window.innerWidth；
clientHeight＝window.innerHeight；
} else{
clientWidth＝document.body.clientWidth；
clientHeight＝document.body.clientHeight；
}
*/
// Figure the scaling factors
xScale＝clientWidth/V_WIDTH；
yScale＝clientHeight/V_HEIGHT；
scale＝(xScale＜yScale)？xScale：yScale；
//Use this to scale based on the diagonal of the display area
<!-- SIPO <DP n="25"> -->
<dp n="d25"/>
//scale＝Math.sqrt(clientWidth*clientWidth+
clientHeight*clientHeight)/V_DIAG；
}
//
// Bounds retrieval methods
//
/*
* Translate the dimensions of a layout object to real layer
coordinates
*/
function getAdjustedBounds(aContent){
var myBounds＝new Object()；
if ((aContent.left！＝null) &&
(typeof(aContent.left)＝＝′string′) &&
(aContent.left.lastIndexOf(′％′)！＝-1)){
myBounds.left＝parseInt(aContent.left)*clientWidth/100；
} else {
myBounds.left＝(myBounds.left！＝null)？
parseInt(aContent.left)：null；
}
if ((aContent.top！＝null) &&
(typeof(aContent.top)＝＝′string′) &&
(aContent.top.lastIndexOf(′％′)！＝-1)){
myBounds.top＝parseInt(aContent.top)*clientHeight/100；
} else {
myBounds.top＝(myBounds.top！＝null)？parseInt(aContent.top)
：null；
}
if ((aContent.width！＝null) &&
(typeof(aContent.width)＝＝′string′) &&
(aContent.width.lastIndexOf(′％′)！＝-1)){
myBounds.width＝parseInt(aContent.width)*clientWidth/100；
} else {
myBounds.width＝(myBounds.width！＝null)？
parseInt(aContent.width)：null；
}
if ((aContent.height！＝null) &&
(typeof(aContent.height)＝＝′string′) &&
(aContent.height.lastIndexOf(′％′)！＝-1)){
myBounds.height＝parseInt(aContent.height)*clientHeight/100；
} else {
myBounds.height＝(myBounds.height！＝null)？
parseInt(aContent.height)：null；
}
myBounds.zIndex＝aContent.zIndex；
return myBounds；
}
/*
* Return a value scaled by the generic scaling factor
*/
functicn adjust(aNum){
var myVal＝aNum*scale；
<!-- SIPO <DP n="26"> -->
<dp n="d26"/>
return(isNaN(myVal))？aNum：Math.round(myVal)；
}
/*
* Return a value scaled by the width scaling factor
*/
function adjustX(aNum){
if (typeof(aNum)！＝′number′)return aNum；
return Math.round(aNum*xScale)；
}
/*
* Return a value scaled by the height scaling factor
*/
function adjustY(aNum){
if(typeof(aNum)！＝′nurmber′)return aNum；
return Math.round(aNum*yScale)；
}
//
//Rendering methods
//
/*
* Render all the layers named in the content object
*/
function render(){
//Get the client screen size
cacheSizes()；
if (！isRenderingEnabled()) return；
// Set the clipping region of the slide layer
//
// PENDING(RWK)-NS4 workaround；without this clip，NS4
// clips the slide to approximatlely 1/2 it’s width
slideLayer.setClipRect(0，0，clientWidth，clientHeight)；
// Render each content element
for (var myName in slideContent){
setStatus(′Rendering(′+myName+′)′)；
renderContent(myName)；
}
}
/*
* Need this on netscape so we can fix the display(not doneyet)
*/
function hasTransparentImages(){
for (var myName in slideContent){
var myContent＝slideContent[myName]；
if (myContent.type＝＝IMAGE_CLASS &&
myContent.backgroundColor＝＝null){
return true；
}
}
return false；
}
/*
* Write the contents associated with a layer
<!-- SIPO <DP n="27"> -->
<dp n="d27"/>
*/
function renderContent(aName，isMove){
if (！isRenderingEnabled())return；
// PENDING(RWK)-Minor hack to make sure we render an entire
outline，even
// if we′re passed the name of one of the subnodes
// (Also note that the regex is not supposed to be a string！Very
wierd.)
aName＝aName.replace(/：.*/g，″)；
// Get references to the properties
var myContent＝slideContent[aName]；
// Get the adjusted bounds(as a separate object so that if the
window
// is resized，we still have the original specification to
recompute
// from.)
var myBounds＝getAdjustedBounds(myContent)；
// Get the layer the content will be rendered into
var myLayer＝myContent._layer；
// For easy content...
if (myContent.type！＝OUTLINE_CLASS)(
// Error check for missing layer
if(！myLayer){
warning(′Unable to locate layer″′+aName+′″′)；
return；
}
// Explicitely set the layer index.
myLayer.style.zIndex＝myBounds.zIndex；
//Set the layer position
myLayer.setOrigin(myBounds.left，myBounds.top)；
if(！isMove){
myLayer.setSize(myBounds.width，myBounds.height)；
// Set the default alignments
myLayer.setAlign(′center′)；
myLayer.setVerticalAlign(′middle′)；
if (ns4){
// Netscape does not understand 0 dimension，it reads
this as unbounded
if (！myBounds.width || myBounds.width＜＝0)
myBounds.width＝1；
if(！myBounds.height || myBounds.height＜＝0)
myBounds.height＝1；
}
// Call the appropriate renderer，based on type
if (aName＝＝BACKGROUND_NAME){
renderBackground(myLayer，myContent，myBounds)；
} else if (myContent.type＝＝TEXT_CLASS){
renderText(myLayer，myContent，myBounds)；
} else if (myContent.type＝＝IMAGE_CLASS){
renderImage(myLayer，myContent，myBounds)；
}
<!-- SIPO <DP n="28"> -->
<dp n="d28"/>
// Flush what we′ve written to the layer
myLayer.flush()；
}
} else {
// Special case for outline
renderOutline(myLayer，myContent，myBounds，(！isMove)？false：
true)；
}
}
/*
* All hyperlinks come through this method，to apply rules to URLs，
and display.
*
* URL munging：
* any string with an″@″w/o a protocol is assimed to be a mailto：
* any plain number is assumed to be a slideNUMBER(as distinct from
a slideID)
* any string starting with″？″are assumed to be a link to another
presentation on this host
* any string (other than the ones above) w/o a protocol get
″http：//″added to them.
*
* Display：
* any iamaze URL is shown in this window
* all ther windows appear in a separate window
*/
function startLinkTag(aURL){
var myLink＝null；
var myTarget＝′target＝″user_link″′；
if(slideIsEditable){
myLink＝′＜u＞′；
] else {
if (aURL.indexOf(′：′)＝＝-1){
if (aURL.indexOf(′@′)！＝-1){
aURL＝″mailto：″+aURL；
} else {
var myNumber＝parseInt(aURL)；
// if the url is a number，treat as a slideNumber(origin
1)
if (！isNaN(myNumber) && (myNumber+′′)＝＝myNumber){
// Force number into proper range
if (myNumber＜1){
myNumber＝1；
} else if(myNumber＞
presentation.slideTitles.length){
myNumber＝presentation.slideTitles.length；
}
aURL＝′？′+
′presentationID＝′+presentationID()+′&′+
′slideID＝′+(myNumber-1)；
} else if (！aURL.startsWith(′？′)){
// Prefix with http：//for URLs that don′t specify a
protocol
aURL＝″http：\/\/″+aURL；
}
}
//Handle？syntax for specifying the arguments to a
<!-- SIPO <DP n="29"> -->
<dp n="d29"/>
//presentation w/o supplying a host
if (aURL.startsWith(′？′)) aURL＝getBase()+aURL；
// Put all internal URLs in same window
if (aURL.startsWith(getBase())||(aURL.indexOf(″iamaze″)
！＝-1)) myTarget＝null；
}
if ((！myTarget) || aURL.startsWith(″mailto：″)){
myLink＝′＜a href＝″′+aURL+′″＞′；
} else {
myLink＝′＜a href＝″′+aURL+′″′+myTarget+′＞′；
}
}
return myLink；
}
/*
* end of a link tag(handled differently on play vs edit).
*/
function endLinkTag(){
return(！slideIsEditable？′＜/a＞′：′＜/u＞′)；
}
/*
* Replace special tokens in the text
*/
var slideTokens＝[
/\％SlideNumber％/g，(presentation.currentSlideIndex+1)，
/\％SlideCount％/g，presentation.slideCount，
null
]；
function replaceSlideTokens(aString){
for (var i＝0；slideTokens[i]！＝null；i+＝2){
aString＝aString.replace(slideTokens[i]，slideTokens[i+1])；
}
return aString；
}
/*
* Write text content
*
* aLayer：the layer to write one text into
* aContent：an object containing any combination of the following
properties
* align -One of″left″，″center″，or″right″
* color -Either a named color or a color in the form
′RRGGBB′
* fontFamily -A comma separated list of font names
* fontSize -A number(not a string！)specifying the font
point size
* fontStvle -Either null or ′italic′
* fontWeight -Either null or ′bold′
* text -Arbitrary text string
* url -A valid URL
* verticalAlign -One of″top″，″middle″，or″bottom″
*/
function renderText(aLayer，aContent，aBounds){
// Check for nothing worth rendering during playback
<!-- SIPO <DP n="30"> -->
<dp n="d30"/>
if ((！aContent.text) && (！aContent.backgroundColor) &&
(！slideIsEditable)) return；
// PENDING(RWK)-Really ugly workaround to make sure we don′t
lose the
// style infomation when rendering to the layer
if (ns4) aLayer.doLayerHack()；
// Set the layer color and alignment
aLayer.setBackgroundColor(aContent.backgroundColor)；
aLayer.setAlign((aContent.align！＝null)？aContent.align：
′left′)；
aLayer.setVerticalAlign((aContent.verticalAlign！＝ null)？
aContent.verticalAlign：′top′)；
// Figure out what text we want
var myText＝aContent.text；
// Do token replacement for slide numbers
if (aContent._subtype ＝＝′SlideNumber′){
myText＝replaceSlideTokens(myText)；
}
// PENDING(RWK)-IE workaround：There is a wierd problem with
line
// spacing in multiple lines of text. We fix this by simply
ensuring
// that the last character is a space. (Don′t ask me why this
works，
// but it does)
if (ie4 && myText && (myText.indexOf(′\n′)！＝-1) &&
myText[myText.length-1]！＝′′)
myText +＝′′；
// Use default text if we′re editing and the text is empty
if (slideIsEditable && (！myText))myText＝DEFAULT_DIRECTIONS +
′+
DEFAULT_TEXT_STRING+′′+aContent.name；
// Render the content
if (myText) {
// Write the url start tag
if (aContent.url) {
aLayer.write(startLinkTag(aContent.url))；
}
// Write the text
writeTextStyle(aLayer，aContent)；
aLayer.write(myText.escapeForHTML())；
aLayer.writeln(′＜/font＞′)；
// Write the url end tag
if (aContent.url) aLayer.write(endLink
}
}
/*
* Write style information for text content
*/
function writeTextStyle(aLayer，aContent) {
var style ＝′′；
<!-- SIPO <DP n="31"> -->
<dp n="d31"/>
if (aContent.fontSize！＝null) style+＝′font-size：′+
adjust(aContent.fontsize)+′pt′；
if (aContent.fontFamily！＝null) style+＝′；font-family：′+
aContent.fontFamily；
if (aContent.fontStyle！＝null) style+＝′；font-style：′+
aContent.fontStyle；
if (aContent.fontWeight！＝null) style+＝′；font-weight：′+
aContent.fontWeight；
if (aContent.color！＝null) style+＝′；color：′+
aContent.color；
aLayer.write(′＜font style＝″′+style+′″＞′)；
}
/*
* Write background content
*/
function renderBackground(aLayer，aContent，aBounds){
aBounds.left＝aBounds.top＝0；
aBounds.width＝clientWidth；
aBounds.height＝clientHeight；
renderImage(aLayer，aContent，aBounds)；
aLayer.setOrigin(0，0)；
aLayer.setSize(clientWidth，clientHeight)；
return；
}
/*
* Write image content
*
* aLayer：the layer to write the text into
* aContent：an object containing any combination of the following
properties
* align - One of″left″，″center″，or″right″
* src - A URL specifying the source of the image
* scale - ′fit′scales the image. Everything else is
unscaled.
* file - If the file was uploaded，the filename where
the image came from
* verticalAlign -One of″top″，″middle″，or″bottom″
* aBounds：The bounds of the image area
*/
function renderImage(aLayer，aContent，aBounds) {
// Set the background color
aLayer.setBackgroundColor(aContent.backgroundColor)；
// Write the empty content string？
if ((aContent.src＝＝null) &&
(aContent.backgroundColor＝＝null)){
if (slideIsEditable && (aContent.name！＝BACKGROUND_NAME))
aLayer.write(DEFAULT_DIRECTIONS+′′+
DEFAULT_IMAGE_STRING+′′+aContent.name)；
return；
}
// Get a cleaned up version of the image source URL
var mySrc＝aContent.src；
if (mySrc && (mySrc.indexOf(′：′)＝＝-1) &&
！mySrc.startsWith (′/′) && ！mySrc.startsWith(′\\′)){
//PENDING(RWK)-Note that we are a little stricter with the
source
// URL since it may be an iAmaze server image reference
<!-- SIPO <DP n="32"> -->
<dp n="d32"/>
mySrc＝′http：\/\/′+mySrc；
}
// Defer rendering the image？
if ((mySrc！＝null) && (deferImageContent(aContent，mySrc)))
return；
// Write out the href link
if (aContent.url！＝null && ！slideIsEditable){
aLayer.write(startLinkTag(aContent.url))；
}
// Write a shim image？
var myScale＝aContent.scale；
if ((！mySrc) || (myScale＝＝SCALE_TILE)){
//Write the shim image to size the layer properly
aLayer.write(′＜img src＝″′+SHIM_IMAGE+′″′+
′width＝′+aBounds.width+′height＝′+aBounds.height+
′hspace＝0 vspace＝0 border＝0＞′)；
}
//Render the image
if (mySrc){
if (myScale＝＝SCALE_TILE){
// Set the image as the layer background
aLayer.setBackground(mySrc)；
} else {
// Use the shim image to make sure the table will be as
small as needed
if (mySrc＝＝null){
mySrc＝SHIM_IMAGE；
myScale＝SCALE_FIT；
}
aLayer.write(′＜img src＝″′+mySrc+′″′)；
if (myScale＝＝SCALE_FIT){
aLayer.write(′width＝′+aBounds.width+′height＝′+
aBounds.height)；
} else if (myScale＝＝SCALE_WIDTH){
aLayer.write(′width＝′+aBounds.width)；
} else if (myScale＝＝SCALE_HEIGHT){
aLayer.write(′height＝′+aBounds.height)；
}
//When editing on netscape，name the image and catch the
onload (see imageLoaded)
if (ns4 && slideIsEditable){
aLayer.write(′name＝″′+IMAGE_NAME_PREFIX+
aLayer.name+
′″onload＝″imageLoaded(this)″′)；
}
aLayer.write(′hspace＝0 vspace＝0 border＝0＞′)；
// And make sure any previous tiling is removed
aLayer.setBackground(null)；
}
} else if (aLayer.getBackground()){
aLayer.setBackground(null)；
}
// Close out the href
if ((aContent.url！＝null) && ！slideIsEditable){
<!-- SIPO <DP n="33"> -->
<dp n="d33"/>
aLayer.write(endLinkTag()}；
}
if (aContent.align！＝null) aLayer.setAlign(aContent.align)；
if (aContent.verticalAlign！＝null)
aLayer.setVerticalAlign(aContent.verticalAlign)；
}
// PENDING(RWK)-Buttugly IE5 workaround：The image onload event
appears to get sent before the slide is actually ready(the complete
flag is still false and the image fails to render.)Instead of
relying on the event，we set up an interval to poll the images at
reasonable intervals. Ugly，ugly，ugly！
var deferredInterval＝null；
/*
* PENDING(RWK)-IE5 workaround(part 1 of 2)：Images that load in
* a delayed fashion are not rendered.
*
* Return true if we have to wait for an image to load，false
* if the image is already loaded.
*
* For images that are not loaded，add the image to our load queue
* and set up an onload handler to check the queue when the image
* loaded.
*/
var deferredContent＝new Array()；
function deferImageContent(aContent，aSrc){
// PENDING(RWK)-I′m turning this off for a while to see how well
things behave. If things continue to work，then we might consider
deleting this code.
return false；
if ((！ie4) || (version＜5)) return false；
// Create and configure only if the image doesn′t already exist
if (！aContent._image){
aContent._image＝new Image(1，1)；
aContent._image.src＝aSrc；
// Defer the image if it′s not loaded
if (！aContent._image.complete){
deferredContent.addObject(aContent)；
if (！deferredInterval){
deferredInterval＝setInterval(′deferredImageCheck()′，
333)；
}
}
}
return (aContent._image.complete)？false：true；
}
/*
* PENDING(RWK)-IE5 workaround (part 2 of 2)：Images that load in
* a delayed fashion are not rendered.
*
* This method is called any time one of our deferred images becomes
loaded.
* Determine which content the image was for，and render that
content.
*/
<!-- SIPO <DP n="34"> -->
<dp n="d34"/>
function deferredImageCheck(aString){
for (var i＝deferredContent.length-1；i＞＝0；i--}(
var myContent＝deferredContent[i]；
if (myContent._image.complete){
// Turn off the handler since animated images will keep
calling
// the handler，and remove the content.
// myContent._image.onload＝null；
deferredContent.removeIndex(i)；
// Render the content
renderContent(myContent._name)；
}
}
// Turn off the timer if there are no deferred images
if ((deferredContent.length＝＝0) && (deferredInterval)){
clearInterval(deferredInterval)；
deferredInterval＝null；
}
}
/*
* Convenience method to determine if the mouse position of
* anEvent is within the slide
*/
function isEventOnSlide(anEvent){
var myBoundsLayer＝slideLayer；
return myBoundsLayer.isHit(anEvent)；
}
/*
* Convenience method to determine if a location
* is within the slide
*/
function isPointOnSlide(aLeft，aTop){
var myBoundsLayer＝slideLayer；
// Cache the bounds，it never changes，and this method is called
// a LOT，so we don′t want to alloc a bounds each time
if (myBoundsLayer.myCachedBounds＝＝null)
myBoundsLayer.myCachedBounds＝
myBoundsLayer.getAbsoluteBounds()；
var mb＝myBoundsLayer.myCachedBounds；
if (aLeft＞＝mb.left && aLeft＜＝(mb.left+mb.width) &&
aTop＞＝mb.top && aTop＜＝(mb.top+mb.height))
return true；
return false；
}
/*
* Accessor for presentationID，for use in URLs
*/
function presentationID(){
var pid＝presentation.presentationID；
if (pid.startsWith(′com.′)){
myStart＝pid.indexOf{′_′)；
if (myStart＞0) pid＝pid.substring(myStart+1)；
}
return pid；
<!-- SIPO <DP n="35"> -->
<dp n="d35"/>
}
/*
* Accessor for formatted titles of slides(used in UI slide
choosers)
*/
function formattedslideTitle(index，maxChars，minChars，padChar){
if (index＜0 || index＞＝presentation.slideTitles.length)
return′Unknown slide index′+index；
var sTitle＝(index+1)+′.′+presentation.slideTitles[index]；
var newln＝sTitle.indexOf(′\n′)；
if (newln＞0){
sTitle＝sTitle.substring(0，newln-1)；
if ((sTitle.length+3)＜maxChars)
sTitle+＝′...′；
}
return sTitle.insureLength(maxChars，minChars，padChar)；
}
/*
* Is this content entity the background
*/
function isBackground(aContent){
if (aContent＝＝null || aContent. name＝＝null)return false；
return (aContent._name＝＝BACKGROUND_NAME)；
}
/*
* Returns the object of the highest number with the passed
objectName
*/
function slideLastObject(objectName){
// The new entity code makes sure that the numbers are
contiguous，
// so look fo the first gap.
if (slideContent[objectName+′1′]){
var biggest＝1；
for (var myName in slideContent){
if (myName.startsWith(objectName)) {
var myIndex＝
parseInt(myName.substr(objectName.length))；
if (myIndex＞biggest) biggest＝myIndex；
}
}
return objectName + biggest；
}
return null；
}
/*
* This is called whenever any image content is finished loading
* Workaround for a bug where handlers were not set properly
* on large images (Netscape)
*/
function imageLoaded(anImage){
if (ns4 && anImage && anImage.name){
setRolloversToCurrentState(getNamedLayer(anImage.name.substr(IMAGE_NA
ME_PREFIX.length)))；
command.safeToSend()；
<!-- SIPO <DP n="36"> -->
<dp n="d36"/>
}
}
//
// CXElementIterator class
//
// This class iterates through the elements of a slide
// aFilter-A function that accepts an element as it′s only
// parameter and returns true for it to be included，false to
// exclude it.
//
function CXElementIterator(aSlide，aFilter){
this.filter＝(aFilter)？aFilter：CXElementIterator.ALL；
this._elements＝new Array ()；
this.nextElementIndex＝0；
for (var myName in aSlide.contentEntities){
this._addElementToIterator(aSlide.contentEntities[myName])；
}
}
CXElementIterator.prototype＝new CXIterator()；
CXElementIterator.ALL＝function(anElement){return true；}
CXElementIterator.prototype._addElementToIterator＝
function(anElement){
if (anElement && this.filter(anElement)){
this._elements[this._elements.length]＝anElement；
if (anElement.nodes){
for (var i＝0；i＜anElement.nodes.length；i++)
this._addElementToIterator(anElement.nodes[i])；
}
}
}
CXElementIterator.prototype.hasNext＝function(){
return(this.nextElementIndex＜this._elements.length)；
}
CXElementIterator.prototype.next＝function(){
return this.elements[this.nextElementIndex++}；
}
表11解释轮廓文档数据结构的JavaScript
function CXOutline(){}；
CXOutline.version＝1；
CXOutline.name＝′Outline′；
CXSystem.registerLibrary(CXOutline)；
/**************************/
//
//Global vars
<!-- SIPO <DP n="37"> -->
<dp n="d37"/>
//
// Default text to show when a node has no text
var DEFAULT_OUTLINE_STRING＝′Empty outline item′；
// Constants for the type of bullet
var BULLET_TEXT＝ ′text′；
var BULLET IMAGE＝ ′image′；
// RWK-It′s important for these to start with the BULLET_TEXT
// string since we do startsWith() comparisons on them.
var BULLET_SYMBOL＝ ′text-symbol′；
var BULLET_LETTER_LOWER＝ ′text-letter-lower′；
var BULLET_LETTER_UPPER＝ ′text-letter-upper′；
var BULLET_NUMBER_PLAIN＝ ′text-number-plain′；
var BULLET_NUMBER_NESTED＝ ′text-number-nested′；
var BULLET_ROMAN_LOWER＝ ′text-roman-lower′；
var BULLET_ROMAN_UPPER＝ ′text-roman-upper′；
// Common symbol bullet characters
var SYMBOL_DASH＝8211；
var SYMBOL_DOT＝8226；
/*
* Initialize an outline
*/
function initOutline(aNode){
// Init the layers array for outline nodes
aNode._nodeLayers＝new Array()；
// Init the root node and all subnodes
aNode._parentNode＝null；
aNode._rootNode＝aNode；
aNode.level＝0；
if ((aNode.nodes！＝null) && (aNode.nodes.length＞0)){
outlineInitNode(aNode)；
outlineCacheAddress(aNode)；
} else if (slideIsEditable){
// If the root node has no nodes，create a placeholder
// so the user has something to click on when editing.
var newNode＝new Object()；
aNode.nodes＝new Array()；
aNode.nodes.addObject(newNode)；
aNode.nodeBulletType＝BULLET_SYMBOL；
aNode.nodeBulletValue＝SYMBOL_DOT；
outlineInitNode(aNode)；
outlineCacheAddress(aNode)；
// Set the address to null to mark this as a placeholder node
newNode.address＝null；
}
// make the height match the nodes
aNode._rootNode.dirtyHeight＝true；
}
/*
* Recursively initialize outline nodes.
*
* - Set the type of each node to OUTLINE_CLASS
* - Set the root node of each node.
* - Set the parent of each node.
<!-- SIPO <DP n="38"> -->
<dp n="d38"/>
* - Enumerate through the nodes of an outline and name the node
after
* it′s node location.
*/
function outlineInitNode(aNode){
// Error check
if (aNode.nodes＝＝null)return；
// Enumerate through each node
for (var i＝0；i＜aNode.nodes.length；i++){
var myNode＝aNode.nodes[i]；
myNode.type＝OUTLINE_CLASS；
myNode._name＝aNode._name+′：′+i；
myNode._parentNode＝aNode；
myNode._rootNode＝aNode._rootNode；
myNode._level＝aNode._level+1；
myNode._subtype＝aNode._subtype；
if ((myNode.nodes ！＝null) && (myNode.nodes.length＞0)){
// If we didn′t just create one，than initialize the node
outlineInitNode(myNode)；
}
}
}
/*
* Cache the address of each outline node
*/
function outlineCacheAddress(aNode){
//Error check
if (aNode.nodes＝＝null)return；
// Enumerate through each node
for (var i＝0；i＜aNode.nodes.length；i++){
var myNode＝aNode.nodes[i]；
myNode._address＝aNode._address+′.nodes[′+i+′]′；
if ((myNode.nodes ！＝null) && (myNode.nodes.length＞0)){
// If we didn′t just create one，than initialize the node
outlineCacheAddress(myNode)；
}
}
}
//
// Outline rendering
//
/*
* Write outline content
*
* Outlines are implemented by rendering each node in it′s own layer.
* For convenience，the layers are stored in the′_nodeLayers′array
within
* the root node，which is initialized in the initSlide() method.
*/
function renderOutline(aLayer，aContent，aBounds，isMove){
// Set up some default properties
aContent.verticalSpacing＝8；
aContent.indentSpacing＝45；
aContent.heightInPixels＝0；// (we′ll total this up)
// Create.the render context and init it
<!-- SIPO <DP n="39"> -->
<dp n="d39"/>
var myContext＝new Object()；
// Set the origin and available width
myContext.left＝aBounds.left；
myContext.top＝aBounds.top；
myContext.width＝aBounds.width；
myContext.zIndex＝aBounds.zIndex；
myContext.indentSpacing＝aContent.indentSpacing；
myContext.verticalSpacing＝aContent.verticalSpacing；
// Set the layers information
myContext.nextLayerIndex＝0；
// Set the properties
myContext.nodeBulletPrefix＝null；
myContext.nextBulletValue＝1；
// Set the effects information
myContext.effectStartTime＝0；
// Error check-Just return if there′re no nodes
// PENDING(RWK)-Hmm.′Not 100％ sure why I put this here.
if (aContent.nodes＝＝null)return；
// Render the nodes
renderOutlineNodes(aContent，myContext，(！isMove)？false：
true)；
// Hide any unused layers
while (myContext.nextLayerIndex＜aContent._nodeLayers.length){
aContent._nodeLayers[myContext.nextLayerIndex++].hide()；
}
if (slideIsEditable){
if (ns4) setRolloverEvents(true)；
if (aContent.dirtyHeight！＝false){
aContent.height＝
Math.round((aContent.heightInPixels/
(slideLayer.getAbsoluteBounds()).height)*
100).toString()
+″％″；
aContent.dirtyHeight＝false；
}
}
}
/*
* Create an outline node
*/
function renderOutlineNodes(anOutline，aContext，isMove){
var myLayers＝anOutline._rootNode._nodeLayers；
// Enumerate through thenode list
for (var i＝0；i＜anOutline.nodes.length；i++){
var myNode＝anOutline.nodes[i]；
var myLayer＝null；
// Create a new layer if needed
if (aContext.nextLayerIndex＞＝myLayers.length){
myLayer＝newNamedLayer(
anOutline._name+′-′+myLayers.length，
<!-- SIPO <DP n="40"> -->
<dp n="d40"/>
slideLayer.layer)；
myLayers.addObject(myLayer)；
// Turn off wrapInTable(we create our own table)and set
// the alignment
myLayer.setWrapInTable(false)；
myLayer.setVerticalAlign(′top′)；
} else {
// Recycle an existing layer
myLayer＝myLayers[aContext.nextLayerIndex]；
// PENDING(RWK)-Really ugly workaround to make sure we
don′t lose the
// style information when rendering to the layer
if (ns4 && (！isMove)) myLayer.doLayerHack()；
}
// Set the association between content and layer
//
// We do this here for outlines rather than in initSlide()
// because，unlike other elements，nodes may switch layers
// (this happens ifa node is added，deleted，or moved during
// editing).
myLayer._content＝myNode；
myNode._layer＝myLayer；
//Set the bounds-Make the height tiny so the content will
push
//the layer to the proper height.
myLayer.setSize(aContext.width，0)；
myLayer.setOrigin(aContext.left，aContext.top)；
if ((！isMove)){//PENDING(HJK) weird indenting for diffs
// Set the background color of the laver
myLayer.setBackgroundColor(myNode.backgroundColor)；
// Write the table tag for the layer
myLayer.write(myLayer.tableTag())；
myLayer.write(′<tr>′)；
//Write the outline node
var myType＝myNode.nodeBulletType；
var myPadding＝null；
// Write out the bullet cell
if (myType！＝null){
// Render the bullet cell
myLayer.write(′＜td valign＝″top″width＝″lpx″＞′)；
if (myType.startsWith(BULLET_TEXT)){
var myText＝null；
writeTextStyle(myLayer，myNode)；
// Determine the prefix string
var myPadding＝ ′. ；′；
var myValue＝(myNode.nodeBulletValue＝＝null)？
aContext.nextBulletValue：
myNode.nodeBulletValue；
if (myType＝＝BULLET_SYMBOL){
myText＝′&#′+myValue+′；′；
<!-- SIPO <DP n="41"> -->
<dp n="d41"/>
myPadding＝′ ； ；′；
} else if (myType＝＝BULLET_LETTER_LOWER) {
myText＝toLetter(myValue，false)；
} else if (myType＝＝BULLET_LETTER_UPPER) {
myText＝toLetter(myValue，true)；
} else if (myType＝＝BULLET_NUMBER_PLAIN) {
myText＝myValue；
} else if (myType＝＝BULLET_NUMBER_NESTED){
myText＝(aContext.nodeBulletPrefix！＝null)
？
(aContext.nodeBulletPrefix+′.′+
myValue)：
myValue；
} else if (myType＝＝BULLET_ROMAN_LOWER) {
myText＝toRoman(myValue，false)；
} else if (myType＝＝BULLET_ROMAN_UPPER) {
myText＝toRoman(myValue，true)；
} else {
warning(′Unrecognized bullet type： ′+
myType)；
)
myLayer.write(myText)；
myLayer.write(′＜/font＞′)；
aContext.nextBulletValue＝myValue+1；
} else if (myType＝＝BULLET_IMAGE){
//PENDING(RWK)-Remove this block once all outlines have had
the image bullets removed
var myValue＝myNode.nodeBulletValue；
if (myNode.fontSize！＝null) {
myLayer.write(′＜img height＝′+
adjust(myNode.fontsize*.8)+′px′
+′src＝″′+myValue+
′″＞ ；&rnbsp； ；′)；
} else {
myLayer.write(′＜img src＝″′+myValue+′″＞′)；
}
aContext.nextBulletValue＝1；
// PENDING(RWK)-End of block to remove
}
myLayer.write(′＜/td＞′)；
} else {
aContext.nextBulletValue＝1；
}
// Write out the padding cell
if (myPadding) {
myLayer.write(′＜td valign＝″top″width＝″lpx″＞′)；
writeTextStyle(myLayer，myNode)；
myLayer.write(myPadding)；
myLayer.write(′＜/font＞＜/td＞′)；
}
// Use default text if we′re editing and the text is
empty
var myText＝myNode.text；
if (slideIsEditable && (！myText)) myText＝
DEFAULT_OUTLINE_STRING；
<!-- SIPO <DP n="42"> -->
<dp n="d42"/>
// Write out the text cell
myLayer.write(′＜td valign＝″top″width＝″99％″＞′)；
if (myText) {
// Write the url start tag
if (myNode.url) {
myLayer.write(startLinkTag(myNode.url))；
}
// Write the text
writeTextStyle(myLayer，myNode)；
myLayer.write(myText.escapeForHTML())；
myLayer.write(′＜/font＞′)；
// Write the url end tag
if (myNode.url)myLayer.write(endLinkTag())；
}
// Close up
myLayer.write(myLayer.tableCloseTags())；
myLayer.flush()；
// Show the layer and offset the context by the size of
the layer
myLayer.style.zIndex＝aContext.zIndex；
myLayer.show()；
}
// Prepare the context for the next node
aContext.top+＝myLayer.getHeight()+
adjust(aContext.verticalSpacing)；
anOutline._rootNode.heightInPixels+＝myLayer.getHeight()+
adjust(aContext.verticalSpacing)；
aContext.nextLayerIndex++；
// Render any subnodes
if ((myNode.nodes！＝null) && (myNode.nodes.length＞0)){
// Store the context
var subContext＝objectCopy(aContext)；
subContext.nextBulletValue＝1；
subContext.nodeBulletPrefix＝myText；
// Configure the context for the subnodes
var myIndent＝adjust(subContext.indentSpacing)；
subContext.left+＝myIndent；
subContext.width-＝myIndent；
if (myNode.nodeBulletType！＝null) {
subContext.nodeBulletType＝myNode.nodeBulletType；
}
if (myNode.indentSpacing！＝null)
subContext.indentSpacing＝myNode.indentSpacing；
if (myNode.verticalSpacing！＝null)
subContext.verticalSpacing＝myNode.indentSpacing；
// Render the subnodes
renderOutlineNodes(myNode，subContext，isMove)；
// Get interesting stuff from the subContext
aContext.nextLayerIndex＝subContext.nextLayerIndex；
// aContext.effectStartTime＝subContext.effectStartTime；
aContext.top＝subContext.top；
}
<!-- SIPO <DP n="43"> -->
<dp n="d43"/>
}
}
/*
* Utility for finding the firstnode，given any node
*/
function firstNode(aNode) {
if (aNode＝＝null || aNode. rootNode＝＝null)
return null；
return aNode._rootNode.nodes[0]；
}
//
// Bulleting conversion utilities
//
/*
* Convert a number to it′s roman numeral equivalent
* PENDING(RWK)-This method probably wants to live somewhere else
*/
var romanData＝[[1000，-1000，′M′]，{900，100，′C′]，[500，-
500，′D′]，[400，100，′C′]，[100，-100，′C′]，[90，10，′X′]，[50，-
50，′L′]，[40，10，′X′]，[10，-10，′X′]，[9，1，′I′]，[5，-5，′V′]，[4，1，′I′]，[1，-
1，′I′]]；
function toRoman(aVal，isUppercase) {
var romanString＝″；
while (aVal＞0) {
for (var i＝0；i＜romanData.length；i++){
if (aVal＞＝romanData[i][0]) {
aVal+＝romanData[i][1]；
romanString+＝romanData[i][2]；
break；
}
}
}
return isUppercase ？romanString：romanString.toLowerCase()；
}
function toLetter(aval，isoppercase) {
return String.fromCharCode((isUppercase？64：96)+(((aVal-1)％
26)+1))；
}
表12创建文档JavaScript数据结构的Java代码
package com.andgit.util；
import java.util.Collection；
import java.util.Iterator；
import java.util.Map；
/**
* This class helps to create JavaScript from other data structures.
*/
public class SXJavaScript {
<!-- SIPO <DP n="44"> -->
<dp n="d44"/>
//
// STATIC METHODS
//
/**
* Puts a backslash (″\″) character in front of all characters
that
* need to be ″escaped″in JavaScript strings，so that they are
not
* interpreted specially by the JavaScript interpreter.
*
* Currently that set of characters is：
* \-＞\\
* ′-＞\′
* backspace-＞\b
* form-feed-＞\f
* newline-＞\n
* Carriage return-＞\r
* tab-＞\t
*/
static public String escapeSpecialCharacters(String baseString)
// NOTE：Adding this method did not seem to effect our
// pages-per-second timing，so I don′t think it′s a problem.
// If it does show up as a problem in future performance tests，
// however，it can be implemented differently(e.g.with lookup
// tables)，though it will be harder to read/debug/add to.
//\-＞\\
baseString＝SXString.replaceSubstring(baseString，″\\″，
″\\\\″)；
// We now need to″escape″all quote (″′″) characters and
// some other characters，according to the JavaScript spec.
// ′-＞\′
baseString＝SXString.replaceSubstring(baseString，″′″，″\\′″)；
// backspace-＞\b
baseString＝SXString.replaceSubstring(baseString，″\b″，
″\\b″)；
// form-feed-＞\f
baseString＝SXString.replaceSubstring(baseString，″\f″，
″\\f″)；
// newline-＞\n
baseString＝SXString.replaceSubstring(baseString，″\n″，
″\\n″}；
// Carriage return-＞\r
baseString＝SXString.replaceSubstring(baseString，″\r″，
″\\r″)；
//tab-＞\t
baseString＝SXString.replaceSubstring(baseString，″\t″，
″\\t″)；
return baseString；
}
/**
* Takes in a table of key/value pairs representing attribute
names and
* attribute values.
* The ″keys″in this table must be of type String.
* The″values″may be of type：
<!-- SIPO <DP n="45"> -->
<dp n="d45"/>
*
* String，Integer，Collection，or″null″
*
* -If the″value″is of type″Collection″，it should be a
Collection
* of SXContentEntity type objects，so that it will generate the
* appropriate textual description when its″toString()″method
gets called.
* Collections will be translated into a JavaScript array.
*
* -If the″value″is of type Integer，and the value of the
Integer is
* ″-1″，the value″null″(without quotes)will be written to the
JavaScript.
*
* If objectToRepresent is a Map，and there is a key in the named
″name″，then
* its value will be used to label that block of data，so given：
* name ＝″Outlinel″，and key value pairs for width，height，top
* and left，produces the following JavaScript output：
*
* Outlinel：{
* width：92，
* height：18，
* top：4，
* left：4
* }
*
* If″quoteNumericValues″is″true″，then the output will look
like this：
* Outlinel：{
* width：″92″，
* height：″18″，
* top：″4″，
* left：″4″
* }
* NOTE，however，that if numeric values aren′t quoted，then
string
* fields which have only numeric values，such as″Title″(on
SXText)
* field with a value of″3″，will be sent down unquoted，which
then
* causes JavaScript errors.
* Nevertheless，this means that some values，like″slideID″will
be
* sent down quoted，and will be interpretted as strings during
* arithmetic operations on the client ，e.g.″+″.
* The client，therefore，should validate what
* it *knows* to be numeric fields，and re-assign them the
numeric
* value of their string. This is the lesser of two evils(the
server
* ″knowing″about types，vs. the client knowing about types).
* This whole dilemma is one of the few
* drawbacks of our″typeless″system.
* (the typing knowledge ＜b＞could＜/b＞actually be done on the
server-side
* via the classmaps，which SXPersistentPropertyHolder already
knows
* about，but the client needs to do field-by-field validation
* anyway，for debugging purposes，so we might as well let the
<!-- SIPO <DP n="46"> -->
<dp n="d46"/>
* client validate/massage their DOM)
*
* NOTE，also，that if the″value″associated with a key in a Map
* or Collection is not of type″String″，or is″null″，
* the value will＜b＞not＜/b＞be quoted，regardless of the value
of
* ″quoteNumericValues″.
*
* There will ＜B＞not＜/B＞be a final carriage-return after the
final
* closing bracket()).
*/
static public SXIndentedStringBuffer
getJavaScriptRepresentationOfData(SXIndentedStringBuffer
indentBuffer，Object objectToRepresent，boolean quoteNumericValues) {
if (objectToRepresent ！＝null){
Object aValue＝null；
boolean objectIsMap＝objectToRepresent instanceof Map；
boolean objectIsCollection＝！objectIsMap &&
objectToRepresent instanceof Collection；
// SOME KIND OF″DATA CONTAINER″...ITERATE OVER IT AND
CALL BACK RECURSIVELY.
if (objectIsMap || objectIsCollection) {
String containerEncloserStartCharacter＝null；
String containerEncloserEndCharacter＝null；
Iterator anIterator；
boolean hasMoreElements；
boolean firstTime＝true；
//DO THIS STUFF ONCE，BEFORE PROCESSING THE CONTAINER
ELEMENTS
if (objectIsMap) {
anIterator＝
((Map)objectToRepresent).keySet().iterator()；
containerEncloserStartCharacter＝″{″；
containerEncloserEndCharacter＝″}″；
} else {
anIterator＝
((Collection)objectToRepresent).iterator()；
containerEncloserStartCharacter＝″[″；
containerEncloserEndCharacter ＝″]″；
}
indentBuffer.println(containerEncloserStartCharacter)；
indentBuffer.indent()；
hasMoreElements＝anIterator.hasNext()；
while (hasMoreElements) {
// DOTHIS STUFF FOR EACH CONTAINER ELEMENT
if (！firstTime) {
indentBuffer.println(″，″)；// Put a comma after the
item prior to us
} else {
firstTime＝false；
}
if (objectIsMap) {
String aKey＝(String)(anIterator.next())；
indentBuffer.print(aKey)；
aValue＝((Map)objectToRepresent).get(aKey)；
indentBuffer.print(″：″)；
<!-- SIPO <DP n="47"> -->
<dp n="d47"/>
} else {
// We must be a Collection...
aValue＝anIterator.next()；
}
// Now，let′s call this method recursively on
″value″...
SXJavaScript.getJavaScriptRepresentationOfData(indentBuffer，aValue，
quoteNumericValues)；
hasMoreElements＝anIterator.hasNext()；
}
// DO THIS STUFF ONCE，AFTER PROCESSING THE CONTAINER
ELEMENTS
indentBuffer.outdent()；
indentBuffer.println(″″)；
indentBuffer.print(containerEncloserEndCharacter)；
// SXJavaScriptProducer... LET IT RE-CALL US WITH THE
HASHMAP IT WANTS SAVED
} else if (objectToRepresent instanceof
SXJavaScriptProducer) {
((SXJavaScriptProducer)objectToRepresent).getJavaScriptRepresentation
(indentBuffer)；
// FLAT，LEAF-NODE VALUE... JUST WRITE IT OUT...
} else {
boolean objectIsInteger＝false；// PENDING(kbern)：see
below
boolean objectIsString＝objectToRepresent instanceof
String；
boolean quoteThisValue＝true；// PENDING(kbern) was false；
see below
/******
PENDING(kbern)：converting to number is no longer
desirable？Note that this causes problems with
strings
that are integers AND have leading zeros，e.g. the
RGB color 002233 becomes 2233.
if (objectIsString) {
try {
objectToRepresent＝new
Integer((String)objectToRepresent)；
} catch (NumberFormatException anException) {
// Quote non-numeric Strings if they′re not empty
(though
// that case is caught in the previous″else if″
clause).
quoteThisValue＝true；
}
}
********/
objectIsInteger＝objectToRepresent instanceof Integer；
if (objectIsInteger) {
if (((Integer)objectToRepresent).intValue()＝＝-1) {
aValue＝″null″；
}
if (quoteNumericValues) {
<!-- SIPO <DP n="48"> -->
<dp n="d48"/>
quoteThisValue ＝true；
}
} else if (objectToRepresent instanceof Boolean) {
quoteThisValue＝false；//booleans are never quoted！
}
String objectToRepresentString＝
objectToRepresent.toString()；
if (quoteThisValue) {
indentBuffer.print(″′″)；
objectToRepresentString＝
SXJavaScript.escapeSpecialCharacters(objectToRepresentString)；
}
indentBuffer.print(objectToRepresentString)；
if (quoteThisValue) {
indentBuffer.print(″′″)；
}
}
} else {
indentBuffer.print(″null″)；
}
return indentBuffer；
}
}
假设浏览器的web页面内容为HTML。然而，实际上并不一定如此，因为一些更先进的浏览器能显示其它格式，最著名的是可扩展标记语言(XML)。因此，这里描述处理也适合其它浏览器文档格式，所以实际上处理并不一定要求HTML格式。
虽然这里已参照较佳实施例描述了本发明，但是本领域技术人员显然明白，其它应用可以替代这里提出的应用而不违背本发明的精神和范围。
因此，本发明只应受下面包含的权利要求的限制。
Claims (63)
1.一种提供和显现可定标web页面的系统，其特征在于，所述系统包括：
浏览器：
与解释码相关的脚本；和
文档对象模型；
其中所述脚本在执行时，创建一种描述页面作者所建立的文档的数据结构；并且
其中所述解释码以一种方式解释所述数据结构，所述方式使所述数据结构操作所述文档对象模型用于向所述浏览器显现所述文档的目的。
2.如权利要求1所述的系统，其特征在于，所述浏览器可以是任一类支持脚本语言的web浏览器，并具有修改所显示的web页面内容的方法。
3.如权利要求1所述的系统，其特征在于，所述数据结构可优化成只包括所述文档的重要信息。
4.如权利要求1所述的系统，其特征在于，所述数据结构和所述解释码可容纳在单个文件内。
5.如权利要求1所述的系统，其特征在于，所述数据结构可与所述解释码分开。
6.如权利要求1所述的系统，其特征在于，所述数据结构包括：
根对象：
其中，所述根对象包括幻灯片阵列，每张所述幻灯片是代表单张显现幻灯片的对象；并且
其中，每张所述幻灯片包括多个内容实体，而每个所述内容实体具有各种属性。
7.如权利要求6所述的系统，其特征在于，所述根对象还包括：
包含所述显现的每张所述幻灯片标题的串阵列。
8.如权利要求6所述的系统，其特征在于，所述根对象还包括：
第一属性，是所述显现中当前幻灯片索引；
第二属性，对样本显现为真；
第属性，对样式显现为真；
第四属性，对模板显现为真；
第五属性，指示所述显现的数据库ID；
第六属性，指示所述显现幻灯片总数；和
第七属性，指示所述对象所属的类型。
9.如权利要求6所述的系统，其特征在于，每张所述幻灯片还包括：
第一属性，指示显示所述幻灯片时使用效果的类别；
第二属性，指示所述显现所基于的布局名称；
第三属性，是一组用户对所述幻灯片提供的注释；
第四属性，指示所述幻灯片的标题；和
第五属性，指示所述幻灯片所属的类别。
10.如权利要求9所述的系统，其特征在于，所述第一属性包括：
第一值，是幻灯片元素从右侧飞入的设定；
第二值，是幻灯片元素从左侧飞入的设定；
第三值，是幻灯片元素从底部飞入的设定；
第四值，是幻灯片元素从顶部飞入的设定；
第五值，是幻灯片元素简短闪烁的设定；和
第六值，是每次鼠标点击逐渐显露幻灯片元素的设定。
11.如权利要求6所述的系统，其特征在于，所述内容实体包括：
文本实体；
轮廓实体；
图象实体；
其中，每个所述内容实体包括：
多个属性，用于共同定义每个所述内容实体所占据的矩形；
存贮每个所述内容实体的属性；
指示每个所述内容实体名称的属性；和
指示层实体在所述幻灯片中z排序的属性。
12.如权利要求11所述的系统，其特征在于，所述文本实体还包括：
定义字体磅值的属性；
定义字体样式的属性；
定义字系列的属性；
定义字重的属性；
定义文本色彩的属性；
定义背景色的属性；
定义水平对齐的属性；
定义垂直对齐的属性；和
定义要定位的URL的属性。
13.如权利要求11所述的系统，其特征在于，所述轮廓体继承所述文本体的所有属性，并且还包括：
定义项目符号类型的属性；
定义用于指定所述项目符号概貌的值的属性；和
定义子轮廓阵列的属性。
14.如权利要求11所述的系统，其特征在于，所述图象体还包括：
定义水平对齐的属性；
定义背景色的属性；
定义在显示所述图象时使用的定标模式的属性；
定义要显示图象的URL的属性；
定义要定位的URL的属性；和
定义垂直对齐的属性。
15.如权利要求14所述的系统，其特征在于，在显示所述图象时定义使用的定标模式的所述属性包括：
配合值，可把所述图象定标成在所述幻灯片边界内准确符合；
宽度值，可对所述图象定标并保持高宽比，使所述图象的宽度在所述幻灯片边界内准确符合；
高度值，可对所述图象定标并保持高宽比，使所述图象的高度在所述幻灯片边界内准确符合；和
分割值，可将所述图象以其原来尺寸分割，准确地填满图象边界。
16.如权利要求14所述的系统，其特征在于，所述图象体包括背景元素，而所述背景元素的边界始终保持对应于所述幻灯片的边界。
17.如权利要求16所述的系统，其特征在于，所述背景元素总是将其z索引保持为零。
18.一种提供和显现可定标Web页面的处理，其特征在于，所述处理包括下述步骤：
通过执行脚本创建描述文档的数据结构；
用解释码以一种方式解释所述数据结构，所述方式允许所述数据结构操作文档对象模型用于将所述文档显现在浏览器中的目的；
其中，所述文档自动更新，以在所述浏览器调整尺寸时向所述浏览器反映变化。
19.如权利要求18所述的处理，其特征在于，所述数据结构可以优化成只包含所述文档的重要信息。
20.如权利要求18所述的处理，其特征在于，所述数据结构与所述解释码可以包含在单个文件内。
21.如权利要求18所述的处理，其特征在于，所述数据结构可以与所述解释码分开。
22.一种创建文档数据结构的处理，其特征在于，包括下述步骤：
用Web服务器对浏览者浏览器对文档的请求作出响应；
以适合的方式检索或创建所述文档的内容；
把所述文档内容翻译成脚本代码块；
把所述脚本代码嵌入返回给浏览者的HTML文档里；和
在浏览者浏览器中执行所述脚本代码块。
23.如权利要求22所述的处理，其特征在于，还包括下述步骤：
由所述数据结构执行任何必要的数据验证。
24.如权利要求22所述的处理，其特征在于，所述执行脚本代码块的步骤包括下述子步骤：
设定背景色；
为显现创建幻灯片层；
使所述幻灯片层的显示有效；
使所述显现和所述幻灯片的地址初始化；
使所述幻灯片内各种幻灯片元素初始化；
设立调整尺寸的处理程序；和
把所述幻灯片呈现为HTML，并在所述浏览器中显示所述显现内容。
25.如权利要求22所述的处理，其特征在于，一个或多个所述幻灯片元素是文本实体，并且所述使所述幻灯片内各种幻灯片元素初始化的子步骤还包括：
设定所述文本体的地址；
为所述文本体建立层；和
使所述层的显示有效。
26.如权利要求22所述的处理，其特征在于，一个或多个所述幻灯片元素为图象实体，并且使所述幻灯片内各种幻灯片元素初始化的所述子步骤还包括：
为所述图象体设定地址；
为所述图象体建立层；和
使所述层的显示有效。
27.如权利要求22所述的处理，其特征在于，一个或多个所述幻灯片元素为轮廓实体，并且使所述幻灯片内各种幻灯片元素初始化的所述子步骤还包括下述分子步骤：
为所述轮廓体设定地址；和
使所述轮廓体的轮廓节点初始化。
28.如权利要求22所述的处理，其特征在于，把所述幻灯片呈现为HTML并在所述浏览器中显示所述显现内容的所述子步骤还包括下述分子步骤：
获取客户屏目尺寸；
设置所述幻灯片层的剪裁区；
呈现所述幻灯片内各种幻灯片元素；和
用输出刷新所述层。
29.如权利要求28所述的处理，其特征在于，一个或多个幻灯片元素为文本实体，而呈现所述幻灯片内各种幻灯片元素的所述分子步骤包括下述次分子步骤：
设定层色并对齐；
生成要显示的文本；
写URL起始标记；
写样式和所述文本；和
写URL结束标记。
30.如权利要求28所述的处理，其特征在于，一个或多个幻灯片元素为图象实体，并且呈现所述幻灯片内各种幻灯片元素的所述分子步骤包括下述次分子步骤：
设定层背景色；
若幻灯片可编辑，写空白内容串；
获取图象源的URL；
写URL起始标记；
呈现所述图象；和
写URL结束标记。
31.如权利要求28所述的处理，其特征在于，一个或多个所述幻灯片元素为轮廓实体，并且呈现所述幻灯片内各种幻灯片元素的所述分子步骤包括下述次分子步骤：
设定默认属性；
创建呈现上下文范围并初始化；
设置起点和有效宽度；
按所述呈现范围呈现轮廓节点；和
隐藏不使用的层。
32.一种解释文档数据结构的处理，其特征在于，所述处理包括下述步骤：
在所述文档数据结构中识别要求呈现给浏览者浏览器的对象；
定位或创建浏览器文档对象模型的诸元素，其中，所述元素用于呈现所述文档；
应用任何使浏览者特定的浏览器配置适应浏览器文档对象模型元素或文档数据结构所必需的变换或其它变化；
生成呈现所述对象所必需的HTML；和
将所述HTML应用到浏览器文档对象模型的元素，使所述文档在所述浏览器中显示。
33.如权利要求32所述的处理，其特征在于，应用任何变换或其它变化的所述步骤包括子步骤：
设定背景色；
为显现建立幻灯片层；
使所述幻灯片层的显示有效；
使所述显现和所述幻灯片的地址初始化；
使所述幻灯片内各种幻灯片元素初始化；和
设立调整尺寸的处理程序。
34.如权利要求33所述的处理，其特征在于，一个或多个所述的幻灯片元素为文本实体，而使所述幻灯片内各种幻灯片元素初始化的所述子步骤还包括下述分子步骤：
对所述文本体设定地址；
为所述文本体建立层；和
使所述层的显示有效。
35.如权利要求33所述的处理，其特征在于，一个或多个所述幻灯片元素为图象体，而使所述幻灯片内各种幻灯片元素初始化的所述子步骤还包括下述分子步骤：
对所述图象体设定地址；
为所述图象体建立层；和
使所述层的显示有效。
36.如权利要求33所述的处理，其特征在于，一个或多个所述幻灯片元素为轮廓体，而使所述幻灯片内各种幻灯片元素初始化的所述子步骤包括下述分子步骤：
对所述轮廓体设定地址；和
使所述轮廓体的轮廓节点初始化。
37.如权利要求32所述的处理，其特征在于，生成呈现所述对象所必需的HTML的所述步骤包括下述子步骤：
获取客户屏幕尺寸；
设置所述幻灯片层的剪裁区；
呈现所述幻灯片内各种幻灯片元素；和
用输出刷新所述层。
38.如权利要求37所述的处理，其特征在于，一个或多个幻灯片元素为文本体，而呈现所述幻灯片内各种幻灯片元素的所述子步骤包括下述分子步骤：
设置层色并对齐；
生成要显示的文本；
写URL起始标记；
写样式和所述文本；和
写URL结束标记。
39.如权利要求37所述的处理，其特征在于，一个或多个幻灯片元素为图象体，而呈现所述幻灯片内各种幻灯片元素的所述子步骤包括下述分子步骤：
设置层背景色；
若幻灯片可编辑，写空白内容串；
获取图象源的URL；
写URL起始标记；
呈现所述图象；和
写URL结束标记。
40.如权利要求37所述的处理，其特征在于，一个或多个幻灯片元素为轮廓体，而呈现所述幻灯片内各种幻灯片元素的所述子步骤包括下述分子步骤：
设定默认属性；
创建呈现上下文范围并初始化；
设置起点和有效宽度；
按所述呈现范围呈现轮廓节点；和
隐藏不使用的层。
41.一种提供和呈现可定标Web页面的方法，其特征在于，所述方法包括下述步骤：
通过执行脚本而创建描述文档的数据结构；
解释码以一种方式解释所述数据结构，该方式允许所述数据结构操作文档对象模型用于将所述文档呈现给浏览器的目的；
其中，所述文档自动更新，以在所述浏览器调整尺寸时对所述浏览器反映变化。
42.如权利要求41所述的方法，其特征在于，所述数据结构可以优化成只包含所述文档的重要信息。
43.如权利要求41所述的方法，其特征在于，所述数据结构和所述解释码可容纳在单个文档中。
44.如权利要求41所述的方法，其特征在于，所述数据结构可以与所述解释码分开。
45.一种创建文档数据结构的方法，其特征在于，包括下述步骤：
用web服务器响应浏览者浏览器对文档的请求；
以合理方式检索或创建所述文档内容；
把所述文档内容翻译成脚本代码块；
把所述脚本代码嵌入返回给浏览者的HTML文档；和
在浏览者浏览器中执行所述脚本代码块。
46.如权利要求45所述的方法，其特征在于，还包括下述步骤：
通过所述数据结构作必要的数据验证。
47.如权利要求45所述的方法，其特征在于，执行脚本代码块的所述步骤包括下述子步骤：
设置背景色；
为显现建立幻灯片层；
使所述幻灯片层的显示有效；
使所述显现和所述幻灯片的地址初始化；
使所述幻灯片内各种幻灯片元素初始化；
设立改变尺寸的处理程序；和
把所述幻灯片呈现为HTML并在所述浏览器中显示所述显现内容。
48.如权利要求45所述的方法，其特征在于，一个或多个所述幻灯片元素为文本体，而使所述幻灯片内各种幻灯片元素初始化的所述子步骤还包括：
对所述文本体设立地址；
为所述文本体建立层；和
使所述层的显示有效。
49.如权利要求45所述的方法，其特征在于，一个或多个所述幻灯片元素为图象体，而使所述幻灯片内各种幻灯片元素初始化的所述子步骤还包括：
对所述图象体设定地址；
为所述图象体建立层；和
使所述层的显示有效。
50.如权利要求47所述的方法，其特征在于，一个或多个所述幻灯片元素为轮廓体，而使所述幻灯片内各种幻灯片元素初始化的所述子步骤还包括下述分子步骤：
对所述轮廓体设定地址；和
对所述轮廓体的轮廓节点初始化。
51.如权利要求47所述的方法，其特征在于，把所述幻灯片呈现为HTML并在所述浏览器上显示所述显现内容的所述子步骤还包括下述分子步骤：
获取客户屏幕的尺寸；
设置所述幻灯片层的剪裁区；
呈现所述幻灯片内各种幻灯片元素；和
用输出刷新所述层。
52.如权利要求51所述的方法，其特征在于，一个或多个幻灯片元素为文本体，而呈现所述幻灯片内各种幻灯片元素的所述分子步骤包括下述次分子步骤：
设置层色并对齐；
生成要显示的文本；
写URL起始标记；
写样式和所述文本；和
写URL结束标记。
53.如权利要求51所述的方法，其特征在于，一个或多个幻灯片元素为图象体，而呈现所述幻灯片内各种幻灯片元素的所述分子步骤包括下述次分子步骤：
设置层背景色；
若幻灯片可编辑，写空白内容串；
获取图象源的URL；
写URL起始标记；
呈现所述图象；和
写URL结束标记。
54.如权利要求51所述的方法，其特征在于，一个或多个幻灯片元素为轮廓体，而呈现所述幻灯片内各种幻灯片元素的所述分子步骤包括次分子步骤：
设置默认属性；
创建呈现上下文范围并初始化；
设起点和有效宽度；
按所述呈现范围呈现轮廓节点；和
隐藏不使用的层。
55.一种解释文档数据结构的方法，其特征在于，所述方法包括下述步骤：
识别所述文档数据结构中需要在浏览者浏览器中呈现的对象；
定位或创建浏览器文档对象模型诸元素，其中，所述元素用于呈现所述文档；
应用使浏览者特定的浏览器配置能适应浏览器文档对象模型或文档数据结构诸元素所需的任何变换或其它变化；
生成呈现所述对象所需的HTML；和
将所述HTML应用到浏览器文档对象模型的元素里，从而在所述浏览器中显示所述文档。
56.如权利要求55所述的方法，其特征在于，应用任何变换或其它变化的所述步骤包括下述子步骤：
设置背景色；
为显现内容建立幻灯片层；
使所述幻灯片层的显示有效；
使所述显现与所述幻灯片的地址初始化；
使所述幻灯片内各种幻灯片元素初始化；和
设置改变尺寸的处理程序。
57.如权利要求56所述的方法，其特征在于，一个或多个所述幻灯片元素为文本体，而使所述幻灯片内各种幻灯片元素初始化的所述子步骤还包括：
对所述文本体设置地址；
对所述文本建立层；和
使所述层的显示有效。
58.如权利要求56所述的方法，其特征在于，一个或多个所述幻灯片元素为图象体，而使所述幻灯片内各种幻灯片元素初始化的所述子步骤还包括：
对所述图象体设置地址；
对所述图象体建立层；和
使所述层的显示有效。
59.如权利要求56所述的方法，其特征在于，一个或多个所述幻灯片元素为轮廓体，而使所述幻灯片内各种幻灯片元素初始化的所述子步骤还包括下述分子步骤：
对所述轮廓体设置地址；和
使所述轮廓体的轮廓节点初始化。
60.如权利要求55所述的方法，其特征在于，生成呈现所述对象所需的HTML的所述步骤包括下述子步骤：
获取客户屏幕尺寸；
设置所述幻灯片层的剪裁区；
呈现所述幻灯片内各种幻灯片元素；和
用输出刷新所述层。
61.如权利要求60所述的方法，其特征在于，一个或多个幻灯片元素为文本体，而呈现所述幻灯片内各种幻灯片元素的所述子步骤包括分子步骤：
设置层色并对齐；
生成要显示的文本；
写URL起始标记；
写样式和所述文本；和
写URL结束标记。
62.如权利要求60所述的方法，其特征在于，一个或多个幻灯片元素为图象体，而呈现所述幻灯片内各种幻灯片元素的所述子步骤包括下述分子步骤：
设置层背景色；
若幻灯片可编辑，写空白内容串；
获取图象源的URL；
写URL起始标记；
呈现所述图象；和
写URL结束标记。
63.如权利要求60所述的方法，其特征在于，一个或多个幻灯片元素为轮廓体，而呈现所述幻灯片内各种幻灯片元素的所述子步骤包括下述分子步骤：
设置默认属性；
创建呈现上下文范围并初始化；
设起点和有效宽度；
按所述呈现范围呈现轮廓节点；和隐藏不使用的层。
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US18043900P | 2000-02-04 | 2000-02-04 | |
| US60/180,439 | 2000-02-04 |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN1398377A true CN1398377A (zh) | 2003-02-19 |
| CN1205571C CN1205571C (zh) | 2005-06-08 |
Family
ID=22660469
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CNB018044883A Expired - Fee Related CN1205571C (zh) | 2000-02-04 | 2001-01-31 | 提供和呈现可缩放web文档的系统和方法 |
Country Status (6)
| Country | Link |
|---|---|
| US (1) | US7412644B2 (zh) |
| EP (1) | EP1256070A2 (zh) |
| JP (1) | JP2003521784A (zh) |
| CN (1) | CN1205571C (zh) |
| AU (1) | AU2001231259A1 (zh) |
| WO (1) | WO2001057718A2 (zh) |
Cited By (17)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN100407138C (zh) * | 2005-08-04 | 2008-07-30 | 腾讯科技（深圳）有限公司 | 基于Brew的一种动态用户界面的体系结构和实现方法 |
| CN101131695B (zh) * | 2006-08-25 | 2010-05-26 | 北京书生国际信息技术有限公司 | 一种文档库系统及其实现方法 |
| CN1954314B (zh) * | 2004-04-30 | 2010-05-26 | 微软公司 | 文档标记方法和系统 |
| CN101414257B (zh) * | 2008-11-13 | 2011-09-21 | 成都市华为赛门铁克科技有限公司 | 软件界面实现方法、装置 |
| CN101449270B (zh) * | 2006-03-15 | 2011-11-16 | 谷歌公司 | 自动显示尺寸调整后的图像 |
| CN101553771B (zh) * | 2006-10-23 | 2012-01-04 | 奥多比公司 | 绘制超文本标记语言内容 |
| CN102314499A (zh) * | 2011-08-26 | 2012-01-11 | 百度在线网络技术（北京）有限公司 | 一种用于处理网页内容的方法与设备 |
| CN102841883A (zh) * | 2011-06-08 | 2012-12-26 | 株式会社Pfu | 表单提供装置以及表单提供方法 |
| CN103229167A (zh) * | 2010-10-06 | 2013-07-31 | 星汇数据解决方案公司 | 用于为电子发现数据编索引的系统和方法 |
| CN103365862A (zh) * | 2012-03-28 | 2013-10-23 | 北京百度网讯科技有限公司 | 一种用于生成与页面对应的图片的方法与设备 |
| CN104272291A (zh) * | 2012-03-07 | 2015-01-07 | 谷歌公司 | 唯一地识别脚本文件 |
| CN105094872A (zh) * | 2014-05-16 | 2015-11-25 | 腾讯科技（北京）有限公司 | 一种显示网页应用的方法和装置 |
| CN105284075A (zh) * | 2013-06-06 | 2016-01-27 | 国际商业机器公司 | 基于为网页的网页元素聚合用户偏好的优化网页加载 |
| CN106557289A (zh) * | 2015-09-29 | 2017-04-05 | 珠海金山办公软件有限公司 | 一种幻灯片显示方法、系统及装置 |
| CN106663083A (zh) * | 2014-07-09 | 2017-05-10 | 惠普发展公司，有限责任合伙企业 | 用于基于http的应用的网络浏览器策略 |
| CN107844465A (zh) * | 2017-11-11 | 2018-03-27 | 江西金格科技股份有限公司 | 一种ofd格式文档支持脚本的方法 |
| CN108023918A (zh) * | 2016-11-02 | 2018-05-11 | 阿里巴巴集团控股有限公司 | 一种服务信息获取方法、装置及系统 |
Families Citing this family (76)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6915484B1 (en) * | 2000-08-09 | 2005-07-05 | Adobe Systems Incorporated | Text reflow in a structured document |
| US7231606B2 (en) | 2000-10-31 | 2007-06-12 | Software Research, Inc. | Method and system for testing websites |
| US7194743B2 (en) | 2000-12-12 | 2007-03-20 | Citrix Systems, Inc. | Methods and apparatus for communicating changes between a user interface and an executing application using property paths |
| US20030189593A1 (en) * | 2001-01-05 | 2003-10-09 | Yarvin Curtis G. | Method and apparatus for dynamically updating a markup language based user interface |
| US7415538B2 (en) * | 2001-03-19 | 2008-08-19 | International Business Machines Corporation | Intelligent document filtering |
| JP2002342382A (ja) | 2001-05-01 | 2002-11-29 | K-Plex Inc | ハイパー・テキスト構造の自動検索方法及び装置 |
| CA2354993C (en) | 2001-08-10 | 2010-11-09 | Ibm Canada Limited-Ibm Canada Limitee | Method of indicating links to external urls |
| EP1318461A1 (en) | 2001-12-07 | 2003-06-11 | Sap Ag | Method and computer system for refreshing client-data |
| US7187376B2 (en) * | 2002-06-04 | 2007-03-06 | Sap Aktiengesellschaft | Displaying views on computer screens |
| US7415452B1 (en) | 2002-06-21 | 2008-08-19 | Adobe Systems Incorporated | Traversing a hierarchical layout template |
| US7051040B2 (en) | 2002-07-23 | 2006-05-23 | Lightsurf Technologies, Inc. | Imaging system providing dynamic viewport layering |
| TWI285808B (en) * | 2002-07-27 | 2007-08-21 | Samsung Electronics Co Ltd | Apparatus and method for reproducing content and information storage medium therefor |
| US7765255B2 (en) | 2002-07-30 | 2010-07-27 | Sap Ag | Extended web infrastructure for business applications |
| ATE385589T1 (de) * | 2002-08-02 | 2008-02-15 | Sap Ag | Verfahren und rechnersystem zur behandlung von inkrementalen daten in klient-server kommunikation. |
| WO2004031984A1 (en) * | 2002-10-01 | 2004-04-15 | Sap Aktiengesellschaft | Method and system for refreshing browser pages |
| EP1406183A3 (en) | 2002-10-01 | 2004-04-14 | Sap Ag | Method and system for refreshing browser pages |
| DE10349015A1 (de) * | 2003-10-17 | 2005-05-19 | Siemens Ag | Betriebsverfahren für einen Server und hiermit korrespondierende Gegenstände |
| US7954050B2 (en) * | 2004-06-25 | 2011-05-31 | Icesoft Technologies Canada Corp. | Systems and methods for rendering and increasing portability of document-based user interface software objects |
| EP1622043B1 (en) * | 2004-07-19 | 2012-07-04 | Sap Ag | Computer method for browsing and web-browser program |
| EP1638015A1 (en) * | 2004-09-15 | 2006-03-22 | Arizan Corporation | Method for requesting and viewing a zoomed area of detail from an image attachment on a mobile communication device |
| US20060056604A1 (en) * | 2004-09-15 | 2006-03-16 | Research In Motion Limited | Method for scaling images for usage on a mobile communication device |
| US7451405B2 (en) | 2004-09-15 | 2008-11-11 | Research In Motion Limited | Method for requesting and viewing a zoomed area of detail from an image attachment on a mobile communication device |
| US7310771B2 (en) * | 2004-12-20 | 2007-12-18 | Microsoft Corporation | Method and computer-readable medium for providing page and table formatting services |
| US7516400B2 (en) * | 2005-03-07 | 2009-04-07 | Microsoft Corporation | Layout system for consistent user interface results |
| US7945853B2 (en) * | 2005-09-12 | 2011-05-17 | Microsoft Corporation | Script markup |
| US7814410B2 (en) * | 2005-09-12 | 2010-10-12 | Workman Nydegger | Initial server-side content rendering for client-script web pages |
| US7739589B2 (en) * | 2005-11-02 | 2010-06-15 | International Business Machines Corporation | Extending markup of a browser using a plug-in framework |
| CN100422985C (zh) * | 2006-02-23 | 2008-10-01 | 珠海金山软件股份有限公司 | 一种在svg中加入svg动画数据的方法 |
| US7694221B2 (en) | 2006-02-28 | 2010-04-06 | Microsoft Corporation | Choosing between multiple versions of content to optimize display |
| CN101480049B (zh) * | 2006-06-23 | 2011-06-22 | 夏普株式会社 | 图像显示装置，图像显示方法，图像显示系统，图像数据发送装置 |
| JP4102847B2 (ja) * | 2006-06-30 | 2008-06-18 | シャープ株式会社 | 画像データ提供装置、画像表示装置、画像表示システム、画像データ提供装置の制御方法、画像表示装置の制御方法、制御プログラム、および、記録媒体 |
| US8161339B2 (en) * | 2006-08-11 | 2012-04-17 | Sharp Kabushiki Kaisha | Content playback apparatus, content playback method, and storage medium |
| US7692658B2 (en) * | 2006-11-17 | 2010-04-06 | Microsoft Corporation | Model for layout animations |
| US8213499B2 (en) * | 2007-04-04 | 2012-07-03 | General Instrument Corporation | Method and apparatus for context address generation for motion vectors and coefficients |
| US20080295018A1 (en) * | 2007-05-24 | 2008-11-27 | Nokia Corporation | Apparatus, method and computer program product providing an adaptive forward button for a browser application |
| US8392890B2 (en) * | 2007-10-15 | 2013-03-05 | Software Research, Inc. | Method and system for testing websites |
| US8424004B2 (en) * | 2007-06-23 | 2013-04-16 | Microsoft Corporation | High performance script behavior detection through browser shimming |
| CN100492289C (zh) * | 2007-09-30 | 2009-05-27 | 田园 | 一种浏览器扩展对象、函数或变量的方法 |
| US9418171B2 (en) * | 2008-03-04 | 2016-08-16 | Apple Inc. | Acceleration of rendering of web-based content |
| US8477143B2 (en) | 2008-03-04 | 2013-07-02 | Apple Inc. | Buffers for display acceleration |
| US8289333B2 (en) | 2008-03-04 | 2012-10-16 | Apple Inc. | Multi-context graphics processing |
| US8307300B1 (en) | 2008-05-13 | 2012-11-06 | Google Inc. | Content resizing and caching in multi-process browser architecture |
| KR20110037958A (ko) * | 2008-06-18 | 2011-04-13 | 톰슨 라이센싱 | 디지털 문서의 디스플레이와 상기 문서 내에서의 네비게이션을 위해 상기 문서를 준비하는 방법 |
| US9495471B2 (en) * | 2008-12-04 | 2016-11-15 | International Business Machines Corporation | Optimize view elements sizes to maximize most data viewed in a multiple view elements GUI |
| US20100218122A1 (en) * | 2009-02-20 | 2010-08-26 | Microsoft Corporation | Asynchronously uploading and resizing content in web-based applications |
| US10671698B2 (en) | 2009-05-26 | 2020-06-02 | Microsoft Technology Licensing, Llc | Language translation using embeddable component |
| US9405745B2 (en) * | 2009-06-01 | 2016-08-02 | Microsoft Technology Licensing, Llc | Language translation using embeddable component |
| WO2011160139A1 (en) | 2010-06-18 | 2011-12-22 | Sweetlabs, Inc. | Systems and methods for integration of an application runtime environment into a user computing environment |
| US8977624B2 (en) * | 2010-08-30 | 2015-03-10 | Microsoft Technology Licensing, Llc | Enhancing search-result relevance ranking using uniform resource locators for queries containing non-encoding characters |
| US9218680B2 (en) * | 2010-09-01 | 2015-12-22 | K-Nfb Reading Technology, Inc. | Systems and methods for rendering graphical content and glyphs |
| KR20120099931A (ko) * | 2011-03-02 | 2012-09-12 | 삼성전자주식회사 | 브라우징 방법, 디바이스, 및 컴퓨터로 읽을 수 있는 저장 매체 |
| US8898562B2 (en) * | 2011-03-04 | 2014-11-25 | Dan Tocchini | System and method for harmonious tiling search and publishing |
| CN102890681B (zh) * | 2011-07-20 | 2016-03-09 | 阿里巴巴集团控股有限公司 | 一种生成网页结构模板的方法及系统 |
| CN102999511B (zh) * | 2011-09-13 | 2016-04-13 | 阿里巴巴集团控股有限公司 | 一种页面快速转换方法、装置和系统 |
| US9317623B2 (en) | 2012-04-20 | 2016-04-19 | Yahoo! Inc. | Dynamic webpage image |
| US8775917B2 (en) | 2012-08-09 | 2014-07-08 | Sweetlabs, Inc. | Systems and methods for alert management |
| US8775925B2 (en) | 2012-08-28 | 2014-07-08 | Sweetlabs, Inc. | Systems and methods for hosted applications |
| US9069735B2 (en) | 2012-10-15 | 2015-06-30 | Sweetlabs, Inc. | Systems and methods for integrated application platforms |
| CN104573412B (zh) * | 2013-10-16 | 2019-04-23 | 航天信息软件技术有限公司 | 防止拷贝网页文字内容的方法和装置 |
| US9749440B2 (en) | 2013-12-31 | 2017-08-29 | Sweetlabs, Inc. | Systems and methods for hosted application marketplaces |
| US10019247B2 (en) | 2014-05-15 | 2018-07-10 | Sweetlabs, Inc. | Systems and methods for application installation platforms |
| US10089098B2 (en) | 2014-05-15 | 2018-10-02 | Sweetlabs, Inc. | Systems and methods for application installation platforms |
| US9600594B2 (en) | 2014-10-09 | 2017-03-21 | Wrap Media, LLC | Card based package for distributing electronic media and services |
| US9489684B2 (en) | 2014-10-09 | 2016-11-08 | Wrap Media, LLC | Delivering wrapped packages in response to the selection of advertisements |
| US9448972B2 (en) * | 2014-10-09 | 2016-09-20 | Wrap Media, LLC | Wrap package of cards supporting transactional advertising |
| US9418056B2 (en) | 2014-10-09 | 2016-08-16 | Wrap Media, LLC | Authoring tool for the authoring of wrap packages of cards |
| US20160103820A1 (en) | 2014-10-09 | 2016-04-14 | Wrap Media, LLC | Authoring tool for the authoring of wrap packages of cards |
| WO2016057188A1 (en) | 2014-10-09 | 2016-04-14 | Wrap Media, LLC | Active receipt wrapped packages accompanying the sale of products and/or services |
| US9600803B2 (en) | 2015-03-26 | 2017-03-21 | Wrap Media, LLC | Mobile-first authoring tool for the authoring of wrap packages |
| US9582917B2 (en) * | 2015-03-26 | 2017-02-28 | Wrap Media, LLC | Authoring tool for the mixing of cards of wrap packages |
| CN107229454B (zh) | 2016-03-24 | 2019-11-12 | 阿里巴巴集团控股有限公司 | 混合视图的显示方法及装置 |
| CN105912517B (zh) * | 2016-03-31 | 2020-05-01 | 深圳市八零年代网络科技有限公司 | 可支持自由表单设计的数据结构及其转换方法及系统 |
| US10755030B2 (en) * | 2017-06-29 | 2020-08-25 | Salesforce.Com, Inc. | Color theme maintenance for presentations |
| CN111158839A (zh) * | 2019-12-31 | 2020-05-15 | 中国银行股份有限公司 | 段落内容展示方法及装置 |
| CN111913705B (zh) * | 2020-05-28 | 2023-07-25 | 中南大学 | 一种基于差异更新算法的JavaScript模板实现方法 |
| CN111708957A (zh) * | 2020-05-29 | 2020-09-25 | 平安科技（深圳）有限公司 | 基于索引和值引更新前端页面的方法、装置、计算机设备 |
Family Cites Families (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5781190A (en) * | 1996-06-05 | 1998-07-14 | Microsoft Corporation | Method and system for transferring a slide presentation between computers |
| US5751283A (en) * | 1996-07-17 | 1998-05-12 | Microsoft Corporation | Resizing a window and an object on a display screen |
| US6012083A (en) * | 1996-09-24 | 2000-01-04 | Ricoh Company Ltd. | Method and apparatus for document processing using agents to process transactions created based on document content |
| US6243700B1 (en) * | 1997-05-16 | 2001-06-05 | Paul Zellweger | Method and apparatus for generating a hypertext-based content menu using an open hierarchical data structure |
| US6008807A (en) * | 1997-07-14 | 1999-12-28 | Microsoft Corporation | Method and system for controlling the display of objects in a slide show presentation |
| JP2000276493A (ja) * | 1999-01-29 | 2000-10-06 | Canon Inc | 電子的にアクセスできるリソースのブラウジング方法 |
| US6456305B1 (en) * | 1999-03-18 | 2002-09-24 | Microsoft Corporation | Method and system for automatically fitting a graphical display of objects to the dimensions of a display window |
| US6515656B1 (en) * | 1999-04-14 | 2003-02-04 | Verizon Laboratories Inc. | Synchronized spatial-temporal browsing of images for assessment of content |
| US6748569B1 (en) * | 1999-09-20 | 2004-06-08 | David M. Brooke | XML server pages language |
| US6718515B1 (en) * | 1999-12-07 | 2004-04-06 | International Business Machines Corporation | Method of populating a dynamic HTML table from a set of data objects through a common interface |
| US7047033B2 (en) * | 2000-02-01 | 2006-05-16 | Infogin Ltd | Methods and apparatus for analyzing, processing and formatting network information such as web-pages |
| US7210099B2 (en) * | 2000-06-12 | 2007-04-24 | Softview Llc | Resolution independent vector display of internet content |
-
2001
- 2001-01-31 EP EP01903451A patent/EP1256070A2/en not_active Withdrawn
- 2001-01-31 US US10/203,044 patent/US7412644B2/en not_active Expired - Lifetime
- 2001-01-31 JP JP2001556906A patent/JP2003521784A/ja active Pending
- 2001-01-31 CN CNB018044883A patent/CN1205571C/zh not_active Expired - Fee Related
- 2001-01-31 WO PCT/US2001/003128 patent/WO2001057718A2/en active Application Filing
- 2001-01-31 AU AU2001231259A patent/AU2001231259A1/en not_active Abandoned
Cited By (25)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1954314B (zh) * | 2004-04-30 | 2010-05-26 | 微软公司 | 文档标记方法和系统 |
| CN100407138C (zh) * | 2005-08-04 | 2008-07-30 | 腾讯科技（深圳）有限公司 | 基于Brew的一种动态用户界面的体系结构和实现方法 |
| CN101449270B (zh) * | 2006-03-15 | 2011-11-16 | 谷歌公司 | 自动显示尺寸调整后的图像 |
| CN101131695B (zh) * | 2006-08-25 | 2010-05-26 | 北京书生国际信息技术有限公司 | 一种文档库系统及其实现方法 |
| CN101553771B (zh) * | 2006-10-23 | 2012-01-04 | 奥多比公司 | 绘制超文本标记语言内容 |
| CN101414257B (zh) * | 2008-11-13 | 2011-09-21 | 成都市华为赛门铁克科技有限公司 | 软件界面实现方法、装置 |
| CN103229167A (zh) * | 2010-10-06 | 2013-07-31 | 星汇数据解决方案公司 | 用于为电子发现数据编索引的系统和方法 |
| CN102841883A (zh) * | 2011-06-08 | 2012-12-26 | 株式会社Pfu | 表单提供装置以及表单提供方法 |
| CN102314499A (zh) * | 2011-08-26 | 2012-01-11 | 百度在线网络技术（北京）有限公司 | 一种用于处理网页内容的方法与设备 |
| CN104272291A (zh) * | 2012-03-07 | 2015-01-07 | 谷歌公司 | 唯一地识别脚本文件 |
| CN104272291B (zh) * | 2012-03-07 | 2017-06-23 | 谷歌公司 | 唯一地识别脚本文件 |
| CN103365862A (zh) * | 2012-03-28 | 2013-10-23 | 北京百度网讯科技有限公司 | 一种用于生成与页面对应的图片的方法与设备 |
| CN105284075A (zh) * | 2013-06-06 | 2016-01-27 | 国际商业机器公司 | 基于为网页的网页元素聚合用户偏好的优化网页加载 |
| US10803232B2 (en) | 2013-06-06 | 2020-10-13 | International Business Machines Corporation | Optimizing loading of web page based on aggregated user preferences for web page elements of web page |
| US10817653B2 (en) | 2013-06-06 | 2020-10-27 | International Business Machines Corporation | Optimizing loading of web page based on aggregated user preferences for web page elements of web page |
| US11017152B2 (en) | 2013-06-06 | 2021-05-25 | International Business Machines Corporation | Optimizing loading of web page based on aggregated user preferences for web page elements of web page |
| US11017153B2 (en) | 2013-06-06 | 2021-05-25 | International Business Machines Corporation | Optimizing loading of web page based on aggregated user preferences for web page elements of web page |
| CN105094872A (zh) * | 2014-05-16 | 2015-11-25 | 腾讯科技（北京）有限公司 | 一种显示网页应用的方法和装置 |
| CN105094872B (zh) * | 2014-05-16 | 2019-04-02 | 腾讯科技（北京）有限公司 | 一种显示网页应用的方法和装置 |
| CN106663083A (zh) * | 2014-07-09 | 2017-05-10 | 惠普发展公司，有限责任合伙企业 | 用于基于http的应用的网络浏览器策略 |
| CN106663083B (zh) * | 2014-07-09 | 2019-06-04 | 惠普发展公司，有限责任合伙企业 | 用于基于http的应用的网络浏览器策略 |
| US10333991B2 (en) | 2014-07-09 | 2019-06-25 | Hewlett-Packard Development Company, L.P. | Web browser policy for HTTP-based application |
| CN106557289A (zh) * | 2015-09-29 | 2017-04-05 | 珠海金山办公软件有限公司 | 一种幻灯片显示方法、系统及装置 |
| CN108023918A (zh) * | 2016-11-02 | 2018-05-11 | 阿里巴巴集团控股有限公司 | 一种服务信息获取方法、装置及系统 |
| CN107844465A (zh) * | 2017-11-11 | 2018-03-27 | 江西金格科技股份有限公司 | 一种ofd格式文档支持脚本的方法 |
Also Published As
| Publication number | Publication date |
|---|---|
| WO2001057718A3 (en) | 2002-08-15 |
| JP2003521784A (ja) | 2003-07-15 |
| EP1256070A2 (en) | 2002-11-13 |
| US7412644B2 (en) | 2008-08-12 |
| WO2001057718A2 (en) | 2001-08-09 |
| US20040177327A1 (en) | 2004-09-09 |
| CN1205571C (zh) | 2005-06-08 |
| AU2001231259A1 (en) | 2001-08-14 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN1398377A (zh) | 提供和呈现可定标web页面的系统和处理 | |
| JP4344693B2 (ja) | ブラウザの文書編集のためのシステムおよびその方法 | |
| US9026733B1 (en) | Content-based caching using a content identifier at a point in time | |
| US7197702B2 (en) | Web page rendering mechanism using external programmatic themes | |
| US7051276B1 (en) | View templates for HTML source documents | |
| JP4698668B2 (ja) | 文書マークアップ方法およびシステム | |
| US9940744B2 (en) | Remote font management | |
| US20090006471A1 (en) | Exposing Specific Metadata in Digital Images | |
| US20120110437A1 (en) | Style and layout caching of web content | |
| JP2010170568A (ja) | アプリケーションからの視覚的形式の情報をデータベースに格納しデータベースから検索する情報格納および検索システム | |
| JPWO2006051715A1 (ja) | 文書処理装置及び文書処理方法 | |
| US9953016B2 (en) | Composition and declaration of sprited images in a web page style sheet | |
| US7865481B2 (en) | Changing documents to include changes made to schemas | |
| JPWO2006051975A1 (ja) | 文書処理装置 | |
| JPWO2006051713A1 (ja) | 文書処理装置及び文書処理方法 | |
| CN105589959A (zh) | 表单处理方法和表单系统 | |
| US20090083300A1 (en) | Document processing device and document processing method | |
| CN110377371B (zh) | 一种基于Web标签的样式表系统管理方法 | |
| US20080250311A1 (en) | Document Processing Device, and Document Processing Method | |
| US7802181B2 (en) | Document processing device and document processing method | |
| JPWO2006051712A1 (ja) | 文書処理装置及び文書処理方法 | |
| US8862976B1 (en) | Methods and systems for diagnosing document formatting errors | |
| US7657869B2 (en) | Integration of external tools into an existing design environment | |
| US20080005136A1 (en) | Data Processing Device, Document Processing Device, and Document Processing Method | |
| US20100077295A1 (en) | Document processing device and document processing module |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| C14 | Grant of patent or utility model | ||
| GR01 | Patent grant | ||
| C17 | Cessation of patent right | ||
| CF01 | Termination of patent right due to non-payment of annual fee |
Granted publication date: 20050608 Termination date: 20100131 |