CN1110064A

CN1110064A - 动态连接系统

Info

Publication number: CN1110064A
Application number: CN94190308A
Authority: CN
Inventors: 戴维·R·安德逊; 杰克·H·佩勒维奇; 拉里·S·罗森斯泰因; 阿诺德·歇埃福尔
Original assignee: Taligent Inc
Current assignee: Taligent Inc
Priority date: 1993-07-19
Filing date: 1994-01-03
Publication date: 1995-10-11
Also published as: JPH09500465A; DE69400870T2; US5787448A; AU5990894A; CA2155357A1; EP0689692A1; EP0689692B1; WO1995003574A1; DE69400870D1; CA2155357C

Abstract

本发明涉及一种用于在一个第一文件中选中一个位置，从而在第二文件中选择一个位置，并在第二文件上执行一个动作和在第一文件所确定之处执行相同动作的方法和系统。一个实施例把一个第一目标连到第二目标并执行一个动作，例如启动第二目标的一个应用程序并记忆最后访问文件的地址。另一实施例被命名为全模型实施例，它对整个目标提供一个锚。该锚使得一个动作可被加至整个目标。

Description

动态连接系统

本发明一般涉及计算机系统的改进，尤其涉及连接文件之间的信息的操作和区域的系统和方法。本申请涉及题为：“面向目标的结构系统”的专利申请，该申请是由沃滕(DebraL.Orton)等人在1992年12月23日提交到美国联邦专利商标局并转让给本申请人。该申请亦在1993年12月23日提交到中国专利局，其申请号为93112880.3。该专利申请的内容结合于此以为参照。本申请的部分内容受版权保护。版权所有人未禁止专利文件的任何人传真其复印件，例如出现在专利局有关文档或记录中的文件。但版权所有人保留所有其他权利。

文件处理是当前个人计算机技术最流行的应用。已有的字处理技术的例子包括Wordperfect文本处理程序以及Mi-crosoft公司的Word文字处理程序。这些产品被设计用于各种操作系统和不同的硬件环境。如果可以在一个单一的硬件环境下共用不同应用程序之间的信息，无疑将会带来很大的方便。通过对美国专利4,674,043所展示的图表进行编辑，可把某些用于建立商用图表数据的自动更新的应用程序进行硬编码而赋予它们上述能力。但是，在当前的字处理环境中，不可能在一个第一文件中动态地锚定信息并根据一个第二文件中的行为交换更新的信息。

因此，本发明的主要目的是提供一种用于在第一文件中选择一个位置，在第二文件中选择一个位置，在第二个文件中执行一个动作并自动地在第一文件的所限定的位置处执行同样动作的系统和方法。一个替换的实施例把一个第一目标连接到一个第二目标并执行一个动作，例如激励第二目标的一个应用程序，并记忆最后访问的文件的位置。另一最佳实施例(称为全模型实施例)为一个完整的目标提供了一个锚。该锚可将一个动作施加到这整个目标。例如，从一个记录板目标(Clipboard Object)复制数据时，复制命令被导向该记录板目标的目标锚。其他实施例则提供了在一个文件或展开图表中代表第一个拼写错误字或最高值的一个锚。

图1是根据本发明最佳实施例的一个个人计算机系统框图；

图2是根据本发明一个最佳实施例的文件显示，它包括一个选定的区域和一个锚。

图3是根据一个最佳实施例的处理流程图。

图4是一个文件显示，其示出了具有相应锚的两个文件；

图5示出了根据本发明的最佳实施例当一个第一命令已在一第一文件上执行之时的文件显示；

图6示出了根据本发明的最佳实施例已在一个第二锚定文件上执行了一个第一命令的文件显示。

本发明最好在IBM PS/2或Apple Macintosh计算机之类的个人机中的操作系统里实施。图1示出了具有代表性的硬件环境，它展示了根据本发明的工作站的典型硬件构造，它包括一个中央处理器10(例如常规的中央处理器)，该中央处理器有一内部非易失存储器11以及多个与系统总线12相连的其他部件。图1所示工作站包括一个RAM14，ROM16，用于连接磁盘部件20和软盘21之类的外围设备到总线的I/O适配器18，用于把键盘24，鼠标器26，扬声器28，麦克风2以及/或其他用户接口设备(例如触摸式屏幕设备)等连到总线的用户接口适配器22，用于把工作站连到数据处理网络23的通讯适配器34，以及把总线连到显示设备38的显示适配器36。该工作站中的操作系统为诸如AppleSystem/7之类的操作系统。

在一个最佳实施例中，本发明是采用面向目标的编程技术的C⁺⁺程序语言实现的。正如本领域一般技术人员所理解的，面向目标的编程(OOP)目标是包括数据结构和数据中的操作的软件实体。这些单元一起以数据单元表示的特性以及由其数据操纵功能表示的行为使目标实际成型为任意现实社会中的实体。以这种方式，目标可以成型为具体的事物，例如人和计算机，而且亦可成为抽象概念，例如数字或几何概念。目标技术的好处来自于三个基本原理：封装，多形性以及继承性。

所谓封装(encapsulation)是指一种把数据以相应的过程存储起来的技术，而多形性则是指在一个共同的界面后面隐藏不同实现，从而简化目标之间的通信的能力。继承则是指一种处理，其中，分类可以利用在分类层级的分支上高于该分类的所有分类所限定的方法和变量。

