CA2217342A1 - Hierarchical encapsulation of instantiated objects - Google Patents

Abstract

An application development system, optimized for authoring multimedia titles, enables users to create selectively reusable object containers by defining links among instantiated objects. The system utilizes hierarchical encapsulation to automatically isolate external dependencies of object containers created by its users, thereby facilitating reusability of object containers and the objects they contain in other container environments.
Authors create two basic types of objects: elements (108-111), which are the key actors within an application, and modifiers (114-117, 119, 122, 123) which modify an element (109-110) characteristics. The object containers (elements and behaviors (118, 120) - i.e., modifier containers) created by authors spawn hierarchies of objects, including the structural hierarchy of elements (111) within elements (108), and the behavioral hierarchy (118), within an element (110), of behaviors (and other modifiers (122, 123), within behaviors (120).
The system utilizes an element's dual hierarchies to make that element an environmental frame of reference to the objects it contains.

Description

W 096/31822 PCTlUb~G/0~96 "HIERARCHICAL ENCAPSULATION OF
INSTANTIATED OBJECTS".
., S I. BACKGRO~D.

A. Field of the Invention.

This invention relates to application development systems generally, and in 10 particular to systems for authoring interactive multimedia applications.

B. Des~ lion of the Related Art.

Since the advent of co~ uL~l~ many d~-c~ s ago, colll~u~er scientists have 15 labored to build increasingly powerful COlll~uL~l hardware that is faster andcheaper to build than its predecessors. Today's computers can perform, in one second, many millions of "add," "shift," "load," "store" and other relatively simple functions.

To perform tasks of any signifir~nt complexity, however, one must somehow cause computers to perform vast numbers of these simple functions in some sequence. ColnpuLel software, in its most basic form, comprises programs or sequences of instructions, each of which directs a COlll~u~t~l to perform thefunction corresponding to that instruction.
" 25 Yet, even as computers have become more powerful, developers of colll~uLel software continue to struggle to create complex programs without having to "reinvent the wheel" for each task they direct computers to perform. This need PCTrUS96104496 for "reusability" permeates virtually every aspect of software development, and is driven ultimately by the end user's desire for "ease of use."

1. Reu~abilitv and the Modular I~ race.

Although there are many varied approaches to this basic problem of reusability, one technique remains constant--"modular progr~mmin~," i.e., the "bo~ d~ing" of multiple simple functions into "modules" of greater and greater complexity that can be reused through higher-level "modular interfaces."
10 Virtually all software relies on modular progr~mming to some extent.

For example, assemblers and compilers enable programmers to bootstrap from the m~l~hinP language defined by a computer's instruction set to a higher-level, more human-readable language. Similarly, o~el~Ling systems 15 perform many of the low-level support tasks commonly needed by applications software developers (e.g., file system, memory management, basic GUI routines, etc.), and then provide developers with a library of "reusable" mo~lllles.

In essence, all application development systems provide to their users a 20 language, an application progr~mming interface ("API"), or some other form ofmodular interface designed to facilitate development of general purpose or highly specialized applications. Such modular interfaces provide reusability of tne "hidden" functionality which implement~ that interface.

2. Fnr~r~ulation and the Object Interface.

One of the most popular current trends cle~ignP~l to promote the creation of reusable software is in the field of object-oriented progr~mming ("OOP"). There are a variety of OOP languages and application development tools on the market 30 today (e.g., C++ and Kaleida Labs' "ScriptX~"), as well as a number of "pseudo-OOP" tools (e.g., "HyperCard~" from Apple Co,l,~uL~r and "Visual SUBS~ t~httl (RU1~26) W O 96/31822 PCTIU~ 96 BasicSM'' from Microsoft) which borrow some, but not all, of the basic principles of OOP.

OOP systems generally are intended to extend reusability to all portions of S a COIIl~U~el program, not just to particular modules. This is accomplished by distributing control of the various tasks performed by a program to individual "objects" with well-defined modular interfaces. These objects typically communicate by directly calling one another's capabilities or "methods."

OOP application development systems generally require their users to define abstract "classes" of objects that define the characteristics of the objects in that class. The actual objects in the user's application are inst~nri~te-l as needed at "runtime" from this class "template." Such systems also typically include certain built-in reusable class libraries to provide the user with an initial base of 15 functionality.

The inst~n~i~tP~ objects that perform the various tasks within the user's application are reusable in large part due to a process known as "encapsulation."
Encapsulation involves defining a class of objects with a well-defined external 20 interface, and "hiding" within the obiects the code and data nPcPcs~ry to implement that interface. In other words, the implementation of an object's interface is "encapsulated" entirely within the object.

Thus, programmers can reuse objects in various different contexts within 25 their application. All other objects that are aware of this interface can "reuse"
this object because its external dependencies are isolated within its modular "object i:nterface. "

Programmers also can use a process known as "inheritance" to "specialize"
30 or modularly extend an object's functionality by reusing some or all of that object's characteristics via its interface or class definition--i.e., the public UltS~ U~

W O96131822 PCTnUS96/04496 methods and data structures that define the template for in~t~nl~çs of that class.
For example, programmers may wish to extend the base functionality of an existing class (whether created by the programmer or provided in a reusable class library) by adding a new method to objects in that class, or replacing (i.e., 5 overriding) or supplementing (i.e., overloading) an existing method.

By defining a sub-class of objects that "inherit" the characteristics of the "parent" class, the programmer can reuse (as well as add to, replace or supplement) those inherited characteristics. For example, a "car" or "bus"
10 sub-class might inherit characteristics from a more general "vehicle" class. A car is a "kind of" vehicle, and may inherit, for example, a vehicle's color and speed properties, as well as steering and braking methods.

3. The Need for Selective Reusabilitv of "User Objects".
Despite their f~ciliti~s for reusability of objects, OOP application development systems remain difficult to use. It is far simpler for application developers to create and configure in~t~nti~t~l objects directly, as opposed to defining abstract classes each time they need to create a slightly different object or 20 to model the relationships or interaction among existing objects.

This problem is exacerbated when an application developer creates and desires to reuse compound or aggregate "user objects"--i.e., a group of objects that are related in the context of a particular application, but do not n~ces~rily 25 share common characteristics. These "user objects," in ~clrlition to requiring extensive inter-object commllni~tion, often involve "part of" or "container"
relationships that occur frequently in any modularly designed application.

Inheritance and encapsulation are well-suited to model "kind of" ,~
30 relationships to further specialize the atomic objects from which an application will SllB~ tSht~ (BUIE26~

W O96~31822 PCTrUS96/04496 be built. All modular systems require certain atomic "building blocks" which arereusable and provide sufficient performance, even if difficult to modify.

To create applications of any signifir~nt complexity, however, one must 5 combine these atomic objects into more complex "user objects" that interact with one another. It is this common modular process that illustrates the significant limit~tion.~ on reusability imposed by traditional OOP systems.

OOP systems allow developers to "reuse" an existing class of objects by:
10 (i) creating a class of objects that inherits from and "specializes" that existing class; (ii) creating a class of objects that encapsulates that existing class within its private (hidden) data structures and methods; or (iii) creating a distinct class of objects that commllnir~tes with (i.e., invokes methods of) that existing class of objects.
Yet, in all three cases, the new class of objects is tightly coupled to, and thus highly dependent upon, the exi.eting class of objects. Mere comml-nir~tion among otherwise unrelated objects provides virtually no reusability, and createsmany explicit dependencies. Although inheritance and encapsulation provide 20 reusability of objects at various levels of complexity, a class of objects at any given level of complexity remains highly dependent upon the particular characteristics it encapsulates or inherits from its less complex superclasses.

It therefore remains quite difficult, if not impossible, to "selectively reuse"
25 characteristics from (and interaction among) complex "user objects" in new ellvholllllents. One cannot, for example, easily "mix and match" object characteristics across class libraries and choose "some from column A and some from column B." At any given level of complexity, a developer cannot simply replace undesired characteristics of a complex object from one class library with 30 the more desirable characteristics of another complex object from a different class ul~s~Er RU~2fi) , W O96/31822 PCTrUS96/04496 library. Until such selective reusability is achieved, the ultimate promise of OOP
cannot be considered fulfilled.

a. An OOP Windowin~ Example.
s Consider the following example involving simple windowing functionality, a very common application for traditional OOP systems. ~m~ginr two independent developers ("A" and "B") creating windowing systems in a typical OOP
development el.vh o~ lent.
Developer A might create a "Window" class of window objects with a name ("Window X"), a particular size (specified by a bounding rectangle), a title bar (specified by another bounding rect~ngle), a color and a beveled border. Itsonly functionality might be to create, destroy and draw these window objects, via 15 three respective methods.

To enhance the functionality of these window objects in a modular manner, Developer A might create a "Minimi7e" subclass that inherits from the Window class and adds a "minimi7e" capability. When a user clicks on the small minimi7to 20 box in the upper right hand corner of the window, the minimi7e object transforms the window object into a small icon at the bottom of the screen,. When the user clicks on the icon, the window is restored.

This Minimi7e subclass would require "minimi7P" and "m~,~imi7ç"
25 methods to perform these functions, as well as a minimi7e box (specified by abounding rectange), a minimi71- flag (in-lir~fing the state of the window--i.e.,whether it is ~;ull~nLly minimi7lorl), and data for a minimi7P icon (pattern, size, position, etc.). In addition, the Minimi7e subclass would overioad the create, destroy and draw methods of the Window class--i.e., to create, destroy and 30 draw the minimi7e box and/or icon as well as the window.

S~l~mUlE Sl~Er (RUIE26) W O 96/31822 PCTnUS96/04496 Finally, Developer A might add additional "drag" functionality to these window objects, which would enable the user to drag the window by its title bar.This subclass could inherit all data and methods from the Minimi7e subclass (which itself inherits from the Window class), and simply add a "drag" method.
1~ 5 Developer B independently might take a similar approach. But, the class of Window objects created by Developer B (named Window X') might not include the beveled border. Moreover, Developer B might add a "window shade"
capability that differs slightly from the minimi7e capability created by Developer 10 A. When the user "double clicks" on the title bar of Window X', the Window might "roll up," showing only the title bar. Developer B might implement this capability bv creating a "Window Shade" subclass that inherits from (and overloads the methods of) the Window class, and adds a drag method to implement this "window shade" capability. That subclass might also include a 15 flag to track whether the window ~;ullell~ly is "pulled up."

Assume that Developers A and B di~l~ibu~e their respective object classes in class libraries cont~ining the public interface (i.e., the methods and data identified above), but not the private code and data that implements that interface.
20 Selective reusability would allow Developer "C" to reuse all or any modular portion of the functionality created by Developers A and B, without recompiling these classes or obtaining access to any such private code.

It is true that Developer C could reuse the Window class, the Minimi7e 25 subclass or the Drag subclass, thereby reusing functionality at various levels of abstraction. But, what if Developer C wanted to reuse the window and the drag capability created by Developer A, but integrate the window shade capability of Window X' in lieu of the minimi7e capability of Window X?

In short, Developer C cannot easily accomplish this task. The problem is that the private data and methods of the Minimi7e and Drag subclasses are tS~ Ul~ ~6) W O96131822 PCTrUS9"01196 dependent upon the public data and methods of the classes from which they inherit. The code might not even link.

The Drag subclass inherits from, and thus assumes the existence of, the 5 Minimi7:e class. The drag method might, for example, modify the bounding rectangle of a ~inimi7e object to "move" that object (as well as the rest of thewindow) across the screen as the user drags the window. This dependency effectively prevents Developer C from replacing the ~inimi71~ class with the Window Shade class. The drag method would attempt to modify data that no 10 longer exists.

Developer C would be forced to rewrite the Window Shade and Drag classes (potentially a .cignific~nt amount of code) merely to reuse the Window class. Reusability therefore is substantially impaired by the external (inter-class or 15 inter-object) dependencies of a subclass on its superclass. As noted above, encapsulating these dependencies or invoking other objects' methods within a class' private methods (as opposed to relying on inheritance) creates similar dependencies and perhaps even less reusability.

Any system of reasonable complexity will contain many levels of these external dependencies, making selective reusability of complex "user objects"
across class libraries extremely difficult, if not practically impossible. As discussed below, today's application development systems create similar externaldependencies that impair selective reusability.

4. The Lack of Sclc~liv~ Reusabilitv in Multimedia Authorin~ Svstems.

Consider, for example, the field of multimedia authoring systems to which an embodiment of the present invention is directed. Although there exist many such systems with almost as many different techniques, these systems all impose U~tS~EEr(lUJlE26) W O96/31822 PCTnUS96/04496 significant limitations on the author's ability to selectively reuse complex "user objects" across different e.,vi.oll...ents.

Certain systems, such as Macromedia's Director,~ employ traditional S metaphors with which authors are familiar and quite comfortable. Director employs a frame-based metaphor that requires authors t~ determine precisely which objects will be present in each frame of a sequence. This metaphor is famili~r to animators, and frequently is used for constructing sequential anim~tion sequences containing relatively little interactivity.
Constructing highly interactive applications, however, is quite difficult within the confines of a frame-based environment. Even with a scripting languageincluded to provide greater control over the sequence in which characters appear, interactivity frequently is limited to that provided by one or more scripts within a 15 frame.

It is quite difficult to reuse any of the characteristics of a particular object, because the object is highly dependent upon its environment (i.e., the scripts of other objects that "call" it, as well as the confines of the frames in which it 20 appears, relative to other objects). Extensive reliance on scripting to modelinteractivity makes it difficult to isolate an object's external dependencies within a single script, and virtually impossible to isolate such dependencies across multiple scripts.

Rigorous OOP tools (such as the ScriptX~ language from Kaleida Labs and the more visually oriented Questn' from Allen Commnnic~ti~ n) still require significant programming e~ lLise on the part of their users. Despite offering extensive libraries of reusable "high-level" objects, such products remain relatively low-level development tools--i.e., OOP programming languages (or perhaps visual programming languages), as opposed to authoring tools.

SUI~ u~ (R~IIE 26) CA 022l7342 l997-lO-03 W O 96/31822 PCTrUS9G/01196 As noted above, such tools impair selective reusability by creating external (inter-object) dependencies as a result of inheritance and encapsulation. Visualprogr~mming techniques facilitate the author's task of creating compIex applications, but still frequently require scripting and/or progr~mming to modify S an object's characteristics or to model inter-object commllnir-~tir~n~ The visual interface, at best, masks the progr"mming that controls the user's application beneath the surface. In any event, the external dependencies remain, and reusability is impaired.

Other systems employ "pseudo-OOP" techniques in an attempt to combine the power of reusable objects with the flexibility of customizing the characteristics of particular objects and modeling inter-object commllnir-~tirJn. Forms-based authoring ~7y.,~ s, such as Apple Computer's HyperCard~ and Microsoft's Visual BasicTU, provide autnors with ~ignifir~nt freedom to create and configure individual 15 objects using highly visual interfaces. Yet, such ~y~,Lt;llls still rely heavily on scripting to implement an object's functionality, as well as inter-object commllnic~tion and other forms of interaction.

Though these systems often contain many built-in types of objects, it is 20 extremely difficult to create new object types. An object's unique characteristics therefore are determined by its script. Recall~e objects communicate with one another directly via scripts, these scripts are highly dependent upon one another, and cannot easily be reused in other ellvhonlllents. Moving an object from one environment to another generally requires reading the scripts not only for t'nat25 object, but for other objects in its former environment.

One category of products (e.g., Apple Colll~u~l's Apple Media ToolTU) provides a highly visual approach to authoring with virtually no scripting or progr"mming involved. In other words, as opposed to visual progr~mming 30 languages (which, in essence, are merely "easy to use" scripting languages), such products provide true "object-based authoring"--i.e., the author creates and lUltS~ UlE26) W O96/31822 PCTnUS96/04496 configures actual inst~nti~te~ objects (or pseudo-objects) with little or no scripting or progr~mming.

One problem with such tools is that they are extremely limited and " S inflexible. Authors typically cannot create custom events or messages, much less add functionality to an existing object or group objects together in any mP~ningful way. Moreover, such ~7y~,~ellls provide no mech~ni~m for modeling modular "container" relationships among objects, and reusing these more complex "user objects" in different container environments.
All of the approaches noted above suffer from a lack of support for the creation of complex "user objects" that can be selectively reused in other environments. An object is only reusable to the extent t_at its dependencies on its external environment are isolated wit_in (i.e., known to) that object. An object is only selectively reusable to the extent that it is loosely coupled to the objects it contains, thereby permitting autnors to modify this relationship.

What is needed is a system that models this "container" relationship among objects in a manner that permits authors to selectively reuse object containers and the objects they contain across different container environments.

II. SUMMARY OF THE ~VENTION.

The present invention encolll~asses an application development system that enables its users to create reusable "object containers" merely by defining links among insf~nti~tecl objects. Employing a technique referred to herein as Hierarchical Encapsulation, the system autom~tir~lly isolates the external dependencies of the object containers created by its users. This isolation of external dependencies resolves the problems addressed above regarding selective SUBSI~l~lt SIIEF (RUl~26) W O 96/31822 PCTrUS96/04496 reusability of "user objects," thereby facilit~ting the development of applications of increasing complexity.

Objects contained within other objects are not "hidden" within or tightly S coupled to their object container environments. Rather, they are loosely coupled with those environments, and therefore can more easily be reused in other environments. By virtue of being contained within another object, the contained object autom~ti~-~lly is afforded access to its environment. Its object container is, in essence, an "e~ iLo"",ent~l frame of reference" for the objects it contains. For 10 example, unless overridden by the author, objects autom~tir~lly receive messages sent to their object container. They autom~tir~lly can access data known to their object container. Their position is even determined relative to their object container.

Moreover, objects are decoupled from their characteristics. By defining two distinct types of objects (one of which modifies the characteristics of the other), and loosely coupling (i.e., temporarily linking) these two types of objects, the system provides a mPrh~ni~m for authors to modify an object's characteristics merely by deeming one object to be contained within another. Removing that 20 object from its container removes that characteristic. In this manner, authors easily can modify an object's characteristics and reuse it in other environments.

In one embodiment described herein, the system is optimized for the development of interactive mllltimPrli~ applications or "titles." T'nis multimedia 25 authoring system provides its users ("authors") with a visual authoring interface that requires little, if any, scripting or progr~mming. The system employs a form of object-based authoring in which authors create and configure inst~nti~tP(l objects directly, typically by "dragging and dropping" icons and configuring dialog boxes.

Authors can create two basic types of objects: Elements and Modifiers.
F.lement~ represent the actual characters or actors that interact with one another in SU~ u~ Slttt~

W O96/31822 PCTrUS96/04496 the author's title. Elements generally can be linked to external media (such as text, sounds, pictures, ~nim~tinns and movies), and possess certain inherent characteristics relating to that media.

Authors can supplement an Element's inherent characteristics by incorporating Modifiers within that F.lement These Modifiers provide the F.lement with properties (known as Variables) that further define what the Element is and capabilities that further determine what the Element does. A special type of Modifier, known as a Behavior, can contain additional Behaviors and other Modifiers, providing the author with a me~h~nicm to create a complex Element "personality. "

Both Elements and Behaviors are "object containers"--in this embodiment, object instances that can "contain" (i.e., be linked to) other object in~t~nres.
Elements can contain Modifiers as well as other Elements; and Behaviors can contain Modifiers, including other Behaviors.

By inc.J.~ thlg Elements within Elements, authors create a Structural Hierarchy of Elements, each Element providing an environment~l "frame of reference" for the F.lement~ it contains. These "parent" Elements enable authorsto provide structure for their titles and to model relationships among their Elements.

Elements can commlmir~tto with one another at a high "Element level,"
without regard to their child Flement~. In one respect, Elements "en~ ulate"
their child Elements by creating a mo~llll~r interface through which an Element's child Elements can commnni~t~- with objects external to that Element container.

~ 30 Similarly, by incorporating Behaviors (and other Modifiers) within Behaviors, all inside an Element, authors create a Behavioral Hierarchy within the SUB~IIU~ SHE~ (RUIE 2~) W O 96/31822 PCTnUS96/04496 Element--i.e., the F.lement's internal "personality." Within the context of an Element "personality," each Behavior provides an environment~l "frame of erelellce" for the Modifiers it contains. These "parent" Behaviors enable authors to model the relationships among the various Behaviors within an Element's

5 overall personality.

Elements, in effect, "inherit" the characteristics provided by their internal Behavioral Hierarchy. Rec~n~e Elements and Modifiers are distinct, loosely coupled objects, authors can modify an Element's characteristics merely by adding 10 Modifiers to (or removing Modifiers from) an Element.

The system provides for significant reusability of object containers by lltili7ing the SLIù~;Luldl and Behavioral Hierarchies to isolate the external dependencies of FlemP.nt~ and Behaviors. In essence, the system du~o~ lly 15 "e..r~ tPs" an author's object containers. Once encapsulated, they can be reused in other "environments." Moreover, by loosely coupling an Flem~nt to the Modifiers it contains, the system enables authors to modify their Elements so as to "inherit" and "disinherit" chara;Leli~Lics while m~int~ining an evolving hierarchical encapsulation vis-a-vis the Element's external environment.
Using a technique known as Adoption, an author can cause an Element to be "adopted" by a new parent Element. Using a similar technique known as Transplantation, an author can "transplant" an Element's Behavior (or its entire"personality") into another F.lement Because Hierarchical Encapsulation is integrated into the Structural and Behavioral Hierarchies determined by the author's object containers, authors obtain the benefits of this technique aulo...~ ie~lly. Their Elements and Behaviors are thus selectively reusable.

-' SUB~ u~ Er(UUIE26) W O 96/31822 PCTnUS96/04496 For example, a mPch~nicm known as Hierarchical Message Bro~,clc~ctin~
provides a structured mecc~gin~ system that bro~rlc~ctc messages from their initial ~lestin~ti~n down the Structural and Behavioral Hierarchies to all descendant Elements and Modifiers. This meeh~nicm isolates an object container as a S centralized abstract ~lestin~tin for all messages intPn~lP.l for "any object within that object container." This mech~nicm facilitates reusability of object containers in other environments in that an object container's new "parent" Element will provide it with messages autom~tiez~lly.

Another mPeh~nicm, known as Hierarchical Variable Scoping, makes a Variable accessible autom~fir-~lly to all descendant objects of the Variable's parent Element or Behavior. This mech~nicm isolates an object container's dependencies on Variables that are external to that object container, but still within its ancestral "ellvho~ lent." By making such Variables "known" to those objects in the object 15 container that rely on that Variable, the object container can be moved to another environment with a well-defined external interface that "knows" which external Variables are assumed to be present in that environment.

Yet another mech~nicm, known as Hierarchical Relative Positioning, 20 determines the position of a child Element relative to the position of its parent Element. As a result, the child Element moves with its parent Element autom~tir~lly. This mech~nicm isolates an Flement's external positional dependencies--i.e., the effects of an Element's environment on the F.lement's position.
In addition to the "built-in" Elements and Modifiers, the system is quite extensible via a "Component API." This Component API enables programmers to se~mleccly integrate new Modifiers (and "Services" that support them) into the system.

SU~ u~t~h~l (RU1~26) PCTrUS96/04496 Finally, the archit~ctllre of the system is substantially platform-independent.
Titles can be "played" on multiple platforms. Moreover, the entire authoring environment can be ported to a variety of platforms with relatively little modification due to the isolation of a platform-dependent layer within the system.

m. BRIEF DESCRIPTION OF THE DRAW~GS.

Fig. 1 is an illustration of the dual hierarchy (Structural and Behavioral) 10 underlying the principles of the present invention.

Fig. 2 is a screen display showing the layout view window, tool palette, object information palette and menus of the graphical user interface of the implementation of one embodiment of the present invention.
Fig. 3 is screen display showing the layers view window of the graphical user interface under one embodiment of the invention.

Fig. 4 is a screen display showing the structure view window of the 20 graphical user interface under one embodiment of the invention.

Fig. 5 is a screen display showing the asset palette of the graphical user interface under one embodiment of the invention.

Fig. 6 is a screen display of showing a library window in the graphical user interface under one embodiment of the invention.

Fig. 7 is a screen display showing the alias palette of the graphical user interface under one embodiment of the invention.

SllBSIu~l~SNEl ~UIE26) CA 022l7342 l997-lO-03 W O96/31822 PCTrUS96/04496 Fig. 8 is a screen display showing the m~s~ging log window of the graphical user interface under one embodiment of the invention.

Figs. 9(a)-(d) are screen displays showing the mToon editor windows of 5 the graphical user interface under one embodiment of the invention.

Fig. 10 is a screen display showing the Element configuration dialog of the graphical user interface under one embodiment of the invention.

Fig. 11 is a screen display of a Behavior configuration dialog in the graphical user interface under one embodiment of the invention.

Figs. 12(a)-(h) are screen displays showing the Modifier configuration dialogs for Variables in the graphical user interface under one embodiment of the 15 invention.

Figs. 13(a)-(g) are screen displays showing the Modifier configuration dialogs for Messengers in the graphical user interface under one embodiment of the invention.
Figs. 14(a)-(c) are screen displays showing the Modifier configuration dialogs for Scene-based Modifiers in the graphical user interface under one embo-~imPnt of the invention.

Fig. 15 is a diagram showing the operation of the Scene change Modifier of Fig. 14(a) in conjunction with the return Scene Modifier of Fig. 14(b).

Figs. 16(a)-(d) are screen displays showing the Modifier configuration dialogs for Motion Modifiers in the graphical user interface under one embodiment of the invention.

5~ 1ultSHEEr~tULE26) W O96/31822 PCTrUS96/04496 Figs. 17(a)-(d) are screen displays showing the Modifier configuration dialogs for Graphics Modifiers in the graphical user interface under one embodiment of the invention.

Figs. 18(a)-(d) are screen displays showing the Modifier configuration dialogs for Sound Modifiers in the graphical user interface under one embodimentof the invention.

Fig. 19 is a screen display showing the Modifier configuration dialog for the style Modifier in the graphical user interface under one embodiment of the invention.

Fig. 20 is a screen display showing the Modifier configuration dialog for the cursor Modifier in the graphical user interface under one embodiment of the invention.

Fig. 21 is a screen display showing the Modifier configuration dialog for the set Miniscript Modifier in the graphical user interface under one embodimentof the invention.
Fig. 22 is a screen display showing the Modifier configuration dialog for the classification Modifier in the graphical user interface under one embodiment of the invention.
-Fig. 23 is a screen display showing the Modifier configuration dialog for the set value Modifier in the graphical user interface under one embodiment of the invention.

Fig. 24 is a high level block diagram of the implPm~nt~riQn of one embodiment of the present invention.

lllUltSHEr(~ E26) W O96/31822 PCTrUS96/04496 Fig. 2~; is a diagram showing the interconnection of the various classes in the object model of the present invention.
., Fig. 26 is a diagram showing the h.~el.:o~ Pction of the Service classes in 5 the object model of the present invention.

Fig. 27 is a diagram showing the storage layout for a multim.o~i~ title in one embodiment of the present invention.

Fig. 28 is a flowchart showing the event processing loop under on~
embodiment of the invention.

Fig. 29 is a diagram showing the architecture of both the Component API
and authoring GUI according to the present invention.
Fig. 30 is a diagram showing the operation of the object model of the present invention.

Fig. 31 is a flowchart showing the loading of Components (Modifiers, 20 Services) at boot-up time of the program under one embodiment of the invention.

Fig. 32 is a screen display showing an implement~ti- n of a snake.

Fig. 33 is a screen display showing an implementation of a school of fish.
Figs. 34(a)-(g) are screen displays of a selectively reusable windowing system.

Figs. 35(a)-(g) are diagrams showing the implement~tic-n of the selectively 30 reusable windowing system.

ul~S~ llUIF26) W O 96J31822 PCTrUS96/04496 ][V. DETAILED DESCRIPTIO~.

A. External A~ ...e--"Author's-Eve View".

Before discussing the underlying implement~tion of the authoring system of ~he present invention, it is helpful to eY~min~- its external architecture--i.e., that portion of the system which is visible to the author.

It is through this external archit~ctl~re that authors create end-user 10 applications or "titles." As is explained in greater detail below, programmers can extend the functionality of this external architecture, se~ml~sly, via an interface to the "core" of the system. Moreover, the platform-independent nature of the system's implem~nt~tion facilitates portability of the efforts of authors and programmers to a wide variety of co~ u~ g platforms.
1. Objects: h',le~n~nt~ and Modifiers.

In one embodiment of this invention, the author can create two basic types of objects: Elements and Modifiers. To use the metaphor of a stage play, the 20 Elements comprise the play's structure (e.g., acts and scenes) and its actors, and the Modifiers co~ fise the stage directions, the motivations the director imbues in the actors to behave the way they do, and other mo-lifir~tinns to the characteristics of the play's structure and its actors.

The system enables authors to create various types of Elements and to assign particular characteristics to each Element. These characteristics includeproperties (e.g., weight, color, etc.) that define what the Element is and capabilities (e.g., send messages, move along a path, etc.) that determine what the Element does.

S~IBSIIIUI~ ~HEr ~RUI~ 26~

W O96~31822 PCTrUS96/04496 Autnors assign characteristics to an Element by incorporating Modifiers within that Element. As is illustrated below, the process of creating and - configuring Elements and Modifiers is highly visual and intuitive, typically involving "dragging and dropping" icons representing Elements and Modifiers, 5 selecting menu items and configuring dialog boxes. Little, if any, scripting or progr~mming is required.

The system is, however, quite extensible via the "Component API,"
~liccllcce~ll in greater detail below. Programmers can use the Component API to 10 create "Components" that become fully integrated Modifiers and "Services"
(which "service" Modifiers but are not accessible directly to authors). Once created, Components are indistinguishable from the system's "built-in" Modifiersand Services.

In this embodiment, there are three general categories of Modifiers:
(i) Variables that simply store data of various types; (ii) Capabilities that perform actions on behalf of the Element; and (iii) Behaviors that "contain" additional Behaviors and other Modifiers. In another embodiment, a hybrid Variable/Capability Modifier could both store data and perform actions.
An autnor can create two general categories of Elements: (i) Structural Elements (including Projects. Sections and Subsections, discussed in greater detail below) that serve only to "contain" other Elements and Modifiers; and (ii) MediaElements (including Scenes, ~liccl~Cce~ below) that not only can contain other 25 Media Elements and Modifiers, but also can be "linked" to raw media, such as text, sounds, pictures, ~nim~tinns and movies.

- There are three basic types of Media Elements that an author can create:
(i) Graphic Elements (including still pictures, ~nim~tions and videos), Text 30 Elements and Sound Elements. An author can then link raw media of a particular SUBSIIlul~ SRElr ~RUI~2C) format to the Element, causing that Element to attain certain inherent capabilities (e.g., to make a sound, display a picture, or play a movie).

