Entity-based revocation and redo operations

Abstract

Techniques for UNDO and REDO operations in a computer user interface are disclosed. The technique enables a user to configure entities for UNDO and REDO operations. The technique also enables a user to roll back an individual entity to an immediately previous state, followed by a previous state, in one UNDO operation. Other entities are not affected by UNDO operations performed on the entity.

Description

Technical Field

[0001] The present invention relates generally to computer user interfaces and, more particularly, to undo and redo functionality of computer user interfaces. Background Art

[0002] Computer user interface can include the command that allows user to undo and redo operation. "UNDO" command enables user to roll back sequentially the operation performed by a series of previous states of application, operating system or other software with computer user interface. "REDO" command works in the order opposite to UNDO command, to sequentially restore the operation previously rolled back. For example, if user desires to undo multiple previous operations performed in application to correct previous errors, user can execute UNDO command to roll back previous operations sequentially to return application to the state before error. But, do so can have undesirable side effect. That is, rolling back to error often involves undoing the non-error operation performed after error. Accordingly, after using multiple UNDO commands to undo error, restoring the original state of application can involve manually repeating non-error operation. Manually repeating non-error operation in computer user interface consumes time inefficiently, causes error and makes user feel frustrated.

[0003] 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. BRIEF DESCRIPTION OF THE DRAWINGS

[0004] In the various figures of the accompanying drawings, embodiments are illustrated by way of example only and not limitation. It should be noted that references to "one" or "an" embodiment in the present disclosure do not necessarily refer to the same embodiment, and they mean at least one. In the accompanying drawings:

[0005] Figure 1 A system block diagram illustrating an example of an environment for implementing systems and processes according to one or more embodiments is shown.

[0006] Figure 2 A block diagram illustrating an example system in accordance with one or more embodiments is shown.

[0007] Figure 3A and Figure 3B A process flow block diagram illustrating an example of a process in accordance with one or more embodiments is shown.

[0008] Figure 4A , Figure 4B , Figure 4C , Figure 4D , Figure 4E , Figure 4F, Figure 4G and Figure 4H Illustrated are changes in state of entities in a user interface display in accordance with one or more embodiments.

[0009] Figure 5 Shown is a time-flow diagram 500 illustrating state changes of an entity in accordance with one or more embodiments.

[0010] Figure 6 An example stack is shown that records the state of an entity in accordance with one or more embodiments.

[0011] Figure 7 A block diagram of a computer system is shown in accordance with one or more embodiments. DETAILED DESCRIPTION

[0012] In the following description, for the purpose of explanation, many specific details are set forth in order to provide a thorough understanding. One or more embodiments may be practiced without these specific details. The features described in one embodiment may be combined with the features described in different embodiments. In some examples, well-known structures and devices are described with reference to block diagram form to avoid unnecessary confusion of the present invention.

[0013] 1. General Overview

[0014] 2. System environment

[0015] 3. System architecture

[0016] 4. Undo / Redo Processing

[0017] 5. Hardware Overview

[0018] 6. Miscellaneous; Extensions

[0019] 1. General Overview

[0020] The present disclosure is directed to systems, methods, and non-transitory computer-readable storage media for a computer user interface that includes UNDO and REDO commands. Embodiments identify and track operations performed by a user on various entities of a computer user interface to enable entity-specific UNDO and REDO commands. Entities may be individual components of a computer user interface whose states may be changed by a user. Entities may include individual elements or groupings of elements. For example, some entities may be entities created by a graphic design application such as ), a single shape (e.g., a rectangle) in a drawing generated by a word processing application such as ) or by a document management application such as ) all in Redmond, Washington In another example, an entity may correspond to a database record. In addition, an entity may include multiple components, such as a layer (including multiple shapes) of a drawing application, a sentence or paragraph (including multiple words) of a word processing application, a folder (including multiple files) of a file management application, or a table of a database application.

[0021] Embodiments disclosed herein track the operations performed by an application per entity to record the state of the entity for performing UNDO and REDO operations. One or more embodiments predefine components of a computer user interface of an application as entities. For example, an embodiment may use a predefined list of entities. In addition or alternatively, some embodiments enable a user to configure an entity by defining a custom list. In addition, some embodiments configure an entity by automatically applying an intelligent criterion or machine learning model that classifies components into entities.

