WO2000051019A1

WO2000051019A1 - Editing a remotely located document in an application-specific format via an sgml-format version of the document

Info

Publication number: WO2000051019A1
Application number: PCT/US1999/026912
Authority: WO
Inventors: Henry Nouri; Jose Collazo
Original assignee: Smart Online, Inc.
Priority date: 1999-02-26
Filing date: 1999-11-12
Publication date: 2000-08-31
Also published as: AU1622500A

Abstract

Systems, methods, and computer program products are provided for modifying a document created within an application program without opening the document within the application program. In a client-server environment, an applet is downloaded from a Web server containing a document to a Web client in response to a user request to modify the document. An SGML-format version of the document is displayed on the Web client via the applet. The SGML-format version of the document includes selected portions that are configured to receive user input. User input obtained via the SGML-format version of the document is used to modify selected portions of the first document via the applet.

Description

EDITING A REMOTELY LOCATED DOCUMENT IN AN APPLICATION-SPECIFIC FORMAT VIA AN SGML-FORMAT VERSION OF THE DOCUMENT

Field of the Invention

The present invention relates generally to documents and, more particularly, to systems, methods and computer program products for editing documents. 5

Background of the Invention

With the advent of the Internet, and the World Wide Web in particular, the ability to quickly and easily share information with persons located

10 around the world is possible. For example, utilizing a web browser and a computer connected to the Internet, a person located anywhere in the world can view documents stored within a web server that is also connected to the Internet. However, conventional web browsers have

15 the ability to interpret and display a limited number of document formats, such as the HyperText Markup Language (HTML) format used by web servers (i.e., HyperText Transfer Protocol or HTTP servers) . Conventional web browsers may not have the ability to

20 directly display a document in the document's native application format. For example, a document created in a native application, such as Microsoft Word^® and Microsoft Excel^®, may not be directly displayable within a web browser.

To overcome this limitation, conventional -web browsers may utilize helper applications to interpret files that a web browser has retrieved but is unable to read. Often, a helper application is the actual application within which a document was created. For example, to view and edit a copy of a Word^® document stored within a web server, a web browser could launch a version of Word^® on the requesting user's computer.

Unfortunately, unless a user has a helper application that can open a document created in a particular format, he or she may not be able to view the document within a web browser. Furthermore, without opening the document within the application within which the document was created, a person may not be able to edit the document using a web browser. To be able to view and edit documents in various formats available through the Internet, a user may need multiple helper applications that are configured to interpret and open documents in the various formats that are encountered on the Internet. Unfortunately, a multiplicity of helper applications may be economically undesirable, as well as unfeasible, for many users.

Accordingly, documents displayed via web browsers are generally either created as HTML documents or are converted from a native application format to an HTML format. For example, a user can create a document using a word processing application such as Microsoft's Word^® word processing application and then convert the Word^® document to an HTML document using a conversion tool provided within the Word^® application. Unfortunately, because of the generally static nature of HTML documents, conventional web browsers do not provide users with the ability to edit displayed HTML documents.

Summary of the Invention In view of the above discussion, it is an object of the present invention to allow Internet users to view and edit, via a web browser, a document generated within the document's native application without requiring that the application be launched within the web browser.

It is another object of the present invention to allow Internet users to modify documents displayed via a web browser such that any modifications are also made to a format of the document that is not displayable within a web browser.

These and other objects of the present invention are provided by systems, methods, and computer program products for modifying a first document created within a first application program without opening the first document within the first application program. According to the present invention, a first document is stored within a first computer (i.e., a web server), and a second computer (i.e., a web client) is in communication with the first computer. An applet is downloaded from the first computer to the second computer in response to a user request to modify the first document. A second document is displayed on the second computer via the applet. The second document is a Standard Generalized Markup Language (SGML) format version of the first document, and includes selected portions that are configured to receive user input .

The second document is displayed via an applet running on the second computer via the following steps performed by the applet. The second document is prepared as a tokenized file stream. The tokenized file stream is then read to identify each markup language tag and each portion of the second document associated with a respective identified markup language tag. Each identified markup language tag and respective second document portion associated with each identified markup language tag is stored as respective objects in a first vector. The second document is then rendered within a scrollable JAVA^® canvas using the objects stored in the first vector.

The second document is created by replacing formatting code in a copy of the first document with respective SGML tags that can mimic the first document formatting code when the second document is displayed via the applet . Interactive SGML tags are also inserted within selected portions of the second document that can allow user input to be obtained when the second document is displayed via the applet. User input is obtained within at least one of the selected portions of the displayed second document. The first document on the first computer is then modified, via the applet, using the user input obtained within the at least one selected portions of the displayed second document. The modified first document is then displayed on the second computer via the applet .

Operations for modifying the first document to include the obtained user input include storing obtained user input as respective objects in a second vector and sending, via the applet, the second vector to the first computer along with an identity of the ' first document. Selected portions of the first document are then modified with objects stored within the second vector. Both the obtained user input and a copy of the modified first document can be stored within the first computer for later access by a user. The present invention is advantageous because users can view and modify documents generated within various application programs without requiring that each document be opened within a respective application program.

Brief Description of the Drawings Fig. 1 illustrates a client-server computing environment in which the present invention may be embodied. Fig. 2 illustrates an exemplary HTML document with markup language tags displayed.

Fig. 3 schematically illustrates a system for editing a document generated by an application program without opening the document within the application program, according to an embodiment of the present invention.

Fig. 4 illustrates operations for displaying and editing a remotely located document having a native application program format via a version of the document in an SGML format, according to an embodiment of the present invention.

Fig. 5 illustrates a document generated and displayed within a version of Microsoft ' s Word^® word processing application.