By linking raw media of a particular format to a Graphic, Text or Sound 5 Element, the author causes the system to "morph" the Element into a more specific type of Element (and among specific types) related to that format. For example, the author could create an "AIFF" sound, an "ASCII" sentenre, a "PICT" picture, a "QuickTime" movie or an "mToon" (a built-in ~nim~tinn format). The morphing process is described in greater detail below with respect to 10 the system's implemenL~lioll.

Elements of a given type also have certain built-in properties known as A~LLil)uLes. An Element's Attributes include properties applicable to the type of media to which the Element is linked (e.g., position, cel number, rate, etc.).
Thus, an Element's properties are defined by its AulibuLes and its author-created Variables. An Element's capabilities are determined by the type of media, if any, to which it is linked, and by its author-created Behaviors and Capabilities (i.e., its non-Variable Modifiers). Together, these ~lu~ Lies and 20 capabilities define an Element's individual characteristics--i.e., what the Element s and what the Element does.

In addition to creating Elements and ~signing them individual characteristics, an author can specify the manner in which these Flement~ interact 25 with one another, via an integrated object mes~,.ging mech~ni~m. This mes~,.ging mechanism is accessible to authors via Modifiers, as is described in greater detail below.

PCT~US96/04496 W O 96~31822 2. Object Conts~ rs: F,l~m~nt~ and Behaviors.

- Unlike simple "leaf" objects, Elements and Behaviors are "object containers" that can comprise a hierarchy of objects. These object hierarchies 5 provide "ellvir-~n,llents" (each enclosed by an object container) in which thesystem can isolate external dependencies. This isolation of an object container's external dependencies, referred to herein as "Hierarchical Encapsulation," results in a significant degree of reusability of the Elements and Behaviors created by an author.
As is illustrated below, authors can construct complex environments comprising a hierarchy of "FlemPnt~ within Elements" interacting with one another. Within an Element, authors can create e~ually complex internal ~llvho~llents (together reprPsenting the F.lemPnt's "personality") comprising a 15 hierarchy of interrelated "Behaviors and other Modifiers within Behaviors."

Authors can selectively reuse these modular Element and Behavior object containers at virtually any level of complexity. Moreover, authors can "mix and match" Flement~ and Modifiers from differing environments at practically any 20 level of the Structural and Behavioral Hierarchies. Furthermore, a team of authors can collaborate to create and test an entire application while individual authors refine their own modular, self-contained environments.

For example, multiple authors might collaborate to build a complex model 25 of a "car" Element that contains one "engine," four "wheel" and various otherElements, as well as a "driving" Behavior that contains "steering," "braking" and various other Behaviors. Individual authors each might create one or more of - these self-contained Elements and Behaviors, and then collaborate with one another to test all or a portion of the "car" and refine the desired interaction among the 30 various Elements and Behaviors.

SU~mUlESEE~ UIE26~

W O g6/31822 PCTnUS96/04496 Moreover, a subsequent author working on a different application could reuse the entire "car" Element or merely one or more of the Elements or Behaviors contained therein. For example, the author might apply the "braking"
Behavior to a "horse" or "airplane" Element in another application.

To create complex objects, authors need not create abstract "classes" or object templates that serve to relate objects to one another with respect to their characteristics. Elements, Behaviors and other Modifiers created by the author are object instances. To permit Elements and Behaviors to "contain" other objects, 10 the system links the Element and Behavior object instances to the other object instances contained within them (as is explained in greater detail below with respect to the system's implementation).

Thus, F.lementc and Behaviors are object containers--in this embo-limPnt, 15 object in~t~n~çs that can "contain" (i.e., be linked to) other object instances. To some extent, however, Elements do attain (at least temporarily) the characteristics they contain. Yet Elements merely provide an ellvironl.lental frame of referenceto their descendant Elements. Elements and Behaviors do not actually "inherit"
the characteristics of the objects they contain.
Many embo-limentc of this "object container" relationship among objects are possible, including intersecting families of objects, multiple-parent relationships and various combinations of "one-to-many" and "many-to-many"
child-parent relationships. In any event, by spawning object hierarchies, object25 containers provide the e~vi-o~ ents that facilitate their reusability via Hierarchical Encapsulation, discussed below.

Authors are thus free to create and work directly with objects that represent, at any level of complexity, the characters in their application and the 30 individual characteristics "contained within" those characters, as well as the ul~SHEE~!lUlE26) W O9~131822 PCT/u~Glo~96 all-encompassing "environmental factors" that "contain" those characters and determine the nature of their interaction.
.
3. Obiect Hi~ ies: Structural Hi~l~,clly and Behavioral Hiçrarchv.

When an Element contains another object within it, the Element object is called a parent and the other object is called its child. If the child object in turn contains another object, the child object is considered the parent of the object it 10 contains, and so on.

This chain of parents and children is called an Element or (Structural) Hierarchy. In one embofliment, each parent can have multiple children, but each child has exactly one parent. Flement.c above and below a particular Element in 15 the Structural Hierarchy can be referred to, respectively, as ance~lo,~ and ~iescen~l~ntc of that Element. Children of the same parent are called siblings.

Just as an Flement can contain other Elements in the Structural Hierarchy, each Element also contains its own Modifier or Behavioral Hierarchy of Behaviors20 and "leaf" Modifiers (i.e. the Element's personality). These Modifiers modify the characteristics of the Element (e.g., by storing data in the Element or performing actions on behalf of the F.lement), often in response to messages from other Modifiers inside the same or another Element.

In the context of the Structural Hierarchy, an Element can be viewed as an environment~l "frame of reference" for its descendant Elements. It is within that Element's ellvho~ lent that its descendant Elements exhibit their persnn~lities.The Structural Hierarchy determines the manner in which those descendant Elements interact with one another within that Element's ellvi,olllllent.

SUB~ ul~SEEr(!allE26) W O9~131822 PCTrUS96/04496 Similarly, the Behavioral Hierarchy determines the manner of interaction among an Element's internal Behaviors. In the context of the Element's overall personality, a Behavior also can be viewed as an environment~l "frame of reference" for its descendant Behaviors and other Modifiers.
Continlling our "car" example, the "car" FlemPnt provides the environment in which the "engine" Element functions. If the car moves, the engine will move with the car autom~tie~lly (as it would in a real car). Yet, the engine Element need not have any internal "movement" Behavior. By acting as 10 the local coordinate system for its child Elements, the car becomes the engine's ellvi,o~ ent~l frame of reference. This particular manner of isolating positional dependencies of Elements within the Structural Hierarchy, referred to as Hierarchical Relative Positioning, is ~liccllcce~l in greater detail below.

Similarly, the "driving" Behavior provides the ellvhonLuent in which the "braking" Behavior rullcLiolls. If the driver does not step on the brakes, the "braking" Behavior will not be invoked--i.e., it will not receive a "brake pedaldepressed" message from its parent "driving" Behavior. By acting as the "g~tekPerer" for messages intended for its child Behaviors, the parent "driving"20 Behavior becomes the "braking" Behavior's e.lvh~."...ent~l frame of reference.
This particular manner of isolating mesc~ging dependencies of Elements and Behaviors (and other Modifiers) within the Structural and Behavioral Hierarchies, referred to as Hierarchical Messa~e Broadcastin~ is ~1iccllcce-1 in greater detail below.
Contimling the example, the "driving" Behavior must monitor the car's speed for a variety of reasons, as must the driver of a real car (e.g., to know when to release the brake). The speed of the car could be stored in a "car speed"
Variable inside the Element, but not nPcess~rily inside the "driving" Behavior 30 because other Behaviors (e.g., an "Air Bag" Behavior detPcting massive deceleration) may need to access this Variable. By making its child Variables SUBSlt~ S&~c ~RUlE26) W O 96131822 PCTnUS96/04496 accessible to its descendants, the car becomes the frame of reference for the "driving" Behavior. This particular manner of isolating data dependencies of - Elements and Behaviors (and other Modifiers) within the Structural and Behavioral Hierarchies, referred to as Hierarchical Variable Scoping, also is discussed in 5 greater detail below.

a. Types of Elementc in the Structural Hierarchy.

As noted above, there exist two basic categories of Elements in this 10 embodiment--Structural Elements and Media Flementc.

Authors can utilize Structural Element to group the contentc of a title into org~ni7p~l sections, like the ch~tel~ of a book or the acts in a play. In this embo-lim~nt the purely Structural F.lemPntc coL~ ise Projects, Sections and 15 Sllbsections.

Media F.lçmPntc (including the Modifiers collt~inPc~ within them) comprise the p,i.llaly content of an author's application. They typically are the characters or actors within a "Scene" (a special Media Element the ~lhll~y purpose of which20 is structural--to contain other Media Elements). Any Media Element can be used structurally, as containers for other Media Elements, to form a more complex Flemrnt Media Elements as their name sn~f~estc, typically are linked to raw media, such as text, sounds, pictures, movies or ~nim~tions, in order to commlmir~tç with the user of the title.
(1) Projects.

- A Project is a Structural Element that contains the entire title. Its children are Sections, which are described below. A Project also can contain Modifiers 30 (including Behaviors) that store data or perform actions on behalf of the entire SUB~I~lU~t~P~ UllE 26) W O9~131822 PCTnUS96/0449G

Project. The score of a game, for example, could be stored in the Project so as to be available to all other Elements and Modifiers.

(2) Sections.
s A Section is a Structural Element that can be used by the author to organize logical portions of his title. It is most analogous to an act in a play or a chapter in a book. For example, an author of a U.S. travel game might create a Section for all Elements and Modifiers relating specifically to the state of 10 California. Sections are parents to Subsections, as described below. As with Projects, Sections also can contain Modifiers. A "time-in-state" Behavior might,for exarnple, track the amount of time the user spent in a particular state.

(3) Sllhsection~.
A Subsection is a Structural Element that can be used by the author to further organize logical portions of a Section. Contim~ing the above example, the author of the travel game might create a Subsection for all Elements and Modifiers relating specifically to the San Francisco Bay Area. Subsections are parents to 20 Scenes, and also can contain Modifiers.

(4) Scenes.

A Scene is a special Media Flement that not only further organizes logical 25 portions of a Subsection, but also contains other (non-Scene) Media Elements and Modifiers. Much like the scenes in a play, the Scene Element contains those Media Elements and Modifiers the author deems nPce,ss,.ry to impart to the user a portion of the interactive experience provided by the parent Subsection.
Conrinlling our travel game example, one Scene might take place on the Pacific 30 Coast, while another occurs further inland in the city of Palo Alto.

'rf' SUB~ ult SHEr (RUlE26) W O9~/31822 PCTrUS96/04496 In one embodiment, there exists a special type of Scene Element known as a Shared Scene. A Shared Scene is used to organize Elements that will be visible- across multiple Scenes, such as a background picture or an ~nim~t.-~ character that travels from Scene to Scene.
In a more refined embodiment, the author can share visible Elements across S~lbsectic ns and Sections by having multiple Shared Scenes, or being able to select one or more Shared Scenes dyn~mi~lly. In the latter case, rather than design~ting a Shared Scene statically at "authoring time," the author can, dyn~mie~lly at l0 "runtime," designate any Scene (or perhaps multiple Scenes) as a current Shared Scene.

(5) Media Elements.

Media Elements co,~ ise the p~i~aly characters or actors in a Scene.
They can contain other Elements (to form a more complex F.lement) and can be linked to raw media. A Media F.lement also can contain Modifiers, and thus Behaviors, which together constitute the Element's personality. As illustrated below, it is an Element's "dual hieldl.;hy" that provides the ellvi.onlnental framework in which descendant Elements interact with one another and exhibit their own individual "personality."

b. Isolation of External Dependencies of Object Containers.
Elements and Behaviors are object containers that spawn hierarchies of ~i~scen~nt objects. Consider the sample illustration of the Structural and ~ Behavioral Hierarchies in Fig. 1. When Media F.lementc are created, they are positioned autom~ti~lly below the Scene in the Project's Structural Hierarchy.
T~us, Element E1 108 is a child of Scene Sc1 106 in Subsection SS1 104 in Section S1 102 in Project P 101. Element E4 111 is a child of Element E1 108.

Ul~S~ RUlE26) W O96/31822 PCTrUS96/04496 By isolating the external depende~icies of the environment created by an Element or Behavior object container, the system provides for a signific~nt degree of selective reusability of that Element or Behavior (or any object contained therein) in other environments, as is further demo~ dLed below. It is this 5 isolation of an object container's external dependencies that allows the F.lement~
and Behaviors created by an author to become an "environment~l frame of reference" for their descendant Element~s, Behaviors and other Modifiers, as wasdemonstrated in the "car" example ~ cu~se~l above.

In one embodiment of this system, three mPch~ni~mc are employed to isolate external dependencies within object containers: (i) Hierarchical MessageBroadcasting--messages that are received by an Element or Behavior typically are "broadcast" down the Structural and Behavioral Hierarchies to its descendantElements and Modifiers (though this effect can be overridden); (ii) Hierarchical15 Variable Scoping--Variables are accessible to all descendant Elements and Modifiers of that Variable's parent Element or Behavior; and (iii) H~ierarchicalRelative Positioning--an Element's position in the Scene is determined relative to the position of (i.e., using the local coordinate system of) its parent Element, and therefore changes as the position of its parent Element ch~ngec.
(1) Hierarchical Message Broadcasting.

A message sent to an Element or Behavior typically will be broadcast down the Structural and Behavioral Hierarchies. Elements pass down messages to their 25 children, be they Modifiers or other Elements. Behavior pass down messages totheir child Modifiers. The precise manner in which the various types of messagespropagate down the Structural and Behavioral Hierarchies is discussed in greaterdetail below with respect to object m~c,s~ging generally.

In one embodiment, the order in which messages are broadcast among Elements, Behaviors and other Modifiers at any given level of the Structural and SU~ ~EEr (RD~E 26~

Behavioral Hierarchies is determined by the order in which those objects appear in the "structure view window" (see, e.g., structure view window 330 in Fig. 4).
- Initially, this is the order in which they are created. The author can modify this order simply by "dragging and dropping" or "cutting and pasting" the object's icon in the structure view window.

For example, referring again to Fig. 1, a message sent to Scene Sc1 106, under one embodiment, initially would be sent down to Element E1 108 (but not to any sibling Elements of Scene Sc1 106, such as Shared Scene ScO 107). It would then be sent down to Element E4 111, and then to Element E2 109. From there it would be sent down to Modifiers M1 114, M2 115 and M3 116, and then to Element E3 110. It would then be sent down to Modifier M4 117, Behavior B1 118 and then down to Modifier M5 119. Finally, it would be sent to Behavior B2 120 and then down to Modifiers M6 122 and M7 123.
Note that, in this embo-1imtqnt, Variables such as Variable V3 121 solely store data and thus do not respond to messages. Their data, however, can be readand written by other Modifiers, as for example, the Miniscript Modifier.

In this manner, a message sent to an Element or Behavior typically will be broadcast to all objects contained within that Element or Behavior. Upon receiving the message, those objects (Elements, Behaviors and other Modifiers) can then respond a~plc)L)liaLely, performing whatever actions are specified by their current configuration.
By providing for the sending of messages to an Element or Behavior object container, and the broadcasting of those messages to the objects within that container, the system facilitates the isolation of meS~EinE traffic to and from that container. In essence, the container becomes a higher-level abstract destination for messages intended not only for the container itself, but for "objects within thecontainer. "

S~BSS~llt S~ (RULE26~) W O~6/31822 PCTAUS96/04496 Contimlin~ the above example of the travel game, assume that Section S1 102 represents California, Section S2 103 represents Kansas and Subsection SS1 104 ,epresellL~. the San Francisco Bay Area. The author could create Behaviors to simulate the different weather patterns in these two states.
s A "Midwest Weather" Behavior in Section S2 103 could simulate the weather in Kansas and periodically update a "temperature" Variable and send a "check tel"pe,dLule" message to that Section S2 103, which would be broadcast down the Structural and Behavioral Hierarchies to all Elements and Modifiers in 10 each Scene in Kansas. This Behavior and the temperature Variable could both be contained at the Section S2 103 level of the Structural Hierarchy to simulate relatively constant weather throughout the state of Kansas.

Conversely, within California, Subsection SS1 104 (the San Francisco Bay 15 Area) could contain two Scenes, one le~rese~ lg the Pacific Coast and the other representing Palo Alto. These Scenes could contain "Coast Weather" and "Inland Weather" Behaviors, respectively, each updating their own "temperature" Variableand sending a "check te,ll~eldLule" message to their respective Scenes. These separate Behaviors could simulate the differing weather l alLtllls that occur even 20 within a relatively small region of California.

"People" Elements in the various Scenes within the two states might be very complex, perhaps cont~ining five or ten different Behaviors, including a Jogging, Swimming and a "Check Temperature" Behavior that check the 25 temperature in response to a "check temperature" message. If the temperature deviates too far from the average tellll eldlule, the Check Temperature Behaviormight send a "Very High Temperature" or "Very Low Temperature" message to its person Element, which will be broadcast down to the Swimming and Jogging Behaviors. The Swimming Behavior might be enabled by "Very High 30 Temperatures" and disabled by "Very Low Temperature" and vice-versa for the Jogging Behavior.

ult S~ RUIE26) W O96/31822 PCTrUS96/04496 By permitting the various "weather" Behaviors to broadcast their messages down the Structural and Behavioral Hierarchies (from the Section level in Kansas, - and from the Scene level in California), the people Elements in either state will receive this message from their respective parent Scenes. The "weather"
5 Behaviors need not target their message directly to a particular person Element, or even know which type of Element might respond to their "check temperature"
m~cc~ge (e.g., person, animal, etc.).

The people Elements, therefore, could be moved from any Scene in Kansas 10 to any other Scene in Kansas or California, and still respond appro~liately to the temperature in that region. Even though the "check temperature" message is sent to a different environment or level of the Structural Hiel~chy in Kansas (Section) than in California (Scene), it still reaches all relevant people Elements.

This degree of reusability of F.lement~ and Behaviors is facilitated by the system's Hierarchical Message Bro~-ic~cting mech~ni~m, which broadcasts messages sent to an object container to t'ne objects it contains. This me~h~nicmisolates the dependencies of a message at the abstract level of the environment represented by the object container to which that message is sent, as opposed to20 re4uiring the author to target the message directly to a particular "leaf" object.

As is discussed below, direct ~y,e~ g of messages remains an option in this embodiment in the event that the author elects to forego a degree of reusability in favor of explicit target naming.
(2) Hierarchical Variable Scoping.