目标根据功能的工作来隐藏(或封装)其数据的结构和算法。除了展现这些实施细节，目标展示清楚表达其抽象而无冗余信息的界面。多形性则将封装又推进一步。该概念是多个形状，一个界面。一个软件部件可以提出另一部件的请求而无需知道那一部件倒底是怎样的。接收请求的部件对其进行解释并根据其变量和数据确定如何执行该请求。第三个原理是继承性，它允许开发者再使用先有的设计和编码。这一能力使开发者避免擦除以生成软件。进而，通过继承，开发者获得继承了行为的子分类，从而使开发者将其客户化以满足特定的需求。

一种先有技术的方法是在过程环境中对目标和分类库进行分层。市场上的许多应用程序都采用了这种设计方法。在这种设计中，在单一操作系统的顶部有至少一个层级。虽然这一方式利用了目标层级中的封装，多形性以及继承性这些原理，实际上是对过程编程技术的重大改进，但其仍有局限性。其困难之处在于虽然开发者能很容易地再使用他们自己的目标，但使用来自其他系统的目标则很难，而且开发者仍需由过程操作系统(OS)调用进入较低的非目标层级。

面向目标编程的另一方向是应用程序开发的结构方式。结构的最合理定义之一是由依利诺易斯大学(University ofIllinois)的强森(Ralph E.Johnson)以及普波(Purdue)的卢棱(Vincent F.Russo)做出的。在他们1991年发表的题为“面向目标设计的再使用(Reusing Object-Oriented Designs)”(该文发表在依利诺易斯大学技术报告UIUCDCS91-1696)一文中提出了以下定义：“一个抽象分类是一组合作执行一组响应的目标的设计。因此，一个结构是一组合作执行所确定的组的计算响应的目标分类”。从编程观点出发，结构实际上是一组提供工作应用程序的预制结构的内连目标分类组。例如，一个用户界面结构可以提供绘制视窗，卷动条以及菜单等的支持和“系统预置”行为。由于结构基于目标技术，该行为可被继承和置换以使开发者对结构进行扩展并在一特定的区域生成客户化方案，由于编程不改变初始码而只是扩展软件，上述优点便成为一个优于传统编程的主要特点。此外，由于结构提供了体系结构指导和模型并在同时允许为问题范畴提供了唯一的独特行为，开发者不会盲目地通过编码层级进行工作。

从商业观点来看，结构被视为在一特定知识领域封装或嵌入专门知识的方式，公司开发机构，独立软件销售商(ISV)以及系统集成者已经提出了在特定区域中的专门知识的要求，这些特定区域包括制造，财会，以及现金交易。该专门知识被嵌入编码中。结构允许这些开发机构捕捉并封装该专门知识的通用特性，其过程是将其嵌入机构的编码之中。首先，这使得开发者生成或扩展利用该专门知识的应用程序，因此把问题解决一次并使商业规律和设计被前后一致地实施和使用。另外，在结构后面的嵌入专门知识以及结构对已经在统管生产和销售的市场的知识(例如生产，财会或生物技术)的那些机构有策略的有益含义，或生物技术需要包装，再销售，以及推广应用其知识，并进而推广和开发普及其技术。

从历史而言，结构(framework)只是在最近才成为个人计算机的主流概念。这一发展得力于面向目标语言(例如C⁺⁺)的发展。C⁺⁺最早是在UNIX系统和研究人员的工作站上实现的，而不是在商用个人计算机上发现的。正是C⁺⁺语言以及其他面向目标的语言(例如Smalltalk等等)使得许多大学和研究项目产生了当今商用结构和分类库的先驱。这些例子包括斯坦福大学(Standford University)的InterViews，卡内基—麦伦大学(Carnegie-Mellon University)的Andrewtoolkit，以及朱瑞赤(University of Zurich)的ET++结构。

根据想解决的问题以及希望涉及的系统层级，有多种结构。这些结构包括帮助开发用户界面的应用程序结构以及提供基本系统软件服务(例如通讯，打印，文件系统支持，图形等等)的低级结构。应用结构的商用例子是MacApp(Apple)，Bedrock(Symantec)，OWL(Borland)，NeXtStep App Kit(NeXT)，以及Smalltalk-80 MVC(ParcPlace)等等。

结构编程要求与常规的其他系统不同的新思维方式。事实上，它与传统概念的“编程”全然不同。在以前的操作系统中(例如DOS或UNIX)，开发者自己的程序提供了所有结构。操作系统通过系统调用提供服务——开发者的程序在需要服务产生调用时以及服务完成时控制返回。程序结构基于嵌入开发者写的编码中的控制流程。

当结构使用时，其过程相反。开发者不再依赖控制流程。开发者必须根据执行流程事先了解编程任务的趋向。进而，必须依据目标的响应性进行思考，这必须根据结构确定何时执行任务。由开发者所写的程序由不是开发者写的而且开发者从未见到的编码激励。控制流程中的转换可能对只在过程编程中有经验的开发者构成较大的心理障碍。但是，一旦明白之后，结构编程所需工作就大大少于其他编程。

以一个应用结构(application framework)给用户提供预制功能性同样方法，系统结构(正如在最佳实施例中包括的)通过提供系统级服务而实现同样概念。系统程序员之类的开发者可用其进行子分类/置换以生成客户化的方案。例如，考虑一个可以提供基础以支持视频，音频，MIDI，动画等等新的以及多功能设备的多媒体结构需要的一种新设备的开发者必须写一个设备驱动程序。若以结构完成这一任务，则开发者只需支持该新设备的特定特性和行为。

在这种情况下，开发者提供将为该多媒体结构调用的某种成员功能实施。开发者可得到的好处在于每类设备需要的通用编码已由多媒体结构提供了。这意味着开发者要编写，测试和检测的设备驱动程序编码减少了。使用系统结构(System framework)的另一例子是对小计算机系统接口(SCSI)设备。NuBus卡，以及图形设备提供各自的I/O结构。由于有继承功能性，每个结构为在其设备类别中发现的通用功能性提供支持。其他开发者则可采用对各种设备一致的界面。