Fig. 6 illustrates operations for creating an SGML format document that includes selected portions configured to receive user input, according to the present invention.

Fig. 7 illustrates the Word^® document of Fig. 5 converted from Word^® format (i.e., the native application format) to a document having an SGML format, according to the present invention.

Fig. 8 illustrates a user interface according to the present invention within which a user can select, display, and purchase documents for editing, according to the present invention. Fig. 9 illustrates a user interface according to the present invention within which a user can provide input for designated user-editable portions of a displayed SGML format document .

Fig. 10 illustrates operations according to the present invention for displaying a copy of a document in SGML format via an applet running within a JAVA^®-enabled web browser, wherein the document is configured to receive user input .

Fig. 11 illustrates operations for obtaining user input within selected portions of a displayed document in SGML format, according to the present invention.

Fig. 12 illustrates operations for modifying a copy of a document in a native application format using the obtained user input, according to the present invention. Fig. 13 illustrates a Word^® document that has been modified by a user according to the present invention without opening the document within the Word^® word processing application program.

Detailed Description of the Invention

The present invention now is described more fully hereinafter with reference to the accompanying drawings, in which preferred embodiments of the invention are shown. This invention may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the invention to those skilled in the art. The present invention will now be described more fully hereinafter with reference to the accompanying drawings, in which preferred embodiments of the invention are shown. Like numbers refer to like elements throughout.

As will be appreciated by one of skill in the art, the present invention may be embodied as a method, data processing system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product on a computer-usable storage medium having computer-usable program code means embodied in the medium. Any suitable computer readable medium may be utilized including hard disks, CD-ROMs, optical storage devices, or magnetic storage devices.

Client-Server Communications

The present invention is preferably practiced within a client-server computer network environment. As is known by those skilled in this art, client-server is a model for a relationship between two computer programs in which one program, the client, makes a service request from another program, the server, which fulfills the request. Although the client-server model can be used by programs within a single computer, it is more commonly used in a network where computing functions and data can be distributed more efficiently among many client and server programs at different network locations.

Many business applications being written today use the client-server model, as does the Internet's main program, "Transmission Control Protocol/Internet Protocol" (TCP/IP) . Typically, multiple client programs share the services of a common server program. Both client programs and server programs are often part of a larger program or application. Relative to the Internet, a web browser is a client program that requests services (the sending of web pages or files) from a web server in another computer somewhere on the Internet. Similarly, a computer with TCP/IP installed allows client requests for files from File Transfer Protocol (FTP) servers in other computers on the Internet . As is known to those with skill in this art, client-server environments within which the present invention may operate include public networks, such as the Internet, and private networks often referred to as "Intranets" and "Extranets." The term "Internet" shall incorporate the terms "Intranet" and "Extranet" and any references to accessing the Internet shall be understood to mean accessing an Intranet and/or and Extranet, as well. The term "computer network" shall incorporate publicly accessible computer networks and private computer networks .

Fig. 1 illustrates a client-server computing environment in which the present invention may be embodied. In the illustrated system, a remote user's computer 10 has a client application (i.e., a web browser) resident thereon and a host computer 20 has a server application (i.e., a web server) resident thereon. The user's computer 10 preferably includes a central processing unit 11, a display 12, a pointing device 13, a keyboard 14, access to persistent data storage, and a communications link 16 for communicating with the host computer 20. The keyboard 14, having a plurality of keys thereon, is in communication with the central processing unit 11. A pointing device 13, such as a mouse, is also connected to the central processing unit 11. The communications link 16 may be established via a modem 15 connected to traditional phone lines, an ISDN link, a Tl link, a T3 link, via cable television, via an ethernet network, and the like. Modem 15 may also be a wireless modem configured to communicate with the modem 25 of the host computer 20 via wireless communications systems . The communications link 16 also may be made by a direct connection of the user's computer 10 to the host computer 20 or indirectly via a computer network 17, such as the Internet, in communication with the host computer 20.

The central processing unit 11 contains one or more microprocessors (not shown) or other computational devices and random access memory (not ^■ shown) or its functional equivalent, including but not limited to, RAM, FLASHRAM, and VRAM for storing programs therein for processing by the microprocessor (s) or other computational devices. A portion of the random access memory and/or persistent data storage, referred to as "cache, " is often utilized during communications between a user's computer 10 and a host computer 20 to store various data transferred from the host computer.

Preferably, a user's computer 10 has an Intel^® Pentium^® processor (or equivalent) with at least thirty-two megabytes (32 MB) of RAM, and at least five megabytes (5 MB) of persistent computer storage 15 for caching. However, it is to be understood that various processors may be utilized to practice the present invention without being limited to those enumerated herein. Although a color display is preferable, a black and white display or standard broadcast or cable television monitor may be used.

Exemplary user computers having a web browser resident thereon may include, but are not limited to, an Apple^®, Sun Microsystems^®, IBM^®, or IBM^®-compatible personal computer. A user's computer 10, if an IBM^®, or IBM^®-compatible personal computer, preferably utilizes either a Windows^®3.1, Windows 95^®, Windows 98^®, Windows NT^®, UNIX^®, or OS/2^® operating system. However, other operating systems may also be utilized without limitation. In addition, it is to be understood that a terminal not having computational capability, or having limited computational capability may be utilized in accordance with the present invention for accessing a host computer 20 in a client capacity. Preferably, a web browser resident on a user's computer 10 is a JAVA^®-enabled browser, such as Netscape Navigator, Version 3.0 and higher. As is understood by those skilled in this art, a JAVA-enabled browser includes a JAVA^® virtual machine (JVM) that interprets JAVA^® bytecode into code that will run on the user's computer.