As demonstrated above, Elements and Behaviors are dependent upon rnessages to enable, disable and trigger certain actions, including those of their 30 descendant Modifiers. Those Modifiers frequently are dependent upon Variablesto perform actions on behalf of their parent Elements. T~ol~ting Variable SHEE~ (RUIE 26~

W O96/31822 PCTrUS96/04496 dependencies within Elements and Behaviors also facilitates reusability of thoseobject containers.

The scope of Variables (data) accessible to a Modifier is another 5 manifestation of that Modifier's environment. Variables are ~ecç~ihle to all cen~nt objects of that Variable's parent Element or Behavior. In other words, Variables are ~c-ce~sible within their parent's environment.

Hierarchical Variable Scoping serves to isolate an object container's 10 dependencies on external Variables. By making Variables ~-~cessihle to descendant objects of the Variable's parent, those descendant objects autom~ti~lly "know about" those external Variables. A descendant Element or Behavior tnerefore becomes reusable in that the external Variables upon which it depends are isolated within ("known to") that F.lem~nt or Behavior.
Returning to our travel game example, the "temperature" Variable in Kansas is ~rceesihle to the "Check Temperature" Behavior within any person Element of any Scene in Kansas. Rec~ e the "temperature" Variable is located at tne Section S2 103 level, its descendant Elements include all Subsections tnerein, 20 each Scene contained within those Subsections, each Element in each such Scene (including any people Elements), and finally the "Check Temperature" Behavior contained within such people Elements.

Moreover, if a person Element was moved from a Scene in Kansas to the 25 Pacific Coast Scene in California, the "temperature" Variable in that Scene would be ~ccessihle, autom~tit~-~lly, to that person F.lement and to its "Check Temperature" Behavior. This degree of reusability is a direct result of t'ne Hierarchical Variable Scoping mech~nicm 30In the above example, this mech~nicm isolates "temperature" Variable dependencies at the Section level in Kansas and at the Scene level within the San h~l (RULE26) W O 96/31822 PCTnUS96104496 Francisco Bay Area in California. As noted above, the Hierarchical Message Broadcasting mech~niem also isolates mes~,.ging dependencies (in particular the - "check temperature" r~essage) at those same levels of the Structural Hierarchy.
Thus, in this example, these two meçh~ni~m~ together make object containers 5 below that level (such as the person Flement) reusable across Sections of a Project.

(3) Hierarchical Relative Positioning.

Another environmental dependency of object containers, in this case limited to Elements, is the position of an Element relative to that of its ancestors. Rather than require the author to model the common circumstance in which the movement of one Element must be relative to the movement of another Element, the system, by default, determines an Element's position in the Scene relative to the position 15 of (i.e., using the local coordinate system of) its parent Element.

In another embodiment, this effect could be made optional. In any event, a child Element can, as part of its own personality, move on its own initiative. Its position nevertheless remains relative to its parent Element. It tnerefore also will 20 continue to move as its parent Element moves.

Thus, a child Flement moves (changes position) within the Scene as its parent Element moves. This effect filters down the Structural Hierarchy below the Scene level. A common use of Hierarchical Relative Positioning is to model 25 Elements physically contained within or attached to other Elements (e.g., a toy in a box or the wings of a bird). It also can be used to model Elements that, for one reason or another, tend to follow other Elements (e.g., planets orbiting the sun, or packs of ~nim~l~ that tend to move together).

Hierarchical Relative Positioning also serves to isolate an Element's dependencies on its environment, in that an author need not model this "follow my SUB~I~lU~t ~ E26~

W O9~131822 PCTnUS96104496 parent" movement. Upon reusing or r~tt~rhing an Element to another parent Element, the system autom~tic~lly recalculates that Element's position relative to its new parent Element.

c. Selective Reusability throu~h Adoption and Transplantation.

The selective reusability of object containers ~ cllsse~ above frequently takes one of two forms. If Elements are to be reused, they often will be placed in a new environment--i.e., given a new parent Element in the Structural Hierarchy. This process is referred to as "Adoption." In other words, the child Element has been "adopted" by a new parent Element.

The underlying implem.ont~tinn of Adoption is discussed in greater detail below. From the author's perspective, Adoption is a simple process at authoring time. For example, lere~lh~g to Fig. 2, the author can break its current link and create a new link with the link tool 365 on the tool palette 36 with another Element in the layout view window 320. Alternatively, the author can drag and drop the Element's icon to the icon representing its new parent Element in the Structure Window 33.

Authors also may desire to move a Behavior or other Modifier from within its parent Element or Behavior to another parent Element or Behavior. This process is referred to as "Transplantation." In other words, a Behavior or otnerModifier, and its associated capabilities, are "transplanted" to a new Element or Behavior, which then acquires those capabilities. Transplantation also can be accomplished quite easily at authoring time, by dragging and dropping the icon representing the Behavior or Modifier from its old parent to its new parent, either in the Layout Window 320 or in the Structure Window 33.

gUBSïli~itS~
-PCTnUS96/04496 W 09~131822 Adoption and Transplantation are ~uite similar, both from the author's perspective and in view of the manner in which they are implemented, as is - discussed in greater detail below. Both involve the transfer of an Element or Modifier to a new parent F.lem--nt or Behavior. In other words, both involve the5 selective reusability of an Element or Modifier in new environments.

In a more refined embodiment, Adoption and/or Transplantation can be performed dyn~mir~lly, at runtime. One author might, for example, desire to model certain ~l~vila~ional forces that cause an Element "planet" orbiting another l0 Element "star" to begin to orbit a new parent Element "rogue star" that passes nearby. Another author might desire to model a change in a person's behavior, ineffect by transplanting a Behavior Modifier within the Element representing thatperson.

As is ~ c1-~serl in greater detail below with respect to the system's implem~ont~tinn, this process is ~uite similar whether performed at authoring time (referred to as "Edit Mode") or at runtime (referred to as "Runtime Mode").
Depending upon the nature of the Adoption or Transplantation the author desires (or perhaps desires to provide to the user), different functions can be ~ces~e(l via the Component API.

Similarly, a programmer can, via the Component API, provide dynamic (runtime) inst~nti~ti~-n of objects, such as Elements and Modifiers. This process, referred to as "Dynamic Creation." also is ~ cll~se~l below with respect to the system's implement~ti~ n.

4. Obiect Authorins~ Interface.

Figs. 2-9 show some of the features of the object authoring interface.
They include the layers view window 310 (Fig. 3), layout view window 320 (Fig.
2), structure view window 330 (Fig. 4), morlifier palettes 35a and 35b (Fig. 9), SUB~ t~ ULE26s _ PCTrUS96/04496 tool palette 36 (Fig. 2), object information palette 37 (Fig. 2), menus 38 (Fig. 2), asset palette 70 (Fig. 5), alias palette 80 (Fig. 7), mToon editor windows 900, 910, 920 and 930 (Fig. 9), and m.osc~ging log window 420 (Fig. 8).

With reference to Fig. 2, the tool palette 36 is provided with a variety of functions, inrlurling: (i) a pointer 361 for selecting, clicking, dragging, scrolling, etc.; (ii) a graphic tool 362 for creating Graphic Elements; (iii) a text placeholder tool 363 for creating Text Elements; (iv) a cropping tool 364 to crop and link non-~nim~t-o~l Graphic Elements; (v) a linking tool 365 for linking Elements into a parent/child relationship; (vi) a hand tool 366 to offset media within Elements, as well as (vii) a background/foreground color tool 367 for selecting the background and foreground colors of an Element.

The object information palette 37 displays an Element's position in x 328 and y 329 coordinates, size in x 336 and y 331 coordinates, scale in x 332 and y333 coordinates, and other data related to a selected Element, such as the Element's name 326, the name of its parent 327, its layer order number 335 and, in the case of an mToon, its cel number 334. In the "Hierarchical Relative Positioning" embodiment ~liccllcce-l herein, the position of the Element is given relative to its parent.

The menus 38 allow access to all other functions not accessible otherwise from the present on-screen r~a~ s. Menu 338a is the "Apple" menu under the Macintoshsu operating system with its well known features. The functions of the rem~ining menus are described below.

"File" menu 338b allows authors to create new Projects, libraries and mToons, to open existing Projects, to close windows, to save projects under the current or another name, to link Elements to media in a particular file or resources folder. Menu 338b further allows authors to break media links, to run a Project SUB~ SHEr(RUlE26) W O96/31822 PCTrUS96104496 from either the start or from a given selection, to build a title from the current Project, or to quit the application.

"Edit" menu 338d allows authors to perform the usual undo, cut, copy, 5 paste, clear, "select all" and duplicate functions, as well as create author messages and set application and Project preferences.

"Format" menu 338d allows authors to set font, font size, font style and text alignment characteristics for selected text.
"Arrange" menu 338e allows authors to align objects, to adjust their sizes, to move them completely forward or backward in the layer order, or incrementallyso, as well as to adjust for any gaps in layer order created by such operations.
"Object" menu 338f allows authors to create new Sections, Subsectionc, ~cenes, Graphic F.lem~nt.~, Sound Elements and Text Elements, to access the Element hlfu~ aLion dialog 950 (Fig. 10), to revert to the default size of an object, to lock an object's settings, to find items by name, as well as to make and break aliases.
"~iew" menu 338g allows authors to open the layout view window 320, the structure view window 330, the layer view window 310, the tool palette 36, the modifier palettes 35a and 35b, the alias palette 80, the asset palette 70, the object information palette 3~ and the m~s~ging log window 420. In addition, 25 authors can use menu 338g to preview the effects of selecting different colortables, to show or hide Element frames, Modifier icons, object names, low resolution (draft) object images, the Shared Scene, as well as to synchronize all windows to reflect information for the same object.

"Window" menu 338h allows authors to access all ~;u~lellLly open windows.

UItSHEEt(P~ 26~

W O96/31822 PCTrUS96/04496 a. Lavout View.

The layout view 32 is used to edit a Scene of a Project. Again with reference to Fig. 2, the basic operation of the layout view 32, through layout view window 320, is as follows. The layout view window 320 represents Projects at a Scene level, thus acting as a stage in which authors can arrange their Media Elements. To bring the appropriate Scene into the layout view window 320, pop-up menus 321, 322 and 323 are provided to navigate, respectively, among a Project's Sections, Subsections and Scenes. These pop-up menus 321, 322 and 323 also have "New Section", "New Subsection" and "New Scene" items, as an al~ alive to using Object menu 338f to create such Structural Elements. Back arrow 324a and forward arrow 324b are an alternate means of ~eC~C.~ing the previous and next Scenes within the current Subsection. Forward arrow 324b is ~limmecl to in~ t~. that the current Scene is the last Scene in the current Subsection. Shown within the content region of layout view window 320 is a Graphic F.leml-.nt 337 cont~inin~. Graphic Modifier 338.

b. Lavers View.

The layers view 31 is used to edit Projects a Section at a time through the layers view window 310. With reference to Fig. 3, the basic operation of the layers view window 310 is now described. The layers view window 310 presents a matrix of Media Elements, arranged by Scene order on the huli~olllal axis and layer order on the vertical. Layer order is the order in which F.lement.~ are drawn on the screen, me~ning that a Scene is layer order 0, and all the Scene's contained Elements progress in increments of 1 therefrom. Layer order is particularly useful to create the illusion that the two dimensional (X,Y) screen has a depth (Z) dimension, an effect referred to as "2.5D. " The layer order can easily be changed by dragging and dropping an Element over another Element, although this may also be accomplished through menus 38. Either way, the user performs such operations as bring to front (make layer order the highest), send to back (make SUB~ SHE~p~UlE2*

W O9~t31822 PCTIUS5G/~1196 layer order 1), bring forward (exeh~nge layer order with next highest) or bring backward (exchange layer order with next lowest). Scenes are ~ ne-l layer - order 0, which cannot be changed by the author, and are thus always in the background.

The layers view window 310 contains pop-up menus 311 and 312 that navigate among a Project's Section and Subsections, respectively, in a manner similar to the pop-up menus 321 and 322 of the layout view window 320.
Furthermore, back and rol~v~d arrows 313a and 313b act to select Subsections much as arrows 324a and 324b navigate through Scenes in the layout view window 320.

Thus, in this example, one can see columns arranged horizontally for Shared Scene 314a, Scene 1 314b, Scene 2 314c and Scene 3 314d. Vertically, one can see rows for layer order 0 (Scene) 318a, layer order 1 318b and layer order 2 318c. Along row 318a, one can see tne background pictures for the respective Scenes 315a, 315b, 31Sc and 315d, as well as four non-Scene Media Elements (Flement 316a and 316d under Scene 1 315b, Element 316b under Scene 2 315c, and Element 316c under Scene 3 315d). Modifiers are also shown witnin Elements (with Modifiers 317a, 317b and 317c in Shared Scene 314a, Modifiers 317d, 317e and 317f in Scene 3 315d, Modifier 317g in Scene 1 315b, Modifier 317h in Scene 2 315c, Modifiers 317i and 317j in Element 316a, and Modifier 317k in Element 316c).

Elements and Modifiers can be dragged and dropped within layers view window 310. In particular, an Element's layer order can be modified easily by dragging and dropping it onto an Element in another layer, causing all Elements to be "pushed up" one layer higher.

SUB~llllll~ S~tkl ~RU~

W O96/31~22 PCTrUS96104496 c. Structure View.

The structure view 33 allows authors to move Elements and Modifiers throughout the Structural and Behavioral Hierarchies -- i.e., across Projects, S Subsections and Scenes, as well as within Elements and Behaviors. Structure view 33 generates and controls the operation of structure view window 330, shown in Fig. 4. The Structural Hierarchy is plainly evident in that Project "Untitled-l"303 is at the top, with Section "untitled section" 304 immediately below and indented with respect to the Project 303 icon, Subsection "untitled subsection" 305 10 imm~i,.tely below and indented with respect to the section 304 icon, Scene "untitled Scene" 306 immediately below and inllent~rl with respect to the SubsectiQn 30S icon. In this instance the Scene 306 icon represents a Shared Scene, to which a Graphic Modifier 308 is attached. The Sl-hsectic n 305 has another child Scene 307, being the actual first Scene, which is represented as equally indented as its sibling Scene 306. Under this Scene 307 is Media Element300. Knobs 302a, 302b, 302c, 302d, 302e and 302f are used to reveal or conceal the objects beneath Elements 303, 304, 30S, 306, 307 and 309, respectively, in the Structural Hierarchy. This is particularly useful for an author who wishes to concentrate on only part of the Project at a given time.
Ch~nging the hierarchical relationship through the structure view window 330 is particularly simple. Elements may be dragged up and down and dropped into t_e Structural Hierarchy at will, subject to a few limitations. For example, a Media Element cannot be dropped directly into a Project, Section or Subsection.
25 Similarly, Scenes cannot be dropped into to a Section or Project. In addition, only Modifiers can be dropped into Behaviors.

d. Asset Palette.

The Asset Manager 7, operating through the Asset Palette 70, illustrated in Fig. 5, is a visual ~t~h~e of the media that have been linked to a Project. This S~ ul~ Sl~EEr (RVlE26) W O 96131822 PCTrUS96/04496 palette makes linking, storing, and copying Graphic and Sound Elements easy and convenient. Each item can then be dragged and dropped onto Scenes from this central location. Each time a new asset is added to the Project, it gets added to the Asset Manager 7, which adds it to the Asset Palette 70 in a manner that is transparent to the author.

Once an asset is in the Asset Palette 70, it can be used by multiple objects in the Project. For example, a single ~nim~tion file can be linked siml~lt~n~oously to multiple Elements. Each Element can use this ~nim~tinn without regard to the other Elements. Each entry in the Asset Palette 70 includes an associated count of the number of objects which use that asset. When an asset is no longer in use (i.e. its count becomes zero), it still remains in the Asset Palette 70.

Each time the author performs a link to media, an asset appears in the Asset Palette 70. "Show" pop-up menu 751 displays media files by selected types (e.g., all types, all graphics types, PICTs, mToons, sounds, QuickTimeTU movies,or color tables). "View" pop-up menu 752 displays assets either as icons or as small or large thumbnails. Trash can icon 7S3 allows authors to remove assets from the palette by dragging them to the trash can. There are multiple assets 754a, 754b, 754c, 754d shown here. For example, asset 754c is a sound, represented by a sound icon and having a preview button to allow the author to hear the sound.

e. Library.
Libraries offer a convenient place to store Elements and Modifiers for use across Projects. Authors can create multiple libraries, and can have more than one open at once. Authors can move Elements and Modifiers freely between any Project and any library. Any object, from a simple Modifier to an entire Scene, Subsection, Section, or Project (at any stage of development) can be dragged between libraries and Projects.

UltS~ UI~21i) W O96/31822 PCT~US96/04496 With reference to Fig. 6, the operation of a view 520 of one of the libraries 52 is shown. It includes the library's name 726, a close box 727, a trash can icon 728 which allows authors to remove items from the library by dragging them to the trash can, a "save" pop-up menu which allows authors to save the library to disk, and, as shown here, multiple objects 729a, 729b, 729c, 729d, 729e and 729f in the library.

f. Alias Palette.

An alias is a progr~mming tool that enables authors to m~int~in identical settings across multiple Modifiers. When a Modifier is "aliased" initially, a master copy is placed in the Alias Palette 80. Authors can create additional aliases that refer to that master copy merely by duplicating any aliased Modifier. The advantage of using aliases lies in the fact t_at they are globally updatable.
Ch~nging the settings of one ~instance" of an alias alters the settings of its master copy in the Alias Palette 80 and ;~ on.~l;c~11y updates the settings of each of the other instances of tnat alias throughout the Project.

Variables are good candidates for aliasing. For example, a game score can be stored and aliased. This Variable can then be strategically placed in Elements far apart in the Structural Hierarchy. Messengers and Miniscript Modifiers in these Elements can access and update their "local copy" of this Variable, which in turn will access the master copy, thereby ensuring synchroni7~tinn across all "local copies" of this Variable. In this manner, various Flementc, regardless of t_eir location in the Structural Hierarchy, will have access to the updated score as the value of this Variable changes during the game. Breaking an alias causes the formerly aliased Modifier to become an independent Modifier, no longer updated when its former aliases are mo-iifi.o~l With lc:re-~llce to Fig. 7, Alias Palette 80, controlled by Alias Manager 8, includes a close box 8S4, a trash can icon 8S1 which allows authors to remove ~S~ ult S~E~ (RUlE 26) W O9~/31822 PCTrUS96/04496 aliases from the palette by dragging them to the trash can, and, as shown here, multiple aliases 8S2a, 852b, 852c, 852d, 852e and 852f, with respective user - counts 853a, 853b, 853c, 853d, 853e and 8S3f. The user count reveals the number of instances of such alias within the current Project. Thus, if a new alias S is created, a new entry in the Alias Palette 80 is added. If a modifier is de-aliased or clelet~c~, the corresponding user count on the Alias Palette 80 is decrem~-ntf ~1 g. Mes~in~ Log.

~fç~ging Log 42 allows authors to "debug" their Projects by m~int~ining for authors a log of particular messages sent to selected objects during Runtimeexecution. It displays these me~c~ges in m~s~ging log window 420, as illustratedin Fig. 8.

The "Enable Logging" checkbox 424 displays the path of messages that have been passed to selected objects during a Runtime execution, such objects having been selected by the author through the structure view window 330. First,one sees a message 425 sent, ~eciryhlg the sender 423, the message type 422 and the recipient 421. What follows is the chain of messages that arise from message425. For example, message 426 caused, in particular, a chain to occur with received messages 427. Turn knobs 428a, 428b, 428c, 428d, 428e and 428f allow the cu~ olldirlg message lines to be revealed or hidden, thereby allowing the author to concellLIdle on the area of interest. More refined embodiments could easily include other standard debugging features, such as breakpoints, stepped execution and e~min~tin of selected data, as are well known in the art.

h. mToon Editor.
..
An mToon is a continuous series of images compiled by the system into a single file. Any ~nim~tion files created in a 3D program, or in a 2D ~nim~tion ;' SU~~ t SHEr (RU~E26) CA 022l7342 l997-lO-03 W O96/31822 PCTnUS96/04496 program which has been saved as or converted to PICT or PICS files, can be imported to the mToon Editor 53 and processed as an mToon.

mToons are cel-based and very flexible. In addition to being able to 5 specify the playback rate and duration of an mToon, a selected cel or range of cels in the mToon can be specified for playback. These ranges can be dyn,.mir~lly setduring Runtime, opening new creative possibilities to the multimedia author.

For example, the sitting, walking, and running motions of a rabbit can be 10 compiled into a single mToon linked to an Element. During Runtime, Mes~.engers or the Miniscript Modifier can be used to specify which cels of the animation toplay back according to predefined conditions. Thus, mToons abstract physical action with frame-by-frame control.

The system m~inf~in~ a link to the actual picture images that make up the individual frames of the mToon. Thus, if any of these images is updated, as verified by the system through the mo~ifi~tion date, the system asks the user whether the mToon should be recreated with the new images. This "hot link"
feature is ideal when additions or adjustments are made frequently to individual20 frames.

Authors can import single or multiple PICS or PICT files into the mToon Editor, and then edit, CO~ cSS and save them as an mToon. Authors also can open and edit ~-xi~ting mToons in this window. Moreover, authors can define 25 ranges of cels within each ~nim~tion and name them as a subset of the mToon. In the current embodiment, these cel ranges are a sequential range of integers;
however, there is nothing to preclude cel ranges from being completely discontiguous and in any order. Once defined, authors can access these ranges byname via Messengers or Miniscript Modifiers during Runtime.

SUI~ k S~ Ul~ 26S

CA 022l7342 l997-lO-03 W O 9~/31822 P~ll~'~CI04496 With reference to Figs. 9(a)-(d), the operation of mToon editor 53 is shown. In Fig. 9(a), mToon editor window 900 is shown, having a registration - point 901 which establishes the upper left corner of an inserted ~nim~tiQn cel, a cel number field 902 which shows the number of the current cel, and a selection S field 903 which displays the range of cels selected for editing. It has an mToon controller 904, which is used to preview the ~nim~tinn (which may assist the author in selecting a range of cels for editing), and has step buttons to step fol~d or backwards through the ~nim~tion, cel by cel. Finally "show" pop-up menu 90~ allows the author to select a specific range of cels, referenced by name to be played.

In Fig. 9(b), the mToon source file information dialog 910 is shown.
Thus, the file path 911 is displayed, along with the cel numbers 912, the original file names for the cel contents 913, the index number 914, if any, when the cel is a PICS file, and the file format 915 (e.g. PrCT, PICS).

In Fig. 9(c), the comyression settings dialog 920 is shown. The col,lplt;ssion type pop-up menu 921 specifies the colllylession method to be used (e.g., none, ~nim~tion, Cinepak, Graphics, Photo-JPEG, or Video). The color depth pop-up menu 922 sets the number of colors used by an mToon, which defaults to 256. A "random access" checkbox 923 provides authors with random access to individual cels despite colllylession. This is neceS~s~ry for an mToon to be played backwards or fclv~ds, cel by cel, or at a constant speed. The compression quality slider 926 controls the quality of the chosen colllyl~ssion method, with lower quality illlyalLing artifacts into the mToon.

In Fig. 9(d), the ranges dialog 930 is shown. It permits the naming of sequences of cels, so that they may be ~rcessed by name, as for example, by the Miniscript Modifier. The name field 931 shows the name ~,Si~nr~ to the range;
the start field 932 shows the cel number at the start of the range; the end field 933 SUI~ u~ SREE~ (RUL~26) W Og6/31822 ~CTrUS96/04496 shows the end; the delete button 934 allows a selected (hip~hlighted) range to be deleted; and the "new" button allows a new range to be created.

i. Modifier Palettes.
s With further reference to Fig. 2, modifier palettes 3~a and 35b are shown.
As ~i~ru~sed below, the system's extensible architecture enables programmers to create and insert additional Modifiers into the system, possibly n~ocescit~tin~
~rltiition~l modifier palettes. Each entry in a modifier palette allows an instance of a Modifier to be created and incorporated within (i.e., linked to the instance of a particular Element (Element, Scene, etc.) through a simple click, drag and drop procedure.

Modifier palettes 3Sa and 3~b include (as ~ cucse~l in greater detail below) icons for the behavior 340, the miniscript Modifier 1980, the MESSENGERS
[~basic) 1200, if me~.~enger 1220, timer 1240, border detection 1260, collision 1280, hypertext 1300 (at bottom right) and keyboard 1320]; the VARIABLES
[integer 1000, integer range 1020, vector 1040, boolean 1060, string 1080, flo~tin~ point 1100, point 1120 and time 1140]; the SCENE MODIFIERS [change Scene 1400, return 1420 and Scene transition 1440]; the MOTION MODIFIERS
[simple 1600, drag 1620, path 1640 and vector 1660]; the VISUAL MODIFIERS
[graphic 1700, color table 1720, gradient 1740 and image effect 1760]; the SOUND MODIFIERS [sound effect 1800 and audio fade 1820]; the style modifier 1900, and the cursor modifier 1920. The classification Modiher 1940 (Fig. 22) and set value Modifier 1960 (Fig. 23) are not shown.

j. Drag and Drop.

As will be discussed below, files cont~ining code for Components 30 (Modifiers and Services) may be added freely to the system by dragging and dropping them inside a special resource folder just as easily as inst,.nti~

u~tSh~ UIE26) PCTnU~9'r~ 96 Modifiers are dragged and dropped into Projects. As discussed herein, Elements and Modifiers may be freely dragged from window to window within a Project, or - into libraries or other Projects.
5. Obiect Me~
S
The object me~c~ing mech~nicm is integrated into the system so as to be accessible to authors via the configuration of Modifiers. Authors can use this m-~çh~nicm to specify the manner in which their Elements and Modifiers will comml]nir,~t-~ with one another.
As is ~liccll~ce-l in greater detail in the next section, authors can configure their Modifiers in Edit Mode to perform actions in response to messages receivedduring Runtime Mode. These messages are created and sent either by the system itself or by a special type of Modifier known as a "Mç~çnger" (i.e., any Modifier 15 capable of sending a mPcc~ge).

For example, during Edit Mode, an author could configure the simple Messenger Modifier 1200 depicted in Fig. 13(a) to respond to a "Mouse Up"
message 1203. This message typically would be sent by the system during 20 Runtime Mode when the user clicks on the Element com~ining this Messenger Modifier 1200. By configuring pop-up menu 1204 with a "Hide" message (a type of message known as a "Comm~n~," tliccuc~ed below), the author will cause Messenger Modifier 1200 to respond to the "Mouse Up" message during Runtime Mode by sending the "Hide" Comm~n~ to the Element, which in turn will cause 25 the F.lement to hide itself from view. Thus, when the user clicks on the Element during Runtime Mode, it will disappear.

a. Categories of Messages.

S~ U~tS~EEr(~LE2C) W O96131822 PCT~US96/04496 In one emborliment, there are three general categories of messages from which authors can select to configure their Modifiers: (i) "Author Messa~es:
(ii) "Environment Messa~es:" and (iii) "Comm~n~

Authors can configure their non-Variable Modifiers to respond to these messages by performing a particular action. Some Modifiers respond by triggering a single pelrullllance of an action (e.g., send a message), whereas others respond by enabling or disabling a continuous action (e.g., start or stopmotion). Numerous other variations are possible when creating a Modifier via theComponent API, as discussed in greater detail below with respect to the system'simplementation .

(1) Author Messages.

Author Messages are messages created by an author and sent from a Messenger for the purpose of enabling, disabling or triggering other Modifiers.
Authors can provide mnemonic names describing the purpose of a message, which typically is to notify other Modifiers tha~ a particular "event" has occurred or that a particular "action" is desired.
It should be noted that reusability is enh~nl~ed to the extent the author specifies general "events," as opposed to desired "actions," as this makes fewerassumptions regarding the destination Modifier. For example, a message indicating that a '~collision" occurred is more likely to be reusable than one requesting the destination Modifier to "beep." Some authors, however, may prefer more specific message names and be willing to sacrifice some degree of reusability.

As discussed below, Author Messages are (by default) "broadcast" from t_eir specified ~lestin~tiQn down the Structural and Behavioral Hierarchies. This Hierarchical Message Broadcasting mech~ni~m, as noted above, .ci~nifir~ntly S~Er (RIJL~26) PCTrUS96/04496 W O 9~/31822 enh~n~ec the reusability of Elements and Behaviors. This mech~ni~m is discussed in greater detail below.

Authors can create and name Author Messages either from a special r S Messenger pop-up menu (described below) or from a dialog box generated by a menu item selected in Edit Mode. ln either event, authors can provide mnemonic names describing the purpose of a message.

~n addition to using the dialog box to create and name Author Messages, 10 authors also can use this dialog box to create and name message "groups" and rearrange their Author Messages among these groups. By org~ni7ing Author Messages in this manner, authors can select an Author Message from an org~ni7Pclhierarchical list integrated into the Messenger pop-up menu. As a result, authors can limit their view to the particular Author Messages within any one group, 15 thereby simplifying the authoring process. Other embo~iimPnt~ include multiple levels of "sub-groups" and "one-to-many" and "many-to-many" relationships between Author Messages and groups/sub-groups.

(2) Environment Messages.
E~nvironment Messages are messages created and sent by the system to reflect ch~nges in the state of the runtime environment, whether due to user events (e.g., depressing the mouse or a key on the keyboard), application events (e.g., a Scene change) or other internal state changes detected by the system (e.g., the 25 "enabling" by the system of an object container). Upon detecting such an "environment event," the system sends an Environment Message to the plol)~iate Element in the Structural Hierarchy (e.g., "Mouse Up" to the Flement clicked on by the user, or "Project Started" to the Project upon activation of the Project during Runtime Mode).

tS~t~ (Rl~26) W O96131822 PCTrUS9''~1~96 That message is then broadcast ih a limited fashion solely to the Behaviors and other Modifiers within that destination Element. In other words, the messagedoes not "cascade" to any child Elements contained within that destination Element, as described in greater detail below. Thus, such mes~glo~ are broadcast5 down the Element's Behavioral Hierarchy, but not its Structural Hierarchy.

Authors also can configure a Messenger to send Environment Messages to any destination, even though the actual environment event represented by the Environment Message never occurred. In other words, the system provides 10 authors with a mech~ni~m to "fake" or simulate the occu~ ce of environment events.

For example, a "button" Element might contain a Modifier that emits a "click" sound when pressed (i.e., when the user releases the mouse button on that 15 Element and the system sends a "Mouse Up" Environment Message to that ~.lem,ont). The author might want to simulate a user's mouse click in another situation (e.g., in an ~nim~te-1 help screen showing the user how to activate that Element). By configuring a Messenger to send a "Mouse Up" Environment Message to the "button" Element at the desired time, the author can simulate that 20 environment event and cause the "button" Element to respond exactly as it would had the user released the mouse button on that Element.

By default, Ellvholllllent Messages sent by Messengers are (unlike those sent by the system) broadcast down the Structural as well as Behavioral 25 Hierarchies. Thus, they are sent to all Elements and Modifiers, if any, contained within a destination F.lement or Behavior.

As will be ~ cll~sed in greater detail below with respect to the system's implementation, many aspects of the Runtime e~lvilol~ ent are available during 30 Edit Mode. In this regard, the system sends certain Environment Messages (not"visible" to authors) during Edit Mode to enable authors to see the effects of SIIBSlllU~t SI~Er (RU1~26) W O96/31822 PCTrUS96104496 particular actions, such as setting the color and other graphic properties of anElement, without having to run their title.

(3) Comm~n~l~
s A Command is a special type of message that autom~t~ lly invokes one of an Element's inherent capabilities. ~f an Flement does not have that particular capability, or is not an a~l r~,l,riaLe state to respond, the Command is ignored.

Unlike a Modifier that can be configured to respond only to particular Author or Environment messages, Elements cannot be configured to elect whether to respond to a Comm~n-l They respond autom~tir~lly upon receiving a Comm~n~i For example, a QuickTimenf movie Flement inherently is capable of playing the QuickTime movie to which it is linked. Upon receiving a "Play"
Comm~n~l, the Element starts playing the movie. If, however, an author sends a "Play" Command to a Text Element, the Comm~n-l is ignored because Text Elements do not know how to "play" media. Similarly, a QuickTimeTM movie Element that already is in its "play" state (discussed below) will ignore a "Play"
Comm~n~l Comm~n-l~ are sent only by authors (via a Messenger pop-up menu, described below), and affect only Elements (i.e., they are ignored if sent to Modifiers). Unlike Author and Environment Messa~es, Comm~nrl~ are never broadcast. Once the destination Element responds to the Comm~n-l, the Command is "deactivated" and is not passed down the Structural or Behavioral Hierarchies.

However, certain Comm~n-l~ cause Elements to change "state," which in - 30 turn causes the system to generate and broadcast a related Ellvho~ ent Message.
For example, at any given time, an ~nim~tinn or movie Flemlo-nt may be in a Su~~ Ultsn~t~ (RUlE26~

W O96131822 PCT~US96/04496 particular state, such as "play," "stop," or "pause." A "Play" Command from a Messenger might cause an Element to transition from a "stop~ or "pause" state toa "play" state. If so, the system detects this state transition and sends a "Played"
Environment Message to the Element. That Environment Message sent by the S system is broadcast down only the Behavioral Hierarchy, to all Behaviors and other Modifiers contained witnin the Element.

In this embo~liment~ the author cannot "fake" Environment Mes,c~ges that are generated in response to an Element's state transition. Yet, given that the 10 author configured a Messenger to send the Command tnat caused the system to generate tnis Ellviromllent Message, the "event" (i.e., the Element's execution of the Command) actually occurred, and therefore need not be "faked."

~his state transition mech~ni~m is described in greater detail below with 15 respect to tne system's implem-ont~tinn b. Parts of a Messa~e.

As noted above, messages are sent only by the system and by Messenger 20 Modifiers. From the author's perspective, they are sent by "name" and can be received by any Modifier configured to respond to that name.

When configuring a Messenger to send a message, the author also specifies a destination for the message and (optionally) some data to be sent along with t'ne 25 message. In addition, t'ne author can alter a message's path after re~rhin~ its targeted destination (e.g., by restricting the broadcasting of an Author Message to the initial destin~ti~ n Element and its Modifiers).

These various parts of a message are described below in the context of the 30 Messenger pop-up menus that are available to all Messengers. The data structures SIIBSlllUlt SHEE~ (RULE26) PCTrUS96/04496 and other implementation details regarding these parts of a message are described in greater detail below with respect to the system's implementation.
-(1) Message Name.
S
All non-Variable Modifiers typically are enabled, disabled, and/or triggered in response to a message. They therefore typically include one or more "Messa~e" pop-up menus from which the author can select the name of the particular Author or Environment Message to which that Modifier will respond.
10 Message pop-up menus do not include Comm~ncl~ because, as noted above, only Elements respond to Comm~n~

As is discussed in greater detail below, certain Modifiers contain multiple Message pop-up menus (e.g., one to enable an action and another to disable tnat 15 action, or one to apply a particular effect and another to remove that effect). The programmer that creates the Modifier has, via the Component API, a wide range of "inherited" filnrtion~lity from which to choose (including as many inst~nti~tions of Message pop-up menus as is desired).

When configuring a Messenger Modifier to send a message, however, the author typically will select that message from a "Messa~e/Command" pop-up menu, which is similar to the Message pop-up menu, but also includes Comm~n~c (for sen~ing to an F.l~ment). Typically, Messengers contain only one Message/Command pop-up menu for sending a single message. If multiple 25 messages must be sent, the author simply can create a second Messenger that responds to the same message. In another embodiment, however, a programmer could create a Modifier capable of sen~ling multiple messages using the ~ Component API ~licc~ efl below.

The Message and Message/Comm~n~l pop-up menus are quite similar in nature, and therefore are ~ c~ e~l together witn rere~ ce to Table I. From SUBSl~lutt SHEr plUlE26~

W O96131822 PCTrUS96/04496 either menu, the author can select "None" (not shown) to in-li.~~t.o that no message is selected (to be sent or to invoke the Modifier). In addition, the author can create or select an Author Message from a hierarchical "Author Messages" menu item (also not shown) that lists all Author Messages used anywhere in the Project 5 (org~ni7~ by groups, as noted above). The system m~int~inc this list of AuthorMessages and makes it available to Modifiers dyn~mi-~lly so that their Message and Message/Command pop-up menus autom~tir~lly contain all Author Messages.

The rem~ining choices include Environment Messages (from either menu) 10 and Comm~n~lc (from the Message/Command pop-up menu only). As noted above, many Comm~n-lc will cause an Element to change state, resulting in the generation of an Environment Message being broadcast throughout the Flement The Message pop-up menu therefore includes these Environment Messages in place of the corresponding Comm~n-lc present in the Message/Command pop-up 15 menu. Comm~n-lc are italicized on the Message/Comm~n-l pop-up menu for easy id~ontifir~tion by the author.

For efficiency, the Environment Messages and Comm~n~c on both menus are illustrated together in Table I. The "Type" and "Message/Command"
20 columns represent the two-level hierarchical nature of these menus. Comm~n-l~are italicized in this table, as in the actual menus. Whenever the two menus differ, both the E~lvi~ulllllent Message (from the Message pop-up menu) and the corresponding Command (from the Message/Command pop-up menu) are shown with a "slash" between them. When the Message pop-up menu has no 25 Environment Message corresponding to the Command on the Message/Comm~n(l pop-up menu, the italicized Command is "greyed out" on the Message pop-up menu (not shown in this table) to in~ t.o that it cannot be selected by the author.

TABLE I. ENVIRONMENT MESSAGES AND COMMANDS

tsl~Er (R~;!6) W O96~31822 PCTnUS96/04i96 ~ Me~ Je/Cor~n7n"~ D~ .Lion - Mouse Mouse Down Ellvilo~ ent Message sent in Mouse Up response to a user's mouse actions.
Mouse Up Inside Mouse Up Outside Mouse Over Mouse Outside Mouse Tracking Tracked Mouse Outside Tracked Mouse Back Inside F.lern-o.nt Shown/Show Environment Message/Command Hidden/Hide used to in~ te that an Element has been (or "command" an Element to be) concealed or revealed Selected/Select Environment Message/Commana' Deselected/Deselect used to inllir,~te that an Element's Toggle Select "selected~ state has been (or "cc mm~nrl " an F.l~,mtonf's "sçl~ctç~l" state to be) set or reset.
Also Command to "toggle" that state Edit Element Command to Text Element to toggle Edit Done whether user allowed to enter or Update G7~ lat~ Fields edit its text, and related Environment Message to intlic~te that user's text editing is complete.
Also Command to update calculation of value of Variables inside text fields Scroll Up Command to move content of Scroll Down Element within its frame in a Scroll Left particular direction. An Integer ScroU Right Variable determines how far to move Element content (in pixels) Preload Element Used to preload media file into RAM for optimal playback (only for PICTs, mToons and AIFF sounds) ~ 57 UIt S~ UIE26) W O96/31822 PCTrUS9''~ 36 Tvpe M~.c~e/Comn?n~ Des.;. ;I,~ion Play Control Played/Play E~viro~ ent Message/Command Stopped/Stop used to inrlir.~tP. that a movie, ~nim~tion or Sound Element has been (or "command" such an Element to be) played once, leaving last cel on screen (except Sound), or stopped Play-Shown/Play-Show E~lv h o~ ent Message/Command Stop-Hidden/Stop-Hide used to in~lir~te that a hidden ~nim~tion or still graphic has been (or "command" such an F.lement to be) played once/shown, leaving last cel on screen (except Sound)~ or stopped/hidden Paused/Pause Environment Message/Command Unpaused/Unpause used to in-lic~tto. that a movie, Toggle Pazcse ~nim~tion or Sound Flement has been (or "comm~n-l" such an F.lem~.nt to be) paused or nnr?~ e~
Also Command to toggle the "paused" state of such an Element.
At First Cel/At First Cel Environment Message/Command At T ~.~t Cel/At Last Cel used to in-iir~tt- that an mToon ~nim~tion Element has reached (or "comm~n-l" such an Element to reach) its first or last cel S Play Forward Command used to cause movie or Play Backward 7,nim~tion Elements to play forwards or bac~w~ds Motion Motion Started En~ omllellL Message to intiir~t~.
Motion Ended that an Element's motion has started or ended Transition Transition Started Environment Message to inriir~t~.
Transition Ended that an Element's transition has started or ended Parent Parent Enabled Environment Message to in~lir.~te Parent Disabled that the Modifier's parent object container has been enabled or disabled Ult S~

