WO2001046863A1

WO2001046863A1 - Server-based active document control

Info

Publication number: WO2001046863A1
Application number: PCT/US2000/034848
Authority: WO
Inventors: Simon Waterhouse; David Halls; Robert Van Der Linden
Original assignee: Citrix Systems, Inc.
Priority date: 1999-12-23
Filing date: 2000-12-20
Publication date: 2001-06-28
Also published as: IL150107A0; CA2392799A1; JP2003518297A; EP1240603A1; HK1047985A1; AU2448001A; KR20020063602A

Abstract

The invention relates to an apparatus and method for displaying the contents (38) of an active document (10) on a client (18) while retaining and executing the executable portion (34) of the active document on a server (14). In one embodiment, the method includes the step of transmitting, from the server to the client, the contents portion of the active document. The server executes the executable portion of the active document to generate output data associated with the active document. The server transmits the output data to manipulate the active document being displayed by the client.

Description

SERVER-BASED ACTIVE DOCUMENT CONTROL

Field of the Invention

The present invention relates generally to an apparatus and method for accessing,

changing and displaying an active document in a client/server environment and more specifically

to an apparatus and method for processing the active document on the server and displaying the

result of the processing on the client.

Background of the Invention

Computer communication networks typically include one or more server nodes and one or more client nodes. A server node provides a service to a client node upon receiving a request

from the client. One example of a service is providing to the client node a web page for display.

An interactive web page can be referred to as an active document. As shown in FIG. 1,

an active document 10 generally contains at least two portions, a "contents" portion 38 and an

"executable" portion 34. The contents portion of the active document includes the components

or contents of the web page, such as a string of text 38a, an image 38b, a table 38c, or a bullet

point 38d. Content components may also include graphics to be displayed as the document 10 is

viewed or style sheets associated with the active document 10. The executable portion 34 of the

active document 10 changes the content components associated with the document 10 while the

user is interacting with the active document 10. The executable portion 34 may include

executable code 34a. The executable portion 34 of the active document 10 may be provided as

an applet, script or any other form of executable code.

As a simple example, and using the embodiment depicted in FIG. 1, the active document

10 includes a text component 38a that is initially displayed in black. Executable code 34a

monitors the position of the cursor on the display and wher the cursor is placed over the text component 38a, the executable coc e 34a alters the content of the text component 38a, the color characteristic, from black to red. Thus changes in the text component 34a occur in response to the movement of the cursor over the displayed active document 10.

As depicted in FIG. 2, when a client 18 requests an active document 10, a server 14

currently sends both the contents portion 38 and the executable portion 34 of the active document

10 to the client 18. Document processing, like the simple example given above, typically occurs

in a browser application 22 executing on the client 18. Because the creator of the active document 10 has no control over which browser application 22 will be used to display the active

document 10, the creator of the active document 10 must contend with issues of deployment,

security, administration and management of the executable portion 34 of the active document 10. The existence of many different browser applications 22 creates a need for a singular, stable

environment in which the executable portion 34 of an active document 10 can be run that,

nonetheless, allows access by multiple browser applications 22.

The present invention addresses this need.

Summary of the Invention

The invention relates to an apparatus and method for accessing, displaying and

changing an active document in a client/server environment. More specifically, the invention

relates to executing the executable portion of the active document on the server, which processes

and manipulates the active document, while displaying the results of the processing and

manipulating of the active document on a client. Executing the executable code portion of the

active document on the server ensures that the execution environment is known and stable. In such a system, the executable program needs to be tested only once. Also, this allows the

executable portion of the active document to manipulate the content independently of any

platform on which the content is displayed. Thus, security and administration issues are minimized. Another advantage of the present invention is that the amount of code required to be

downloaded to the client is minimized. This helps increase the speed of transmittal of an active

document and by keeping the executable portion on the server, proprietary code is not revealed to the user on the client. Further there are no irreversible deployment decisions because executable

code (e.g., scripts and applets) which will run on the server also can run on the client browser

should the need arise. Thus, the present invention allows an active document to be delivered to a

