WO2000068788A1 - Data modeling simulation - Google Patents

Abstract

A method and system for displaying a visual model on a display of a computer includes at least two computer program components that are stored on the computer. The functionality of and connectivity between these components can be defined using an authoring environment. The computer program components execute in conjunction with a network browser application and can be used to obtain data over a computer network from a data source, create a visual model representative of the data, display the visual model on the computer display, allow a user to interact with the visual model, and display a version of the visual model based on the user interaction. Additionally, the computer program components executing on one computer can enable a user of that computer to provide input to one or more of the computer program components executing on another computer by sending this input from one computer to another computer over a computer network.

Description

DATA MODELING SIMULATION

Technical Field

The present invention relates to the field of computer software and more specifically to network browser plug-in computer software used to create dynamic data modeling simulations and graphical animations.

Background Information Networks, such as the Internet, contain a large amount of information in many different formats. The available conventional tools for displaying data graphically in a network environment generally are difficult to use, and they do not allow users to become sufficiently engaged by the information to gain knowledge or understanding from it.

Summary of the Invention It is an object of the invention to provide a tool that effectively graphically displays complex data concepts and allows users to interact with the display so as to maximize the users' knowledge and understanding of, and engagement with the data.

In one aspect, the invention relates to a method of displaying a visual model on a computer screen. According to the method, a number of program components are stored on a computer. These components execute in conjunction with a network browser application. One or more of the components obtains data over a computer network from a remote data source. One or more of the components creates a visual model based on the obtained data. One or more of the components displays the visual model on the computer screen and enables a user of the computer to interact with the visual model by providing data input to the computer. After the user provides data input, one or more of the components modifies the visual model based on the data input and then displays it on the computer screen.

Embodiments according to this aspect of the invention can include the following features. Data can be obtained from one data source and additional data can be obtained from another data source and the visual model can be based on these two sets of data. The visual model can include a visual simulation based on the obtained data. The visual model can be animated. A user can specify a modification to the displayed model. The program components can be obtained over a computer network. The computer network can be a TCP/IP network. The - 2 - program components can be obtained from a computer disk. The browser application can be an HTML network browser. The program components can be defined to the browser application in an HTML document. One of the program components can be a controlling module that manages communication among components and between components and the controlling module. The controlling module can control the behavior of the program components. The process of controlling the program components can include synchronizing program components so that one program component performs a function based on an occurrence of an event produced by a function of another program component. The program components can be created using a common set of programming rules, which enables the program components to communicate with the controlling module and with each other. The user can interact with the visual model using a keyboard or a mouse.

In another aspect, the invention involves a system that provides additional functions to a network browser application executing on a computer. The system includes a number of program components. At least one of the program components is capable of obtaining data from a remote data source using a computer network. At least one of the program components is capable of obtaining data input from a user of the computer. At least one of the program components is capable of creating a visual model based on the data obtained from the remote data source. At least one of the program components is capable of modifying the visual model based on the input obtained from the user of the computer. The system also includes a controlling module that controls and directs each of the program components. The controlling module also communicates with the program components and with the network browser application.

Embodiments according to this aspect of the invention can include the following features. The controlling module can synchronize program components so that one program component performs a function based on an occurrence of an event produced by a function of another program component. The visual model can include a visual simulation based on the data obtained from a data source. The visual model can be animated. The data input obtained from the user of the computer can be a specification of a modification to the displayed visual model. The computer network can be a TCP/IP network. The program components can be obtained over the computer network. The network browser application can be an HTML network browser. The program components and the controlling module can be defined to the browser application in an HTML document. The data input obtained from the user of the computer can be keyboard or mouse input.

In yet another aspect, the invention features a method to create a computer program that displays a visual model on a computer screen. A user selects a number of program components in a graphical environment, and the user then uses connectivity functions to define connections and interrelationships between the selected program components. A computer file ultimately is created, and this file contains the user-defined connections and interrelationships between the program components. The file, together with the selected program components, defines the functionality of a computer program that is capable of obtaining data over a computer network, creating a visual model based on the data, displaying the visual model on a computer screen, allowing a computer user to interact with the visual model, and displaying a version of the visual model based on the user interaction.

Embodiments according to this aspect of the invention can include the following features. The connections and interrelationships between the program components can include synchronization between program components so that one program component performs a function based on an occurrence of an event produced by a function of another program component. The file with user-defined connections can contain HTML code that defines at least one of the program components to the browser application. The program components can be created using a common set of programming rules, which enables the creation of user-defined connections and interrelationships between the program components.

In still another aspect, the invention relates to a method of displaying a visual model on one computer based on data input obtained from another computer. According to the method, a number of program components are stored on a first computer and on a second computer. In general, the components on the first computer operate in conjunction with a network browser application executing on the first computer, and the components on the second computer operate in conjunction with another browser application executing on the second computer. One or more of the components on the first computer obtains data over a computer network from a remote data source, one or more of the components on the first computer create and display a visual model based on the data obtained from a remote data source. One or more of the components on the second computer obtain input from a user of the second computer and one or more of the components on the second computer send this input over the computer network to the first computer. One or more of the components on the first computer modify the visual model based on the input sent by the second computer and then display this version of the visual model on the first computer.

Embodiments according to this aspect of the invention can include the following features. The input sent to the first computer can include commands used to control at least one of the program components on the first computer.

The foregoing and other objects, aspects, features, and advantages of the invention will become more apparent from the following description and from the claims.

Brief Description of the Drawings In the drawings, like reference characters generally refer to the same parts throughout the different views. Also, the drawings are not necessarily to scale, emphasis instead generally being placed upon illustrating the principles of the invention. FIG. 1 is a schematic block diagram illustrating the interaction between a user of a computer connected to a network and program components executing in conjunction with a network browser application, in accordance with the invention.

FIG. 2 is a general schematic block diagram of a computer.

FIG. 3 A is a schematic block diagram illustrating the operation of components executing in conjunction with a network browser application according with the invention.

FIG. 3B is a schematic illustration of a screen representation of the operation of the components of FIG. 3 A.

FIG. 4 is a schematic illustration of the design structure of a controlling module and of a document file containing instructions used by the controlling module to control and communicate with components.

FIG. 5 is a schematic flowchart of an authoring system for generating a document file and an HTML document.

FIG. 6A is an example of a user interface screen of the authoring system of FIG. 5. FIG. 6B is an example of a user interface screen of the authoring system of FIG. 5. FIG. 6C is an example of a user interface screen of the authoring system of FIG. 5.

FIG. 7 is a schematic flowchart of a method for designing and programming a component.

FIG. 8 is a schematic block diagram illustrating the communication between two users of two computers connected to a network who are accessing the same network page. FIG. 9 is a schematic block diagram of a user list maintained by a network server. Description The present invention employs one or more computer software components that execute together in conjunction with a network browser application executing on a computer. Together, the components can obtain input from a user of the computer and/or obtain data from another computer connected to the network, and display information on the display of the computer based on the user input and/or the data.

Referring to FIG. 1 , in one embodiment according to the invention, a user 50 is using a computer 10 on which a browser application 15 is executing. Typically, the browser application 15 is computer software installed on an industry-standard computer 10 operating under an industry-standard operating system such as Windows or Macintosh OS. Typically, the browser application 15 is an HTML browser, such as the Netscape Navigator or the Microsoft Internet Explorer. The computer 10 can be any general purpose computer, such as a PC or a workstation, running any one of a variety of operating systems.