[0022] According to the present disclosure, a user can command an application's computer user interface to UNDO and REDO operations performed on a selected entity. In response to the UNDO and REDO commands, the application can identify the state information of the selected entity in a corresponding log (e.g., an UNDO stack) and roll back the operations performed on the selected entity based on the log without undoing operations performed on other entities in the computer user interface. Doing so greatly improves the operation of the computer user interface by reducing the computing resources used to perform UNDO and REDO operations on unselected objects and by improving the efficiency and accuracy of the computer user interface.

[0023] 2. System environment

[0024] Figure 1 A flow chart illustrating an example environment 100 for implementing systems and processes according to aspects of the present disclosure is shown. The environment 100 includes a computing system 105 including a display device 110 that displays a user interface 115 of an application 120. For purposes of illustration, 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, graphics, pictures, and other drawing objects such as entities 131, 133, and 135. The application 120 may identify operations performed on the various entities 131, 133, and 135 and record states of the entities 131, 133, and 135 resulting from these operations.

[0025] Furthermore, the user interface 115 of the application 120 may include a selection of UNDO and REDO commands. In this example, the application 120 generates an on-demand context menu 140 in the user interface 115, which has UNDO and REDO commands that can be selected by the cursor 125. For example, the user interface 115 may display the context menu 140 in response to a user input (e.g., a right-click mouse operation) on the entity 133. Selecting the UNDO action in the context menu 140 may command the application 120 to roll back the last operation on the selected entity 133. For example, if the most recent operation on the entity 133 is to resize a triangle object, the user may UNDO the last operation by triggering the context menu 140 and selecting "UNDO", which causes the application 120 to roll back the most recent operation recorded by the application 120 by restoring the entity 133 to a previous state before the resizing. Furthermore, selecting the REDO command in the context menu 140 will cause the application 120 to restore the most recently undone operation by restoring the entity 133 to its original state before the UNDO command.

[0026] In addition, via user interface 115, a user may repeatedly command application 120 to UNDO a previous operation performed on an entity, such as entity 133. In response to the repeated UNDO command, application 120 may sequentially roll back the state of entity 133 based on the state information stored in the log for entity 133, without rolling back any previous operations performed on entities 131 and 135. For example, the previous operations performed on entity 133 may be "resize", "rotate", and "flip" in reverse order. Furthermore, the previous operations performed on entity 131 may be "rotate" and "add" in reverse order. Moreover, the previous operation performed on entity 131 may be "add". In reverse order, the operations on all entities may be, for example, entity 133: "resize", entity 135: "rotate", entity 135: "add", entity 133: "rotate", entity 133: "flip", and entity 131: "add". Repeated use of the context menu 140 command to apply the previous operations performed on entity 133 will cause the application to sequentially roll back entity 133 to the state before the "resize" operation, then the state before the "rotate" operation, and then the state before the "flip" operation. However, since the UNDO command is only for entity 133, application 120 will not roll back any previous operations performed on entities 131 and 135.

[0027] 3. System architecture

[0028] Figure 2A computing system 105 according to one or more embodiments is illustrated. The computing system 105 may be the same or similar to that described above. Embodiments of the computing system 105 may be implemented on one or more digital devices. A digital device may be any hardware device including a processor. Some embodiments of a digital device may refer to a physical device that executes an application or a virtual machine. Examples of digital devices include personal computers, tablet computers, laptop computers, desktop computers, servers, web servers, network policy servers, proxy servers, general purpose machines, function-specific hardware devices, mainframes, televisions, content receivers, set-top boxes, printers, mobile handheld devices, smart phones, personal digital assistants ("PDAs"), and / or client devices.

[0029] The computing system 105 may include a display device 110, an input / output device 203, and a storage device 205. The display device 110 may be the same or similar to that described above. An embodiment of the 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. The I / O device 203 may include any device that enables a person to interact with the computing device 430 (e.g., a user interface), and / or any device that enables the computing system 105 to communicate with one or more other computing devices or peripheral devices using any type of communication link. The I / O device 203 may be, for example, a touch screen display, a pointer device (e.g., a computer mouse), a keyboard, etc.

