EP0988739A2 - Procede de manipulation de composantes logicielles dans un reseau, avec amelioration des performances et diminution du trafic du reseau - Google Patents

Procede de manipulation de composantes logicielles dans un reseau, avec amelioration des performances et diminution du trafic du reseau

Info

Publication number
EP0988739A2
EP0988739A2 EP98928033A EP98928033A EP0988739A2 EP 0988739 A2 EP0988739 A2 EP 0988739A2 EP 98928033 A EP98928033 A EP 98928033A EP 98928033 A EP98928033 A EP 98928033A EP 0988739 A2 EP0988739 A2 EP 0988739A2
Authority
EP
European Patent Office
Prior art keywords
component
computer
event
application
client computer
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Withdrawn
Application number
EP98928033A
Other languages
German (de)
English (en)
Inventor
Andrew R. Siks
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Ironside Technologies Inc
Original Assignee
Ironside Technologies Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Ironside Technologies Inc filed Critical Ironside Technologies Inc
Publication of EP0988739A2 publication Critical patent/EP0988739A2/fr
Withdrawn legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46—Multiprogramming arrangements
    • G06F9/54—Interprogram communication
    • G06F9/542—Event management; Broadcasting; Multicasting; Notifications

Definitions

  • This invention relates to a method of manipulating software components through a network with enhanced performance and reduced network traffic, and in particular to a method of managing windowing components through a network such as the Internet.
  • Windowing system An object-oriented program designed to implement a
  • GUI Graphical User Interface
  • the windowing system typically controls the display of information on a display monitor, and detects user activities through a keyboard and pointer devices. Data indicative of detected user activities are passed by the windowing system to a program for processing.
  • Application A program designed to perform a predetermined set of tasks.
  • the application receives user-input data via the windowing system, and passes data to the windowing system for rendering on a display monitor to be viewed by a user.
  • Component An instance of an object created by operation of an application, typically to implement a functional feature of the application.
  • each component contains data and methods which control the rendering of the component on the display screen and provide the component's functionality.
  • an application will provide the user with a "Print” button which is displayed on the monitor screen by the windowing system. The user must then "click” on the displayed image of the print button to effect the desired function.
  • the "Print” button is a component created during runtime of the application as an instance of a "button” object.
  • the component contains data defining, for example the size, shape, color and location of the image to be rendered on the monitor), and methods defining the functionality of the — component (i.e. what happens when the user "clicks" on the image of the button as it is rendered on the display monitor by the windowing system).
  • Event An object that encapsulates user activities that have been detected by a windowing system. For example, as a pointer device (e.g. a mouse) is moved by a user, the windowing system generates a series of events representing the changing coordinates of the pointer. If the user presses a key on the keyboard, the windowing system generates an event indicating the key that was pressed. Events are passed by the windowing system to the affected component, for handling in accordance with the component's methods.
  • a pointer device e.g. a mouse
  • Significant Event An event which is likely to advance an application, as opposed to those events that will not advance the application. For example, when a character is keyed into a text field, a "key press" event is generated by the windowing system and passed to the text field component. However, at that point, the user may not have finished keying, so consequently this "key press” event is not significant. On the other hand, when the user presses the "Enter” key, the "key press” event generated by the windowing system and passed to the text field is significant, because is it possible that the user typed some text into the text field prior to the "key press” event, and this new text will have to be processed by the application. Recent developments in computer technology have given rise to a dramatic increase in the use of networks to facilitate communication between computers.
  • the Internet has experienced explosive growth, both in terms of the number of users, and the volume of data traffic.
  • PC personal computer
  • the functionality of applications designed to operate through networks are frequently limited more by the data transmission speed of the underlying network than by the capacity of the computers themselves.
  • the network backbone while providing the means of communication between computers, also presents the single most significant impediment to that communication.
  • the use of so-called "Fire-wall” computers which are typically employed to enhance security and prevent unauthorized access to computers connected to the network, further compounds this problem, as the operation of the "Fire-wall" imposes its own restrictions on data through-put.
  • OOP Object-Oriented-Programming
  • OS/2 OS/2
  • a panel component is created as an instance of a panel class of object, and stored in memory.
  • a panel component-peer which is specific to the O/S of the computer, is then created (by the panel component) and stored in memory in association with the component.
  • the application calls the "display” method of the panel component
  • the panel component calls the "display” method of its associated panel component-peer; which then interacts with the O/S to effect the display of the component on the monitor screen.
  • This multi-step process allows for the creation of a set of low-level windowing objects (e.g.
  • an Object Oriented program does not have a "main program” - "sub-program” structure, in which the main program governs the control- flow of the program, and which inherently imposes restrictions upon the actions which can be taken by the user as the program operates. Instead, the operation of an Object Oriented program is furnished by means of executing the methods (procedures) of each of the various components, and interactions between the components in response to "events" initiated by the user. Thus action of the program is heavily dependent on what the user wants to do at any particular time.
  • a “main program” or “Start-up Logic” is commonly used to define global parameters and to govern the initial creation and display of components during the start-up of the application.
  • this type of operation can be effected over a network, such as the Internet, between a server computer, and a client computer.
  • a network such as the Internet
  • One method that has been employed for this purpose involves an arrangement in which the application runs on the server computer. Components, and their corresponding component-peers are created and maintained on the server, and an image of the resulting screen display is transmitted through the network to the client computer and displayed on the screen. User inputs are transmitted by the client computer through the network to the server, and utilized in the continued operation of the application.
  • This arrangement has a number of disadvantages.
  • the transmission of an image of the screen display to the client computer involves the transmission of a large volume of data, so that delays in transmission can severely degrade the quality of the image displayed on the client computer.
  • communication between the server and client computers is virtually continuous, which will not be permitted by many firewall systems.
  • An alternative method is to download the entire application from the server, so that it can be run locally on the client computer. This permits a high performance operation on the client computer, and reduces network traffic while the application is running. However, substantial (frequently unacceptable) delays in starting the application can be encountered, depending on the amount of time required to transmit the entire application through the network. Furthermore, once the application is downloaded to the client computer, the owner of the application looses control over how that application is used. For example, "pirate" copies of the application could be made and distributed in violation of the application owner's copyright.
  • a further object of the invention is to provide a method by which an application can manipulate components on a client computer through a network having one or more intervening "Fire-wall" systems.
  • the present invention provides, in a network comprising at least one server computer and at least one client computer connected via a communications media, the client computer having a conventional windowing system capable of rendering components of an application on a monitor of the client computer, and further capable of passing user-initiated events to components of an application running on the client computer, a method of manipulating components of an application running on the server computer.
  • the method comprises monitoring the windowing system of the client computer, and, upon receipt of a user initiated event.
  • Data indicative of the user initiated event to is encoded to create an activity packet, the amount of data of the activity packet typically being smaller than that of the data indicative of the event.
  • the activity packet is transmitted to the server computer.
  • the activity packet is decoded to obtain event data indicative of the user initiated event.
  • the event data is passed to the application running on the server computer to process the event.
  • the application running on the server computer is monitored, and, upon receipt of component change data indicative of changes in a component, component change data indicative of the component change is transmitted to the client computer.
  • the component change data is passed to components running on the client computer for rendering on the monitor of the client computer.
  • a further aspect of the invention provides a method of manipulating components on a remote computer via a network, the method comprises receiving component change data concerning changes in a component from an application running on a first computer;. _ Encoded data indicative of the component change data is transmitted to the remote computer. When received by the remote computer, the encoded data is decoded to obtain component change data concerning desired component changes. Finally, the component change data is passed to components running on the remote computer to render the desired component changes.
  • a further aspect of the present invention provides, in a network comprising at least one server computer and at least one client computer connected via a communications media, a method of starting an application for use by a user of a client computer.
  • the method comprises preliminarily storing the application, a proxy application and an enabler program on a server computer.
  • the enabler program is run continuously on the server computer to continuously monitor the communication media for a network connection attempt initiated from a client computer.
  • the proxy application is transmitted from the server computer to a client computer via the network and initialized on the client computer.
  • a network connection with the enabler program on the server computer is established.
  • the application on the server computer is initialized in response to establishment of a network connection with the enabler program.
  • components are created in accordance with start-up logic of the application.
  • a respective remote component peer for each component is also created on the server computer.
  • component creation instructions are transmitted to the proxy application running on the client computer.
  • a respective client component corresponding to each component created on the server computer is rendered on the client computer in accordance with the component creation instructions transmitted by the remote component peers.
  • a further aspect of the present invention provides a method of manipulating components through a network.
  • the method comprises receiving an event from a windowing system of a client computer, the event being initiated by a user of the client computer.
  • Event data indicative of the user initiated event is encoded to create an activity packet, and transmitted to a server computer through the network.
  • the activity packet is decoded to obtain the event data indicative of the user initiated event.
  • One or more methods of a component on the server computer are called in accordance with the event data.
  • Component change data indicative of changes in a component running on the server computer are received and transmitted as component change data to the client computer.
  • one or more methods of a component running on the client computer are called in accordance with the component change data.
  • a still further aspect of the present invention provides, in a network comprising a server computer and a client computer connected by a network media allowing two-way transmission of data between the server and client computers, and wherein each computer includes a conventional windowing system capable of facilitating interaction between components of an application running on each computer and a respective user of each computer, a method for manipulating components of an application running on the server computer in response to inputs provided by a user of the client computer, with minimum network traffic.
  • the method comprises providing a proxy application on the client computer capable of emulating, on the basis of instructions codes received from the server computer, components of the application running on the server computer.
  • the proxy application is further capable of receiving data and user-initiated events from the windowing system of the client computer, and transmitting an activity packet indicative of the data and user-initiated events input to the server computer.
  • a remote windowing system is provided on the server computer capable emulating, on the basis of codes received from the client computer, data and user-initiated events received from the windowing system of the client computer.
  • the remote windowing system is further capable of receiving data indicative of changes in components of the application on the server computer, and transmitting instruction codes indicative of such component changes to the client computer.
  • components of an application running on the server computer can be manipulated on the basis of data and user-initiated events provided by a user of the client computer, and network traffic is limited to transmission of activity packets indicative of such data and user-initiated events from the client computer to the server computer, and component change data indicative of component changes from the server computer to the client computer.
  • a further aspect of the present invention provides, in a network comprising at least one server computer and a client computer connected for communication via a network media, a method of initializing an application on a server computer for use by a user of the client computer.
  • the method comprises providing and continuously running an enabler program on a server computer, the enabler program being capable of monitoring the network for, and accepting, network connection requests from the client computer.
  • An object class definition of a proxy application is retrieved into the client computer and initialized.
  • Using the proxy application a network connection with the enabler program running on the server computer is established.
  • the enabler program on the server to accepts a network connection from the proxy application, the enabler program is used to create and initializing an instance of the application's startup logic on the server.
  • components are created consistent with the application's intended form of operation.
  • a respective remote component peer is created on the server computer.
  • component creation instructions are transmitted to the proxy application on the client computer.
  • the component manager is used to create a client component on the client computer on the basis of the component creation instructions received from the server computer, the client component corresponding to and emulating a respective component on the server computer.
  • a still further aspect of the present invention provides, in a network comprising a server computer and a client computer connected by a network media allowing two-way transmission of data between the server and client computers, and wherein each computer includes a conventional windowing system capable of facilitating interaction between components of an application running on each computer and a respective user of each computer, a system for manipulating components of an application running on the server computer in response to inputs provided by a user of the client computer, with minimum network traffic.
  • the system comprises a proxy application on the client computer, the proxy application being capable of emulating, on the basis of codes received from the server computer, components of the application running on the server computer.
  • the proxy application is further capable of receiving data and user-initiated events from the windowing system of the client computer, and transmitting an activity packet indicative of data and user-initiated events to the server computer.
  • a remote windowing system on the server computer the remote windowing system being capable emulating, on the basis of codes received from the client computer, data and user-initiated events received from the windowing system of the client computer.
  • the remote windowing system is further capable of receiving data indicative of changes in components of the application on the server computer, and transmitting instructions codes indicative of such component changes to the client computer.
  • the proxy application comprises at least one client component capable of interacting with the windowing system of the client computer in a conventional manner to facilitate rendering of each client component and reception of data and user- initiated events.
  • a component manager is capable of instantiating and manipulating each client component in response to instruction codes received from the server computer.
  • An event handler is responsive to each client component and capable of receiving event data ' indicative of a user initiated event received by a client component, and transmitting the event data to the server computer as an activity packet.
  • a client component table is provided containing component identifier and address information for each client component. The client component table provides a look-up table whereby the component manager can select a component on the basis of a component ID received from the server computer.
  • a component painter is capable of interacting with each client component, and the windowing system on the client computer, to control the rendering of "paintable" components on a monitor of the client computer.
  • the event handler comprises an event filter responsive to each client component for determining whether or not a user-initiated event is significant.
  • An event transmitter is responsive to the event filter for encoding and transmitting to the server computer event data as an activity packet.
  • a change transmitter is responsive to the event filter for encoding and transmitting to the server computer induced component change data as an activity packet.
  • a proxy-application When an application is started on the server computer, a proxy-application is transmitted to and started on the client computer.
  • the proxy-application receives instruction codes and data concerning the creation of components and changes in the state of each component from the server computer.
  • the proxy-application creates components and changes the state of components on the client computer.
  • the proxy-application reproduces on the client computer the component changes occurring on the server computer as a result of operation of the application.
  • the proxy-application is further designed to receive events generated by the windowing system of the client computer, and transmit instruction codes and data concerning such events to the server computer.
  • the proxy-application operates in the client computer, and mimics the operation of the application. Like a conventional application, the proxy-application receives events generated by the windowing system, and creates and manipulates components in response to those events. However, rather than handling the events and determining component changes locally, the proxy-application transmits encoded events and component data to the server computer, and then receives instruction codes and data concerning component changes from the server computer. Since the interface between the proxy-application and the windowing system on the client computer is identical to that which exists between a conventional application and windowing system, the existence of the network between the client computer and the application on the server computer is rendered transparent to the user of the client computer.
  • a remote windowing system is activated and maintained in the server computer.
  • the remote windowing system is designed to receive encoded events and component data transmitted by the proxy-application on the client computer.
  • the remote windowing system triggers appropriate component methods so as to cause the affected components to handle the events in an appropriate manner.
  • the remote windowing system reproduces on the server computer the events generated by the windowing system on the client computer.
  • the remote windowing system is further capable of receiving component operations from the application on the server computer, and transmitting to the client computer instruction codes and data concerning the creation of components and changes in the state of each component.
  • the remote windowing system operates in the server computer, and mimics the operation of the windowing system on the client computer. Like a conventional windowing system, the remote windowing system generates events based on actions of the user, and receives component operations concerning component changes resulting from operation of the application. However, rather than responding to a user of the server computer and effecting component changes on the server computer, the remote windowing system receives encoded events and component data from the client computer, and then transmits instruction codes and data concerning component changes to the client computer. Since the interface between the application and the remote windowing system is identical to that which exists between an application and a windowing system in a conventional discrete system, the existence of the network between the application on the server computer and the windowing system on the client computer is rendered transparent to the application.
  • the remote windowing system comprises a remote component toolkit (RCT), a Remote Event Dispatcher, a Component table, and a plurality of remote-Component Peers (RCP).
  • the RCT receives, from the client computer, instruction codes and data concerning events generated by the system thread, and triggers actions of the application in response to those events.
  • Each RCP interfaces with a respective component of the application running on the server computer in a substantially conventional manner, and transmits instruction codes and data concerning component changes to the client computer.
  • the proxy-application comprises Component
  • CMS Management Software
  • ETS Event Transmission Software
  • the proxy-application is capable of discriminating between a significant event and an insignificant event, whereby only data concerning significant events is transmitted by the ETS to the server computer.
  • the amount of network traffic and server load can be reduced by eliminating the transmission of insignificant events.
  • the proxy-application is further capable of accumulating information concerning changes in the data stored in one or more components until a significant event occurs.
  • the accumulated information is transmitted by the ETS along with the instruction codes concerning the significant event, as a single transmission. By this means, the number of data transmissions can be reduced.
  • the remote windowing system transmits to the client computer instruction codes and data concerning component changes resulting from operation of the application only in response to receipt of an event from the client computer.
  • the exchange of all instruction codes and data between the server computer and the client computer occurs in the form of a sequence of Event/Response cycles, all of which are initiated by the client computer.
  • Event/Response cycles of this nature are typically accepted by intervening Fire wall systems, so that operation of Fire Wall systems will not interfere with the communications between the server computer and the client computer.
  • the remote windowing system and the proxy-application are preferably capable of transmitting and receiving instruction codes and data formatted as either binary data, or an HTTP/HTML request and response.
  • the size of the proxy-application will be significantly smaller than the application itself. As a result, the time required to download the — proxy-application to the client computer is proportionately less than would be the case if the application were to be downloaded. 2. Because the proxy-application only contains code necessary to replicate component changes caused by the application, it follows that the same proxy- application can be used for a great many different applications. Thus the time required for a user (on a client computer) to start an application (which includes downloading the proxy-application) is constant, and independent of the size of the application.
  • a specific embodiment of the present invention provides a process whereby a Java program running on one computer (the server computer) creates and manipulates Java Components on one or more remote computers (client computers), through a network, and receives Events from these Components.
  • the Java Components on each client computer run independently of Java Components on other client computers, while being remotely manipulated by the server computer.
  • a Java application on the server computer in a conventional manner.
  • the getToolKit() method of a Java Component without a peer or parent is called, an instance of a Remote Component Toolkit (RCT) is returned.
  • RCT Remote Component Toolkit
  • the create method instantiates a Remote Component Peer (RCP) of the correct type and returns it to the Java Component.
  • the RCP communicates with the Component Management Software (CMS) on the Client computer.
  • CMS Component Management Software
  • the RCP transmits component related instructions to the CMS.
  • the CMS converts these instructions into component method calls that result in the creation and manipulation of components on the client computer.
  • an Event is generated on the client computer (by action of the user) and delivered to the postEvent() method of a component, the Event, of significant, is codified and transmitted to a Remote Event Dispatcher of the Server computer.
  • the Remote Event Dispatcher re-creates the Event on the server computer and calls the postEvent() method of the corresponding Java Component on the server computer.
  • the method of the invention comprises the steps of: Receiving, from an application, a method call for a selected component; Transmitting to the client computer information indicative of the selected component, the desired method call and its parameters; In the client computer, receiving the information from the server computer; Decoding the information to extract the ID of the selected component, the desired method and its parameters; and Issuing the method call to the selected component on the client computer.
  • the method of the invention comprises the steps of: Receiving an event from a windowing system; Analyzing the event to determine whether or not the event is significant; when the result of this step is "yes", determining whether or not the data in any component has changed; When the result of this step is "yes", transmitting to the server computer information indicative of the component and its contents; In the server computer receiving the information from the client computer; Decoding the information to extract the ID of the selected component and its contents; and storing the contents in memory for subsequent access by the application.
  • Event information indicative of the event and its associated component
  • server computer receiving the information from the client computer; Decoding the information to extract the ID of the selected component and the event; and passing the event to the selected component in accordance with the methods of the selected component.
  • Figure 1 is a simplified schematic illustration of a conventional Object Oriented application running on a discrete system
  • Figure 2 is a simplified schematic illustration of a conventional Object Oriented application running between a server computer and a client computer through a network
  • Figure 3 is a schematic illustration showing the server-side of an Object Oriented application running on a server computer and communicating with a client computer through a network in accordance with the present invention
  • Figure 4 is a schematic illustration showing the client-side of an Object Oriented application running on a client computer and communicating with a server computer through a network in accordance with the present invention
  • FIG. 5 is a schematic illustration showing the Event-Handling Software of the proxy-application of Figure 4.
  • Figures 6a and 6b show a flow-chart illustrate the general sequence of steps in the method of the present invention
  • Figures 7a-7b are network transmission diagrams illustrating the transmission of graphical information data from a server computer to a client computer
  • Figure 8 is a schematic illustration of a display monitor screen of a client computer which is connected with a server computer running an example application in accordance with the present invention
  • Figures 9a-9f are network transmission diagrams illustrating the transmission of data between the client computer and server computer in the example of Figure 5.
  • a conventional Object Oriented application 1 running on a discrete computer utilizes the general structure illustrated, in simplified form in Figure 1.
  • the application 1 comprises application start-up logic 2, and one or more components or extended components 3a-c.
  • the application 1 makes use of a windowing system 4 that contains a windowing toolkit 5 capable of creating component peers 6a-c corresponding to each component 3.
  • the application start-up logic 2 controls the initialization, creation, and displayMof components3 during the start-up of the application 1. Subsequent creation and manipulation of components 3 is triggered by other components 3 in response to events received from the windowing system 7.
  • the windowing toolkit 5 creates component peers 6 for each type of component 3 utilized by the application 1 , and is called upon for this purpose by each component 3 as it is created.
  • Changes in the status of each component 3, during operation of the application 1 are passed by the component 3 to its associated component peer 6, which communicates the component changes to the operating system 7 to effect any necessary operations (for example to cause the monitor display to change).
  • events are passed by the operating system 7 to the affected component peer 6, which then passes the event on to its associated component 3 for processing in accordance with the component's methods.
  • This basic structure can be adapted to work through a network.
  • two alternative methods are typically used. The first is to simply download the application program to the client computer having the correct operating environment. In this case, when the application program is subsequently started, the operating structure described above in connection with Figure 1 is set up. This arrangement allows the application to run on the client computer as a discrete system, thereby avoiding any performance difficulties due to transmission speed of the network.
  • the amount of time required to download the entire application can be substantial.
  • a typical application program may be on the order of 700,000 bytes in size.
  • the owner of the application looses control of the use of the application program, and any proprietary information and/or methods contained within it.
  • the user of the client computer could easily make and distribute unauthorized copies of the application.
  • the user of the client computer could attempt to "reverse-engineer" the application to determine proprietary methods developed by the owner of the application.
  • the application software is divided into two parts or "tiers" One part runs on the server computer 8 while the-other part runs on the client computer 9 Only the client-side part creates window components that make use of the windowing system on the client computer 9
  • the responsibilities of the client-side part are typically limited to user interaction while the server side part handles the details of data access, computations , or "business" logic
  • the client-side part transmits operational requests and user inputs to the server- side part, which performs the required operations and transmits the resultant information to the client-side for display to the user
  • the present invention employs a combination of application-specific and generic (i e application-independent) software which is initialized and stored into memory of the server computer 8 and the client computer 9 when an application is started
  • application-specific and generic i e application-independent
  • the structure and function of the software loaded onto each of the two systems will be described in general terms, with reference to Figures 3 - 5
  • the method by which this structure transmits information between the server and client computers will then be described with reference to Figures 6a-6b, followed by a description of the method by which the entire system is initialized and loaded
  • specific examples of the operation of the present invention will be described with reference to Figures 7a-b, 8, and 9a-f.
  • an object oriented application running in accordance with the present invention comprises an application 1 program and a remote windowing system 11 on the server computer 8, and a proxy-application 12 and client windowing system 13 running on the client computer 9
  • the application 1 includes application start-up logic 2, and one or more components 3 (only one is shown in Figure 3), each of which are structured and function in a conventional manner as described above in connection with Figure 1 , and thus will not be described in further detail here.
  • the remote windowing system 11 operates in the server computer 8 and interacts with the components 3 of the application program 1 in a manner substantially identical to the windowing system 4 in a conventional discrete system (as described above in connection with Figure 1 ).
  • the remote windowing system 11 serves to emulate the client windowing system 13 on the client computer 9 in such a way as to render the intervening network 10 transparent to the application 1.
  • the remote windowing system 11 comprises a remote component toolkit 14, a remote event dispatcher 15, a component table 16, and a respective remote component peer 17 corresponding to each component 3 of the application 1.
  • Each remote component peer 17 is designed to interface with a respective component 3, and to transmit instruction codes and data concerning changes in the state of its respective component 3 to the proxy-application 12 running in the client computer 9.
  • the remote event dispatcher 15 is designed to receive, from the proxy- application 12, instruction codes and data concerning events generated by the client windowing system 13 on the client computer 9. The format and origin of these instruction codes and data will be described in greater detail below.
  • the remote event dispatcher 15 uses the component table 16 to locate and call the affected remote component peer 17, which in turn call methods of its associated component 3 in order to trigger that component's methods in substantially the same manner as is typically performed by conventional component peers upon receipt of events from the windowing system in a conventional discrete system.
  • the remote component toolkit 14 creates instances of the appropriate type of remote component peers 17 when called to do so by a component 3.
  • the object definitions for the remote component peers 17 are selected from a plurality of previously defined object definitions compatible with the O/S and communications software operating on the client computer 9, so that component instructions and data concerning changes in components can be transmitted efficiently to the client computer 9.
  • the remote component peer 17 upon receipt of a component change from its associated component 3, transmits an encoded component instruction to the client computer 9 through the network 10.
  • the specific contents of the component instruction will normally vary in accordance with the associated component's object definition, but always includes sufficient information for the component change to be fully replicated in the client computer 10.
  • the encoded component instruction transmitted to the client computer will contain: a code indicating that text-field data is being transmitted; the component identifier of the affected component; the length of the data; and the data itself.
  • the proxy application 12 runs in the client computer 9, and interacts with the client windowing system 13 in a manner substantially identical to the interaction between a conventional application and a windowing system of a discrete computer as described above in connection with Figure 1.
  • the proxy application 12 comprises a component manager 18, an event handler 19, a respective client component 20 corresponding to each component 3 of the application program 1 , a component painter 21 , and a client component table 22.
  • the component manager 18 is designed to receive encoded component instructions transmitted by the remote windowing system 11 on the server computer 8. Upon receipt of the component instructions, the component manager 18 decodes the instructions, selects the affected client component 20 from the component table 22, and effects the desired changes in the selected client component 20.
  • the component painter 21 is used in the rendering of graphic objects associated with any client component 20. The specific operations performed by the component manager 18 will normally depend on the component instructions received, but always replicates the component changes passed by the corresponding component 3 to the remote component peer 17 in the server computer 8.
  • the event handier 19 is designed to receive data concerning user-initiated events and component changes from each client component 20, and selects those events deemed to be significant, and then transmits an activity packet containing encoded data concerning significant events and component changes to the remote event dispatcher 15 in the server computer 8.
  • the event handler 19 includes an event filter 23, a change transmitter 24, and an event transmitter 25.
  • the client windowing system 13 is substantially conventional, and comprises a windowing toolkit 4 which is used by each client component 20 to create its corresponding _ component peer 6 in a conventional manner, interactions between each client component 20 of the proxy application 12 and the client windowing system 13 on the one hand, and between the component peers 6 and the operating system 7 of the client windowing system 13 on the other hand, are entirely conventional, and thus will be described in further detail only with respect to discrimination between significant and insignificant events.
  • every action taken by the user results in the generation of one or more events.
  • movement of a pointer device e.g. a mouse, not shown
  • the text field component (or its corresponding component peer) to receive and accumulate changes in the text data while the user is typing, and then only transmit the final data back to the server (as a user- induced component change) upon receipt of the "Action" event corresponding to the click of the "Ok” button.
  • the method of the present invention can be represented as a series of Event/Response cycles, in which: a user initiated (significant) event is transmitted by the proxy-application 12 to the server computer 8; the event is processed by the application 1 to yield component changes; and these component changes are then transmitted back to the proxy-application 12 for rendering on the client computer 9.
  • a user initiated (significant) event is transmitted by the proxy-application 12 to the server computer 8; the event is processed by the application 1 to yield component changes; and these component changes are then transmitted back to the proxy-application 12 for rendering on the client computer 9.
  • all events are passed from the operating system 7 to the component peer 6, which passes the event on to its associated client component 20 in a conventional manner at step S1.
  • the client component 20 automatically passes the event (again without regard to whether the event is significant) to the event filter 23, which is programmed to discriminate between significant and insignificant events (step S2), depending on the operational requirements of the application 1 as determined by the application designer.
  • Insignificant events are checked to determine whether or not they effect component changes (at step S3) and either accumulated as induced component changes at step S4 (as briefly described above, and in further detail in the examples below), or ignored (step S5).
  • significant events are passed to the event transmitter 25 for encoding and transmission to the remote event dispatcher 15 in the server computer 8.
  • the event transmitter 25 receives data concerning significant events from the event filter 23; determines whether any induced component changes exist to be transmitted to the server 8 (step S6); if necessary, triggers the change transmitter 24 to transmit data concerning user-induced component changes; and then transmits to the server computer 8 instruction codes and data concerning those events and induced component changes. Conveniently, instruction codes and data concerning induced component changes, and instruction codes and data concerning events will be transmitted sequentially, as separate logical blocks. Thus if it is determined at step S6 that induced component changes exist to be transmitted to the server 8, the event transmitter 25 triggers the change transmitter 24 to assemble an activity packet containing inducted component changes (Step S7) which is then transmitted to the server computer 8 (Step S8).
  • the format and specific contents of the activity packet containing instruction codes and data concerning induced component changes will normally vary in accordance with the associated component's object definition, but always includes sufficient information for the induced component change to be fully replicated in the server computer.
  • the instruction codes and data concerning induced component changes transmitted to the server computer 8 will contain: a code indicating that text-field data is being transmitted; the component identifier of the affected component; the length of the text data being transmitted; and the text data itself.
  • the activity packet containing induced component changes is received by the remote event dispatcher 15 in the server computer 8 (Step S9), the activity packet is decoded to extract the identifier of the affected component 3 and the component changes involved (Step S10), and the component changes stored with the selected component for later use by the application 1 (Step S11 ).
  • the event transmitter 25 constructs an activity packet (at Step S12) for the event passed from the event filter 22 at step S2. This activity packet is then transmitted to the server computer 8 (Step S13).
  • activity packets containing instruction codes and data concerning significant events will normally vary in accordance with the associated component's object definition, but always include sufficient information for the event to be fully replicated in the server computer 8.
  • the instruction codes and data concerning the event transmitted to the server computer will contain: a code indicating that event data is being transmitted; the component identifier of the affected component; the event identifier; and any arguments which accompany that event.
  • the activity packet containing instruction codes and data concerning significant events is received by the remote event dispatcher 15 in the server computer 8 (Step S14), decoded to extract the identifier of the affected component 3 and details of the event (Step S15), and the event passed to the selected component 3 (or remote component peer 17) at step S16.
  • the event is then processed by the component 3 (Step S17) in accordance with the component's methods in a manner identical to that following receipt of an event in a conventional discrete computer.
  • any component changes resulting from processing of the event are not rendered on the server computer 8 as would conventionally be the case.
  • changes in any component 3 are passed to the corresponding remote component peer 17 which transmits instruction codes and data concerning the involved component changes to the component manager 18 in the client computer 9 (Step S18).
  • the component manager 18 Upon receipt of instruction codes and data concerning the component changes from a remote component peer 17 (Step S19), the component manager 18 selects the affected client component 20 and passes the instruction codes and data to the affected client component 20 (Step S20) to be processed and rendered in accordance with the client component's methods and the client windowing system 13.
  • the present invention replaces the conventional windowing system 4 (comprising a windowing toolkit 5 and component peers 6) with a remote windowing system 11 (comprising a remote component toolkit 14, remote component peers 17, component table 16, and a remote event dispatcher 15).
  • a remote windowing system 11 comprising a remote component toolkit 14, remote component peers 17, component table 16, and a remote event dispatcher 15.
  • the present invention replaces the application with a proxy application 12 comprising the component manager 18, event handler 19, one or more client components 20, a component painter 21 and a component table 22.
  • a proxy application 12 comprising the component manager 18, event handler 19, one or more client components 20, a component painter 21 and a component table 22.
  • the present invention intervenes between the application program and components resident in the server, and the windowing system in the client computer, to render the network transparent to both the application and the windowing system.
  • the present invention will be illustrated by means of specific examples, each of which involve applications written in Java (trade name).
  • the network connecting the server and client computers is the Internet, and in particular the World-Wide-Web, and the use of conventional TCP/IP and HTTP protocols, sockets, and URL's is assumed.
  • conventional operating systems such as, for example Windows (Trademark), Windows NT (Trademark), and Unix (Trademark), and Java-enabled browser programs such as Netscape Navigator (Trademark) and Microsoft Internet Explorer (Trademark) are assumed to be operating in the server and client computers.
  • the operating systems running in both of the client and server computers can support event-driven object oriented applications.
  • the network communications software is capable of responding to application components by transmitting data through the network.
  • the network communications software is capable of receiving commands and data from the network and passing those commands and data to application components.
  • Application components in the client computer are capable of acting on commands and data received through the network (via the communications software), and events initiated by the user of the client computer.
  • Example 1 Conventional Initialization of an application
  • the user of a conventional Java-enabled web browser (such as Netscape
  • Navigator may click on a link which causes the browser to retrieve, from an HTTP server, an HTML page containing an HTML "applet tag".
  • the applet tag names the Java class corresponding to the object class definition of the application's start-up logic, which must extend the "applet” class.
  • the browser retrieves the object class definition of the application's start-up logic from the HTTP server and creates an instance of the object.
  • the browser calls a sequence of methods of the object representing the application as is conventionally prescribed for starting any object of the applet class. This sequence includes the "init" method.
  • Example 2 Initialization of an application employing the present invention.
  • An application, written in Java for use over the Internet, which makes use of the present invention, may be started in the following manner: 1.
  • An "enabler” program, written in Java, is run (continuously) on a server computer 8.
  • the enabler program listens for, and accepts, network connections.
  • the user of a browser on a client computer 9 clicks on a link which causes the browser to retrieve, from an HTTP server, an HTML page containing an HTML applet tag.
  • the applet tag names the Java class corresponding to the object class definition of a proxy application 12, which extends the applet class.
  • the browser retrieves the object class definition of the proxy application 12 from the HTTP server and creates an instance of the object.
  • the browser then calls a sequence of methods of the object representing the proxy application 12 as is conventionally prescribed for starting any object of the applet class. This sequence includes calling the "init"' method. Note that this step is identical to step 1 of Example 1 above, for an application operating conventionally, with the exception that a proxy application 12 has replaced the start-up logic of the application itself.
  • the HTTP server from which the HTML page and the object class definition of the Proxy-Application 12 may or may not be the same as server computer 8 on which the enabler program, or the application program itself are run. 3.
  • the proxy application 12 establishes a network connection with the enabler program running on the server computer 8 and, conveniently, detects and transmits characteristics of the client computer 9, such as, for example the type and version of the operating system and the resolution of the monitor screen, to the server computer 8.
  • the enabler program on the server 8 accepts a network connection from the proxy application 12, it creates an instance of the application's startup logic 2 on the server 8.
  • the enabler program ensures that the conventional windowing toolkit 5 has been replaced by a remote component toolkit 14 that is compatible with the proxy application 12 running on the client computer 9 and the detected characteristics of the client computer 9.
  • the enabler program then calls the methods of the application's start-up logic 2 as prescribed for starting any object of the applet class. 5.
  • the application's "init" method is called, the application 1 proceeds to create components 3 and extended components consistent with its intended form of operation. As additional object class definitions are required by the application 1 , they are available locally on the server computer 8.
  • any component peers that are created by application components 3 are in fact remote component peers 17.
  • the remote component peers 17 encode and transmit component creation and change instructions to the proxy application 12 running on the client computer 9 in the manner previously described.
  • the user of the client computer 9 Upon completion of the above initialization sequence, the user of the client computer 9 will observe the various components of the application 1 displayed on their monitor screen in substantially the same manner as if the application 1 had been initialized and was operating entirely within the client computer 9. The user is then able to make -. _ keyboard and mouse inputs to continue with utilization of the application 1 , with communication of data proceeding between the server computer 8 and the client computer 9 as illustrated in the following example application.
  • Example 3 creation of components, and rendering of same on the client computer 9.
  • Figures 7a and 7b illustrate the process of creation of a component 3 on the server computer 8, through to rendering of that component on the monitor of the client computer 9.
  • the application 1 , remote windowing system 11 , and the proxy application 12 will be assumed to have been initialized as described in example 2 above.
  • a client component 20 corresponding to the "parent container” component 3, and its component peer 6 in the client windowing system 13 will already exist.
  • a new component will be created and added to the "parent container", a corresponding remote component peer 17 will be created and its identity and attributes transmitted to the client computer 9; a corresponding client component 20 is then created and added to the client component of the "parent container", which precipitates the creation of a client component peer 6 and rendering on the monitor of the client computer 9.
  • a "parent container” does not exist (such as during initial start-up of an application)
  • suitable adjustments in the process described below can be readily made, as will be seen later in Example 4.
  • new components can be created by any components of an application, and thus the present invention is not limited to cases where components are created by operation of the application logic per se, as in the present example.
  • a remote component peer 17 could transmit all relevant attributes each time a component 3 is created.
  • the component manager 18 on the client computer 9 is provided with a set of "state" variables for attributes that may remain unchanged from one component creation to another. Accordingly, the remote component peers 17 maintain a matching set of state variables and only send changes to state variables when needed. Each such state variable change is sent to the client computer 9 as either a lone Operation Code, or an Operation Code followed by data to be associated with the state variable.
  • the application calls various methods of the new component 3, as prescribed for starting any object of the applet class, in order to set the various attributes of the new component.
  • the application then calls the "add" method of the parent container to add the new component to the parent container, which precipitates creation of a remote component peer 17 for the new component 3 using the remote component toolkit 14.
  • the remote component peer 17 first ensures that a number of "state" variables will be correctly set on the client computer 9.
  • state variables include: the parent container's component ID, the new component's visibility and enabled states, foreground and background colors, font specifications, paint instructions, and possibly others depending on the type of component.
  • the remote component peer can obtain the parent container's component ID from the remote component peer corresponding to the parent container of the new component.
  • the visibility and enabled states, colors and font specifications must be obtained by calling appropriate methods of the new component.
  • the remote component peer creates a remote graphics object and passes it to the new component's "paint" method.
  • the remote graphics object implements all of the methods required of a graphics object. As the various graphics drawing methods the remote graphics object are called by the "paint" method of the new component 3, the remote graphics object encodes each drawing operation into a byte sequence that is appended to a byte array. When the "paint" method finishes, the remote component peer 17 can get the byte array from the remote graphics object for transmission.
  • the remote component peer 17 obtains a new component ID for the new component 3.
  • the new component ID and a pointer to the remote component peer 17 are stored in the component table 16.
  • the component ID is also stored within the remote component peer 17 itself for rapid future reference.
  • the remote component peer 17 acquires location, size, and possibly other attributes by calling methods of the new component 3 and transmits component instructions similar to:
  • Component Type Code i.e. for this example, a code for "Button"
  • control returns to the application logic for continued operation of the application.
  • the component manager 18 on the client computer 9 receives the state variable operation codes from the server computer 8, the appropriate state variables are set.
  • Some state variables may be pointers to objects that are constructed using received information (the font, for example).
  • the component manager 18 converts the ID into a pointer to the referenced container client component 20 using the client component table 22.
  • the component manager 18 Upon receipt of the Operation Code for "New Component” and following data, the component manager 18 creates a new client component 20 of the specified type (e.g. "button") and adds the new component ID and new client component pointer into the client component table 22 for future reference.
  • the component manager 18 sets all attributes of the new client component by calling methods of the new client component (many of the attributes coming from state variables) and stores a pointer to the current array of paint instructions within the new client component 20 (if the component is a paintable component). Finally, the component manager 18 adds the new client component 20 to the current parent container component which causes the creation of a conventional component peer 6 in the client windowing system 13 and consequently the display of the new client component 20 on the display monitor of the client computer 9. As a consequence of this peer creation, the client windowing system 13 on the client computer 9 calls the "paint" method of the new client component (if it is "paintable").
  • the "paint” method calls the component painter 21 , passing to it the graphics object received from the client windowing system 13 and the stored byte array of paint instructions.
  • the component painter 21 decodes the byte away of paint instructions and calls methods of the graphics object in a sequence and manner identical to the original calls made by the "paint" method of the new component 3 on the ⁇ server computer 8.
  • Example 4 a simple application.
  • a System Performance Test Panel 26 ( Figure 8) is displayed within a browser frame 27 on a display monitor 28 of the client computer 9.
  • the System Performance Test Panel 26 includes an input text field 29, an output text field 30, and a button 31 initially labeled "Start".
  • Each of the input and output text fields 29 and 30 are instances of a "TextField” object, which includes text data (corresponding to the contents of the respective field) and methods for reading and writing the text data.
  • the button 31 is an instance of a "Button" object.
  • the System Performance Test Panel 26 is started on the client computer 9 as a result of the user of the browser reaching an HTML page that contains an applet tag referencing a proxy application 12 which precipitates the running of the appropriate application 1 on the server computer 8.
  • the client components 20a-20e are created and displayed on the client computer monitor 28 as a result of instruction codes received from the server computer 8 during and after startup of the application 1.
  • the application 1 performs the following operation: when the "Start" button 31 is clicked, the application 1 changes the button label to "Stop”, starts a timer, and then executes a calculation a number of times determined by the number in the Input text field 29. While the calculations are being executed, a progress bar 32 on the panel 26 is periodically re-painted to show the progress being made. Upon completion of the calculations, the timer is stopped and the total elapsed time is displayed in the output text field 30 and the button label is restored to "Start".
  • Figure 8 illustrates a client monitor display after initialization of the application 1 and creation of the System Performance Test Panel 24 and its elements 29-31.
  • the application 1 has advanced to the point where it is ready to receive input from the user.
  • the input text field 29 contains the number "100", which for the purpose of the present example, will be assumed to have been input by the user.
  • Figures 9a through 9c illustrate the activities that take place leading to the state shown in Figure 8.
  • the browser creates an instance of the applet panel representing the proxy application 12 (Step ES1).
  • the key logical elements of the proxy application 12 i.e. component manager 18, event handler 19, component painter 21 and startup logic
  • the browser then continues in the manner prescribed for the starting of applets by setting attributes of the applet panel (Step ES2), adding the applet panel to the browser frame (Step ES3) and calling the applet panel's "init” method.
  • an execution thread is started which performs the necessary start-up processing.
  • This start-up includes the establishment of communications with the enabler program on the server computer 8 (Step ES5); initialization of the client component table 22 to contain references to the browser frame and applet panel client components 20a and 20b (Step ES6); and the transmission of "start up" information to the enabler program (Step ES7).
  • the "start up” information can be expected to contain, at minimum, the component attributes of the applet panel that was instantiated by the browser.
  • the thread After transmitting the "start-up" information, the thread begins execution of the component manger 18, which starts reading from the communications connection and blocks until the arrival of data from the server computer 8.
  • the enabler program running on the server computer 8 when the enabler program running on the server computer 8 receives the "start-up" information, it must “mirror” the two components that already exist on the client computer 9 (that is, the browser frame and applet panel). To that end, the enabler program creates and “shows” a browser frame component 3a (Step ES8). By “showing” the browser frame component 3a, a browser frame remote component peer 17a for the browser frame component 3a is created by the remote component toolkit 14. The browser frame remote component peer 17 does not transmit component creation instructions to the client computer 9 because of a (implementation-specific) "Browser frame marker" associated with the browser frame object.
  • the enabler program After mirroring the browser frame client component 20a, the enabler program creates the applet panel component 3b (Step ES9) corresponding to a target application (the identity of the target application may have been transmitted in the "start-up” information).
  • the enabler program sets the applet panel 's attributes (Step ES10) according to the "set-up" information received from the client computer 9 and adds the applet panel component 3b to the previously created browser frame component 3a (Step ES11 ). Adding the applet panel component 3b to the browser frame component 3a precipitates the creation of an applet panel remote component peer 17b for the applet panel (Step ES12).
  • the remote component peer for a panel is conveniently programmed to recognize a panel with a parent container (in this case the browser frame) having the "Browser frame marked", and consequently not transmit component creation instructions to the client computer 9.
  • the applet panel remote component peer 17b must, however, send, to the client computer 9, instructions to paint the applet panel. In the present example, these paint instructions are used to render the labels under the text fields 29, 30 and draw and label the progress bar area 32.
  • the applet panel remote component peer 17b creates a remote graphics object that it passes to the applet panel component's paint method.
  • the remote graphics object implements all of the methods required of a conventional graphics object.
  • the remote graphics object encodes each drawing operation into a sequence of bytes that are appended to a byte array.
  • the applet panel remote component peer 17b extracts the byte array from the remote graphics object and sends (Step ES13) a sequence of instructions similar to the following:
  • the component manager 18 on the client computer 9 receives the above instructions, it locates a pointer to the "selected component" using the Component ID and the client component table 22; creates a new byte array containing the received byte array data; stores the byte array in the selected component as paint instructions (Step ES14); and calls the "repaint” method of the selected component (i.e. the applet panel client component 20b) (Step ES15).
  • the client windowing system 13 calls the "paint” method of the applet panel component 20b
  • the "paint” method calls the component painter 21 , passing to it the graphics object received from the client windowing system 13 and the stored byte array of paint instructions (Step ES16).
  • the component painter 21 decodes the byte array of paint instructions and appropriately calls methods of the graphics object in a sequence and manner identical to the original calls made by the - - "paint” method of the target application's applet panel running on the server computer 8.
  • the enabler program calls the "init” method of the applet panel component 3b (Step ES17). It is normal practice for the "init" method of an applet panel to exercise application logic to deploy an initial set of windowing components to begin the user's "experience" of the application. For the present example, the application 1 will create the "Start" button 31 and the input and output text fields 29 and 30.
  • the application 1 creates a button component 3d (Step ES18), sets its attributes (for example its color, size, location, label, etc.), and calls the "add" method of the applet panel component 3b to add the new button component 3d onto the applet panel (Step ES19).
  • the remote component toolkit 14 is called to create a remote component peer for the button (Step ES20).
  • Step ES21 the button component's attributes
  • Step ES22 sends component creation instructions to the client computer 9 (Step ES22).
  • Step ES23 the application 1 proceeds to create and add the remaining components 3c and 3e in a manner similar to the creation of the "Start" button component 3d as described above.
  • the "init" method completes and returns control to the enabler program (Step ES24) which flushes the communications output buffers and passes control to the remote event dispatcher 15 which blocks waiting for a transmission to be received from the client computer 9.
  • the enabler program starts a "Flush Timer" thread prior to creating the applet panel component 3b at ES9, that is, before any application code is executed on the server computer 8
  • the purpose of the flush timer thread is to ensure that the physical transmission of component instructions generated by remote component peers is not excessively delayed.
  • the output stream of the communications software can be expected to buffer data to be transmitted. Physical transmission only occurs when the buffer is filled or a "flush" operation is performed on the output stream.
  • the communications software may effect physical transmission of buffer data without intervention of the flush timer thread. Such applications are those that initialize quickly, respond to events quickly, and do not start their own threads that manipulate windowing components.
  • the flush timer thread plays an important role by flushing the output stream in such a manner as to ensure that component instructions are not delayed any longer than a prescribed amount of time.
  • a decision of when to flush the output stream should be a function of the age of both the oldest and newest component instructions currently buffered in the output stream, and whether or not the remote event dispatcher 15 is reading from the communications input stream.
  • each key pressed by the user results in associated events being generated and passed to the input TextField client component 20c (Step ES25).
  • the event filter 23 does not pass the events to the event transmitter 25. Instead, the keys pressed by the user are accumulated by and within the input TextField component peer 6c. The event filter 23 will, however, add a reference to the input TextField client component 20c to a "changed components" list.
  • Step ES26 the “button click” event is passed to the button client component 20d and forwarded to the event filter 23 (Step ES26).
  • the "button click" event is analyzed by the event filter 23 to determine whether it is significant.
  • the event filter 23 calls the change transmitter 24 (Step ES27) to send component changes if needed.
  • the change transmitter 24 checks the "changed components” list and determines that the input TextField 29 has been changed, and therefore must be updated on the server computer 8. Accordingly, the change transmitter 24 gets the input TextField's component ID from the client component table 22, reads the text data from the input TextField client component 20c, and transmits an "activity packet" (Step ES28) with contents similar to the following:
  • the remote event dispatcher 15 extracts the component ID from the activity packet (Step ES30), locates the corresponding remote component peer in the component table 16 (in this case the input TextField remote component peer 17c for the input TextField), and passes the activity packet data to the input TextField remote component peer 17c for processing (Step ES31).
  • the input TextField remote component peer 17c after examination of the operation code, extracts the text data (in this case the string "100"), and stores it within the peer for later retrieval by the application 1 (Step ES32).
  • Step ES34 constructs and transmits an event-type activity packet (Step ES34) with contents similar to the following:
  • the remote event dispatcher 15 extracts the component ID from the activity packet (Step ES35), locates the button remote component peer 17d in the component table 16, and passes the activity packet data to the button remote component peer 17d for processing (Step ES36).
  • the button remote component peer 17d after examination of the operation code and event type code, creates an event object representing the "button click" event and calls the event-processing method of its associated button component 3d, passing the event object as a parameter (Step ES37).
  • the button component's event processing method invokes application logic which, in accordance with the present example, (a) reads the contents of the input TextField component 3c to determine the number of calculations to perform (Step ES38); (b) sets the button component's label to "Stop” (Step ES39); (c) starts an Application Thread to perform the repetitive calculations (Step ES40); and (d) returns control back to the remote event dispatcher 15 (Step ES4l)._
  • the application 1 reads the contents of the input TextField component 3c, it does so by calling a "get text” method of the input TextField component 3c, which, in turn, calls a "get text” method of its corresponding input TextField remote component peer 17c.
  • the input TextField remote component peer 17c returns the string "100" which it had previously stored (at Step ES38).
  • Step ES42 When the application 1 sets the button's label to "Stop" (at Step ES39) by calling a "set label” method of the button component 3d, the button component 3d calls a "set label” method of its corresponding button remote component peer 17d.
  • the "set label” method of the button remote component peer 17d transmits to the client computer 9 (Step ES42) a sequence of component instructions similar to the following:
  • Component ID (I.e. the ID of the button component)
  • the component manager 18 acts each of the instructions code in sequence by first storing the text, second looking up the component ID in the client component table 22 and storing the pointer to the selected component, and finally calling the "set labels” method of the selected component with the stored text (Step ES43) as a parameter.
  • the component manager 18 obtains the component ID of the button client component 20d from the client component table 22, and then calls the "set labels” method of the button client component 20d with the stored text as a parameter.
  • the "set labels" method of the button client component 20d calls the "set labels” method of the corresponding button component peer 6d in a conventional manner to effect rendering of the button 31 with the new label text on the monitor 28 of the client computer 9.
  • the remote event dispatcher 15 flushes the communications output buffers, ensuring that all instructions transmitted by the remote component peers are now physically sent. In the present example, this most likely results in the entire physical transmission of the instructions needed to set the button label to "stop".
  • the application thread that was started by the application 1 as a result of the "button click" event begins operation by requesting the repainting of the applet panel for a new rendition of the progress bar 32.
  • the application thread does this by calling the "repaint” method of the applet panel component 3b (Step ES44), which in turn calls the "repaint” method of the corresponding applet panel remote component peer 17b
  • the applet panel remote component peer 17b proceeds to call the applet panel component's "paint” method (Step ES45) and send new paint instructions to the client computer 9 (Step ES46) in the same manner as described earlier when the applet panel remote component peer 17b was first created Notice, however, that under the present circumstances, with component instructions being generated as a result of a thread of execution other than that of the remote event dispatcher 15 (i e the application thread), that physical transmission of data is guaranteed only as a result of the flushing of the output stream by the flush timer thread
  • the application thread proceeds to perform 100 iterations of its designated computational task, during which it periodically repaints the applet panel to show its progress through the iterations (Step ES47)
  • the application thread computes the elapsed time and calls the "Set text" method of the output TextField component 3e passing the elapsed time as a parameter (Step ES48)
  • the output TextField component 3e then passes the elapsed time string to the "set text" method of its associated output TextField remote component peer 17d, which transmits (Step ES49) a series of component instructions similar to
  • the component manager 18 acts each of the instructions code in sequence by first storing the text, second looking up the component ID in the client component table 22 and storing the pointer to the selected component, and finally calling the "set text” method of the selected component with the stored text as a parameter
  • the component manager 18 obtains the component ID of the output TextField client component 20e from the client component table 22, and then calls the "set text” method of the output TextField client component 20e with the stored text as a parameter
  • the "set text” method of the output TextField client component 20e calls the "set text” method of the corresponding output TextField component peer 6e in a conventional manner to effect rendering of the output text field 30 with the new label text on the monitor 28 of the client computer 9 (Step ES50).
  • the application thread then sets the button label back to "Start” (Step ES51 and ES52) in a manner directly analogous to that described above for setting the button label to "Stop”, and finally terminates its execution (Step ES53). Notice again, that since the remote windowing system 11 is unaware of the completion of the application threads activities, the flushing of the communications output stream is performed by the flush timer thread.
  • the present invention is applicable to the field of communications through computer networks, and in particular to the field of communications through the Internet.
  • the present invention will be of particular utility for electronic commerce using such networks, and for so-called "network computers" which are designed to rely on server- based applications, rather than applications stored on the computer's own hard-disk, to provide users with functional programs.

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Theoretical Computer Science (AREA)
  • Multimedia (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Computer And Data Communications (AREA)
  • Information Transfer Between Computers (AREA)
  • Communication Control (AREA)
  • Multi Processors (AREA)

Abstract

L'invention concerne un procédé et un appareil servant à produire des turbulences dans une suspension de pâte afin de défloculer celle-ci dans une section de mise en feuille à surface ouverte d'une machine à fabriquer le papier. L'appareil comporte une caisse (2) à égoutter assurant une déshydratation par égouttage à vide, et qui comporte un ensemble d'éléments d'égouttage produisant des turbulences dans des couches relativement épaisses de pâte transportées à des vitesses de fonctionnement atteignant environ 400 m/min, en vue de produire des produits de papier qui présentent un grammage dépassant généralement environ 160 gsm. Chaque ensemble d'éléments comporte un élément (5) d'entrée, au moins un élément (6, 7) intermédiaire et un élément (8) de sortie. Le trajet du tissu (13) de formation est dévié vers le bas lorsqu'il passe au-dessus des éléments intermédiaires, qui sont inclinés selon un angle d'environ 0° à environ 10° à partir d'un plan défini par des surfaces de support du tissu de mise en feuille situées sur les éléments d'entrée et de montée. Ce mouvement vertical provoque des turbulences et des agitations dans la pâte, qui servent à défloculer celle-ci et à réduire une possibilité d'obturation de feuille. L'appareil peut être utilisé en combinaison avec d'autres dispositifs connus de mise en feuille et d'égouttage situés en amont ou en aval, de façon à augmenter leurs performances pour des couches de pâte plus épaisses et se déplaçant plus lentement.
EP98928033A 1997-06-13 1998-06-10 Procede de manipulation de composantes logicielles dans un reseau, avec amelioration des performances et diminution du trafic du reseau Withdrawn EP0988739A2 (fr)

Applications Claiming Priority (3)

Application Number Priority Date Filing Date Title
CA2207746 1997-06-13
CA002207746A CA2207746A1 (fr) 1997-06-13 1997-06-13 Methode de manipulation de composantes logicielles par reseau, permettant d'obtenir une meilleure performance et de reduire le trafic reseau
PCT/CA1998/000573 WO1998058478A2 (fr) 1997-06-13 1998-06-10 Appareil et procede de production de turbulences de pate dans une section de mise en feuille a table plate

Publications (1)

Publication Number Publication Date
EP0988739A2 true EP0988739A2 (fr) 2000-03-29

Family

ID=4160886

Family Applications (1)

Application Number Title Priority Date Filing Date
EP98928033A Withdrawn EP0988739A2 (fr) 1997-06-13 1998-06-10 Procede de manipulation de composantes logicielles dans un reseau, avec amelioration des performances et diminution du trafic du reseau

Country Status (6)

Country Link
EP (1) EP0988739A2 (fr)
JP (1) JP2002505776A (fr)
AU (1) AU8005798A (fr)
CA (1) CA2207746A1 (fr)
GB (1) GB9929428D0 (fr)
WO (1) WO1998058478A2 (fr)

Families Citing this family (24)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7720672B1 (en) 1995-12-29 2010-05-18 Wyse Technology Inc. Method and apparatus for display of windowing application programs on a terminal
EP1208442A4 (fr) 1999-09-21 2007-01-24 Wyse Technology Programmes d'application de fenetrage d'affichage sur un terminal
JP3842493B2 (ja) * 1999-10-04 2006-11-08 富士通株式会社 ３次元オブジェクト共有処理方法及び記憶媒体
US20020103882A1 (en) * 2000-10-02 2002-08-01 Johnston Robin Andrew Courtland Method and system for hands-on e-learning
US7467379B2 (en) 2001-01-16 2008-12-16 International Business Machines Corporation System and method for incrementally executing a client/server application
DE10146255A1 (de) * 2001-09-20 2003-04-10 Deutsche Telekom Ag Verfahren zum Erzeugen von Multimedia-Inhalten aus mehreren Multimedia-Elementen
US9026578B2 (en) 2004-05-14 2015-05-05 Microsoft Corporation Systems and methods for persisting data between web pages
US7712110B2 (en) * 2004-09-28 2010-05-04 Citrix Systems, Inc. System and method for remoting twain function calls from a user session to a client system
US8433747B2 (en) * 2008-02-01 2013-04-30 Microsoft Corporation Graphics remoting architecture
AU2009319665B2 (en) 2008-11-26 2015-08-20 Calgary Scientific Inc. Method and system for providing remote access to a state of an application program
US10055105B2 (en) 2009-02-03 2018-08-21 Calgary Scientific Inc. Method and system for enabling interaction with a plurality of applications using a single user interface
CN102446116B (zh) 2010-09-30 2013-10-16 中国移动通信有限公司 一种输入工具调用的系统、方法及一种代理设备
US9741084B2 (en) 2011-01-04 2017-08-22 Calgary Scientific Inc. Method and system for providing remote access to data for display on a mobile device
CA2734860A1 (fr) 2011-03-21 2012-09-21 Calgary Scientific Inc. Procede et systeme pour la mise au point d'un modele d'etat d'un programme d'application
KR20140080483A (ko) 2011-08-15 2014-06-30 캘거리 싸이언티픽 인코포레이티드 애플리케이션 프로그램에 대한 비-침투적 원격 액세스
EP2745467A4 (fr) 2011-08-15 2015-10-14 Calgary Scient Inc Procédé permettant de contrôler le flux et d'assurer une communication fiable dans un environnement collaboratif
CA2850422C (fr) 2011-09-30 2023-09-26 Calgary Scientific Inc. Extensions d'application non couplees comprenant une couche de surface numerique interactive pour partage et annotation d'application distante collaborative
SG11201402546WA (en) 2011-11-23 2014-06-27 Calgary Scient Inc Methods ans systems for collaborative remote application sharing and conferencing
CA2865707A1 (fr) 2012-03-02 2013-09-06 Calgary Scientific Inc. Controle a distance d'une application au moyen d'une injection dll (dynamic linked library)
US9729673B2 (en) 2012-06-21 2017-08-08 Calgary Scientific Inc. Method and system for providing synchronized views of multiple applications for display on a remote computing device
GB2516833A (en) 2013-07-31 2015-02-11 Ibm Running software application with dynamic action delegation
US9686205B2 (en) 2013-11-29 2017-06-20 Calgary Scientific Inc. Method for providing a connection of a client to an unmanaged service in a client-server remote access system
US10015264B2 (en) 2015-01-30 2018-07-03 Calgary Scientific Inc. Generalized proxy architecture to provide remote access to an application framework
US11310348B2 (en) 2015-01-30 2022-04-19 Calgary Scientific Inc. Highly scalable, fault tolerant remote access architecture and method of connecting thereto

Family Cites Families (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5544320A (en) * 1993-01-08 1996-08-06 Konrad; Allan M. Remote information service access system based on a client-server-service model
KR100221374B1 (ko) * 1995-01-19 1999-09-15 포만 제프리 엘 이벤트를 효율적으로 처리하는 데이타 처리 시스템 및 그의 방법과 저장장치

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
See references of WO9858478A3 *

Also Published As

Publication number Publication date
WO1998058478A2 (fr) 1998-12-23
WO1998058478A3 (fr) 1999-03-18
GB9929428D0 (en) 2000-02-09
AU8005798A (en) 1999-01-04
CA2207746A1 (fr) 1998-12-13
JP2002505776A (ja) 2002-02-19

Similar Documents

Publication Publication Date Title
EP0988739A2 (fr) Procede de manipulation de composantes logicielles dans un reseau, avec amelioration des performances et diminution du trafic du reseau
US6101510A (en) Web browser control for incorporating web browser functionality into application programs
US6073163A (en) Method and apparatus for enabling web-based execution of an application
US5933144A (en) Utility for providing printing support to graphical Java applications
US5958013A (en) Apparatus, methods and computer program products for conducting a persistent session with a host-based application
US6363433B1 (en) Method and mechanism for client-side handling of extensions originally written for servers
US5724514A (en) System, method and apparatus for controlling the transfer of data objects over a communications link
US6405367B1 (en) Apparatus and method for increasing the performance of Java programs running on a server
US6014702A (en) Host information access via distributed programmed objects
US6904600B1 (en) Application programming interface to the simple object access protocol
US5835914A (en) Method for preserving and reusing software objects associated with web pages
US6275868B1 (en) Script Engine interface for multiple languages
US5943496A (en) Methods for developing and instantiating object classes using a java virtual machine extension
US20020165993A1 (en) System and method of partitioning software components of a monolithic component-based application program to separate graphical user interface elements for local execution at a client system in conjunction with remote execution of the application program at a server system
US6003094A (en) Generic Java Gateway for connecting a client to a transaction processing system
EP2315114A1 (fr) Procédés de génération d'interface utilisateur et modification d'application
US20060265662A1 (en) System and method for generating and updating user interfaces of web-based applications
US6401109B1 (en) Virtual socket for JAVA interprocess communication
KR100481064B1 (ko) 서버와 클라이언트노드 사이의 접속을 관리하기 위한시스템 및 방법
US20050021756A1 (en) Method of developing, delivering and rendering network applications
US7496654B2 (en) Multi-threaded system for activating a process using a script engine and publishing data descriptive of the status of the process
JPH10124324A (ja) アプレットを非ｉｐネットワーク上で実行する方法及びコンピュータ・ワークステーション
US20040049530A1 (en) Distributed computer system using a graphical user interface toolkit
US20030182469A1 (en) Distributed computer system using a graphical user interface toolkit
GB2341463A (en) Software file loading

Legal Events

Date Code Title Description
PUAI Public reference made under article 153(3) epc to a published international application that has entered the european phase

Free format text: ORIGINAL CODE: 0009012

17P Request for examination filed

Effective date: 20000105

AK Designated contracting states

Kind code of ref document: A2

Designated state(s): AT BE CH CY DE DK ES FI FR GB GR IE IT LI LU MC NL PT SE

17Q First examination report despatched

Effective date: 20010927

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: THE APPLICATION IS DEEMED TO BE WITHDRAWN

18D Application deemed to be withdrawn

Effective date: 20010103

REG Reference to a national code

Ref country code: HK

Ref legal event code: WD

Ref document number: 1026091

Country of ref document: HK