Referring to FIG. 2, the computer 10, regardless of what type of computer it is, typically includes a central processor (CPU) 110, a memory 115 for storing programs and/or data, an input/output controller 120, a network interface 125, one or more input devices 130 such as a keyboard and a mouse, a display device 45, a fixed or hard disk drive unit 140, a floppy disk drive unit 145, a CD-ROM drive unit 150, and a data bus 155 coupling these components to allow communication therebetween. In general, one or more computer programs define the operational capabilities of the computer 10. Some or all portions of the programs can be loaded into the computer 10 via the hard drive 140, the floppy drive 145, the CD-ROM drive 150, and/or the network interface 125, and then those programs can reside in a temporary memory portion (e.g., RAM chips) of the memory 115. Some, all, or portions of the programs may reside alternatively in a permanent memory portion (e.g., a ROM chip) of the memory 115. In some other embodiments, the computer 10 can include specially-designed, dedicated, hard- wired electronic circuits which perform some or all of the functions described herein, with or without the need for instructions from computer programs.

Referring back to FIG. 1 , a controlling module 20 and a component 22 are computer program modules residing on the computer 10. The controlling module 20 controls components (e.g. the component 22) and directs the communication between and among the components. The component 22 is an instance created by a dynamic linked library (DLL) when the browser application 15 is running in a Windows environment, or an equivalent to a DLL when the browser application 15 is running in a non- Windows environment such as, for example, a Macintosh operating system. There can be an unlimited number of components and each component has a universally unique identity. Components can communicate with the controlling module and with other components. However, components do not need to contain programming logic that makes one component aware of another component. The communication among components and the communication between components and the controlling module is enabled according to the component programming rules described below with reference to FIG. 7. Thus, the controlling module 20 can control and communicate with any component created according to the invention, without requiring any modification to the programming logic of the controlling module 20.

A component can contain one or more item routines (e.g. item routine 60 or 65) and each item routine is a set of software instructions and data that enable the graphical representation of an item on a display (e.g. display 45). An item routine can also control the functionality of an item (e.g. item 61 or 66), such as, for example, the functionality enabling a user (e.g. user 50) to interact with an item. For example, an item may be an image of a bottle (e.g. item 376 in FIG. 3B) and a corresponding item routine is a set of software instructions and data necessary to render the image of the bottle on a display.

In the disclosed embodiment, an item routine 60, 65 may be invoked, for example, upon the execution of the browser application 15 or based on an occurrence of a specific event, such as when a user 50 clicks on or types in an item 61. 66 on a display 45. For example, clicking on a play button item (e.g. item 378 in FIG. 3B) invokes the item routine corresponding to the play button item, and the invoked item routine changes the play button to a pause button. Alternatively, if an item contains an input field, a user may invoke an item routine by, for example, typing in the input field of the item and pressing the Enter key on the computer keyboard. Alternatively, the item routine 60, 65 may have already been invoked by the time a user clicks on or types in the item 61, 66.

Components can be grouped into one or more of a plurality of categories, and these categories can include a data generator, data probe and data processor category, a user-interaction device category, an output-display category, and a specific-use category.

Components belonging to the data generator, data probe and data processor category are instances that perform data retrieval and manipulation, typically in an iterative manner. Components belonging to the user-interaction device category are instances that allow a user to interact with a browser application (e.g. browser application 15), typically by using an input device (e.g. input device 130 in FIG. 2) to click on or type in an item in a visual model (e.g. visual model 55) on a computer display. Components belonging to the output-display category are instances that display a visual model in a browser application on a computer display, where the generated visual model is typically associated with one or more outputs, such as items 61, 66, produced by a component belonging to the data generator, data probe and data processor category. Components belonging to the specific-use category are instances wherein a purpose- built DLL has been written - for example, a DLL which downloads data from a world wide web weather site and which utilizes the downloaded data to plot graphically a course of a hurricane. In the embodiment of FIG. 1, the component 22 obtains data, manipulates it, obtains input from the user 50, and generates the visual model 55. Therefore, according to the embodiment of FIG. 1 , the component 22 represents all four categories described above.

A computer (e.g. the computer 10) may obtain a controlling module (e.g. the controlling module 20) and one or more components (e.g. the component 22) from an external source, including an external disk (e.g. the disk 145), a CD-ROM disk (e.g. the CD-ROM disk 150) or a computer network (e.g. the network 25). Typically, the computer network is a TCP/IP network, such as the Internet, and the controlling module and components may be downloaded from another computer connected to the network. Typically, the controlling module and the components are written in an object-oriented programming language, such as, for example, C++ or Java. Components and the controlling module may be obtained by the computer all at the same time or at different times, and may be updated or replaced by other components at any time. For example, initially, new components and the controlling module may be loaded onto the computer from an installation CD-ROM disk and then new or existing components or the controlling module may be added or updated when the user accesses the Internet using a network browser application such as Netscape Navigator or Microsoft Internet Explorer.

The controlling module 20 and the component 22 are stored on the computer 10 on, for example, the fixed drive 140 (FIG. 2). After the user 50 executes the browser application 15 and the browser application opens an HTML document that references the controlling module 20, the browser application 15 executes the controlling module 20. The controlling module 20 is a computer program of the type known in the art as a plug-in to an industry standard browser such as, for example, Netscape Navigator or Microsoft Internet Explorer. The controlling module 20 manages the operation of all other components (e.g. component 22). The functionality of the controlling module 20 is described in more detail below with reference to FIGs. 3A, 3B and 4. Once executed, the controlling module 20 then executes one or more other components. In the embodiment depicted in FIG. 1 , the component 22 is a computer program module that is capable of accessing a computer network 25 and obtaining data from a data source 30 on the computer network 25. For example, the data source 30 may be a database of weather data located on a remote computer 27 that is connected to the network 25. The data source 30 may be accessed by using, for example, an SQL query, a proprietary database query, or by parsing information encoded in HTML. Once the component 22 obtains data from the data source 30, it retains the data locally as data 35 on the computer 10, for example by storing the data on a disk (e.g. disk 140 in FIG. 2) or retaining the data in memory (e.g. memory 1 15 in FIG. 2). In other embodiments, instead of being retained locally, the data is retrieved from the data source on an as-needed basis. In other embodiments, there may be multiple components each accessing a different data source, or there may be components that are individually capable of accessing more than one data source.

In the embodiment depicted in FIG. 1, once the data 35 is retained on the computer 10, the component 22 creates the visual model 55 based on and representative of the data 35. The visual model 55 contains two items 61, 66. The item 61 is generated by the item routine 60 and the item 66 is generated by the item routine 65. Thus, the component 22 employs item routines 60 and 65 to generate and display the visual model 55 on the display 45. In other embodiments, multiple components may generate multiple visual models based on multiple data sources. Furthermore, several components may be used in combination to generate one or more visual models. In other embodiments, several visual models may be displayed by any combination of several components and several visual models may be displayed by one component. The visual models are displayed on the computer display 45 within the browser application 15.

