Configurable entity-based undo and redo behavior

Abstract

Techniques are disclosed for undo and redo operations in a computer user interface. The techniques allow a user to configure entities for undo and redo operations. The techniques also allow a user to roll back an individual entity to a previous state with one undo operation and subsequently roll back to other previous states. Other entities are not affected by the undo operation on that entity.

Description

[Technical Field]

[0001] Technical Field The present invention relates generally to computer user interfaces, and more particularly to undo and redo functionality in computer user interfaces. [Background technology]

[0002] background Computer user interfaces may include commands that allow users to undo and redo actions. The "undo" command allows a user to sequentially roll back actions performed through a series of previous states of an application, operating system, or other software having a computer user interface. The "redo" command works in the reverse order of the undo command, sequentially restoring previously rolled-back actions. For example, if a user wants to undo several previous actions performed in an application to correct a previous error, the user can execute the undo command to sequentially roll back the previous actions and return the application to its pre-error state. However, such actions may have undesirable side effects. That is, rolling back to an error often requires undoing error-free actions performed after the error. Thus, after using multiple undo commands to undo errors, restoring the application's initial state may require manually repeating the error-free actions. Manually repeating error-free actions in a computer user interface is inefficient, time-consuming, error-prone, and frustrating for users. Summary of the Invention [Means for solving the problem]

[0003] The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Thus, unless otherwise indicated, it should not be assumed that any approach described in this section qualifies as prior art merely by virtue of its inclusion in this section.

[0004] Embodiments are illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings, in which: Note that references to "an" or "one" embodiment in this disclosure do not necessarily refer to the same embodiment, but rather to at least one. [Brief explanation of the drawings]

[0005] [Figure 1] FIG. 1 is a system block diagram illustrating an example environment for implementing systems and processes according to one or more embodiments. [Figure 2] FIG. 1 is a block diagram illustrating an example system according to one or more embodiments. [Figure 3A] FIG. 1 is a process flow block diagram illustrating an example of a process according to one or more embodiments. [Figure 3B] FIG. 1 is a process flow block diagram illustrating an example of a process according to one or more embodiments. [Figure 4A] 1 is a diagram illustrating the state of an entity in a user interface display according to one or more embodiments. [Figure 4B] 1 is a diagram illustrating the state of an entity in a user interface display according to one or more embodiments. [Figure 4C] 1 is a diagram illustrating the state of an entity in a user interface display according to one or more embodiments. [Figure 4D] 1 is a diagram illustrating the state of an entity in a user interface display according to one or more embodiments. [Figure 4E]1 is a diagram illustrating the state of an entity in a user interface display according to one or more embodiments. [Figure 4F] 1 is a diagram illustrating the state of an entity in a user interface display according to one or more embodiments. [Figure 4G] 1 is a diagram illustrating the state of an entity in a user interface display according to one or more embodiments. [Figure 4H] 1 is a diagram illustrating the state of an entity in a user interface display according to one or more embodiments. [Figure 5] 5 is a time flow diagram 500 illustrating entity state changes according to one or more embodiments. [Figure 6] 1 is an exemplary stack for recording the state of an entity, according to one or more embodiments. [Figure 7] FIG. 1 is a block diagram illustrating a computer system according to one or more embodiments. DETAILED DESCRIPTION OF THE INVENTION

[0006] Detailed Description In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding. One or more embodiments may be practiced without these specific details. Features described in one embodiment may be combined with features described in different embodiments. In some instances, well-known structures and devices are described with reference to block diagram form in order to avoid unnecessarily obscuring the present invention. 1. Overview 2. System Environment 3. System Architecture 4. Undo / redo processing 5. Hardware Overview 6. Other, Expansion 1. Overview The present disclosure is directed to a system, method, and non-transitory computer-readable storage medium for a computer user interface that includes undo and redo commands. Embodiments identify and track actions performed by a user on individual entities of a computer user interface to enable entity-specific undo and redo commands. An entity can be an individual component of a computer user interface whose state a user can change. An entity may include a single element or a group of elements. For example, some entities may be a single shape (e.g., a rectangle) in a drawing created by a graphic design application such as VISIO®, a single word in a document created by a word processing application such as WORD®, or a single file stored by a file management application such as SHAREPOINT®, all of which are products of Microsoft Corporation of Redmond, Washington. In another example, an entity may correspond to a database record. Furthermore, an entity may include multiple components, such as a layer in a drawing application containing multiple shapes, a sentence or paragraph in a word processing application containing multiple words, a folder in a file management application containing multiple files, or a table in a database application.

[0007] Embodiments disclosed herein track actions performed by an application on a per-entity basis and record the state of the entities to perform undo and redo operations. One or more embodiments predefine components of an application's computer user interface as entities. For example, embodiments may use a list of predefined entities. Additionally or alternatively, some embodiments allow a user to configure entities by defining a customized list. Furthermore, some embodiments configure entities by automatically applying smart criteria or machine learning models that classify components as entities.