[0030] The storage device 205 may be one or more hard disk drives, flash drives, optical disk read-only memories (ROMs), digital versatile disks (DVDs) 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 codes) for the operation of the computing system 105, as well as information (such as libraries and data). In addition, 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. In addition or alternatively, a user may customize the entity library 213. One or more embodiments Other embodiments use intelligent criteria (e.g., machine learning models) to determine entities on the fly and store entities in the entity library 213. As described in detail below, UNDO / REDO log 215 may store time-ordered entity states on a per-entity basis.It will be appreciated that some or all of the information used by computing system 105 may be stored remotely, such as in data source 101 or some other data repository or storage system.

[0031] In addition, computing system 105 can execute computer program instructions for application 120, which can be the same or similar to the instructions previously described. Application 120 can be any type of software with a computer user interface, such as a graphical user interface (e.g., user interface 115). For example, application 120 can be a word processor application, a code editor application, a database application, a spreadsheet application, a presentation application, a drawing application, a mail 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 change components of a user interface.

[0032] 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 generated by the application (e.g., entities 131, 133, 135). The UNDO / REDO module 225 may also instantiate and maintain a log UNDO stack for each tracked entity in the UNDO / REDO log 215. Although the UNDO / REDO module 225 is shown as being included in the application 120, it is understood that the UNDO / REDO module 225 may be a stand-alone module or may be incorporated in another application. For example, the UNDO / REDO module 225 may be a service of the operating system of the computing system 105.

[0033] In one or more embodiments, computing system 105 may include Figure 2 More or fewer components may be used than shown. Figure 2 The components shown in may be local to each other, or may be remote from each other. Figure 2 The components shown in the figure can be implemented in software and / or hardware. Each component can be distributed on multiple applications and / or machines. Multiple components can be combined into one application and / or machine. The operation described with respect to one component can be performed by another component instead.

[0034] According to some embodiments, the technology described herein is implemented by one or more general or special computing devices. General computing devices can be, for example, servers, personal computers, smart phones, tablet computers, laptop computers, etc. Special computing devices can be hardwired to perform these technologies, or can include digital electronic devices (such as one or more application-specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), or network processing units (NPUs)) that are permanently programmed to perform these technologies, or can include one or more general hardware processors that are programmed to perform these technologies according to program instructions in firmware, memory, other storage devices, or combinations of these. Such special computing devices can also combine custom hardwired logic, ASICs, FPGAs, or NPUs with custom programming to implement these technologies. Special computing devices can be desktop computer systems, portable computer systems, handheld devices, networking devices, or any other devices that combine hardwiring and / or program logic to implement these technologies.

[0035] Any combination of the features and functionality described herein may be used according to one or more embodiments. In the foregoing description, embodiments have been described with reference to numerous specific details that may vary from implementation to implementation. Accordingly, the description and drawings should be considered in an illustrative rather than a restrictive sense. The sole and exclusive indication of the scope of the invention, and what the applicants intend to be the scope of the invention, is the literal and equivalent range of the set of claims generated by this application, in the specific form in which such claims are generated, including any subsequent corrections.

[0036] 4. Undo processing

[0037] Figure 3A and Figure 3B The flowcharts in the drawings illustrate the functionality and operation of systems, devices, processes and computer program products according to various embodiments of the present disclosure. Figure 3A and Figure 3B Each block in the flowchart may represent a module, a segment, or a portion of program instructions, which includes one or more computer executable instructions for implementing the functions and operations shown. In some embodiments, the functions and / or operations shown in a specific block of the flowchart may not be in the order in which they are shown. Figure 3A and 3B . For example, two boxes shown in succession may be executed substantially simultaneously, or may sometimes be executed in reverse order, depending on the functionality involved. In addition, in some embodiments, the boxes of the flow chart may be rearranged in a different order. In addition, in some embodiments, the flow chart may include fewer boxes or more boxes. It should also be noted that each box in the flow chart and the combination of boxes in the flow chart may be implemented by a dedicated hardware-based system or a combination of dedicated hardware and computer instructions that performs a specified function or action.

[0038] Figure 3A and Figure 3B A flow chart illustrating an example process 300 for performing an UNDO operation according to one or more embodiments is shown. At block 301, process 300 defines an entity detected by an application. As described above, an entity can be any individual component of a computer user interface, and its state can be changed by a user. An entity (e.g., entity 131, 133, and 135) can include a single component of a user interface or a grouping of components (e.g., a drawing layer including entity 131, 133, and 135). An application (e.g., application 120) can be any computer software, module, or program instruction set that generates a computer user interface (e.g., user interface 115) that allows a user to change a component of a computer user interface.