wide variety of personal computers, Internet appliances, personal digital assistants, and other

similar client devices.

In one embodiment, the invention relates to a method for providing an active

document to a client over a communication channel, wherein the active document includes a

contents portion and an executable portion. This method includes the steps of transmitting over

the communication channel to a client at least a part of the contents portion of the active

document, generating output data from the executable portion of the active document and transmitting over the communication channel to the client the generated output data to change at

least a part of said transmitted content portion of said active document by the client. In another

embodiment, the method also includes the step of maintaining said executable portion of said

active document on a server. In another embodiment, the method also includes the step of

receiving from the client, prior to the step of transmitting the contents portion of the active

document, a request identifying the active document. In another embodiment, the request from the client includes receiving a Uniform Resource Locator (URL) address identifying the active

document. In another embodiment the method also includes the steps of receiving data from the

client and generating, responsive to the received data, output data from the executable portion of

the active document. In another embodiment the method also includes the step of changing at

least a part of the content portion of the active document in response to the received data. In another embodiment the method also includes executing the executable portion of the active

document and changing at least a part of the contents portion of the active document in response

to the execution of the executable portion of the active document. In another embodiment the

method also includes the steps of executing a second application that interacts with the active

to the execution of the second application.

The invention also relates to a server for providing an active document to a client over a communication channel. In one embodiment, the server includes an output data generator and

a transceiver. The output data generator produces output data in response to the executable

portion of the active document. The transceiver receives generated output data for transmission

over the communications channel and the transceiver includes an Application Program Interface

(API) for manipulating the content portion of the active document. In another embodiment, the

output data generator produces output data in response to input data received from the

communications channel. In another embodiment, the server API includes a Document Object

Model (DOM) API. In another embodiment, the server transceiver transmits generated output

data over the communications channel.

The invention also relates to a client for receiving over a communications channel and

displaying an active document. The client includes a browser interface and a transceiver. The

browser interface is in communication with a browser application. The transceiver receives data

via the communication channel and transmits received data to the browser interface.

Brief Description of the Drawings

The invention is pointed out with particularity in the appended claims. The advantages of

the invention described above, together with further advantages, may be better understood by

referring to the following description taken in conjunction with the accompanying drawings. In the drawings, like reference characters generally refer to the same parts throughout the different

views. Also, the drawings are not necessarily to scale, emphasis instead generally being placed upon illustrating the principles of the invention.

FIG. 1 is a block diagram of an embodiment of an active document.

FIG. 2 is a block diagram of a process of transmitting an active document from a

server node to a client node as known in the prior art.

FIG. 3 is a logical diagram of an embodiment of an active document in which an

application-programming interface for manipulating the content components of the active

document is provided.

FIG. 4 is a block diagram of an embodiment of a system for providing and displaying

an active document in a client/server environment.

FIG. 5 is a more detailed block diagram of the embodiment of the invention shown in

FIG. 4.

FIG. 6 is a state diagram illustrating one embodiment of DAM behavior useful in

connection with the present invention.

FIG. 7 is a state diagram illustrating one embodiment of DOM Proxy behavior useful

in connection with the present invention.

FIG. 8 is a screen shot of an embodiment of the invention, depicting in more detail a

specific example of an interactive web page.

Detailed Description of the Invention

Referring now to FIG. 3, an active document 10 may include many different content

components 38a, 38b, ..., 38n (referred to generally as the contents portion 38), and each

component of the contents portion 38 may be created and modified by the executable portion 34

of the active documents 10. In one embodiment, each cont jnt component 38 is described by a Document Object Model (DOM) <_nd the DOM exposes an Application Programming Interface

(DOM API) 42 to the executable portion 34. As described in more detail below, the executable

portion 34 of the active document 10 remains on the server 14 while the contents portion 38 is

transmitted to the client 18 and thus the DOM API 42 functions are performed over the

communication channel 30. The DOM API 42 allows the executable portion 34 to manipulate

content components 38 of the active document 10 in a standard way. Because the DOM API is

standardized, content components 38 may be manipulated in a standard way regardless of the browser application 22 used to display the active document 10.