W O9~/31822 ~CTfU~9~ 96 Type M~ ve/Comn7n~?~ Des~ ,L-on Scene Scene Started Environment Message to intii~te Scene Ended that a Scene has been startedt Scene Deactivated ended, deactivated or reactivated - Scene Reactivated Shar~d Scene Returned to Scene Ellvhu~ ent Message to indicate to Scene Changed a Shared Scene that control has Scene Time Expired returned to or changed from a No Next Scene Scene, or that time has expired No Previous Scene within a Scene, or that, with respect to the current Scene, there is no previous or next Scene Project Close Title Command to close a Project or Project Started standalone "title" (i.e., quit User Timeout Runtime Mode) and Environment Message to intlir~t~ that a Project has started or that the specified user timeout period has expired without the expected action by the user Get/Set Get/Set Height Command to read or write PICT
Attribute Get/Set Posihon ALL~ ult:S
Get/Set Width Get/ Set Layer Get/Set Text Command to read or write Text Get/Set Layer Element Attributes Get/Set Height Command to read or write mToon Get/Set Position ~nim~tion Element ALLli~uLes Get/Set Width Get/Set Layer Get/Set Cel Get/Set Range Get/Set Rate Get/Set Paused ; SUI~lllllltSIIEr(RUIE26) W O 96/31822 ~ X96/04496 Tvpe MP-~c~5~plco~?mn~~l Des~ Lion Get/Set Height Command to read or write Get/Set Position QuickTime~ movie FlemFent Get/Set Width ALLli~uL~s Get/Set Layer Get/Set Cel Get/Set Range Get/Set Rate Get/Set Paused Get/Set keyFrame Get/Set Volume Get/Set timeValue Get/Set Rate Command to read or write Sound Get/Set Volume F.lem~nt ALL1 ibuLes Get/Set masterVolume Command to read or write Project Get/Set User limeout Element ALLIibuLt;s Marks Frea~te Marks Command to execute a particular Begin Marks "markn chosen by the author, or End Marks begin or end execution of all "marks" within an AIFF-formatted soundtrack linked to a Sound F,lement s As is illustrated in Table I above, authors can configure their Modifiers to send or be invoked by a wide variety of Environment Messages and Comm~n~
(as well as create their own Author Me~g~c).

For example, in this embodiment, authors can select Ellvho~ lent Messages representing: (i) the state of users' mouse movements (e.g., "Mouse Up," "Mouse Down," ~Mouse Tracking," etc.); (ii) the state of a Media F.lemf~nt's "playing" of media (e.g., "Shown," "Hidden," "Paused,~ "Stopped,"
etc.) or its motion in the Scene (e.g., "Motion Started" or "Motion Ended"); (iii) 15 the state of Structural Elements such as a Scene (e.g., "Scene Changedn) or the entire Project (e.g., "Project Started~); and even (iv) the state of an Modifier's Parent object container (e.g., "Parent Enabled" or "Parent Disabled").

SU8Sr~ E SHEET (RULE 26) W O 96/31822 PCTnUS96/04496 A wide variety of Comm~n-1c also is made available to enable authors to access the inherent ALLLil)uL~s and capabilities of their Elements, including:
(i) causing a Media Element to change its state of "playing" its media (e.g., "Show," "Hide," "Pause," "Stop," etc.); (ii) causing a Text Element to toggle its 5 "editable" state (e.g., "Edit F.l~ment") or update calculatior.s on Variables contained in its text field (e.g., "Update Calculated Fields"); (iii) causing a Sound Element to sync to "marked" locations within its lin'Ked soundtrack (e.g., "Execute Marks"); (iv) causing an Element to preload its linked sound or ~nim~tion for optimal playback (e.g., "Preload Element"); and (v) causing an 10 Element to read or write its various A~L il,u~es (e.g., "Get Cel" of an ~nim~tion or movie, "Set Position" of any Graphic Element, "Get Master Volume" of the Project, etc.).

As is a~l,~en~ from the above discussion, another emborliment of this 15 system could make virtually any internal state tr~n~ition or event known to the system available to authors as an Environment Message, as well as any additionalComm~n~lc to which Elements are capable of responding.

(2) Message De~LillaLion.
When configuring a Messenger to send a message, authors must specify a "destination" Element or Modifier to which that message will be sent initially. As noted above (and ~liccncced in greater detail below with respect to the message path), the message may propagate further and be "broadcast" down the Structural 25 and/or Behavioral Hierarchies.

In any event, authors specify their desired message destin~ti~n by configuring their Messenger's Destination" pop-up menu, illustrated below in Table II. Using a mech~nicm referred to as "Relative Targeting," an author can 30 specify a "relative" destination in the Structural and Behavioral Hierarchies--e.g., any object container cont~ining that Messenger, including "Project,"

S~ulult Sn~tl (RUlE2~) c "Section," "Subsection," "Scene," "Element's Parent" and "Messenger's Parent."
This mech~ni~m provides the author with a significant degree of reusability of that Messenger.

For example, by specifying "Parent" as the destination for a message sent by a Messenger, the author can use that Messenger inside a different object cont~in.-r (i.e., another Element or Behavior) without moflific~tion. It will always send that message to its "Parent" object container.

Authors also can specify the "Next Element" and "Previous Element,"
which are siblings of the Element cont~ining the Messenger. This too is a form of Relative Targeting, in that the destination Flement is not determined precisely at authoring time. Instead, it is determined at Runtime relative to the Messenger'sposition in the Structural and Behavioral Hierarchies.
Authors also can specify certain destinations known to the system during Runtime Mode, such as the "Active Scene," the "Shared Scene," and the "Sender's Parent." These too are a form of Relative Targeting, in that these destinations are determined based upon the state of the runtime environment.
An author also may employ "Direct Tar~eting" to select, as a message destination, particular Flement~ or Modifiers made available to the author basedupon the system's knowledge of the Structural and Behavioral Hierarchies (e.g., "Messenger's Siblings" or "Element's Siblings"). In this case, however, the author selects the actual name of a particular Element or Modifier, and thus targets that Element or Modifier directly. During Runtime Mode, the message will be sent to that particular F.lement or Modifier (provided that the system can still locate that Element or Modifier).

Both the Direct Targeting mech~nicm (in which the system resolves the destination name into an "ID" during Edit Mode) and the Relative Targeting SUBS~ tS~ IllE2~) W O96/31822 PCT~US96/04496 mech~ni~m (in which the system resolves the destination "name" dyn~mic~lly at Runtime) are described in greater detail below with respect to the system's implementation.

TABLE II. MESSAGE DESTINATIONS
De~ on C~
Project Message sent initially to Project Element cont~ining Messenger Section Message sent initially to Section Element cont~ining Messenger Snhse~ n Message sent initially to Subsection Element cont~ining Messenger Scene Message sent initially to Scene Element cont~ining Messenger F.l~m~n~'s Parent Message sent initially to Parent of Messenger's "Parent Element"
Me~ c~ 's Parent Message sent initially to Messenger's Parent object container (F.lement or Behavior) Next F,lPmPn~ Message sent initially to F.lement "next in line" (in the Structural Hierarchy) after Messenger's "Parent ~lem~.nt"
Previous Fl~-n~nt Message sent initially to Element "previously in line" (in the Structural Hierarchy) before Messenger's "Parent Element"
Active Scene Message sent initially to Active Scene (visible to user at time message is sent) Shared Scene Message sent initially to Shared Scene (visible to user at time message is sent) Source's Parent Message sent initially to Parent object container of the "source~ Messenger (i.e., the Messenger that sent the message which invoked the Messenger sending this message) M~ .-r. s .~ihlinf~c Message sent initially to actual Modifier selected by (D~CT TARGETING) n~me from submenu (cont~ining Messenger's siblings) SU~~ 5~~ E26) W O9~/31822 PCTrUS96/04496 D~ ;on CommPntc F~ nt's Siblings Message sent initially to actual Element selected by (DIRECT TARGET~G) name from submenu (cont~ining siblings of Messenger's "Parent Element") rd~ b Message sent initially to Element or Behavior (DIRECT TARGETING) selected by name from submenu (cont~ining Messenger's ances (3) Message Data.

In ~ lition to speci~ying the message name and destination in the Messenger's dialog box, authors also can conhgure Messengers to include certain 10 data with their message. Authors specify such data using the "With" pop-up menu, discussed below.

Authors can avoid this option entirely by selecting "None" from the With pop-up menu. Authors also can select "Enter Value" which generates a dialog 15 box cont~ining a field into which authors can enter any desired value. By selectin~ "Incoming Value," this Messenger will "pass on" to the destination thedata received with the message that invoked this Messenger. The system determines the value of such data dyn~mir~lly during Runtime Mode.

Finally, authors can select any Variable shown on the With pop-up menu.
All Variables within the Messenger's "scope" are included. As rli~cu~e~l above with respect to Hierarchical Variable Scoping, a Variable is accessible to all descendants of its parent object container. Thus, the Messenger can access any Variable whose parent object container also contains that Messenger.
(4) Message Path.

As noted above, Author Messages and Environment Messages sent by Messengers will, by default, be "broadcast" to all objects, if any, contained within SU~ ul~S~ E26) W O9~/31822 PCTrUS96/04496 that destination Element or Modifier (i.e., they will propagate from the destination down both the Structural and Behavioral Hierarchies). The only exception is a "switchable" Behavior which, when switched off, prevents further broadcasting ofa message to its child objects. As a general rule, E~lvho~ ent Messages sent by 5 the system will be broadcast solely to Behaviors and other Modifiers within the destin~tion Element. Certain Environment Messages, however (e.g., "Scene Started" and "Parent Enabled") are of sufficient interest to most Flem~ntc to merit being broadcast down from the Scene. Comm~n~c, on the other hand, are sent initially to an Flement (or else ignored) and will propagate no further. Authors10 can modify the default message path of the messages they send via Messengers, as rli.cc~-.c.ced below.

(a) Broadcasting of Messages.

Hierarchical Message Bro~dr~etin~, as ~licc~lceed above, involves the traversal of the Structural and Behavioral Hierarchies in an order determined bythe order of the objects as represented in the Structure View Window (see, e.g.,Structure View Window 330 in Fig. 2), initially determined by the order in whichsuch objects were created. Authors can modify this order by "dragging and 20 dropping" icons within the Structure View Window 330.

For example, the message is broadcast first down the Behavioral Hierarchy of the Element or Behavior object container--i.e., to all child Behaviors and other Modifiers of that Element or Behavior. By default, it is sent from Modifier 25 to Modifier within the Behavioral Hierarchy. At any given level, the order is determined, as noted above, by the order in the Structure Window. Upon re~rhing a Behavior, it is sent down to the child Behaviors and other Modifiers contained within that Behavior. Upon re~rhing a non-Behavior Modifier, it is sent to a sibling Behavior or other Modifier (if any), and so on. Even if a particular 30 Modifier responds to the message, the message is "relayed" to the next Modifier t~P~RIHE26) W O~6/31822 PCTrUS96/04496 in the Behavioral Hierarchy until all Modifiers within the original Flement or Behavior object container have received the message.

Of course, if the original destination was a non-Behavior Modifier, no 5 further propagation of the message would occur. Yet, if the original destination was an Element, the message would, by default, "cascade" down the Structural Hierarchy to the child Elements contained within that Element. The message would be sent down the Behavioral Hierarchy of each such child Element as discussed above, and then propagate to the next child Element until all Elements10 (and objects contained within them) within the original F.lemenr object cortainer have received the message.

Thus, as noted above, Author and Environment Messages sent by Messengers are, by default, broadcast down both the Structural and Behavioral 15 Hierarchies. Authors may, however, configure a Messenger to limit or optimizethis default path to avoid llnneceec~ry (and perhaps undesired) message traffic or otherwise minimi7e potential p~-r~ ance bottlenecks.

(b) Tmme~i~te.
As is ~iiccucsetl in greater detail below with respect to the system's implementation, messages are delivered to Flementc and Modifiers in "threads" ofexecution during Runtime Mode. Despite the message ~icp~tching efficiencies thatresult from routing messages along the Structural and Behavioral Hierarchies, an25 author can impact system performance in certain situations, for example, by broadcasting a message to a large number of Elements and Modifiers.

In this regard, authors are provided with an option to configure a Messenger to postpone the default "imme~ fe" processing of the message sent by 30 that Messenger until after the current "chain of activities" has concluded. In other words, rather than process this message "imm~ tely" as it is encountered, the SUBSll~Ult SHEEI (RUl~ 26) CA 022l7342 l997-lO-03 W O96/31822 PCTrUS96/04496 system can complete its more time-critical tasks and wait until an "idle" cycle to process this message.

(c) ~cc~
~j Another mrch~nicm provided to the author to optimize performance is the option to configure a Messenger to limit the default bro~lr~cting of a message sent to an Element object container to the Behavioral Hierarchy within that destination F.lement In other words, the message will not "c~cc~-le" to child Elements within 10 the ~iestin~tion Element. It will be processed in a manner similar to that of El~vhonlllent Messages sent by the system. This feature will be illustrated in the snake example discussed below.

(d) Relay.

A final mechanism provided to the author to optimize pelrc,llllance is the option to configure a Messenger to limit the default broadcasting of a message to the first Modifier that is configured to respond to that message. In other words, once a Modifier responds to the message, the message will not be "relayed" to 20 another Modifier and will not "c~cc~le" to another Element. It will just stop.

6. Object G--~r~ul~lion.

a. - Elements.

Each Element is a state m~rhinr, and in the current embodiment, has six states: (i) initial (construction); (ii) begin play; (iii) play; (iv) end play;
(v) duration (what to do after play); and (vi) last (destruction). Not all these states have any particular m~nin~ when connected with various media. For example, 30 for a PICT, there really only is the play state. End play might signify releasing a cached bitmap.

SU~ o~ P~e (~ULE26) The author configures a Media Element through the Element configuration dialog 950 as shown in Fig. 10. Dialog 950 includes the Element tltle 951 and Element type icon 952 (showing that the Element is either an llnlink~d Graphic Element or linked to a PICT, mToon, QuickTime~ movie, Text Element, or 5 Sound Element in AIFF or snd format), and source file path 953. There are a variety of check boxes to configure the initial state. Thus, "Hidden" checkbox 954 determines whether the Element is initially hidden at Runtime, "Paused"
checkbox 955 determines whether movies, mToons and sounds are initially paused. "Loop" checkbox 959 determines whether an mToon will continue 10 replaying. "Back and Forth" checkbox 960 determines whether the mToon is played backwards after being played r~lw~ds (before possibly repeating itself inaccordance with "Loop" checkbox 959). "Mute" checkbox 964 determines whether a sound is initially muted. Also data entry area 963 allows one to override a sound file's original volume.
Other options are configured through the "Play Every Frame" checkbox 956 (which overrides QuickTime's feature of dropping frames to ensure sound synchronization), the "Cache Bitmap" checkbox 9~7 (which converts the E;lement'sscreen display format to a bitmap, obviating the need to perform the complex 20 instructions which created such display) and the "Direct to Screen" checkbox 958 which overrides layer order and draws the Element on top of all others. Finally,the data entry area 962 allows the mToon rate to be adjusted and the data entry area 961 allows the layer order number to be adjusted.

lUlt ~;EEr ~RUlE 26) W O 96/31822 PCTrUS96/04496 b. Modifiers.

The p~ ~y means for "modifying" an Element's inherent characteristics is provided by Modifier configuration dialogs. As was discussed above, little or noS scripting or progr~mming is required; rather, it is a visually-driven authoring environment.

Each of the Modifiers has its own configuration dialog. The types of data present in such dialogs reflect the in~l,llation required to properly configure the 10 modifier. Thus, it is useful to understand how to "program" the Modifiers --Behaviors, Variables and Capabilities.

(1) Behavior.

lS The Behavior, by cont~ining additional Behaviors and other Modifiers, acts as the structural backbone of the Behavioral Hierarchy. As such, the Behavior view 34 produces, with reference to Fig. 11, a dialog box 340 to configure and display various data items thereof. The Behavior dialog box 340 includes a name field 343, a modifier icon 344, an "enable when" pop-up menu 345 for specifying 20 an enabling message, and a "disable when" pop-up menu 346 for specifying a disabling message. Also included are a "clean up" button 341, a switch check box342, a set of message lines 347a, 347b, 347c, 347d, as well as a set of contained Modifiers 348a, 348b, 348c, 348d, 348e. The switch check box 342 is used to allow an author to enable and disable the Behavior via the enable and disable pop-up menus 345 and 346.

The enabling and disabling messages thus specify an operational "window"for the Behavior. The name field 343 can represent, as a mnemorlic aid, the Behavior's conceptual function (e.g., "steering" Behavior). The Modifier icon 344 30 represents the Modifier type (in this case, Behavior). Each of the contained Modifiers 348a, 348b, 348c, 348d, 348e are l~l~sen~t;d by their name, icon and ~U~IIlu~ SDEr (RUIE 26) PCTnUS96/04496 W 09~6/31822 ordinal number (the number in parentheses), which is the order in which each of the Modifiers is executerl within the Behavior. By default, these ordinal numbers are the creation order of the contained Modifier, but can be overriddèn by a special pop-up menu (not shown). These Modifiers may be rearranged around the S dialog box 340 by clicking and dragging. The "clean up" button 341 serves to autom~tic~lly rearrange the contained Modifiers according to their mess~ging order. The message lines 347a, 3471b, 347c and 347d ~ csent the messages to and from the contained Modifiers 348a, 348b, 348c, 348d, 348e.

Thus, for example, Modifier 348d is enabled by the mouse tracking message 347a, represented by the vertical arrow pointing to the Modifier, and sends an update Element message 347d, represented by the vertical arrow pointingto the message line. In the embodiment discussed here, a purple arrow is used torepresent a message em~n~ting from a contained Modifier, a green arrow is used 15 to l~lesen~ a message received by a contained Modifier that exec~lte~, applies or enables t'nat Modifier, and a red arrow is used to represent a mPs,s~e received by a contained Modifier that termin~tPs, removes or disables that Modifier. Thus, in this example, one can see that m~ssenger modifiers 348c and 348d are each responsible for creating the "Update Flemtont" message 347d, which serves to 20 enable Miniscript Modifier "C~zllculz~t~- Element Specs" 348e.

(2) Variables.

Variable Modifiers store values, such as numbers and strings. These 25 values can be configured to act as variables (changeable values) or constants(non-changeable values). These values may be referenced by Messengers and sent with messages. In addition, authors can write scripts using the Miniscript Modifier to reference and modify these values as well as include them with messages.

SUB~ t Shttl (RWE 2C) W O96~31822 PCTnUS96/04~96 The location of a Variable within the Structural and Behavioral Hierarchies determines its scope; that is the group of objects which can access that Variable.
Put simply, a Variable is accessible to all descendants of its parent. For example, a Variable placed on a Section is available to any Modifier on the Section, and all 5 other descendants of that Section.

A Variable whose parent is the Project is called a global. Global Variables can be ~c~oc~ecl by any ~ iate Modifier in the entire Project. A "special-purpose" scope may be created through ~ ing, as was discussed above.
Variables are either simple or compound. Simple Variables store a single value, whereas compound Variables store at least two values. For example, an integer Variable stores a single integer, so it is a simple Variable. On the other hand, a point Variable stores two values (the x and y coordinates), so it is a 15 compound Variable.

With reference to Figs. 12(a)-(h), the dialog boxes for the various Variable Modifiers (integer 1000, integer range 1020, vector 1040, boolean 1060, string 1080, floating point 1100, point 1120 and time 1140) each respectively includes a title 1001, 1021, 1041, 1061, 1081, 1101, 1121, 1141; icon 1002, 1022, 1042, 1062, 1082, 1102, 1122, 1142; "Cancel" button 1004, 1024, 1044, 1064, 1084, 1104, 1124, 1144; and "OK" button 100S, 1025, 1045, 1065, 1085, 1105, 1125, 1145. The "Cancel" button is used to discard any editing changes, while the "OK" button commits such changes to memory.
(a) Integer.

An Integer Variable is used to store an integer value (e.g., 7). Integer Variables range in value from -32767 to 32767. In Fig. 12(a), one can see a data30 entry area 1003 comprising an entry position for an integer.

SUB~'lnultsREl ~UIE26) PCTrUS96/04496 (b) Integer Range.

An Integer Range Variable is used to store an integer range value (e.g., 4...8). In Fig. 12(b), one can see a data entry area 1023 comprising an entry 5 position for two integers, the starting integer of the range and the ending integer of the range.

(c) Vector.

A Vector Variable is used to store vector values in degrees (angle) and inches per second (m~nitu(~e). In Fig. 12(c), one can see a data entry area 1043co~ lising an entry position for an angle, and one for a m~gnit~lcie.

(d) Boolean.
A Boolean Variable stores a true/false value: In Fig. 12(d), one can see a data entry area 1063 comprising two radio buttons, one for true and one for false.

(e) String.
A String Variable stores a string (e.g., "Bob Brown"). In Fig. 12(e), one can see a data entry area 1083 comprising an entry position for a string of up to 255 characters.

(f~ Floating Point.

A Floating Point Variable stores a flo~ting point value (e.g., 3.14159). In Fig. 12(f~, one can see a data entry area 1103 comprising an entry position for a floating point number.

SU~IIIu~ tlt~ (RUIE26) PCTrUS96/04496 W 096~31822 (g) Point.

- A Point Variable stores point values (e.g., (25,45)). In Fig. 12(g), one can see a data entry area 1123 comprising an entry position for two integers, the x-S coordinate of the point and the y-coordinate of the point.

(h) Time.

A Time Variable stores time in the format:
"minllt.os:seconds.milliceconds." In Fig. 12(h) one can see a data entry area 1083 comprising an entry position for the time in such format.

(3) Capabilities.

As noted above, Capabilities are modifiers that perform actions on behalf of the Element. In the current embo~iiment, that would include Messengers and Effects, as well as three singletons: the Miniscript Modifier, the Classification Modifier and the Set Value Modifier.

(a) Messengers.

Messengers are used to send messages and (optionally) accompanying data to Elements and Modifiers. They can be enabled, disabled and triggered upon receipt of messages as can all other non-Variable Modifiers. Although each has unique functionality, there are some similarities among them worth noting.

Witn reference to Figs. 13(a)-(g), one notes that the dialog boxes for the various Messengers [(basic) 1200, if messenger 1220, timer 1240, border detection 1260, collision 1280, hypertext 1300 and keyboard 1320] each respectively has a title 1201, 1221, 1241, 1261, 1281, 1301 and 1321, an icon 1202, 1222, 1242, 1262, 1282, 1302 and 1322, a "Cancel" button 1207, 1228, 1250, 1273, 1296, SHEErtRUlE26) PCTrUS96/04496 1312 and 1331, and an "OK" button 1208, 1229, 1251, 1274, 1297, 1313 and 1332.

As Messengers, each respectively has a mess~ping block co~ ,ising (i) a S Message/Command pop-up menu 1204, 122S, 1247, 1268, 1288, 1306 and 132S, (ii) a With pop-up menu 1206, 1226, 1249, 1275, 1289, 1307 and 1327, and (iii) a Destination pop-up menu 1205, 1227, 1248, 1269, 1292, 1308 and 1326.
Furthermore, each has mecc~ging checkboxes for (i) imme~i~te messages 1209, 1230, 1252, 1270, 1298, 1309 and 1328, (ii) ç~c~-le~i messages 1210, 1231, 12S3, 1271, 1299, 1310 and 1330, and (iii) relayed messages 1211, 1232, 1254, 1272, 1279, 1311 and 1331.

It is critical that a Messenger specify the type and destination for its message. Thus, the Destin~tinn pop-up menu permits the author to ~lesi~n~t~
targets in accordance with the range of Flement~ specified irl Table I above. The Message/Command pop-up menu allows the user to specify the type of message to be tr~ncmitte~ The With pop-up menu permits various types of data to be attached to the message. The mess~ging option check boxes allow the message to be configured, respectively, for imm~ te tr~ncmi~sion, c~cc~-ling or relaying, as discussed above.

Most MPscengers have an "enable when" pop-up menu and a "disable when" pop-up menu, which together specify a window of events in between which the Messenger is active (and conditionally sends messages). Other Messengers have an "execute when" pop-up menu which is configured to "fire and forget,"
i.e., conditionally send the message once upon receiving the triggering event.

i) Basic Messenger.

The Basic Messenger 1200, illustrated in Fig. 13(a), simply sends a message with optional author-supplied data when a particular message is detected.

tSREl ~UIE26) W O 96/31822 PCTnUS96/04496 ii) If Messenger.

If Messenger 1220, illustrated in Fig. 13(b), allows conditional sending of messages using Boolean logic. In addition to the "execute when" pop-up menu S 1223, a data entry area 1224 allows the author to impose a condition which must be met for the message to be sent (using the same syntax as is used by the Miniscript Modifier discussed below).

iii) Timer Messenger.
The Timer Messenger 1240, illustrated in Fig. 13(c), waits an author-specified period of time before sending a message. One can see "execute when"
1243 and "terminate when" 1244 pop-up menus, a data entry area 1245 for expressing a countdown time in the format of "minllt~ seconds.milliceconds,"
with a loop timer checkbox 1246 to send the timed message repe~terlly.

iv) Boundary Detection Messenger.

The Boundary Detection Messenger 1260, illustrated in Fig. 13(d), detects collisions with enclosures. One can see "enable when" 1263 and "disable when"
1264 pop-up menus, and three radio buttons to specify the detection conditions for collisions with the Element's parent's borders: (i) on first detection only 126S, (ii) while continll~lly detected 1266, and (iii) while exiting enclosure only 1267.

v) Collision Messenger.

The Collision Messenger 1280, illustrated in Fig. 13(e), detects collisions with Elements. One can see "enable when" 1283 and "disable when" 1284 pop-up menus. The "collide with" pop-up menu 128'. can be used to designate Elements 30 that can be collided with, e.g., Elements which are "solid." This can be specified using the Classification Modifier, described below. The detect "in front" and S~ tSHEE~(RUL~26) W O96/31822 PCTrUS96104496 "behind" check boxes 1286 and 1287 can be used to filter out Elements from different layers. The detect buttons 1293, 1294, and 1295 can be used, respectively, to configure m~ ing only upon first contact of the Elements;
co~ lly while two Elements are in contact; or when the two Elements cease S being in contact with each other. Collisions suggest a special target for a message, apart from the normal range of targets provided through destination pop-up menu 1292 discussed above, namely the actual Elements collided with. This is made available through the "Collision Elements" destination button 1290, which allows the author to toggle between the normal mode of m~.~s~in~ to a specified 10 destination, and this special mode of targeting only collided Elements. The first Element collided with may be specified exclusively through the use of the "FirstElement Only" checkbox 1291.

vi) Hypertext Messenger.
Hy~lL~l Messenger 1300, illustrated in Fig. 13(f~, links the se.n-ling of a message with a user's mouse actions. When a Hypertext Messenger is dropped into a Text Element, any hypertext label that has been assigned to text within the Element appears on the "On" pop-up menu 1303. The Messenger will thus trigger 20 upon receipt of the specified message, in~lir~ting a user's mouse action on such "hot" text. Furthermore, through the highliEht effect pop-up menu 1304, the following effects to the "hot" text may be applied: none, underline, invert, high1ipht~ tone up, tone down or squiggly underline. This effect may be sustained through application of the "Remain highli~hte(l" checkbox 1305.~5 vii) Keyboard Messenger.

Keyboard Messenger 1320 detects and responds to keyboard events.
Instead of being triggered upon receipt of a message (as are most non-Variable 30 Modifiers), it is triggered by author-specified (via controls 1323) user key or key combinations, including the control, comm~n-l option and shift keys. The key b~ RIIIE26) PCTrUS96/04496 state of the trigger may be specified through radio buttons 1324 as down, up or repeating.

(b) Effects.
In general, Modifiers grouped under the category of Effects modify the visible characteristics of their parent Elements.

With reference to Figs. 14(a)-(c), 16(a)-(d), 17(a)-(d), 18(a)-(b), 19 and 20, the categories of effects include: the Scene Modifiers (change Scene 1400, return 1420 and Scene transition 1440); the Motion Modifiers (simple 1600, drag 1620, path 1640 and vector 1660); the Visual Modifiers (graphic 1700, color table 1720, gradient 1740 and image effect 1760); the Sound Modifiers (sound effect 1800 and audio fade 1820); the style Modifier 1900, and the cursor modifier 1920.
These Modifiers respectively have a title 1401, 1421, 1441, 1601, 1621, 1641, 1661, 1701, 1721, 1741, 1761, 1801, 1821, 1901 and 1921 and an icon 1402, 1422, 1442, 1602, 1622, 1642, 1662, 1702, 1722, 1742, 1762, 1802, 1822, 1902 and 1922. All but the path Modifier 1640 and Graphic Modifier 1700 have, respect*ely, a "Cancel" button 1409, 1424, 1449, 1609, 1628, 1666, 1726, 1747, 1769, 1807, 1827, 1911 and 1926 and an "OK" button 1410, 142S, 1450, 1610, 1629, 1667, 1727, 1748, 1770, 1808, 1828, 1912 and 1927.

i) Scene.

With reference to Fig. 14(a), the Change Scene Modifier 1400 is used to change the currently visible Scene during Runtime (the "Active Scene") from one Scene to another. It is executed when the message specified in pop-up menu 1403 is received. Radio buttons 1404 designate that the Active Scene should be switched to: (i) the next Scene in the Subsection, (ii) the previous Scene in the Subsection, or (iii) a particular Scene. When the last radio button of 1404 has been selecte~l, pop-up menus 140S allow the particular Section, Subsection and SllBSlllul~S0EEI ~WE~6) W O g6/31822 PCTnUS96104496 Scene to be specified. Checkbox 1406 allows tne Active Scene to be mixed in with the destination Scene, through pop-up menus 1405. Checkbox 1407 adds this Scene to the "return list" of a future Scene with a return Modifier, as discussed below. Checkbox 1408 ~iesign~tes that switching to a previous or next Scene will5 wrap around, if nPcçss~,y, through the Scenes of the Subsection.

With reference to Fig. 14(b), the Return Modifier 1420 works in association with a Change Scene Modifier with its "add to return list" option selected. The Return Modifier returns to the Scene which has been added to the 10 return list when the message specified in pop-up menu 1423 is received.