本发明的一个最佳实施例采用了结构的概念并将其应用于整个系统。对于商业和企业开发者，系统集成商或OEM，这意味着象Mac/App一类的结构所展示的优点可以不仅作用于文本和用户界面之类的事物，而且亦可用于系统的服务，例如图形，多媒体，文件系统，I/O，以及测试等等。

在一个最佳实施例的体系结构中的应用程序生成实质上与编写附加到结构协议的特定域的谜块类似。在这一方式中，编程的整个概念改变了。代之以在调用多个API层级的编码行之后写编码行，软件将由在该环境中的先有结构导出的分类所发展，并然后根据需要加入新行为并/或替换继承的行为。

如此，开发者的应用程序成为由所有其他结构应用程序编写和共享的编码集。由于开发者将可在相互的工作上工作，因此这是一个很有力的概念。这也为开发者提供了根据需要进行客户化的灵活性。某些结构将被原样使用。在某些情况下，客户化的量将很小，所以开发者插入的谜块将很小。在另外的情况中，用户可以进行很大修改并生成全新的事件。在一个最佳实施例中，如图1所示，在RAM14中的程序由CPU10的控制用一个面向目标的文件结构来管理各种任务。

同步连接的综观

本系统的文件体系结构提供了用于连接的技术。这一体系结构的一部分包括对于通用目的面向数据连接的表达和命令。该连接体系结构也将用于实现其他与通用数据连接人类界面例如注释不相类似的特性。此外，第三方开发者可使用连接体系结构以便在其自己的应用程序(例如一个日历)或一个分类建文本环境中实现特殊能力。

同步连接使同样信息可在不止一个位置被观看。两个相互更新的信息的频率和方向可在连接的任意一端被控制。连接锚是在一个文件中被连接数据的延伸的特殊可见指示。

生成连接

生成一个同步连接与剪裁/复制和粘贴很类似。为了启动一个连接，用户用只要是对该数据类型必要和适当的手段来选择某些数据。采用菜单命令，用户可复制该选择。然后，在理想的目的地，用户从菜单项目中选择一个命令并从随后的会话框中选择另一命令。可复制某些事物，然后作为连接粘贴不止一次。甚至在源文件被关闭之后。当原始源文件再次打开之时，将展示源数据是从哪个连接锚复制而来的。

一个直接操纵方法是要用来选中一个特殊连接拖曳工具以便将该选择拖移至新地点。按住任选和命令键是执行该命令的简捷方法。这样便把其他两个修改键的语义加在一起了——任选键用于复制而命令键用于引用连接。因此，修改键是获取该工具的捷径。连接优选菜单项在选择被粘贴(或任选拖曳)并仍被选中之后成为可用。然后，用户可以常规方式进行复制和粘贴。进而，在粘贴的信息仍被选中时，把连接接通以加速把命令施加到另一文件。

删除

删除只接收信息的连接与删除任何其他目标一样。源目标会在某点被通知接收者不再存在。删除发送信息的连接可能需要一个警告以通知用户删除该连接将影响其他文件的一些部分。当文件打开时，通知指示发送连接不再存在。当一个连接源被删除时，其接收连接将是嵌入或吸收的数据。

编辑数据

用户交互连接的数据的过程与他们和任何其他嵌入或吸收的数据交互的过程一样。当连接的数据被选中时。表示连接程度的锚和与连接能力相关的命令出现在菜单中。根据文件的特权级以及连接的特性，用户可以能够完全编辑并进行改变，或只限于在数据中进行选择。当连接的数据在任意端都是可编辑之时，根据该连接被设定更新的频率在一端所做的改变出现在另一端。

当连接的信息只从一端到另一端时，接收端的数据是不可编辑的，但其是可选择的。例如，字和句子可在连接文本的一个段落中选择。一个文件的特权级也可影响该文件中的连接的可编辑性。连接的信息可被选择但在一锁定文件中不可编辑。包含连接的选择在复制和粘贴时保留其连接。例如，从一个连接的句子中复制和粘贴一个字也将复制和粘贴该连接。特殊粘贴允许在没有连接的情况下粘贴数据。连接的扩展可包括连接并与其他连接区重叠。

到底在连接的一端有多少信息可以改变而又不会影响连接的另一端是与数据类型的实现相关的，通过使用风格，客户可以对连接的数据进行本地改变。

跟随连接

连接的另一端可由在连接上得到优先级(在菜单项目中的“Get info”或“Link info”)一个优先级显示板包含一个对另一端的实际引用连接。或至少，它可包含一个标记为“OpenSource”，“Open destination”，“Open other end”的按键，或若不止一个时，将包含有关该连接另一端的表。

更新频率和方向

最新生成的同步连接将与某个系统预置特性一起被生成。一个新连接将根据用户的要求把数据从源推入到目的(以一个方向)。在目的中将是不可编辑的。选中这种设置是由于其安全且易于理解。对数据的改变只是在连接以前生成的方向流动——从连接的起始地点到新地点。对数据的改变只发生在用户请求他们发生之时。用户必须清楚地选通任选以便对数据的改变是一双向的，或更频繁地更新。

连接的优先级可在连接的任一端改变这些设置，用于选择连接的优先级显示将包含下列信息和命令：

·History of the Link：created in…，goes to…，last updatedon…

·Update when：(default：none selected)

-on close

-on open

-on date & time

-on frequency

·Open Source/Destination/Other end documen

·Unlink

·Update now

·Allow editing in destination/(two way link)

