Automatic creation and server push of multiple distinct drafts

Abstract

An application automatically saves drafts of a document in association with the document. Drafts are saved, for example, whenever the application closes the document. Thus, the application stores a separate draft of the document for each session in which the document was used. The saved drafts are logically associated with each other and their original document. Because of this association, whenever the user accesses the document in the application, the application may present to the user a list of the various drafts of the documents. The user may continue working on the last saved draft, or the user may select another draft from which to continue working. The application further includes a collaborative interface for listing objects at a server. The server pushes new changes or additions to the objects directly to the client, and the client updates the interface accordingly, without user intervention.

Description

FIELD OF THE INVENTION

Embodiments of the invention described herein relate generally to object management, and, more specifically, to techniques for saving and/or sharing objects edited by an application.

BACKGROUND

The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section.

Collaborative projects typically require extensive use of document authoring applications. Members of a project team may create documents at their computer using various document authoring applications, and then share those documents with other members of the project team. The other members may view and utilize the information in these shared documents using document authoring applications at other computers.

One way for a project member to share information with another project member is to share an image. An image may communicate information in a variety of ways. For example, an image may depict a chart, graph, map, picture, or textual passage.

One way for a project member to produce an image to share with other project members is for the project member to utilize image generation functionality in a document authoring application. For example, a document authoring application may allow a user to generate images of charts or graphs produced in the course of working with a report document. As another example, a document authoring application may also allow a user to generate a screenshot image of information currently depicted in the application. These images may then be shared with other project members.

Although image sharing is useful for quickly communicating a limited amount of information, a weakness of the above-described techniques is that the techniques do not provide other project members with access to any information other than the information depicted in the image. Nor does the technique allow other project members to use or edit the information depicted in the image.

For example, a first project member may use a document authoring application to create a reporting document with very detailed data regarding stock prices over the course of several years. Using the document authoring application, the project member may then produce an image of a graph that summarizes the detailed data. The first project member may then share that image with other project members. While the other project members would be able to quickly interpret the summary information depicted in the graph, the other project members would be unable to access the more detailed data stored in the reporting document.

One solution to this problem would be for the first project member to send the reporting document to the other project members instead of the image. However, this solution has several drawbacks. First, the solution creates unnecessary copies of the reporting document. The unnecessary copies waste space, create security risks, and introduce potential data synchronization problems. Second, without sharing the image, the first project member loses the benefit of the image's efficiency in quickly communicating an overview of the information in the reporting document. Third, the solution is more labor-intensive for the first project member, since the solution requires the first project member to locate the reporting document in a file system so that it can be attached to an email or otherwise sent to the other project members.

Existing techniques for using document authoring applications are inefficient for a number of reasons. For example, users of document authoring applications often find it necessary to switch quickly to other documents or tasks. In switching to another document or task, a user must often close his or her current document. To avoid losing work on a currently open document, the user is required to save the currently open document before closing it. This requirement slows down the speed with which a user may switch to another document or task. Moreover, a user can sometimes forget to save the currently open document and consequently lose work.

Application designers have proposed various techniques to solve these problems. One such technique is to automatically save changes to a currently open document when the application is caused to close the document. However, this technique is undesirable because the user may not have intended to save the changes, or the user may have intended to save the changes as a different version of the document so that the original version of the document is not overwritten. Another technique prompts the user to confirm that the document should or should not be saved before closing the document. However, this technique still decreases the speed with which the user may switch documents or tasks.

Another technique relies on automatically saving a document periodically in a single auto-saved version. If a document is closed without a save operation having been performed, the auto-saved version may be used to recover unsaved information. For example, upon resumption of an application, the application may check to see whether any auto-saved versions exist. If an auto-saved version does exist, the user is prompted to save or discard the auto-saved version. However, this technique merely shifts the transaction time required for a save operation to a later time. In fact, this technique may create more work for a user, in that the user may be required to locate the auto-saved file and/or save the auto-saved version over the last saved version. Furthermore, a user will still lose any changes made between the time of the last auto-save and the time the document was closed.

As another example of inefficiency in existing techniques for using document authoring applications, consider the task of sharing documents between users of document authoring applications at different systems. A common technique for sharing documents is to email the documents. However, this technique may be inefficient in certain situations. For example, users who share documents in this manner are typically subjected to at least some time delay while waiting for an email to arrive. This technique also results in extraneous copies of the same data. In the event a user wishes to edit data from a shared document, they must also email those changes back to original document author, who must be sure to replace his or her document with the changed version.

Another approach for sharing documents is to store documents on a centralized server. This approach requires a user to know how to use their operating system to navigate to the server and locate the shared documents. This technique further requires that an original document author notify other members of a project team of the existence and location of new documents. The time required to navigate the server and communicate messages regarding the existence and location of new documents represent inefficiencies in the collaborative process.

Other approaches use complex document management or version control applications that require check-in and check-out of documents.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which like reference numerals refer to similar elements and in which:

FIG. 1 is a block diagram that illustrates a system 100 that supports project collaboration;

FIG. 2 is a flow chart 200 illustrating a method for auto-saving drafts;

FIG. 3 is a flow chart 300 illustrating a method for facilitating user interaction with saved drafts of an object;

FIG. 4 is a flow chart 400 illustrating a method for a server pushing new or saved objects to a user;

FIG. 5 illustrates an example draft listing 510 in a graphical interface 500 presented by a document authoring application;

FIG. 6 illustrates an example graphical interface of a document authoring application in which a draft is selected;

FIG. 7 illustrates an interface 700 that includes an example collaborative document listing interface 750; and

FIG. 8 is block diagram of a computer system upon which embodiments of the invention may be implemented.

DETAILED DESCRIPTION

In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, that the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to avoid unnecessarily obscuring the present invention.

Embodiments are described herein according to the following outline:

• • 1.0. General Overview
    • 1.1. Terms and Definitions
  • 2.0. Structural Overview
  • 3.0. Functional Overview
    • 3.1. Auto Saving of Drafts
    • 3.2. User Interaction with Drafts
    • 3.3. Server-Push of New or Saved Objects
  • 4.0. Implementation Examples
    • 4.1. Example Interface for Drafts
    • 4.2. Example Interface for Server-Pushed Updates to Objects
    • 4.3. Example Triggering Events
    • 4.4. Example Draft Format
    • 4.5. User-Instigated Save Operations
  • 5.0. Implementation Mechanism—Hardware Overview
  • 6.0. Extensions and Alternatives
  • 7.0. Conclusion

1.0. GENERAL OVERVIEW

Approaches, techniques, and mechanisms are disclosed for addressing the above-described in and other problems. In an embodiment, more efficient mechanisms are provided for saving changes made to a document when the document is closed. Embodiments also provide mechanisms for distinguishing between changes made during different application sessions involving the document.

According to an embodiment, a document authoring application automatically saves a new draft of a document whenever the application closes the document. Each draft is stored in addition to drafts that were previously stored. Thus, the application stores a separate draft of the document for each application session in which the document was used. The application saves the drafts in such a manner that the drafts are logically associated with each other and their original document. Because of this logical association, whenever the user accesses the document in the application, the application may present to the user a list of the various drafts of the documents. The user may continue working on the last saved draft, or the user may select another draft from which to continue working.

According to an embodiment of the invention, document collaboration mechanisms are integrated into a program application. A document authoring application (also known as “the client”) may feature a collaborative document listing interface. The client is connected to a server at which the client and other clients store documents created by users. The client presents the collaborative document listing interface to a user using, for example, a sidebar, window pane, or other graphical interface component. The collaborative document listing interface lists document identifiers for various documents on the server that are accessible to the client's user. The client's user can open a document by selecting a corresponding document identifier in the document listing interface.

When a second user saves a new document to the server, the first user's client automatically updates the document listing interface to display data for the new document. Deletion and renaming operations at a second client may likewise result in automatic updates at the document listing interface of the first client. In some embodiments, this automatic updating occurs as a result of the first client periodically polling the server for new documents. In other embodiments, the server immediately pushes data indicating document additions, changes, and deletions to clients.

In other aspects, the invention encompasses a computer apparatus and a computer-readable medium configured to carry out the foregoing steps.

In an embodiment, an application creates multiple drafts of an object. The application automatically creates each draft of the multiple drafts in response to one or more triggering events. The one or more triggering events include one or more of: a first command that causes the application to close the object; or a second command that causes the application to generate output for the object, wherein the output is different than the draft. The application causes each of the multiple drafts to be stored concurrently, in association with the object.

An embodiment comprises: receiving a command to open the object, and in response to the command, opening a most recently created draft of said multiple drafts. An embodiment comprises: presenting a list of the multiple drafts, receiving a selection of a particular draft from the list of the multiple drafts, and in response to receiving the selection of the particular draft, opening the particular draft. In an embodiment, the list of the multiple drafts includes, for each of the multiple drafts, data indicating a time at which the draft was saved. In an embodiment, the application creates the multiple drafts without deleting any draft. In an embodiment, the application automatically creates each draft in response to the one or more triggering events, without user intervention. In an embodiment, the output is one of a report, image, printout, or link. In an embodiment, each of the multiple drafts is stored within the object. In an embodiment, each of the multiple drafts is stored external to the object and includes an identifier for the object. In an embodiment, the one or more triggering events are each commands that cause the application to close the object. In an embodiment, the command that causes the application to close the object is one of an instruction to close the object, an instruction to open another object, or an instruction to terminate the application. In an embodiment, the one or more triggering events are each commands that cause the application to generate output for the object, wherein the output is different than the draft.

In an embodiment, an application opens an object. The application receives first input that causes the application to modify the object. The application receives a first command that causes the application to close the object. In response to the first command, the application creates a first draft of the object and storing the first draft in association with the object. Subsequent to the first command, the application again opens the object. The application receives second input that causes the application to modify the object. The application receives a second command that causes the application to close the object. In response to the second command, the application creates a second draft of the object and storing the second draft in association with the object, without deleting the first draft of the object.

In an embodiment, the application displays a list of drafts associated with object, the list of drafts including the first draft and the second draft. The application receives a user selection of a particular draft from the list of drafts. The application opens the particular draft. In an embodiment, the steps of: in response to the first command, the application creating a first draft of the object and storing the first draft in association with the object, and in response to the second command, the application creating a second draft of the object and storing the second draft in association with the object, are performed without user intervention.

An embodiment comprises presenting an interface comprising a list of objects stored at a location on a server. While presenting the interface, without user intervention, and further without polling the server, data is received from the server indicating the availability of a new object at the server. In response to the data, the list of objects is updated to include the new object. In an embodiment, the new object is a draft of an existing object in the list of objects, and the updated list of objects is organized in a hierarchy indicating that the draft is associated with the existing object.

1.1. Terms and Definitions

For convenience, various embodiments of the techniques described herein are described with respect to “documents.” As used herein, a document is any type of object, including files and other resources, that embodies, encapsulates, or encodes information in structured data. Specifically, the data for a document is structured in such a manner so as to be understood by one or more document authoring applications. An application understands structured data when the application, upon reading the data, may perform various actions with the information represented by the object, such as presenting the information to a user. Documents may include word processing files, PDF files, images, and any other form of structured data. Moreover, a document authoring application is any application that may interpret a document in such a manner so as to deliver one or more visual presentations of the information embodied, encapsulated, or encoded within the document.

An example method of sharing information from a document follows. The steps described above are only examples of steps that may be employed according to an embodiment of the invention. Other embodiments may require more or fewer steps, in different orders.