The operation of the "Return list" using Scene change and return Modifiers is illustrated in Fig. 15. Therein, Scene A 1500, Scene B 1510, Scene C 1520, Scene D lS30 and Scene E 1540 each includes, respectively, Scene Chaflge Modifiers 1505, 1515, 1525, 1535 and Return Modifier 1545. Scene Change Modifier 1515 on Scene B 1510 has its "Add to return list" checkbox 1407 set.
Thus, when Return Modifier 1545 is ~ c~,lte~l, the Active Scene changes from Scene E lS40 to Scene B 1510, skipping interm.o~ te Scene D 1530 and Scene C
1~20.
With reference to Fig. 14(c), Scene Transition Modifier 1440 creates one of a variety of tra~llsitions for a change of Scene. Upon receiving the messages set through pop-up menus 1443 and 1444, respectively, the Modifier in essence, registers (and revokes registration of) the selected transition with the system (to 25 take effect upon an actual change of Scene). The type of transition is specified through pop-up menu 1445, and in~ s pattern dissolve, random dissolve, fade, push, slide, wipe or zoom. The number of steps required to accomplish this transition is specified through data entry area 1447. Certain transition effectsspecified through pop-up menu 1445 require further specification of a direction,30 which is accomplished through pop-up menu 1446. The rate at which the transition takes place, in steps per second, is entered through data entry area 1448.

S~ ult SE~ ~RlllE2~) ii) Motion.

With reference to Fig. 16(a), the Simple Motion Modifier 1600 initi~t~c a simple motion path. It commences and termin~t.-s execution of such motion when the messages set through pop-up menus 1603 and 1604, respectively, are received.The types of motion available are set through pop-up menu 1605 and include: (i) "Into Scene" which moves the Element into the Scene from its current position;
(ii) "Out of Scene" which moves the Element off the Scene from its current position; and (iii) "Random Bounce" which bounces the object at random angles within the boundary of its parent Element. Direction in the first two instances of motion is specified through pop-up menu 1606. The number of steps and rate to accomplish this motion path are specified through pop-up menus 1607 and 1608, respecti~ely.

With rer~rellce to Fig. 16(b), the Drag Motion Modifier 1620 allows the user to drag the F.lemtont at Rnntim~o. [All Media F.lemP.ntc have this capability during Edit Mode in the layout view window 320.] This feature is respectively enabled and disabled when the messages set through pop-up menus 1623 and 1624, respectively, are received. A checkbox 1625 controls whether the Element will beconstrained to remain within the boundaries of its parent. A set of data entry areas 1626 riesign~t~- the top, bottom, left and right constraints. A set of radio buttons 1627 ~ ci~n~ft- whether dragging is unconstrained, or constrained to thehuli~o~ l or vertical directions.

With reference to Fig. 16(c), the Path Motion Modifier 1640 controls the motion paths of Flementc, and in particular animations. It commences and termin~t~-s execution of such motion when the messages set through pop-up menus 1643 and 1644, respectively, are received. The editing buttons 164S allow the author to set down a polygonal path for the Element to follow, the path being followed by the upper left hand corner of the Element's enclosure. Data entry area 1647 allows the position in the path to be specified, with data entry area 1648 ~9~ L~E~ (~a~26) W O9~/31822 PCTrUS96104496 inrli~ting the corresponding mToon cel which should be played at that position.
Slider control 1646 allows an author to step or play through the positions, forward or backwards, thus providing a previewing capability while the dialog box 1640 is open. The rate at which the ~nim~tion is played over the path is configured 5 through data entry 1649. The author also can specify whether the ~nim~tion will always begin at the first position set (through radio button 1650) or whether it will continue from its then-current Runtime position (through radio button 1651).
Checkboxes 1652, 1653 and 1654 respectively control whether the ~nim~tion is to be looped indefinitely, repeated fol w~r-ls and then backwards, or just played 10 backwards.

With reference to Fig. 16(d), the Vector Motion Modifier 1660 initi~tPs vector motion in degrees and inches per second. It commences and termin~t~-s execution of such motion when the messages set through pop-up menus 1663 and 15 1664, respectively, are received. The actual vector for the motion is specified through pop-up menu 1665.

iii) Visual.

With reference to Fig. 17(a), the Graphic Modifier 1700 modifies graphic attributes of Elements. It is applied and removed when the messages set through pop-up menus 1703 and 1704, respectively, are received. The type of ink effect (copy, background trall~pdlel1t, invisible, blend, tran~L,alellL, ghost, reverse copy, reverse tral~alellL, reverse ghost, chameleon dark, chameleon light) is specified through pop-up menu 1705. A matte may be applied through pop-up menu 1706 with Graphic Elements having a solid background color, such matte function making the specified color Llal~ nt. This m~tting color is specified through matte color box 1709, which brings up a color palette. The "hot" region shape ofan Element, i.e., that portion of an Flem~nt that will respond to mouse messages, is configured through pop-up menu 1707, and includes rectangle, round rectangle,oval, star and polygon. A polygon requires use of tools 1710 to create and edit t~EEr(RU~~26) W O9~31822 PCTrUS96/04496 the end points thereof. The background and foreground colors of the Element can be selected through boxes 1708, which bring up color palettes. The border size of ~ a defined F.lem~nt shape, the shadow and shadow of the matte can be adjusted through data entry areas 1711, 1713 and 1714, respectively.

With reference to Fig. 17(b), the Color Table Modifier 1720 manages color tables. It is applied and removed when the messages set through pop-up menus 1723 and 1724, respectively, are received. The color table is specified through pop-up menu 172~;.
With reference to Fig. 17(c), the Gradient Modifier 1740 creates color gradients in Elements that have not been linked to an external media file. It isapplied and removed when the messages set through pop-up menus 1743 and 1744, respectively, are received. The gradient style buttons 174S specify the direction or type of gradient (e.g. vertical, h~ ollLal~ diagonal, central). TheStart and End color boxes 1746 specify the colors which co.,.~lise the beginningand end of the color gradient, accessible through pop-up color palettes.

With reference to Fig. 17(d), the Image Effect Modifier 1760 creates image effects, particularly useful for implementing buttons within a project. It is applied and removed when the messages set through pop-up menus 1763 and 1764, respectively, are received. The image effect is ~ ign~t~cl through pop-up menu 176S (e.g. invert, select bevel, l~n~elect bevel, tone up, tone down). The width of bevel effects is specified through data entry area 1766. Tone amount isspecified through data entry area 1767. The checkbox 1768 controls whether image effects operate outside any margins set by a graphic modifier, as discussed above.

ult SHEEr ~IIE26) W O9G/31822 PCTrUS96/04496 iv) Sound.

With reference to Fig. 18(a), the Sound Modifier 1800 plays sound effects.
It commences and termin~tes execution of such sound effect when the messages setthrough pop-up menus 1803 and 1804, respectively, are received. The actual sound is specified through pop-up menu 1805, with a preview capability provided through button 1806.

With rere.~llce to Fig. 18(b), Sound Fade Modifier 1820 decreases or increases the default volumè level of a sound. It commences and terminat-s execution of such sound effect when the messages set through pop-up menus 1823 and 1824, respectively, are received. The percentage of the sound fading is specified through data entry area 182S, while the duration of the fade is specified through data entry area 1826.
v) Text.

With rer~lellce to Fig. 19, the Style Modifier 1900 is used to modify text styles. It is applied and removed when the messages set through pop-up menus 1903 and 1904, respectively, are received. The font type, alignment and size arespecified through pop-up menus 1905, 1906 and 1907, respectively. The font style (e.g., bold, italics, underline, outline, shadow, con-ien~e~ and extended) is specified through checkboxes 1910.

vi) Cursor.

With reference to Fig. 20, the Cursor Modifier 1920 is used to change the mouse cursor icon. It is applied and removed when the messages set through pop-up menus 1923 and 1924, respectively, are received. The type of cursor is 30 specified through pop-up menu 1925.

su~nr.llE SREr ~UU 26) W O 96/31822 PCTrUS96/04496 (c) Miniscript.

The Miniscript Modifier bears special mention. Although the current embodiment emphasizes a visually-driven authoring environment, there are times 5 when authoring a short script is more convenient than progr~mming a special-purpose modifier. At some point, however, frequently used constructs suggest thecreation of a separate modifier. The "If" Messenger is a good example. It is used to trigger a message on a simple boolean expression handled much like the Miniscript Modifier, but with the special me~ging mrrh~ni~mc presented like any 10 other Messenger. In the current embodiment, the Miniscript Modifier allows access to internal Attributes of Elements (e.g. position) not otherwise accessible directly by authors.

With reference to Fig. 21, the Miniscript Modifier 1980 has a title 1981 15 and an icon 1982. It is executed upon receipt of a message as configured via pop-up menu 1983. The data entry area 1984 permits the author to enter tne script using the Miniscript scripting language. The compile button 1982 compiles any changes made in the data entry area 1984.

The syntax of the Miniscript Modifier is based on the following keywords:
(i) "set", "of" and "to" (used to set Variables); (ii) "if", "then", "else" and "end if" (to form conditional structures); and (iii) "send" and "with" (for message ~licp~trh;ng). The Miniscript Modifier also can access and manipulate the inherent ALLIibu~s of Elements, e.g., for an mToon, its height, position, width,cel, range, rate and paused fields. It permits Relative Targeting of messages through tag names, such as Project, Section, Scene, Element, F.lement's Parent, activeScene, sharedScene and parent. The Miniscript language also has access to various mathematical functions, such as absolute value (abs), arctangent (atn), random (rnd), and so on.

âU~IllultSHEr ~UIE26) W O~6/31822 PCTrUS96/04496 The Miniscript Modifier in the current embodiment is not implemented as a p-code (il,Lt;ll,leted pseudocode) system; rather, it is a compiled, atom-based execution system. Thus, the miniscript is broken down into atoms, allowing the arguments for each to be loaded and executed by calling the apL,r- pli~ function, S which in most cases is the method of another Modifier. Implementations of scripting languages are well known in the art. Moreover, additional scripting functionality could be added to the system via the Component API, discussed below with respect to the system's implementation.

(d) Classification.

With rer~ c~ to Fig. 22, the Classification Modifier 1940 establishes a classification scheme which allows authors to create and name classes and group any objects into one or more of these classes. In one sense, the Classification lS Modifier 1940 implements a set-based, rather than a familv-based hierarchy. In other words, one can target sets of Elements, rather than f~mili.o.s. However, as can be readily understood, the current embodiment is optimized to service a family hierarchy.

The Classification Modifier 1940 has a title 1941 and an icon 1942. It is applied and removed when the messages set through pop-up menus 1943 and 1945, respectively, are received. The classification is specified through pop-upmenu 1944.

An example application of the Classification Modifier 1940 is in conjunction with the Collision Messenger 1280 (see Fig. 13(e)). The Collision Messenger's "Collide With" pop-up menu 1285 can be configured to "Parent's Class," m~o~ning that its parent Element will detect collisions only with other Elements in the same class. Thus, authors could configure bouncing ball Elementsthat would only bounce off one another.

S~ u~t S~EEr (RUlE26) W O 9G/31822 PCTnUS96/04496 (e) Set Value Modifier.

With reference to Fig. 23, the Set Value Modifier 1960 is used to reset the value of a Variable Modifier. It has a title 1961 and an icon 1962. It is executed 5 upon receipt of the message specified via pop-up menu 1963. The author can select the source of the data to be written via pop-up menu 1965, and the targetVariable or incoming data to be changed via pop-up menu 1964.

B. Core System Ar~hite~nre.

The overall architecture of a system 100 embodying the principles of the invention is presented in Fig. 24. The major modules of system 100 are separatedinto those governing the actual title content, Runtime functionality, and Edit Mode 15 functionality. This system 100 interacts through h~r-lw~e peripherals, such as a display 3, speakers 4, keyboard 5, and mouse 6 or other joystick-like a~l.a d~uS.
As shown by the stretched rectangles, there are modules which straddle the Rllntim~/Edit Mode boundary, and are thus present in both.

Under the classification of "title content" are those modules that are specific to a particular title. They include the logic 1, which is the storage for the project itself, including all Elements and Modifiers, and the media 2, which is the storage for all media linked into the project.
-There is certain functionality available to the author only in Edit Mode, such as access to windows, dialogs, etc. However, there is very little difference between Edit Mode and Runtime Mode in the current embodiment. In both modes, certain background Environment Messages (not visible to the author) are issued by system 100, which trigger Modifiers to perform certain functions, suchas updating Element positions on-screen. Certain functionality ~-~cessihle to authors through Modifiers also is realized during Edit Mode. For example, the SUBSIIlultS8EE~ ~UE26) - -W O96131822 PCTnUS96/04496 system updates an Element's graphic atffibutes in accordance with the author's configuration of the Graphic Modifier, and steps through an author-specified path, configured via the Path Motion Modifier. Most ~untime functionality, however (such as the sen~ing of messages throughout the Structural and Behavioral 5 Hierarchies to trigger Modifiers), is suppressed during Runtime Mode.

In an alternative embodiment, rather than suppressing most Runtime functionality during the Edit Mode, such Runtime functionality could proceed at a significantly slower rate. This would give the author the impression of how the 10 Project would proceed at normal speed, while allowing the author sufficient time to reconfigure Elements and Modifiers without inlellu~ g the flow.

1. Edit Mode Func~ionality.

The mo~nles comprising the Edit Mode functionality in this embodiment include the title builder 51, the libraries S2, the mToon editor 53, the views manager 30 and the authoring GUI support 40, as well as the asset manager 7, thealias manager 8, the hypertext support 9 and the cross-platform architecture 50 that are shared with the Runtime functionality.
The title builder S1 is the module which transforms a project into a standalone title, severing the Edit Mode functionality. In view of the cross-platform architecture 50 discussed below, this task can be accomplished for various target platforms with minim~l difficulty.
The libraries 52 provide centralized storage for Elements and Modifiers, in contrast to external media resources controlled by the asset manager 7. As discussed below with reference to Fig. 6, the libraries module 52 generates and controls the library windows 520.

SIJBSIIIUIESHE~ (~UIE26) W O96131822 PCTrUS96/04496 The mToon editor 53 allows manipulation of the proprietary "mToon"
animation format, as well as the conversion of other formats, such as QuickTime~, into the mToon format. As ~liccllcce(1 above with reference to Figs.9(a)-(d), this module controls the mToon editor window 900, the source file dialog 910, the co~ lession settings dialog 920 and the mToon ranges dialog 930.

The views manager 30 controls and presents to the author various views of the Project, which include a layers view 31, a layout view 32, a structure view 33 and a behavior view 34. The layers view 31 is used to edit projects a Subsection10 at a time, with the various Scenes projected along one axis, and the Elements with their layer order on the other. It controls, with reference to Fig. 3, the layers view window 310.
The layout view 32 is used to edit a Scene and is the view closest in se~ Lion to the actual running of the Project. It controls, with reference to 15 Fig. 2, the layout view window 320.

The structure view 33 shows and allows the manipulation of the Structural Hierarchy of Project, Section, Subsection, Scenes and Media Elements, as well asthe Behavioral Hieldrclly of Behaviors and other Modifiers. It controls, with 20 rert:lence to Fig. 4, the structure view window 330. It should be noted that Modifiers may be edited in all three views (layers view 31, layout view 32 and structure view 33), as discussed below. The Behavior view 34 shows (via Behavior Window 390 shown in Fig. 11) and allows the author to control the mPss~gin~ connections among a Behavior's child Modifiers.
The asset manager 7 is a ~i~t~h~ce system that provides centralized access to all external resources (such as pictures, ~nim~tit~ns, text and fonts) storedexternally in the media 1 (e.g. on hard disk). The asset manager 7 is implemented as a flat-file ~i~t~h~ce, having a search engine for files. The asset manager ? has 30 the ability to follow assets as they may be moved around a file system. If the asset manager 7 does not find an asset in the prescribed dh~;luly~ it will first Ul~:S~tl p~UlE26) --PCTrUS9~'0.1~6 .

determine if other assets that used to be in the same directory as the asset in question have been moved to another directory. If so, the asset manager 7 will ask the author whether to pursue that other directory for such asset. Otherwise, it will continue to seek other '~c~n~ te~ directories among the moved assets. If the 5 asset manager 7 then fails in this process, the author will be prompted either to relink the media at its new location or to link to other media, or simply ignore this lack of media linkage. In the latter case, the Element in question simply will not "play" any media.

The alias manager 8 handles the aliasing of Modifiers. For Variables, such as integers, this link of data is m~int~inPd at Runtime. Thus, changes to one instance of the aliased Variable are reflected in all other such in~t~nres during Runtime Mode. In one embodiment, aliasing affects other non-Variable Modifiers only during Edit Mode. Invocation of one in~t~nre of an aliased Modifier (e.g., in response to a message) does not result in the invocation of other such in~t~nr-es.
However, nothing in the embodiment tli~cucsed here precludes implementing aliasing such that all Modifiers are linked dyn~mic~lly, and thus are invoked simultaneously during the Runtime Mode.

The hypertext support 9 implements hypertext capability, whereby any part of a Text Element's text may be transformed into a "label." Hypertext labels aretags that can be applied to the entire text or to blocks of text within Text Elements.

The authoring GUI support 40 controls various aspects of the graphical user interface, inrlllrling the r~lul~s of media linking 41, mes~ging log 42, drag and drop 43 and morphing 44.

The media linking module 41 controls mapping of external media 2 resources to Elements within a Project. it also permits "thumbnails", which are draft mode, low resolution representations of such media that are substituted for q SUB~ ult~EE~(ll~l~E26) the actual media. This saves space and thus ma'Kes Projects more transportable, a useful feature during title development. Moreover, a title could even be executed over a network (e.g., the Internet) with signific~nt savings in bandwidth due to the repl~rçment of large media files.
The mrss~ging log 42 provides debugging information in the form of messages sent and received by various Elements of the Project. The mesS~f ing log 42 traps all message t;affic during l~-lntime and presents the author with the desired filtered view thereof through the m~s~ging log window 420 (see Fig. 8).
The drag and drop module 43 provide the visual paradigm for transferring, e.g., Elements and Modifiers from one part of a Project to another, or even to other Projects, by pressing the mouse 6 button down on the object and dragging it to its desired destination. The implement~tion of drag and drop behavior is well-15 known in the art. The consequences of particular drag and drop actions, such asAdoption, Transplantation and hierarchical object linking, are handled by particular core modules, as ~ c~ e-l below. The drag and drop module 43 will intiir~te a disallowed action by moving an outline of the object's icon bacK to its original position.
The morphing module 44 controls the tvpe of link to external media, thus allowing an mToon Graphic Element to be transformed into a PICT Graphic Element, for example. It does so by creating an in~t~nti~ti~n of the new Media Element, copying over the structure pointers, ID numbers, etc. (as explained 25 below), and setting up the ~ru~liate icon for the new media. It does not, however, destroy the original Element until the author performs another operation, after which "undo" capability is lost.

SU~IIul~ SHEEI ~RU~E26) a. Connectin~ Objects.

As discussed in greater detail below, Elements, Modifiers, "Players" and "Assets" are implemented as classes of objects. When the author creates an 5 Element or Modifier, or links an FlemPnt to external media, the system 100 inct~nti~tes objects from these classes. The author may then configure and connect these objects to form the working Project.

(1) Element To Element Connection.
The connection of objects underlying this authoring process is illu.trated in Fig. 25. It must be stressed that the particular connections shown are for purposes of demonstration by example, and the principles underlying the present inventionare not limited to the actual connections shown. One sees a portion of the 15 Structural Hierarchy represented by Scene Element lS1 pointing to its first child Flement 152, which points to and is in turn pointed back to by its sibling Element lS3. Both Elements 152 and 153 point back to their parent Scene Element lS1.
The Scene Element lS1 is pointed to and points back to its parent Subsection Flçment lS0. The SLlu-;Luldl Hiel~-;hy continues, though not shown, through the 20 Section level up to the Project level.

Had the author decided to make F.lement lS3 a child of Flement lS2 instead of a sibling, the next sibling and previous sibling pointers of Element lS2 and Element 153 would have been respectively voided, the first child pointer of 25 Element 152 would be set to point to Flement lS3 and the parent pointer of Element lS3 reset to point to Element 152. Adding new Flement~ would proceed in an analogous fashion.

Thus, an Element has (i.e., in its instance data structure) pointers to:
30 (i) its parent Element; (ii) its first child Flem~-nt (iii) its previous sibling Element;
(iv) its next sibling Element; and (v) its first child Modifier.

SU~ ul. S~Er~RUlE~6) PCTAUS9610~496 (2) Modifier ConnPcti~ ns.

The Modifier objects shown in Fig. 25, namely 161, 162 and 163 (and Services 168, 169 and 170 in Fig. 26) are not implemented as conventional C++
classes, as is the rest of the core 99 (and thus are represented specially as double rectangles). These Components (Modifier and Services) are special classes of objects ~lesignPd to extend the functionality of the external architecture discussed above. They will be ~iccucsed in more detail below in connection with the Component API. To bridge the core 99 architect~re with the Component API, a "wrapper" class interfaces with each Component class. There are thus wrappers for Modifiers and wrappers for Services (~liccllcs-pd in greater detail below with respect to the Component API). The Modifier wrappers thus have pointers to: (i) the Modifier; (ii) its parent F.lem~nt; (iii) it. parent Behavior, if any; (iv) its first child Modifier, if any; and (v) its next sibling Modifier.
When an author drags and drops a Modifier into an Element, a Modifier object is created. In other words, a Modifier wrapper object is inst~nti~tPd from a Modifier wl~per class (as is a corresponding special Modifier object, such as Modifiers 161, 162 and 163, ~liccl-cced in greater detail below with respect to the Component API). These Modifier wrapper objects are inst~nti~tPd from a general wrapper class, except for Behavior Modifiers, whose wrapper objects are inct~nti~tP~ from a Behavior wrapper class. These wrapper classes provide for the Modifiers a backbone of methods to read and write data, to obtain and draw the Modifier's icon, to open and close the dialog editor, to copy data, and to send messages throughout the Structural and Behavioral Hierarchies.

Focusing now dowllwalds from Element lS3, one can see that it points to - itc first child Modifier 161 through Modifier wrapper 158, which in turn points to the second child Modifier 162 through wrapper 159, which in turn points to the third child Modifier 163 through wrapper 160. Element lS3 is itself pointed to by the Modifier wrappers lS8, 159 and 160. Thus, the Element lS3 knows of its ~ 91 SUBSlllUlESEEr (RUlE26) W O96131822 PCT~US96/04496 first child Modifier 161, and all three sibling Modifiers 161, 162 and 163 know of their parent, Element lS3.

With the sibling pointers going in only one direction (right), one can see that the Modifier wrappers 158, lS9 and 160 form a singly-linked list. This is distinguished from the sibling Elements lS2 and lS3 which form a doubly-linked list. This slight difference in the implementation of the Structural and Behavioral Hierarchies is due to a subjective judgment that, in practice, it is more often nPceee~.y to know one's previous sibling Element than one's previous sibling Modifier.

As will be di.ec~l.e.eell below, messages are passed among Modifiers from "left" to "right," i.e, along the sibling chain. If need be, one can always record the pointer to the present Modifier, proceed up through the parent and then cycle rolw~d from the first sibling, recording each pointer in turn until the present Modifier is encuu~ ed again. Allowing authors to move Modifiers within the Behavioral Hierarchy requires analogous updating of pointers as described above with respect to Structural Hierarchy changes.

(3) Player and Asset Connections.

When an author creates a new Element (e.g., a Graphic Element), an Element object is inet~nti~t~.~l from a general Graphic Element class. In ~ ition, corresponding "player" and "asset" objects are instantiated from their core classes.
25 From Element lS3, one can also see ~tt~rhPri a player 154 and asset lSS. The player lS4 knows how to "play" media of a particular type, e.g. a PICT, a sound,or a QuickTimeD' movie. The asset lSS is a pointer to the actual media, which is~c~ sen~d as stored on disk lS7. Of course, the opeld~ g system lS6 provides the n-ocPe~,. y interface between the asset 15S and media lS7. In the embodiment30 discussed here, player lS4 performs the bulk of the interaction with Element 153, while asset 15S only exchanges ID reference numbers with the Element lS3.

Sl~BSlllUltSl~ UIE26) W O 9~/31822 PCTrUS96/04496 The process by which an Element is linked to a player is as follows. When the media file 157 is selected by the author through a standard file dialog box, the asset manager 7 is asked whether it knows about that particular asset. If so, that asset lSS is used and connPctecl as shown. Otherwise, a rl~t~b~ce entry is created 5 in asset manager 7, the asset 155 is established and the file description is passed on to player 154. If the author decides to switch the type of media entirely, a new player object would be inct~nfi~tP-I, with all the pointer information carried over from player 154. This morphing process is controlled by the morphing 44 module. Similar to the process of originally creating an asset, a new asset would 10replace asset 155, while asset 155 would remain as an entry in the asset manager

7. The asset manager 7 would simply decrement the user count in its Asset Palette 70 display, even if that meant that the user count was now zero.

(4) Touch-Up Process.
When an author initi~tPs Adoptions or Transpl~nt~tionc, the system 100 attaches and detaches Elements or Modifiers, as the case may be, as discussed above. In order to complete either process, and enable the Element or Modifier to operate in its new environment, a few additional measures are required.
When an author moves an Element or Modifier from one environment to another, the system 100 bro~lc~ctc an Environment Message from the Project level. As will be understood more fully below, Mecc~ging Management 13 dispatches messages along the Structural and Behavioral Hierarchies not only to 25 Elements and Modifiers, but also to all views, palettes, and certain other "system objects," in order that they also may respond ~l"~liately. The message specifies the relevant object and type of change. This change can be as subtle as requesting a view window to highlight an icon selected by the author.

30When an object is moved to a new ellvhu~ lent, a "touch up" process takes place. This process applies not only to Elements and Modifiers, and each of the ~u~lllult ~ UlE ~G) , W O96/31822 PCTrUS96/04496 object they contain, but also to assetc, symbol IDs, mToon ranges, sound ranges,etc. The system 100, through the Symbol Manager 19, asks each entity to identifyby name its "external dependencies" from its previous environment, e.g., Author Messages, Variables, aliases, mToon symbols and sound symbols.
s If the name is present in the new environment, and the ID number supplied by the Symbol Manager 19 differs, the system replaces the entity's old ID numberwith the ID number from the new environment. If the name is not present, yet theID number conflicts with an existing ID number, the entity is assigned a new, 10 non-conflicting ID number.

The implementation of Hierarchical Element Positioning (i.e. that a child Flem~nt moves with its parent Element), n.oceccit~ttos its own type of "touch up"
process. In the current embo-liment, position (an ~ttribute) only applies to 15 Graphic and Text F.lemPnte (although one could envisage and readily implement"stereo" sound F.lemPntc, where the Element's position would reflect the relative amplitude between the left and right speakers).

In any event, when a parent Element moves, the position of each of its 20 child Elementc (and their child Elements, and so forth) must be modified. Thecoordinates of the child Element are readjusted in a straighlrc,lw~d manner by the system, which subtracts the old parent's coordinates (saved when detached) from the Element's coordinates and adds the new parent's coordinates to the Element'scoordinates. Fig. 25 illu~ tes how to access a parent's data structures, and thus 25 in particular, its position Attribute.

b. Aliasing.

The alias manager 8 works with all Modifiers and operates by m~int~ining 30 a list of all alia es, along with the users of such aliases. In the current embodiment, all manifestations of an alias are separate inct~nti~tic,ns of a Modifier SllBS~ h~ko (~UlE26) W O 96/31822 PCTnUS96/04496 which are kept in sync with each other. Thus, the relationship of an aliased Modifier to the objects it connects with (pointers to Elements, parent Behaviors, sibling and child Modifiers, etc.) is kept intact.

S Each in~t~nti~tP~l Modifier has an alias ID code which is set to zero if not an alia~" and will share the same non-zero alias ID code when aliased together with others. Thus, if one of the Modifiers under an alias is changed, the Modifier state data is written out and the alias manager 8 tr~n~mit~ the data to the other Modifiers under the alias. For Variables, this can and does occur in Runtime Mode. For all other Modifiers, this occurs only in Edit Mode. This accounts for the ability of aliased Variables to circumvent their normal scope. Of course, itshould be noted that this is an implementational decision only, and anyone of ordinary skill in the art would realize that non-Variable Modifiers could easily be ~,yllchlollized at Runtime as well.
2. Sav;n~ Project~ and Titles.

As was ~ cllc~ec7 above, the Project's Elements and Modifiers are stored in Logic 1, while tne various files may be dispersed in whatever fashion in the storage for media 2 (e.g., directories for files stored on magnetic media, CD-ROM, etc.). It is worth noting how the title builder ~1 actually allocates storage (on a mPrlillm such as CD-ROM) for a standalone title, rather than a Project under development, such that the object loader 16 can efficiently load objects into memory. With the slow seek and read access time of CD-ROM, it is important to advantageously arrange data thereupon so as to minimi7e the amount of read-head thrashing.

- In one embodiment, the logic 1 and various media 2 files are all placed in one file container, which is a contiguous arrangement of all the files, and which only has to be opened by the operating system once, always a costly operation in~erms of time. Each asset will be written to disk in its rawest form, as notning but IIUItS~Er~llUlE26) W O96131822 PCTrUS96104496 the application itself will need to access the asset. Thus, a picture will be a co-l-plessed bitmap, rather than a PICT. It is thus imperative that the computerrunning the title be able to know where everything is within this file container, as it cannot resort to the u~e~ g system file utilities.
s Thus, with reference tû Fig. 27, one can see a cross-section of the available tracks on the CD-ROM 175 (neglecting the track curvature here for clarity). The actual application code 176 precedes all other data and is loaded into memory first. The Runtime engine embodied in the application code 176 would l0 include all used players, Modifiers, Services, etc. Thereafter, the Structural Elements 177 (i.e. Project, Sections, Subsections), as well as Scenes, are stored and are all lûaded in memory for the entirety of the title operation. The actual act of loading inst~nti~t.-s each of the objects in this embodiment.

The assets of individual Scenes are stored, each in turn, with the table of assets for the given Scene as a "hidden" asset. These tables of assets written to disk by the title builder S1 would be stripped of everything nnnt~ce~ry for the title. Thus, unused assets as well as the user count are discarded. The asset manager 7, in conjunction with the title builder 51, also would have sc~nn~ the Scenes and correlated the order in the asset manager 7 rl~t~h~ce with layer order number for each of the Elements in the Scene before writing these assets and thetables of assets to disk.