对数据的改变可被推到连接的另一端。若包含连接另一端的文件被打开，则其将接收新信息可用的通知。若接收文件此时关闭，则其将在被打开之时得到通知和新信息。连接亦可把数据从连接的另一端“拉”回来。这种情况的发生与包含另一端的文件的开关状态无关。若在另一端没有发生任何变化，则接收的数据不可以可见地改变。

本发明的一个最佳实施例生成的动态锚，这与粘贴选择或同步连接相类似。选择被用于选定文本或展开单元或在绘制文件中的特定图形的一个范围(邻接的或不邻接的)。图2的210展示了一个选择的例子，一个锚是一个总是有效并可通过一些其他手段进行选择检索的选择。通常有与该选择有关的标记220。用户可以在该标记上扣一下以使该选择再次成为当前选择。在一个最佳实施例中的连接是在两个锚之间的连接。一个动态锚操作的例子发生于两个选择和两个支持的操作把数据推过一个连接并在该连接上拉回的时候。一个最佳实施例的唯一特性是支持连接的动态位置而非固定位置的能力。

例如，若一个用户有两个字处理文件A和B，而且一个锚被加到文件A的一段，并且文件B中的相应段落有另一附加的锚，则数据可以在两个文件之间用推拉命令前后推移。动态锚的有趣之处在于目的地在连接被激励之前是自由的。除了连到文件的特定选择，可能发生动态结合，例如，拼写检查程序可以动态地加到一个文件以便在文件中选择第一个错误拼写字。代换之，通过结合一个展开图表可以选择该展开图表中的最大值。基本上，动态锚允许运行时间计算以确定所连接的实际的特定物理数据。

给定一个先有技术的连接模型，其中的每一事物都被选中并有一个连接附加于上，则当对该模型进行相加时，连接不包括新加入的数据它只包括初始选中的部分。根据本发明最佳实施例的动态和的完整模型锚，包括了该模型的全部数据，而无论后加了多少。该锚在数据请求时刻被计算。然后，若更多数据加到模型中，则其计算该锚初始有效的不同范围。当在剪裁板中执行复印操作时，模型中的数据的复制被检索，然后，出版连接操作被执行到动态锚，该锚表示在该模型中的所有数据，以及请求粘贴剪接板数据的时候，执行连接请求以及将数据通过接出栈。这一体系结构展示了动态锚的实施并加强了通过锚和连接进行信息出栈以实施剪裁板的能力。无需采用超出常规对连接出杠和压入数据的特殊码。

图3是展示根据本发明最佳实施例的处理流程图。处理始于3000并立即去往功能框310。在310处打开第一和第二目标。目标可以是文本文件，图形图象，展开图表或其他计算机应用程序。然后在功能框320处，在两个目标中生成一个锚位置。该锚仅标志了一个选择区并抽象地指定了一个动作。该动作在其后或查阅时间被判定。功能框330展示了在起始一侧生成跟随命令的处理。该处理选择连接的位置并在文件的起始一侧生成跟随命令。虽然本例在两个文件中有两个起始一侧和目的一侧，本技术的一般技术人员可认识到两个目标可位于同一文件中。然后，在功能框340处，命令被送至另一文件的锚的目的一侧。送出操作要求在功能框350处的连接请求，从而把选择设置成锚，并将锚的位置卷动到可见位置。如功能框360所文。然后，加在起始一侧的命令被加至目的一侧，如框370所示。最后，处理完成于380处。

图4是展示具有相应锚的两个文件的文件显示图。两个锚示于410和420处，正如由线所围绕的选择区域。如上所述，在源文件410中的锚允许命令在将被加到锚定的目的文件的源文件上执行。图5示出了当一个第一命令在第一文件上执行的文件显示。在这一情况下的命令是出现在锚定区500处的销售数字的更新。

图6是根据一个最佳实施例在一个第一命令已在一个第二锚定的文件中执行时的文件显示。图6中，源文件已将命令加至600处的锚定区。锚定的区域反映了在源文件上已完成的同样改变。替换之，在图6中，展开图表的最大值可从600处的动态锚中选取。基本上动态锚允许运行时间计算以确定对用户有用的实际特定物理数据。

锚程序表C⁺⁺语言

/MAbstractModelAnchor/
class MAbstractModelAnchor：public MCollectible{

    public：

          virtual

    ～MAbstractModelAnchor()；         ：

          virtual TStream&amp;                operator＞＞＝(TStream&amp;
towhere)const；

          virtual TStream&amp;                operator＜＜＝(TStream&amp;
fromwhere)；

          virtual long Hash()const；

          virtualBoolean                  IsEqual(const MCollectible*)
const；

          virtual void PrintMe()const；

          VersionDeclarationsMacro(MAbstractModelAnchor)；

    TGlobalID GetUniqueID()const；

          virtual     void                SetUniquelD(const
TGlobalID&amp;)；

          virtual     TModelSurrogate*    CopyModelSurrogate()
const＝0；

          virtual     const TModelSurrogate*GetModelSurrogate()const＝()；

          virtual     void                 SetModel(const
TAbstractModel&amp;)＝0；    
				
				<dp n="d15"/>
    protected：

    MAbstractModelAnchor(const MAbstractModelAnchor&amp;)；

    MAbstractModelAnchor()；

    MAbstractModelAnchor&amp;                     operator＝(const
MAbstractModelAnchor&amp;)；

    private：

          TGlobalID                           fUniqueID；

          static const VersionInfo    kOriginalVersion；
}；                                                  ..
/*-*/
/*TModelAnchorSurrogate*/
class TModelAnchorSurrogate；public MAbstractModelAnchor{

    public：

    TModelAnchorSurrogate(const TModelAnchorSurrogate&amp;)；

    TModelAnchorSurrogate(const MAbstractModelAnchor&amp;)；