[0039] Defining entities for detection may include configuring which computer user interface components of the application will have tracked operations and recorded states. One or more embodiments store predefined components as entities in a library (e.g., entity library 213). In addition, one or more embodiments enable users to define components as entities. For example, an application may include a user interface menu that lists selectable components (e.g., shapes, groups, layers, and slides of a drawing application) of a computer user interface that are to be defined as entities for tracking and recording. The application may also receive and decode regular expressions or context-free grammars to determine rule-based entity definitions based on user input. In addition or alternatively, the computer user interface may include an on-demand context menu 140 that includes options for users to define components or groups of components as entities. For example, a user may identify a group of objects in a drawing application as a single entity. In addition, one or more embodiments automatically identify components as entities. For example, an application may include a machine learning model trained using data describing the selection of previous components and previous UNDO / REDO commands to infer components that should be defined as entities.

[0040] At block 303, the process 300 detects the user's execution of an operation in the application. For example, the application may monitor user input to the user interface via an I / O device (e.g., I / O device 203) that triggers the operation. One or more embodiments detect the execution of all operations in the application, including, for example, file management operations, menu selections, toolbar commands, information entry, editing operations, etc. At block 305, the process determines whether the candidate operation detected at block 303 is performed on one or more entities of the computer user interface. The determination can be based on detecting the execution of the operation at block 303 and determining that the detected operation involves one of the entities configured at block 301. For example, the application can detect user input to adjust the size of an object (e.g., entity 131) in a 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 operation is not performed on the entity (e.g., block 305 is "no"), then at block 307, the process 300 avoids recording the detected operation and returns to block 303.

[0041] On the other hand, if the operation detected at box 303 is performed on one or more entities (e.g., box 305 is "yes"), then at box 309, process 300 records the operation detected at box 303 corresponding to the entity on which the operation was performed identified at box 305. Recording the operation can include identifying the respective entities on which the operation was performed at box 311. For example, based on the coordinates of a cursor (e.g., cursor 125) controlled by an I / O device (e.g., a computer mouse or a touch screen), the application can determine that the operation was performed on a particular entity (e.g., entity 131). Recording the operation can also include storing the first operation performed on the first entity in one or more logs (e.g., UNDO / REDO log 215) at box 312. As described below with respect to Figure 6 Specifically, the log may include an UNDO stack that records all operations performed by the computer user interface (e.g., Figure 6 , the log may include an UNDO stack (e.g., UNDO stack 601) that records all operations performed by the computer user interface and one or more UNDO stacks (e.g., UNDO stacks 603, 605, and 607) that record operations performed on a specific entity. The recording operation may also include storing the subsequent operations performed on the second entity in the entity log at block 313. One or more embodiments store the first operation of block 312 and the subsequent operations of block 313 in the same log. The log may include a single stack that includes the first operation of block 312 and the subsequent operations of block 313, or the log may include different stacks that store the first operation of block 312 and the subsequent operations of block 313, respectively. In addition or alternatively, one or more embodiments store the first operation of block 312 and the subsequent operations of block 313 in different logs. The recording may include storing metadata of the state change in the UNDO stack for all entities displayed in the user interface. In addition, for each entity in the user interface, the recording may include storing the state information in the UNDO corresponding to each entity. It is understood that some embodiments store the state information about the entity in the same log. Other embodiments store state information about entities in different logs corresponding to each entity.

[0042] At block 315, process 300 receives an instruction to perform an UNDO operation of the application associated with the first entity identified at block 311. Receiving the instruction to perform the UNDO operation may include receiving input via a user interface executed on the first entity. For example, the computer user interface of the application may receive the command to perform the UNDO operation on 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).

[0043] Continue via off-page connector "A" to Figure 3B At block 323, based on (a) the instruction to perform the UNDO operation received at block 315 and (b) the operation performed on the first entity stored at block 312 and the subsequent operation performed on the second entity stored at block 313 by the application on different entities, the process 300 identifies an operation for performing the UNDO operation from the operation log. Performing the UNDO operation may include searching a set of log entries for the most recently performed operation on the first entity, the set of log entries including the 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 at block 312, but not for the operation stored in the UNDO stack of the second entity at block 313. At block 325, the process 300 performs a first undo operation to undo the first operation performed on the first entity, but not the subsequent operation performed on the second entity.