[0008] According to the present disclosure, a user can instruct a computer user interface of an application to undo and redo actions performed on a selected entity. In response to the undo and redo commands, the application can identify state information of the selected entity in a corresponding log (e.g., an undo stack) and, based on the log, roll back the actions performed on the selected entity without undoing actions performed on other entities in the computer user interface. Doing so significantly improves the operation of the computer user interface by reducing computing resources used for undo and redo actions on non-selected objects and improving the efficiency and accuracy of the computer user interface.

[0009] 2. System Environment 1 illustrates a flow block diagram depicting an exemplary environment 100 for executing systems and processes according to aspects of the present disclosure. The environment 100 includes a computing system 105 including a display device 110 that displays a user interface 115 of an application 120. By way of example, the application 120 may be a drawing application that allows a user to control a cursor 125 to draw and manipulate (e.g., move, rotate, resize, color, etc.) shapes, text, drawings, photos, and other drawing objects, such as entities 131, 133, and 135. The application 120 may identify actions performed on individual entities 131, 133, and 135 and record the states of the entities 131, 133, and 135 that result from the actions.

[0010] The user interface 115 of the application 120 may also include undo and redo command options. In this example, the application 120 generates an on-demand context menu 140 in the user interface 115 with undo and redo commands selectable by the cursor 125. For example, the user interface 115 may display the context menu 140 in response to user input (e.g., a right-click mouse action) on the entity 133. Selecting the undo action in the context menu 140 may instruct the application 120 to roll back the previous action on the selected entity 133. For example, if the most recent action on the entity 133 was resizing a triangle object, the user may undo the previous action by triggering the context menu 140 and selecting “undo,” which causes the application 120 to roll back the most recent action recorded by the application 120 by restoring the entity 133 to its previous state before the resizing. Additionally, selecting the Redo command in the context menu 140 causes the application 120 to undo the most recently undone action by restoring the entity 133 to its original state before the Undo command.

[0011] Additionally, via user interface 115, a user may repeatedly instruct application 120 to undo previous actions performed on entities, such as entity 133. In response to the repeated undo commands, application 120 may sequentially roll back the state of entity 133 based on state information stored in entity 133's log, without rolling back previous actions performed on entities 131 and 135. For example, previous actions performed on entity 133 may be, in reverse order, "resize," "rotate," and "flip." Further, previous actions performed on entity 131 may be, in reverse order, "rotate" and "add." Further, a previous action performed on entity 131 may be "add." For example, the actions for all entities in reverse sequence may be: entity 133: "resize," entity 135: "rotate," entity 135: "add," entity 133: "rotate," entity 133: "flip," and entity 131: "add." If context menu 140 is repeatedly used to instruct the application to undo previous actions performed on entity 133, the application will sequentially roll back entity 133 to the state before the "resize" action, then the state before the "rotate" action, then the state before the "flip" action. However, because the undo command only targets entity 133, application 120 will not roll back any of the previous actions performed on entities 131 and 135.

[0012] 3. System Architecture 2 illustrates a computing system 105 according to one or more embodiments. The computing system 105 can be the same as or similar to those described above. An embodiment of the computing system 105 can be implemented in one or more digital devices. A digital device can be any hardware device that includes a processor. An embodiment of a digital device may refer to a physical device that runs an application or a virtual machine. Examples of digital devices include a personal computer, a tablet, a laptop, a desktop, a server, a web server, a network policy server, a proxy server, a general-purpose machine, a function-specific hardware device, a mainframe, a television, a content receiver, a set-top box, a printer, a mobile phone, a smartphone, a personal digital assistant ("PDA"), and / or a client device.

[0013] Computing system 105 may include display device 110, input / output device 203, and storage device 205. Display device 110 may be the same as or similar to those described above. Embodiments of display device 110 may be, for example, a liquid crystal display (LCD) display, an organic light-emitting diode display (OLED), or other suitable display device. IO device 203 may include any device that allows an individual to interact with computing device 430 (e.g., a user interface) and / or any device that allows computing system 105 to communicate with one or more other computing or peripheral devices using any type of communications link. IO device 203 may be, for example, a touchscreen display, a pointer device (e.g., a computer mouse), a keyboard, etc.

[0014] The storage device 205 may be one or more hard disk drives, flash drives, compact disc read-only memories (ROMs), digital versatile disc (DVD) optical storage technologies, or other suitable fixed, non-transitory computer-readable storage devices. The storage device 205 may store computer-readable program instructions, such as applications, software modules, and other program code, as well as information, such as libraries and data, for operating the computing system 105. Additionally, the storage device 205 may store an entity library 213 and an undo / redo log 215. The entity library 213 may store information identifying entities and entity types for tracking and recording one or more applications (e.g., application 120) executed by the computing system 105. Some embodiments of the entity library 213 identify components or types of components defined as entities. For example, an application may include predefined entities in the entity library 213. Additionally or alternatively, a user may customize the entity library 213. One or more other embodiments use smart criteria (e.g., machine learning models) to determine entities on the fly and store the entities in the entity library 213. As described in more detail below, the undo / redo log 215 may store, for each entity, a chronologically ordered state of the entity. It is understood that some or all of the information used by the computing system 105 may be stored remotely, such as in the data source 101 or some other data repository or storage system.