In broad overview and referring to FIG. 4, a system constructed in accordance with the

invention permits a user acting on a client computer 18 to communicate with a server computer

14 over a communication channel 30 (also referred to as a network) to access an active document

10. In this embodiment, only the content components 38 are transmitted to the client 18. The

executable portion 34 of the active document 10 is retained on the server 14. In response to a

user request from the client 18 for the active document 10, the server 14 transmits over the

communication channel 30 the content components 38 of the active document 10 to the client 18.

The contents components 38 may be transmitted all together, or each component may be

transmitted as the browser 22 encounters it, i.e., the components 38 may be transmitted "on

demand."

The server 14 provides a DOM Proxy 50, which includes a DOM API 42. The

executable portion 34 of the active document 10 issues commands to the DOM Proxy 50 and

receives output from the DOM Proxy 50 as if it were directly interacting with the DOM API

provided by the browser application 22. The DOM Proxy 50 may accept more commands than

the DOM API does. In this embodiment, the DOM Proxy translates additional commands into one or more commands the DOM API provides. In some embodiments, the DOM API 42 provided by the DOM Proxy 50 may be enhanced to provided additional functionality, or it may

conform to the DOM Level 0 specification or DOM Level 1 specification promulgated by the

World Wide Web Consortium.

The DOM Proxy 50 receives commands from the executable portion of the active

document 10 and transmits them to the client node 18 via the communication channel 30. The

DOM Proxy 50 may also receive data from the client 18 over the communications channel 30 and provide the received data to the executable portion 34 of the active document 10. The DOM

Proxy 50 may be provided as a servlet or application program. For example, the DOM Proxy 50

may be provided as a JAVA bean or an Active X control. Alternatively, the DOM Proxy 50 may

be provided by modifying a browser application 22 to transmit data over the communications channel 30 rather than rendering the results of DOM API commands as visual display.

The client node 18 and the server node 14 can communicate with each other using a

variety of network connections including standard telephone lines, LAN or WAN links (e.g., TI,

T3, 56kb, X.25), broad band connections (ISDN, Frame Relay, ATM), and wireless connections.

Connections can be established using a variety of communication protocols (e.g., TCP IP, HTTP,

IPX, SPX, NetBIOS, Ethernet, RS232, and direct asynchronous connections).

The client 18 includes a DOM Access Module (DAM) 46. The DAM 46 communicates

with the DOM Proxy 50 over the communications channel 30. The DAM 46 issues DOM API

calls to the DOM API 42 provided by the browser 22 in response to data received from the DOM

Proxy 50 over the communications channel 30. The DOM Proxy 50 and the DAM 46 may pack

and unpack data for transfer over the communications channel 30. Alternatively, the DOM

Proxy 50 and the DAM 46 may enhance a standard protocol or provide their own protocol for transmission of data. The DAM 46 may be provided as a script, applet, plug-in or application

program. For example, the DAM 46 may be provided as a JAVA bean or an Active X control.

FIG. 5 depicts the system of FIG. 4 in more detail. In the embodiment shown, the client

18 executes a browser 22 which establishes an initial connection 30a with web server software

54 located on the server 14 using the communications channel 30. The browser 22 may be any

appropriate browser application, such as NETSCAPE NAVIGATOR, manufactured by Netscape

Communications of Mountain View, California or INTERNET EXPLORER manufactured by

Microsoft Corporation of Redmond, Washington. The server 14 executes any web server

software 54, such as the APACHE WEB SERVER, an open-source web server coordinated by The Apache Foundation of Forest Hill, Maryland or INTERNET INFORMATION SERVER,

manufactured by Microsoft Corporation of Redmond, Washington. The web server software 54

receives a request for an active document 10 from the client browser 22 executing on the client 14 and retrieves the requested active document 10. The server 14 may retrieve the active

document 10 from mass storage, such as tape, magnetic disk, optical disk, or CD-ROM. Alternatively, the server 14 may retrieve the document 10 from memory, such as RAM or ROM,

or from another server, for example, via a network connection.