A host computer 20, functioning as a web server, may have a configuration similar to that of a user's computer 10 and may include a central processing unit 21, a display 22, a pointing device 23, a keyboard 24, access to persistent data storage, and a communications link 26 for connecting to the user's computer 10 via a modem 25, or otherwise. It is preferable that a host computer 20 have an Intel^® Pentium^® processor or equivalent. However, a host computer 20 for carrying out the present invention may be implemented using various types of processors and via various types of computing devices, including, but not limited to, mainframe computing systems and mini- computers.

It is understood that a user's computer having a web browser resident thereon or a host computer having a web server resident thereon or other apparatus configured to execute program code embodied within computer usable media, may operate as means for performing the various functions and carrying out the methods of the various operations of the present invention .

Standard Generalized Markup Language

Standard Generalized Markup Language (SGML) is a standard for how to specify a document markup language or tag set. SGML is based on the idea that documents have structural and other semantic elements that can be described without reference to how such elements should be displayed. The actual display of such a document may vary, depending on the output medium and style preferences .

HyperText Markup Language (HTML) , is an example of an SGML-based language . An HTML document can be comprised of text, images and a variety of objects, each of which are surrounded by various markup language tags that control format attributes and identify different portions of the document (i.e., <tag_name>text</tag_name>) . It is to be understood that the terms "tag" and "markup language tag" can be used interchangeably. HTML documents are typically written and stored in ASCII text format using a text editor.

Markup language tags are conventionally denoted by the "< >" symbols, with an actual tag located between the brackets . Most markup language tags have a beginning tag "<tag>" and an ending tag

"</tag>." For example, to make a line of text appear as a heading the following tags enclose the text: <H3x/H3>. (<H3>This text appears as a heading. </H3>) . To make a word or line of text appear in bold the text is enclosed by the tags: <Bχ/B>. (<B>Bold text</B>) .

In addition there are numerous link tags in HTML to enable the viewer of a Web page to jump to another place in the same page, to jump to a specific place in another Web page, or to create and jump to a remote link to another Web server. HTML is described in the HTML Reference Manual, published by Sandia National Laboratories, January 6, 1996, which is incorporated herein by reference, in its entirety. Because markup language tags are used only within an HTML source document located on a web server, they do not appear within the actual completed online page. An exemplary HTML document 30 is illustrated in Fig. 2. The illustrated HTML document 30 includes a header section 32 demarcated by <HEAD> tags 32a, 32b. A body section 34, demarcated by <BODY> tags 34a, 34b, includes various "content" portions 36a, 36b, 36c, 36d. It is these content portions 36a, 36b, 36c, 36d that contain information displayed to a user viewing the HTML document 30 with a web browser.

A document type definition (DTD) is a specific definition that follows the rules of SGML. A DTD is a specification that accompanies a document and identifies the functions of the markup tags contained within the document . By sending a DTD with a document, an SGML compiler can process the document and display or print the document as intended via the markup tags. Conventional web browsers are SGML compilers designed to handle HTML (a particular DTD) .

Markup Language of the Present Invention

The present invention utilizes a specialized, proprietary DTD that follows the rules of SGML.

Included within the DTD of the present invention are markup tags that allow designated portions of a document to become interactive when displayed via a specialized SGML compiler. According to the present invention, a JAVA^® applet configured to run within a JAVA^®-enabled web browser contains an SGML compiler . configured to process documents containing the specialized markup tags of the present invention.

Exemplary markup tags are illustrated below in Table 1.

Table 1

Additional exemplary markup tags are listed below in Table 2.

Table 2

<L> Left Justification (Left justifies a paragraph)

<R> Right Justification (Right justifies a paragraph)

<CENTER> </CENTER> Center (Center a paragraph)

<CBxxx> </CBxxx> Click here blocks (user-editable portion) Hardware and Software Environment

The present invention is preferably implemented as a plurality of modules within a web server. These modules, which are compatible with all web server software including, but not limited to,

Apache, CERN HTTPD, NCSA HTTPD, Netscape, Microsoft NT, Quarterdeck and Spry, implement one or more JAVA^® applets which are configured to interact with a user through a web browser. JAVA^® is an object-oriented programming language developed by Sun Microsystems, Mountain View, California. JAVA^® is a portable and architecturally neutral language. JAVA^® source code is compiled into a machine-independent format that can be run on any machine with a JAVA^® runtime system known as the JAVA^® Virtual Machine (JVM) . The JVM is defined as an imaginary machine that is implemented by emulating a processor through the use of software on a real machine. Accordingly, machines running under diverse operating systems, including UNIX^®, Windows NT^®, and

Macintosh^® having a JVM can execute the same JAVA^® program .

Web browsers including Netscape Navigator^® (version 3.0 and higher) and Microsoft Internet Explorer^® (version 3.0 and higher) are referred to as JAVA^®-enabled browsers because they include a version of the JVM. JAVA^® applets are programs written in JAVA^® and configured to run within JAVA^®-enabled browsers. Handled in a manner similar to the way images are handled, JAVA^® applets are displayed as part of an HTML document. When an applet is loaded, it can present special effects, such as animation, graphics, and sound, perform real-time data updates and applications, and can interact with a user through a mouse, keyboard and various interface elements such as buttons, slides and text fields. As is known to those skilled in this art,

JAVA^® source code is compiled into bytecode using a JAVA^® compiler referred to as a JAVAc . Compiled JAVA^® programs are saved in files with the extension ".class". When a JAVA^®-enabled web browser recognizes that an applet has been requested, a JAVA^® interpreter program runs the applet bytecode on the JVM within the web browser.