[0015] Additionally, computing system 105 may execute computer program instructions for application 120, which may be the same as or similar to those described above. Application 120 may be any type of software having a computer user interface, such as a graphical user interface (e.g., user interface 115). For example, application 120 may be a word processor application, a code editor application, a database application, a spreadsheet application, a presentation application, a drawing application, an email application, a text messaging application, an internet browser application, a calculator application, a file management application, or any other suitable type of computer software application or module that allows a user to modify components of the user interface.

[0016] One or more embodiments of application 120 may include an undo / redo module 225, which may include program instructions for tracking operations (e.g., formatting, resizing, rotating, adding, etc.), states, and commands (e.g., undo and redo) performed on entities (e.g., entities 131, 133, 135) created by the application. The undo / redo module 225 may also instantiate and maintain as a log an undo stack in the undo / redo log 215 for each entity tracked. While the undo / redo module 225 is shown as being included in application 120, it will be understood that the undo / redo module 225 may be a stand-alone module or may be incorporated into another application. For example, the undo / redo module 225 may be a service of the operating system of the computing system 105.

[0017] In one or more embodiments, computing system 105 may include more or fewer components than those shown in Figure 2. The components shown in Figure 2 may be local or remote from one another. The components shown in Figure 2 may be implemented in software and / or hardware. Each component may be distributed across multiple applications and / or machines. Multiple components may be integrated into one application and / or machine. Operations described with respect to one component may instead be performed by another component.

[0018] According to an embodiment, the techniques described herein are performed by one or more general-purpose or special-purpose computing devices. The general-purpose computing device can be, for example, a server, a personal computer, a smartphone, a tablet computer, a laptop computer, etc. The special-purpose computing device may be hardwired to execute these techniques, or may include digital electronic devices such as one or more application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or network processing units (NPUs) permanently programmed to execute these techniques, or may include one or more general-purpose hardware processors programmed to execute these techniques according to program instructions in firmware, memory, other storage, or a combination thereof. Such special-purpose computing devices may also achieve these techniques by combining custom hardwired logic, ASICs, FPGAs, or NPUs with custom programming. The special-purpose computing device may be a desktop computer system, a portable computer system, a handheld device, a networking device, or any other device incorporating hardwired and / or program logic to implement these techniques.

[0019] Any combination of the features and functions described herein may be used in accordance with one or more embodiments. In the foregoing specification, embodiments have been described with reference to numerous specific details that may vary from implementation to implementation. Accordingly, the specification and drawings should be interpreted in an illustrative, rather than a limiting, sense. The sole and exclusive indication of the scope of the invention, and what the applicant intends to be the scope of the invention, is the literal equivalents of the series of claims issuing from this application, the specific form in which such claims are issued, including any subsequent amendments.

[0020] 4.Undo processing The flow diagrams in FIGS. 3A and 3B illustrate the functions and operations of systems, devices, processes, and computer program products according to various embodiments of the present disclosure. Each block in FIGS. 3A and 3B may represent a module, segment, or portion of program instructions, including one or more computer-executable instructions for implementing the illustrated functions and operations. In some implementations, the functions and / or operations depicted in a particular block of the flow diagrams may occur in a different order than that depicted in FIGS. 3A and 3B. For example, two blocks depicted in succession may be executed substantially simultaneously, or the blocks may sometimes be executed in the reverse order, depending on the functionality involved. Furthermore, in some implementations, the blocks of the flow diagrams may be rearranged in a different order. Furthermore, in some implementations, the flow diagrams may include fewer or additional blocks. It should also be noted that each block of the flow diagrams, and combinations of blocks in the flow diagrams, may be executed by a dedicated hardware-based system that performs the specified functions or operations, or by a combination of dedicated hardware and computer instructions.

[0021] 3A and 3B show a flow block diagram illustrating an example process 300 for performing an undo operation according to one or more embodiments. In block 301, process 300 defines entities to be detected by an application. As previously described, an entity can be any individual component of a computer user interface whose state a user can change. An entity (e.g., entities 131, 133, and 135) can include a single component of a user interface or a group of components (e.g., a drawing layer including entities 131, 133, and 135). An application (e.g., application 120) can be any computer software, module, or set of program instructions that generates a computer user interface (e.g., user interface 115) that allows a user to change components of the computer user interface.