Once the browser 22 has established the initial communications between client 18 and

server 14, active document 10 data transfer between client 18 and server 14 occurs through a

second channel 30b. This second channel 30b is a communication channel established between a

DAM 46 on the client 18 and the DOM Proxy 50 on the server 14. Data transfer to and from the

active document 10 also occurs through this channel 30b. The DAM 46 and the DOM Proxy 50

communicate using a protocol that allows individual elements of an active document to be

identified and represented so that changes in an individual element can be communicated between the DAM 46 and the DOM proxy 50. In some embodiments, a numeric handle or

"ticket" uniquely identifies each component.

In one embodiment, the protocol used by the DAM 46 and the DOM Proxy 50 allows the

DOM Proxy 50 to indicate that it should receive notification of certain events occurring on the

client 18. In these embodiments, the DOM Proxy 50 associates a handler routine with the ticket

identifying the event in which it has an interest, such as a "MouseClicked" event. When that

event occurs on the client 18, the DAM 46 notifies the DOM Proxy 50. In embodiment, the

DAM 46 notifies the DOM Proxy 50 by sending a message to the DOM Proxy indicating the

event has occurred and includes the ticket and, optionally, a description of the event. The DOM

Proxy may also indicate that it is no longer interested in an event by sending a message to the

DAM 46 including the ticket identifying the event. In a particular embodiment, the DAM 46 responds to such a message with an acknowledgement, allowing the DOM Proxy 50 to release

the binding between the ticket and the handler for the event, e.g., the DOM Proxy 50 can remove

an entry in a table associating the handler and the event.

FIGs. 6 and 7 depict state machines describing one embodiment of DAM behavior and

DOM Proxy behavior that implement a protocol useful in connection with the present invention.

Once the client 18 has made the initial connection with a server 14, the DAM 46 is in an Initial

state 60 and the DOM Proxy 50 is in an Initial state 80. The DAM 46 remains in the Initial state

60 until an active document 10 identifies an executable portion 34 associated with a content

component. Once an executable portion 34 is identified, the DAM 46 initiates a connection with

the DOM Proxy 50 on the server 14 (arrow 62) and enters a Connect Pending state 64.

In one embodiment, initiation of the connection yarrow 62) is accomplished by sending a

message to the server 14 indicating that a connection is rec uested. In some embodiments, the connect message may include information relaxing to the requested connection, such as the active document 10 to which the connection request relates, a maximum number of content components

that may be specified during the connection, the preferred speed at which to transfer information

relating to content components, and whether to use encryption when transferring data.

If the DOM Proxy 50 accepts the connection request, the DAM 46 receives one or more

messages from the DOM Proxy 50 acknowledging the connection request (arrow 82 of FIG. 7

and arrow 66 of FIG. 6). The DAM 46 transitions to a Connected state 68 and the DOM Proxy transitions to a Connected state 84. The acknowledgment messages received from the DOM

Proxy 50 may include application initialization results, including one or more commands

instructing the DAM 46 to make changes to one or more content components of the active

document 10.

If the DOM Proxy 50 rejects the connection request or if the connection fails for some

other reason, such as physical media failure, absence of a response from the server 14, server

failure or an explicit signal from the local transport mechanism indicating a loss of server

responsiveness, the DAM 46 returns to the Initial state 60.

While in their respective Connected states 68, 84 the DAM 46 and the DOM Proxy 50

may both initiate synchronous and asynchronous messages. Synchronous messages require acknowledgement of completion, while asynchronous messages do not require any

acknowledgement. Table 1 below lists a number of exemplary messages that may be generated by a server.

Table 1 - Exemplary messages generated by server

The DOM Proxy 50 may generate a number of asynchronous commands that may be sent to the

DAM 46 in any order. When transmitting asynchronous commands to the DAM 46, the DOM

Proxy 50 remains in the Connected state 85 (arrow 86), as does the DAM 46 (arrow 70). When

the DOM Proxy 50 transmits a synchronous event to the DAM 46, the DOM Proxy enters a