Once the visual model 55 is displayed on the computer display 45, the user 50 may interact with the visual model 55. Interaction with the visual model 55 may involve, for example, clicking on the visual model 55 using a mouse input device 130 (FIG. 2), or typing in an input field of the visual model 55 using a keyboard input device 130 (FIG. 2). By interacting with the visual model 55, the user 50 can change parameters that are used by the component 22 to create the visual model 55. The scope of these parameters can vary from one embodiment to another and depends on the logic of the computer software in the component 22. In other embodiments, there may be several visual models displayed by one or more components, and a user may be able to interact with more than one of these components. Thus, by changing a parameter in one component, a user may affect one or more visual models created by one or more other components. Once the user 50 interacts with the- visual model 55 and modifies the parameters used by the component 22 to create the visual model 55, the component 22 re-creates the visual model 55 based on the new set of parameters and then re-displays the new visual model 55 on the computer display 45. The user 50 may then continue to interact with the visual model 55, causing the component 22 to re-create the visual model 55 each time the user 50 causes a change to the parameters used by the component 22.

In the example depicted in FIGs. 3A and 3B, a computer program 320 according to the invention includes a group of components 324, 326, 328, 331 and the controlling module 20 executing in conjunction with the browser application 15 (FIG. 1). The execution of the controlling module 20 is governed by commands contained in a document file 450. The document file 450 is described in more detail below with reference to FIG. 4. The creation of the document file 450 is described in more detail below with reference to FIGs. 5 and 6A-6C. The component 324 belonging to the data generator, data probe and data processor category performs iterative calculations of the motion of a body in two dimensions according to a predetermined algorithm. The algorithm applies, for example, Newton's laws of motion to the body. An item routine 330 of the component 324 contains software instructions and data to render a pictorial representation of the motion of a body 333 (FIG. 3B) when the body 333 moves within a square enclosure 370. An item routine 334 of the component 324 contains several controls, typically in the form of a graphic representation of buttons 373, 374, 375 (FIG. 3B), whereby when the button 374 is selected a user can vary the position of the body 333 and when the button 375 is selected a user can vary the velocity of the body 333 on the display 45. Thus, the component 324, via its item routines 330, 334, may be utilized to simulate the motion of the body 333, and to represent the motion pictorially and graphically for different positions and velocities of the body 333.

A graphical component 331 belonging to the output-display category performs iterative calculations to generate a Cartesian graph. An item routine 332 of the component 331 is a set of software instructions and data for rendering a graphical representation of the Cartesian graph item 372. An animation component 326 belonging to the output-display category performs iterative calculations of a still graphic 376 to generate an animation, according to a predetermined algorithm. In the example depicted in FIGs. 3A and 3B, the algorithm employed in the component 326 is a method for rotating and/or repositioning the still graphic 376 according to data received from the controlling module 20. The data may be generated from any component operated by the controlling module 20. An item routine 336 of component 326 is a set of software instructions and data for rendering a pictorial representation of the graphic 376, as the calculations are performed. The item routine 336 further contains properties, such as variables representing position and size of the graphic 376, which are used by component 336 for generating an updated graphic 376 in an updated position on the screen. Thus, the component 326 and its item routine 336 may be utilized to generate an animation of the graphic 376.

The component 328 belonging to the user-interaction device category determines when the graphic representations which simulate controls for starting, stopping, and pausing the operation of the controlling module 20 are generated on the display 45. An item routine 338 is a set of software instructions and data for rendering a pictorial representation of a start icon item 378 (FIG. 3B) and a pause icon item, as are used in standard video recorders. An item routine 340 is a set of software instructions and data for rendering a pictorial representation of a stop icon item 380 (FIG. 3B). The item routines 338 and 340 further contain respective properties which are utilized by the component 328 for its operation. Thus, the component 328 and its item routines 338 and 340 may be utilized to simulate controlling the controlling module 20 using standard graphical icons as represented by the items 378, 380.

The algorithm in the item routine 330 of the component 324 generates successive positions of a body represented by the body 333, referred to herein as the item 333 (FIG. 3B), and these positions are read by the controlling module 20. In the following example, it is assumed that the item 333 moves only vertically. The algorithm in the item routine 330 (FIG. 3A) performs calculations simulating the item 333 (FIG. 3B) moving vertically up and down and bouncing off the horizontal walls of the item 370 (FIG. 3B). The controlling module 20 (FIG. 3A) transfers the values of the positions of the item 333 (FIG. 3B) to the component 331. The item routine 332 of the component 331 plots a graph of the vertical position of the item 333 versus time and represents this graph as the item 372. The controlling module 20 also transfers the values of the positions to the component 326. The item routine 336 of the component 326 performs the functions to rotate the item 376 so that it generally points towards the item 333. Typically, the motion of the body represented by the item 333, the plotting of the graph represented by the item 372, and the rotation of the body represented by the item 376, are started by a user clicking on the item 378, and stopped by a user clicking on the item 380, which clicking is read by the controlling module 20. Thus the controlling module 20 acts as a conduit, transferring data between and among the components 324, 326, 328, 331.

In the example depicted in FIG. 3A, the controlling module 20 executes instructions that it obtains from the document file 450. Based on these instructions, the controlling module 20 sends and receives data to and from components 324, 326, 328, 331. For example, one or more commands in the document file 450 may specify that the controlling module 20 should monitor for the component 328 to report a specific event, for example a mouse click on an icon, and, upon the occurrence of this event, to execute the item routine 332 of the component 331. Additionally, one or more commands in the document file 450 may specify that the controlling module 20 should monitor for the component 324 to report a specific event, for example a receipt of data from a data source and, upon the occurrence of this event, to send the data to the component 326 and to execute the item routine 336. Thus, the controlling module 20 continuously queries components 324 and 328 to discover whether either event occurred. If the component 324 reports that it received data from a data source, then the controlling module 20, per the commands in the document file 450, obtains this data from the component 324, sends it to the component 326 and then executes the item routine 336. Likewise, if the component 328 reports a mouse click, then the controlling module 20 executes the item routine 332 of the component 331. Additional commands in the document file 450 may, for example, specify how the controlling module 20 should respond with respect to the occurrence of events reported by any of the components 324, 326, 328, 331. By executing some of the commands in the document file 450 cyclically and by executing some of the commands in the document file 450 based on specific events, the combination of the controlling module 20 and the components 324, 326, 328, 331 achieve functional synchronization. Thus, the controlling module 20 and the document file 450 together provide a mechanism by which the components 324, 326, 328, 331 may be synchronized so that a function within one component is performed based on an occurrence of an event reported by another component. Referring to FIG. 4, which is a schematic illustration of the operating structure of the controlling module 20 and the document file 450, the controlling module 20 performs functions based on the commands contained in the document file 450. The document file 450 is a - 13 - computer file that is generated by the authoring system described below with reference to FIGs. 5, 6A, 6B and 6C. Based on the commands and information contained in the document file 450, the controlling module makes calls to components 324, 326, 328, 331 and receives data from these components. For example, the component 324 may be called HURRICANE and it may contain a pre-programmed function called GetData, which retrieves data from a data source. A command in the document file 450 may instruct the controlling module 20 to execute the function GetData by calling the component HURRICANE with a command instructing the component HURRICANE to execute the function GetData.