In this example, there are three Scenes (Scene 1, Scene 2 and Scene 3), each with a table of assets 178, 181 and 183, respectively, which provides indices to all the assets witnin the given Scene. Tnese are loaded, respectively, immediately prece~ling the beginning of the playing of their corresponding Scene.
A flag in the table of assets determines whether an asset should be preloaded, m~ning that the asset will be loaded imm~ t~ly after the asset table is loaded and inspected, and memory allocated to the asset locked down. Following each of those tables are all of the objects (Elements and Modifiers) 179, 182 and 184, UltS~ RU~26) PCTrUS96/04496 W 09~131822 -respectively, associated with each Scene. Thereafter would be stored individual media, as for example shown here for Scene 1, a back~,-o~ d picture 180.
.~
Typically, to save space, assets are stored in only one place on the CD-S ROM 175. However, in order to minimi7e the read-head movement, and thus enhance Runtime pe-ro~ ance, the asset manager 7 may be configured, during the authoring process, to store assets used more than once in multiple separate places.
The order in which the media are presented in the asset manager 7 is the order in which the title builder 51 writes out the title for CD-ROM. It is thus also 10 advantageous if the assets which are to be preloaded be up at the front of the asset manager 7, for the reasons discussed above.

3. E~nntim~ Functionalitv.

Under the c~ ific~tinn of RllntimP functionality with lefelc~"ce to Fig. 24, one finds a world manager 10, a component manager 20, and the cross-platform architPctnre 50. The world manager 10 and component manager 20 can be referred to collectively as the core 99 (see Fig. 29).

The world manager 10 controls the overall processing of the Runtime functions and includes an asset m~n~ger 7, an alias m,7n,7~Pr 8, hypertext support 9, asset classes 11, media player classes 12, mP~s<7~ing management 13, a rendering manager 14, a sound manager 15, an object loader 16, memory manager 17, thread manager 18 and symbol manager 19, some already discussed above.
The asset classes 11 are the basic classes which describe the external resources, as for example fonts, pictures, movies, sounds, etc.
-Tl1e media player classes 12 govern the low-level Runtime operation of a 30 Project or title. They include picture players, movie players, sound players, etc.

SU~lultS~ UlE26) PCTnUS96/04496 The mess~ging management 13, discussed in more detail below, is the subsystem which controls the dispatch and targeting of messages among objects.
Rather than operating on a method-to-method call basis, which often is unwieldy and slow, messages are dispatched through a commllnit~ti~ n network, relying 5 heavily on the Structural and Behavioral Hierarchies, with these destinations resolved and optimized at Runtime.

The rendering manager 14 renders bitmaps to the display 3. The rendering manager 14 may also m~int~in alternate off-screen buffers, or "GWorlds." All 10 draw comm~n~c are ~t~cllmnl~t~(l for optimal concurrent drawing operatioL during idle processor cycles, as ~iiccu~e~l below.

The sound manager 15 controls the audio signal that is tr~n~mitte~l through the speaker 4.
The object loader 16 reads in definitions of the various objects (e.g. the inst~nti~t~ Elements and Modifiers) for the particular title/Project from the logic 1 storage.

The memory manager 17 ~elro.,lls the low-level allocation of memory for the system.

The thread manager 18, as ~ cu~e~l more fully below, controls the multit~cking threads of system 100, whether posted by the system 100 itself, by the Modifiers 22, or by the user interacting through the keyboard 5 or mouse 6 or other peripheral. In one embodiment, for the Apple Macintosh~ operating system, all threads are cooperative or real-time, cooperative mP~ning all other operations are suspended until a thread declares itself done, and real time m~ning that they operate at a fixed time by invoking an h~lellu~t. The former type is implementedwith a list of timers, with regular checks to see if the timer has expired, and if so, processing the corresponding thread as soon as practicable. The latter type under .

Sl~llTUlES~{Er ~RU~E26) W O 96/31822 PCTrUS96/04496 the Macintosh operating system should only be used for short tasks; otherwise the system is likely to fail.

The symbol m~n~gçr 19 associates names of objects with internal reference - S IDs. Given one, it will return the other. It is called upon by various modules throughout the system 100 to produce lists of messages, Elements, Modifiers, etc.

The component manager 20 (~ cll~ce~l in greater detail below) implements the extensibility of the architecture in accordance with the present invention, and includes the component API 21, a plurality of Modifier classes 22, the Service manager 23, and a plurality of Service classes 24.

Both the Modifier 22 and Service classes 24 are coupled to the system through the Component API 21, which is the applir~tion programmer's interface lS that enables the core 99 of the system 100 to communicate with the various Components (Modifiers and Services) created by programmers. The Component manager 20 permits programmers to add custom Modifiers and Services to the system. The Component API 21 actually permits Modifiers 22 and Services 24 to interface with each other as well as with core functions.
The service manager 23 inventories and manages the various Services 24, controlling, for example, how Modifiers become (or are removed as) clients of particular Services.

The Services 24 are, generally speaking, groups of functions or functionality accessible by a Modifier. Some key Services implement such vital functions as determining an object's parent, detecting collisions of Elements orproviding time-of-day filn~tion~lity.

The ability to add additional Services represents enormous extensibility of the functionality present in the system. For example, one could write an SllB~ u~SHEEr~lUlE26) WO 96/31822 PCTrUS96/04496 AppleScriptlU Service which would allow scripts to be written through an AppleScript Modifier and give access to the already-developed capabilities of the AppleScript language. Anotner example, discussed in more detail below, is to provide a "gravitational" service, with a gravity Modifier giving "mass" to its 5 Flem~nt~.

Both Modifiers 22 and Services 24 use a form of dynamic binding, resolved at Runtime, implemented using the object model hereinafter described.
This yields enormous flexibility in the overall design. For example, patch code 10 can be provided separately and be incorporated into the system 100 during the Runtime binding process, overriding the existing code.

Finally, the cross-platform architecture 50 controls the access to low-level rea~ules that are platform-dependent. For each function that must be performed on 15 the display 3 or through the operating system, a generic method call is made,which in turn makes the platform-dependent method call. This generic call may invoke a real function which prepares whatever overhead is required for the particular platform, or it may be simply a macro which invokes the platform-dependent function directly. The former scenario would occur where structures 20 are not easily reconciled between platforms, as for example a window under the Apple Macintosh~ operating system as compared with one under Microsoft WindowsTn. Under these most extreme circumstances, a placeholder class is created to handle both implementations.

Thus, under the present invention, a title need not be "ported" to another platform -- i.e., the code targeted for one platform need not be lt;wliLLell to run for a new platform. For example, the title can be built by title builder 51 in accordance with the platform-dependent methods for the various platforms supported by the system (e.g., Apple Macintosh~ 68K, PowerPC alld Microsoft Windows~). In one embodiment, the particulars of dialog screens, for example the Modifier configuration dialogs ~ cll~sed in depth earlier, are stored as device-SU8SII~u~

W O 96131822 PCTrUS96/04496 independent scripts within the application, thus providing the dialogs for each platform tran~p~elllly. This overall design philosophy prevents the various abstract functions from becoming too tightly bound to the implementations of a particular platform, which is the typical h~ r.hr of the normal porting process.
S Typically, software quality assurance approaches would be fixated upon concentrating on only one platform implement~tion at a time, and freezing features until the overall structure is stable. The multi-platform approach here resolves this porting problem.

The functionality of the Runtime environment involves two major processes: (i) message targeting and ~licp~trhjng, and (ii) event loop proces~ing, both of which merit further discussion.

a. Messa~e Tar~etin~ and Dicp~trhinE~.
Typically object-oriented authoring ~ybLellls provide no special merh~nicm for dispatching messages among objects. They simply rely on method-to-method function calls which necessitate a laborious search through function tables to access the proper methods. By contrast, under the principles of the present 20 invention, mrss~gin~ is accomplished by means more akin to a commlmic~tion packet-switching system.

The problem posed in optimi7ing performance with regard to m~s~ging is llow to account for target destinations which may not yet exist at the time of 25 authoring, yet not incur a time penalty for each message when the system searches tables for the proper target. This problem is exacerbated by the freedom afforded under the present invention to drag and drop objects from one environment to another.

The data structure for m~ss~fring in one embodiment of the invention is presented in Table III.

S~ lllUlt~hc~ JIE26) , W O 96/31822 PCTrU59"~496 TABLE m. MESSAGE DATA STRUCTURE
Member Type Description f_info long Flags describing the characteristics of the message, inrlll~ing whether the message be sent im m~ t~.ly, c~cc ~-le-l or relayed.
f_keysig long Special l)as~wc-d for ~rces~ing proprietary Modifiers.
f_sender void* Identifies the sender of the message.
f_event long The ID code corresponding to the message name.
f_eventinfo long Adds any additional information for the message.
f_LalgeLillro struct The destin~tiQn target illrolla~ion.
f_data union The various kinds of data (e.g. vector, another event) that can be sent with the message.

Referring back to Fig. 1, consider the scenario in which the author desires that a Modifier M4 117 on Element E3 110 send a message to Element E2 109.
Thus, the first step is to make available all possible destinatiorls for Modifier M2 ~lS to the author in Edit Mode, as for example, through the DesLil,aLion pop-up lS menu of the Modifier dialog. The Me~ging Management 13 ~rcessçs the data structure of Modifier M4 117. Under the embodiment here, rec~lling the discussion above with respect to Fig. 2S, one can readily understand how the Me~ging Management 13 can access the ID code of its parent, in this case Element E3 110. Knowing Element E3 110 allows Mecs~ging Management 13 to access its data structure, yielding the ID code of parent Scene Scl 106. It is clear that this process can thus be readily booL~ ed, to reproduce the entire Structural and Behavioral Hierarchies. Yet, in this embodiment, M~ss~ging Management 13 only proceeds further to discern the chain of ancestors, from Scene Sc1 106 to Subsection SSl 104, Section Sl 102 and Project 101. Element E3 110 could also yield its previous sibling, namely Element E2 109. However, in the current embodiment, the siblings of Element E3 108 are obtained in a different manner.

~s SUB~Illu~tSllEr(RIIIE26) CA 022l7342 l997-lO-03 W O 96/31822 PCTnUS96/04496 Knowing the parent Scene Scl 106, one can obtain the pointer to its first child, namely E1 108. Then, Mess~ing Management 13 proceeds down the sibling list, namely Flement E1 108, Element E2 109 and ending here with F.leJnent E3 110. Mec.s~ging Management 13 does this by broadcasting an 5 identifi~tion request message to the Scene Scl 106, which filters down one level so that the children of Scene Scl 106 identify them~elves as well. The process of locating the siblings of modifier M4 117 employs an analogous identifir.~tion request bro~lc~ct~ this time to Element E3 110.

10The actual tr~ncl~tion of ID codes into names for presentation to the author is accomplished by the Symbol Manager 19, which m~int~in.c all such name-ID
code correspondences. Thus, the Destination pop-up menu is populated with all the actual names of these Elements and Modifiers, including Element E2 109.
Thus, when the author references a target by name, the ~L)pl~liate ID code is 15 stuffed directly into the f_L~ge~ ro piece of the message data structure. This whole process was referred to above as Direct Targeting.

However, the author might not want to reference by name, as for example, in the h~ e~ of reusability. Thus, the author can reference a target by "tag," a20 stand-in for most of those very same destinations presented in the Destination pop-up by name, and as described above as Relative Targeting in conjunction with Table II. Unlike the bo~Lld~l!ing process discussed above, this process resolvesthe ID codes by procee~lin~ directly up through the Structural and Behavioral Hierarchies, ~rces.cin~ the nearest-neighbor sibling Elements directly from the 25 F.lemrnt's next and previous Element pointers, rather than by the "identification request broadcast" procedure. Once the proper ID code has been resolved at Runtime in the first in.~t~nre, the ID code can be stuffed into f_la,gelillro, allowing the mess~ging to proceed in a targeted manner th~l~arL~.

30The embot1iment ~ c~ ed above permits targeted me.c.~gin~ to initial destinations within a somewhat fixed scope. It is suitable in most in~t~nrlo~ where S~SJI~UIt SHEEr (RUIE 26) CA 022l7342 l997-lO-03 W O96/31822 PCTrUS9~v~119G

there is a close relationship among Elements, or the number of F.lementc is rather small. To commllnir~te to an Element outside this small family of Fl~mentc, in this embodiment, requires targeting the most recent common ancestor Element.
The message will cascade down to that Element's progeny, including the real 5 target F.lement For example, Modifier M2115 could not target Element E4111 directly in this embodiment, because the parent of Modifier M2115 (F.l~ment E2109) is neither an ancestor, child or sibling of Element E4111; rather it is only an "uncle" of Element E4111. Thus, Modifier M2 115 could target the most common ancestor of F.lement E2109 and Element E4111, that being Scene Scl 106. Thus, Scene Sc1106 would pass the message to its children, F.l~mentc E1 108, E2109 and E3110. It is worth noting that in the embodiment r~iccuC~er here, F.lem.qnt E1110 would pass the message to Element E4111 before the message is passed from Element E1 108 to Element E2109 (showing a plerere-lce for one's children over one's siblings), In an alternate embodiment, however, it may be desirable to modify the Structural and Behavioral Hierarchies at Runtime, through Dynamic Creation (i.e., 20 inst~nti~ticn of objects), Transplantation or Adoption. Under this scenario, the destination might best be resolved each time the message needs to be sent. This would allow Relative Targeting to work, even though we have, in essence, "moving targets." To permit an author to achieve these dynamic functions, one merely need create a set of Modifiers which specify the conditions under which 25 such events can occur.

b. Event Loop Processing.

The management of all tasks related to the execution of an application 30 requires allocation of ~locessor time among such tasks. Thus, with reference to Fig. 28, this process starting from block 250 may be described. In one SU~ ult SHEEr (RUIE 26~

CA 022l7342 l997-lO-03 PCTrUS96/04496 W O9~/31822 emborlimPnt ~ltili~ing the Apple Macintosh~ operating system, various tasks may operate concurrently under what is known as cooperative mnltit~king, m~ning that a task must surrender use of the co~ ulel's processor in order that anothertask may be serviced (as opposed to pre-emptive multit~cking, where the processor 5 may be usurped by another task without a declared surrender by the first task).
Thus, the decision box 251 represents the release of the processor by the operating system (including other applications and back~ ulld network functions, for example) to system 100, which then pelrolllls pending tasks if the operating system is in what is termed here as an "idle cycle."
If the processor is not idle, and the operating system itself is not running some other task, the World Manager 10 determines whether there are any pending messages to any active Services or Modifiers at step 2S2. If there are any active Services or Modifiers, these Services and/or Modifiers are queried to determine 15 whether proces~ing such a message may be deferred at step 253. This is a decision that may be based on a lack of ul~el-~;y, or whether the proce~ing olll~d by such message would hamper pelr,llllance were it done at a time-critical moment, or various other factors. Thus, processing that needs to be done imm~ ely is done at step 254 while deferred processing is sch~dllle~l through the 20 posting of a thread at step 2S6 by the thread manager 18. One may even envisage a hybrid situation where some small amount of critical procec~ing is done immP~i~tely while the rest is deferred through a posted thread. The final step 2SS
of the "non-idle" state is to relinquish the ~rocessor to the operating system to ~lrOllll all its other tasks.
The idle cycle commences by a~ trigger for the ~nim~tinn of the Shared Scene 257. This step does not perform the actual drawing; rather, it is an - opportunity to post draw comm~n~l~ for later implement~tinn. This stre~mlint~e the actual drawing process, e.g., elimin~tin~ the need to draw portions of the display 30 3 due to motion in one layer when a covering layer that obscures the Element in the first layer continues to cover that portion of the display 3. It should be noted ult ~h~ (RULE~

W O96/31822 PCTrUS96/04496 here that, whenever an Element is moved, plu~ g a draw command to show such movement, each of the Element's children is notified that the parent was redrawn, so each child Element can then post its own redraw comm~n-~ Thus, children Elements can follow their parent Elements in accordance with the S Hierarchical Relative Positioning mPrh~ni~m ~licc~ e-l above. Next, ~nim~tion of the ~;ull~llLly active Scene is triggered at step 258 and similarly h~nrlle-l.

Next, all previously posted threads (either posted by Modifiers or Services at step 2~6, or by the system 100 itself) are ~Loc~-sse~ at step 259. Thus, all 10 motion Modifiers would proceed to move their Elements according to their prescribed manner of motion. Messenger Modifiers, if triggered, would post new messages to the system 100. Services would pe~rollll their "idle" processing, and so on.

Thereafter, all ~rcnm~ tP-ll draw requests are ~,rc,l,lled at step 260. Each redraw command is specified by inv~litl~ting the old and new visible regions of the corresponding Element. As described above, that may be driven by posted requests from the F.lemPnt~, or by Motion Modifiers, etc. There may be instanceswhere particular Elements need to be notified that such drawing operations 20 occurred. This decision is ,e~lesellled by step 261. For example, a QuickTimeTM
movie needs to know when to start its sound. Thus, such Elements would be so notified at step 262.

A similar holl~ç~ eping function is step 263, which inquires whether any 25 sound files that were previously playing have actually ended. If so, then anynPcess~ry "end play" procedures can be executed (e.g., deallocating the memory taken up by the sound file). In other words, the cull~ollding Element receives this Environment Message and transitions to its "end play" state.

Finally, step 265 decides whether the idle process should relinquish control of the processor. There are titles, such as games, that have a signifi~nt amount SUBSlllUlt SHEr (RUlE26) W O96/31822 PCTnUS96/04496 of user interaction and screen updating that nececsit~te the use of a large fraction of the total processor time. On the other hand, a networked computer needs to I~clr~ regular background tasks to keep the network connection up and running.
Thus, a sliding scale is established by the title's author, or set by a user, between 5 the extremes of never giving up control (squeezing out all other tasks) and always giving up control (and ~urr~lhlg a pelrollllance penalty). The outcome of this decision step 265 is determined in accordance with this sliding scale.

When no system time is made available, the World Manager 10 must do 10 the ch~c~ing for the mouse 6 and keyboard 5 events. When a mouse down event occurs, the World Manager 10 will continue to track the mouse 6 while it is being dragged, although it will intermittently give up time to other threads, including the idle process. It is up to the World Manager 10, which knows the positions of allElements, to determine which Element was selected in this manner.

C. Component API _ c'r~ .a.-l~ner's-Eve View".

The current embodiment of the invention is geared toward almost llnlimite~
20 extensibility. Programmers can add Components (Modifiers and Services that support them) that extend the system's architectllre. These Components are indistinguishable from the system's built-in Modifiers and Services, which implement much of the system's external architectllre ~ cu~e~ above. Thus, from the author's perspective, the system is extended sP~rnle,ssly by the addition of 25 new Modifiers (and supporting Services) to which the author has full access.

With reference to Fig. 29, one sees a plurality of modifiers 22a, 22b, 22c, ..., 22z and a plurality of services 24a, 24b, 24c, ..., 24z coupled to the core 99 of system 100 through the component API 21 as plug-in Components.

S~ sHEE~(~ULE~6~

W O96131822 PCTnUS96/04496 The core 99 in this embodiment is implemented through ordinary C++
classes. However, the modifiers 22 and Services 24 are not ordinary C++
classes. To permit extensibility of the system, they are implemented through the"MOM" object model described below. In order to handle these "new"
5 Modifier/Service classes, "wrapper" classes 94 and 9S of the ordinary C++ typeare provided to interface with them as was ~iiccucce-l above in the context of Figs.
25 and 26. Through these wrapper cla_ses, the Service manager 23 controls the Services 24 and the world manager 10 and Component manager 20 inst~nti~teS
Modifiers, such as Modifier 96 illustrated in Fig. 29. The world manager 10 alsol0 inct~nti~t~,c Elements, such as Element 97, which are coupled to col,e3~0llding inct~n~es of a media player class 12 and an asset class 11.

It will be well understood to those of ordinary skill in the art that the media player classes could themselves be migrated out of the core 99, O~ld~ g under 15 the object model of the present invention and conn~o-cted through a wrapper class and an API analogous to the Component API 21, making the types of media the system 100 can interact with an extensible feature ac well.

1. Obje~t Model.
The object model underlying this invention can be described as "shock proof." It lies along a spectrum in between "rugged" and "fragile" object models.
A rugged object model would permit a programmer to change dyn~mic~lly virtually any aspect of the class hierarchy (e.g., adding, modifying or deleting25 parent classes, subclasses or interme~i~te classes) without requiring recompilation or other mo-lifir~ti~ns of e~icting classes. A fragile object model, on the other hand, would not permit a programmer to make any such changes dyn~rni~lly.

The mFactory Object Model ("MOMn) of this embodiment represents a 30 co~ rolllise between these two extremes. Rather than incurring the overhead and pe~rullllance penalties of a rugged object model, MOM permits a programmer SUB~ ul~ Sh~tl ~RU~E 28) W O96/31822 PCTnUS96/04496 dyn~mir-~lly to add subclasses, or add methods and/or fields to or otherwise augment superclasses, provided that the order in the class hiera~;chy is preserved.
~ In this manner, most of the functionality that a user/author would desire as extensions to the system can be provided with minim~l overhead, as com~aled to aS rugged object model.

One aspect of MOM is that, at compilation time, each class identifies its associated superclasses and their estim~te~l sizes. At Runtime, the class hierarchy is verified, particularly whether the sequence of classes is preserved. If it is10 preserved, then MOM adjusts for any dirrelellces in the sizes of the class structures by ch~ngin~ the offset field for each class structure to reflect the new difference in size. This permits new fields to be added to each class structure or entries to be added to the virtual function table (vtable) dyn~mir~lly without global recompilation. If the class sequence is not preserved, the system will not crash;
15 rather, the affected object(s) simply will not run.

Another aspect of MOM is its use of virtual tables. Programmers can access the virtual tables of their classes as well as the virtual tables of the superclasses above. The tables are created by the system and resolved upon 20 loading. One can add fields and methods, though one cannot later rearrange them witnout a full recompile. One key advantage of this construct is that adding fields and methods to a superclass does not require recompilation of its subclass below.

With reference now to Fig. 30, the operation of MOM is described in 25 detail. In Fig. 30, one sees a class hiel~cl1y of classes "An, "B" and "C"
represented by "self" class structures 126a for base class "A", 126b for class "B", and 126c for class "C". Prepended to each of the class structures is a pointer to the class' entry in vtabs 127, a table with pointers to each of tne virtual tables present in the A/B/C class structure. In one embodiment, the pointer prece-7in~
30 the "self" structure is not directly ~rceseed by the programmer, but rather is UltSHEE~U~

W O96/31822 PCTrUS96~04496 provided indirectly through a function call, relieving the programmer from the implemPnt~tinnal details thereof.

From the pointer to the class structure 126c for class "cn, for example, the S pointer to its corresponding entry in vtabs 127 is obtained. From the ~lopliate pointer in vtabs 127 one can then recuvel the pointer into the ~ lo~lia~ vtable 128c for class "C". With such a pointer, one can then obtain the actual functionpointer in the methods storage 129 to the ~plu~lia~e method 129a, 129b, 129c, etc. In one embodiment, the vtable contains not only the function pointer, but the 10 slot number of the class com~ining the version of the method that class "C' will call. Thus, if vtable 128c had for a particular function a slot number of n~ it would mean "C's" function would be called; if it had a slot number of " 1 ", "B's"
function would be called, and thus a slot number of "0" would ~esign~tP the use of "A's" function, i.e. no overriding.
It is thus clear how the system is polymorphic, in that you can both override (replace the e~cicting functionality) and overload (add to the existingfunctionality) methods of a subclass. As our example of overloading, for the "CompConstructor" method 129b shown here (which represents the method that 20 creates or "con~llu-;~" a Component inst~nti~tiQn for class "Cn), one could perform all the construction necessitated by class "C" itself, but rely on the construction pe.rul-lled by class "B" through an "Inherit" function which invokes "B's" class through its slot number. In the embodiment ~ cllese/1 here, the programmer's selection of either overloading or overriding is invoked through a 25 function call, sparing the programmer from the implement~tional details of this boo~ ing. In actuality, the base class methods are ~cçc~ecl through C-function calls which reference the base class method through the corresponding slot number in the vtable.

With the above mPrh~ni~m in place, it is clear how the "shock proof"
mech~ni~m of MOM works. If a programmer wished to add a new method 129z, SI~ u1~0E~U1~26) W O96/31822 PCTrUS96/04496 say, to class "Bn, such method would be appended to the end of the existing methods 129a, 129b, 129c, etc. (though this time for class "Bn). A new entry pointing to this method would be made in vtable 128b, at the end of that list. This would nPce~eit~te ~-xp~nrling the size of vtable 128b, and thus subsequent vtables S (in this case vtable 128c) would be pushed back accordingly. The correspondingentries in vtabs 127 for the vtables subsequent to class "B" would thus also be updated to reflect this offset change. Changes in any of the class self data structures 126 themselves will be ~ c~ e~ in the context of Modifiers below.

A further advantage of this implemPnt~tit n is that a programmer can write Components as "C" functions, and MOM will treat these functions as methods of an inherited subclass. All the apparatus, as mentioned above, for m~int~ining this class hiel~clly is hidden to such programmers through function calls.

2. Component Method~.

On an object-oriented level, Components comprise a MOM class hierarchy.
The base Component class, n Component", provides for three m~n-l~tory methods:
(i) a creation/in~t~nti~tinn routine; (ii) a duplication routine; and (iii) a deletion 20 routine. The m~ , y methods are those which the core provides no default for,or for which the class would have no independent mt-~ning absent its own method.
In accordance with the object authoring interface discussed above, these would be invoked, for example, when: a Modifier is dragged from the Modifier 25 palettes 35a or 35b; an existing Modifier is selected and the "Duplicate" menu item is selectPd or the "Comm~nd-D" key sequence is typed; or, when an existing Modifier is selected and the "Delete" key is typed. The various Components are either direct subclasses of_Component, or themselves may form a hierarchy, such as the Messenger Modifier having as a subclass the If Messenger.

W O96/31822 PCTrUS96/04496 In addition to the m~n-i~tory methods listed above, a typical Modifier would include at least two more methods: (i) presenting the author with the Modifier's configuration settings; and (ii) committing the author's n~o-1ifi~tinns of those settings to memory. These would be invoked, respectively, when the author 5 double-clicked on the Modifier's icon to bring up the Modifier's dialog box, and when the author clicked the "OK" button in lieu of the "Cancel" button to save all author changes.

A representative sample of the virtual functions of_Component in the 10 current embodiment are described in Table IV as follows.

TABLE IV. BASE COMPONENT CLASS FUNCTIONS
Name Description CommPnt~
CompInit entry point to Component M~nr~tory methods methods (main function in C program).
CompCon~llucLo- Create Component.
CompCopyConstructor Duplicate Component.
CompDestructor Destroy Component.
CompEditorOpen Prepare for Modifier edit. Editor methods CompEditorAccept Commit edits to Modifier.
CompProcessMessage Act on message received. Message processing CompEventCount Query Component as to the number of events it responds to.
CompGetEvent Query Component as to a particular event it responds to.
CompSetEvent Set Component to respond to a particular event.
CompGetService Get pointer to Service. Service methods UIE S~ (!~UlE26) W O96131822 PCTnUS96104496 Name Desc~ ion Comments CompAddClient Register Component to Service.
Co ,mpDeleteClient Unregister Component from Service.
CompGetPIu~cl Ly Get stored Variable. Variable methods CompGetPropertyCount Get number of stored Variables.
CompSetPlupcl~y Store Variable.
CompGetSavelnfo Asks a Component what Save/Restore revision it is, and its size. methods CompRestoreComponent Restores the state of the Component as previously saved.
CompSaveComponent Saves the state of the Co~ ollel~l upon exiting application.
CompAddThread Adds a new thread for Thread methods executi~ n.
CompKillThread Deletes a given thread from further e~ecutic)n CompCalculateDrawParams Particular drawing Miscellaneous CompDrawDeviceContext functionalities, especially methods CompDrawMedia to alternate screen CompGetClipRegion, n GWorld n, CompGetMargins CompPostDrawMedia CompDrawGWorld CompPostDrawGWorld CompPreDrawWorld UltS~ UlE26) ~ ~ ~ -PCTrUS96/04496 W 096t31822 Name Dcs~ ion Comment.c CompEditorAcceptChanges Particular editor CompEditorDeclineChanges functionalities.
CompEditorIdle CompEditorltemAdjustCursor 5 CompEditorItemChanged CompEditorCustomDraw CompEditorCustomClick CompEditorltemTyping CompEditorltemTyping 10 CompEditorValidateChanges CompOpenMediaStream Access to particular location in file of stream created by another When a Component is first registered (as discussed below), a structure is created cont~ining any class-wide data (in C language syntax):

typedef struct {
struct** f_vtabs;
long* f_soffsets;
short f_cindx;
} MFCDRec;
where "f_vtabs" represents the pointer to the vtabs table, i.e. the table which points to all virtual tables, from which the class' virtual table may be derived;
"f_soffsets" is a table of offsets from the root of each self record in each of the 25 base classes; and "f_cindx" is the Component index, which is an index m~int~ined by the Component Manager 20 which allows the Component to access common information about such Component, such as its name. This structure is appended witn the in.ct~n~.e data.

An offset is used to allow for any changes in the size of structures of classes above it. Thus, tne offsets are calculated at registration time (described below), allowing pointers to be calculated up the class hierarchy through the f_soffsets table. lt should be noted that f_vtabs is ~ ign~-l at the end of W O96/31822 PCTnUS96/04496 registration, when the objects have been loaded and all offsets in vtable sizes have been adjusted accordingly.

In actuality, the embodiment of MFCDRec in the Apple Macintoshn' 68K
i S implement~tion contains one more structure member, "f_A4", which is a long integer. One drawback of tne 68K system is the inability of code resources to have their own globals, such as strings or initi~1i7e-1 variables. A normal application can have such globals, with register A5 pointing to the top of such global data. Thus, particular globals would be accessed via offsets with respect to AS.

Register A4 is used as the pointer to a code resource. Thus, if one code resource calls another's code resource, one could not know where that code resource's globals were, as there was no way of knowing what that code lS resource's A4 value was. Thus, dynamic loading on tne 68K could not include globals, unless one was prepared to save and restore A4 pointers each time one code resource called another.

In the present embodiment, the Component can store the A4 value as well as the slot number of the vtable methods. Thus, there is no need to bracket method calls from one Component to another which set up and restore the values for A4. Thus, a tral~.palelll mech~ni~m is provided to access globals within each Component.

An example of an in~t~nre data structure is presented in the case of a "gravity" Modifier, which would add "mass" to Elements, pru~l~plillg them to "fall" in the presence of the gravit~tiQn~1 "force," imp1emente~ as discussed below, through a Service. Thus, the structure for the instance data could be as described in Table V:

SUBSlllUlt S0EET (P~ULE~ 26) W O96131822 PCTrUS96/04496 TABLE V. SAMPLE INSTANCE DATA STRUCTURE
Member Submember Type Description f_enableEvent f_type short Specifies the enabling event.
f_event long f event_info long f_disableEvent f_type short Specifies the disabling event.
f_event long f_event_info long S f_mass f_type short Specifies the F.lemPnt's "mass".
f_value double f_lastvector f_type short Specifies the Element's "position".
f_angle double f_m~gnitll~le double f_pixelvelocity f_type short Specifies the F.lem-~nt's "velocity"
f value.PNTX short in pixels.
f value.PNTY short f_totalMoved PN'IX short Specifies the total displacement since the F.lement started falling.
PNTY short f_startTime --- long Specifies the time the Flempnt started falling.

For the class-wide data one could have simply (in C language syntax):

typedef struct {
double g_constant;
} MFClassRec, *MFClassPtr;
where g_constant is the ~vi~ ion~l nconstant," expressing the overall strength of the gravitational force. By making it class-wide data, one could then easily override this data (e.g., with the electrical "constant," turning the gravity Modifier 20 into an "electrical force" Modifier, the mass being replaced by electrical charge), yet leaving lm-lictllrbed all other mPrh~ni~m~ of the ~ viL~lional Modifier.

SUB~IIlul~SHE~ ~UlE26) -W O96/31822 PCT~US96tO4496 3. I~ lion Process.