[0044] At block 329, process 300 may determine whether it has received an instruction from the application to perform another UNDO operation on the first entity identified at block 311. If not received (e.g., "No" at block 333), process 300 ends. If received (e.g., "Yes" at block 333), process 300 may iteratively repeat blocks 323 and 325 to perform another UNDO operation on the first entity.

[0045] 4. Example Embodiments

[0046] For the sake of clarity, detailed examples are described below. The components and / or operations described below should be understood as a specific example, which may not be applicable to certain embodiments. Therefore, the components and / or operations described below should not be interpreted as limiting the scope of any claim.

[0047] Figure 4A , Figure 4B , Figure 4C and Figure 4D The diagram illustrates changes in the state of entities in the application display screen presented by the user interface 115, which are caused by the operation of the application (e.g., application 120), as described herein, which can be recorded for UNDO / REDO operations. For example, the application shown can be a drawing application. Figure 4A The first entity E1 (e.g., entity 131) is shown displayed by the user interface 115 when it is in a first state of the entity S1 at a first time (e.g., T0-7) before the current time (e.g., T0). The state S1 of the entity E1 can be an initial state of the entity E1 after the object is initially drawn, or the state S1 can be some later state of the entity E1 previously manipulated by the user. Figure 4B The first entity E1 (eg, entity 131) is shown in the first state of the entity S1 at a second time (eg, T0-6) before the current time. In addition, Figure 4B A second entity E2 (eg, entity 135) is shown at a second time. State S1 of entity E2 may be an initial state of entity E2 after the object is initially drawn, or state S1 of entity E2 may be some later state of entity E2 previously manipulated by a user. Figure 4C A first entity E1 is shown in a second state of entity S2 at a third time (e.g., T0-5) before a current time (e.g., T=0), and a second entity E2 (e.g., entity 135) is shown in the first state of entity S2. State S2 of entity E1 may be a state of entity E1 after state S1 is modified. For example, state S2 of entity E1 may be the result of a "stretch" operation that changes the scale of E1. Figure 4D A first entity E1 is shown in a third state of entity S2 at a fourth time (e.g., T0=-4) before a current time (e.g., T=0), and a second entity E2 is shown in a second state of entity S2. State S2 of entity E2 may be a state of entity E2 after state S1 is modified. For example, the modification may be a "resize" operation that changes the size of entity E2 while maintaining the relative proportions of entity E2. Figure 4E A first entity E1 in a third state of entity S3 at a fifth time (e.g., T0-3) before a current time (e.g., T=0), a second entity E2 in a first state of entity S1, and a third entity E3 (e.g., entity 133) in the first state of entity S1 are shown. State S1 of entity E3 may be an initial state of entity E1 after the object is initially drawn, or state S1 may be some subsequent state of entity E1 previously manipulated by a user. Figure 4F A first entity E1 in the second state of entity S2 at a sixth time (e.g., T0-2) before a current time (e.g., T=0), a second entity E2 in the third state of entity S3, and a third entity E3 in the first state of entity S1 are shown. State S3 of entity E2 may be the state of entity E2 after state S2 is modified. For example, the modification may be a "stretch" operation that changes the relative size and proportion of entity E2. Figure 4G A first entity E1 in a third state of entity S3 at a seventh time (e.g., T0-1) before a current time (e.g., T=0), a second entity E2 in a third state of entity S3, and a third entity E3 in a first state of entity S1 are shown. State S3 of entity E1 may be a state of entity E1 after state S2 is modified. For example, the modification may be a "stretch" operation that changes the relative size and proportion of E1. Figure 4HThe first entity E1 in the fourth state of the entity S4 is shown, rolled back to Figure 4C The second entity E2 of the state S1 of entity E2 at T0-5 shown in the figure and the third entity E3 in the first state S1 of entity E3 at the current time (e.g., T=0). The rollback of the state of E2 from state S3 to state S1 can be achieved by the user selecting E2 and executing an UNDO command of two UNDO commands. According to aspects of the present disclosure, the UNDO command operates only on the selected entity E2, and does not operate on the unselected entities E1 and E3. Undoing one or more operations on entity E2 to roll back states S3 and S2 does not affect the current state S3 of entity E1 or the current state S1 of entity E3.

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