Typically, the document file 450 consists of an entry script 452, a loop script 454, and an exit script 456. Additionally, the document file 450 contains for each component 324, 326, 328, 331 a component information and script data block 460, 462, 464, 466. Each component information and script data block, such as 460, 462, 464, 466, contains information about a component, such as the name of the component, the location of the component, and the items within the components. Additionally, a component information and script data block may contain instructions that the controlling module executes when the corresponding component is invoked, known as component scripts and described in more detail below. In some embodiments, the component information element and the component script element of the component information and script data block are independent entities within the document file 450, while in other embodiments they reside in the same location within the document file 450. Unlike the component information and script data block, which is component- specific, the entry script 452, loop script 454 and exit script 456 are controlling module-specific. Thus, the instructions contained in the scripts 452, 454 and 456 are executed upon the invocation of the controlling module 20, regardless of whether any of the components 324, 326, 328, 331 are invoked. An entry script 452 contains commands which are executed by the controlling module 20 when the controlling module 20 begins operation. An entry script 452 can contain functions that must be executed as part of starting the controlling module 20. For example, the entry script 452 may have commands to set up variables and parameters that will be used by the controlling module 20 and by other components 324, 326, 328, 331 or to set up the graphical environment, such as the background color of the browser window on the display.

After the controlling module 20 executes the entry script 452 commands, the controlling module 20 executes the commands contained in the loop script 454. The controlling module 20 reads and acts upon the commands contained in the loop script 454 in a sequential fashion, until all the commands in the script have been completely executed, at which point script execution returns to the beginning of the loop script 454 and this process is repeated. The controlling module 20 continues executing the commands contained in the loop script 454 until the occurrence of an event that signifies that the execution of the loop script 454 should stop. An event that signifies that the execution of the loop script 454 should stop may be, for example, a user closing the browser application 15 (FIG 1).

While the loop script 454 is executing, one or more commands in the loop script 454 generates calls from the controlling module 20 to one or more components 324, 326, 328, 331, and the components 324, 326, 328, 331 generate one or more transfers of data to the controlling module 20 which are acted on by the controlling module 20 based on the commands in the loop script 454. The controlling module 20 obtains from the component information and script data blocks 460, 462, 464, 466 information about components 324, 326, 328, 331, which enables the controlling module 20 to communicate with the components 324, 326, 328, 331. This communication enables the controlling module 20 to monitor events reported by components 324, 326, 328, 331 and to send instructions and data to components 324, 326, 328, 331. For example, if a user clicks on an item controlled by the component 326, the component 326 reports this event to the controlling module 20. The controlling module 20 then executes any instructions that may exist in the component information and script data block 462. Information in the document file 450 also enables the controlling module 20 to identify other components that may be affected by the occurrence of this event, for example components 328 and 331 and reports the occurrence of this event to the components 328 and 331, causing components 328 and 331 to react to the occurrence of this event according to their programming logic. Thus, components can be synchronized so that one component performs a function based on an occurrence of an event produced or reported by another component, as is described in more detail above with reference to FIG. 3 A.

When the loop script 454 stops executing, the controlling module 20 performs the commands contained in the exit script 456, thereby invoking component functions used when the controlling module 20 ceases operation. The commands contained in the exit script 456 may request that the controlling module 20 executes component functions that perform, for example, general clean up such as closing files and windows, and releasing unneeded memory. AUTHORING SYSTEM

In order to enable users easily to define connections and interrelationships between components, an authoring environment is provided, in accordance with the invention. Referring to FIGs. 5 and 6A-6C, an authoring system 500 according to the invention is used to generate a computer file that contains and defines connections and interrelationships between components. That file is referred to herein as a document file. FIGs. 6A, 6B and 6C are examples of authoring system user interface screens. Typically, the authoring system 500 is used to generate document and HTML files which can be utilized by a browser application 15 (FIG. 1) in a run-time mode. Using the authoring system 500, a user can generate a document file (450 in FIG. 4) that specifies what tasks the controlling module 20 (FIGs. 1 , 3 A, 4) should perform and how it should control other components. As its final product, the authoring system 500 generates a document file (450 in FIG. 4) and, optionally, also an HTML file that enable all the components to communicate with the browser application 15 (FIG. 1).

In the authoring system 500, components (described above with reference to FIGs. 1, 3A- B, and 4) are stored in locations accessible by the computer on which the authoring system 500 is executing. These locations may be, for example, on a fixed drive, a CD-ROM, or on a network location. Components have common characteristics which identify them as components. For example, all components may use the same file naming convention, such as a .CMP file name extension. Alternatively, all components may reside in the same directory or in the same DLL library. In the authoring system 500, a list of components is accessed, typically by opening a component menu 630 in step 502. A component menu 630 may be opened, for example, by clicking an icon representing a component drop-down menu. The component menu 630 displays a list of available components 635. The list of available components may be compiled by examining one or more directories or locations on the computer and identifying components, for example based on their file name extension. One or more components is then chosen in step 504 from the list of components, for example by clicking on the component name on the list.

For each component, the authoring system 500 displays a list of item routine names 640 associated with the component. The names are as defined by the item routines contained in the components. Each item routine is represented by a graphical icon or symbol, referred to herein as an item. Items may be selected in step 506, for example, by using a mouse, and then dragged and placed anywhere on the screen in step 508 to generate a visual display of the items 645. A component can have one or more pre-defined functions and variables associated with it. For example, a component called HURRICANE that draws the path of a hurricane may have a function called PATH that receives from a data source the values representing the path of the hurricane and two variables called PATHX and PATHY that represent the horizontal and vertical location of the hurricane respectively. In the authoring system 500, these functions can be used to create connections and interrelationships between components. The functions are typically displayed via a dialog box accessed by selecting the Functions menu item 650 and the variables are typically displayed via a dialog box accessed by selecting the User Variables menu item 660. The dialog box is opened in step 510, for example, by clicking on an item 645 associated with the component whose function list the user wishes to access. Each dialog box typically provides access to one or more fields wherein the user can enter expressions so as to define the respective functions of the item. Typically, expressions that may be entered in these fields are chosen by clicking the field, which results in one or more expression dialogs being displayed, so that a list of available expressions is generated in step 512. The expressions generated in step 512 are dependent on the components chosen in step 504, and thus the list of generated expressions corresponds to the components chosen in step 504.

The authoring system 500 includes a set of commands that a user can employ to assign values to variables and to provide connectivity between components. The commands include Do Function, Set Variable Value, IF Then, Open URL, Beep, Set Step and mathematical expressions commands.

The Do Function command allows the user of the authoring system 500 to direct when a specific function is executed at run-time. For example, the user may wish for a function INIT of the component HURRICANE to execute immediately upon the invocation of controlling module 20. Thus, the first command specified by the user may be, for example, "Do Function HURRICANE. INIT". Alternatively, functions may be executed, for example, based on the occurrence of a specific event, as described in more detail below.

The Set Variable Value command allows the user of the authoring system 500 to assign a value to a variable of a component. The value may be set to a specific number, or to a number produced by a Mathematical Expression. For example, the expression "HURRICANE. PATHX = 5" assigns the number 5 to the variable PATHX of component HURRICANE. Alternatively, the expression "HURRICANE.PATHX = 5 * COMPONENT2.VARIABLEA" assigns the product of the number 5 and the value of variable A of component2 to the variable PATHX of component HURRICANE. Thus, the authoring system 500 allows components to be interconnected by assigning values based on variables of one component to the variables of another component.