Having explained what Components are and how they are createdt the process of se~mlessly integrating them into the system is now described.
In one embo~limlont of the invention, Components are loaded into the system at boot-up time. They are stored in "kits", special files cont~ining coderesources. In the Apple MacintoshTU 68K operating system, these code resources would be designated of type "XOBJ," each code resource ~ccessihle through its 10 identifir~tion number and name. In the Macintosh PowerPC~ system, they would be stored as code fragments. Under Microsoft Windows~, these kits would be dynamic-link libraries (DLL's) with a particular file extension, e.g. ".MOM."

The process by which each Co~ onellL becomes known to the core 99 is 15 called registration. Each Component is i(lrntifi~sl through a unique 16 character ID string. In one embodiment, this ID string is the numeric r~lc;se.lL~Lion of the exact time the Component was first created. The revision number of a particular Component is controlling in the event the application enco~ the same Component (as evirlPnr-ed by its ID string) among multiple kits. This is a very 20 useful feature in the event patch code, bug fixes or enhancements for such Component are provided. If the core 99 encoulllel~ Components with identic~l ID
string and revision numbers, then the system will retain the first one registered.

The actual registration or Component loading process is now described, 25 with reference to Fig. 31. The process, which starts at step 27S, first scans a directory or directories for kit files in step 276. In one emborlimrnt, tnis would be a special directory named "Resources" at the same level in the directory structure as the application. Next, all kit files are identifir-d at step 277. The file types for the various platforms provide the identifying merh~ni~m as discussed 30 earlier. The total number of Components is determined in step 278. Then, u~ @UlE 26) W O96/31822 PCTrUS96/04496 allocating the tables for accomodating all the Components counted is done at step 279.

Steps 280-283 represent a sul,~Luces~ which loops, in three passes, through each of the kits i~ ntifiP~l at step 277 above. In step 280, the system initi~li7es the self records for each Component from the given kit, based on the Component's stored values for the sizes therefor and its class structure order. In step 281, the system initi~li7es each of the methods for each Component as nt-cç~s~ry, i.e.
filling in the methods that are being overridden by such Component. In step 282,the virtual tables and vtabs table are created, with slot numbers inserted into the virtual tables, and actual sizes of self records established by walking up the chain of the real self records in the class hierarchy. The decision at step 283 determines whether the process should loop back to process further kits. Otherwise, the process termin~tes at step 284.
It can thus be understood, as an additional advantage, how this object model compensates for platform migration in that readjustments are made in the structure offsets that owe to the difference in byte ~lignments in data structure packing on one platform as co~ ~ed with another.
4. Core and Service Utilities.

Services can be thought of as providing two basic types of functions: (i) as a repository of common fhnrtion~lity that can be ~rc.-c~e~l by different Modifiers;
and (ii) as a server, by which various subscribed client Components are serviced.
However, Modifiers as well as Services could be configured as servers, clients or both.

An example of the former would be a Service performing common housekeeping functions, or a library of m~fhem~tie~l or string functions. An example of the latter would be a collision Service f~at needs to know where all rbl~SE~p~UlE~6) W O9~/31822 PCTnUS96/04496 F.lemPnt~ are positioned in order to decide whether any two F.lement~ have collided. The collision Messenger is the client of the collision Service for an Element that desires to be informed of collisions.

The C~raphic Modifier, for example, requires no Service to provide color to its parent Element. However, if one wanted to ensure that the colors of all on-screen objects do not "clash", one might write a "fashion" Service that monitored all such colors and informed an "enh~nred" Graphic Modifier of a clash.

One advantage of delçg~ting a lot of functionality to a Service is that it keeps the Modifier's size down, certainly a concern when Modifiers will be multiply inst~nti~t.o~. Another advantage of being a Service is that it may be ler~;lellced in Modifier methods by name when set up to be a server, rather thanapplying slot numbers through vtables to be ~rceese~-As was seen above, Modifiers and Services interact in a very simple manner. Modifiers may be "users" of a particular Service. Therefore, they must notify the Service when to add or delete them from the list of active users thereof.
For example, to write a gravitational Service, one must take into account how all objects with "mass" interact with one another, and so such a Service must know which Elements are "massive", i.e. contain a gravitational Modifier. Thus, the gravitational Service, knowing all the masses and positions, can apply the law of gravitation to change the position~ of each massive Element according to the time slice involved. The List class, which m~int~in~ a dynamic list of clients, wouldreflect the active "users" or clients of the ~,ldviLalional service.

As ~ cu~se-1 above, the class structures and registration processes are entirely analogous for Services as they were for Modifiers. In fact, the only distinction between Services and Modifiers, from a data structure viewpoint, is that a Modifier has a flag set which in~ tes that it should be added to a Modifier Palette 35a or 35b, while a Service has this flag clear.

?-S~ ult~ (RUL~26) W O96/31822 PCTrUS96/04496 While Modifiers may be multiply inst~nti~te~ as the need arises, it would be atypical that a Service be inst~nti~te~i more than once. A notable exception would be to in~t~nti~te a "GWorld," an offscreen graphics world, as often as needed, especially for applications that are very graphics-intensive.
Referring once more to Fig. 26, one can see that the inst~nti~te~ Services 168, 169 and 170 (again represented by double rectangles to signify their special class nature) are ~ccesse~l through service wrappers 165, 166 and 167, respectively. The Services are thus referenced through a list 164, preferably 10 m~int~in~fl by the Service rnanager 23.

Because Services are not part of the Behavioral Hierarchy and are not visible to authors (as are Modifiers), they need not m~int~in the same pointers linking them together. In essence, they are independent objects called upon by 15 Modifiers for support.

The MOM architoct--re above permits many modules inside the core 99 to be migrated easily into Components. For example, there is nothing to preclude the media player classes 12, the draw engine for the rendering manager 14, the 20 memory manager 17, the file I/O for the object loader 16 or the ~i~t~h~e management system for the asset manager 7 from being implemented as a Service rather than being in the core 99. Thus, if one needed to scale up the system to handle an enormous number of objects, one could replace the ~l~t~h~e system of the asset manager 7 with a heavy-duty relational ~i~f~h~e system.
D. Examples.

Now that the functionality of an embodiment of the present invention has been explained, the true power of this invention, with respect to its ease of design 30 and reusability, can be illustrated through particular working examples.

u~ S~ 6) -W O 9~/31822 PCTnUS~ I9 1. Snake.

This example serves to demo,.slldLe how "Hierarchical Relative Positioning" and Relative Targeting of messages can be used to great advantage in producing a ch~in~c~ object whose overall motion is complicated, yet is achievedby simple motion and coordination between adjacent links in the chain.

In this example, illustrated in Fig. 32, an implementation of a snake is explained. In the layout view window 320, one notes five ovals representing the segments of the snake (SnakeHead 450, SnakeMiddle (1) 460, SnakeMiddle (2) 470, SnakeMiddle (3) 470 and SnakeTail 490). One may note that each segment has a Graphic Modifier, respectively 4~1, 461, 471, 481 and 491, that can be configured with a distinct color for eye-pleasing effect.

With respect to the Structural Hierarchy, SnakeHead 4S0 is the parent of SnakeMiddle (1) 460, which in turn is the parent of SnakeMiddle (2) 470, which in turn is the parent of SnakeMiddle (3) 470, which itself is the parent of SnakeTail 490. Thus, in accordance with Hierarchical Relative Positioning, movement by SnakeHead 4S0 is "added" to that of SnakeMiddle (1) 460, both of which "add" to the motion of SnakeMiddle (2) 470, and so on, until SnakeTail 490is at the mercy of the motion of all its ances~ls.

Each of SnakeMiddle (1) 460, SnakeMiddle (2) 470, SnakeMiddle (3) 470 and SnakeTail 490 is equipped with an identically configured Full Motion Modifier, respectively parts 462, 472, 482 and 492. Each has a path that consists of a sixteen step arc which starts from the horizontal baseline (where the segment is lined up with its parent), takes four increments to rotate 45~ about its parent, eight more to bring it to -45~ of its parent, and then four more increments back to the baseline. These motions are out of phase in order to avoid the cllm~ tive curling that could rotate the snake into a circle!

ul~SHEF~UIE~) -Thus, timer m~engers are placed on each of these segmt~nt~, respectively 463, 473, 483 and 494. Each is set to delay for one-half second and then transmit a "PreviousLinkStarted" message to its parent, with the c~cc~e option turned off.
With each of these segments triggered to start its Full Motion Modifier upon 5 receipt of this same message, it is clear how a half-second time lag in the motion builds up in the snake. Notice that by turning off the c~ç~ option, the middle segmPnt~ are not confused by the message they sent and the message they received, even though named identically for reusability. It is clear that one could use different names for each segm~nt's commllnic.~ti--n with the following one.
10 Yet, one of the strengths of this design, its reusability, shows that one could add an indefinite number of "SnakeMiddle" segments and the snake would still work.

It is important to provide a mec-h~ni~m to start the wriggling process.
Thus, a Messenger 492 sitting on the SnakeTail 490 acts as a ~ietectc-r, waiting for 15 a MouseDown event on that segment (as if one stepped on the snake). This Messenger 492 is programmed to send the PreviousLinkStarted message to SnakeTail 490 itself, thus "faking" the propagation of this message from a non-L~ segment behind.

On the SnakeHead 450, the Previoll~r ink~Started message is i,lL~ el~d dirr~lell~ly. Rather than triggering an arcing motion, it triggers the SnakeHeadMotion 453 vector motion Modifier, which causes the entire snake to propagate in the direction of SnakeHeadVector 452. Thus, once the whole snake starts wriggling, it can start actually moving ahead. A Boundary Detection Messenger 455 detects whether the snake hits a wall, triggering a WallHit message which disables SnakeHeadMotion 453 and causes SnakeHit Sound 454 to echo the event.

It is clear that this design is very much an abstraction of a snake.
Certainly, one could replace the ovals and arc motion with separate mToon sequences showing each snake segment swaying back and forth, each out of phase W O96/31822 PCTrUS96/04496 but joining smoothly with the adjacent segment so that it looks like one continuous snake. This would certainly build very easily on the architecture provided.
~ .
2. Fi~h.
,, 5 This example serves to illustrate how an object may encapsulate differing Behaviors which are in colllpelilion with one another, yet coordinate with similar objects to produce a global or "collective" Behavior. In this example, illustrated in Fig. 33, an implemPnt~tion of a school of fish is explained. In the layout view window 320, one notes three fish 360, 400 and 440 in Scene-A 350. The Graphic Modifier 356 is present simply to give the a4ualiulll a pleasant sea color.

Before procee-ling further into the implement~tion, it is useful to consider the physical model upon which this example is based. Fish have a tendency to school. Thus, there must be a certain probability that a fish, seeing another fish proceed in one direction, will follow that other fish. On the other hand, fish may spontaneously change direction. This may be due to the perception of a threat, food, another fish appro~hing too close, sheer caprice, etc. Thus, these two tendencies, to school or to change direction, are in tension with one another.
Furthermore, if a fish is constrained to an aquarium, it must at some point reverse direction, otherwise it will crash into a wall. For simplicity's sake, the speed, though not direction, of each fish is constant.

Each of these fish 360, 400 and 440 is an mToon Element with an i(lentic~l Behavioral Hierarchy, hence personality. Thus, the representation of the Behavioral Hierarchy from Modifier 361 through 398, contained in fish 360 and seen in'the structure view window 330 is the same for fishes 440 and 440. Each fish has four Behaviors: StayInTank 370, Trend-Setting Behavior 380, Schooling Behavior 390 and ChangeVector 395. Most of these Behaviors, as will be seen, are driven by the Tick Messenger 366, which is like the "heart beat" of the fish, sen-ling out a "Tick" message once per second.

S~ ultSHEr(RU~E26) W O 96131822 PCTrUS96/04496 There are two vector Variables (MyVelocity 362 and NewVelocity 363) which respectively define the fish's present and future h~ings. The actual motion is performed by the Vector Motion Modifier 365, which is keyed to MyVelocity 362. The Drag Motion Modifier 364 is simply there to allow the user to drag the fish around at will during Runtime. Finally, the T~an~ lL Graphic Modifier 361 is there to give the bach~,luulld of the mToon the a~lu~iulll color.

There are some ~ignifir~nt Variables placed at the Scene level which govern overall fish behavior: SchoolingProbability 351, SwitchProbability 352 and MaxSwitchAngle 355. These could probably be incorporated into the fish so that one could have different types of fish with slightly different swimming characteristics. SchoolingProbability 351 is the probability a fish will follow another, given its hP~ling. SwitchProbability 352 is the probability that a fish will strike out on its own new h~ rling. MaxSwitchAngle 355 defines a m~imllm change in angle if a fish does strike out on its own. Thus, if MaxSwitchAngle 3~;5 was equal to forty-five degrees, then the new h~ ing of the fish would be within i45~ of its original hP~1ing. Two less .~ignifir~nt Variables, TopBottom 353 and LeftRight 354, are simply used as mnemonics for whether a fish has reached the vertical or hc,lizc,ll~l constraints of the tank, respectively.
The StayInTank 370 Behavior constrains the fish to stay in the tank. Thus, TB Border Detection Messenger 371 and LR Border Detection Messenger 372 respectively detect whether the fish has reached the vertical and hol izo~ l borders of Scene-A 350. When either happens, the respective Messenger would send a HitBorder message to the fish, with data equal to the values of TopBottom 353 orLeftRight 354, respectively. The BounceOffBorder 373 Miniscript Modifier, based on a HitBorder message, executes the following script:

if incoming = TopBottom then set NewVelocity.angle to (360-MyVelocity.angle) else if incoming = LeftRight then set NewVelocity.angle to (180-MyVelocity.angle) ~U~IIlult SHEE~ ~JIE26) PCTrUS96/04496 end if send "ChangeVector" to F~lempnt Thus, the new hP~riing is a reflection off the a4ua~iull. wall of the present h.o~rling, S and such new he~-iing is commllnir~tçd to the fish. A BounceSound 374 sound Modifier, triggered also by the HitBorder message, is added for extra effect.

The Trend-Setting Behavior 380 implements how a fish strikes out on its own. The if Messenger DecideToRandomlySwitch 381, triggered every time the lO Tick message is received from Tick Messenger 366, sends a message SwitchDirection to the Element when the SwitchProbability 352 PX~ee-l~ a random number from 1 to 100. The miniscript Modifier InvokeRandomDirection 382, triggered by the SwitchDirection message, executes this script:

set NewVelocity.angle to (MyVelocity.angle + rnd(2*MaxSwitchAngle) -MaxSwitchAngle) send "ChangeVector" to FlemPnt Thus, the new he~-1ing varies from the present ht-~-ling by as much as 20 MaxSwitchAngle 355, and such new h~-lin~ is commlmi~tP~ to the fish.

The Schooling Behavior 390 implements the tçn~l~Pnry to conform. It is premised on the fact that each fish would notice the h~ling of other fish in theschool. To simlll~fç this, each fish broadcasts to Scene-A 350 a "MyHeading"
25 message with the actual vector MyVelocity 363 as data. It is triggered upon the receipt of the Tick message, plus an ~ ition~l time delay, via t_e DelayedMyHç~-lingRroadcast timer Messenger 392. This delay ~im~ tPs a "reaction time" for the other fish. By virtue of the broadcast to Scene-A 350, each fish will get this MyHeading message. This triggers the Schooling Decision 30 391 miniscript:

if rnd(99) < SchoolingProbability then set NewVelocity.angle to incoming.angle end if SUBSIllultS0EEl (RUIE26) CA 022l7342 l997-lO-03 W O96~18i2 PCT/U~ 96 send "ChangeVector" to FlemPnt=~

Thus, the new h~ing will be equal to the hP~ing of the other fish that sent the MyHeading message, with such new h~ing comml-ni-~tP~l to the fish.
S
The ChangeVector 39~ behavior actually implements a change in he~-ling, based on the ChangeVector message issued by any of StayInTank 370, Trend-Setting Behavior 380 or Schooling Behavior 390. It çx~cutes the following miniscript Modifier 398 script:

if NewVelocity.angle < 0 then set NewVelocity.angle to (360 + NewVelocity.angle) end if if ((NewVelocity.angle > 90) and (NewVelocity.angle <270)) then set FlemPnt range to LeftCelRange else set Flement range to RightCelRange end if set MyVelocity.angle to NewVelocity.angle NewVelocity 363 is first colle~;led to be within 0 to 360 degrees. Then, the script determines whether the new hP~rlin~ is directed to the left, in which case a left-swimming range of ~nim~tinn cels of the mToon specified by LeftCelRange 396 is used; otherwise, the right-swimming range, RightCelRange 397 is used. Finally, the NewVelocity 363 is committe-l to the fish's actual velocity, MyVelocity 362.
It is clear that this fish could be improved by allowing for a more continuous range of ~nim~tiQn cels based more closely on the fish's h~ lin~, andthis can certainly be done in a straigl,lrcl~.l fashion. One could also have 30 schools form into "superschools," where each fish has a fictitious parent, its school, which itself has a he~tling, say the average hP~riing of all fish in theschool. The school would then broadcast to other schools. Thus, each school might influence the other schools to follow them, though with less probability than one fish within a school influences a sibling school member. This would allow a 35 lot of the mPrh~ni~mc built into the fish to be recycled at the school level. If one SUBSIllultSHEr (RUlE26) W O 9G~1822 PCTnUS96/04496 were ~iiCc~ticfiP~i with this fiction of the school parent, one could simply build a more complex schooling behavior into the fish, such as being influenced less by the hr~-lin~c of more distant fish than closer ones. The possibilities are certainly endless.

3. Wind~ System.

This final example illustrates how the present invention provides selective reusability of object containers in new environments. As was discussed earlier, 10 the difficulty of "mixing and m~trhing" objects across different environments is a filn-l~mrnt~l limit~tiQn of convention~l OOP systems.

This example presents two similar, yet distinct, implemrnt~tinns of simple windowing ~y~lellls created with an embodiment of the present invention. Each 15 system develops complex functionality in a modular manner. The example then illustrates how easily individual modules of one system can be reused in the environment of the other system, with little or no effort (much less progr~mming) on the part of the author.

The example intentic)n~lly mimics the public data structures and methods likely to be present in a traditional OOP implement~tion of a similar system (such as the windowing system described earlier with respect to the background of thisinvention). In this manner, the rlictinrtions between the interdepen~rnrirs of classes in an OOP class hierarchy and this system's isolation of an object container's dependencies on its external environment, should become quite evident.

With reference to Figs. 34(a)-34(g), this example will now be ~iiccllcse~l in detail. A bevelled window 2100 with title bar 2120, labelled "Window X," is shown in Fig. 34(a). It can be analogized to the public interface to the base class of the window class hierarchy described above. Analogizing to a derived class, a W O96/31822 PCTnUS96/04496 minimi71- box 2240 is added to the bevelled window 2200, with title bar 2220, asillustrated in Fig. 34(b). Clicking on the minimi7e box 2240 reduces the window 2200, together with the title bar 2220, to a small icon (not shown). Finally, dragging capability is added, again analogous to a derived class from a minimi7.o S class which in turn was derived from the bevelled window class. In this regard, bevelled window 2300 can be dragged on display 3 by clicking and dragging a mouse 6 on title bar 2320.

The alternative windowing system, illustrated in Fig. 34(d), inrlu-ies a simple window 2400 (no bevel) with title bar 2420, labelled "Window X"' to denote its pedigree separate from "Window X". In lieu of the minimi7e capabilityof the first windowing system, a "window shade" capability is added to window 2500 with title bar 2520. Double clicking this title bar 2520 causes the window 2500 to be hidden, reducing the display 3 area taken up by the window by an al~ la~ e means to icon minimi7~tion.

In Fig. 34(f), the bevelled window 2600, with title bar 2620, operates with functionality from both systems. The window 2600 may be dragged around freely via title bar 2620 as in the initial system, but the minimi7e capability has been replaced with the "window shaden feature from the second system.

Finally, Fig. 34(g) shows the full hybridi_ation of the two systems. The minimi7e capability is added back in, in addition to the "window shade" feature.Bevelled window 2700 may be dragged around by its title bar 2720, minimi7.-rl toan icon by clicking on minimi7.- box 2740, and may be "drawn up" in shade fashion through a double click on title bar 2720.

All features continue to operate in their new ellvhulllllent, with very little integration required beyond simple interface issues. The isolation of dependencies at each step of the process are of particular interest.

SUB'illluitSHEI (RUE2~) W O 96/31822 PCTrUS96/04496 The implement~tion of these windowing systems is described below in detail with reference to Figs. 3~(a)-3S(g). Apart from the purely structural Elements of Project "WlNDOW Example" 2000 (namely Window Section 2010, Window Subsection 2020, Window Shared Scene 2030 and Window Scene 2040), Window X 2100 (illustrated in Fig. 3S(a)) cont~in~ various Modifiers analogous to the "public interface" of an OOP class.

For example, the name of Window X 2100 is stored in string Variable Modifier Name 2101. The coordinates of its bounding rectangle are stored in Point Variable Modifiers BonnllingRect_TopLeft 2102 and Bol]nflingRect 2103, while Grapbic Modifier 2104 provides its color, and Image Effect Modifier 210S
its bevelled appearance.

Miniscript Modifier "CREATE Window" provides a function akin to a creation or initi~li7~tion method which often is e~ocllte~ at the bepinnin~ of the Scene 2040:

set position.x to Bolln-lingRect_TopLeft.x set position.y to Bolln-lingRect_TopLeft.y set height to Bolln-lingRect_BottomRight.y -Bo In-lingRect_TopLeft.y set width to Bolln-lingRect_BottomRight.x -Bolln~lingRect_TopLeft.x 25 The position of Window X 2100 is set to the bounding rect~ngl~'s upper left-hand corner, and it's dimensions are set by the bounding rectangle's height and width.

The title bar "TitleBar" 2120 is a child of Window X 2100, and it too has a "public interface" co~ lised of point Variable Modifiers TitleRect_TopLeft 30 2123 and TitleRect_BottomRight 2124, which form the bounding rect~ngle of title bar 2120, with Text Style Modifier 2121 which sets the title's font size and style, a Graphic Modifier 2122 which sets its foreground and background colors (black and white, respectively).

S~ ult ~~

W O96131822 PCTrUS96/04496 The Miniscript Modifier "CREATE TitleBar" 2125 is the creation "method" for TitleBar 2120 and is executed at the beginning of Scene 2040.

set text to Name set TitleRect_TopLeft.x to 0 set TitleRect_TopLeft.y to 0 set TitleRect_BottomRight.x to Bolln~lingRect_BottomRight.x -Bollnr~ in~Rect_TopLeft.x set TitleRect_BottomRight.y to 20 set position.x to (TitleRect_TopLeft.x+TitleRect_BottomRight.x-width)/2 set position.y to (TitleRect_TopLeft.y+TitleRect_BottomRight.y-height)/2 The text of TitleBar 2120 is set to Name 2101. The bounding rectangle of the title "area" is set to the top 20 pixels of Window X 2100, and the position of the lS TitleBar 2120 is centered within such bounding rectangle. Thus, the non-functional appearance of window 2120 in Fig. 34(a) is obtained.

Minimi7ç box "MinBox" 2240, illustrated in Fig. 35(b), is then added to window ~Window X + MinMax" 2200 with TitleBar 2200. The functions of all 20 Modifiers 2201-2206 and 2221-2225 are identical to the corresponding Modifiers 2101-2106 and 2121-2125, and thus need not be repeated here.