Referring now to Fig. 3, an exemplary system 40 for practicing the present invention, is schematically illustrated. In the illustrated configuration, an SGML converter 41 is utilized to convert a document 42 in a native application format to a document 43 having an SGML format that is dissimilar to the native application format (i.e., a non-native application format) . An example of a document in a native application format is a Word^® document created within the Word^® word processing application. Specifically, the formatting code of the document 42 is replaced with proprietary SGML-based markup.tags, as described above. Converters for converting a document from a native application format to an SGML-based language format are known to those skilled in this art, and need not be described further herein.

According to the illustrated embodiment, a web server 44 is configured to store a copy of the document 42 in the native application format and a copy of the converted document 43 in the SGML (i.e., non- native application) format. Preferably, the web server 44 hosts a plurality of documents in respective native application formats and a corresponding plurality of documents converted to SGML formats, as illustrated: In addition, the illustrated web server 44 includes persistent data storage 45 (or access thereto) for storing user input provided within designated areas of a document, as will be described below. The illustrated web server 44 also includes a user document generator module 46 for merging stored user input with a copy of a document 42 stored therewithin in a native application format. Preferably, the web server 44 also includes persistent data storage 47 (or access thereto) for storing user modified documents. In the illustrated embodiment, a client computer 50 is in communication with the web server 44 via a computer network, such as the Internet 51. A JAVA^®-enabled web browser 52 running on the client computer 50 is configured to make client requests to the web server 44. An applet 54 downloaded from the web server 44 and configured to display a document to a user and accept user input in designated portions of the document, according to the present invention, is running within the web browser 52. The applet 54 includes a loader module 56, a parser module 58, a renderer module 60, and a scrollable JAVA^® canvas 62. Together, the loader module 56, parser module 58, renderer module 60, and scrollable JAVA^® canvas 62 serve as means for displaying a document in an SGML format to a user and as means for accepting user input in designated portions of the displayed document. Together, the loader module 56, parser module 58, renderer module 60, and scrollable JAVA^® canvas 62 also serve as means for transmitting user input to the web server 44 for use in modifying a copy of a displayed document in a native application format. Each of these components are described in detail below.

Computer program code for carrying out aspects of the present invention is preferably written in the JAVA^® object oriented programming language . However, portions of the computer program code for carrying out operations of the present invention may also be written in other object oriented programming languages such as Smalltalk or C++, as well as conventional procedural programming languages, such as the "C" programming language. The present invention is described below with reference to flowchart illustrations of methods, apparatus (systems) and computer program products according to an embodiment of the invention. It will be understood that each block of the flowchart illustrations, and combinations of blocks in the flowchart illustrations, can be implemented by computer program instructions . These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including .instruction means which implement the function specified in the flowchart block or blocks.

The computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart block or blocks.

Referring now to Fig. 4, operations for displaying and editing a remotely located document having a native application format via a version of the document in an SGML format , according to an embodiment of the present invention, are schematically illustrated. A document (42, Fig. 3) created in a native application, such as Word^®, contains selected portions that are designated for receiving user input (also referred to as "user-editable portions"). A converter (41, Fig. 3) is utilized to create a second document that is a version of the first document (43, Fig. 3) in an SGML format that can be displayed within an applet running on a web browser (Block 100) . A copy of the document in the native application format and a copy of the SGML format document are stored within a web server (or accessible thereto) (Block 200) .

Upon receiving a web browser request from a user, the SGML format document is displayed within an applet downloaded to the user's computer from the web server (Block 300) . User input provided within selected user-editable portions of the displayed document is ■ then obtained (Block 400) . The obtained user input is then used to modify a copy of the document in the native application format (Block 500) . A copy of the modified document in the native application format is then transmitted to the user's client computer (Block 600) .

Create SGML Format Document With Designated Portions For Receiving User Input

Initially, a document is created in a native application format that cannot be directly displayed or edited within a web browser . Documents created by many applications such as, but not limited to, Microsoft Word^®, Microsoft Excel^®, Corel WordPerfect^®, Lotus 123^®, conventionally have respective formats that cannot be directly displayed or edited within a web browser. For example, Fig. 5 illustrates a document 60 generated and displayed within a version of Microsoft ^■ s Word^® word processing application 62. As is understood by those skilled in this art, a Word^® document cannot be directly displayed or edited within a web browser, without launching the Word^® application within the web browser and displaying (and editing) the Word^® document therein. However, this typically requires that the Word^® application be located on the user's computer or be accessible via the user's computer.

The illustrated Word^® document 60 contains various portions 64a-64h that are designated as user- editable. The user-editable portions 64a-64h are indicated by leading and trailing "#" symbols, as illustrated. However, it is to be understood that various symbols may be utilized for designating portions of a document as user-editable. In addition, the illustrated Word^® document 60 contains a portion 66 that is centered and displayed in bold style.

Referring to Fig. 6, operations for creating a document in SGML format from a document in a native application format that is directly displayable within an applet running within a web browser (Block 100) are illustrated. An SGML format document is created by replacing the formatting code of the document in the native application format with markup language tags that are capable of mimicing the native application formatting code (Block 110) . In addition, proprietary- interactive markup language tags are placed around portions of the document designated for receiving user input (Block 120) . As is known to those skilled in this art, a markup language tag describes to a compiler the style and function of a respective portion of a document associated with the markup language tag. According to the present invention, format code from the native application of a document can be replaced with specific markup language tags. For example, format code that designates a portion within the requested document to be displayed in bold style can be replaced with the markup language tags "<Bx/B>", which surround the particular document portion.