The If Then command 670 allows users to define functionality that is triggered based on the occurrence of an event. For example, the following expressions assign the value of 0 to variables PATHX and P ATHY of component HURRICANE in the event that the value of PATHX is 5:

IF HURRICANE.PATHX = 5 THEN HURRICANE.PATHX = 0 HURRICANE.PATHY = 0 END IF

The Open URL command 675 enables the script to direct the network browser application to load a page from the specified URL address. For example, if the value of an END_OF_PROCESS variable is TRUE, then the browser can be directed to transfer control to a default address. The mathematical expressions commands can be used in conjunction with any variable or any expression, and include standard mathematical functions, such as addition, division, multiplication, and parenthesis nesting. For example, HURRICANE.PATHX = 5 + (12 * (HURRICANE.PATHY - 2)).

The Beep command produces a sound, so as to draw the run-iime user's attention to a particular event. In the following example, if the value of a variable is determined to be greater than 1000, the computer program sounds a beep and then displays an error message: If HURRICANE.PATHX > 1000 then Beep

Do Function HURRICANE.ERROR End If

The preceding example assumes that a function called ERROR is defined for the component HURRICANE.

The Set Step command specifies how often the controlling module 20 (FIGs. 1 , 3 A, 4) executes commands contained in the loop script (454 in FIG. 4), thereby determining the speed at which the controlling module 20 communicates with the other components. Using this command, the user of the authoring system 500 can control, for example, the speed of the animation produced by the computer program (320 in FIG. 3 A). A list of commands that affect the selected functions is generated by choosing expressions from the list of available expressions, via a decision step 514 and its associated loop- back. Once the commands have been completed, the expression dialog and the item dialog box are closed in a step 518. The steps 510 to 514 are repeated as required for other items chosen in the step 506.

Once the user of the authoring system 500 selects the appropriate components, functions and variables, and creates the appropriate links between the various components and variables, the authoring system 500 generates a document file (450 in FIG. 4) in step 520 containing all of the commands, expressions, definitions, and connections specified by the user. The document file may also contain information about every component chosen in step 504 and every item chosen in step 506. In one embodiment, for example, the authoring system 500 assigns a sequential hexadecimal number to each item chosen in step 506, which allows items to be referenced by corresponding hexadecimal numbers, instead of names.

After the document file is created in step 520, the authoring system 500 may also create an HTML document that contains commands and links that enable a browser application (15 in FIG. 1), the controlling module (20 in FIG. 1 ) and the components (22 in FIG. 1) to communicate with each other. An example of an HTML document created by the authoring system 500 is depicted in Table 1 below. The HTML document in Table 1 contains references to a controlling module called "SimPlayer," a document file called "car," and five items referenced as 00000003, OOOOOOOC, OOOOOOOE, OOOOOOOA, and OOOOOOOB. According to the example in Table 1, the HTML document references five instances of the controlling module "SimPlayer," where the controlling module is a plug-in to a network browser application and each instance of the plug-in represents a different item. Thus, the invention enables multiple instances of the same network browser plug-in to be used within the same network browser page. <HTML>

<SCRIPT LANGUAGE = "JavaScript"> theDate=new Date(); documentRID=/*theDate.getMilliseconds()+*/1000^:1:(theDate.getSeconds()+60^5l!(theDate.getMin utes()+theDate.getHours()*60)); function GetDocumentID()

{ return documentRID;

}

/* 4 child frame function GetDocumentID() { return parent.GerDocumentID();

}

*/ documentBase=self.location;

function GetBaseUrl()

{ return documentBase;

} /* 4 child frame

function GetBaseUrl()

{ return parent.GetBaseUrl(); } */

</SCRIPT> <!-- 4 Netscape ~>

<EMBED TYPE="application/x-SimPlayer#l " ACTBASE- "&{GetBaseUrl();};" ACTID="&{GetDocumentID();};" ACTNAME="car" HIDDEN=TRUE></embed>

<table width="540" border="0" height="200" cellpadding="0" cellspacing="0" vspace="0^M hspace=^M0"> <tr>

<td><embed type="application/x-SimPlayer#l " actbase= "&{GetBaseUrl();};" width=510 height=170 actid="&{GetDocumentID();};" actname="car" actitem="00000003"> </embed></td> <td><embed type="application/x-SimPlayer#l " actbase= "&{GetBaseUrl();};" width=31 height=171 actid="&{GetDocumentID();};" actname="car" actitem="0000000C'^*> </embed></td> </tr> <tr>

<td><embed type="application/x-SimPlayer#l" actbase= "&{GetBaseUrl();};" width=513 height=24 actid="&{GetDocumentID();};" actname="car" actitem="0000000E"> </embed></td> <td>&nbsp;</td>

</tr> </table>

<!-- 4 Netscape --> <!-- 4 Netscape --> <EMBED TYPE="application/x-SimPlayer#l " ACTBASE= "&{GetBaseUrl();};" width=34 height=34 ACTID="&{GetDocumentID();};" ACTNAME="car" ACTITEM="0000000A"> </embed> <!-- 4 Netscape -->

<EMBED TYPE="application/x-SimPlayer#l " ACTBASE= "&{GetBaseUrl();};" width=34 height=34 ACTID="&{GetDocumentID();};" ACTNAME="car^M ACTITEM-"0000000B"> </embed> <!-- 4 Netscape --> <!-- 4 Netscape --> <!-- 4 Netscape --> </HTML>

TABLE 1 - HTML document created by the authoring system of the invention. COMPONENT PROGRAMMING RULES

According to the invention, in order to enable components to be interconnected with each other, they must be programmed according to a specific set of rules. The set of rules must enable components to communicate with each other and with the controlling module using a consistent mechanism, commonly referred to as an application program interface (API), so that components programmed by different programmers may be used interchangeably within the computer program 320 (FIG. 3 A) with no additional modification. These rules allow the controlling module to direct and control any number of components without the necessity to program some components so that they are aware of other components within the computer program 320 (FIG. 3A). Furthermore, the programming rules must include rules that will enable the authoring system 500 (FIG. 5) to identify the functions, items, and variables within a component. In Java, for example, all of the functions, items, and variable definitions are located in the XML file, which is accessed by the authoring system 500 to obtain this information. In other languages, other mechanisms may be employed to specify this information, as is known in the arts. Typically, components are written in an object oriented language such as C++ or Java. While the following description refers to writing the components in Java, those skilled in the art will be able to write the components in other languages. Typically, a component is written by modifying an existing component project skeleton.

A component project skeleton typically includes, the source files for the support classes, the interface to other classes that bridge between Java environment and the software, and a complete example of a simple component. An example of the data structure of a component in Java programming language is shown in Table 2 below. <!DOCTYPE CO PONENTROOT PUBLIC "-Logal Param Descnptxon" "logal .dtd//paramlogal dtd"> <COMPONENTROOT>

<COMPDESC classname = "JStarterComponent" <'--The class name for the component --> name = "JStarter" <'--The component name --> defname = " avaStarterComponent" id = "JSTARTERID" <'--Unιque ID for the controlling module --> iconname = "itemicon.png ' <' --Image file for icon --> dialog = "true" <'-- Component has a dialog --> dialogclass = "JExampleDialog" > <'--the class that implements the dialog --> <ITE DESC <' --repeat th s section for each item --> itemdesc = "Simple Item" <' --Description --> itemID = "1" <<'' ----NNuummeeric ID for item --> itemicon = "itemicon png" <' --Image file for icon --> itemclass = "JItemStarter" > <' --Class name for this item ->