    TModelAnchorSurrogate()；

        virtual

    ～TModelAnchorSurrogate()；

                        TModelAnchorSurrogate&amp;   operator＝(const
TModelAnchorSurrogate&amp;)；

                        TModelAnchorSurrogate&amp;   operator＝(const
MAbstractModelAnchor&amp;)；

        virtual TStream&amp;                     operator＞＞＝(TStream&amp;
towhere)const；

        virtual TStream&amp;                     operator＜＜＝(TStream&amp;
fromwhere)；

        virtual void     PrintMe()const；

        MCollectibleDeclarationsMacro(TModelAnchorSurrogate)；
				
				<dp n="d16"/>
             virtual    TModelSurrogate*    CopyModelSurrogate()

    const；

             virtual    const TModelSurrogate*GetModelSurrogate()const；

             virtual    void                      SetModel(const

    TAbstractModel&amp;)；

             //Check if surrogate is for valid anchor.

             virtual    Boolean                       IsValid()const；

             virtual TModelAnchor*GetAnchor()const；

             //Data exchange

             virtual    void    ..

    CreatePreferredTypeList(TSequence&amp;theTypes)const；

             virtual    TTypeDescription*

    ChoosePreferredType(const TSequence&amp;theChoices，ETypeAcceptKind&amp;)
const；

             virtual    TModel*

    CopyDataAndAnchors(const TTypeDescription&amp;theType)const；

             //Constants

             static const TModelAnchorSurrogate&amp;    kInvalidAnchor；

    private：

             TModelSurrogateStreamer                fModel；

             static const VersionInto    kOriginalVersion； 
  }；
  /*-*/
  /*TModelAnchor*/

    class TModelAnchor：public MAbstractModelAnchor，public TModelSelection
{

        public：

                                                    TModelAnchor(const

    TAbstractModel&amp;，const TTime&amp;modifydate)；

                                                    TModelAnchor(const

    TModelSelection&amp;，const TTime&amp;modifydate)；

                                                     TModelAnchor(cons

    TModelAnchor&amp;)；    
				
				<dp n="d17"/>
                                                    TModelAnchor()；

                      TModelAnchor&amp;                 operator＝(const
TModelAnchor&amp;)；

          virtual～TModelAnchor()；

          virtual Boolean                IsEqual(const MCollectible*)const；

          virtual TStream&amp;               operator＞＞＝(TStream&amp;towhere)
const；    

          virtual TStream&amp;               operator＜＜＝(TStream&amp;fromwhere)；

          virtual void                         PrintMe()const；

          MCollectibleDeclarationsMacro(TModelAnchor)；

          virtual    void                      Touch()；..

          virtual    void                      GetModifvDate(TTime&amp;
theDate)const；

          virtual    void                      SetModifyDate(const TTime&amp;
theDate)；

          virtual    void                      SetSelection(const
TModelSelection&amp;theSelection)；

          virtual    void

    AdoptSelection(TModelSelection*theSelection)；

          virtual    const TModelSelection*GetSelection()const；

          virtual    void                      Follow(const
TModelLinkSurrogate&amp;theLink)；

          virtual    void                      Execute(const
TModelLinkSurrogate&amp;theLink，TModelCommand&amp;theCommand)；

          //TModelSelection overrides

          virtual    TModelAnchor*             CreateAnchor()const；

          virtual Boolean                      IsAnchorable()const；

          virtual Boolean                      IsReadable()const；

          virtual Boolean                      IsWriteable()const；

          virtual Boolean                      IsClearable()const；

          virtual    void                      SetModel(const
TAbstractModel&amp;theModel)；

          vir*ual    TModelSurrogate*          CopyModelSurrogate()const；

          virtual    const TModelSurrogate*    GetModelSurrogate()const；
				
				<dp n="d18"/>
             virtual    void                     SetPresentation(cons
TPresentation&amp;thePresentation)；

             virtual    void                     SetPresentation(const
TPresentationSurrogate&amp;thePresentation)；

             virtual    void

     CreatePreferredTypeList(TSequence&amp;theTypes)const；

             virtual    TTypeDescription*        ChoosePreferredType(const
TSequence&amp;theChoices，ETypeAceeptKind&amp;)const；

             virtual    TModel*                  CopyDataAndAnchors()
const；

             virtual    TModel*

    CopyDataAndAnchors(const TTypeDescription&amp;theType)const；

             virtual    TModel*                  ..

     AbsorbDataAndAnchors(TModel*theData，

    TModelSelection*&amp;theNewSelectionIfDifferent)；

             virtual    TModel*

    AbsorbDataAndAnchorsForUndoRedo(TModel*theData)；

             virtual    TModel*

    EmbedDataAndAnchors(TModel*theData，
TModelSelection*&amp;theNewSelectionIfDifferent)；

             virtual    TModel*

     ClearDa taAndAnchors(TModelSelection*&amp;theNewSelectionIfDifferent)；

             virtual    TModel*

    ClearDataAndAnchorsForUndoRedo()；

              virtual    TModel*

    ImportDataAndAnchors(TModel*)const；

             virtual    BooleanIsA(const TToken&amp;theType)const；

             virtual    Boolean    IsValid()const；

             virtual    void  SetValid(Boolean isValid＝TRUE)；

             virtual    Boolean    IsEmpty()const；

             virtual    void

    AddAnchor(const MAbstractModelAnchor&amp;anAnchor)；

             virtual    void                RemoveAnchor(const
MAbstractModelAnchor&amp;anAnchor)；    

              virtual    void                RemoveAllAnchors()；

             virtual    TIterator*          CreateAnchorlterator()const；

              virtual    void    
				