An application “opens” a document. The application may, for example, open the document for viewing or editing.

The application displays information from the document in a graphical user interface (GUI). As used herein, “information from the document” may be any data contained in the actual document, as well as any information collected or generated based on the data within the document. For example, the document may contain data that, when interpreted by the application, causes the application to collect information from one or more databases and then format that information for display in a graphical user interface. One such document may contain, for instance, data that causes the application to generate an interactive display of graphed financial data.

A user submits input that indicates that the user wishes to generate an image based on information from the document. The input may be any suitable input, including, for example, a keystroke, control selection, or mouse click. The user may submit this input to the application itself, or the user may submit it to any other process running on the computing device, such as a background or system process that listens for certain input. For instance, a background application may feature one or more buttons for receiving such input. As another example, an operating system may listen for a certain keystroke combination that indicates that the user wishes to take a screenshot.

According to an embodiment, the input comprises the user clicking on a “one-click sharing” button. For example, an example GUI of an application may includes a visual representation of a financial document named “new investigation.” A “one-click sharing” button allows a user to submit input indicating the user's intent to take a screenshot of the information presented in the GUI. In response to a user clicking on the button, the application may (1) take a screenshot of the information in the GUI, (2) generate a link to the document “new investigation,” and (3) place both the link and the screenshot in a system clipboard for use in other applications.

According to an embodiment, the input is a single input event. For example, the input may be a single mouse click, single menu selection, or single keystroke combination.

According to an embodiment, the input is received subsequent to an initial input indicating that the user wishes to take a formatted screenshot, and/or one or more additional inputs to an interface for formatting or filtering the screenshot.

In response to the input from the user, the application or process that received the input generates an image based on information from the document. The image indicates a visual representation of at least a portion of the information. For example, the application may take a screenshot of the information displayed in the GUI. Or, the application may execute an image generation routine to translate the document or portions thereof into visual information. The image may be in any suitable format, including bitmap (BMP), Portable Document Format (PDF), Tagged Image Format (TIFF), or Joint Photographic Experts Group (JPEG).

The generated image may depict a variety of information stored in or generated from a currently opened document. For example, the image may be a screenshot of information currently being presented to the user, such as graphs or tables. The screenshot may comprise an image bitmap of the current application window or active application window. The screenshot may be of the entire application window, or a designated portion thereof. As another example, the application may feature built-in routines for generating various summary images of the document in response to a user selecting various buttons or menu items in the graphical interface.

In some embodiments a process other than the original application (such as a background application or an operating system service) may be responsible for receiving the input from the user. In some embodiments, this other process may communicate with the original application via an application programming interface (API) to obtain from the application any information necessary for the process to perform the image generation. Additionally, the process may also utilize this API to cause the application to perform some or all of the above.

For convenience, various embodiments of the techniques described herein are described with respect to “screenshots.” Generally, a screenshot is an image that captures the graphical content of a computer screen at a given time, encoded as data in an image-based format (e.g. a bitmap file). However, the techniques described herein are applicable to many types of media other than “screenshots,” including other types of images, slideshows, presentations, and videos. Thus, unless otherwise noted, any technique or step described herein as involving a “screenshot” or an image, is likewise applicable to any media derived from or based on a document being viewed or otherwise utilized in a document authoring application.

In some embodiments, the original application may save a reference draft of the document just prior to creating the image. A link may refer to this reference draft of the document instead of the document draft that was originally opened by the user. The reference draft may be write-protected so as to ensure that the reference draft always includes the same information that was contained in the document at the time the image was generated.

2.0. STRUCTURAL OVERVIEW

FIG. 1 is a block diagram that illustrates a system 100 that supports project collaboration, according to an embodiment of the invention. System 100 may be any system in which document authoring applications are utilized, including a financial analysis system such as deployed by Palantir Finance.

System 100 includes a computing device 110 operated by a user 111. Computing device 110 executes an application 120a. Application 120a is a document authoring application, such as a web browser, word processor, or Palantir Finance client. Application 120a allows user 111 to view and edit document 121. As depicted, document 121 is structured data stored in memory at server 130. However, document 121 may be stored at any location accessible to application 120a, including at computing device 110.

Server 130 is a computing device connected to system 100 via a network 140. Network 140 may be, for instance, an internet or intranet. Server 130 may be any computing device capable of sharing structured data with computing devices connected to network 140, including a web server, file server, or Palantir Finance server.

While using application 120a, user 111 may periodically issue commands that cause application 120a to close document 121. Such commands may include, among others, a command to close document 121, a command to close application 120a, a command to switch to editing another document in application 120a, and so on. In response to each of such commands, application 120a may generate a new draft of document 121, as illustrated by drafts 121a-121x. Each of drafts 121a-121x is data indicating a different version of document 121. Application 120a may also save drafts 121a-121x in response events other than commands that cause application 120a to close document 121, including commands that explicitly instruct application 120a to save a new draft, commands that cause application 120a to share document 121 with another user, and commands that cause application 120a to generate output based on document 121.

Application 120a may save these drafts 121a-121x in association with the original document 121, so that when user 111 later reopens document 121, application 120a may easily provide user 111 with a listing of the different drafts of document 121 that have been created. From this listing, user 111 may access and/or resume working with any of drafts 121a-121x.

As depicted, each of drafts 121a-121x are stored separately from document 121. However, some or all of drafts 121a-121x may be stored inside of document 121. Drafts 121a-121x may include a full copy of the version of document 121 that they represent, or drafts 121a-121x may merely constitute data from which the represented version may be derived, such as differential data indicating changes since a specified previous draft. In some embodiments, document 121 is itself a draft, including a complete copy of an original version of the document. In other embodiments, document 121 is a meta-object, and its document data is stored entirely in drafts 121a-121x.