Referring now to Fig. 7, an SGML format document 70 has been created from the Word^® document 60 of Fig. 5. As illustrated, markup language tags are utilized to describe to the style and function of respective portions of ^♦-he document 70. For example, on the first line of the illustrated document 70, the * document portion "NOTE AND GUARANTEE" is surrounded by the markup language tags <Bx/B> and <CENTERx/CENTER> . These markup language tags describe to a compiler that the document portion "NOTE AND GUARANTEE" is to be centered in bold style when displayed. Similarly, respective pairs of markup language tags

<cb002x/cb002>, <cb002x/cb002>, <cb003x/cb003>, <cb004x/cb004>, <cb005x/cb005> , <cb006x/cb006>, <cb007x/cb007>, <cb008x/cb008> , and <cb009x/cb009> surround respective portions of the document 70 that were designated as user-editable in Fig. 5 (i.e., 64a- 64h) . A copy of the document 60 in the native application format and a copy of the document 70 in SGML format are then stored in a location within (or accessible by) the web server (Block 200, Fig. 4) . The creation of SGML format documents from documents in a native application format can be performed either during creation of the native application document or subsequent to creation of the native application document. Preferably, conversion is performed during creation of the first document via an SGML plug- in component (i.e., 41, Fig. 3) that can be added on to an application such as Word^®. An SGML plug- in component conventionally is configured to convert the formatting of a document prepared by an application into various markup language tags. SGML plug-in components may be utilized with a wide range of applications, including, but not limited to, word processing applications and spread sheet applications. SGML plug-in components for converting the formatting code of a document produced by an application to markup language tags are well known in this art and need not be described further herein.

Alternatively, the creation of an SGML format document from a native application document format can be performed "on-the-fly" in response to receiving a user request for a document, according to the present invention.

Displaying Copy of Document in SGML Format Via Applet Downloaded to Web Client

Referring now to Fig. 8, a user interface 80 within which a user can select, display, edit and purchase documents created in a format not directly displayable via a web browser is illustrated. The user interface 80 includes a selection area 81 for selecting a category of documents and a selection area 82 for selecting a particular document within a selected category. A display area 83 is provided for displaying a selected document. The illustrated user interface 80 is preferably displayed within a web browser on a user's computer via an applet downloaded from a web server (44, Fig. 3) .

When a user selects a. document for display within the user interface 80 of Fig. 8, a loader module (56, Fig. 3) within the applet 54 retrieves a copy of the SGML format of the selected document stored within (or accessible to) the web server (44, Fig. 3) .

Preferably, a user can obtain a copy of the selected document by passing to the loader module (56, Fig. 3) the name of the document and the name of the web server within which the document is stored. The loader module (56, Fig. 3) then retrieves and passes a copy of the document in SGML format as a tokenized stream to the parser module (58, Fig. 3) and renderer module (60, Fig. 3) within the applet 54.

In the illustrated embodiment of Fig. 8, a document 85 entitled "NOTE AND GUARANTEE" from the category "PROMISSORY NOTE" has been selected by a user and is displayed within the display area 83. The displayed document 85 in Fig. 8 is the Word^® document 60 of Fig. 5 displayed in SGML format. The displayed document 85 in Fig. 8 is configured to have a similar appearance to that of the original Word^® document 60 displayed in Fig. 5. In addition, the various portions 64a-64h of the document 60 of Fig. 5 that are designated as user-editable are provided within the displayed document of Fig. 8 in italics and designated as 64a¹ -64h', respectively. In order to provide input within the user- editable portions 64a' -64h' of the displayed document 85, a user purchases the document 85 by clicking on the illustrated "Buy" button 84. When the "Buy" button 84 is clicked by a user, any of various known electronic- commerce methods can be invoked to conduct a transaction with the user to allow the user to purchase the selected document. Electronic-commerce methods via the Internet are well known by those skilled in this art, and need not be described herein. Once purchased, the document 85 is displayed within the user interface 86 illustrated in Fig. 9. The illustrated user interface 86 of Fig. 9 provides a user with the ability to navigate through the document 85 and provide input in the user-editable portions 64a'- 64h' . Buttons 87, 88 enable a user to navigate to the previous and next user-editable portion, respectively. Referring now to Fig. 10, operations for displaying a copy of a document in SGML format that is configured to receive user input within the user interface 86 of Fig. 9 (Block 300) will now be described. In response to receiving a client request to display a selected document, a loader module (56, Fig. 3) within the applet (54, Fig. 3) passes a copy of the selected document in SGML format as a tokenized file stream to the parser module (58, Fig. 3) (Block 310) . The loader module (56, Fig. 3) serves the function of a "tokenizer." As is understood by those skilled in this art, a tokenizer "reads-in" text input and "outputs" individual tokens, one for every word, each on a separate line, until the end of the input is reached. Table 3 below illustrates an exemplary tokenizer for tokenizing the text input "Good dogs do not bite their masters . "

Table 3

#include <rw/ctoken.h>

#include <rw/rstream.h> mai ( ) {

RWCString a ("Good dogs do not bite their masters ");

RWCTokenizer nex (a) ; // Tokenize the string a

RWCString token; // Will receive each token

// Advance until the null string is returned: while ( ! (token=next () ) . isNullO ) cout << token << "\n / }

Program output produced by the tokenizer of Table 3 is illustrated in Table 4

Table 4

Good dogs do not bite their masters

The parser module (58, Fig. 3) reads the tokenized file stream provided by the loader module (56, Fig. 3) and identifies each markup language tag and each portion of the selected document associated with a respective identified markup language tag (Block 320) . The parser module (58, Fig. 3) then takes the tokenized file stream and forms a hierarchical structure similar to a phrase marker or a relational diagram.