[0049] Figure 5 Shows instructions for use Figures 4A-4H 500 of an example showing a time flow diagram 500 of state changes of entities presented. The time flow diagram 500 includes a plurality of time slots T0-7, T0-6, T0-5, T0-4, T0-3, T0-3, T0-1, and T0, which represent time frames for performing operations on entities E1, E2, and E3 in a computer user interface (e.g., user interface 115) of an application (e.g., application 120). In addition, the time flow diagram 500 includes bands 503, 505, and 507, illustrating states S1, S2, and S3 of the respective entities E1, E2, and E3 during time slots T0-7, T0-6, T0-5, T0-4, T0-3, T0-3, T0-1, and T0, resulting from operations performed by a user on the entities E1, E2, and E3 via the computer user interface.

[0050] As mentioned above about Figures 4A-4H As shown, band 503 shows the state of entity E1. At T0-7, entity E1 is in state S1. (See, for example, Figure 4A . ) At T0-5, due to the user performing a "stretch" operation, entity E1 is in state S2. (See, for example, Figure 4C. ) At T0-1, due to the user performing the second "stretch" operation, entity E1 is in state S3. (See, for example, Figure 4G . ) Strip 505 shows the state of entity E2. At T0-6, entity E2 is in state S1. (See, for example, Figure 4B . ) At T0-4, due to the user performing the "resize" operation, entity E2 is in state S2. (See, for example, Figure 4D . ) At T0-2, entity E2 is in state S3 due to the user performing a "stretch" operation. (See, for example, Figure 4F . ) At T0, entity E2 is in state S1 due to the user executing a selection of entity E2 and instructing the computer user interface to execute two sequential UNDO commands to roll back entity E2 from state S3 to S2 and from state S2 to state S1. (See, for example, Figure 4H . ) Strip 507 shows the state of entity E2. At T0-6, entity E3 is in state S1. According to aspects of the present disclosure, at the current time T0, due to the UNDO command executed on entity E2 at T0, the current state S1 of entity E2 has been rolled back from state S3 at T0-2 and state S2 at T0-4. However, the UNDO command does not change the states of entities E1 and E3. Since the user did not select entities E1 and E3 to execute the UNDO command at T0, entity E1 retains state S3 since T0-1 and entity E3 retains state S1 since T0-3.

[0051] One or more embodiments record operations on entities E1, E2, and E3 in an UNDO stack, as described below with respect to Figure 6 As described. For example, the application may receive a "stretch" command via a computer user interface, such that the application performs a first "stretch" operation on entity E2 at T0-2 before recording the stretch operation. Moreover, the application may receive another "stretch" command via a computer user interface, such that the application performs a second "stretch" operation on entity E1 at T0-1 before recording the second stretch operation. It is noteworthy that 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.

[0052] Figure 6 Shows the application in the record Figures 4A-4H2, 3, 605, and 607 are shown in FIG. 1 . The example UNDO stacks 601, 603, 605, and 607 are maintained in a log (e.g., UNDO / REDO log 215) of state information (e.g., S1, S2, S3) of entities (e.g., E1, E2, E3) in the example display screen. The UNDO stacks 601, 603, 605, and 607 can be a data structure that stores state information in time-ordered blocks, where the newest information is stored in the bottom-most occupied block and the oldest information is stored in the top-most block. Although for ease of explanation, Figure 6 The stacks 601, 603, 605, and 607 shown in FIG. 1 include eight blocks (such as blocks 611, 615, and 619), but it is 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 is also understood that the order of the blocks may be reversed so that the newest information is stored in the topmost block and the oldest information is stored in the bottommost occupied block.

[0053] The state information stored in the UNDO stacks 601, 603, 605, and 607 may include the current state of the entity and the operation of the user interface (e.g., user interface 115) that caused the current state. In addition, the state information may include parameters for displaying the corresponding entity E1, E2, E3 by the application in the previous state and / or the current state. The parameters for displaying the entity E1, E2, E3 may include data used by the application to draw or redraw the entity E1, E2, E3 in the user interface. For example, for an object of a drawing application, the parameters may include identification, size, position, text, shadow, reflection, three-dimensional format, rotation, filling, line parameters, etc. The information describing the entity may also include a value describing a parameter change from the previous state to the current state. For example, a parameter change for a resizing operation may include a change in the vertical size of the entity and a change in the horizontal size.