System 100 further includes computing device 160 operated by user 161. Computing device 110 executes an application 120b. Application 120b is any application capable of viewing document 121, including another instance of application 120a. Application 120b includes an interface for accessing documents and drafts at server 130. When document 121 and/or drafts 121a-121x are added or modified at server 130, server 130 “pushes” information to application 120b indicating that the document or draft has been created or modified. In response to this information, application 120b instantly updates its listing of documents and drafts at server 130. Alternatively, application 120b may poll server 130 periodically to determine if new drafts exist.

System 100 is but one example of a system in which the techniques disclosed herein may be practiced. Various embodiments of the invention may be practiced in other systems having more or fewer components. For example, some embodiments featuring only the auto-saving of drafts may not require a server 130 or computing device 160. As another example, some embodiments featuring only a server that pushes new or updated objects, may not involve drafts 121a-121x.

3.0. FUNCTIONAL OVERVIEW

3.1. Auto Saving of Drafts

According to an embodiment of the invention, an application creates multiple drafts of an object. The application automatically creates each draft of the multiple drafts in response to one or more triggering events. The one or more triggering events may include, for example, a command that causes the application to close the object or a command that causes the application to generate output for the object. Outputs are one of: a report, image, printout, or link. Each of the multiple drafts to be stored concurrently, in association with the object. In other words, previously saved drafts are preserved by the application instead of overwritten.

According to an embodiment, each of the multiple drafts includes information associating the draft with a specific session in which the draft was generated. A “session” refers to a period of time between an application opening the object for editing and a triggering event. For example, this information may include an opening and/or closing timestamp for the session. The application may later use this session-specifying information to present an interface allowing a user to select from amongst the multiple drafts of the object.

FIG. 2 is a flow chart 200 illustrating a method for auto-saving drafts according to an embodiment. At step 210, an application, such as application 120a, opens an object, such as document 120. As used herein, the terms “opening an object” and “opening a document” refer to the application loading a copy of object or document from a storage location such as a non-volatile memory into a location in volatile memory.

At step 215, the application receives input that causes the application to modify the object in the volatile memory, but not in the storage location. For example, the application may receive input identifying user edits to the document. Or, the application may receive information indicating that a resource relied upon by the object has changed.

At step 220, after having modified the document in step 215, the application receives a command that causes the application to close the object. As used herein, the terms “closing the object” and “closing the document” refer to the application removing the modified copy of the object or document from the location in volatile memory in which it was loaded during step 210. Such removal may occur, for instance, because of the termination of the application instance or application thread that opened the object or document.

Step 220 may, for example, comprise any of several user actions that cause the application to close the document. A user may close the application window, or the user may perform an action that causes the application to load a different document in place of the current document. The application may also automatically save a new draft when it is forced to close a document in response to application or system events, such as an inactivity timeout, a request from a memory management component to release memory, a user logout, or a system restart.

At step 230, in response to the command of step 220, before closing the object, the application creates a first draft of the object, such as draft 121a. At step 240, the application stores this first draft in association with the object, for example in a same storage directory from which the object was loaded in step 210. The application may store the draft in association with the object using a variety of techniques, as discussed in section 4.4.

Subsequent to the command of step 220, the application again opens the object at step 250. At step 255, the application again receives input that causes the application to modify the object.

At step 260, after having modified the document in step 255, the application receives another command that causes the application to close the object.

At step 270, in response to the command of step 260, before closing the object, the application creates a second draft of the object. At step 280, the application stores a second draft in association with the object, without deleting the first draft of the object. Again, the application may store the draft in association with the object using a variety of techniques, as discussed in section 4.4. Thus, upon completion of flow chart 200, the object will be associated with two different drafts reflecting changes from two different sessions.

Although logically presented as separate steps, steps 230 and 240 may in fact be accomplished by a single step of saving the new draft to a storage medium. The same is also true of steps 270 and 280.

In some embodiments, steps 230 and 270 may be performed in response to events other than the commands of steps 220 or 260. Example triggering events are discussed in section 4.3.

3.2. User Interaction with Drafts

FIG. 3 is a flow chart 300 illustrating a method for facilitating user interaction with saved drafts of a document, according to an embodiment.

At step 310, an application receives a command to open the document for viewing or editing. In some embodiments, the application immediately responds to this command by opening the original document or the most recently saved draft. However, the user may subsequently select other drafts for viewing and editing via the subsequent steps. In other embodiments, the application waits for the subsequent steps to open any documents or drafts.

At step 320, the application determines which, if any, drafts exist for the document. The application may, for instance, search through a repository of files for drafts of the document. In finding drafts, the application may utilize stored metadata, information about the file system structure, or any other indicator of logical association between a draft and an original document. In an embodiment, a server storing the drafts, such as server 130, features an API by which the application may request a list of drafts for a document. The exact technique used to identify drafts for an object will depend upon the manner in which the application stores drafts, as discussed in section 4.4.

At step 330, the application then presents to the user a list of available drafts. For example, in the case of the object opened during flow 200 of FIG. 2, the application may display for the object a list that includes the first draft and the second draft. An example interface for presenting a list of drafts is described in section 4.1. The application may skip this and subsequent steps if no drafts exist.

At step 340, the application may receive input indicating user's selection of a particular draft from the displayed list. At step 350, upon the user selection of the particular draft, the application may open and present the draft to the user for viewing and editing.

In some embodiments, the application may allow a user to delete drafts. For example, the user may select the draft using a draft listing. The user may then press a “delete” key to erase the draft.

3.3. Server-push of New or Saved Objects

FIG. 4 is a flow chart 400 illustrating a method for a server pushing new or saved objects to a user, according to an embodiment.

At step 410, a client, such as application 120a, presents an interface comprising a list of objects stored at a location on a server, such as server 130. One example of such an interface is described in section 4.2.