According to the present invention, the parser module (58, Fig. 3) provides means for building up descriptions of sequences of words/tokens. Tokens ultimately form a description of a document. For example, a document may be broken into separate parts as illustrated below in Table 5 (these other parts are also comprised of tokens) .

Table 5

Document

- Paragraph

- Sentence

- Formated Text

- User-editable fields Each identified markup language tag, and respective document portion associated therewith, is stored as a respective object in a first vector (Block 330) . As is known to those skilled in this art, a vector is an array that is re-sizeable and threadsafe .

A renderer module (60, Fig. 3) within the applet (54, Fig. 3) then renders the selected document within a scrollable JAVA^® canvas 62 on the display of a user's computer using the objects stored in the first vector (Block 340) . For each object stored within the first vector, a markup language tag associated with a respective portion of the selected document is read by the renderer module (50, Fig. 3) to set the attributes and behavior of the respective document portions within the scrollable JAVA^® canvas 62. Each document portion associated with a respective markup language tag is then rendered, word-by-word, according to respective markup language tags associated therewith. The renderer module (60, Fig. 3), preferably renders each object stored within the first vector "on-the-fly. " The document 85 displayed within Figs. 8 and 9 has been rendered within a scrollable JAVA^® canvas 62 according to the above-described operations.

Obtaining User Input Within User-Editable

Portions of Displayed Document

Referring back to Fig. 9, a user has purchased the document 85 and has begun providing input in the designated user-editable portions 64a¹ -64h'. User-editable portions 64a' -64c¹ have been modified by a user as indicated. User-editable portion 64d' is currently activated so as to receive user input. User- editable portions 64e'-64h' have not been modified by the user.

Referring now to Fig. 11, a user provides input in user-editable portions of a document (Block 400) . The renderer module (60, Fig. 3) renders the entire document within a displayed scrollable JAVA^® canvas 62 to reflect the added user input (Block 410) . User input is stored as objects within a second vector (Block 420) . Preferably, after user input is provided for a particular user-editable portion, focus is thrown on the next user-editable portion.

Modifying Copy of Document in Native Application Format to Include Obtained User Input Referring now to Fig. 12, operations for modifying a copy of a document in a native application format using obtained user input (Block 500) will be described. After a user has provided input within the user-editable portions of an SGML format document displayed within a scrollable JAVA^® canvas (62, Fig. 3), the second vector containing user input is transmitted to the web server (44, Fig. 3) along with an identity of a document in a native application format that is to be modified via the user input (Block 510) . User input contained within the second vector is stored within a storage area (45, Fig. 3) of the web server (44, Fig. 3) (Block 520) . A document generator module (46, Fig. 3) then utilizes the provided user input to modify portions of a copy of the identified document in the native application format (Block 530) . The modified portions of the copied document are predefined fields which the user's input will be inserted into. This process may be somewhat similar to a mail- merge .

A copy (90, Fig. 13) of the modified document in the native application format is then transmitted to the user (Block 600, Fig. 4) . Preferably, a copy of a user-modified document is also stored within a designated user area (47, Fig. 3) of the web server (44, Fig. 3) such that the user can retrieve a copy of . the modified document at a later time. The foregoing is illustrative of the present invention and is not to be construed as limiting thereof. Although a few exemplary embodiments of this invention have been described, those skilled in the art will readily appreciate that many modifications are possible in the exemplary embodiments without materially departing from the novel teachings and advantages of this invention. Accordingly, all such modifications are intended to be included within the scope of this invention as defined in the claims. In the claims, means-plus-function clause are intended to cover the structures described herein as performing the recited function and not only structural equivalents but also equivalent structures. Therefore, it is to be understood that the foregoing is illustrative of the present invention and is not to be construed as limited to the specific embodiments disclosed, and that modifications to the disclosed embodiments, as well as other embodiments, are intended to be included within the scope of the appended claims. The invention is defined by the following claims, with equivalents of the claims to be included therein.

Claims

THAT WHICH IS CLAIMED IS:

1. A method of modifying a first document created within a first application program without opening the first document within the first application program, wherein the first document is stored within a first computer, and wherein a second computer is in communication with the first computer, the method comprising the steps of : downloading an applet from the first computer to the second computer in response to a user request to modify the first document; displaying a second document on the second computer via the applet, wherein the second document is a Standard Generalized Markup Language (SGML) format version of the first document, and wherein the second document includes selected portions that are configured to receive user input; obtaining user input within at least one of the selected portions of the displayed second document; modifying, via the applet, the first document with user input obtained within the at least one selected portions of the displayed second document; and displaying the modified first document on the second computer via the applet .

2. A method according to Claim 1 further comprising the step of storing obtained user input within the first computer.

3. A method according to Claim 1 further comprising the step of storing a copy of the modified first document within the first computer.

4. A method according to Claim 1 wherein the second document is created via the following steps : replacing formatting code in a copy of the first document with respective SGML tags that can mimic the first document formatting code when the second document is displayed via the applet; and inserting interactive SGML tags in selected portions of the second document that can provide interactivity when the second document is displayed via the applet.

5. A method according to Claim 1 wherein the step of displaying the second document via an applet running on the second computer comprises the following steps performed by the applet: preparing the second document as a tokenized file stream; reading the tokenized file stream to identify each markup language tag and each portion of the second document associated with a respective identified markup language tag; storing each identified markup language tag and respective second document portion associated with each identified markup language tag as objects in a first vector; and rendering the second document within a scrollable JAVA^® canvas using the objects stored in the first vector.

6. A method according to Claim 1 wherein the step of obtaining user input within at least one of the selected portions of the displayed second document further comprises the step of displaying the second ^■ document with the obtained user input via the applet .