However, both window "Window X + MinMax" 2200 and TitleBar 2226 have identir-~l (in this example, aliased) versions, respectively 2207 and 2226, of 25 Behavior Modifier MinMaxResponse. Its purpose will be understood in conjunction with a description of MinBox 2240. It too has a public interface comprised of a Boolean Variable Modifier MinFlag 2243 (which in-lic~tPs whether the window 2200 is minimi7Pcl or not), point Variable Modifiers BoxRect_TopLeft 2244 and BoxRect_BottomRight 2245 (which define the bounding rect~ngle of 30 MinBox 2240), MinICONDimPn~ ns 2246 and the height and width of the minimi7P~l icon, the Image Effect Modifier 2241 (which gives MinBox 2240 a bevelled appearance when clicked on), and Graphic Modifier 2242 (to set its color.

S~IIIIJI~ SI~EEr (RUI~ 26) W O 96131822 PCTrUS96/04496 Miniscript Modifier "CREATE MinBox" 2247 initi~ s MinBox 2240 at the beginning of Scene 2040 as follows:

set MinFlag to false set width to 20 set height to 20 set BoxRect TopLeft.x to Bolln-lingRect_BottomRight.x -Bollnr~ingRect TopLeft.x - width set BoxRect_TopLeft.y to 0 set BoxRect_BottomRight.x to BoxRect_TopL,eft.x + width set BoxRect BottomRight.y to BoxRect_TopLeft.y + height set position to BoxRect_TopLeft set MinICONDimensions to (40,40) 15 M[inBox 2240 is initially m~ximi7ed (as in-lic~t~ l by the flag being set to false), 20 pixels on a side, at the upper right hand corner of window 2200, with an iconized state of 40 pixels on a side.

Min~R~oh~vior Modifier 2248 controls the minimi7in~ operation.
20 Receipt of a mouse down within the bounding rect~ngle of MinBox 2240 causes Miniscript Modifier DetectMinBoxSelect 2249 to be executed:

set MinFlag to not MinFlag send "MinBoxActivated" with MinFlag to element's parent The state of MinFlag 2243 is toggled and the message "MinBoxActivated" is sent, along with the new state of MinFlag 2243, to the parent of MinBox 2240, in a Relative Targeting fashion. This turns out to be the window 2200 itself. ~hus, this message triggers the two in.~t~nres of MinMaxResponse 2207 and 2226 on 30 window 2200 and TitleBar 2200, respectively.

As seen under MinMaxResponse 2207, this aliased Behavior has two If Messenger Modifiers under it, "Max Response" 2208 and "Min Response" 2209.
They each command the Element to be shown or hidden. Thus, window 2200 and 35 Ti~leBar 2200 will either reappear or disappear when the MinBox 2240 is clicked.

SHEF ~RIIIE26) CA 022l7342 l997-lO-03 W 096131822 PCT/U~ 96 The receipt of the message "MinBoxActivated" by MinMaxBehavior 2248 causes Miniscript Modifier "MinMax Response" 2250 to be invoked:

if incoming = true then set width to MinICONDimensions.x set height to MinICONDimensions.y set position.x to - (element's parent.position.x) set position.y to scene.height - element's parent.position.y -MiniCONDimensions .y else send "Scene Started" to element end if If MinFlag 2243 is true (as tne incoming data), MinBox 2240 is minimi7Pcl 15 by setting its dimensions to the icon dimensions MinICONDimensions 2246, and is placed in the lower left hand corner of Scene 2040 (including calculations of the relative coordinates of Parent window 2200). If MinFlag 2243 is false, a "Scene Sl~rted" Ellvhollluent Message is sent to the F.lemrnt, which is a shorthand way to rei~voke the initi~li7~tion Miniscript Modifier "Create MinBox" 2247.
The window "Window X + MinMax + Drag" 2300 adds tne dragging functionality to TitleBar 2320. MinBox 2340 is a passive beneficiary of this dragging ability by virtue of its status as a child of window 2300, tnus being dragged due to Hierarchical Relative Positioning. Its implemrntati~ n is identical 25 to MinBox 2240 (inrhl-ling all its contained Modifiers), and thus need not berepeated again. Also, Modifiers 2301-2307 and 2321-2326 are i(lentir~l to Modifiers 2201-2207 and 2221-2226 (including any contained Modifiers), respectively, and need not be described again.

The dragging ability is implemrnt.-ll through TitleBar DRAG Behavior 2327. Had TitleBar 2320 been the parent of window 2300 instead of its child, Hierarchical Relative Positioning would have h,.ntllecl the movement of window 2300 ~ULo~ r~lly~ In any event, upon receiving a mouse down within TitleBar 2320, Messenger MouseDown 2329 sends a TitleBarMouseDown message to its ~ lultS~ UIE26) W O 96/31822 PCTnUS96/04496 Element's parent, namely window 2300. Si~nilarly, a successive mouse up event will cause the TitleBarMouseUp message to be tr~ncmitttod to window 2300. A
mouse down also invokes the Miniscript Modifier CalcMouseOffset 2330, which c~lrul~t~os the offset, stored as point Variable MouseOffset 2328, between the 5 mouse down and window 2300 positions.

set MouseOffset to mouse - element's parent.position.
Timer Messenger TitleBarMouseTracking 2331, which is respectively 10 enabled and disabled by mouse downs and mouse ups, loops repeatedly with no tirne delay (mP~ning no delay within the limits of idle cycling) and sends the message TitleBarMouseTracking with MouseOffset 2328 as data.

The l!lhllaly purpose of the TitleBar Drag Behavior 2327 is to invoke the 15 Window Drag Behavior 2308 between the TitleBarMouseDown and TitleBarMouseUp messages, through its Follow Mouse Miniscript Modifier 2309, whose simple script is as follows:

set position to mouse - incoming.
Thus, resetting the position of window 2300 in accordance with MouseOffset 2328 (which was passed as data) brings the window 2300 into tne position it would have been had it been dragged directly via a Drag Motion Modifier.

Fig. 35(d) introduces the implementation of the alternative windowing system, namely that built upon Window X' 2400. It is virtually i~lentir.~l to Window X, particularly with respect its use of Modifiers Name 2400, Bol-n-lingRect_TopLeft 2402, Bolln-lin~Rect_BottomRight 2403, Graphic Modifier 2404, CREATE Window 2405, as well as Modifiers under TitleBar 2420. The 30 sole difference is the lack of Image Effect Modifier 2105, and thus no beveling, as ilhlstrated in Fig. 34(d).

Sll~lllUltS~ (RUlE26) W O96131822 PCTrUS96/04496 The window "Window X' + WindowShade" 2500 introduces the "window shade" feature, as seen in Fig. 35(e). Modifiers 2501-2505 and 2521-2525 are f~mili~r inc~h~lalions of previous windows and need not be described again. The window shade feature is implemented through WinSh~ Rehavior 2526 which S relies on Window Win~h~le Response 2506. Thus, Boolean Variable Modifier Win.~h~leFlag 2527 stores the window shade "state" (up=true, down=false) of window 2500, with Miniscript Modifier INITFlag 2529 simply initi~li7ing this state to false.

The invocation of the window shade feature is accomplished by a double mouse click on TitleBar 2520. The DetectDoubleClick Behavior 2530 detects a double mouse click. An INITFlag Miniscript Modifier 2532 sets a Boolean Variable Modifier ClickFlag 2531 to false at the beginning of Scene 2040. Upon the rletecti~n of a Mouse Up event inside TitleBar 2520, the MouseUpResponse 15 Miniscript Modifier 2533 is run with the following script:

if ClickFlag = true then set WinShadeFlag to not WinShadeFlag send "WindowShadeActivated" with WinShadeFlag to element's parent set ClickFlag to false else set ClickFlag to true end if Thus, the state of ClickFlag 2531 is toggled. If it was true, the state of WinShadeFlag 2527 is toggled and sent with message "WindowShadeActivated" to window 2500. Click Timer 2534 tracks the m~imllm length of time allowed in between single clicks of a double click, and is also invoked by the Mouse up event 30 inside TitleBar 2520. When Clock Timer 2534 times out, it sends the message SingleClick, which invokes the SingleClick Miniscript Modifier 2535 which sets ClickFlag 2S31 to false. In other words, if MouseUpResponse 2533 is not invoked before SingleClick 2535 is triggered, then the WindowShadeActivated message will not be sent.

blt SDEr Ql!JIE 26) W O96131822 PCTrUS96/04496 The WindowShadeActivated message is received by the "WINDOW
Win.Sh~-leResponse" Behavior 2S06, which either triggers the If Messenger "ShadeDown Response" 2507 which comm~n~lc the window 2500 to show or the If ~l~s~Pngto-r "ShadeUp Response" 2508 which comm~n~ the window 2500 to hide, 5 depending on the state of WinShadeFlag 2527 (tr~n~mitte~ as data).

Finally, WinShade Sound 2528 provides a "window ch~-ling" sound effect, invoked when the TitleBar 2520 itself receives the WindowShadeActivated message, regardless of the state of WinShadeFlag 2527.
Fig. 35(f~ illustrates how easily the minimi7ing feature in window 2300 can be replaced by the window shade feature from window 2500 and integrated into window "Window X + WindowShade + Drag" 2600, despite the fact that they come from two different environments (analogous to two different "class 15 hierarchies").

"WINDOW Win.~h~leResponse" 2607 replaces MinMaxResponse 2307, WinSh~PRehavior 2626 replaces MinMaxResponse 2326 within TitleBar 2620, and MinBox 2340 is removed. All other Modifiers (2601-2606, 2608, 2621-2625 20 and 2627) continue to operate as do their coullLel~;~L~ in the previous windows.
And the window 2600 somehow just "works".

Though it utilizes MinBox 2340, Window 2600 (including its Window Drag Behavior 2308 and TitleBar Drag Behavior 2327) was not dependent on the 25 ~ ence of MinBox 2340. The fact that messages no longer cascade down to a MinBox does not affect the operation of the window, unlike the situation in which an OOP superclass is replaced, causing its tightly coupled former subclass to "break" in an effort to locate the mi~sing (inherited) methods and data structures.
Even had an explicit reference to a MinBox Modifier been left behind, this 30 windowing system would not break. The affected Modifier would simply stop working until this dependency was i~lentif~ and resolved (a task that still would W O 96131822 PCTrUS96/04496 not require the author to have access to the private data structures or methods of any object).

Fig. 35(g) shows how a window ALL 2700 could in fact incorporate both 5 the r~lules of window 2300 and 2500, i.e. have the window shade as well as the minimi7-- feature. With co~ uisoll to window 2600 in Fig. 35(f~, the MinMaxResponse 2707 has returned under window 2700, as has MinMaxResponse 2726 under TitleBar 2720. MinBox 2740 has been reintroduced, though with the addition of a "MINBOX Win~hadeResponse" Behavior 2749 iclentie~l in function 10 to the Window Win~h~.oReponse 2708. All Modifiers 2701-2706, 2708, 2709, 2721-2728, and 2741-2748 again operate as do their cuunl~ . in previous windows.

In summary, this example illustrates the modularity of the Flempnt~ and 15 Behaviors of the current invention. In one respect, these object containers are quite independent of one another, relying on message broadcasting within the relatively narrow confines of the Structural and Behavioral Hierarchies. Adding a new Behavior from a foreign ellviloml~ent often requires either no additional work or the relatively simple integration of a copy of an exi~ting Behavior within an20 exi~ting Flem~-nt Even where dependencies exist, they are evident from the surface (i.e., the configuration of the Elements and Modifiers being transferred), as opposed to being inextricably inL~;l Lwilled with their former container ellvholllllents, which often requires recompilation, access to third-party source code and, nltim~tely~ fairly extensive progr,.mming.
2~
Although the invention has been described in detail with reference to its presently pler~;lled embodiments, it will be understood by one of oldh~y skill in the art that various mo-lifit~ti~ ns can be made, without departing from the spirit and the scope of the invention. Accordingly, it is not intended that the invention 30 be limited except as by the appended claims.

S~ lllUlt SHEr Q~

Claims (53)

We claim:

1. An application development system comprising:
(a) a first class of Element objects from which one or more Elements can be instantiated, the class defining a first set of characteristics inherent to eachElement object in the class;
(b) a second class of Modifier objects from which one or more Modifiers can be instantiated, the class defining a second set of characteristics inherent to each Modifier object in the class;
(c) a first hierarchical linking mechanism that allows an author to link a firstinstantiated Element from the first class as a parent to a first instantiated Modifier from the second class, the first instantiated Element attaining the second set of characteristics while the Element and Modifier remain linked; and (d) a second hierarchical linking mechanism that allows an author to link the first instantiated Element as a parent to a second instantiated Element from thefirst class, the first instantiated Element providing an environmental frame of reference for the second instantiated Element and the first instantiated Modifier, but not attaining the second set of characteristics.

2. An application development system comprising:
(a) a first class of Element objects from which one or more Elements can be instantiated, the first class defining a first set of characteristics inherent to each Element in the first class;
(b) a second class of Modifier objects from which one or more Modifiers can be instantiated, the second class defining a second set of characteristics inherent to each Modifier in the second class;
(c) a third class of Element objects from which one or more Elements can be instantiated the third class defining a third set of characteristics inherent to each Element in the third class;
(d) a first hierarchical linking mechanism that allows a first Element instantiated from the first class to be linked to a first Modifier instantiated from the second class, the first Element providing an environmental frame of reference for the first Modifier, and attaining the second set of characteristics, while the first Element and first Modifier remain linked; and (e) a second hierarchical linking mechanism that allows the first Element to be linked to a second Element instantiated from the third class, the first Element providing an environmental frame of reference for the second Element while the first and second Elements remain linked, whereby the system allows for the creation of an object hierarchy.

3. The application development system of claim 2 wherein the first and third classes are equivalent.

4. An application development system comprising:
(a) a first set of Elements sharing in common a first set of characteristics inherent to each member in the first set of Elements;
(b) a second set of Modifiers sharing in common a second set of characteristics inherent to each member in the second set of Modifiers;
(c) a third set of Elements sharing in common a third set of characteristics inherent to each member in the third set of Elements;
(d) a first hierarchical linking mechanism that allows a first Element from the first set of Elements to be linked to a first Modifier from the second set of Modifiers, the first Element providing an environmental frame of reference for the first Modifier, and attaining the second set of characteristics, while the firstElement and first Modifier remain linked; and (e) a second hierarchical linking mechanism that allows the first Element from the first set of Elements to be linked to a second Element from the third set ofElements, the first Element providing an environmental frame of reference for the second Element while the first and second Elements remain linked, whereby the system allows for the creation of a hierarchy of Elements and Modifiers.

5. The application development system of claim 4 wherein the first and third sets of Elements are equivalent.

6. The application development system of claim 2, 3, 4 or 5 wherein:
(a) the first Element's set of characteristics includes a current position of the first Element;
(b) the second Element's set of characteristics includes a current position of the second Element; and (c) the environmental frame of reference provided by the first Element is manifested at least in part by a Hierarchical Relative Positioning mechanism that determines the current position of the second Element relative to the current position of the first Element.

7. An application development system comprising:
(a) a first class of Element objects from which one or more Elements can be instantiated, the first class defining a first set of characteristics inherent to each Element in the first class;
(b) a second class of Modifier objects from which one or more Modifiers can be instantiated, the second class defining a second set of characteristics inherent to each Modifier in the second class; and (c) a hierarchical linking mechanism that allows an author to link a first Element instantiated from the first class to a first Modifier instantiated from the second class the first Element attaining the second set of characteristics while the first Element and first Modifier remain linked, whereby the system allows a form of object-based authoring by enabling the modification of the behavior of an object without modifying the system's underlying class hierarchy.

8. An application development system comprising:
(a) a first set of Elements sharing in common a first set of characteristics inherent to each member in the first set of Elements;

(b) a second set of Modifiers sharing in common a second set of characteristics inherent to each member in the second set of Modifiers; and (c) a hierarchical linking mechanism that allows an author to link a first Element from the first set of Elements to a first Modifier from the second set of Modifiers, the first Element attaining the second set of characteristics while the first Element and first Modifier remain linked, whereby the system allows the behavior of an Element to be modified.

9. The application development system of claim 7 or 8 wherein:
(a) the first Element's set of characteristics includes a current position of the first Element that is visually perceptible to a user of the system; and (b) the first Modifier's set of characteristics includes the ability to detect when the current position of the first Element crosses a predetermined boundary.

10. The application development system of claim 7 or 8 wherein the first Modifier's set of characteristics includes the ability to detect a collision between the first Element and another Element.

11. The application development system of claim 7 or 8 wherein:
(a) the first Element constitutes a first object container containing the first Modifier while the first Element and first Modifier remain linked; and (b) the system can discern automatically dependencies of that first object container.

12. The application development system of claim 11 wherein:
(a) the first Element's set of characteristics includes a current position of the first Element;
(b) the system further comprises a relative positioning mechanism that determines the current position of the first Element relative to a current position of an ancestor Element of the first Element; and (c) the dependencies of the first object container include the current position of the first Element.

13. The application development system of claim 11 wherein:
(a) the system further comprises an object configuration and messaging mechanism that allows the first Modifier to be configured to perform an action in response to the receipt of a specified message; and (b) the dependencies of the first object container include the specified message to which the first Modifier is configured to respond.

14. The application development system of claim 11 wherein:
(a) the system further comprises Variable Modifiers having a third set of characteristics inherent to each Variable Modifier, the third set of characteristics including the ability to store data on behalf of an Element (b) the system further comprises an object configuration and variable scoping mechanism that allows the first Modifier to be configured to access a second Variable Modifier, provided that the second Variable Modifier stores data on behalf of the first Element or an ancestor Element of the first Element; and (c) the dependencies of the first object container include the data stored by the second Variable Modifier.

15. An application development system comprising:
(a) a first class of Element objects from which one or more Elements can be instantiated, the first class defining a first set of characteristics inherent to each Element in the first class;
(b) a second class of Modifier objects from which one or more Modifiers can be instantiated, the second class defining a second set of characteristics inherent to each Modifier in the second class; and (c) a hierarchical linking mechanism that allows a first Element instantiated from the first class to be linked to a first Modifier instantiated from the second class, the first Element providing an environmental frame of reference for the first Modifier while the first Element and first Modifier remain linked, whereby the system allows the behavior of an Element to be modified.

16. An application development system comprising:
(a) a first set of Elements sharing in common a first set of characteristics inherent to each member in the first set of Elements;
(b) a second set of Modifiers sharing in common a second set of characteristics inherent to each member in the second set of Modifiers; and (c) a hierarchical linking mechanism that allows a first Element from the first set of Elements be linked to a first Modifier from the second set of Modifiers, the first Element providing an environmental frame of reference for the first Modifier while the first Element and first Modifier remain linked, whereby the system allows the behavior of an Element to be modified.

17. The application development system of claim 2, 4, 15 or 16 wherein:
(a) the system further comprises a messaging mechanism that sends messages to Elements and Modifiers; and (b) the environmental frame of reference provided by the first Element is manifested at least in part by a Hierarchical Message Broadcasting mechanism that uses the messaging mechanism to broadcast a message sent to the first Element todescendants of the first Element.

18. The application development system of claims 2, 4, 15 or 16 wherein:
(a) the system further comprises Variable Modifiers having a fourth set of characteristics inherent to each Variable Modifier, the fourth set of characteristics including the ability to store data on behalf of an Element; and (b) the environmental frame of reference provided by the first Element is manifested at least in part by a Hierarchical Variable Scoping mechanism that renders data stored in a Variable Modifier on behalf of the first Element accessible to descendants of the first Element.

19. The application development system of claim 7, 8, 15 or 16 wherein:
(a) the first Element's set of characteristics includes a current position and agraphic representation of the first Element that are visually perceptible to a user of the system; and (b) the first Modifier's set of characteristics includes the ability to change the current position of the first Element over time.

20. The application development system of claim 7, 8, 15 or 16 wherein:
(a) the first Element's set of characteristics includes a graphic representation of the first Element that is visually perceptible to a user of the system; and (b) the first Modifier's set of characteristics includes graphic attributes thatalter the first Element's graphic representation.

21. An application development system comprising:
(a) a first class of Behavior objects from which one or more Behaviors can be instantiated, the first class defining a first set of characteristics inherent to each Behavior in the first class;
(b) a second class of Modifier objects from which one or more Modifiers can be instantiated, the second class defining a second set of characteristics inherent to each Modifier in the second class; and (c) a hierarchical linking mechanism that allows a first Behavior instantiated from the first class to a first Modifier instantiated from the second class, the first Behavior providing an environmental frame of reference for the first Modifier while the first Behavior and first Modifier remain linked, whereby the system allows a behavioral hierarchy of Modifiers to be created.

22. An application development system comprising:
(a) a first set of Behaviors sharing in common a first set of characteristics inherent to each member in the first set of Behaviors;
(b) a second set of Modifiers sharing in common a second set of characteristics inherent to each member in the second set of Modifiers; and (c) a hierarchical linking mechanism that allows a first Behavior from the firstset of Behaviors to be linked to a first Modifier from the second set of Modifiers, the first Behavior providing an environmental frame of reference for the first Modifier while the first Behavior and first Modifier remain linked, whereby the system allows a behavioral hierarchy of Modifiers to be created.

23. The application development system of claim 21 or 22 wherein:
(a) the system further comprises a messaging mechanism that sends messages to Behaviors and Modifiers; and {b) the environmental frame of reference provided by the first Behavior is manifested at least in part by a Hierarchical Message Broadcasting mechanism that uses the messaging mechanism to broadcast a message sent to the first Behavior to descendants of the first Behavior.

24. The application development system of claim 21 or 22 wherein:
(a) the system further comprises Variable Modifiers having a fourth set of characteristics inherent to each Variable Modifier, the fourth set of characteristics including the ability to store data on behalf of a Behavior; and (b) the environmental frame of reference provided by the first Behavior is manifested at least in part by a Hierarchical Variable Scoping mechanism that renders data stored in a Variable Modifier on behalf of the first Behavior accessible to descendants of the first Behavior.

75. The application development system of claim 7, 8, 15, 16, 21 or 22 wherein the second set of characteristics includes the ability to send a message to another Modifier.

26. An application development system comprising:
(a) a first class of Element objects from which one or more Elements can be instantiated, the first class defining a first set of characteristics inherent to each Element in the first class;

(b) a second class of Modifier objects from which one or more Modifiers can be instantiated, the second class defining a second set of characteristics inherent to each Modifier in the second class;
(c) a third class of Behavior objects from which one or more Behaviors can be instantiated, the third class defining a third set of characteristics inherent to each Behavior in the third class;
(d) a fourth class of Modifier objects from which one or more Modifiers can be instantiated, the fourth class defining a fourth set of characteristics inherent to each Modifier in the fourth class; and (e) a hierarchical linking mechanism that allows:
(1) linking of a first Element instantiated from the first class to a first Modifier instantiated from the second class and a first Behavior instantiated from the third class; and (2) linking of the first Behavior to a second Modifier instantiated from the fourth class, wherein the first Behavior attains the fourth set of characteristics while the first Behavior and second Modifier remain linked, and the first Element attains the second, third and fourth sets of characteristics, while the first Element, first Behavior and first and second Modifiers remain linked, whereby the first, second, third and fourth sets of characteristics define the first Element's personality.

27. An application development system comprising:
(a) a plurality of object classes from which one or more objects can be instantiated, each class defining a set of characteristics inherent to each object in that class; and (b) a hierarchical linking mechanism that allows:
(i) creation of a first object container by linking an instantiated first object having a first set of characteristics to an instantiated second object having a second set of characteristics, wherein the first object provides an environmental frame of reference for the second object while the first and second objects remain linked;
(ii) creation of a second object container by linking the second object to an instantiated third object having a third set of characteristics, wherein the second object provides an environmental frame of reference for the third object while the second and third objects remain linked; and (iii) replacement of the second object with an instantiated fourth object by breaking the links between the second object and the first and third objects, and establishing corresponding links between the fourth object and the first and third objects, such that the first object provides an environmental frame of reference for the fourth object, which in turn provides an environmental frame of reference for the third object, while the first, third and fourth objects remain linked, whereby the system allows for selective reusability of an object container and the objects it contains.

28. The application development system of claim 27 wherein the first, second, third and fourth objects are Elements.

29. The application development system of claim 27 wherein the first and second objects are Elements, and the third object is a Modifier, and wherein thesecond object attains the third set of characteristics while the second and third objects remain linked.

30. The application development system of claim 27 wherein the first object is an Element, the second object is a Behavior and the third object is a Modifier, and wherein the first object attains the second and third sets of characteristics while the first, second and third objects remain linked.

31. The application development system of claim 27 wherein the first and second objects are Behaviors, and the third object is a Modifier, and wherein the first object attains the second and third sets of characteristics while the first, second and third objects remain linked.

32. An application development system comprising:
(a) a plurality of object classes from which one or more objects can be instantiated, each class defining a set of characteristics inherent to each object in that class; and (b) a hierarchical linking mechanism that allows creation of:
(i) a first object container by linking an instantiated first object having a first set of characteristics to an instantiated second object having a second set of characteristics, wherein the first object provides an environmental frame of reference for the second object while the first and second objects remain linked; and (ii) a second object container, replacing the first object with an instantiated third object having a third set of characteristics, by breaking the link between the second object and the first object, and establishing a corresponding link between the second object and the third object, such that the third object provides an environmental frame of reference for the second object while the objects remain linked, whereby the system allows selection of a new object container for an object.

33. The application development system of claim 32 wherein the first, second and third objects are Elements.

34. The application development system of claim 32 wherein each of the first and third objects is either an Element or Behavior, and the second object is either a Behavior or Modifier.

35. The application development system of claim 32 wherein the dynamic object configuration and hierarchical linking mechanism allows configuration of the second object such that the replacement of the first object with the third object occurs dynamically, at runtime, upon the occurrence of a specified condition.

36. The application development system of claim 32 wherein the hierarchical linking mechanism further includes a touch-up mechanism that, upon the replacement of the first object with the third object, automatically identifies and resolves dependencies of the first, second and third objects.

37. The application development system of claim 36 wherein the dependencies include a current position of the first and third objects.

38. The application development system of claim 36 wherein the dependencies include a Variable accessed by the second object.

39. The application development system of claim 36 wherein the dependencies include a message to which the second object responds.

40. The application development system of claim 36 wherein:
(a) the dependencies include a first asset constituting a dependency of the second object and a second asset constituting a dependency of the third object, the system referencing each of the first and second assets both by a name and by a unique identifier; and (b) the touch-up mechanism, upon the replacement of the first object with the third object, resolves name and unique identifier conflicts by:
(i) replacing the unique identifier of the first asset with the unique identifier of the second asset, if the name of the first and second assets are equivalent; and (ii) assigning a new unique identifier to the first asset if the unique identifiers, but not the names, of the first and second assets are equivalent.

41. An application development system comprising:

(a) a plurality of object classes from which one or more objects can beinstantiated, each class defining a set of characteristics inherent to each object in that class;
(b) a hierarchical linking mechanism that allows creation of:
(i) a first object container, by linking an instantiated first object to an instantiated second object, wherein the first object provides an environmental frame of reference for the second object while the first and second objects remain linked; and (ii) a first object hierarchy within the first object container, by linking the second object to an instantiated third object, thereby creating a second object container wherein the second object provides an environmental frame of reference for the third object while the second and third objects remain linked; and (c) a Hierarchical Message Broadcasting mechanism that broadcasts a message sent to the first object container to the second and third objects contained within the first object hierarchy, whereby the system allows the broadcasting of messages within an object hierarchy.

42. The application development system of claim 41 wherein:
(a) the hierarchical linking mechanism further allows for linking of the first object to an instantiated fourth object, wherein the first object provides an environmental frame of reference for the fourth object while the first and fourth objects remain linked;
(b) the system further comprises an object configuration and messaging mechanism that allows the third object to be configured to send a message to a runtime object container that contains the third object when the message is sent at runtime; and (c) if the first object is a runtime object container of both the third and fourth objects, the message sent by the third object to the first object will be broadcast to the fourth object by the Hierarchical Message Broadcasting mechanism, whereby an object can be configured to send a message to another object by relatively targeting the lowest common ancestor of the two objects.

43. The application development system of claim 41 further comprising an object configuration and messaging mechanism that allows an object to be configured to send a message to a specified destination Element and limit its broadcasting, via the Hierarchical Message Broadcasting mechanism, such that themessage will not cascade to any Elements contained within the destination Element.

44. The application development system of claim 41 further comprising an object configuration and messaging mechanism that allows an object to be configured to send a message to a specified destination object and limit its broadcasting, via the Hierarchical Message Broadcasting mechanism, such that themessage will not be relayed beyond the first object configured to respond to themessage.

45. An application development system comprising:
(a) a plurality of object classes from which one or more objects can be instantiated, each class defining a set of characteristics inherent to each object in that class;
(b) a hierarchical linking mechanism that allows creation of an object containerby linking an instantiated first object to an instantiated second object, wherein the first object provides an environmental frame of reference for the second object while the first and second objects remain linked; and (c) an object configuration and messaging mechanism that allows configuration of the second object to send a message to a runtime object container that contains the second object when the message is sent at runtime, whereby the system allows the relative targeting of message destinations.

46. An application development system comprising:

(a) a first class of Element objects from which one or more Elements can be instantiated, the first class defining a first set of characteristics inherent to each Element in the first class;
(b) a second class of Modifier objects from which one or more Modifiers can be instantiated the second class defining a second set of characteristics inherent to each Modifier in the second class;
(c) a hierarchical linking mechanism that allows a first Element instantiated from the first class to be linked to a first Modifier instantiated from the second class, the first Element attaining the second set of characteristics while the first Element and first Modifier remain linked; and (d) a component API that allows:
(i) creation of a third class of Modifier objects, the third class defining a third set of characteristics inherent to each Modifier in the third class;
and (ii) integration of the third class of Modifiers into the system such that the hierarchical linking mechanism can be used to link the first Element to a second Modifier instantiated from the third class, wherein the first Element attains the third set of characteristics while the first Element and second Modifier remain linked, whereby the system's component API allows the functionality of the system to be extended.

47. The application development system of claim 46 wherein the third class is a subclass of the second class.

48. The application development system of claim 46 wherein:
(a) the system further comprises a fourth class of Modifier objects from which one or more Modifiers can be instantiated, the fourth class constituting a subclass of the second class and inheriting at least some of the second set of characteristics, and defining a fourth set of characteristics inherent to each Modifier in the fourth class; and (b) the component API further allows:
(i) addition of one or more methods and data structures to the second class, via the component API, without access to or recompilation of source code defining the second class, thereby defining a supplemental set of characteristics, in addition to the second set of characteristics, inherent to each Modifier in the modified second class; and (ii) integration of the modified second class of Modifiers into the system such that the hierarchical linking mechanism can be used to link the first Element to a third instantiated Modifier from the fourth class, wherein the first Element attains the supplemental set of characteristics, in addition to the fourth set of characteristics, while the first Element and third Modifier remain linked, whereby the system's component API allows the functionality of an existing superclass of the system to be extended.

49. An application development system comprising:
(a) a first class of Element objects from which one or more Elements can be instantiated, the first class defining a first set of characteristics inherent to each Element in the first class; and (b) a media linking mechanism that allows:
(i) linking of a first Element instantiated from the first class to a first media item having a first media data type, such that the first Element will take on the appearance of the first media item during runtime while the first Element and first media item are linked;
(ii) breaking of the link between the first Element and the first media item; and (iii) linking of the first Element to a second media item having a second media data type, such that the first Element will take on the appearance of the second media item during runtime while the first Element and second media item are linked, whereby the system allows an Element to be morphed among different media data types.

50. The application development system of claim 49 wherein the media linking mechanism further comprises an object configuration and dynamic linking mechanism that allows configuration of the first Element such that the system dynamically, upon the occurrence of a specified runtime condition, breaks the link between the first Element and the first media item and establishes a link between the first Element and the second media item.

51. An application development system comprising:
(a) a first class of Element objects from which one or more Elements can be instantiated, the first class defining a first set of characteristics inherent to each Element in the first class;
(b) a second class of Element objects from which one or more Elements can be instantiated, the second class defining a second set of characteristics inherent to each Element in the second class;
(c) a third class of Variable Modifier objects from which one or more Variables can be instantiated, the third class defining a third set of characteristics inherent to each Variable in the third class, the third set of characteristics including the ability to store data on behalf of an Element;
(d) an alias mechanism that allows an author to create an alias of a first instantiated Variable having a first value, from which aliased copies of the first Variable can be made; and (e) a hierarchical linking mechanism that allows an instantiated first Element from the first class to be linked to a first aliased copy of the first Variable, and to link an instantiated second Element from the second class to a second aliased copy of the first Variable, such that the first aliased copy of the first Variable stores the first value on behalf of the first Element, and the second aliased copy of the first Variable stores the first value on behalf of the second Element;

(f) wherein the alias mechanism causes any change at runtime to the first value stored by the first aliased copy of the first Variable to be reflected dynamically in the second aliased copy of the first Variable, such that the first and second aliased copies of the first Variable store the same value at any give time during runtime, whereby the system provides dynamically aliased Variables.

52. An application development system comprising:
(a) a first class of Element objects from which one or more Elements can be instantiated, the first class defining a first set of characteristics inherent to each Element in the first class;
(b) a media linking mechanism that allows an instantiated first Element be linked to to a first media item having a cel-based animation data format, such that the Element will take on the appearance of the cels of the first media item at aspecified animation rate during runtime; and (c) an object configuration and animation range selection mechanism that allows the first Element to be configured to play a specified range of cels of the first media item during runtime upon the occurrence of a specified condition, whereby the system allows dynamic changes to a portion of an animation that is played during runtime upon the occurrence of a specified condition.

53. An application development system comprising:
(a) a plurality of object classes from which one or more objects can be instantiated, each class defining a set of characteristics inherent to each object in that class; and (b) a hierarchical linking mechanism that allows creation of:
(i) a first object container in a first application, by linking an instantiated first object to an instantiated second object, wherein the first object provides an environmental frame of reference for the second object while the first and second objects remain linked;
(ii) a first object hierarchy within the first object container, by linking the second object to an instantiated third object, thereby creating a second object container wherein the second object provides an environmental frame of reference for the third object while the second and third objects remain linked; and (iii) a third object container in a second application, by linking an instantiated fourth object to an instantiated fifth object, wherein the fourth object provides an environmental frame of reference for the fifth object while the fourth and fifth objects remain linked; and (c) an object library mechanism that allows copying of:
(i) the second object container from the first application into a first object library upon breaking the link between the first and second objects;
and (ii) the second object container from the first object library into the second application, and linking of the fourth object using the hierarchical linking mechanism, wherein the fourth object provides an environmental frame of reference for the second object container while the second, third and fourth objects remain linked, whereby the system allows for selective reusability of object containers across applications.