[0054] UNDO stack 601 may be a data structure used by an application (eg, application 120 executing UNDO / REDO module 225) to record state information of all entities in the computer user interface of the application. Figure 5 In the example shown in FIG. 6 , the UNDO stack 601 may record the states S1, S2, and S3 of the entities E1, E2, and E3 in bands 503, 505, and 506 on a time basis. Figure 5 In the time order shown in , UNDO stack 601 can 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.

[0055] In addition, according to aspects of the present disclosure, entity UNDO stacks 603, 605, 607 may be data structures used by an application to store state information of each entity E1, E2, and E3, respectively. Figure 5 In the example shown in , entity UNDO stack 603 can record the state information of entity E1 in band 503, entity UNDO stack 603 can record the state information of entity E2 in band 505, and entity UNDO stack 607 can record the state information of entity E3 in band 507. Using entity UNDO stacks 603, 605, and 607, an application can selectively perform UNDO operations on each entity E1, E2, and E3. For example, Figure 4H and Figure 5 As shown in FIG. 1 , 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. Rolling back the state of entity E2 from state S3 to state S1 in response to an UNDO operation performed on entity E2 in the user interface can involve identifying the current state of E2 block 611 of stack 603 (e.g., E2, S3), restoring entity E2 to state S2 based on the state information stored in block 615, and further restoring entity E2 to state S1 based on the state information (state S2) of entity E2 stored in block 619.

[0056] 5. Hardware Overview

[0057] According to one embodiment, the technology described herein is implemented by one or more special-purpose computing devices. The special-purpose computing device can be hard-wired to perform the technology, or can include digital electronic devices such as one or more application-specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), or network processing units (NPUs) that are permanently programmed to perform the technology, or can include one or more general-purpose hardware processors that are programmed to perform the technology according to program instructions in firmware, memory, other storage devices, or a combination of these. These special-purpose computing devices can also combine custom hard-wired logic, ASICs, FPGAs, or NPUs with custom programming to implement the technology. The special-purpose computing device can be a desktop computer system, a portable computer system, a handheld device, a networking device, or any other device that combines hard-wiring and / or program logic to implement the technology.

[0058] For example, Figure 7700 is a block diagram illustrating a computer system 700 upon which embodiments 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 with bus 702 for processing information. Hardware processor 704 may be, for example, a general purpose microprocessor.

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

[0060] Computer system 700 also 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 or optical disk, is provided and coupled to bus 702 for storing information and instructions.

[0061] The computer system 700 may be coupled via the 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 the bus 702 for communicating information and command selections to the processor 704. Another type of user input device is a cursor control 716, such as a mouse, trackball, or cursor direction keys, for communicating direction information and command selections to the processor 704 and for controlling cursor movement on the display 712. Such input devices typically have two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), to allow the device to specify a position in a plane.

[0062] The computer system 700 may implement the techniques described herein using custom hardwired logic, one or more ASICs or FPGAs, firmware, and / or program logic that, in combination with the computer system, makes the computer system 700 a special purpose machine or programs the computer system 700 to be a special purpose machine. According to one embodiment, the techniques herein are performed by the computer system 700 in response to the processor 704 executing one or more sequences of one or more instructions contained in the main memory 706. These instructions may be read into the main memory 706 from another storage medium, such as the storage device 710. Execution of the sequences of instructions contained in the main memory 706 causes the 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.

[0063] 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 particular 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, tapes or any other magnetic data storage media, CD-ROMs, any other optical data storage media, any physical media with hole patterns, RAM, PROM and EPROM, FLASH-EPROM, NVRAM, any other memory chip or cassette, content addressable memory (CAM) and ternary content addressable memory (TCAM).

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

[0065] Various forms of media may be involved in carrying one or more sequences of one or more instructions to the processor 704 for execution. For example, the instructions may initially be carried on a 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 the 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 the bus 702. The bus 702 carries the data to the main memory 706, from which the processor 704 retrieves and executes the instructions. The instructions received by the main memory 706 may optionally be stored on the storage device 710 before or after execution by the processor 704.

[0066] Computer system 700 also includes a communication interface 718 coupled to bus 702. Communication interface 718 provides bidirectional data communication coupled to network link 720, wherein network link 720 is connected to local network 722. For example, communication interface 718 can be an integrated services digital network (ISDN) card, a cable modem, a satellite modem, or a modem that provides data communication connection to a telephone line of a corresponding type. As another example, communication interface 718 can be a LAN card that provides data communication connection to a compatible local area network (LAN). Wireless links can also be implemented. In any such implementation, communication interface 718 sends and receives electrical signals, electromagnetic signals, or optical signals that carry digital data streams representing various types of information.

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