7. A method according to Claim 1 wherein the step of modifying the first document to include the obtained user input comprises the steps of: storing obtained user input as respective objects in a second vector; sending, via the applet, the second vector to^' the first computer along with an identity of the first document ; and modifying portions of the first document with objects stored within the second vector.

8. A method according to Claim 1 wherein the first computer is a web server.

9. A method of modifying a first document created within a first application program without opening the first document within the first application program, wherein the first document is stored within a first computer, and wherein a second computer is in communication with the first computer, the method comprising the steps of: downloading an applet from the first computer to the second computer in response to a user request to modify the first document; creating a second document, wherein the second document is a Standard Generalized Markup Language (SGML) format version of the first document, and wherein the second document includes selected portions that are configured to receive user input, comprising the steps of: replacing formatting code in a copy of the first document with respective SGML tags that can mimic the first document formatting code when the second document is displayed via the applet; and inserting interactive SGML tags in selected portions of the second document that can provide interactivity when the second document is displayed via the applet; displaying the second document on the second computer, comprising the following steps performed by the applet : preparing the second document as a tokenized file stream; reading the tokenized file stream to identify each markup language tag and each portion of the second document associated with a respective identified markup language tag; storing each identified markup language tag and respective second document portion associated with each identified markup language tag as objects in a first vector; and rendering the second document within a scrollable JAVA^® canvas using the objects stored in the first vector; obtaining user input within at least one of the selected portions of the displayed second document; and modifying, via the applet, the first document with user input obtained within the at least one selected portions of the displayed second document .

10. A method according to Claim 9 further comprising the step of displaying the modified first document on the second computer via the applet .

11. A method according to Claim 9 further comprising the step of storing obtained user input within the first computer.

12. A method according to Claim 9 further comprising the step of storing a copy of the modified first document within the first computer.

13. A method according to Claim 9 wherein the step of obtaining user input within at least one of the selected portions of the displayed second document further comprises the step of displaying the second document with the obtained user input via the applet.

14. A method according to Claim 9 wherein the step of modifying the first document to include the obtained user input comprises the steps of : storing obtained user input as respective objects in a second vector; sending, via the applet, the second vector to the first computer along with an identity of the first document ; and modifying portions of the first document with objects stored within the second vector.

15. A method according to Claim 9 wherein the first computer is a web server.

16. A system for modifying a first document created within a first application program without opening the first document within the first application program, wherein the first document is stored within a first computer, and wherein a second computer is in communication with the first computer, comprising: means for downloading an applet from the first computer to the second computer in response to a user request to modify the first document; means for displaying a second document on the second computer via the applet, wherein the second document is a Standard Generalized Markup Language (SGML) format version of the first document, and wherein the second document includes selected portions that are configured to receive user input; means for obtaining user input within at least one of the selected portions of the displayed second document; means for modifying, via the applet, the first document with user input obtained within the at least one selected portions of the displayed second document ; and means for displaying the modified first document on the second computer via the applet .

17. A system according to Claim 16 further comprising means for storing obtained user input within the first computer.

18. A system according to Claim 16 further comprising means for storing a copy of the modified first document within the first computer.

19. A system according to Claim 16 wherein means for creating the second document comprise : means for replacing formatting code in a copy of the first document with respective SGML tags that can mimic the first document formatting code when the second document is displayed via the applet; and means for inserting interactive SGML tags in selected portions of the second document that can provide interactivity when the second document is displayed via the applet.

20. A system according to Claim 16 wherein the means for displaying the second document via an applet running on the second computer comprises : means for preparing the second document as a tokenized file stream; means for reading the tokenized file stream to identify each markup language tag and each portion of the second document associated with a respective identified markup language tag; means for storing each identified markup language tag and respective second document portion associated with each identified markup language tag as objects in a first vector; and means for rendering the second document within a scrollable JAVA^® canvas using the objects stored in the first vector.

21. A system according to Claim 16 wherein the means for obtaining user input within at least one of the selected portions of the displayed second document further comprises means for displaying the second document with the obtained user input via the applet .

22. A system according to Claim 16 wherein the means for modifying the first document to include the obtained user input comprises : means for storing obtained user input as respective objects in a second vector; means for sending, via the applet, the second vector to the first computer along with an identity of the first document; and means for modifying portions of the first document with objects stored within the second vector.

23. A system according to Claim 16 wherein the first computer is a web server.

24. A system for modifying a first document created within a first application program without opening the first document within the first application program, wherein the first document is stored within a first computer, and wherein a second computer is in communication with the first computer, comprising: means for downloading an applet from the first computer to the second computer in response to a user request to modify the first document; means for creating a second document, wherein the second document is a Standard Generalised Markup Language (SGML) format version of the first document, and wherein the second document includes selected portions that are configured to receive user input, comprising: means for replacing formatting code in a copy of the first document with respective SGML tags that can mimic the first document formatting code when the second document is displayed via the applet; and means for inserting interactive SGML tags in selected portions of the second document that can provide interactivity when the second document is displayed via the applet; means for displaying the second document on the second computer, comprising: means for preparing the second document as a tokenized file stream; means for reading the tokenized file stream to identify each markup language tag and each portion of the second document associated with a respective identified markup language tag; means for storing each identified markup language tag and respective second document portion associated with each identified markup language tag as objects in a first vector; and means for rendering the second document within a scrollable JAVA^® canvas using the objects stored in the first vector; means for obtaining user input within at least one of the selected portions of the displayed • second document; and means for modifying, via the applet, the first document with user input obtained within the at least one selected portions of the displayed second document .

25. A system according to Claim 24 further comprising means for displaying the modified first document on the second computer via the applet .