[0022] Defining entities to be detected may include configuring which computer user interface components of an application have their actions tracked and their states recorded. One or more embodiments store predefined components as entities in a library (e.g., entity library 213). Furthermore, one or more embodiments allow a user to define components as entities. For example, an application may include a user interface menu that lists selectable components of the computer user interface to define as entities to be tracked and recorded (e.g., shapes, groups, layers, and slides in a drawing application). The application may also receive and decode regular expressions or context-free grammars to determine rule-based entity definitions based on user input. Additionally or alternatively, the computer user interface may include an on-demand context menu 140 that includes options for a user to define a component or group of components as an entity. For example, a user may identify a group of objects in a drawing application as a single entity. Furthermore, one or more embodiments automatically identify components as entities. For example, an application may include a machine learning model trained using data describing previous selections of components and previous undo / redo commands to infer which components should be defined as entities.

[0023] At block 303, process 300 detects the user's performance of an action in the application. For example, the application may monitor user input to a user interface via an IO device (e.g., IO device 203) that triggers the action. In one or more embodiments, the process detects the performance of all actions in the application, including, for example, file management actions, menu selections, toolbar commands, information entry, editing actions, etc. At block 305, the process determines whether the candidate action detected at block 303 was performed on one or more entities of the computer user interface. This determination may be made based on detecting the performance of the action at block 303 and determining that the detected action involved any of the entities configured at block 301. For example, the application may detect user input resizing an object (e.g., entity 131) in the user interface (e.g., user interface 115) and determine whether the object is defined as an entity (e.g., in entity library 213). If the process determines that the action was not performed on the entity (e.g., block 305 returns "no"), then in block 307, process 300 refrains from recording the detected action and returns to block 303.

[0024] On the other hand, if the action detected in block 303 was performed on one or more entities (e.g., block 305 returns "yes"), then in block 309, process 300 records the action detected in block 303 corresponding to the entities identified in block 305 on which the action was performed. Recording the action may include identifying the individual entities on which the action was performed in block 311. For example, based on the coordinates of a cursor (e.g., cursor 125) controlled by an IO device (e.g., a computer mouse or touchscreen), an application may determine that the action was performed on a particular entity (e.g., entity 131). Recording the action may also include storing the first action performed on the first entity in one or more logs (e.g., undo / redo log 215) in block 312. As described in more detail below with respect to FIG. 6, the log may include an undo stack that records all actions performed by the computer user interface (e.g., FIG. 6), and the log may include an undo stack (e.g., undo stack 601) that records all actions performed by the computer user interface and one or more undo stacks (e.g., undo stacks 603, 605, and 607) that record actions performed on a particular entity. Recording an action may also include storing a subsequent action performed on a second entity in block 313 in the entity log. One or more embodiments store the first action of block 312 and the subsequent action of block 313 in the same log. The log may include a single stack that includes the first action of block 312 and the subsequent action of block 313, or the log may include different stacks that separately store the first action of block 312 and the subsequent action of block 313. Additionally or alternatively, one or more embodiments store the first action of block 312 and the subsequent action of block 313 in different logs.This recording may include storing state change metadata in an undo stack for all entities displayed in the user interface. Additionally, for individual entities in the user interface, this recording may include storing state information corresponding to the individual entity in the undo stack. It will be understood that some embodiments store state information for entities in the same log. Other embodiments store state information for entities in different logs corresponding to the individual entities.

[0025] At block 315, process 300 receives, by the application, an instruction to perform an undo operation with respect to the first entity identified at block 311. Receiving the instruction to perform the undo operation may include receiving input via a user interface executed with respect to the first entity. For example, the computer user interface of the application may receive a command to perform the undo operation with respect to the first entity via a context menu (e.g., on-demand context menu 140) or some other command input (e.g., a keyboard shortcut such as OPTION-CTRL-Z).

[0026] Continuing to FIG. 3B via off-page connector “A,” in block 323, process 300 identifies an operation from the operation log to perform the undo operation based on (a) the instruction to perform the undo operation received in block 315 and (b) the operation performed on the first entity stored in block 312 and the subsequent operation performed on the second entity stored in block 313 were performed by the application on different entities. Performing the undo operation may include searching for the operation most recently performed on the first entity in a set of log entries that includes operations performed on the first entity and the second entity in chronological order. For example, the application may determine that the undo operation is for the operation stored in the undo stack of the first entity in block 312 but not for the operation stored in the undo stack of the second entity in block 313. In block 325, process 300 performs a first undo operation to undo the first operation performed on the first entity without undoing the subsequent operation performed on the second entity.

[0027] In block 329, process 300 may determine whether an instruction to perform another undo operation by the application with respect to the first entity identified in block 311 has been received. If not (e.g., block 333 is "no"), process 300 ends. If received (e.g., block 333 is "yes"), process 300 may iteratively repeat blocks 323 and 325 to perform another undo operation with respect to the first entity.