				<dp n="d19"/>
    AddModel(const TAbstractModel&amp;aModel)；

          virtual    void

    RemoveModel(const TAbstractModel&amp;aModel)；

         virtual    void  RemoveAllModels()；

         virtual    TIterator*               CreateModelIterator()const；

         virtual    TIterator*               CreateSelectionIterator()const；

         virtual    TModelSelection*          ；

    CopyAndExtendToStart()const；

         virtual    TModelSelection*

    CopyAndExtendToEnd()const；

    //Anchorattributes                        ..

         virtual    void AddAttribute(const TAttribute&amp;theAttribute)；

         virtual    void DeleteAttribute(const TAttribute&amp;theName)；

         virtual    const TAttribute*

    LookupAttribute(const TAttribute&amp;theName)const；

         virtual    void          DeleteAllAttributes()；

         virtual    TIterator*    CreateAttributeIterator()const；

        //Links

         virtual    void          AdoptLink(TModelLink*
aLink)；

         virtual    TModelLink*

     OrphanLink(const TAbstractModelLink&amp;aLink)；

          virtual    TModelLink*

    LookupLink(const TModelLinkSurrogate&amp;aLink)；

          virtual    void           DeleteAllLinks()；

         virtual    TIterator*

    CreateLinkIterator()const；

         virtual    void           SetVisibility(Boolean visible＝
TRUE)；

          virtual    Boolean        GetVisibility()const；

         virtual    Boolean

         IsDynamic()const；

    private：

         TTime                      fModifyStamp；
				
				<dp n="d20"/>
    TModelSelection*            fSelection；
 
    TSimpleAttributeGroup*           fAttributes；

    TDeque fLinks；

    Boolean fVisible；

    static const VersionInfo    kOriginalVersion；
#ifndef NO_INTERN AL

    public：

        virtual  void                FinalizeAfterLookup()；
#endif
}；
/*-*/
/*TDynamicAnchor*/
class TDynamicAnchor：public TModelAnchor{

    public：

        virtual                           ～TDynamicAnchor()；

        virtual TStream&amp;          operator＞＞＝(TStream&amp;towhere)
const； virtual TStream&amp;          operator＜＜＝(TStream&amp;fromwhere)；

        virtual void PrintMe()const；

        VersionDeclarationsMacro(TDynamicAnchor)；

        //TModelAnchor overrides

        virtual    void              SetVisibility(Boolean)；

        wrtual     Boolearn                 GetVisibility()const；

        virtual    BooleanIsDynamic()const；

        virtual    void              FinalizeAfterLookup()；

    protected：

                                             TDvnamicAnchor(const
TAbstractModel&amp;，const TGloballD&amp;)；

                                            TDynamicAnchor(const
TDvnamicAnchor&amp;)；

                                            TDynamicAnchor()；
				
				<dp n="d21"/>
    TDynamicAnchor&amp;operator＝(const TDynamicAnchor&amp;)；

    virtual    TModelSelection*CreateDynamicSelection()const＝0；

    private：