</ITEMDESC>

<ITEMDEΞC itemdesc = "Referenceltem" itemID = "2" itemclass = ¹¹JItemReference dialog = 'true" -21- script = "true" dialogclass "JRefItemProperties" ;/ITEMDESC> c/COMPDESC>

<PARAMDESC>

<PARAM <! --Repeat for each component parameter --> paramID = "Paraml" <'--ID (used in a controlling module expression --> paramDesc = "Parameter_l" > <' -description (used in controlling module popup menus - > </PARAM> <PARAM paramID = "Param2" paramDesc = "Parameter_2"> </PARAM> </PARAMDEΞC>

<COMMANDDESC>

<COMMAND <ι --Repeat for each script command - - > menuStrmg = "Set Color Control" <'-- command name --> commandstπng = "Set Color Control" <'-- command help text --> format = '"Set Color Control"©"Mιn wavelength"@DOUBLE@"Max wavelength"©DOUBLE®"Intensity"©DOUBLE¹

< ^! - -To understand better the format parameter open the SIMPLAYER control window, add the --> < i --Jstarter component, and look at its scripting commands---- commandID = "_."> <' --Numeric ID for the command -->

</COMMAND,- <COMMAND menuStrmg = "Command ₂" commandstnng = "Command 2 " format = ' "Test

Menu"©"Where "©POP | Sea, and, Borders, Cyties, Grid®"Color"©POP | Default, hite, gray, black, cyan, It blue, smoke blue, blue, yellow, cactus, green, row sienna, ark green, brown, orange, ed, dark red@"Redraw 0/l"@INT' commandID = " 2 " >

</COMMAND> <COMMAND menuStrmg "Command ₃ " commandstnng "Command 3 " format ' "PhotoSyn Test"@"Integer"@INT@"Text"@TEX ' commandID " 3 " > </COMMAND> <COMMAND menuStrmg "Command " commandstnng "Command 4" format ' "Color Test" "Coloi OLOR ' commandID "4"> </COMMAND> <COMMAND menuStrmg = " Command 5 " commandstnng = "Command 5" format = ' "Var Test". "Var"@VAR' commandID = " 5 " > </COMMAND> <COMMAND menuStr g "Test Execute Script" commandstnng "Test Execute Script" format ' "Test Execute Scπptt" ^■Item"@INT' commandID "6"> </COMMAND> </COMMANDDESC>

</COMPONENTROOT> TABLE 2 - Data structure of a component in Java programming language.

Referring to FIG. 7, which is a schematic flowchart of a method for designing and programming a component, in a Component Structure Design step 810, a programmer decides on one or more items to be included in a component, one or more input parameters, and one or more result parameters. A parameter is a block of data that is passed between a component and a controlling module (20 in FIG. 1) or between two components. Typically, the block of data is an array of alphanumeric values. Parameters can be used as input to a component and as output from the component.

In the Component Definition step 820, the programmer writes software instructions defining an interface between the component being designed and the controlling module (20 in FIG. 1), as well as the input and output parameters, and one or more component functions.

The Component Definition step 820 includes three definition sub-steps: General 822, Parameters 824, and Component Functions 826. In the General sub-step 822, the programmer codes general information about the component. Typically, general information includes a component class name which implements the component, where the class typically extends a

JComponent class. Additionally, the general information typically includes a component name, a component description, a component universally unique identity, and a definition of each item included in the component. An example of the data structure of a component is shown in Table 2 above in the <COMPDESC> section. For each item within a component, the item definition typically includes an item description, a universally unique identity, and an item class name. Typically, the item class implements the respective item and extends a JComponentltem class. An example of the data structure of an item is shown in Table 2 above in the <ITEMDESC> section.

In a Parameters sub-step 824, a parameter definition is written for each parameter used by components to communicate with other components and with the controlling module. Typically, each definition includes a unique parameter identity and a parameter description, as shown in Table 2 above in the <PARAMDESC> section.

In a Component Functions sub-step 826, a definition is written for each component function, which sets up a template for the script command. Typically, the definition includes a component function name, which is the name that appears in the component function menu described above with reference to FIGs. 5 and 6A. The definition for each component function further comprises a unique identity, and a command syntax. The command syntax defines a template of the component function described with reference to FIG. 5, and is described in more detail below. Typically, the command syntax includes one or more fields, and the fields are separated from adjacent fields by a pre-defined ASCII character such as an "@" character. A field may be, for example, a text string, an integer value field, a floating point value field, a popup menu field, or a color selection field. A component function can be formulated using one or more of these fields. An example of the data structure of a component function is depicted in Table 2 within the <COMMANDDESC> section.

In a Write Component Main Class step 830, the programmer implements methods that react to changes in values of respective parameters defined in the Parameters sub-step 824 and that output values of the respective parameters. The Write Component Main Class step 830 also includes implementing methods to perform a simulation step, most preferably by calling a method to pass updated values to the controlling module (20 in FIG. 1), wherein the controlling module (20) acts on the updated values to calculate an updated state of the visual model (55 in FIG. 1) and an updated presentation on the computer display (45 in FIG. 1). Additionally, the Write Component Main Class step 830 includes implementing methods for loading and saving data that is provided to the component by other components. Using the Java programming language, for example, the component main class extends the JComponent class.

A Write Item Classes step 840 includes implementing, for each item defined in the General sub-step 822, methods for handling a graphical user interface corresponding to the respective item. Using the Java programming language, for example, item classes extend the JComponentltem class. Since the JComponentltem class is a subclass of the Applet class, each item is written in substantially the same manner as a Java Applet, as is known in the art. Thus, functions performed within item classes include handling GUI events, displaying graphics, and defining sub-views. Each item must be defined in the properties list and the definition must include the class name, so that the definition can be instantiated automatically by the controlling module (20 in FIG. 1). All classes and properties must be placed into a single JAR file.

In a Write References step 850, communication is enabled between the component being written and the controlling module, or between the component being written and another component. Typically, communication is enabled using a JExpressionRef and/or a JComponentRef class.

A component, written as described above with reference to FIG. 7, may be interconnected with other components using the authoring system described above with reference to FIGs. 5, 6A-6C. The syntax and template defined in the Component Definition step 820 for any of the component functions or parameters are used by the authoring system to enable the user to define connections and interrelationships between components. IDENTIFICATION COMPONENT

The present invention enables network users to communicate with other network users using program components referred to herein as identification components. Additionally, the identification components allow one user to interact with the components that are executing on another user's computer by sending locally entered data to the components executing on a remote computer. Referring to FIGs. 8 and 9, which are a schematic block diagram illustrating the communication between two users of two computers connected to a network who are accessing the same network page and a schematic block diagram of a user list maintained by a network server respectively, two users 952 and 982 are interacting with components 958, 960, 988, 990 and with controlling modules 956, 986, all of which are executing in conjunction with a network browser application 954, 984. The interaction of a user with components executing in conjunction with a browser application is described in detail above with reference to FIGs. 1, 3 A and 3B.

The two users 952, 982 are accessing the same URL location 971 via a network 25. A network server 972 maintains a user list 974. The user list 974 contains information about users who have registered with the network server 972 by providing registration information to the network server 972. A user may register with the network server, for example, when the controlling module (20 in FIG. 1) is first installed on the user's computer (10 in FIG. 1) or by accessing via the network 25 a registration page on the network server 972. For each registered user, the user list 974 consists of a unique identifier, such as, for example, the user's IP address or a user-supplied user name. The user list 974 may also include additional information about the user, such as a user nickname, address, telephone number, age, and data about user preferences. In addition, the user list 974 contains information for each user specifying the network URL address or location that the user is currently accessing, if that URL address or location contains an identification component. For example, the user list 974 depicted in detail in FIG. 9, shows four registered users 952, 982, 946, 948, and specifies that the registered users ^' 952 and 982 are both accessing the same URL called "WWW.NETWORKADDRESS.COM". The entry for the registered user 946 does not specify a URL address or location, signifying that the registered user 946 is either not currently accessing the network 25 or not currently accessing a URL address or location that contains an identification component.

Referring to FIG. 8, the two users 952 and 982 are respectively using the browser applications 954, 984 to access the same URL address 971. For example, each user 952, 982 is accessing the "WWW.NETWORKADDRESS.COM" URL. The URL 971 accessed by the users 952, 982 contains information and program components including a component 960, 990, an identification component 958, 988, and a controlling module 956, 986 that is substantially identical to the controlling module 20 described above with reference to FIGs. 1, 3 A and 4. Since both users 952 and 982 are accessing the same URL 971 , all elements of the URL 971 that are accessed by user 952 are identical to all elements of the URL 971 that are accessed by user 982. Therefore, the components 958, 960 and the controlling module 956 executing in conjunction with the browser application 954 are identical to the components 988, 990 and the controlling module 986 executing in conjunction with the browser application 984. All communication between components and the network server 972, according to the invention, are performed via the network 25. When the user 952 accesses the URL 971, the identification component 958 determines a unique identifier for the user 952 and sends a message to the network server 972. This message contains the unique user identifier and the URL 971 address that the user 952 is accessing. Based on this message, the network server 972 updates the user list 974, so that the user list 974 contains information specifying that the user 952 is currently accessing the URL 971. Likewise, when the user 982 accesses the URL 971, the identification component 988 determines a unique identifier for the user 982. The unique identifier may be determined, for example, from dynamically identifying the user's IP address. Alternatively, information, known in the art as a cookie, containing a unique user identifier may be placed on the user's fixed drive (140 in FIG. 2) during the identification component installation process described above.

Once the identification component 988 determines a unique identifier for the user 982, it sends a message to the network server 972 containing the unique user identifier and the URL 971 address that the user 982 is accessing. Based on the contents of this message, the network server 972 updates the user list 974, so that the user list 974 now contains information specifying that the users 952 and 982 are currently accessing the URL 971.

Other components, such as the components 960, 990, may send commands to the identification components (958, 988) and receive responses from the identification components (958, 988). Communication between components and identification components executing in conjunction with the same browser application on the same computer can be routed through a controlling module or can be established directly between two components without involving a controlling module. Thus, for example, the component 960 can communicate with the identification component 958 via the controlling module 956 and the component 990 can communicate with the identification component 988 via the controlling module 986. Alternatively, the component 960 can communicate directly with the identification component 958 and the component 990 can communicate directly with the identification component 988. In the example depicted in FIG. 8, when the user 952 accesses the URL 971 , the component 960 requests from the identification component 958 a list of all users who are currently accessing the URL 971. In response to this request, the identification component 958 queries the network server 972 for a list of users who are accessing the URL 971. The network server 972 examines the user list 974, compiles a list of users who are accessing the URL 971 and returns this list to the identification component 958. The identification component 958 then passes this list to the component 960 and the component 960 displays this list to the user 952 within the window of the browser application 954. Likewise, when the user 982 accesses the URL 971 , the component 990 requests from the identification component 988 a list of all users who are currently accessing URL 971. In response to this request, the identification component 988 queries the network server 972 for a list of users who are accessing URL 971. The network server 972 examines the user list 974, compiles a list of users who are accessing the URL 971 and returns this list to the identification component 988. The identification component 988 then passes this list to the component 990 and the component 990 displays this list to the user 982 within the window of the browser application 984. Assuming that the user 952 accessed the URL 971 before the user 982, the list displayed to the user 982 by the component 990 will include information about the user 952. The identification components 958, 988 continuously query the network server 972 at pre-defined time intervals to receive updated lists of users who are accessing the URL 971. Thus, after the user 982 accesses the URL 971, the identification component 958 will receive an updated list from the network server 972 and will pass this list to the component 960. The component 960 will then display the updated list to the user 952, so that, once both users 952, 982 are accessing the URL 971, the user list displayed for them by their respective components 960, 990 will include information about both users 952 and 982.

An identification component can enable users to communicate with each other by sending messages between the users' respective browser applications. In the example depicted in FIG. 8, the component 960 displays to the user 952 a list of active users. The component 960 may also display a command prompt, such as, for example, an icon that user 952 can click to send a message to another user. Alternatively, for example, the user 952 can click on one of the user names on the list of active users to initiate a communication session.

When a communication session is initiated, the component 960 may display a communication window within the browser application 954 to the user 952. The communication window may, for example, accept keyboard input from the user 952 and display responses from another user to the user 952. When the user 952 clicks on the user name of the user 982 in the user list in order to initiate a communication session, the component 960 sends a command to the identification component 958, requesting a communication session with the user 982. Having received this command, the identification component 958 sends a command to the network server 972, requesting a communication session with the user 982. The identification component 958 either sends this command directly to the network server 972 or it sends this command via the controlling module 956, depending on the preference of the programmer who designed the component 960 according to the programming rules described above with reference to FIGs. 7-9 and depending on the preference of the user who defined connections and interrelationships between components using the authoring system described above with reference to FIGs. 5, 6A- 6C.

When the network server 972 receives a command from the identification component 958 requesting communication with the user 982, the network server 972 identifies the location of the user 982, such as, for example, the IP address of the user 982. The network server 972 can obtain information about the user 982, for example, from the user list 974, or alternatively, this information may be provided to the network server 972 by the identification component 958. Having obtained the location of the user 982, the network server 972 sends a command to the identification component 988 requesting a communication session. The network server 972 can send this command directly to the identification component 988 or via the controlling module 986, depending on program design.

When the identification component 988 receives the request to initiate a communication session, the identification component 988 sends a similar command to the component 990, based on which the component 990 displays a communication window to the user 982 within the browser application 984. When the user 982 types data into this window, the component 990 sends the data entered by the user 982 to the network server 972, directing the network server 972 to relay the data to the user 952. The network server 972 relays the data to the identification component 958, which in turn relays it to the component 960. The component 960 displays the data to the user 952 in the communication window within the browser application 954. Thus, the data entered by the user 952 is visible to the user 982 and the data entered by the user 982 is visible to the user 952.

In the example depicted in FIG. 8, the user 952 can request that the user 982 provides data input to the components executing within the browser application 954. For example, the user 952 may click with a mouse on a request icon displayed by the component 960, which causes the component 960 to send a command to the network server 972 inviting the user 982 to provide data input. The command sent by the component 960 is communicated to user 982 via the identification component 958, the network server 972, the identification component 988 and the component 990 according to, for example, the communication method described above. After the user 982 accepts the invitation communicated by the user 952, the user 982 can continue to interact with the browser application 984 as before. During this interaction, the data entered by the user 982 within the browser application 984 is sent by the identification component 988 to the identification component 958. When the identification component 958 receives this data, it sends it to the controlling module 956. The controlling module 956 sends this data to the component 960 and the component 960 treats this data as if it was entered by the user 952 within the browser application 954. The controlling module 956 and the component 960 interact with each other according to the method described above with reference to FIGs. 3A and 3B. Thus, the data entered by the user 982 is substituted for the data entered by the user 952, enabling the user 952 to observe the behavior of the components executing in conjunction with the browser application 954 without providing his own input to these components.

Variations, modifications, and other implementations of what is described herein will occur to those of ordinary skill in the art without departing from the spirit and the scope of the invention as claimed. Accordingly, the invention is to be defined not by the preceding illustrative description but instead by the spirit and scope of the following claims. What is claimed is:

Claims

WO 00/68788 PCT/USOO/l 1138

- 29 -

Claims L A method of displaying a visual model on a display of a computer, comprising: (a) storing on the computer a plurality of program components; (b) obtaining data over a computer network using at least one of the plurality of program components in conjunction with a browser application executing on the computer; (c) creating on the computer a visual model representative of the data using at least one of the plurality of program components in conjunction with the browser application; (d) displaying the visual model on the display of the computer using at least one of the plurality of program components in conjunction with the browser application; (e) allowing a user of the computer to interact with the displayed visual model using at least one of the plurality of program components in conjunction with the browser application; and (f) displaying a version of the visual model using at least one of the plurality of program components in conjunction with the browser application, the version of the visual model being modified based on the user interaction in step (e).

2. The method of claim 1 wherein step (b) comprises obtaining the data over the network from a first computer and obtaining additional data over the network from a second computer, and wherein step (c) comprises creating the visual model which is representative of both the data and the additional data.

3. The method of claim 1 wherein step (c) comprises creating the visual model which includes a visual simulation based on the data.

4. The method of claim 1 wherein step (e) comprises allowing the user to specify a modification to the displayed visual model.

5. The method of claim 1 wherein the computer network is a TCP/IP network.

6. The method of claim 1 wherein step (a) comprises obtaining the plurality of program components over a computer network.

7. The method of claim 6 wherein the computer network is a TCP/IP network.

8. The method of claim 1 wherein step (a) comprises obtaining the plurality of program components from a computer disk.

9. The method of claim 1 wherein the browser application is an HTML network browser.

10. The method of claim 1 wherein the program components are defined to the browser application by an HTML document.

11. The method of claim 1 wherein one of the plurality of program components is a controlling module that manages communications between at least two of the plurality of program components and between at least one of the plurality of program components and the browser application.

12. The method of claim 1 wherein one of the plurality of program components is a controlling module that controls the plurality of program components.

13. The method of claim 12 wherein controlling the plurality of program components includes synchronizing the plurality of program components so that one program component performs a function based on an occurrence of an event produced by a function of another program component.

14. The method of claim 1 1 wherein each of the plurality of program components is created using a common set of programming rules, the set of rules enabling each of the plurality of program components to communicate with the controlling module and with each other.

15. The method of claim 1 wherein the visual model is animated.

16. The method of claim 1 wherein the user interaction in step (e) further comprises using a keyboard or a mouse.

17. A system for providing additional functionality to a browser application, comprising: a plurality of program components, each of the plurality of program components capable of performing at least one function including at least one of the plurality of program components capable of obtaining data over a computer network, at least one of the plurality of program components capable of obtaining input from a user of the browser application, at least one of the plurality of program components capable of creating a visual model based on the data obtained over the computer network, and at least one of the plurality of program components capable of modifying the visual model based on the input obtained from the user of the browser application; and a controlling module that communicates with and controls and directs each of the plurality of program components and that interfaces with the browser application.

18. The system of claim 17, wherein the controlling module synchronizes the plurality of the components so that one component performs a function based on an occurrence of an event produced by a function of another component.

19. The system of claim 17 wherein each of the plurality of program components is created using a common set of programming rules, the set of rules enabling each of the plurality of program components to communicate with the controlling module and with each other.

20. The system of claim 17 wherein the visual model includes a visual simulation based on the data.

21. The system of claim 17 wherein the input obtained from a user of the browser application is a specification of a modification to the displayed visual model.

22. The system of claim 17 wherein the computer network is a TCP/IP network.

23. The system of claim 17 wherein the plurality of program components and the controlling module are obtained over the computer network.

24. The system of claim 23 wherein the computer network is a TCP/IP network.

25. The system of claim 17 wherein the browser application is an HTML network browser.

26. The system of claim 17 wherein the module and the plurality of program components are defined to the browser application by an HTML document.

27. The system of claim 17 wherein the visual model is animated.

28. The system of claim 17 wherein the input obtained from the user is keyboard or mouse input.

29. A method of creating a computer program for use in displaying a visual model on a display of a computer in conjunction with a browser application executing on the computer, comprising: (a) allowing a user to select, in a graphical environment, a plurality of program components; (b) allowing the user to use connectivity functions to define connections and interrelationships between and among the plurality of program components; and (c) creating a file with the user-defined connections and interrelationships between and among the plurality of program components, the program components and the file together defining the functionality of the computer program including the ability to (1) obtain data over a computer network using at least one of the plurality of program components, (2) create on the computer a visual model representative of the data using at least one of the plurality of program components, (3) display the visual model on the display of the computer using at least one of the plurality of program components, (4) allow the user to interact with the displayed visual model using at least one of the plurality of program components, and (5) display a version of the visual model using at least one of the plurality of program components, the version of the visual model being modified based on the user interaction.

30. The method of claim 29, wherein the connections and interrelationships between and among the plurality of program components include synchronization between program components so that one program component performs a function based on an occurrence of an event produced by a function of another program component.

31. The method of claim 29, wherein the file in step (c) contains HTML code that defines at least one of the plurality of program components to the browser application.

32. The method of claim 29, wherein the plurality of program components is comprised of program components created using a common set of programming rules, said set of programming rules thereby enabling the creation of user-defined connections and interrelationships between and among the plurality of program components.

33. A method of displaying a visual model, comprising: (a) storing a plurality of program components on a first computer and a plurality of program components on a second computer; (b) obtaining data over a computer network using at least one of the program components on the first computer in conjunction with a browser application executing on the first computer; (c) creating on the first computer a visual model representative of the data using at least one of the program components on the first computer in conjunction with the browser application; (d) displaying the visual model on the display of the first computer using at least one of the program components in conjunction with the browser application executing on the first computer; (e) obtaining input from a user of the second computer using at least one of the program components on the second computer in conjunction with a browser application executing on the second computer; (f) sending data from the second computer over the computer network to the first computer, the data comprising the input obtained in step (e); and (g) displaying on the first computer a version of the visual model using at least one of the program components on the first computer in conjunction with the browser application executing on the first computer, the version of the visual model being modified based on the input sent in step (f).

34. The method of claim 33, wherein the data in step (f) further comprises commands used to control at least one of the program components on the first computer.