CA2207746A1 - Method of manipulating software components through a network with enhanced performance and reduced network traffic - Google Patents
Method of manipulating software components through a network with enhanced performance and reduced network trafficInfo
- Publication number
- CA2207746A1 CA2207746A1 CA002207746A CA2207746A CA2207746A1 CA 2207746 A1 CA2207746 A1 CA 2207746A1 CA 002207746 A CA002207746 A CA 002207746A CA 2207746 A CA2207746 A CA 2207746A CA 2207746 A1 CA2207746 A1 CA 2207746A1
- Authority
- CA
- Canada
- Prior art keywords
- component
- computer
- event
- user
- 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.)
- Abandoned
Links
- 238000000034 method Methods 0.000 title claims abstract description 53
- 230000000694 effects Effects 0.000 claims abstract 36
- 238000009877 rendering Methods 0.000 claims 6
- 230000005540 biological transmission Effects 0.000 claims 5
- 238000004891 communication Methods 0.000 claims 4
- 238000012544 monitoring process Methods 0.000 claims 3
- 239000003973 paint Substances 0.000 claims 3
- 230000003993 interaction Effects 0.000 claims 2
- 238000001914 filtration Methods 0.000 claims 1
- 238000010422 painting Methods 0.000 claims 1
- 230000001960 triggered effect Effects 0.000 claims 1
- 230000001934 delay Effects 0.000 description 1
- GWUSZQUVEVMBPI-UHFFFAOYSA-N nimetazepam Chemical group N=1CC(=O)N(C)C2=CC=C([N+]([O-])=O)C=C2C=1C1=CC=CC=C1 GWUSZQUVEVMBPI-UHFFFAOYSA-N 0.000 description 1
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
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)
- Information Transfer Between Computers (AREA)
- Computer And Data Communications (AREA)
- Multi Processors (AREA)
- Communication Control (AREA)
Abstract
A method of manipulating components through an network with enhanced performance and reduced network traffic includes providing a proxy application on a client computer and a remote windowing system on a server computer. The proxy application emulates, on the basis of instruction codes received from the server computer, the components of an application running on the server computer. The remote windowing system emulates, on the basis of activity packets received from the client computer, data input and user-initiated events provided by the windowing system of the client computer.
In operation, when a user-initiated event is passed to the proxy application by the windowing system of the client computer, the proxy application encodes event data indicative of the event, and transmits the encoded event data to the server computer as an activity packet. Upon receipt of an activity packet, the remote windowing system in the server computer decodes the event data, and passes the event data to a selected component of the application for processing. Component changes resulting from processing of the event by the application are encoded by the remote windowing system and transmitted as instruction codes to the client system. Upon receipt of the instruction codes, the proxy application renders the component changes on the client computer. As a result, a user of the client computer is able to utilize the application as if it were running locally on the client computer, instead of running on a remote server computer. Network traffic between the client and server computers is reduced to encoded activity packets and instruction codes, which are small and can be transmitted quickly.
In operation, when a user-initiated event is passed to the proxy application by the windowing system of the client computer, the proxy application encodes event data indicative of the event, and transmits the encoded event data to the server computer as an activity packet. Upon receipt of an activity packet, the remote windowing system in the server computer decodes the event data, and passes the event data to a selected component of the application for processing. Component changes resulting from processing of the event by the application are encoded by the remote windowing system and transmitted as instruction codes to the client system. Upon receipt of the instruction codes, the proxy application renders the component changes on the client computer. As a result, a user of the client computer is able to utilize the application as if it were running locally on the client computer, instead of running on a remote server computer. Network traffic between the client and server computers is reduced to encoded activity packets and instruction codes, which are small and can be transmitted quickly.
Description
StikPm~,Elliott File16487-O05 Description of the Invention The present invention provides a process whereby a Java program running on one computer (the Server System) creates and manipulates Java Components on one or more remote co~ ulel~ (Client Systems), through a network, and receives Events from these Components.
The Java Components on each Client System run independently of Java Components on other Client Systems, while being remotely manipulated by the Server System. By this means, the need to transmit large numbers of Java class files to the Client System is elimin~tc.l, thereby significantly reducing delays perceived by a user of the Client System.
With reference to the attached drawing:
A Java program on the Server System creates instances of Java Components, on theServer System, in a conventional manner. When the getToolKitO method of a Java Component without a peer or parent is called, an instance of a Remote Component ToolKit (RCT) is returned.
When the addNotify() method of any non-abstract Component is called, the ~plopl;ate "create" method of the RCT is called{ 1 } . The create method inst~nti~tes a Remote Component Peer (RCP) of the correct type {2} and returns it to the Component.
The RCP communicates with Component Management Software (CMS) on the Client System {3}. The RCP transmits component-related instructions to the CMS. The CMS converts these instructions into Component method calls that result in the creation {4} and manipulation of Components on the Client System.
When an Event is generated {5} on the Client System and delivered to the postEventO
method of a Component, the Event, if significant, is codified and transmitted {6} to a Remote Event Dispatcher on the Server System. The Di~p~tçher re-creates the Event {7} on the Server System and calls the postEvent() method of the corresponding Component on the Server System.
The Java Components on each Client System run independently of Java Components on other Client Systems, while being remotely manipulated by the Server System. By this means, the need to transmit large numbers of Java class files to the Client System is elimin~tc.l, thereby significantly reducing delays perceived by a user of the Client System.
With reference to the attached drawing:
A Java program on the Server System creates instances of Java Components, on theServer System, in a conventional manner. When the getToolKitO method of a Java Component without a peer or parent is called, an instance of a Remote Component ToolKit (RCT) is returned.
When the addNotify() method of any non-abstract Component is called, the ~plopl;ate "create" method of the RCT is called{ 1 } . The create method inst~nti~tes a Remote Component Peer (RCP) of the correct type {2} and returns it to the Component.
The RCP communicates with Component Management Software (CMS) on the Client System {3}. The RCP transmits component-related instructions to the CMS. The CMS converts these instructions into Component method calls that result in the creation {4} and manipulation of Components on the Client System.
When an Event is generated {5} on the Client System and delivered to the postEventO
method of a Component, the Event, if significant, is codified and transmitted {6} to a Remote Event Dispatcher on the Server System. The Di~p~tçher re-creates the Event {7} on the Server System and calls the postEvent() method of the corresponding Component on the Server System.
Claims (39)
1. 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 comprising the steps of:
(a) monitoring the windowing system of the client computer, and, upon receipt of a user initiated event:
[i] encoding data indicative of the user initiated event 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;
[ii] transmitting the activity packet to the server computer;
[iii] receiving the activity packet in the server computer;
[iv] decoding the activity packet to obtain event data indicative of the user initiated event;
[v] passing the event data to the application running on the server computer to process the event;
(b) monitoring the application running on the server computer, and, upon receipt of component change data indicative of changes in a component:
[i] transmitting the component change data to the client computer;
[ii] receiving the component change data in the client computer;
[iii] passing the component change data to components running on the client computer for rendering on the monitor of the client computer.
(a) monitoring the windowing system of the client computer, and, upon receipt of a user initiated event:
[i] encoding data indicative of the user initiated event 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;
[ii] transmitting the activity packet to the server computer;
[iii] receiving the activity packet in the server computer;
[iv] decoding the activity packet to obtain event data indicative of the user initiated event;
[v] passing the event data to the application running on the server computer to process the event;
(b) monitoring the application running on the server computer, and, upon receipt of component change data indicative of changes in a component:
[i] transmitting the component change data to the client computer;
[ii] receiving the component change data in the client computer;
[iii] passing the component change data to components running on the client computer for rendering on the monitor of the client computer.
2. The method of claim 1, wherein steps (a) and (b) of claim 1 are conducted in sequence as an event/response cycle initiated by receipt of a user initiated event at step (a) of claim 1.
3. The method of claim 1, wherein step (a) of claim 1 includes the step of filtering the user-initiated event to determine whether or not the user-initiated event is significant, steps a[i] through b[iii] of claim 1 being executed only when it is determined that the user-initiated event is in fact significant.
4. The method of claim 1, wherein step (a) of claim 1 further includes the step of storing user-induced component changes, and, prior to step a[i] of claim 1:
(1) checking components for user-induced changes;
(2) when user induced changes are found, encoding the user induced changes to create an activity packet concerning the user induced changes;
(3) transmitting the activity packet to the server computer;
(4) receiving the activity packet in the server computer;
(5) decoding the activity packet to obtain the user-induced changes; and (6) storing the user-induced changes in association with a selected component of the application.
(1) checking components for user-induced changes;
(2) when user induced changes are found, encoding the user induced changes to create an activity packet concerning the user induced changes;
(3) transmitting the activity packet to the server computer;
(4) receiving the activity packet in the server computer;
(5) decoding the activity packet to obtain the user-induced changes; and (6) storing the user-induced changes in association with a selected component of the application.
5. A method of manipulating components on a remote computer via a network, the method comprising the steps of:
(a) receiving component change data concerning changes in a component from an application running on a first computer;
(b) transmitting encoded data indicative of the component change data to the remote computer;
(c) receiving the encoded data in the remote computer;
(d) decoding the encoded data in the remote computer to obtain component change data concerning desired component changes;
(e) passing the component change data to a selected component running on the remote computer to render the desired component changes.
(a) receiving component change data concerning changes in a component from an application running on a first computer;
(b) transmitting encoded data indicative of the component change data to the remote computer;
(c) receiving the encoded data in the remote computer;
(d) decoding the encoded data in the remote computer to obtain component change data concerning desired component changes;
(e) passing the component change data to a selected component running on the remote computer to render the desired component changes.
6. The method of claim 5, wherein the encoded data comprises:
(a) a component ID indicative of a component to be changed, the component ID be used in the remote computer to select a desired component to be changed;
(b) an Op Code indicative of the type of change to be effected, the Op-Code being used in the remote computer to trigger a method of the desired component; and (c) data serving as parameters for the method of the desired component triggered in response to the Op-Code.
(a) a component ID indicative of a component to be changed, the component ID be used in the remote computer to select a desired component to be changed;
(b) an Op Code indicative of the type of change to be effected, the Op-Code being used in the remote computer to trigger a method of the desired component; and (c) data serving as parameters for the method of the desired component triggered in response to the Op-Code.
7. A method of manipulating components on a remote computer comprising the steps of:
(a) receiving a user initiated event from a component running on a first computer;
(b) encoding the event to create an activity packet;
(c) transmitting the activity packet to a second computer;
(d) receiving the activity packet in the second computer;
(e) decoding the activity packet to obtain the event;
(f) passing the event to a selected component of an application running on the second computer to process the event.
(a) receiving a user initiated event from a component running on a first computer;
(b) encoding the event to create an activity packet;
(c) transmitting the activity packet to a second computer;
(d) receiving the activity packet in the second computer;
(e) decoding the activity packet to obtain the event;
(f) passing the event to a selected component of an application running on the second computer to process the event.
8. The method of claim 7, wherein the activity packet comprises:
(a) a component ID indicative of a component affected by the user-initiated event; and (b) an Op Code indicative of the user-initiated event.
(a) a component ID indicative of a component affected by the user-initiated event; and (b) an Op Code indicative of the user-initiated event.
9. 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 comprising the steps of:
(a) preliminarily storing the application, a proxy application and an enabler program on a server computer;
(b) running the enabler program on the server computer to continuously monitor the communication media for a network connection attempt initiated from a client computer;
(c) transmitting the proxy application from the server computer to a client computer via the network and initializing the proxy application on the client computer;
(d) establishing, by means of the proxy application, a network connection with the enabler program on the server computer;
(e) initializing the application on the server computer in response to establishment of a network connection with the enabler program;
(f) creating, on the server computer, one or more components in accordance with start-up logic of the application;
(g) creating a respective remote component peer for each component;
(h) transmitting, by means of each remote component peer, component creation instructions to the proxy application running on the client computer;
(i) creating, on the client computer, a respective client component corresponding to each component created on the server computer, on the basis of the component creation instructions; and a) rendering on a monitor of the client computer, client components as required by the intended initial condition of the application so as to begin a user's experience of the application.
(a) preliminarily storing the application, a proxy application and an enabler program on a server computer;
(b) running the enabler program on the server computer to continuously monitor the communication media for a network connection attempt initiated from a client computer;
(c) transmitting the proxy application from the server computer to a client computer via the network and initializing the proxy application on the client computer;
(d) establishing, by means of the proxy application, a network connection with the enabler program on the server computer;
(e) initializing the application on the server computer in response to establishment of a network connection with the enabler program;
(f) creating, on the server computer, one or more components in accordance with start-up logic of the application;
(g) creating a respective remote component peer for each component;
(h) transmitting, by means of each remote component peer, component creation instructions to the proxy application running on the client computer;
(i) creating, on the client computer, a respective client component corresponding to each component created on the server computer, on the basis of the component creation instructions; and a) rendering on a monitor of the client computer, client components as required by the intended initial condition of the application so as to begin a user's experience of the application.
10. The method of claim 9, wherein the step of initializing the proxy application includes detecting characteristics of the client computer, and transmitting to the server computer data indicative of the detected characteristics.
11. The method of claim 9, wherein the step of creating, on the server computer, one or more components, includes, for each paintable component, defining and storing a respective byte array of encoded paint instructions corresponding to the paintable component.
12. The method of claim 11, wherein the step of transmitting component creation instructions to the proxy application includes, for each paintable component, the steps of:
transmitting the byte array of encoded paint instructions to the client computer; receiving the byte array in the client computer; and storing the byte array in the client computer in association with a corresponding client component.
transmitting the byte array of encoded paint instructions to the client computer; receiving the byte array in the client computer; and storing the byte array in the client computer in association with a corresponding client component.
13. The method of claim 12, wherein the step of rendering client components on a monitor of the client computer comprises painting each paintable component in accordance with its respective byte array of encoded paint instructions.
14. A method of manipulating components through a network, comprising:
(a) receiving an event from a windowing system of a client computer, the event being initiated by a user of the client computer;
(b) encoding event data indicative of the user initiated event to create an activity packet;
(c) transmitting the activity packet to a server computer through the network;
(d) receiving the activity packet in the server computer;
(e) decoding the activity packet to obtain the event data indicative of the user initiated event;
(f) calling one or more methods of a component on the server computer in accordance with the event data;
(g) Receiving component change data indicative of changes in a component running on the server computer;
(h) transmitting the component change data to the client computer;
(i) receiving the component change data in the client computer; and (j) calling one or more methods of a component running on the client computer in accordance with the component change data.
(a) receiving an event from a windowing system of a client computer, the event being initiated by a user of the client computer;
(b) encoding event data indicative of the user initiated event to create an activity packet;
(c) transmitting the activity packet to a server computer through the network;
(d) receiving the activity packet in the server computer;
(e) decoding the activity packet to obtain the event data indicative of the user initiated event;
(f) calling one or more methods of a component on the server computer in accordance with the event data;
(g) Receiving component change data indicative of changes in a component running on the server computer;
(h) transmitting the component change data to the client computer;
(i) receiving the component change data in the client computer; and (j) calling one or more methods of a component running on the client computer in accordance with the component change data.
15. The method of claim 14, wherein a flush timer thread running on the server computer is used to force timely transmission of the component change data to the client computer.
16. The method of claim 14, wherein the activity packet containing encoded data indicative of a user-initiated event comprises:
(a) a component ID indicative of a component affected by the user-initiated event;
(b) an Operation Code indicating that the activity packet contains information of a user-initiated event; and (c) an event-type code indicative of the type event initiated by the user.
(a) a component ID indicative of a component affected by the user-initiated event;
(b) an Operation Code indicating that the activity packet contains information of a user-initiated event; and (c) an event-type code indicative of the type event initiated by the user.
17. The method of claim 14, wherein the step of transmitting component change data to the client computer comprises the steps of:
(a) transmitting an operation code indicative of the component change;
(b) if required, transmitting any data associated with the component change;
(c) transmitting an operation code for "select component' (d) transmitting a Component ID indicative of a specific component affected by the component change; and (e) transmitting an operation code indicative of a functional operation to be performed on the component identified by the component ID.
(a) transmitting an operation code indicative of the component change;
(b) if required, transmitting any data associated with the component change;
(c) transmitting an operation code for "select component' (d) transmitting a Component ID indicative of a specific component affected by the component change; and (e) transmitting an operation code indicative of a functional operation to be performed on the component identified by the component ID.
18. The method of claim 17, wherein the step of receiving the component change data in the client computer, comprises sequentially receiving and processing each transmission described in claim 4.
19. The method of claim 14, wherein the step of receiving a user initiated event includes determining whether or not the user-initiated event is significant; steps b-j of claim 14 being executed only when the user-initiated event is determined to be significant.
20. The method of claim 19, further comprising the step of, when the user initiated event is determined to be insignificant, storing data indicative of induced component changes related to the insignificant event.
21. The method of claim 19, further comprising, when a user initiated event is determined to be significant, the steps of:
(a) determining whether or not data indicative of induced component changes related to prior insignificant events have be previously stored, and, when it is determined that such data have been stored;
(b) encoding the data indicative of induced component changes to create an activity packet;
(c) transmitting the activity packet to the server computer through the network;
(d) receiving the activity packet in the server computer;
(e) decoding the activity packet to obtain the data indicative of the induced component changes; and (f) storing the data indicative of the induced component changes in association with a component running on the server computer.
(a) determining whether or not data indicative of induced component changes related to prior insignificant events have be previously stored, and, when it is determined that such data have been stored;
(b) encoding the data indicative of induced component changes to create an activity packet;
(c) transmitting the activity packet to the server computer through the network;
(d) receiving the activity packet in the server computer;
(e) decoding the activity packet to obtain the data indicative of the induced component changes; and (f) storing the data indicative of the induced component changes in association with a component running on the server computer.
22. The method of claim 21, wherein the encoded data indicative of induced component changes is transmitted to the server computer prior to transmitting the event data indicative of the user initiated event.
23. The method of claim 21, wherein the activity packet containing encoded data indicative of induced component changes comprises:
(a) a component ID indicative of a component affected by the induced component change;
(b) an Operation Code indicative of a type of the induced component change; and (c) if required, any data stored in association with the affected component as a result of the induced component change
(a) a component ID indicative of a component affected by the induced component change;
(b) an Operation Code indicative of a type of the induced component change; and (c) if required, any data stored in association with the affected component as a result of the induced component change
24. 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 comprising:
(a) 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 being 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;
(b) providing a remote windowing system 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 being 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;
(c) whereby 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 ofactivity 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) 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 being 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;
(b) providing a remote windowing system 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 being 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;
(c) whereby 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 ofactivity 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.
25. 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 comprising the steps of:
(a) 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;
(b) retrieving an object class definition of a proxy application into the clientcomputer, and initializing the proxy application in the client computer;
(c) using the proxy application to establish a network connection with the enabler program running on the server computer;
(d) when the enabler program on the server to accepts a network connection from the proxy application, using the enabler program to create and initializing an instance of the application's startup logic on the server;
(e) using the application's startup logic to create components consistent with the application's intended form of operation;
(f) as each component is created, creating a respective remote component peer on the server computer;
(g) using the remote component peer to transmit component creation instructions to the proxy application on the client computer; and (h) using the component manager 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) 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;
(b) retrieving an object class definition of a proxy application into the clientcomputer, and initializing the proxy application in the client computer;
(c) using the proxy application to establish a network connection with the enabler program running on the server computer;
(d) when the enabler program on the server to accepts a network connection from the proxy application, using the enabler program to create and initializing an instance of the application's startup logic on the server;
(e) using the application's startup logic to create components consistent with the application's intended form of operation;
(f) as each component is created, creating a respective remote component peer on the server computer;
(g) using the remote component peer to transmit component creation instructions to the proxy application on the client computer; and (h) using the component manager 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.
26. The method of claim 25, wherein the network is a TCP/IP network, and theclient computer communicates with the server computer using a browser program.
27. The method of claim 26, wherein a user of the client computer triggers initialization of the application by clicking on a link which causes the browser to retrieve, from an HTTP server, an HTML page containing an HTML applet tag which identifies the object class definition of the proxy application; the browser being responsive to the applet tag to retrieve the object class definition of the proxy application from an HTTP server and create and initialize an instance of the proxy application object in a conventional manner.
28. The method of claim 26, further comprising, when the proxy application establishes a network connection with the server computer, the step of using the proxy application to detect and transmits data indicative of functional characteristics of the client computer.
29. The method of claim 28, wherein the data indicative of functional characteristics of the client computer includes the type and version of the operating system and the resolution of a monitor screen of the client computer.
30. The method of claim 28, further comprising, when the enabler program initializes the application startup logic on the server computer, the step of using the enabler program to replace the conventional windowing toolkit of the server computer with a remote component toolkit that is compatible with the proxy application running on the client computer and the detected functional characteristics of the client computer, whereby remote component peers compatible with the proxy application and functional characteristics of the client computer are created during subsequent creation ofcomponents of the application on the server computer.
31. The method of claim 27, wherein the enabler program and application, the HTML page, and the object class definition of the proxy application are each stored of respective different server computers on the network.
32. The method of claim 27, wherein any two or more of the enabler program and application, the HTML page, and the object class definition of the proxy application are stored on the same server computer.
33. 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 comprising:
(a) a proxy application running 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 being 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;
(b) a remote windowing system running 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 being 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.
(a) a proxy application running 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 being 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;
(b) a remote windowing system running 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 being 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.
34. A system as claimed in claim 33, wherein the proxy application comprises:
(a) 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;
(b) a component manager capable of instantiating and manipulating each client component in response to instruction codes received from the server computer;
(c) an event handler 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;
(d) a client component table containing component identifier and address information for each client component, the client component table providing a look-up table whereby the component manager can select a component on the basis of a component ID received from the server computer; and (e) a component painter 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.
(a) 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;
(b) a component manager capable of instantiating and manipulating each client component in response to instruction codes received from the server computer;
(c) an event handler 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;
(d) a client component table containing component identifier and address information for each client component, the client component table providing a look-up table whereby the component manager can select a component on the basis of a component ID received from the server computer; and (e) a component painter 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.
35. A system as claimed in claim 34, wherein the event handler comprises:
(a) an event filter responsive to each client component for determining whether or not a user-initiated event is significant;
(b) an event transmitter responsive to the event filter for encoding and transmitting to the server computer event data as an activity packet;
(c) a change transmitter responsive to the event filter for encoding and transmitting to the server computer induced component change data as an activity packet.
(a) an event filter responsive to each client component for determining whether or not a user-initiated event is significant;
(b) an event transmitter responsive to the event filter for encoding and transmitting to the server computer event data as an activity packet;
(c) a change transmitter responsive to the event filter for encoding and transmitting to the server computer induced component change data as an activity packet.
36. A system as claimed in claim 35, wherein the event transmitter is caused to transmit event data only when event filter determines that the user-initiated event is significant.
37. A system as claimed in claim 35, wherein the event filter stores data indicative of induced component changes when it a user-initiated event is determined to be insignificant.
38. A system as claimed in claim 37, wherein, when the event filter determines that a user-initiated event is significant, the event filter causes the change transmitter to encode and transmit induced component changes prior to causing the event transmitter to encode and transmit the event data.
39. A system as claimed in claim 33, wherein the remote windowing system comprises:
(a) a respective remote component peer corresponding to each component of an application running on the server computer, the remote component peer being capable of interacting with its corresponding component in a conventional manner to reflect changes in the component resulting from operation of the application and to pass user-initiated events to the component for processing, the remote component peer being responsive to component changes to transmit change codes indicative of the component changes to the client computer;
(b) a remote component toolkit comprising object classes for creating a remote component peer to correspond with a respective component, during creation of each component of the application;
(c) remote event dispatcher capable of receiving activity packets from the client computer, decoding each activity packet to obtain event data, and passing the event data to a selected remote component peer as an event; and (d) a component table including component identifiers and addresses for each remote component peer, whereby the remote event dispatcher can readily select a remote component peer on the basis of the event data received from the client computer.
(a) a respective remote component peer corresponding to each component of an application running on the server computer, the remote component peer being capable of interacting with its corresponding component in a conventional manner to reflect changes in the component resulting from operation of the application and to pass user-initiated events to the component for processing, the remote component peer being responsive to component changes to transmit change codes indicative of the component changes to the client computer;
(b) a remote component toolkit comprising object classes for creating a remote component peer to correspond with a respective component, during creation of each component of the application;
(c) remote event dispatcher capable of receiving activity packets from the client computer, decoding each activity packet to obtain event data, and passing the event data to a selected remote component peer as an event; and (d) a component table including component identifiers and addresses for each remote component peer, whereby the remote event dispatcher can readily select a remote component peer on the basis of the event data received from the client computer.
Priority Applications (6)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CA002207746A CA2207746A1 (en) | 1997-06-13 | 1997-06-13 | Method of manipulating software components through a network with enhanced performance and reduced network traffic |
| AU80057/98A AU8005798A (en) | 1997-06-13 | 1998-06-10 | Method of manipulating software components through a network with enhanced performance and reduced network traffic |
| JP50344799A JP2002505776A (en) | 1997-06-13 | 1998-06-10 | How to operate software components through a network with enhanced performance and low network traffic |
| PCT/CA1998/000573 WO1998058478A2 (en) | 1997-06-13 | 1998-06-10 | Method of manipulating software components through a network with enhanced performance and reduced network traffic |
| EP98928033A EP0988739A2 (en) | 1997-06-13 | 1998-06-10 | Method of manipulating software components through a network with enhanced performance and reduced network traffic |
| GBGB9929428.2A GB9929428D0 (en) | 1997-06-13 | 1999-12-10 | Method of manipulating software components through a network with enhanced performance and reduced network traffic |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CA002207746A CA2207746A1 (en) | 1997-06-13 | 1997-06-13 | Method of manipulating software components through a network with enhanced performance and reduced network traffic |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CA2207746A1 true CA2207746A1 (en) | 1998-12-13 |
Family
ID=4160886
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CA002207746A Abandoned CA2207746A1 (en) | 1997-06-13 | 1997-06-13 | Method of manipulating software components through a network with enhanced performance and reduced network traffic |
Country Status (6)
| Country | Link |
|---|---|
| EP (1) | EP0988739A2 (en) |
| JP (1) | JP2002505776A (en) |
| AU (1) | AU8005798A (en) |
| CA (1) | CA2207746A1 (en) |
| GB (1) | GB9929428D0 (en) |
| WO (1) | WO1998058478A2 (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7467379B2 (en) | 2001-01-16 | 2008-12-16 | International Business Machines Corporation | System and method for incrementally executing a client/server application |
Families Citing this family (23)
| 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 |
| EP2345966B1 (en) | 1999-09-21 | 2017-05-10 | Wyse Technology L.L.C. | Displaying windowing application programs on a terminal |
| JP3842493B2 (en) * | 1999-10-04 | 2006-11-08 | 富士通株式会社 | 3D object sharing processing method and storage medium |
| US20020103882A1 (en) * | 2000-10-02 | 2002-08-01 | Johnston Robin Andrew Courtland | Method and system for hands-on e-learning |
| DE10146255A1 (en) * | 2001-09-20 | 2003-04-10 | Deutsche Telekom Ag | Method for generating multimedia content from several multimedia elements |
| 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 |
| EP2359527B1 (en) | 2008-11-26 | 2021-02-24 | 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 (en) | 2010-09-30 | 2013-10-16 | 中国移动通信有限公司 | System and method for input tool invoking and proxy device |
| 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 (en) | 2011-03-21 | 2012-09-21 | Calgary Scientific Inc. | Method and system for providing a state model of an application program |
| WO2013024342A1 (en) | 2011-08-15 | 2013-02-21 | Calgary Scientific Inc. | Method for flow control and for reliable communication in a collaborative environment |
| AU2012296247B2 (en) | 2011-08-15 | 2017-06-22 | Calgary Scientific Inc. | Non-invasive remote access to an application program |
| WO2013046015A1 (en) | 2011-09-30 | 2013-04-04 | Calgary Scientific Inc. | Uncoupled application extensions including interactive digital surface layer for collaborative remote application sharing and annotating |
| AU2012342170B2 (en) | 2011-11-23 | 2017-03-09 | Calgary Scientific Inc. | Methods and systems for collaborative remote application sharing and conferencing |
| US9602581B2 (en) | 2012-03-02 | 2017-03-21 | Calgary Scientific Inc. | Remote control of an application using dynamic-linked library (DLL) injection |
| 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 |
| EP3075111B1 (en) | 2013-11-29 | 2017-12-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 |
| KR20170110612A (en) | 2015-01-30 | 2017-10-11 | 캘거리 싸이언티픽 인코포레이티드 | Highly Scalable, Fault Tolerant Remote Access Architecture and Access Method |
Family Cites Families (2)
| 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 (en) * | 1995-01-19 | 1999-09-15 | 포만 제프리 엘 | Method and system for managing events |
-
1997
- 1997-06-13 CA CA002207746A patent/CA2207746A1/en not_active Abandoned
-
1998
- 1998-06-10 EP EP98928033A patent/EP0988739A2/en not_active Withdrawn
- 1998-06-10 WO PCT/CA1998/000573 patent/WO1998058478A2/en not_active Application Discontinuation
- 1998-06-10 JP JP50344799A patent/JP2002505776A/en active Pending
- 1998-06-10 AU AU80057/98A patent/AU8005798A/en not_active Abandoned
-
1999
- 1999-12-10 GB GBGB9929428.2A patent/GB9929428D0/en not_active Ceased
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7467379B2 (en) | 2001-01-16 | 2008-12-16 | International Business Machines Corporation | System and method for incrementally executing a client/server application |
Also Published As
| Publication number | Publication date |
|---|---|
| AU8005798A (en) | 1999-01-04 |
| GB9929428D0 (en) | 2000-02-09 |
| WO1998058478A2 (en) | 1998-12-23 |
| JP2002505776A (en) | 2002-02-19 |
| WO1998058478A3 (en) | 1999-03-18 |
| EP0988739A2 (en) | 2000-03-29 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CA2207746A1 (en) | Method of manipulating software components through a network with enhanced performance and reduced network traffic | |
| US6112235A (en) | Method and apparatus for remotely managing a network hardware device having an embedded server with a client computer across a network | |
| US5724514A (en) | System, method and apparatus for controlling the transfer of data objects over a communications link | |
| US7036081B2 (en) | System and method for annotating and capturing chart data | |
| US7346857B2 (en) | Dynamic controls for use in computing applications | |
| KR100290200B1 (en) | Host information access via distributed program objects | |
| EP1203297B1 (en) | Method and system for extracting application protocol characteristics | |
| US7203940B2 (en) | Automated installation of an application | |
| US5928324A (en) | Data processing system, and method having a server handling output request from a display terminal and forwarding access request to client system | |
| US8195633B2 (en) | Enabling interactive integration of network-accessible applications in a content aggregation framework | |
| US6795851B1 (en) | Web-based client/server communication channel with automated client-side channel endpoint feature detection and selection | |
| US20030093585A1 (en) | System and method for providing real-time information to a web browser | |
| JP3565490B2 (en) | Client server system, server, client, proxy server control method, proxy server function providing method, and storage medium | |
| EP1308841A2 (en) | Service portal with application framework for facilitating application and feature development | |
| GB2381424A (en) | Controlling the amount of data transferred between a terminal and a server | |
| JP2001506104A (en) | Web interface to programmable controller | |
| EP1331556B1 (en) | Server-based computer environment | |
| JP2003015793A (en) | Method and system for dynamically changing and displaying information to be monitored on network on monitor screen and user interface player program for realizing the same system | |
| AU663015B2 (en) | Data processing system | |
| US20030069998A1 (en) | Motion services protocol accessible through uniform resource locator (URL) | |
| JP2002182942A (en) | Content authentication system | |
| EP1269336B1 (en) | System and method of monitoring video and/or audio conferencing through a rapid-update website | |
| JP4004993B2 (en) | Remote control method, server device, and virtual machine program | |
| JP2004537784A (en) | System for initiating communication between a user interface and a vision processor | |
| KR970010034B1 (en) | Remote User Information Transmission Method |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| EEER | Examination request | ||
| FZDE | Discontinued | ||
| FZDE | Discontinued |
Effective date: 20020613 |