         static const VersionInfo  kOriginalVersion；

    }；

    /**/

    /*TCurrentSelectionAnchor*/

    class TCurrentSelectionAnchor：public TDynamicAnchor{

         public：

         TCurrentSelectionAnchor(const TAbstractModel&amp;)；

         TCurrentSelectionAnchor(const TCurrentSelectionAnchor&amp;)；    

                   TCurrentSelectionAnchor&amp;    operator＝(const

    TCurrentSelectionAnchor&amp;)；

               virtual～TCurrentSelectionAnchor()；

              virtual TStream&amp;           operator＞＞＝(TStream&amp;toWhere)

    const；
              virtual TStream&amp;           operator＜＜＝(TStream&amp;fromwhere)；

              virtual void                     printMe()const；

              MCollectibleDeclarationsMacro(TCurrentSelectionAnchor)；

    protected：

    TCurrentSelectionAnchor()；

         virtual    TModelSelection*CreateDynamicSelection()const；

    private：

         static const VersionInfo kOriginalVersion；

    }；

    /*-*/

     /*TWholeModelAnchor*/
				
				<dp n="d22"/>
    class TWholeModelAnchor：public TDynamicAnchor{

          public：

    TWholeModelAnchor(const TAbstractModel&amp;)；

    TWholeModelAnchor(const TWholeModelAnchor&amp;)；

                  TWholeModelAnchor&amp;operator＝(const
TWholeModelAnchor&amp;)；

         virtual～TWholeModelAnchor()；

         virtual TStream&amp;           operator＞＞＝(TStream&amp;towhere)
const；

         virtual TStream&amp;           operator＜＜＝(TStream&amp;fromwhere)；

         virtual void               printMe()const；

         MCollectibleDeclarationsMacro(TWholeModelAnchor)；

    protected：

                                                  TWholeModelAnchor()；

    virtual    TModelSelection*CreateDynamicSelection()const；

    private：

         static const VersionInfo  kOriginalVersion；
  }；
  /*-*/
  /*TAbstractModelLink*/
  class TAbstractModelLink；public MCollectible
  {

    public：

          virtual

    ～TAbstractModelLink()；

                   TGlobalID              GetUniqueID()const；

         virtual    void                  SetUniqueID(const
TGlobalID&amp;)；

    const TModelAnchorSurrogate*    GetHere()const；

    const TModelAnctorSurrogate*    GetThere()const；
				
				<dp n="d23"/>
         VersionDeclarationsMacro(TAbstractModelLink)；

         virtual TStream&amp;operator＞＞＝(TStream&amp;towhere)const；

         virtual TStream&amp;operator＜＜＝(TStream&amp;fromwhere)；

         virtuallong     Hash()const；

         virtual Boolean               IsEqual(const MCollectible*)
  const；

         virtual void PrintMe()const；    
   protected：
   TAbstractModelLink()；
   TAbstractModelLink(const TAbstractModelLink&amp;)；   ..    
   TAbstractModelLink(const TModelAnchorSurrogate&amp;here，

                                                        const
TModelAnchorSurrogate&amp;there)；

    TAbstractModelLink&amp;operator＝(const TAbstractModelLink&amp;)；

    private：
          TGlobalID                                fUniqueID；

          TModelAnchorSurrogate    fHere；

           TModelAnchorSurrogate                    fThere；

           static const VersionInfo       kOriginalVersion；

    }；

    /*-*/

    /*TModelLinkSurrogate*/

    class TModelLinkSurrogate：public TAbstractModelLink

    {

          public：

          TModelLinkSu rrogate(const TModelLinkSurrogate&amp;)；

         TModelLinkSurrogate(const TAbstractModelLink&amp;)；

                                              TModelLinkSurrogate()；

              virtual                         TModelLinkSurrogate()；

          TModelLinkSurrogate&amp;operator＝(const TModelLinkSurrogate&amp;)；
				
				<dp n="d24"/>
    TModelLinkSurrogate&amp;           operator＝(const TAbstractModelLink&amp;)；

    virtual TStream&amp;operator＞＞＝(TStream&amp;towhere)const；

    virtual TStream&amp;operator＜＜＝(TStream&amp;fromwhere)；

    MCollectibleDeclarationsMacro(TModelLinkSurrogate)；

         //Check if surrogate is for valid link.

         virtual    Boolean IsValid()const；
         //Constants

         static const TModelLinkSurrogate&amp;           kInvalidLink；

         static const VersionInfo kOriginalVersion；    ..
  }；
  /*-*/
  /*TModelLink*/
  class TModelLink：public TAbstractModelLink
  {

        public：

                                                         TModelLink(const

    TModelAnchorSurrogate&amp;here，

                                                                    const

     TModelAnchorSurrogate&amp;there)；

                                                         TModelLink(const

    TModelLink&amp;)；

                                                         TModelLink()；

         virtual                                         ～TModelLink()；

                      TModelLink&amp;      operator＝(const TModelLink&amp;)；

         virtual TStream&amp;              operator＞＞＝(TStream&amp;towhere)
const；
         virtual TStream&amp;              operator＜＜＝(TStream &amp; fromwhere)；

         MCollectibleDeclarationsMacro(TModelLink)；

         //Link attributes

         virtual    void               AddAttribute(const

    TAttribute&amp;theAttribute)；
				
				<dp n="d25"/>
         virtual    void                      DeleteAttribute(const
TAttribute&amp;theName)；

         virtual    const TAttribute*  LookupAttribute(const TAttribute&amp;
theName)const；

         virtual    void                      DeleteAllAttributes()；

         virtual TIterator*            CreateAttributeIterator()const；

         virtual    Boolean                   IsBidirectional()const；

         virtual    void               SetBi directional(Boolean＝
TRUE)；

    private：

         TSimpleAttributeGroup*        fAttributes；

         Boolean                              fBidirectional；

         static const VersionInfo      kOriginalVersion；
}；
/*-*/
/*TModelAnchorCollection*/
//TModelAnchorCollection provides the abstract protocol for a collection of model
anchors.
//This protocol is used by TModel tomanage its list of anchors and links.This class
is
//abstract and may be subclassed to provide a specific implementation
TModelAnchorCollections
//own their anchors and are responsible all associated memorymanagement.  
class TModelAnchorCollection：public MCollectible
{

      public：

          /*…………………………………………………*/

          /*Constructors and Destructors*/

      TModelAnchorCollection()；

      TModelAnchorCollection(const TModelAnchorCollection&amp;)；
				
				<dp n="d26"/>
         virtual

    ～TModelAnchorCollection()；

                    TModelAnchorCollection&amp;    operator＝(const
TModelAnchorCollection&amp;)；    

         /*……………………………………………………………………*/

         /*Overrides*/

         virtual    TStream&amp;                   operator＞＞＝(TStream&amp;
towhere)const；

         virtual    TStream&amp;                   operator＜＜＝(TStream&amp;
fromwhere)；                                       ..

         VersionDeclarationsMacro(TModelAnchorCollection)；

         /*……………………………………………………………………………*/

         /*Collection methods*/
virtual void Adopt(TModelAnchor*anAnchor)＝0；
virtual TModelAnchor*Orphan(const MAbstractModelAnchor&amp;)＝0；
virtual TModelAnchor*Member(const MAbstractModelAnchor&amp;)

        const＝0；
virtual unsigned long  Count()const＝0；
virtual TIterator*CreateIterator(Boolean includeInvisibleAnchors，

        Boolean includeDynamicAnchors)const＝0；

        virtual     void AnchorsFixedUp()＝0；

        private：

              static const VersionInfokOriginalVersion；
}；
/*-*/
/*TModelAnchorSet*/
//TModelAnchorSet is a concrete subclass of TModelAnchorCollection that
implements the
//anchor collection using a TSet
class TModelAnchorSet：public TModelAnchorCollection
{

    public：  
				
				<dp n="d27"/>
/*…………………………………………………*/

       /*Constructors and Destructors*/

       TModelAnchorSet()；

       TModelAnchorSet(const TModelAnchorSet&amp;)；

            virtual                          ～TModelAnchorSet()；

       TModelAnchorSet&amp;operator＝(const TModelAnchorSet&amp;)；
/*…………………………………………………………………*/
           /*Overrides*/
       virtual    TStream&amp;operator＞＞＝(TStream&amp;towhere)const；
             virtual    TStream&amp;operator＜＜＝(TStream&amp;fromwhere)；