26. A system according to Claim 24 further comprising means for storing obtained user input within the first computer.

27. A system according to Claim 24 further comprising means for storing a copy of the modified first document within the first computer.

28. A system according to Claim 24 wherein the means for obtaining user input within at least one of the selected portions of the displayed second document further comprises means for displaying the second document with the obtained user input via the applet .

29. A system according to Claim 24 wherein the means for modifying the first document to include the obtained user input comprises : means for storing obtained user input as respective objects in a second vector; means for sending, via the applet, the second vector to the first computer along with an identity -of the first document; and means for modifying portions of the first document with objects stored within the second vector.

30. A system according to Claim 24 wherein the first computer is a web server.

31. A computer program product for modifying a first document created within a first application program without opening the first document within the first application program, wherein the first document is stored within a first computer, and wherein a second computer is in communication with the first computer, the computer program product comprising a computer usable storage medium having computer readable program code means embodied in the medium, the computer readable program code means comprising: computer readable program code means for downloading an applet from the first computer to the second computer in response to a user request to modify the first document; computer readable program code means for displaying a second document on the second computer via the applet, wherein the second document is a Standard Generalized Markup Language (SGML) format version of the first document, and wherein the second document includes selected portions that are configured to receive user input; computer readable program code means for obtaining user input within at least one of the selected portions of the displayed second document; computer readable program code means for modifying, via the applet, the first document with user input obtained within the at least one selected portions of the displayed second document; and computer readable program code means for displaying the modified first document on the second computer via the applet.

32. A computer program product according to Claim 31 further comprising computer readable program code means for storing obtained user input within the first computer.

33. A computer program product according to Claim 31 further comprising computer readable program code means for storing a copy of the modified first document within the first computer.

34. A computer program product according to Claim 31 wherein the computer readable program code means for creating the second document comprise: computer readable program code means for replacing formatting code in a copy of the first document with respective SGML tags that can mimic the first document formatting code when the second document is displayed via the applet; and computer readable program code means for inserting interactive SGML tags in selected portions of the second document that can provide interactivity when the second document is displayed via the applet .

35. A computer program product according to Claim 31 wherein the computer readable program code ' means for displaying the second document via an applet running on the second computer comprises: computer readable program code means for preparing the second document as a tokenized file stream; computer readable program code means for reading the tokenized file stream to identify each markup language tag and each portion of the second document associated with a respective identified markup language tag; computer readable program code means for storing each identified markup language tag and respective second document portion associated with each identified markup language tag as objects in a first vector; and computer readable program code means for rendering the second document within a scrollable JAVA^® canvas using the objects stored in the first vector.

36. A computer program product according to Claim 31 wherein the computer readable program code means for obtaining user input within at least one of the selected portions of the displayed second document further comprises computer readable program code means for displaying the second document with the obtained user input via the applet .

37. A computer program product according to Claim 31 wherein the computer readable program code means for modifying the first document to include the obtained user input comprises : computer readable program code means for storing obtained user input as respective objects in a second vector; computer readable program code means for sending, via the applet, the second vector to the first computer along with an identity of the first document; and computer readable program code means for modifying portions of the first document with objects stored within the second vector.

38. A computer program product according to Claim 31 wherein the first computer is a web server.

39. A computer program product for modifying a first document created within a first application program without opening the first document within the first application program, wherein the first document is stored within a first computer, and wherein a second computer is in communication with the first computer, the computer program product comprising a computer usable storage medium having computer readable program code means embodied in the medium, the computer readable program code means comprising: computer readable program code means for downloading an applet from the first computer to the second computer in response to a user request to modify the first document; computer readable program code means for creating a second document, wherein the second document is a Standard Generalized Markup Language (SGML) format version of the first document, and wherein the second document includes selected portions that are configured to receive user input, comprising: computer readable program code means for replacing formatting code in a copy of the first document with respective SGML tags that can mimic the first document formatting code when the second document is displayed via the applet; and computer readable program code means for inserting interactive SGML tags in selected portions of the second document that can provide interactivity when the second document is displayed via the applet; computer readable program code means for displaying the second document on the second computer, comprising: computer readable program code means for preparing the second document as a tokenized file stream; computer readable program code means for reading the tokenized file stream to identify each markup language tag and each portion of the second document associated with a respective identified markup language tag; computer readable program code means for storing each identified markup language tag and respective second document portion associated with each identified markup language tag as objects in a first vector; and computer readable program code means for rendering the second document within a scrollable JAVA^® canvas using the objects stored in the first vector; computer readable program code means for obtaining user input within at least one of the selected portions of the displayed second document; and computer readable program code means for modifying, via the applet, the first document with user input obtained within the at least one selected portions of the displayed second document .

40. A computer program product according to Claim 39 further comprising computer readable program code means for displaying the modified first document on the second computer via the applet .

41. A computer program product according to Claim 39 further comprising computer readable program code means for storing obtained user input within the first computer.

42. A computer program product according to Claim 39 further comprising computer readable program code means for storing a copy of the modified first document within the first computer.

43. A computer program product according to Claim 39 wherein the computer readable program code means for obtaining user input within at least one of the selected portions of the displayed second document further comprises computer readable program code means for displaying the second document with the obtained user input via the applet .

44. A computer program product according to Claim 39 wherein the computer readable program code means for modifying the first document to include the obtained user input comprises : computer readable program code means for storing obtained user input as respective objects in a second vector; computer readable program code means for sending, via the applet, the second vector to the first computer along with an identity of the first document; and computer readable program code means for modifying portions of the first document with objects stored within the second vector.

45. A computer program product according to Claim 39 wherein the first computer is a web server.