Client Busy state 90 (arrow 88). In this state, the DOM Proxy 50 waits for the DAM 46 to

respond to the synchronous command. The DOM Proxy 50 returns to the Connected state 84

upon receipt of a response from the DAM 46 (arrow 92). The DAM remains in the Connected

state 68 when responding to synchronous messages from the DOM Proxy 50 (arrow 72). Examples of DAM 46 responses are shown in Table 2 below:

Table 2 - Exemplary messages generated by client

Input from the user that the DOM Proxy 50 has identified as being of interest is sent from

the browser 22 to the DAM 46 for transmission to the DOM Proxy 50. The DAM 46 transmits a

synchronous event message to the DOM Proxy 50 and transitions to an Event Sent state 76

(arrow 74). When the DOM Proxy receives the synchronous message from the DAM 46, it

transitions to an Event Received state 96 (arrow 94). While in Event Sent state 76, the DAM 46

remains able to receive and respond to messages from the DOM Proxy 50 as in its Connected

state 68 (arrows 72', 70'). While in its Event Sent state 76, however, the DAM 46 may not

generate additional event messages and, therefore, the browser 22 will not respond to user input. When the DAM 46 transmits a synchronous event message to the DOM Proxy 50, the

DOM Proxy 50 transitions to an Event Received state 96 (arrow 94). In this state, the DOM

Proxy 50 interacts with the executable portion of the active document 10 to update the active

document 10. Once the active document has been updated with the user input, the DOM Proxy

50 transmits a message indicating that the event has been processed to the DAM 46 and

transitions to the Connected state 84 (arrow 98). Similarly, the DAM transitions to its Connected

state 68 (arrow 78).

Data associated with the active document 10 is received by the DOM proxy 50 and

communicated to the executable portion 34 of the active document 10 and/or other applications

58 residing on the server 14. Similarly, data associated with the active document 10 destined for the client 18 is sent to the DOM proxy 50 for transmittal.

In one exemplary embodiment, Fig. 8 shows an active document 10 that is a real estate

web page 100. One feature of this web page is to create a table 120 within the active document

10 according to the user's selected criteria. This web a^e 100 displays several components 104,

108, 112, 116, 120 that would be included as part of the co tents portion 38 of the active

document that is sent to the client 18. One component is an ima e map of the United Kingdom 104. This is used to select a

particular county. There are also several instances of a check box component 108 for the user to

identify criteria to be used in the search. There are four instances of a selection component 1 12

for the user to select out of a group of items. There are 2 instances of a text field component 116

for the user to select price. There is a table component 120 and it is empty when it is initially

sent as part of the contents portion 38 of the active document 10.

The picture component 124 is not initially sent to the client 18 as part of the contents

portion 38. As stated above, in addition to altering the components of the contents portion 38,

the executable portion 34 may also add or remove components from the contents portion 38. The

picture component 124 is an example of a component that is not sent to the client 18 until there is

some user input.

The executable portion 34 of the web page 100 remains on the server 14. The executable

portion 34 monitors the user inputs (i.e., monitors the components 104, 108, 1 12, 1 16 of the

contents portion 38) and creates the table component 120 in response to those user selections.

The database of available real estate that is used to select from may be part of the executable

portion 34 or it may be part of the other applications 58.

The executable portion also alters the other components of the contents portion 38. For

example, when the cursor is moved over a county in the UK image map 104 and there is a mouse

click, the executable portion 34 will change the list of towns in the town selection component

1 12a to match the selected county. In more detail, to effect this change, the following steps

occur. The client 18 establishes initial communication with the server 14 over communication

channel 30, which is the Internet. The browser 22 sends the web server software 54 the URL

corresponding to the real estate web page 100. The web server software retrieves the web page

100 (i.e., active document 10) from its storage location. The web page 100 is defined in accordance with the DOM Level 1 specification. The server 14 transmits the contents portion 38 of the web page 100 to the client 18. The browser 22 accesses the contents portion 38 of the web

page using the DOM API 42 and displays the web page 100 by displaying each of the

components 104, 108, 1 12, 116, 1120 of the contents portion 38.