At step 420, while presenting the interface, without user intervention, the client receives from the server data indicating either a change to an object at the server, or the availability of a new object at the server. For example, the client may receive data indicating that metadata—such as an object name or timestamp—for an object has changed. This metadata may be metadata that is currently being displayed in the interface. As another example, the client may receive information indicating that a new draft of an existing object has been added to the server. In an embodiment, step 420 is further accomplished without the client polling the server. For example, the server may send to the client unsolicited announcements of new or changed objects at the server.

At step 430, in response to the data received in step 420, the client updates its list of objects to reflect the change or addition. For example, if the client had received data indicating a new name for an object, the client would update the list of objects to reflect the new name. As another example, if the client had received notification of the availability of a new draft of an existing object, the client would update the list of objects to include a tree-like hierarchy indicating the new draft as a “leaf” of a node for the existing object.

4.0. IMPLEMENTATION EXAMPLES

4.1. Example Interface for Drafts

FIG. 5 illustrates an example draft listing 510 in a graphical interface 500 presented by a document authoring application, according to an embodiment. FIG. 6 illustrates an example graphical interface 600 of a document authoring application in which a draft is selected. Referring first to FIG. 5, draft listing 510 is part of a document listing 520 in a sidebar 530 of the graphical interface. While draft listing 510 is depicted as a modal-less component of graphical interface 500, in that it may remain visible while a user works on his or her document in graphical interface 500, the application may present draft listing 510 to the user using a variety of other graphical interface techniques.

Document listing 520 may include a draft listing toggle button 522, which permits a user to instruct the application to show or hide draft listings for each document identifier in document listing 520.

Draft listing 510 includes an original document identifier 511, which identifies the original document as “my google.” Draft listing 510 also includes draft identifiers 514-515. Each draft identifier 514-515 includes a draft name and a time at which the draft was saved. To represent the logical association between the original document and its drafts, draft identifiers 514-515 are displayed in positions that are hierarchically below the original document identifier 511. The application may also use other graphical presentation techniques to visually distinguish between drafts and the original document, such as different display intensity, different color, different character styles, etc.

When a user selects a draft identifier 514-515, the application may present to the user a draft identified by the selected draft identifier. The application may change the visual appearance of a selected draft identifier to keep the user informed of which draft he or she is viewing. For example, in FIG. 5, draft identifier 515 is highlighted to signal that the draft identified by draft identifier 515 is currently being edited within graphical interface 500. In FIG. 6, the draft identifier “my goog chart” 602 is displayed with gray highlighting to indicate that it is selected. In response to selection of a draft name, a corresponding graphical chart 604 for the selected draft is displayed in the graphical interface.

4.2. Example Interface for Server-pushed Updates to Objects

FIG. 7 illustrates an interface 700 that includes an example collaborative document listing interface 750, according to an embodiment. Collaborative document listing interface 750 is a sidebar of application window 700. Collaborative document listing interface 750 lists a number of document identifiers 752 in a tree-like structure. The tree-like structure may be sortable, searchable, and/or filterable. A document corresponding to each listed document identifier 752 is stored on a server accessible to the software application.

4.3. Example Triggering Events

In some embodiments, the application may also or instead automatically save new drafts in response to events other than the closing of a document. For example, the application may save a new draft after a certain period of time has elapsed, or in response to detecting certain types or quantities of changes to the document. The application may also create a new draft each time the user saves the document. The application may also automatically save a draft in response to a sharing operation, such as the “one-click sharing” operation discussed in “One-Click Sharing for Screenshots and Related Documents.”

Approaches, techniques, and mechanisms are disclosed for the efficient sharing of information between multiple users. According to an embodiment, an application provides a user with an efficient mechanism for simultaneously sharing access to documents that store information along with media, such as images, that overview or are derived from that information.

According to an embodiment, an application comprises a sharing mechanism that allows a user to 1) quickly generate an image of information from a document, 2) concurrently generate a link to the document, and 3) simultaneously paste the image with the associated link in another application. In response to a user action that implicates this sharing mechanism, the application generates an image, such as a screenshot, that depicts information from a document that has been opened in the application. The application places the image, along with an associated link to the document, in a buffer, such as a system clipboard. While in another document authoring application, such as a word-processor or email application, the user pastes the contents of the buffer into another document that has been opened in the other application. An image is therefore placed in the other document along with the associated or embedded link.

The other document is then shared with another user. The other user opens the other document in another instance of the other application. The other user views the embedded image for a quick overview of the information in the original document. If the other user requires access to the information in the original document, the other user may select or click on the embedded image. This selection causes the other application to activate the associated link. In response, the other application causes another instance of the original application to launch and open the original document for the other user.

In an embodiment, an application provides a user with functionality for cropping a screenshot prior to taking the screenshot. The application may receive initial input indicating that the user wishes to take a cropped screenshot. The application may then receive user input selecting a pre-defined or arbitrary region of the GUI for the screenshot. In response to the latter input, the application may generate an image of the selected region of the GUI.

According to an embodiment, an application may provide a user with functionality for annotating a screenshot prior to taking the screenshot. The application may receive initial input indicating that the user wishes to take a screenshot. The application may then receive input indicating annotations, such as graphics and text, to layer over the GUI. The application may then receive input indicating that the application should take the screenshot. In response to the latter input, the application may generate an image of the GUI with the overlaid annotations.

For convenience, various embodiments of the techniques described herein are described with respect to “screenshots.” Generally, a screenshot is an image that captures the graphical content of a computer screen at a given time, encoded as data in an image-based format (e.g. a bitmap file). However, the techniques described herein are applicable to many types of media other than “screenshots,” including other types of images, slideshows, presentations, and videos. Thus, unless otherwise noted, any technique or step described herein as involving a “screenshot” or an image, is likewise applicable to any media derived from or based on a document being viewed or otherwise utilized in a document authoring application.