[0028] 4. Exemplary Embodiments For clarity, detailed examples are described below. The components and / or operations described below should be understood as one particular example that may not be applicable to an embodiment. Therefore, the components and / or operations described below should not be construed as limiting the scope of any of the claims.

[0029] 4A, 4B, 4C, and 4D illustrate changes in the state of entities in an application display screen presented by user interface 115 due to actions of an application (e.g., application 120), which can be recorded for undo / redo actions as described herein. The illustrated application can be, for example, a drawing application. FIG. 4A illustrates a first entity E1 (e.g., entity 131) displayed by user interface 115 in a first state of entity S1 at a first time (e.g., T0-7) before the current time (e.g., T0). State S1 of entity E1 can be the initial state of entity E1 after the object is first drawn, or state S1 can be some subsequent state of entity E1 following a previous action by the user. FIG. 4B illustrates a first entity E1 (e.g., entity 131) in a first state of entity S1 at a second time (e.g., T0-6) before the current time. Additionally, FIG. 4B illustrates a second entity E2 (e.g., entity 135) at a second time. State S1 of entity E2 can be the initial state of entity E2 after the object is first drawn, or state S1 of entity E2 can be some subsequent state of entity E2 following a previous action by the user. FIG. 4C illustrates that at a third time (e.g., T0-5) prior to the current time (e.g., T=0), the first entity E1 is in entity S2's second state and the second entity E2 (e.g., entity 135) is in entity S2's first state. State S2 of entity E1 can be the state of entity E1 after state S1 changes. For example, state S2 of entity E1 can be the result of a "stretch" action that changes E1's proportions. FIG. 4D shows that at a fourth time (e.g., T0=-4) before the current time (e.g., T=0), the first entity E1 is in the third state of entity S2 and the second entity E2 is in the second state of entity S2.State S2 of entity E2 may be the state of entity E2 after a change from state S1. For example, this change may be a "resize" action that changes the size of entity E2 while maintaining the relative proportions of entity E2. Figure 4E shows that at a fifth time (e.g., T0-3) before the current time (e.g., T=0), a first entity E1 is in the third state of entity S3, a second entity E2 is in the first state of entity S1, and a third entity E3 (e.g., entity 133) is in the first state of entity S1. State S1 of entity E3 may be the initial state of entity E1 after the object is first drawn, or state S1 may be some subsequent state of entity E1 following a previous action by the user. FIG. 4F shows that at a sixth time (e.g., T0-2) before the current time (e.g., T=0), a first entity E1 is in the second state of entity S2, a second entity E2 is in the third state of entity S3, and a third entity E3 is in the first state of entity S1. The state S3 of entity E2 may be the state of entity E2 after a change in state S2. For example, this change may be a "stretch" operation that changes the relative sizes and proportions of entity E2. FIG. 4G shows that at a seventh time (e.g., T0-1) before the current time (e.g., T=0), a first entity E1 is in the third entity S3, a second entity E2 is in the third state of entity S3, and a third entity E3 is in the first state of entity S1. The state S3 of entity E1 may be the state of entity E1 after a change in state S2. For example, this change may be a "stretch" operation that changes the relative sizes and proportions of E1. Figure 4H shows that the first entity E1 is in the fourth state of entity S4, the second entity E2 has been rolled back to state S1 of entity E2 at T0-5 as shown in Figure 4C, and the third entity E3 is in the first state S1 of entity E3 at the current time (e.g., T=0).Rolling back the state of E2 from state S3 to state S1 can be accomplished through an undo command by a user selecting E2 and executing two undo commands. According to aspects of the present disclosure, the undo commands only affected the selected entity E2 and not the unselected entities E1 and E3. Undoing one or more actions on entity E2 to roll back states S3 and S2 did not affect the current state S3 of entity E1 or the current state S1 of entity E3.

[0030] The exemplary entities shown in Figures 4A-4H are shown as shapes in a drawing application for illustrative purposes. The entities may be other types of user interface components in other types of applications. For example, an entity may be a word, sentence, paragraph, or section of a text document. For example, an entity may be a term, code block, control block, class, method, or code file in a code editor application. For example, an entity may be a file, folder, or collection in a file management application. For example, an entity may be a record, column, table, or database in a database management application. Thus, it should be understood that embodiments consistent with the present disclosure encompass other types of applications in which a computer user interface includes entities having a state that can be changed by a user.

[0031] 5 illustrates a time flow diagram 500 showing state changes of entities presented using the exemplary displays of FIGS. 4A-4H. Time flow diagram 500 includes several time slots TO-7, TO-6, TO-5, TO-4, TO-3, TO-3, TO-1, and TO, which represent time periods during which actions were taken on entities E1, E2, and E3 within a computer user interface (e.g., user interface 115) of an application (e.g., application 120). Additionally, time flow diagram 500 includes bands 503, 505, and 507 that illustrate states S1, S2, and S3 of entities E1, E2, and E3, respectively, in time slots TO-7, TO-6, TO-5, TO-4, TO-3, TO-3, TO-1, and TO, resulting from actions taken by a user on entities E1, E2, and E3 via the computer user interface.