For data transfer associated with the web page 100, the browser 22 initializes the DAM

46, if not initialized and establishes a communication channel 30b for data transfer to and from

the DAM 46. If the client does not have a DAM 46, then one may be downloaded in several

different ways including with the contents portion 38 of the web page 100. For data transfer

associated with the web page 100, the web server software 54 initializes the DOM Proxy 50, if not initialized and establishes a communication channel 30b for data transfer to and from the

DOM Proxy 50.

As the user on the client 18 performs a mouse click on one county on the UK image map

104, this event is captured by the client-based DOM API 42 and sent to the DAM 46. The DAM

46 packs the data representing this event and transmits it to the DOM Proxy 50 according to, for

example, the steps identified in connection with FIG. 6. The DOM Proxy 50 unpacks the data

and transmits it, via the server 14 based DOM API 42 to the executable portion 34. In response to this event, the executable portion 34 creates a command to alter the town selection list

component 112a in the contents portion 38 to make the list match the county selected. The

executable portion retrieves the list of applicable towns. The executable portion 34 issues a

command to change the selection list component 112a to the retrieved list. The executable

portion 34 sends this command to the server 14 based DOM API 42. The DOM Proxy 50 packs

the data representing this command and transmits it to the DAM 46. The DAM 46 unpacks the

data and sends the command to the client 18 based DOM API 42. The client-based DOM API 42

readily understands this command, as it was issued for the server-based DOM API 42. Beside the transmission delay, this creates a seamless operation, even though the executable portion 34

is executed remotely from the client 18. The client based DOM API 42 then alters the component 112a according to the command and the selection list is updated. As the DOM API is

altering the component 112a in its storage location, the browser modifies the display accordingly.

The invention may be embodied in other specific forms without departing from the spirit

or essential characteristics thereof. The foregoing embodiments are therefore to be considered in

all respects illustrative rather than limiting on the invention described herein. Scope of the

invention is thus indicated by the appended claims rather than by the foregoing description, and

all changes that come within the meaning and range of equivalency of the claims are therefore intended to be embraced therein.

Claims

CLAIMS What is claimed is: 1. A method for providing an active document to a client over a communication channel, said active document including a contents portion and an executable portion, said method comprising the steps of:

(a) transmitting over said communication channel to said client at least a part of said contents portion of said active document;

(b) generating output data from said executable portion of said active document; and

(c) transmitting over said communication channel to said client said generated output data to change at least a part of said transmitted content portion of said active document by said client.

2. The method of claim 1 further comprising the step of receiving from said client a request identifying said active document.

3. The method of claim 1 further comprising the step of receiving from said client a URL address identifying said active document.

4. The method of claim 1 wherein step (b) comprises:

(b-a) receiving data from said client; and

(b-b) generating, responsive to said received data, output data from said executable portion of said active document.

5. The method of claim 1 further comprising the step of maintaining said executable portion of said active document on a server.

6. The method of claim 1 further comprising the steps of:

a) executing said executable portion of said active document; b) changing at lea it a part of said contents portion of said active document in response to said execution of said executable portion of said active document.

7. The method of claim 1 further comprising the steps of:

a) executing a second application that interacts with said active document; and

b) changing at least a part of said contents portion of said active document in response to said execution of said second application.

8. A server for providing an active document to a client over a communication channel, said active document including a contents portion and an executable portion, said server comprising:

an output data generator producing output data in response to said executable portion of said active document; and

a transceiver receiving said generated output data for transmission over said communications channel, said transceiver including an API for manipulating said contents portion of said active document.

9. The server of claim 8 wherein said output data generator produces output data in response to input data received from said communications channel.

10. The server of claim 9 wherein said API comprises a DOM API.

11. The server of claim 9 wherein said transceiver transmits generated output data over said communications channel.

12. A client for receiving over a communications channel and displaying an active document, said active document including a contents portion and an executable portion, said client comprising:

a browser interface, said browser interface in communication with a browser application;

a transceiver receiving data via said communication channel and transmitting received data to said browser interface.