In some embodiments, the original application may save a reference draft of the document just prior to creating the image. The link may refer to this reference draft of the document instead of the document draft that was originally opened by the user. The reference draft may be write-protected so as to ensure that the reference draft always includes the same information that was contained in the document at the time the image was generated.

In some embodiments, the application may be configured to automatically save a new draft upon the closing of a document, or in response to another event, only when a document has been changed.

4.4. Example Draft Storage Techniques

The application may utilize a variety of techniques to save new drafts. For example, the application may save a separate file for each draft. In an embodiment, the application avoids asking the user to provide a name for the file in which the application saves the draft, instead determining a unique name for the draft based on one or more of the original document's name, a time at which the document was saved or opened, a running count of drafts for the object, a running count of drafts for the application (or a server at which the application stores drafts, a user name, and a random number.

As another example, instead of creating a separate file for each draft, the application may store drafts within the original document. Drafts may comprise a full copy of the original document. Drafts may instead include only data that indicates changes between the draft and one or more previous drafts, including the original document. In an embodiment, each draft is stored in the original document in such a manner so as to indicate a chronological order for the drafts.

The application may take steps to logically associate drafts with the original document. For example, the application may store metadata associating each draft with its original document. This metadata may be stored within the drafts, within the original document, or in any other location accessible to the application. In addition or instead of storing logical association metadata, the application may name or store draft files within a file system in such a manner as to make the logical association between drafts and their original document apparent. In embodiments where drafts are included in the original document, the drafts are logically associated with the original document by virtue of their inclusion in the original document.

In an embodiment, each draft includes metadata indicating a time at which the draft was saved and/or originally opened.

4.5. User-instigated Save Operations

In some embodiments, a user may instigate a save operation on a draft by means of, for instance, a save interface. The resulting save operation may, for instance, create a new draft, overwrite the original object, or create an entirely new document based on the draft. Some embodiments may not include an explicit save interface since saves are performed implicitly. However, it may be useful to provide such an interface in other embodiments to support explicit save operations. In response to user selection of the save interface, the application may, for example, promote a draft to be a separate document. Alternatively, the application may create a new draft of the document in response to the save operation. In one embodiment, in response to the explicit save operation, the application may also purge one or more previously saved drafts.

5.0. IMPLEMENTATION MECHANISM—HARDWARE OVERVIEW

According to one embodiment, the techniques described herein are implemented by one or more special-purpose computing devices. The special-purpose computing devices may be hard-wired to perform the techniques, or may include digital electronic devices such as one or more application-specific integrated circuits (ASICs) or field programmable gate arrays (FPGAs) that are persistently programmed to perform the techniques, or may include one or more general purpose hardware processors programmed to perform the techniques pursuant to program instructions in firmware, memory, other storage, or a combination. Such special-purpose computing devices may also combine custom hard-wired logic, ASICs, or FPGAs with custom programming to accomplish the techniques. The special-purpose computing devices may be desktop computer systems, portable computer systems, handheld devices, networking devices or any other device that incorporates hard-wired and/or program logic to implement the techniques.

For example, FIG. 8 is a block diagram that illustrates a computer system 800 upon which an embodiment of the invention may be implemented. Computer system 800 includes a bus 802 or other communication mechanism for communicating information, and a hardware processor 804 coupled with bus 802 for processing information. Hardware processor 804 may be, for example, a general purpose microprocessor.

Computer system 800 also includes a main memory 806, such as a random access memory (RAM) or other dynamic storage device, coupled to bus 802 for storing information and instructions to be executed by processor 804. Main memory 806 also may be used for storing temporary variables or other intermediate information during execution of instructions to be executed by processor 804. Such instructions, when stored in storage media accessible to processor 804, render computer system 800 into a special-purpose machine that is customized to perform the operations specified in the instructions.

Computer system 800 further includes a read only memory (ROM) 808 or other static storage device coupled to bus 802 for storing static information and instructions for processor 804. A storage device 810, such as a magnetic disk or optical disk, is provided and coupled to bus 802 for storing information and instructions.

Computer system 800 may be coupled via bus 802 to a display 812, such as a cathode ray tube (CRT), for displaying information to a computer user. An input device 814, including alphanumeric and other keys, is coupled to bus 802 for communicating information and command selections to processor 804. Another type of user input device is cursor control 816, such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processor 804 and for controlling cursor movement on display 812. This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane.

Computer system 800 may implement the techniques described herein using customized hard-wired logic, one or more ASICs or FPGAs, firmware and/or program logic which in combination with the computer system causes or programs computer system 800 to be a special-purpose machine. According to one embodiment, the techniques herein are performed by computer system 800 in response to processor 804 executing one or more sequences of one or more instructions contained in main memory 806. Such instructions may be read into main memory 806 from another storage medium, such as storage device 810. Execution of the sequences of instructions contained in main memory 806 causes processor 804 to perform the process steps described herein. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions.

The term “storage media” as used herein refers to any media that store data and/or instructions that cause a machine to operation in a specific fashion. Such storage media may comprise non-volatile media and/or volatile media. Non-volatile media includes, for example, optical or magnetic disks, such as storage device 810. Volatile media includes dynamic memory, such as main memory 806. Common forms of storage media include, for example, a floppy disk, a flexible disk, hard disk, solid state drive, magnetic tape, or any other magnetic data storage medium, a CD-ROM, any other optical data storage medium, any physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, NVRAM, any other memory chip or cartridge.

Storage media is distinct from but may be used in conjunction with transmission media. Transmission media participates in transferring information between storage media. For example, transmission media includes coaxial cables, copper wire and fiber optics, including the wires that comprise bus 802. Transmission media can also take the form of acoustic or light waves, such as those generated during radio-wave and infra-red data communications.