[0032] As described above with respect to Figures 4A-4H, band 503 indicates the states of entity E1. At T0-7, entity E1 is in state S1 (see, e.g., Figure 4A). At T0-5, entity E1 is in state S2 as a result of the user performing a "stretch" operation (see, e.g., Figure 4C). At T0-1, entity E1 is in state S3 as a result of the user performing a second "stretch" operation (see, e.g., Figure 4G). Band 505 indicates the states of entity E2. At T0-6, entity E2 is in state S1 (see, e.g., Figure 4B). At T0-4, entity E2 is in state S2 as a result of the user performing a "resize" operation (see, e.g., Figure 4D). At T0-2, entity E2 is in state S3 as a result of the user performing a "stretch" operation (see, e.g., Figure 4F). At T0, entity E2 is in state S1, which is the result of a user selecting entity E2 and executing two successive undo commands to instruct a computer user interface to roll back entity E2 from state S3 to S2 and from state S2 to state S1 (see, for example, FIG. 4H). Band 507 shows the states of entity E2. At T0-6, entity E3 is in state S1. According to aspects of the present disclosure, at current time T0, entity E2's current state S1 was rolled back from state S3 at T0-2 and from state S2 at T0-4 as a result of the undo commands executed on entity E2 at T0. Meanwhile, the undo commands did not change the states of entities E1 and E3. Because the user did not select entities E1 and E3 for execution of the undo command at T0, entity E1 retains state S3 at T0-1, and entity E3 retains state S1 at T0-3.

[0033] In one or more embodiments, operations on entities E1, E2, and E3 are recorded in an undo stack, as described below with respect to FIG. 6. For example, an application may receive a "stretch" command via a computer user interface that causes the application to perform a first "stretch" operation on entity E2 at T0-2 before recording the stretch operation. The application may also receive another "stretch" command via the computer user interface that causes the application to perform a second "stretch" operation on entity E1 at T0-1 before recording the second stretch operation. Notably, the first "stretch" command and the second "stretch" command may correspond to the same command of the application, with different parameter values ​​corresponding to entities E1 and E2, respectively.

[0034] FIG. 6 illustrates exemplary undo stacks 601, 603, 605, and 607 maintained by an application in a log (e.g., undo / redo log 215) that records state information (e.g., S1, S2, S3) for entities (e.g., E1, E2, E3) in the exemplary display screens of FIGS. 4A-4H. Undo stacks 601, 603, 605, and 607 may be data structures that store state information in chronologically ordered blocks, with the most recent information stored in the bottom occupied block and the oldest information stored in the top block. For illustrative purposes, stacks 601, 603, 605, and 607 are shown in FIG. 6 as including eight blocks, such as blocks 611, 615, and 619, although it will be understood that any number of blocks may be used. For example, each undo stack 601, 603, 605, and 607 may include 64 or more blocks. It will also be appreciated that the order of the blocks can be reversed so that the most recent information is stored in the top block and the oldest information is stored in the bottom occupied block.

[0035] The state information stored in the undo stacks 601, 603, 605, and 607 may include the current state of the entities and the actions of the user interface (e.g., the user interface 115) that resulted in the current state. Additionally, the state information may include parameters for the application to display each entity E1, E2, E3 in a previous and / or current state. The parameters for displaying entities E1, E2, E3 may include data the application uses to draw or redraw entities E1, E2, E3 in the user interface. For example, for an object in a drawing application, the parameters may include identity, size, position, text, shadow, reflection, 3D formatting, rotation, fill, line parameters, etc. The information describing the entity may also include values ​​describing changes in parameters from a previous state to a current state. For example, a change in parameters for a resize operation may include a change in the vertical size and a change in the horizontal size of the entity.

[0036] The undo stack 601 may be a data structure that an application (e.g., application 120 executing undo / redo module 225) uses to record state information for all entities within the application's computer user interface. Referring to the example shown in Figure 5, the undo stack 601 may record, in chronological order, states S1, S2, and S3 of entities E1, E2, and E3 within bands 503, 505, and 505. For example, in the chronological order shown in Figure 5, the undo stack 601 may record state 1 of E1, state 1 of E2, state 2 of E2, state 1 of E3, state 3 of E2, and state 3 of E1.

