US 8,131,815 B1Grant
Client-side modification of electronic documents in a client-server environment
Issue Date:2012-03-06
•36 Claims
•9 Drawing Sheets
Abstract
Client-side modification of electronic documents by server-generated instructions in a client-server environment enables dynamic modification of formatting information in an electronic document to accommodate new data received from the server. A server generates machine instructions to send to a client along with new data for an electronic document. The generated instructions modify the electronic document at the client to accommodate the new data. The generated instructions may include at least one tag indicating a relative order in which the new data is to be imported into the electronic document and the instructions are to be performed.
Metadata
Assignee
- Adobe Systems Incorporated
Inventors
- Roberto Perelman
- Scott E. Petersen
Application Information
Application Number:US 10/006,260
Filing Date:2001-11-02
Priority Date:2001-11-02
Art Unit:2451
Classifications
IPC:
G06F15/16
Patent Drawings (9 sheets)
Description
Background
[0001] The present application describes systems and techniques relating to client-side modification of electronic documents in a client-server environment, for example, transmitting document specific instructions along with data from a server to a client to modify a final format electronic document at the client to accommodate the data.
[0002] A client-server environment is a network architecture in which clients generally rely on servers for resources, such as files, databases, devices, processing power, etc. The World Wide Web and its associated Web servers and Web browsers are a typical example of a client-server environment using an existing underlying network (e.g., the Internet) for communications. The World Wide Web generally presents server resources to clients in a context of virtual pages, which are blocks of data to be presented in a visual display. Each virtual page is typically stored as a Hypertext Markup Language (HTML) document and typically contains hyperlinks. A hyperlink may be any link to a server resource, including another virtual page or another file identified by a Universal Resource Identifier (URI), or a server process (e.g., a button on a Web page that causes a server to search a database, run a program, generate a new Web page, etc., is also a hyperlink).
[0003] HTML is a markup language, derived from Standard Generalized Markup Language (SGML), for electronic documents. Predefined tags are typically used in HTML documents to define the semantic value of data within the file, including tags defining how the document should look when presented as a virtual page on a client display or when printed. HTML includes tags for identifying and interpreting scripting code, such as JavaScript, which is commonly used to add animation or advertisements to an HTML page. These tags typically specify the timing of interpreting the scripting code. For example, a function performed by the scripting code may be temporally coupled with a specific action, such as opening of the HTML page, closing of the HTML page, or clicking of a button by a user.
[0004] In general, HTML documents stay true to the client-server model, that is, traditional HTML involves a server sending electronic documents containing formatting, or presentation, information. Thus, changes that need to be made to an HTML document to respond to a client request for data generally result in a new HTML document being sent from the server to the client. However, different types of HTML exist. For example, dynamically produced HTML (e.g., Active Server Pages) is a server-side implementation variation of standard HTML, in which different requests for an HTML page may result in different versions of the HTML page being sent based on processing at the server (e.g., two clients in different geographic locales may receive different HTML pages in response to two requests having the same URI). In contrast, Dynamic HTML is a new type of HTML in which a Web page may contain machine instructions (e.g., scripts) that allow a downloaded Web page to react and change at the client in response to user inputs without sending a request to the server.
[0005] Conventional HTML files may include tags for use in creating virtual forms that a user may fill out using a Web browser. HTML does not generally separate tags relating to data type semantics from tags relating to data presentation semantics. Thus traditional HTML forms mix data collection information with data presentation information in the same document.
[0006] Efforts are underway to remove the mixing of data collection information with data presentation information in traditional HTML forms. The World Wide Web Consortium (W3C) is creating “XForms”, which is a specification of Web forms that uses the Extensible Markup Language (XML) to separate form data into sections that describe what the form does (data type semantics stored in XML), and sections that describe how the form should look (data presentation semantics stored in XHTML (Extensible HTML)). (See http://www-w3-org/MarkUp/Forms/) When data in the form needs to change, a Web server may send new data to the Web browser in the XML format. When presentation format of the form needs to change, the Web server may send a new XHTML document.
[0007] In general, each HTML document may be thought of as a single virtual page, regardless of whether the document is stored as traditional HTML or XHTML. An HTML document generally has no ability to specify which portions of the document will appear on which physical pages when printed. In fact, a publisher of an HTML document has no final control over how the document will appear to an end user, because presentation of an HTML document, either by display on a monitor or by printing, is determined by the Web browser, which interprets the HTML tags.
[0008] In contrast, a final format document is an electronic document describing one or more virtual pages having a predetermined final format. The predetermined final format defines a specific visual appearance for the electronic document when displayed or printed. A final format document generally provides a device-independent and resolution-independent format for publishing and/or distributing electronic documents. Thus, a final format document is conventionally a file that lies between a layout program and the typical raster image processors, which drive traditional printing apparatus.
[0009] The final format generally allows a publisher to control the look and feel of the document as seen by an end user, including the specific physical page or pages on which information appears when printed or displayed. Thus, the final format should generally support and preserve all visual formatting features (e.g., fonts, graphics, color, etc.) of any source document, regardless of the source computer platform and/or software application used to create the source document. The ability to control final appearance, or look-and-feel, of an electronic document as viewed by a reader can be a critical branding issue for businesses and other publishing organizations, and is particularly useful when available across various computer platforms.
[0010] An example of a final format is the PORTABLE DOCUMENT FORMAT (PDF) developed by Adobe Systems, Inc. of San Jose, Calif. Example software for creating and reading PDF documents is the ACROBAT™ software, also of Adobe Systems, Inc. The Adobe ACROBAT™ software is based on Adobe's POSTSCRIPT® technology which describes formatted pages of a document in a device-independent fashion.
[0011] Final format documents may be used in client-server environments. For example, on the World Wide Web, PDF documents are commonly used to present various types of information to, and also to obtain information from, Web users. A final format document may store a form, which users can fill in and/or print out, or which a server can modify to include data specific to a user. For example, Forms Data Format (FDF) is a data representation format developed by Adobe Systems, Inc. to allow importing of data into an existing PDF document. FDF files may be used to submit data to a server, or to receive data from a server. FDF Toolkit is an application program interface (API) developed by Adobe Systems, Inc. to facilitate the writing of server applications to generate and/or parse FDF data from a form created by the Adobe ACROBAT™ Forms plug-in.
Summary
[0012] Client-side modification of electronic documents by server-generated instructions in a client-server environment enables dynamic modification of formatting information in an electronic document to accommodate new data received from the server. A server generates machine instructions to send to a client along with new data for an electronic document. The generated instructions modify the electronic document at the client to accommodate the new data. The generated instructions may include at least one tag indicating a relative order in which the new data is to be imported into the electronic document and the instructions are to be performed. The electronic document may be a final format document, such as a PDF document. The dynamic modification of the electronic document may preserve pre-existing formatting information in the electronic document, either explicitly or by appending the differences created by modification to the modified electronic document.
[0013] In one aspect, a machine-implemented method of modifying an electronic document includes receiving a request from a client, producing data corresponding to the client request, generating instructions for an electronic document having a predetermined final format defining an appearance of the electronic document, and transmitting the produced data and the generated instructions to the client. The generated instructions specify operations to modify the predetermined final format at the client to accommodate the produced data.
[0014] The produced data may include a file name for a locally accessible electronic document, or a location from which the client is to retrieve the electronic document. Modification of the electronic document may maintain pre-existing final format information in the electronic document. The generated instructions may be a script, such as JavaScript, may be specific to the electronic document, and may include a tag indicating a relative order in which the produced data is to be imported into the electronic document and the instructions are to be performed.
[0015] The electronic document may be a form, such as a registration form, having one or more form fields. The form fields may be responsive to user actions and may overlay pre-existing visual objects in the electronic document, including pre-existing form fields.
[0016] In another aspect, a machine-implemented method of modifying an electronic document includes obtaining an electronic document having a predetermined final format defining an appearance of the electronic document, sending a request to a server, receiving from the server data and instructions for the electronic document, and modifying the electronic document's predetermined final format in accordance with the received instructions to accommodate the received data. Obtaining the electronic document may constitute retrieving the electronic document as directed by the instructions or just receiving the electronic document.
[0017] In yet another aspect, a machine-implemented method of modifying an electronic document includes receiving a request from a client, producing data corresponding to the client request, generating instructions for an electronic document defining visual information to be displayed, and transmitting the produced data and the generated instructions to the client. The generated instructions specify operations to modify the electronic document to accommodate the produced data, and include at least one tag indicating a relative order in which the produced data is to be imported into the electronic document and the instructions are to be performed. The at least one tag may indicate that the produced data is to be imported into the electronic document either before or after the instructions are performed, or the at least one tag may indicate that at least a portion of the generated instructions are to be inserted into the electronic document.
[0018] Implementations of the systems and techniques described here may occur in hardware, software or a combination of both, and may include machine instructions for causing a machine to perform the operations described.
[0019] Moreover, one or more of the following advantages may be provided. The systems and techniques described may result in on the fly customization of existing electronic documents for personalized data presentation while maintaining visual presentation features of the existing electronic document as desired by an author. The systems and techniques described also may result in more flexible and dynamic final format documents, including a richness in the available flexibility provided by the sequence tags described here. The systems and techniques described also may result in decreased network bandwidth consumption, improved cache utilization and faster document transmission times due to less need to reformulate and retransmit entire documents in a client-server environment.
Brief Description of the Figures
[0020] FIG. 1A is a block diagram illustrating an example client-server environment.
[0021] FIG. 1B is a logic flow diagram of an example client process and a corresponding server process for transmitting document-specific instructions and data to modify an electronic document at a client to accommodate the data.
[0022] FIG. 2A is a diagram illustrating an example data model for use in transmitting data and machine instructions to modify a final format document.
[0023] FIG. 2B is an example printout of an example data tree stored as an FDF.
[0024] FIG. 2C is an example printout of another example data tree stored as an FDF.
[0025] FIGS. 3A and 3B are illustrations of an example final format document, before and after modification by document-specific machine instructions.
[0026] FIGS. 4A and 4B are illustrations of an example final format form document, before and after modification by document-specific machine instructions.
[0027] FIG. 5 is a block diagram illustrating an example computing environment.
[0028] Details of one or more embodiments are set forth in the accompanying drawings and the description below. Other features and advantages may be apparent from the description and drawings, and from the claims.
Detailed Description
[0029] The systems and techniques described here relate to client-side modification of electronic documents in a client-server environment.
[0030] FIG. 1A is a block diagram illustrating an example client-server environment. A network 100 provides communication links between a server 110 and one or more clients 120. The network 100 may be any communication network linking machines capable of communicating using one or more networking protocols, including a local area network (LAN), metropolitan area network (MAN), wide area network (WAN), enterprise network, virtual private network (VPN), the Internet, etc. The server 110 may be any machine or process, capable of communicating over the network 100, that has resources available to other machines coupled with the network 100. The clients 120 may be any machines or processes capable of communicating over the network 100 with the server 110. For example, the server 110 may be a Web server, and the clients 120 may be Web browsers. The clients 120 request resources from the server 110, and the server 110 provides requested resources to the clients 120, if available.
[0031] FIG. 1B is a logic flow diagram of an example client process and a corresponding server process for transmitting document-specific instructions and data to modify an electronic document at a client to accommodate the data. A client receives an electronic document at 150. The electronic document may have a predetermined final format defining an appearance of the electronic document. For example, the electronic document may be a PDF document, such as an electronic form, publication, or search result received from a server, which may or may not be a server performing the corresponding server process described below.
[0032] The client sends a request to a server at 155. The request relates to the electronic document, and may be initiated by user interaction with the electronic document. For example, the electronic document may be a form stored as a PDF file, which causes a request to be sent to the server at 155 when a user enters information into a form field or selects a check-box. Alternatively, the request may be initiated by some other user activity. For example, a user may click a hyperlink in an HTML page or a PDF document that causes the request to be sent at 155.
[0033] The server receives the request at 160. The server processes the request and produces data corresponding to the request at 162. For example, the server may access a data store or search a database to collect the data corresponding to the request, or the server may generate the data using one or more scripts or software processes. In addition, the server generates instructions, which are specific to the electronic document, at 164. The generated instructions are machine instructions to modify the electronic document at the client to accommodate the produced data. These machine instructions may be scripts written in a scripting language, such as JavaScript, VBScript (Visual Basic Scripting Edition), Jscript, ECMAScript (ECMA-262 (European Computer Manufacturers' Association standard 262)), etc.
[0034] Then at 166, the server sends the produced data and the machine instructions to the client. The machine instructions may be compressed before transmission to the client to reduce transmission load. For example, the machine instructions may be compressed JavaScript added to an FDF along with the produced data, and the FDF is then transmitted as a stream of information to the client at 166. Alternatively, the server may send the produced data and a reference to the machine instructions to the client at 166, and the client then retrieves the referenced machine instructions.
[0035] The client receives the data and the document-specific machine instructions at 170. Then at 175, the machine instructions are performed at the client to modify the electronic document. Although the machine instructions are specific to the electronic document, they need not be specific to only a single electronic document, or specifically identify the electronic document. For example, the electronic document may be a PDF file currently opened in a Web browser, in which case the machine instructions are performed against the currently opened document unless another document is identified by the generated instructions and/or the produced data.
[0036] The generated instructions are tied to the produced data and to the electronic document in that they are customized to modify the formatting of the electronic document to accept the produced data. By sending the machine instructions with the produced data to the client, the visual presentation formatting of the electronic document may be dynamically changed in a client-server environment to accommodate data produced by a server in response to user activity, without the need to send a new electronic document having visual presentation formatting definitions.
[0037] Moreover, additional benefits may be obtained in the context of final format electronic documents by not re-flowing the electronic document in light of the modification. For example, if the electronic document is a form stored in PDF, the instructions may add a new field to the existing form by appending attribute definitions to the PDF file that describe how to construct the field (e.g., type of field, location, dimensions, color, border, etc.), even if the resulting field would overlay some existing content in the visual presentation of the PDF file. By not re-flowing the electronic document, and thus not changing pre-existing final format information in the electronic document, the predefined final format is preserved/respected. The modified electronic document may include many layers of visual presentation information and effectively retains a history of the changes made, which can easily be unmade if desired.
[0038] Alternatively, a history of changes may be maintained by appending differences between a modified final format document and the unmodified final format document as discussed further below.
[0039] In addition, the generated instructions may include a tag that indicates a relative order in which the produced data is to be imported into the electronic document and the machine instructions are to be performed. For example, three tags may be defined: (1) ‘Before’, (2) ‘After’, and (3) ‘Document’. The ‘Before’ tag indicates that the machine instructions are to be performed against the electronic document before the produced data is imported into the electronic document. The ‘After’ tag indicates that the machine instructions are to be performed against the electronic document after the produced data is imported into the electronic document. Finally, the ‘Document’ tag indicates that the machine instructions are to be inserted into the electronic document, to become document-level machine instructions (potentially replacing any subroutines having the same name). These document-level machine instructions would generally be executed against the electronic document each time the electronic document is opened, but may also be invoked as subroutines by future machine instructions executing in the document.
[0040] The logic flow depicted in FIG. 1B does not require the particular order shown. For example, receiving the electronic document at 150 may occur after receiving the data and instructions at 170. The data and instructions received at 170 may specify the electronic document to be modified using a URI, in which case, the client receives the electronic document to be modified at 175 only after requesting the electronic document from an appropriate server following 170. Moreover, in certain implementations, multi-tasking and parallel processing are performed.
[0041] FIG. 2A is a diagram illustrating an example data model for use in transmitting data and machine instructions to modify a final format document. The data model may be generally regarded as a tree 200. The tree 200 is typically stored as data and machine instructions with associated tags defining the semantic value of the data and machine instructions. The tree 200 may be written to a file, and the data and machine instructions may be stored as ASCII (American Standard Code for Information Interchange) characters.
[0042] The tree 200 includes a root node 205, which may be explicit or implicit. For example, the root node 205 may be explicit, such as when a specific tag identifies the root node 205. Alternatively, the root node 205 may be implicit, such as when it is represented by a declaration at the beginning of a data stream or a data file, or such as when a data file has an extension on the file's name to identify the type of data contained therein.
[0043] The root node 205 may have one or more child nodes 210, which in turn may have one or more child nodes 215, and so on. These nodes 210,215 are elements, which may be data elements or machine instruction elements, and which may have various associated attributes. The tags that delineate these elements may be implemented using many different syntax standards. For example, they may be implemented using XML. Alternatively, they may be implemented using Key/Value pairs to identify elements, along with grouping symbols to group multiple sub-elements within a Value field. For example, a tree 200 may be stored in the PDF syntax. The full specification for the PDF syntax can be found at the following URL: http://partners-adobe-com/asn/developer/acrosdk/docs/PDFRef.pdf.
[0044] FIG. 2B is an example printout of an example data tree stored as an FDF. The printout of FIG. 2B shows a dictionary object containing Key/Value pairs and grouping symbols ‘<<’ and ‘>>’. The first Key in an indirect object ‘1 0’ is the ‘/FDF’ Key 230. Its Value is a dictionary object grouped by the ‘<<’ and ‘>>’ symbols. This dictionary object contains a ‘/F’ Key 232, which is an optional key that identifies the PDF file for which the FDF has been specifically tailored. If the ‘/F’ Key 232 is not present, the FDF may be specific to a currently opened PDF (e.g., if a user is looking at a PDF document in a Web browser, and the user performs an action that triggers generation and transmission of the FDF to the Web browser, such as by triggering a Common Gateway Interface (CGI) script on a server, then the FDF implicitly refers to the opened PDF). Alternatively, absence of the ‘/F’ Key 232 may cause a window to be opened allowing a user to browse for the PDF when the FDF is processed.
[0045] A ‘/JavaScript’ Key 234 identifies the Value to follow as machine instructions, which will include instructions in the JavaScript language. The first machine instruction is a ‘/Before’ Key 236, which is a tag that instructs a machine to perform the JavaScript instructions in the string Value 238 before processing the FDF with respect the PDF document. This first machine instruction could also be a ‘/After’ Key or a ‘/Doc’ Key.
[0046] FIG. 2C is an example printout of another example data tree stored as an FDF. In this example, a ‘/After’ Key 250 is used, and its Value is a reference 252 to an indirect object ‘2 0’, instead of a string. The indirect object ‘2 0’ identifies an outside source 256, using beginning and ending tags 254,258, from which to obtain streaming JavaScript. As mention above, the JavaScript may also be compressed.
[0047] A data tree as described above may also be used to store the differences between a modified final format document and the unmodified final format document, by appending the differences created by modification to the modified final format document in the data tree syntax.
[0048] FIGS. 3A and 3B are illustrations of an example final format document, before and after modification by document-specific machine instructions. A company information document 300 is a final format document that may be printed or viewed exactly as shown, including viewing the company information document 300 with a Web browser. The company information document 300 includes a company graphic 310 and a company logo 315. The graphic 310 and the logo 315 are designed to be consistent with the company's overall branding strategy.
[0049] The company information document 300 may include information such as employee contact information 320. The employee contact information 320 may include an employee name field 322, a phone number field 324, an email field 326, an address/location field 328, and a company department field 330. These fields may have various functionality associated with them. For example, the company information document 300 may be a PDF document in which, when the document is viewed with a Web browser, clicking on the employee name field 322 causes the Web browser to retrieve a Web page biography of the employee from the company's Web site, clicking on the email field 326 causes a new email message window to be opened with the particular employee's email address already included, and clicking on the company department field 330 causes the Web browser to retrieve another PDF document with details about the company department.
[0050] Referring now to FIG. 3B , a company information document 350 is a final format document derived from the company information document 300 using the systems and techniques described here. For example, a user may be browsing a company's Web site and perform a search for company employees that satisfy user specified criteria. In response to the user's search request, the company's Web server performs a database search, packages the search result data, a reference to the company information document 300 and machine instructions for modifying the company information document 300 into a single communication, which is sent to the user's Web browser. The Web browser receives the communication, retrieves the company information document 300, and performs the machine instructions to modify the company information document 300 to create the company information document 350 for display to the user.
[0051] The company information document 350 retains the same company graphic 310 and company logo 315 as the original company information document 300. But the company information document 350 also contains the search result data in appropriately formatted fields 360,362. If the search result data had been more extensive, the machine instructions sent by the Web server would have modified the company information document 300 to be a multiple page company information document 350. Because the company information document 350 is a final format document, it is ready to be printed and will appear on the printed page as the company intends.
[0052] Moreover, the machine instructions may add functional fields that are context sensitive. Thus, in the example described above, the company Web server also sent machine instructions to add a link field 364, which allows the user to go back to the previous page (i.e., the search request page in this example) by clicking the link field 364. This link may be to many different types of previous pages, including an HTML Web page, an XHTML Web page, a final format document, etc.
[0053] If the user clicks the link field 364, and then submits a new search request, the company's Web server may now send a single communication that contains the new search result data and machine instructions for modifying the company information document 350. Because the user already has a copy of the company information document 350, the company graphic 310 and the company logo 315 do not need to be retransmitted to the Web browser, thus reducing transmission times and network congestion.
[0054] Moreover, the same company information document 350 may be modified to become many different types of company information documents. For example, the user may click on one of the company department fields in the company information document 350, and the Web server may then send data and machine instructions to modify the company information document 350 to include details about the selected company department, potentially removing or overlaying the fields 360,362,364.
[0055] An example FDF for modifying a PDF file in a manner similar to that shown in FIGS. 3A and 3B is shown here in Table 1. The example FDF shown in Table 1 is uncompressed, whereas typically the FDF would be compressed to save on memory usage and transmission times.
[0056]
| TABLE 1 | |
|---|---|
| %FDF-1.2 | |
| 1 0 obj | |
| << | |
| /FDF << | |
| /Fields 2 0 R | |
| /JavaScript << | |
| /Doc [ | |
| (DrawOneRow)9 0 R | |
| (DrawResultField)11 0 R | |
| (DrawBackButton)13 0 R | |
| (SetCaption)10 0 R | |
| ] | |
| /Before 12 0 R | |
| >> | |
| IF (SearchResult.pdf)>> | |
| >> | |
| endobj | |
| 2 0 obj | |
| [ | |
| << /T (name1)/Kids 3 0 R >> << /T (phone)/Kids 4 0 R >> << /T (email)/ | |
| Kids 5 0 R >> | |
| << /T (location)/Kids 6 0 R >> << /T (office_num)/Kids 7 0 R >> | |
| << /T (job_title)/Kids 8 0 R >> << /T (result)/V | |
| (Total records found = 2)>> | |
| << /T (back)/A << /S /GoToR /D (MainPage)/F (PhnDirSrch.pdf)>> >> | |
| ] | |
| endobj | |
| 3 0 obj | |
| [ | |
| << /T (0)/V (Roberto Perelman)>> <</T (1)/V (Vadim Perelman)>> | |
| ] | |
| endobj | |
| 4 0 obj | |
| [ | |
| << /T (0)/V (408-536-4421)>> << /T (1)/V (408-536-4453)>> | |
| ] | |
| endobj | |
| 5 0 obj | |
| [ | |
| << /T (0)/A << /S /JavaScript /JS (app.mailMsg\(true, “[email protected]”\))>> | |
| >> | |
| << /T (1)/A << /S /JavaScript /JS (app.mailMsg\(true, | |
| “[email protected]”\))>> >> | |
| ] | |
| endobj | |
| 6 0 obj | |
| [ | |
| << /T (0)/V (WestTower.15)>> << /T (1)/V (WestTower.15)>> | |
| ] | |
| endobj | |
| 7 0 obj | |
| [ | |
| << /T (0)/V (W15-430)>> << /T (1)/V (W15-Kabel)>> | |
| ] | |
| endobj | |
| 8 0 obj | |
| [ | |
| << /T (0)/V (Document Technologies)>> << /T (1)/V | |
| (Acrobat Engineering)>> | |
| ] | |
| endobj | |
| 9 0 obj | |
| << | |
| >> | |
| stream | |
| var i=0.2; | |
| var p=0; | |
| function DrawOneRow( ) | |
| { | |
| var inch=72; | |
| if( j%10 == 0 && j ) | |
| { | |
| this.spawnPageFromTemplate(“blank”); | |
| p++; | |
| i=0.5; | |
| } | |
| var aRect = this.getPageBox( {nPage: p} ); | |
| aRect[0] += 0.3*inch; | |
| aRect[2] = aRect[0]+2*inch; | |
| aRect[1] −= i * inch; | |
| aRect[3] = aRect[1] − 40; | |
| var f = this.addField(“name1.”+j, “text”, p, aRect ); | |
| f.delay = true; | |
| f.borderStyle = border.s; | |
| f.borderColor = color.magenta; | f.textSize = 16; |
| f.textColor = color.blue; | |
| f.fillColor = color.yellow; | |
| f.readonly = true; | |
| f.delay = false; | |
| var aRect = this.getPageBox( {nPage: p} ); | |
| aRect[0] += 2.4*inch; | |
| aRect[2] = aRect[0]+1.6*inch; | |
| aRect[1] −= i * inch; | |
| aRect[3] = aRect[1] − 40; | |
| var f = this.addField(“phone.”+ j, “text”, p, aRect ); | |
| f.delay = true; | |
| f.borderStyle = border.s; | |
| f.borderColor = color.magenta; | f.textSize = 0; |
| f.textColor = color.blue; | |
| f.fillColor = color.yellow; | |
| f.readonly = true; | |
| f.delay = false; | |
| var aRect = this.getPageBox( {nPage: p} ); | |
| aRect[0] += 4.1*inch; | |
| aRect[2] = aRect[0]+1.2*inch; | |
| aRect[1] −= i * inch; | |
| aRect[3] = aRect[1] − 40; | |
| var f = this.addField(“email.” + j, “button”, p, aRect ); | |
| f.delay = true; | |
| f.borderColor = color.magenta; | f.borderStyle = border.i; |
| f.textColor = color.blue; | |
| f.fillColor = color.yellow; | |
| f.textSize = 16; | |
| f.delay = false; | |
| var aRect = this.getPageBox( {nPage: p} ); | |
| aRect[0] += 5.4*inch; | |
| aRect[2] = aRect[0]+1.7*inch; | |
| aRect[1] −= i * inch; | |
| aRect[3] = aRect[1] − 40; | |
| var f = this.addField(“location.”+ j , “text”, p, aRect ); | |
| f.delay = true; | |
| f.borderStyle = border.s; | |
| f.borderColor = color.magenta; | f.textSize = 13; |
| f.textColor = color.blue; | |
| f.fillColor = color.yellow; | |
| f.readonly = true; | |
| f.delay = false; | |
| var aRect = this.getPageBox( {nPage: p} ); | |
| aRect[0] += 7.2*inch; | |
| aRect[2] = aRect[0]+1*inch; | |
| aRect[1] −= i * inch; | |
| aRect[3] = aRect[1] − 40; | |
| var f = this.addField(“office_num.” + j, “text”, p, aRect ); | |
| f.delay = true; | |
| f.borderStyle = border.s; | |
| f.borderColor = color.magenta; | f.textSize = 14; |
| f.textColor = color.blue; | |
| f.fillColor = color.yellow; | |
| f.readonly = true; | |
| f.delay = false; | |
| var aRect = this.getPageBox( {nPage: p} ); | |
| aRect[0] += 8.3*inch; | |
| aRect[2] = aRect[0]+2.5*inch; | |
| aRect[1] −= i * inch; | |
| aRect[3] = aRect[1] − 40; | |
| var f = this.addField(“job_title.” + j, “text”, p, aRect ); | |
| f.delay = true; | |
| f.borderStyle = border.s; | |
| f.borderColor = color.magenta; | f.textSize = 0; |
| f.textColor = color.blue; | |
| f.fillColor = color.yellow; | |
| f.readonly = true; | |
| f.multiline = true; | |
| f.delay = false; | |
| i+=0.8; | |
| } | |
| endstream | |
| endobj | |
| 10 0 obj | |
| << | |
| >> | |
| stream | |
| function SetCaption( string ) | |
| { | |
| aList = string.split(“,”); | |
| for( var i=0 ; i < aList.length−1; i++) { | |
| var f = this.getField(“email.”+i); | |
| f.buttonSetCaption(aList[i]); | |
| } | |
| } | |
| endstream | |
| endobj | |
| 11 0 obj | |
| << | |
| >> | |
| stream | |
| function DrawResultField( ) | |
| { | |
| var inch=72; | |
| if( j%10 == 0 && j ) | |
| { | |
| this.spawnPageFromTemplate(“blank”); | |
| p++; | |
| i=0.5; | |
| }; | |
| var aRect = this.getPageBox( {nPage: p} ); | |
| aRect[0] += 1 *inch; | |
| aRect[2] = aRect[0]+4*inch; | |
| aRect[1] −= (i+0.1) * inch; | |
| aRect[3] = aRect[1] − 35; | |
| var f = this.addField(“result”, “text”, p, aRect); | |
| f.delay = true; | |
| f.borderStyle = border.b; | |
| f.fillColor = color.green; | |
| f.textColor = color.gray; | |
| f.borderColor = color.red; | |
| f.readonly = true; | |
| f.delay = false; | |
| } | |
| endstream | |
| endobj | |
| 12 0 obj | |
| << | |
| >> | |
| stream | |
| for (j=0; j<2; j++) | |
| DrawOneRow( ); | |
| SetCaption(“ rperelma,vperelma, ”); | |
| DrawResultField( ); | |
| DrawBackButton( ); | |
| endstream | |
| endobj | |
| 13 0 obj | |
| << | |
| >> | |
| stream | |
| function DrawBackButton( ) | |
| { | |
| var inch=72; | |
| var aRect = this.getPageBox( {nPage: p} ); | |
| aRect[0] += 5.5*inch; | |
| aRect[2] = aRect[0]+4*inch; | |
| aRect[1] −= (i+0.1) * inch; | |
| aRect[3] = aRect[1] − 35; | |
| var f = this.addField(“back”, “button”, p, aRect ); | |
| f.delay = true; | |
| f.borderStyle = border.b; | |
| f.fillColor = color.green; | |
| f.textColor = color.gray; | |
| f.borderColor = color.red; | |
| f.delay = false; | |
| f.buttonSetCaption(“BACK TO INITIAL PAGE”) | |
| } | |
| endstream | |
| endobj | |
| trailer | |
| << | |
| /Root 1 0 R | |
| >> | |
| %%EOF | |
[0057] FIGS. 4A and 4B are illustrations of an example final format form document, before and after modification by document-specific machine instructions. A registration form document 400 is a final format document that may be printed or viewed exactly as shown, including viewing the registration form document 400 with a Web browser. The registration form document 400 may be any type of registration form (e.g., product registration, event registration, voter registration, etc.), and may include a logo 405.
[0058] The registration form 400 includes a user information section 410 for collecting user information (e.g., name, address, gender, age, etc.), a form specific information section 415 for collecting information corresponding to the particular type of registration form (e.g., location of purchase, meal selection, political party selection, etc.), and a validation information section 430 for collecting validation information (e.g., product serial number, membership number, digital signature, hand written signature, etc.). Each of these form sections 410,415,430 may include various types of form fields, such as text entry fields, check-box fields, alternative check-box fields, etc. These form fields may be static (i.e., the user must print the form out to use it; or a server must initiate insertion of data into the fields, such as by using the systems and techniques described here) or dynamic (i.e., the user may enter data directly into the electronic final format form document).
[0059] The registration form 400 also includes an optional check-box 420 to allow a user to submit optional information. If the user clicks the optional check-box 420, a request is sent to a server for the optional information fields. In response, the server sends data and machine instructions to convert the registration form 400 into a registration form 450. The registration form 450 retains the logo 405, the user information section 410, and the form specific information section 415. In addition, the registration form 450 includes an optional information section 425 for collecting optional information (e.g., a consumer survey), and a new validation information section 435, which retains any information previously entered in the validation information section 430, but is now in a new location on the page.
[0060] Although the example above is of a registration form, many different types of form documents are possible. Moreover, each such form may have its underlying final format, and the corresponding visual appearance, customized by machine instructions received from a server to accommodate data sent by the server along with the machine instructions. This includes removal of form fields and/or addition of form fields.
[0061] Moreover, many other types of final form document may utilize the systems and techniques described here. A company may send an abbreviated catalogue of their products to a consumer, and then dynamically expand the product coverage in the catalogue as the consumer makes new requests for information. An electronic publication may incorporate dynamic customized annotation stores (e.g., using a Web repository or SQL (Structured Query Language) database) and/or dynamic preference settings. For example, a server may cause machine instructions to be inserted into a final format document, where the machine instructions set up a user's online commenting preferences for that final format document. Each time the final format document is then opened, the user's online commenting preferences are automatically set up for that viewing.
[0062] FIG. 5 is a block diagram illustrating an example computing environment. An example machine 500 includes a processing system 502, which may include a central processing unit such as a microprocessor or microcontroller for executing programs to control tasks in the machine 500, thereby enabling the features and function described above. Moreover, the processing system 502 may include one or more additional processors, which may be discrete processors or may be built in to the central processing unit.
[0063] The processing system 502 is coupled with a bus 504, which provides a set of signals for communicating with the processing system 502 and may include a data channel for facilitating information transfer between storage and other peripheral components of the machine 500.
[0064] The machine 500 may include embedded controllers, such as Generic or Programmable Logic Devices or Arrays (PLD, PLA, GAL, PAL), Field Programmable Gate Arrays (FPGA), Application Specific Integrated Circuits (ASIC), single-chip computers, smart cards, or the like, which may serve as the processing system 502.
[0065] The machine 500 may include a main memory 506 and one or more cache memories, and may also include a secondary memory 508. These memories provide storage of instructions and data for programs executing on the processing system 502, and may be semiconductor based and/or non-semiconductor based memory. The secondary memory 508 may include, for example, a hard disk drive 510, a removable storage drive 512 and/or a storage interface 520.
[0066] The machine 500 may also include a display system 524 for connecting to a display device 526. The machine 500 includes an input/output (I/O) system 530 (i.e., one or more controllers or adapters for providing interface functions) for connecting to one or more I/O devices 532-534. The I/O system 530 may provide a communications interface, which allows software and data to be transferred, in the form of signals 542, between machine 500 and external devices, networks or information sources. The signals 542 may be any signals (e.g., electronic, electromagnetic, optical, etc.) capable of being received via a channel 540 (e.g., wire, cable, optical fiber, phone line, infrared (IR) channel, radio frequency (RF) channel, etc.). A communications interface used to receive these signals 542 may be a network interface card designed for a particular type of network, protocol and channel medium, or may be designed to serve multiple networks, protocols and/or channel media.
[0067] Machine instructions (also known as programs, software or code) may be stored in the machine 500 or delivered to the machine 500 over a communications interface. As used herein, the term “machine-readable medium” refers to any media used to provide information indicative of one or more operational instructions for the machine 500. Such information includes machine instructions provided to the processing system 502 for execution, and such media include embedded controllers, memory devices, and signals on a channel.
[0068] Other systems, architectures, and modifications and/or reconfigurations of machine 500 of FIG. 5 are also possible. The various implementations described above have been presented by way of example only, and not limitation. Other embodiments may be within the scope of the following claims.
Claims
What is claimed is:
1. A machine-implemented method of modifying an electronic document, the method comprising:
receiving, at a computer system comprising at least one processor and at least one memory device, a request from a client;
producing, at the computer system, data corresponding to the client request;
generating instructions to modify an electronic document having a predetermined format that defines an appearance of the electronic document independent of a device used to present the electronic document, the generated instructions specifying one or more operations to modify the electronic document's predetermined format at the client to accommodate the produced data, the generated instructions to be performed at the client to effect the one or more operations, wherein the one or more operations to modify the predetermined format at the client comprise adding information to the electronic document without changing pre-existing information in the electronic document; and
transmitting the produced data and the generated instructions to the client.
2. The method of claim 1, wherein the produced data includes a location from which the client is to retrieve the electronic document.
3. The method of claim 1, wherein the produced data includes a file name for the electronic document, which is already locally accessible by the client.
4. The method of claim 1, wherein the generated instructions comprise a script.
5. The method of claim 4, wherein the generated instructions further comprise at least one tag indicating an order in which the produced data is to be imported into the electronic document and the instructions are to be performed.
6. The method of claim 5, wherein the at least one tag is a before tag, an after tag or a document tag, wherein the before tag indicates that the produced data is to be imported into the electronic document before the instructions are performed, the after tag indicates that the produced data is to be imported into the electronic document after the instructions are performed, and the document tag indicates that at least a portion of the generated instructions are to be inserted into the electronic document.
7. The method of claim 5, wherein the electronic document comprises a form document including one or more form fields, which are responsive to user actions.
8. The method of claim 7, wherein adding the information causes a new visual object to overlay one or more pre-existing visual objects in the electronic document.
9. The method of claim 7, wherein the generated instructions are specific to the electronic document, and the operations to modify the predetermined format at the client result in one or more of the following document changes: field identity change, field location re-arrangement, and field content change.
10. The method of claim 7, wherein the client comprises a device having a memory storing the electronic document.
11. The method of claim 7, wherein the client comprises a software application.
12. The method of claim 7, wherein the client request comprises a database search request, and wherein producing data comprises retrieving data from a database.
13. The method of claim 7, wherein producing data comprises generating data using scripts.
14. The method of claim 7, wherein generating instructions comprises:
retrieving initial instructions; and
customizing the initial instructions to be specific to the electronic document.
15. A machine-implemented method of modifying an electronic document, the method comprising:
obtaining an electronic document having a predetermined format that defines an appearance of the electronic document independent of a device used to present the electronic document;
sending a request to a server;
receiving, from the server, data and instructions to modify the electronic document; and
modifying the electronic document's predetermined format in accordance with the received instructions to accommodate the received data, wherein modifying the electronic document's predetermined format comprises adding information to the electronic document without changing pre-existing information in the electronic document.
16. The method of claim 15, wherein obtaining the electronic document comprises receiving the electronic document.
17. The method of claim 15, wherein obtaining the electronic document comprises retrieving the electronic document as directed by the instructions.
18. The method of claim 15, wherein the instructions comprise a script.
19. The method of claim 18, wherein the instructions further comprise at least one tag indicating an order in which the produced data is to be imported into the electronic document and the instructions are to be performed.
20. The method of claim 19, wherein the at least one tag is a before tag, an after tag or a document tag, wherein the before tag indicates that the produced data is to be imported into the electronic document before the instructions are performed, the after tag indicates that the produced data is to be imported into the electronic document after the instructions are performed, and the document tag indicates that at least a portion of the generated instructions are to be inserted into the electronic document.
21. The method of claim 19, wherein the electronic document comprises a form document including one or more form fields, which are responsive to user actions.
22. A machine-implemented method of modifying an electronic document, the method comprising:
receiving, at a computer system comprising at least one processor and at least one memory device, a request from a client;
producing, at the computer system, data corresponding to the client request;
generating instructions to modify an electronic document defining visual information to be displayed, the generated instructions specifying one or more operations to modify the electronic document at the client to accommodate the produced data, and the generated instructions including at least one tag indicating an order in which the produced data is to be imported into the electronic document and the instructions are to be performed, and the generated instructions to be performed at the client to effect the one or more operations, wherein the one or more operations to modify the electronic document comprise adding formatting information to the electronic document without changing pre-existing formatting information in the electronic document; and
transmitting the produced data and the generated instructions to the client.
23. The method of claim 22, wherein the at least one tag indicates that the produced data is to be imported into the electronic document before the instructions are performed.
24. The method of claim 22, wherein the at least one tag indicates that the produced data is to be imported into the electronic document after the instructions are performed.
25. The method of claim 22, wherein the at least one tag indicates that at least a portion of the generated instructions are to be inserted into the electronic document.
26. The method of claim 22, wherein the at least a portion of the generated instructions result in dynamically set preference settings for the electronic document.
27. The method of claim 22, wherein the generated instructions comprise a script.
28. The method of claim 27, wherein the electronic document comprises a form document including one or more form fields, which are responsive to user actions.
29. A non-transitory machine-readable storage medium embodying information indicative of instructions for causing one or more machines to perform operations comprising:
receiving a request from a client;
producing data corresponding to the client request;
generating instructions for an electronic document having a predetermined format that defines an appearance of the electronic document independent of a device used to present the electronic document, the generated instructions specifying one or more operations to modify the predetermined format at the client to accommodate the produced data, the generated instructions to be performed at the client to effect the one or more operations, wherein the one or more operations to modify the predetermined format at the client comprise adding information to the electronic document without changing pre-existing information in the electronic document; and
transmitting the produced data and the generated instructions to the client.
30. The non-transitory machine-readable storage medium of claim 29, wherein the produced data includes a location from which the client is to retrieve the electronic document.
31. The non-transitory machine-readable storage medium of claim 29, wherein the produced data includes a file name for the electronic document, which is already locally accessible by the client.
32. The non-transitory machine-readable storage medium of claim 29, wherein the generated instructions comprise a script.
33. The non-transitory machine-readable storage medium of claim 32, wherein the generated instructions further comprise at least one tag indicating an order in which the produced data is to be imported into the electronic document and the instructions are to be performed.
34. The non-transitory machine-readable storage medium of claim 33, wherein the at least one tag is a before tag, an after tag or a document tag, wherein the before tag indicates that the produced data is to be imported into the electronic document before the instructions are performed, the after tag indicates that the produced data is to be imported into the electronic document after the instructions are performed, and the document tag indicates that at least a portion of the generated instructions are to be inserted into the electronic document.
35. The non-transitory machine-readable storage medium of claim 33, wherein the electronic document comprises a form document including one or more form fields, which are responsive to user actions.
36. The non-transitory machine-readable storage medium of claim 35, wherein adding the information causes a new visual object to overlay one or more pre-existing visual objects in the electronic document.
Patent Citations (15)
| Patent | Date | Inventor | Cited By |
|---|---|---|---|
| US5465299(A) | 1995-11-01 | Matsumoto et al. | Examiner |
| US5634064(A) | 1997-05-01 | Warnock et al. | Examiner |
| US5778372(A) | 1998-07-01 | Cordell et al. | Examiner |
| US5987480(A) | 1999-11-01 | Donohue et al. | Examiner |
| US6026433(A) | 2000-02-01 | D'Arlach et al. | Examiner |
| US6259445(B1) | 2001-07-01 | Hennum et al. | Examiner |
| US6469714(B2) | 2002-10-01 | Buxton et al. | Examiner |
| US6557005(B1) | 2003-04-01 | Burget | Examiner |
| US6609200(B2) | 2003-08-01 | Anderson et al. | Examiner |
| US6701343(B1) | 2004-03-01 | Kenyon | Examiner |
| US6829746(B1) | 2004-12-01 | Schwerdtfeger et al. | Examiner |
| US6868525(B1) | 2005-03-01 | Szabo | Examiner |
| US2002/0198933(A1) | 2002-12-01 | Kwak | Examiner |
| US2003/0225853(A1) | 2003-12-01 | Wang et al. | Examiner |
| WO/51018 | 2000-08-01 | Examiner |
Non-Patent Literature (12)
- Houghton Mifflin Company, The American Heritage College Dictionary, Houghton Mifflin Company, 4th, p. 519.Examiner
- Wikipedia definition of “Device Independent”,http://en.wikipedia.org/wiki/Device independent.Examiner
- Mikhalenko, Peter, “Introduction to Device Independence, Part1”, Sep. 22, 2004.Examiner
- Wikipedia definition of “XML”, http://en.wikipedia.org/wiki/Xml.Examiner
- Abrams, Marc, et al., “UIML: An XML Language for Building DeviceIndependent User Interfaces”.Examiner
- Wikipedia definition of “Cross platform”, http:I/en.wikipedia.org/wiki/Crosslaptform.Examiner
- Wikipedia definition of “Java programming language”,http://en.wikipedia.org/wiki/Java programming language.Examiner
- Microsoft Computer Dictionary Fifth Edition,copyright 2002, p. 511.Examiner
- Adobe PhotoDeluxe Home Edition 3.0 Getting Started Guide, 1998, Adobe Systems incorporated.Applicant
- Microsoft Windows98 Second Edition Help System, 1999.Applicant
- http//graphicssoft.about.com/cs/photoshopationtip/, Photoshop Action Tips—using managing debugging and troubleshooting Photoshop actions, Sep. 12, 2001.Applicant
- Apple Guide Complete: Designing and Developing Onscreen Assistance, Addison-Wesley Publishing company, Feb. 1995.Applicant