Various forms of media may be involved in carrying one or more sequences of one or more instructions to processor 804 for execution. For example, the instructions may initially be carried on a magnetic disk or solid state drive of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system 800 can receive the data on the telephone line and use an infra-red transmitter to convert the data to an infra-red signal. An infra-red detector can receive the data carried in the infra-red signal and appropriate circuitry can place the data on bus 802. Bus 802 carries the data to main memory 806, from which processor 804 retrieves and executes the instructions. The instructions received by main memory 806 may optionally be stored on storage device 810 either before or after execution by processor 804.

Computer system 800 also includes a communication interface 818 coupled to bus 802. Communication interface 818 provides a two-way data communication coupling to a network link 820 that is connected to a local network 822. For example, communication interface 818 may be an integrated services digital network (ISDN) card, cable modem, satellite modem, or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 818 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links may also be implemented. In any such implementation, communication interface 818 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.

Network link 820 typically provides data communication through one or more networks to other data devices. For example, network link 820 may provide a connection through local network 822 to a host computer 824 or to data equipment operated by an Internet Service Provider (ISP) 826. ISP 826 in turn provides data communication services through the world wide packet data communication network now commonly referred to as the “Internet” 828. Local network 822 and Internet 828 both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link 820 and through communication interface 818, which carry the digital data to and from computer system 800, are example forms of transmission media.

Computer system 800 can send messages and receive data, including program code, through the network(s), network link 820 and communication interface 818. In the Internet example, a server 830 might transmit a requested code for an application program through Internet 828, ISP 826, local network 822 and communication interface 818.

The received code may be executed by processor 804 as it is received, and/or stored in storage device 810, or other non-volatile storage for later execution.

6.0. EXTENSIONS AND ALTERNATIVES

In the foregoing specification, embodiments of the invention have been described with reference to numerous specific details that may vary from implementation to implementation. Thus, the sole and exclusive indicator of what is the invention, and is intended by the applicants to be the invention, is the set of claims that issue from this application, in the specific form in which such claims issue, including any subsequent correction. Any definitions expressly set forth herein for terms contained in such claims shall govern the meaning of such terms as used in the claims. Hence, no limitation, element, property, feature, advantage or attribute that is not expressly recited in a claim should limit the scope of such claim in any way. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.

7.0. CONCLUSION

Using the above-described automatic draft-saving techniques, an application may greatly reduce the amount of time and effort required of a user when switching between different documents and/or tasks. At the same time, the above-described techniques allow a user, with minimal effort, to maintain and access a record of changes to a document over time.

Moreover, in providing a collaborative document listing interface that implements the above described techniques for a server pushing updated objects, an application enhances collaboration between users by simplifying the process of a user locating and opening documents created and edited by others. Furthermore, by automatically updating the document listing in the collaborative document listing interface upon additions, deletions, and changes at a server, an application reduces transaction times associated in the document sharing process.

Claims

1. A method comprising: an application automatically creating multiple drafts of an object reflecting changes to data inside of the object, wherein each draft of the multiple drafts is a different version of the object;receiving a first command that causes the application to close the object;the application automatically creating a first draft of the multiple drafts, without deleting or overwriting any other draft of the multiple drafts, and without deleting or overwriting the object, in response to a change in the object and the first command;receiving a second command that causes the application to open the object;receiving a third command that causes generating output for the object based on the data inside of the object, wherein the third command is an input requesting to generate the output for the object based on the data inside of the object, and wherein the output is a screenshot of the object and a link to the object, and wherein the screenshot of the object and the link to the object are placed in a buffer that is shared with a plurality of applications executing at a computing device;the application automatically creating a second draft of the multiple drafts, without deleting or overwriting any other draft of the multiple drafts, and without deleting or overwriting the object, in response to a change in the object and the third command;the application causing each of the multiple drafts to be stored concurrently, in association with the object;the application presenting a list of the multiple drafts;the application receiving a selection of a particular draft from the list of the multiple drafts;in response to receiving the selection of the particular draft, the application opening the particular draft;wherein the application creates at least one of the multiple drafts in response to another command that causes the application to close the object;wherein the method is performed by one or more computing devices.

2. The method of claim 1, further comprising: receiving a command to open the object;in response to the command, opening a most recently created draft of said multiple drafts.

3. The method of claim 1, wherein the list of the multiple drafts includes, for each draft of the multiple drafts, data indicating a time at which each draft of the multiple drafts was saved.

4. The method of claim 1, wherein the application automatically creates each draft, without user intervention.

5. The method of claim 1, wherein each of the multiple drafts is stored within the object.

6. The method of claim 1, wherein each of the multiple drafts is stored external to the object and includes an identifier for the object.

7. The method of claim 1, wherein the first command that causes the application to close the object is one of an instruction to close the object, an instruction to open another object, or an instruction to terminate the application.

8. The method of claim 1, wherein generating the output comprises generating, in association with an image derived from the data inside of the object, a link to the second draft of the object.

9. The method of claim 1, wherein generating the output comprises generating a link to the second draft of the object, wherein the second draft is a write-protected reference draft of the object.

10. The method of claim 1, wherein each draft of the multiple drafts comprises session-identifying information associating each draft of the multiple drafts with a specific application session in which each draft of the multiple drafts was created.

11. The method of claim 10, wherein the application presenting the list of the multiple drafts comprises presenting, for each draft of the multiple drafts, the session-identifying information associated with each draft of the multiple drafts.