             MCollectibleDeclarationsMacro(TModelAnchorSet)；

             /*………………………………………………………*/

             /*Collection methods*/

    virtual void    Adopt(TModelAnchor*anAnchor)；

    virtual TModelAnchor*Orphan(const MAbstractModelAnchor&amp;)；

    virtual TModelAnchor*Member(const MAbstractModelAnchor&amp;)

       const；

         virtual unsigned long  Count()const；

         virtual TIterator*               CreateIterator(Boolean
includeInvisibleAnchors，

                     BooleanincludeDynamicAnchors)const；

         virtual           void AnchorsFixedUp()；

      private：

         TSet fAnchors；

         static const VersionInfo kOriginalVersion；
}；
/*-*/
/*TAnchorNotification*/
class TAnchorNotification：public TNotification
				
				<dp n="d28"/>
{

    public：

    TAnchorNotification(const TInterest&amp;theInterest，

                                                           const
MAbstractModelAnchor&amp;theAnchor)；

    TAnchorNotification(const TAnchorNotification&amp;)；

         virtual                                    ～TAnchorNotification()；

                    TAnchorNotification&amp;      operator＝(const
TAnchorNotification&amp;)；    

         virtual    TStream&amp;                  operator＞＞＝(TStream&amp;
towhere)const；

         virtual    TStream&amp;                  operator＜＜＝(TStream&amp;
towhere)；

         MCollectibleDeclarationsMacro(TAnchorNo tification)；

         virtual    const TModelAnchorSurrogate&amp;

    GetAnchorSurrogate()const；

    protected：

    TAnchorNotification()；

    private：

          TModelAnchorSurrogate fAnchor；

          static const VersionInfo kOrigina lVersion；
}；
/*-*/
/*TModelLinkNotification*/
class TModel LinkNotification：public TNotification
{

    public：

    TModelLinkNotification(const TInterest&amp;thelnterest，
				
				<dp n="d29"/>
    TAbstractModelLink&amp;theAnchor)；                                      const

        TModelLinkNotification(const TModelLinkNotification&amp;)；

            virtual TModelLinkNotification()；

            TModelLinkNotification&amp;      operator＝(const

        TModelLinkNotification&amp;)；

            virtual      TStream&amp;        operator＞＞＝(TStream&amp;

    towhere)cons t；

            virtual      TStream&amp;        operator＜＜＝(TStream&amp;

    towhere)；                             ..

            MCollectibleDeclarationsMacro(TModelLinkNotification)；

            virtual    const TModelLinkSurrogate&amp;

    GetModelLinkSurrogate()const；

    protected：

    TModelLinkNotification()；

    private：

    TModelLinkSurrogate fLink；

    static const VersionInfo kOriginalVersion；
  }；
  /*-*/

以上实施例只是根据本发明的一些示例，本技术领域内的一般技术人员可在本发明的范围内对其进行修改和变型。本发明受以下的权利要求保护。

Claims

1.一种用于文件合成的装置，其特征在于包括：

(a)一个处理器；

(b)与处理器相连的存储器；

(c)由处理器控制的显示；

(d)位于存储器中并由显示表示的文件；

(e)与一个第一选择关联的第一选择目标；

(f)与一个第二选择关联的第二选择目标；

(g)用于连接两个选择目标的装置；以及

(h)把一个命令加至第一选择目标并自动把该命令加至第二选择目标的装置。

2.权利要求1所述装置，还包括由一个围绕一个选择目标的几何结构表示该选择目标的装置。

3.权利要求1所述装置，还包括把信息推进第二选择目标的装置。

4.权利要求1所述装置，还包括使信息从第二选择目标出栈的装置。

5.权利要求1所述装置，还包括把一个询问加至第二选择目标的装置。

6.权利要求5所述装置，其中所述询问包括一个拼写检查操作。

7.权利要求5所述装置，其中所述询问包括一个选择最大值操作。

8.权利要求5所述装置，其中所述询问包括一个选择最小值操作。

9.用于在具有存储器和显示器的处理器上合成文件的方法，其特征在于包括以下步骤：

(a)将一个文件装入存储器并在显示器上表达该文件；

(b)生成一个与存储器中的第一选择关联的第一选择目标；

(c)生成一个与存储器中的第二选择关联的第二选择目标；

(d)连接第一和第二选择目标；以及

(e)将一个命令加至第一选择目标并自动地把该命令加至第二选择目标。

10.权利要求9所述方法，还包括由围绕一个选择目标的几何结构表示锚的步骤。

11.权利要求9所述方法，还包括把信息推入到第二选择目标的步骤。

12.权利要求9所述方法，还包括从第二选择目标出栈信息的步骤。

13.权利要求9所述方法，还包括把一个询问加至第二选择目标的步骤。

14.权利要求13所述方法，其中的询问是一个拼写检查操作。

15.权利要求13所述方法，其中所述询问是一个选择最大值操作。

16.权利要求13所述方法，其中所述询问是一个选择最小值操作。

17.一种文件合成装置，其特征在于包括：

(a)一个处理器；

(b)一个与处理器相连的存储器；

(c)一个由处理器控制的显示器；

(d)一个位于存储器中并由显示器表示的文件；

(e)一个与第一选择关联的选择目标；以及

(f)用于初始化一个命令并自动将该命令加至该选定目标的装置。

18.权利要求17所述装置，还包括由围绕选定目标的几何结构表示该选定目标的装置。

19.要权要求17所述装置，还包括与选定目标交换信息的装置。

20.权利要求17所述装置，还包括将询问加至选目标的装置。