[0037] Further, according to aspects of the present disclosure, entity undo stacks 603, 605, and 607 can be data structures used by an application to store state information for individual entities E1, E2, and E3, respectively. Referring to the example shown in FIG. 5 , entity undo stack 603 can record state information for entity E1 in band 503, entity undo stack 603 can record state information for entity E2 in band 505, and entity undo stack 607 can record state information for entity E3 in band 507. Using entity undo stacks 603, 605, and 607, an application can selectively perform undo operations on individual entities E1, E2, and E3. For example, as shown in FIGS. 4H and 5 , in response to selecting entity E2 via user interface 115, the application can roll back the state of entity E2 from state S3 in block 611 to state S1 in block 619 based on stack 605, regardless of the state information stored in undo stacks 601, 603, and 607. In response to an undo operation performed on entity E2 in the user interface, rolling back the state of entity E2 from state S3 to state S1 may include identifying the current state (e.g., E2, S3) of E2 block 611 of stack 603, returning entity E2 to state S2 based on the state information stored in block 615, and further returning entity E2 to state S1 based on the state information stored in block, entity E2, state S2.

[0038] 5. Hardware Overview According to one embodiment, the techniques described herein are performed by one or more special-purpose computing devices. The special-purpose computing devices may be hardwired to perform the techniques, or may include digital electronic devices such as one or more application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or network processing units (NPUs) permanently programmed to perform the techniques, or may include one or more general-purpose hardware processors programmed to perform the techniques according to program instructions in firmware, memory, other storage, or a combination thereof. Such special-purpose computing devices may also achieve the techniques by combining custom hardwired logic, ASICs, FPGAs, or NPUs with custom programming. The special-purpose computing devices may be desktop computer systems, portable computer systems, handheld devices, networking devices, or any other devices incorporating hardwired and / or program logic to perform the techniques.

[0039] 7 is a block diagram illustrating a computer system 700 upon which an embodiment of the present invention may be implemented. Computer system 700 includes a bus 702 or other communication mechanism for communicating information, and a hardware processor 704 coupled to bus 702 for processing information. Hardware processor 704 may be, for example, a general-purpose microprocessor.

[0040] Computer system 700 also includes a main memory 706, such as a random access memory (RAM) or other dynamic storage device, coupled to bus 702 for storing information and instructions executed by processor 704. Main memory 706 may also be used to store temporary variables or other intermediate information during execution of instructions to be executed by processor 704. Such instructions, when stored on a non-transitory storage medium accessible to processor 704, render computer system 700 a special-purpose machine customized to perform the operations specified in the instructions.

[0041] Computer system 700 further includes a read-only memory (ROM) 708 or other static storage device coupled to bus 702 for storing static information and instructions for processor 704. A storage device 710, such as a magnetic disk or optical disk, is provided and coupled to bus 702 for storing information and instructions.

[0042] Computer system 700 may be coupled via bus 702 to a display 712, such as a cathode ray tube (CRT), for displaying information to a computer user. An input device 714, including alphanumeric and other keys, is coupled to bus 702 for communicating information and command selections to processor 704. Another type of user input device is a cursor control device 716, such as a mouse, trackball, or cursor direction keys, for communicating directional information and command selections to processor 704 and for controlling cursor movement on display 712. 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), allowing the device to specify a position in a plane.

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

[0044] The term "storage medium," as used herein, refers to any non-transitory medium that stores data and / or instructions that cause a machine to operate in a specific manner. Such storage media may include non-volatile media and / or volatile media. Non-volatile media include, for example, optical or magnetic disks, such as storage device 710. Volatile media include dynamic memory, such as main memory 706. Common forms of storage media include, for example, floppy disks, flexible disks, hard disks, solid-state drives, magnetic tape, or any other magnetic data storage medium, CD-ROMs, any other optical data storage medium, any physical medium with a pattern of holes, RAM, PROMs, and EPROMs, FLASH-EPROMs, NVRAMs, any other memory chips or cartridges, content addressable memories (CAMs), and ternary content addressable memories (TCAMs).

[0045] Storage media are distinct from but may be used in conjunction with transmission media. Transmission media involves transferring information to and from storage media. For example, transmission media include coaxial cables, copper wire and fiber optics, including the wires that comprise bus 702. Transmission media can also take the form of acoustic or light waves, such as those generated during radio wave and infrared data communications.

[0046] Various forms of media may be involved in carrying one or more sequences of one or more instructions to processor 704 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 may load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system 700 can receive the data on the telephone line and use an infrared transmitter to convert the data to an infrared signal. An infrared detector can receive the data carried in the infrared signal and appropriate circuitry can place the data on bus 702. Bus 702 carries the data to main memory 706, from which processor 704 retrieves and executes the instructions. The instructions received by main memory 706 may optionally be stored on storage device 710 either before or after execution by processor 704.

[0047] Computer system 700 also includes a communication interface 718 coupled to bus 702. The communication interface 718 provides a two-way data communication coupling to a network link 720 that is connected to a local network 722. For example, communication interface 718 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 718 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN. A wireless link may also be implemented. In any such implementation, communication interface 718 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.