12. A method comprising: a first device presenting an interface comprising a list of drafts of an object stored at a location on a server, the interface configured to allow access to each draft in the list of drafts, wherein each draft in the list of drafts is a different version of the object;concurrent to the first device presenting the interface, a second device creating a new draft of the object, without deleting or overwriting any other draft, and without deleting or overwriting the object, and storing the new draft in association with the object at the location on the server;wherein the second device automatically creating a new draft comprises the second device automatically saving edits to the object as the new draft in response to a change in the object and input requesting to generate output for the object based on data inside of the object, wherein the output is a screenshot of the object and a link to the object, and wherein the screenshot of the object and the link to the object are placed in a buffer that is shared with a plurality of applications executing at a computing device;while presenting the interface, without user intervention, and further without polling the server, the first device receiving from the server data indicating the availability of the new draft at the server;in response to the data, the first device updating the list of drafts of the object to include the new draft;wherein the application creates at least one of the drafts in response to another command that causes the application to close the object;wherein the method is performed by one or more computing devices.

13. The method of claim 12, wherein the updated list of drafts is part of a hierarchy of objects, the hierarchy indicating that each draft in the list of drafts is associated with the existing object.

14. The method of claim 12, further comprising: the second device presenting a second interface comprising the updated list of drafts;concurrent to the second device presenting the second interface, the first device creating a second new draft of the object and storing the second new draft in association with the object at the location on the server;while presenting the interface, without user intervention, and further without polling the server, the second device receiving from the server second data indicating the availability of the second new draft at the server;in response to the second data, the second device updating the list of drafts of the object to include the second new draft.

15. The method of claim 12, wherein the new draft is a reference draft associated with the output.

16. The method of claim 12, wherein each draft in the list of drafts comprises session-specifying information associating each draft in the list of drafts with a specific application session in which each draft in the list of drafts was created.

17. The method of claim 16, wherein the first device presenting an interface comprising a list of drafts of an object stored at a location on a server comprises presenting, for each draft of the list of drafts, the session-identifying information associated with each draft in the list of drafts.

18. One or more non-transitory media storing instructions which, when executed by one or more processors, cause: an application automatically creating multiple drafts of an object reflecting changes to data inside of the object, wherein each draft of the multiple drafts is a different version of the object;receiving a first command that causes the application to close the object;the application automatically creating a first draft of the multiple drafts, without deleting or overwriting any other draft of the multiple drafts, and without deleting or overwriting the object, in response to a change in the object and the first command;receiving a second command that causes the application to open the object;receiving a third command that causes generating output for the object based on the data inside of the object, wherein the third command is an input requesting to generate the output for the object based on the data inside of the object, and wherein the output is a screenshot of the object and a link to the object, and wherein the screenshot of the object and the link to the object are placed in a buffer that is shared with a plurality of applications executing at a computing device;the application automatically creating a second draft of the multiple drafts, without deleting or overwriting any other draft of the multiple drafts, and without deleting or overwriting the object, in response to a change in the object and the third command;the application causing each of the multiple drafts to be stored concurrently, in association with the object;the application presenting a list of the multiple drafts;the application receiving a selection of a particular draft from the list of the multiple drafts;in response to receiving the selection of the particular draft, the application opening the particular draft;wherein the application creates at least one of the multiple drafts in response to another command that causes the application to close the object.

19. The one or more non-transitory media of claim 18, wherein the instructions, when executed by the one or more processors, further cause: receiving a command to open the object;in response to the command, opening a most recently created draft of said multiple drafts.

20. The one or more non-transitory media of claim 18, wherein the list of the multiple drafts includes, for each draft of the multiple drafts, data indicating a time at which each draft of the multiple drafts was saved.

21. The one or more non-transitory media of claim 18, wherein the application automatically creates each draft, without user intervention.

22. The one or more non-transitory media of claim 18, wherein each of the multiple drafts is stored within the object.

23. The one or more non-transitory media of claim 18, wherein each of the multiple drafts is stored external to the object and includes an identifier for the object.

24. The one or more non-transitory media of claim 18, wherein the first command that causes the application to close the object is one of an instruction to close the object, an instruction to open another object, or an instruction to terminate the application.

25. The one or more non-transitory media of claim 18, wherein generating the output comprises generating, in association with an image derived from the data inside of the object, a link to the second draft of the object.

26. The one or more non-transitory media of claim 18, wherein generating the output comprises generating a link to the second draft of the object, wherein the second draft is a write-protected reference draft of the object.

27. One or more non-transitory media storing instructions which, when executed by one or more processors, cause: a first device presenting an interface comprising a list of drafts of an object stored at a location on a server, the interface configured to allow access to each draft in the list of drafts, wherein each draft in the list of drafts is a different version of the object;concurrent to the first device presenting the interface, a second device creating a new draft of the object, without deleting or overwriting any other draft, and without deleting or overwriting the object, and storing the new draft in association with the object at the location on the server;wherein the second device automatically creating a new draft comprises the second device automatically saving edits to the object as the new draft in response to a change in the object and input requesting to generate output for the object based on data inside of the object, wherein the output is a screenshot of the object and a link to the object, and wherein the screenshot of the object and the link to the object are placed in a buffer that is shared with a plurality of applications executing at a computing device;while presenting the interface, without user intervention, and further without polling the server, the first device receiving from the server data indicating the availability of the new draft at the server;in response to the data, the first device updating the list of drafts of the object to include the new draft;wherein the application creates at least one of the drafts in response to another command that causes the application to close the object.

28. The one or more non-transitory media of claim 27, wherein the updated list of drafts is part of a hierarchy of objects, the hierarchy indicating that each draft in the list of drafts is associated with the existing object.

29. The one or more non-transitory media of claim 27, wherein the instructions, when executed by the one or more processors, further cause: the second device presenting a second interface comprising the updated list of drafts;concurrent to the second device presenting the second interface, the first device creating a second new draft of the object and storing the second new draft in association with the object at the location on the server;while presenting the interface, without user intervention, and further without polling the server, the second device receiving from the server second data indicating the availability of the second new draft at the server;in response to the second data, the second device updating the list of drafts of the object to include the second new draft.

30. The one or more non-transitory media of claim 27, wherein the new draft is a reference draft associated with the output.