[0068] 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, server 730 can transmit the requested code for an application program through Internet 728, ISP 726, local network 722, and communication interface 718.

[0069] 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.

[0070] 6. Miscellaneous; Extensions

[0071] Embodiments are directed to a system having one or more devices comprising a hardware processor and configured to perform any of the operations described herein and / or in any of the following claims.

[0072] In an embodiment, a non-transitory computer-readable storage medium comprises instructions that, when executed by one or more hardware processors, cause performance of any of the operations described herein and / or recited in any of the claims.

[0073] Any combination of the features and functionality described herein may be used according to one or more embodiments. In the foregoing description, various embodiments have been described with reference to numerous specific details, which may vary from one embodiment to another. Accordingly, the description and drawings should be considered in an illustrative rather than a restrictive sense. The sole and exclusive indication of the scope of the invention, and what the applicants intend to be the scope of the invention, is the literal and equivalent range of the set of claims generated by this application, in the specific form in which such claims are generated, including any subsequent corrections.

Claims

1. A non-transitory computer-readable storage medium comprising instructions that, when executed by one or more hardware processors, cause operations to be performed, the operations comprising: A plurality of operations that have been performed by the application are recorded by the application, where the plurality of operations are performed on at least one entity among the plurality of entities, and the plurality of operations include: a first operation performed by the application on a first entity of the plurality of entities; and a second operation performed by the application on a second entity of the plurality of entities, wherein the second operation is performed after the first operation; receiving, by an application, a first instruction, the first instruction (a) specifying a first entity and (b) including a command to perform a first undo operation associated with the first entity; and Based on (a) a first instruction specifying a first entity and (b) comprising a command to perform a first undo operation associated with the first entity: identifying a first operation stored in the operation log in association with the first entity for performing a first undo operation; and A first undo operation that undoes a first operation is performed without undoing a second operation that was performed after the first operation was applied. 2 . The medium of claim 1 , wherein the first operation and the second operation are recorded by the application in a same operation log. 3 . The medium of claim 1 , wherein the first operation and the second operation are recorded by the application in different stacks of the same operation log.

4. The medium of claim 1, wherein performing an undo operation comprises: A collection of log entries that includes, in chronological order, operations performed on the first entity and the second entity is searched for an operation most recently performed on the first entity.

5. The medium of claim 1, wherein: Before recording the first operation, receiving, by the application via the first interface, a first command for executing the first operation, wherein the application executes the first operation in response to the first command; and Before recording the second operation, a second command for executing the second operation is received by the application via the same first interface, wherein the application executes the second operation 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 but have different parameter values ​​corresponding to the first entity and the second entity, respectively.

7. The medium of claim 1, wherein: The first instruction specifies the first operation to be undone; as well as The operations also include: Based on (a) a first instruction and (b) a first operation and a second operation performed by the application on different entities: identifying, from the operation log, a third operation that is performed on the first entity and that is performed after the first operation is performed on the first entity; as well as A second undo operation is performed that undoes the third operation.

8. The medium of claim 1, wherein the application maintains a plurality of operation logs respectively associated with the plurality of entities, and wherein maintaining the plurality of operations comprises: In response to detecting execution of each particular operation of the plurality of operations: identifying a particular entity among the plurality of entities on which a particular operation has been performed; as well as The specific operation is stored in an operation log corresponding to the specific entity among the multiple operation logs.

9. The medium of claim 1, wherein the application maintains a single operation log to store operations performed on any of the plurality of entities, wherein maintaining the plurality of operations comprises: In response to detecting execution of each particular operation of the plurality of operations: identifying a particular entity among the plurality of entities on which a particular operation has been performed; as well as Specific operations are stored in a single operation log along with the identification of the specific entity on which the specific operation was performed.

10. The medium of claim 1, wherein the operations further comprise: determining, by the application, a candidate operation to be performed by the application, wherein the candidate operation is not performed on any of the plurality of entities; as well as In response to determining that the candidate operation has not been performed on any of the plurality of entities, recording the candidate operation in the same manner as the plurality of operations is avoided.

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

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

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

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

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

Images