[0048] Network link 720 typically provides data communication through one or more networks to other data devices. For example, network link 720 may provide a connection through local network 722 to a host computer 724 or to data equipment operated by an Internet Service Provider (ISP) 726. ISP 726 provides data communication services through the worldwide packet data communication network now commonly referred to as the “Internet” 728. Local network 722 and Internet 728 both use electrical, electromagnetic, or optical signals that carry digital data streams. The signals through the various networks, the signals on network link 720, and the signals through communication interface 718, which carry the digital data to and from computer system 700, are exemplary forms of transmission media.

[0049] Computer system 700 can send messages and receive data, including program code, through the network(s), network link 720 and communication interface 718. In the Internet example, a server 730 might transmit a requested code for an application program through Internet 728, ISP 726, local network 722 and communication interface 718.

[0050] The received code may be executed by processor 704 as it is received, and / or stored in storage device 710, or other non-volatile storage for later execution.

[0051] 6. Other, Expansion Embodiments are directed to systems comprising one or more devices that include a hardware processor and are configured to perform any of the operations described herein and / or recited in any of the claims below.

[0052] In one embodiment, a non-transitory computer-readable storage medium includes instructions that, when executed by one or more hardware processors, cause any of the operations described and / or claimed herein to be performed.

[0053] Any combination of the features and functions described herein may be used in accordance with one or more embodiments. In the foregoing specification, embodiments have been described with reference to numerous specific details that may vary from implementation to implementation. Accordingly, the specification and drawings should be interpreted in an illustrative, rather than a limiting, sense. The sole and exclusive indication of the scope of the invention, and what the applicant intends to be the scope of the invention, is the literal equivalents of the series of claims issuing from this application, the specific form in which such claims are issued, including any subsequent amendments.

Claims

1. A non-transitory computer-readable storage medium containing instructions that, when executed by one or more hardware processors, cause a number of operations to occur, the number of operations including: The application includes recording a plurality of actions performed by the application, the plurality of actions being performed on at least one of a plurality of entities, the plurality of actions comprising: a first operation performed by the application on a first entity of a plurality of entities; a second operation performed by the application on a second entity of the plurality of entities, the second operation being performed after the first operation, the plurality of operations further comprising: receiving, by the application, a first instruction that (a) specifies the first entity and (b) includes a command to perform a first undo operation with respect to the first entity; (a) the first instruction specifies the first entity; and (b) includes the command to perform the first undo operation with respect to the first entity. identifying the first action for performing the first undo action stored in the action log associated with the first entity; performing the first undo operation to undo the first operation without undoing the second operation performed by the application after the first operation.

2. The medium of claim 1 , wherein the first action and the second action are logged by the application in the same action log.

3. The medium of claim 1 , wherein the first action and the second action are logged by the application in different stacks of the same action log.

4. performing the undo operation 10. The medium of claim 1, further comprising: searching for a most recently performed operation on the first entity in a set of log entries containing operations performed on the first entity and the second entity in chronological order.

5. before recording the first action, the application receives, via a first interface, a first command to perform the first action, and the application performs the first action in response to the first command; 2. The medium of claim 1, wherein, prior to recording the second action, the application receives, via the same first interface, a second command to perform the second action, and the application performs the second action in response to the second command.

6. The medium of claim 5 , wherein the first command and the second command correspond to the same command with different parameter values ​​corresponding to the first entity and the second entity, respectively.

7. the first instruction specifies the first action to be undone; The plurality of actions further include: Based on (a) the first instruction and (b) the first operation and the second operation performed by the application on different entities, identifying a third action from the action log that was performed on the first entity and that occurred after the first action on the first entity; and performing a second undo operation to undo the third operation.

8. The application maintains a plurality of action logs respectively associated with the plurality of entities, and maintaining the plurality of actions comprises: in response to detecting execution of a particular operation of each of the plurality of operations; identifying a particular entity of the plurality of entities on which the particular operation was performed; and and storing the particular action in one action log of the plurality of action logs corresponding to the particular entity.

9. The application maintains a single action log for storing actions performed on any of the plurality of entities, and maintaining the plurality of actions comprises: in response to detecting the execution of each particular operation of the plurality of operations; identifying a particular entity of the plurality of entities on which the particular operation was performed; and and storing the particular action in the single action log along with an identification of the particular entity on which the particular action was performed.

10. The plurality of operations include: the application determining that a candidate action performed by the application has not been performed on any of the plurality of entities; 10. The medium of claim 1, further comprising: in response to determining that the candidate action has not been performed on any of the plurality of entities, refraining from recording the candidate action in the same manner as the plurality of actions.

11. The medium of claim 1 , wherein the plurality of entities respectively correspond to a plurality of sections of the same file.

12. The medium of claim 1 , wherein the plurality of entities respectively correspond to a plurality of files that are modified using the same application.

13. A method comprising the operations of any one of claims 1 to 12.

14. A system comprising means for performing the operations of any one of claims 1 to 12.

15. A system comprising at least one device including a hardware processor, the system being configured to perform the operations of any one of claims 1 to 12.

Images