Entity-based undo and redo operations

Abstract

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

Description

Technical Field

[0001] This invention generally relates to computer user interfaces, and more specifically, to undo and redo functions of computer user interfaces. Background Technology

[0002] Computer user interfaces can include commands that allow users to undo and redo operations. The "UNDO" command enables users to sequentially roll back a series of previous states performed by an application, operating system, or other software with a computer user interface. The "REDO" command works in the reverse order of the UNDO command, sequentially restoring previously rolled-back operations. For example, if a user wants to undo multiple previous operations performed in an application to correct a previous error, the user can execute the UNDO command to sequentially roll back the previous operations to return the application to its state before the error. However, doing so has undesirable side effects. That is, rolling back to an error often involves undoing non-error-related operations performed after the error. Accordingly, after undoing an error using multiple UNDO commands, restoring the application to its original state may involve manually repeating the non-error-related operations. Manually repeating non-error-related operations in a computer user interface is inefficient, time-consuming, error-prone, and frustrating for users.

[0003] The methods described in this section are feasible, but not necessarily methods that have been previously conceived or implemented. Therefore, unless otherwise stated, no method described in this section should be assumed to be prior art simply because it is included in this section. Attached Figure Description

[0004] In the various figures of the accompanying drawings, the embodiments are illustrated by way of example only and not as limitations. It should be noted that references to "a" or "an" embodiment in this 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 a system and processing according to one or more embodiments is shown.

[0006] Figure 2 A block diagram illustrating an example system according to one or more embodiments is shown.

[0007] Figure 3A and Figure 3B A process flow diagram illustrating an example of processing according to one or more embodiments is shown.

[0008] Figure 4A , Figure 4B , Figure 4C , Figure 4D , Figure 4E , Figure 4F, Figure 4G and Figure 4H The illustration shows a change in the state of an entity in a user interface display according to one or more embodiments.

[0009] Figure 5 A time flow diagram 500 illustrating the state changes of an entity according to one or more embodiments is shown.

[0010] Figure 6 An example stack of the state of a record entity is shown according to one or more embodiments.

[0011] Figure 7 A block diagram of a computer system according to one or more embodiments is shown. Detailed Implementation

[0012] In the following description, numerous specific details are set forth for purposes of explanation 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 examples, well-known structures and devices are described with reference to block diagrams to avoid unnecessarily obscuring the 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; Extension

[0019] 1. General Overview

[0020] This disclosure relates to systems, methods, and non-transitory computer-readable storage media for computer user interfaces including UNDO and REDO commands. Embodiments identify and track user actions performed on various entities of the computer user interface to enable entity-specific UNDO and REDO commands. An entity may be an individual component of the computer user interface whose state can be changed by the user. An entity may include a single element or a group of elements. For example, some entities may be generated by a graphic design application (such as...) Individual shapes (e.g., rectangles) generated in the drawing, and text processing applications (such as...) A single word in a document generated by ; or by a file management application (such as The storage consists of individual files, all of which are located in Redmond, Washington. The company's products. In another example, an entity can correspond to a database record. Furthermore, an entity can include multiple components, such as a layer (including multiple shapes) in a drawing application, a sentence or paragraph (including multiple words) in a word processing application, a folder (including multiple files) in a file management application, or a table in a database application.

[0021] The embodiments disclosed herein track operations performed by an application on an entity basis to record the entity's state for performing UNDO and REDO operations. One or more embodiments predefine components of the application's computer user interface as entities. For example, embodiments may use a predefined list of entities. Additionally or alternatively, some embodiments enable users to configure entities by defining a custom list. Furthermore, some embodiments configure entities by automatically applying intelligent criteria or machine learning models that classify components as entities.

[0022] According to this disclosure, a user can command the application's computer user interface to perform operations on selected entities using UNDO and REDO. In response to UNDO and REDO commands, the application can identify the state information of the selected entity in the corresponding log (e.g., the 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. This significantly improves the operation of the computer user interface by reducing the computational resources used to perform UNDO and REDO operations on unselected objects and by increasing the efficiency and accuracy of the computer user interface.

[0023] 2. System Environment

[0024] Figure 1 A flowchart illustrating an example environment 100 for implementing a system and processing according to aspects of this disclosure is shown. Environment 100 includes a computing system 105, which includes a display device 110 displaying a user interface 115 of an application 120. For illustration, 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). Application 120 may identify operations performed on the respective entities 131, 133, and 135 and record the states of entities 131, 133, and 135 resulting from these operations.

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

[0026] Additionally, via user interface 115, the user can repeat previous operations performed on entities (such as entity 133) by commanding application 120 to UNDO. In response to the repeated UNDO command, application 120 can roll back the state of entity 133 sequentially 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, previous operations performed on entity 133 could be "resize", "rotate", and "flip" in reverse order. Furthermore, previous operations performed on entity 131 could be "rotate" and "add" in reverse order. Moreover, the previous operation performed on entity 131 could be "add". In reverse order, operations on all entities could be, for example, entity 133: "resize", entity 135: "rotate", entity 135: "add", entity 133: "rotate", entity 133: "flip", and entity 131: "add". Repeating the UNDO command applied to entity 133 using context menu 140 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 applied to 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 as 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 virtual machine. Examples of digital devices include personal computers, tablets, laptops, desktops, 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, smartphones, 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 as or similar to those described above. Embodiments of the display device 110 may be, for example, a liquid crystal display (LCD), an organic light-emitting diode display (OLED), or other suitable display devices. The I / O device 203 may include any device that enables an individual 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 peripherals using any type of communication link. The I / O device 203 may be, for example, a touchscreen display, a pointing device (e.g., a computer mouse), a keyboard, etc.

[0030] Storage device 205 may be one or more hard disk drives, flash drives, optical disc read-only memory (ROM), digital versatile optical disc (DVD) optical storage technology, or other suitable fixed, non-transitory computer-readable storage devices. Storage device 205 may store computer-readable program instructions (such as applications, software modules, and other program code) for the operation of computing system 105, as well as information (such as libraries and data). Additionally, storage device 205 may store entity library 213 and UNDO / REDO log 215. Entity library 213 may store information identifying entities and entity types for tracking and logging one or more applications (e.g., application 120) executed by computing system 105. Some embodiments of entity library 213 identify components or types of components defined as entities. For example, an application may include predefined entities in entity library 213. Furthermore or alternatively, a user may customize entity library 213. Other embodiments use intelligent criteria (e.g., machine learning models) to determine entities on the fly and store them in entity library 213. As detailed below, the UNDO / REDO log 215 can store the entity status ordered by time on a per-entity basis. It is understood that some or all of the information used by the computing system 105 can be stored remotely, such as in the data source 101 or some other data repository or storage system.

[0031] Furthermore, the computing system 105 can execute computer program instructions for application 120, which may be the same as 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, code editor application, database application, spreadsheet application, presentation application, drawing application, email application, text messaging application, internet browser application, calculator application, file management application, or any other suitable type of computer software application or module that allows the user to change components of the 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 (e.g., entities 131, 133, 135) generated by the application. UNDO / REDO module 225 may also instantiate and maintain a log UNDO stack for each tracked entity in UNDO / REDO log 215. While UNDO / REDO module 225 is shown as included in application 120, it is understood that UNDO / REDO module 225 may be a standalone module or may be incorporated into another application. For example, UNDO / REDO module 225 may be a service of the operating system of computing system 105.

[0033] In one or more embodiments, the computing system 105 may include a ratio Figure 2 The components shown may have more or fewer components. Figure 2 The components shown can be local to each other or can be far apart from each other. Figure 2 The components shown can be implemented in software and / or hardware. Each component can be distributed across multiple applications and / or machines. Multiple components can be combined into one application and / or machine. An operation described with respect to one component can be performed by another component.

[0034] According to some embodiments, the techniques described herein are implemented by one or more general-purpose or special-purpose computing devices. General-purpose computing devices may be, for example, servers, personal computers, smartphones, tablets, laptops, etc. Special-purpose computing devices 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) that are persistently programmed to execute these techniques, or may include one or more general-purpose hardware processors, or combinations thereof, programmed to execute these techniques according to program instructions in firmware, memory, other storage devices. Such special-purpose computing devices may also combine custom hardwired logic, ASICs, FPGAs, or NPUs with custom programming to implement these techniques. Special-purpose computing devices may be desktop computer systems, portable computer systems, handheld devices, networking devices, or any other device that combines hardwired and / or program logic to implement these techniques.

[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 depending on the implementation. Accordingly, the description and drawings should be considered in an illustrative rather than restrictive sense. The unique and exclusive indication of the scope of the invention, and what the applicant intends to define as the scope of the invention, is the literal and equivalent scope of the set of claims resulting from this application, in the specific form of such claims, including any subsequent corrections.

[0036] 4. Cancellation Process

[0037] Figure 3A and Figure 3B The flowcharts 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 box in the flowchart may represent a module, segment, or part 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 shown in specific boxes of the flowchart may not be arranged in a specific order. Figure 3A and 3B The order in which the flowchart blocks occur is shown. For example, two blocks shown consecutively may execute substantially simultaneously, or sometimes in reverse order, depending on the functionality involved. Furthermore, in some embodiments, the flowchart blocks may be rearranged in a different order. Additionally, in some embodiments, the flowchart may include fewer or more blocks. It should also be noted that each block in the flowchart, and combinations of blocks in the flowchart, may be implemented by a dedicated hardware-based system or a combination of dedicated hardware and computer instructions that performs the specified function or action.

[0038] Figure 3A and Figure 3B A flowchart illustrating an example process 300 for performing UNDO operations according to one or more embodiments is shown. At block 301, process 300 defines entities to be detected by an application. As described above, an entity can be any individual component of a computer user interface whose state can be changed by a user. Entities (e.g., entities 131, 133, and 135) can include individual components of the user interface or groups 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.

[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). Furthermore, one or more embodiments enable a user to define components as entities. For example, the application may include a user interface menu listing selectable components of the computer user interface (e.g., shapes, groups, layers, and slides in a drawing application) to be defined as entities for tracking and recording. The application may also receive and decode regular expressions or context-free syntax 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 the user to define a component or group of components as entities. For example, a user may identify a group of objects in a drawing application as a single entity. Additionally, one or more embodiments automatically identify components as entities. For example, the application may include a machine learning model trained using data describing previous component selections and previous UNDO / REDO commands to infer components that should be defined as entities.

[0040] At block 303, process 300 detects user actions performed within 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 action. One or more embodiments detect the execution of all actions within 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 is performed on one or more entities of the computer user interface. This determination may be based on detecting the execution of the action at block 303 and determining that the detected action involves one 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 an entity (e.g., block 305 is "No"), then at block 307, process 300 avoids recording the detected action 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, processing 300 records the operation detected at box 303 corresponding to the entity to which the operation was performed, as identified at box 305. Recording the operation may include identifying the respective entities to 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 touchscreen), the application may determine that the operation was performed on a specific entity (e.g., entity 131). Recording the operation may 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. (See below for more details.) Figure 6 In detail, 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) recording all operations performed by the computer user interface and one or more UNDO stacks (e.g., UNDO stacks 603, 605, and 607) recording operations performed on a specific entity. Recording operations may also include storing subsequent operations performed on a second entity in an entity log at block 313. One or more embodiments store the first operation of block 312 and the subsequent operation 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 operation of block 313, or the log may include different stacks that store the first operation of block 312 and the subsequent operation of block 313, respectively. Alternatively or additionally, one or more embodiments store the first operation of block 312 and the subsequent operation of block 313 in different logs. Recording may include storing metadata about state changes in an UNDO stack for all entities displayed in the user interface. Furthermore, for each entity in the user interface, recording may include storing state information in an UNDO corresponding to that entity. It is understood that some embodiments store state information about entities 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 application's computer user interface 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] Continuing via external connector "A" Figure 3B At block 323, based on (a) the instruction to perform an 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, process 300 identifies the 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 operations performed on the first and second entities in chronological order. For example, the application may determine that the UNDO operation is for the operation stored at block 312 in the UNDO stack of the first entity, but not for the operation stored at block 313 in the UNDO stack of the second entity. At block 325, 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 box 329, process 300 can determine whether it has received an instruction from the application to perform another UNDO operation on the first entity identified at box 311. If no instruction is received (e.g., box 333 is "No"), then process 300 terminates. If an instruction is received (e.g., box 333 is "Yes"), then process 300 can iteratively repeat boxes 323 and 325 to perform another UNDO operation on the first entity.

[0045] 4. Example Implementation

[0046] For clarity, detailed examples are described below. The components and / or operations described below should be understood as a particular example and may not be applicable to some embodiments. Therefore, the components and / or operations described below should not be construed as limiting the scope of any claims.

[0047] Figure 4A , Figure 4B , Figure 4C and Figure 4D The illustration depicts changes in the state of entities on an application display screen presented by user interface 115, caused by operations of an application (e.g., application 120), which, as described herein, may be recorded for UNDO / REDO operations. For example, the illustrated application could be a drawing application. Figure 4A The diagram shows a first entity E1 (e.g., entity 131) displayed when the user interface 115 is in the first state of entity S1 at a first time (e.g., T0-7) before the current time (e.g., T0-7). The state S1 of entity E1 can be the initial state of entity E1 after the object is initially drawn, or the state S1 can be a later state of entity E1 previously manipulated by the user. Figure 4B This illustrates the first entity E1 (e.g., entity 131) when it is in the first state of entity S1 at a second time prior to the current time (e.g., T0-6). Furthermore, Figure 4B A second entity E2 (e.g., entity 135) is shown at a second time. The state S1 of entity E2 can be the initial state of entity E2 after the object is initially drawn, or the state S1 of entity E2 can be a later state of entity E2 previously manipulated by the user. Figure 4C The diagram shows a first entity E1 in the second state of entity S2 at a third time (e.g., T0-5) prior to the current time (e.g., T=0), and a second entity E2 (e.g., entity 135) in the first state of entity S2. The state S2 of entity E1 can be the state of entity E1 after modifying state S1. For example, the state S2 of entity E1 can be the result of a "stretching" operation that changes the scale of E1. Figure 4D The diagram shows a first entity E1 in the third state of entity S2 at a fourth time prior to the current time (e.g., T0 = -4), and a second entity E2 in the second state of entity S2. The state S2 of entity E2 can be the state of entity E2 after modifying state S1. For example, the modification can be a "sizing" operation that changes the size of entity E2 while maintaining its relative proportions. Figure 4E The diagram shows a first entity E1 in the third state of entity S3 at a fifth time (e.g., T0-3) prior to the current time (e.g., T=0), a second entity E2 in the first state of entity S1, and a third entity E3 (e.g., entity 133) in the first state of entity S1. The state S1 of entity E3 can be the initial state of entity E1 after the object is initially drawn, or state S1 can be a subsequent state of entity E1 previously manipulated by the user. Figure 4F The diagram illustrates a first entity E1 in the second state of entity S2 at a sixth time (e.g., T0-2) prior to the 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. The state S3 of entity E2 can be the state of entity E2 after a modification of state S2. For example, the modification could be a "stretching" operation that changes the relative size and scale of entity E2. Figure 4G The diagram illustrates a first entity E1 in the third state of entity S3 at a seventh time (e.g., T0-1) prior to the 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. The state S3 of entity E1 can be the state of entity E1 after a modification of state S2. For example, the modification could be a "stretching" operation that changes the relative size and scale of E1. Figure 4HThe first entity E1, which is in the fourth state of entity S4, is shown rolling back to, as... Figure 4C The diagram shows a second entity E2 in state S1 of entity E2 at T0-5, and a third entity E3 in state S1 of entity E3 at the current time (e.g., T=0). The state of E2 can be rolled back from state S3 to state S1 via an UNDO command where the user selects E2 and executes two UNDO commands. According to aspects of this disclosure, the UNDO command operates only on the selected entity E2, and not 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 are depicted 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 in a text document. Furthermore, for example, an entity can be a term, code block, control block, class, method, or code file in a code editor application. Additionally, for example, an entity can be a file, folder, or collection in a file management application. Moreover, an entity can be a record, column, table, or database in a database management application. Accordingly, it should be understood that embodiments consistent with this disclosure cover other types of applications where the computer user interface includes entities with states that can be changed by the user.

[0049] Figure 5 Instructions for use are shown. Figures 4A-4H The example shows a timeline diagram 500 illustrating the state changes of the presented entities. The timeline diagram 500 includes multiple time slots T0-7, T0-6, T0-5, T0-4, T0-3, T0-3, T0-1, and T0, which represent time frames in which entities E1, E2, and E3 are manipulated within the computer user interface (e.g., user interface 115) of an application (e.g., application 120). Furthermore, the timeline diagram 500 includes bands 503, 505, and 507, illustrating the states S1, S2, and S3 of the corresponding 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 the user performing operations on entities E1, E2, and E3 via the computer user interface.

[0050] As mentioned above Figures 4A-4H As shown, strip 503 illustrates the state of entity E1. In T0-7, entity E1 is in state S1. (See, for example, [reference needed]) Figure 4A In T0-5, entity E1 is in state S2 because the user performed a "stretch" operation. (See, for example, [link to relevant documentation]). Figure 4CIn T0-1, entity E1 is in state S3 because the user performs the second "stretch" operation. (See, for example, [link to relevant documentation]). Figure 4G (505 shows the state of entity E2. In T0-6, entity E2 is in state S1. (See, for example, [reference needed]) Figure 4B In T0-4, entity E2 is in state S2 because the user performed an "adjust size" operation. (See, for example, [link to relevant documentation]). Figure 4D In T0-2, entity E2 is in state S3 because the user performed a "stretch" operation. (See, for example, [link to relevant documentation]). Figure 4F At T0, because the user selects entity E2 and instructs 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, entity E2 is in state S1. (See, for example, [link to relevant documentation]). Figure 4H (Step 507 shows the state of entity E2. At T0-6, entity E3 is in state S1. According to an aspect of this 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. 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 the UNDO stack, as described below. Figure 6 As described. For example, an application can receive a "stretch" command via a computer user interface, causing the application to perform a first "stretch" operation on entity E2 at T0-2 before recording the stretch operation. Furthermore, the application can receive another "stretch" command via the computer user interface, causing the application to perform a second "stretch" operation on entity E1 at T0-1 before recording the second stretch operation. It is worth noting that the first and second "stretch" commands can correspond to the same command of the application, having different parameter values ​​corresponding to entities E1 and E2 respectively.

[0052] Figure 6 This demonstrates the application in recording. Figures 4A-4HExample UNDO stacks 601, 603, 605, and 607 are maintained in the logs (e.g., UNDO / REDO log 215) of the status information (e.g., S1, S2, S3) of entities (e.g., E1, E2, E3) in the example display. UNDO stacks 601, 603, 605, and 607 can be data structures that store status information in blocks ordered by time, where the latest information is stored in the bottom occupied block and the oldest information is stored in the top block. Although for ease of explanation, Figure 6 The stacks 601, 603, 605, and 607 shown include eight blocks (such as blocks 611, 615, and 619), but it is understood that any number of blocks can be used. For example, each UNDO stack 601, 603, 605, and 607 can include 64 or more blocks. It is also understood that the order of the blocks can be reversed, such 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 UNDO stacks 601, 603, 605, and 607 may include the current state of an entity and the operations of the user interface (e.g., user interface 115) that led to that current state. Furthermore, the state information may include parameters used by the application to display the corresponding entity E1, E2, E3 in the previous and / or current state. The parameters used to display entities E1, E2, E3 may include data used by the application to draw or redraw entities E1, E2, E3 in the user interface. For example, for objects in a drawing application, parameters may include identifier, size, position, text, shadow, reflection, 3D format, rotation, fill, line parameters, etc. Information describing the entity may also include values ​​describing parameter changes from the previous state to the current state. For example, parameter changes for resizing operations may include changes to the entity's vertical and horizontal dimensions.

[0054] The UNDO stack 601 can be a data structure used by an application (e.g., application 120 executing the UNDO / REDO module 225) to record state information of all entities in the application's computer user interface. Reference Figure 5 As shown in the example, the UNDO stack 601 can record the states S1, S2, and S3 of entities E1, E2, and E3 on a time-based basis in strips 503, 505, and 505. For example, according to... Figure 5 As shown in the time sequence, the UNDO stack 601 can record the state 1 of E1, the state 1 of E2, the state 2 of E2, the state 1 of E3, the state 3 of E2, and the state 3 of E1.

[0055] Furthermore, according to aspects of this disclosure, the entity UNDO stacks 603, 605, and 607 can be data structures used by the application to store the state information of each entity E1, E2, and E3 respectively. (See reference) Figure 5 In the example shown, entity UNDO stack 603 can record the state information of entity E1 in strip 503, entity UNDO stack 603 can record the state information of entity E2 in strip 505, and entity UNDO stack 607 can record the state information of entity E3 in strip 507. Using entity UNDO stacks 603, 605, and 607, the application can selectively perform UNDO operations on individual entities E1, E2, and E3. For example, as Figure 4H and Figure 5 As shown, 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 may involve identifying the current state (e.g., E2, S3) of E2 block 611 in stack 603, 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 of entity E2 (state S2) stored in the block.

[0056] 5. Hardware Overview

[0057] According to one embodiment, the techniques described herein are implemented by one or more dedicated computing devices. The dedicated computing device may be hardwired to execute the technology, or may include one or more application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or network processing units (NPUs) that are persistently programmed to execute the technology, or may include one or more general-purpose hardware processors programmed to execute the technology according to program instructions in firmware, memory, or other storage devices, or a combination of these. These dedicated computing devices may also implement the technology by combining custom hardwired logic, ASICs, FPGAs, or NPUs with custom programming. The dedicated computing device may be a desktop computer system, a portable computer system, a handheld device, a networking device, or any other device that combines hardwired and / or program logic to implement the technology.

[0058] For example, Figure 7This is a block diagram illustrating a computer system 700 on which embodiments of the present invention may be implemented. The computer system 700 includes a bus 702 or other communication mechanism for transmitting information and a hardware processor 704 coupled to the bus 702 for processing information. The hardware processor 704 may be, for example, a general-purpose microprocessor.

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

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

[0061] Computer system 700 can be coupled via bus 702 to a display 712, such as a cathode ray tube (CRT), for displaying information to a computer user. Input device 714, including alphanumeric keys and other keys, is coupled to bus 702 for transmitting information and command selections to processor 704. Another type of user input device is a cursor control 716, such as a mouse, trackball, or arrow keys, for transmitting directional information and command selections to processor 704 and for controlling cursor movement on 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] Computer system 700 may implement the techniques described herein using custom hard-wired logic, one or more ASICs or FPGAs, firmware, and / or program logic, which, in combination with the computer system, make computer system 700 a special-purpose machine or program the computer system 700 as such. According to one embodiment, the techniques herein are executed by computer system 700 in response to processor 704 executing one or more sequences of one or more instructions contained in main memory 706. These instructions may be read into main memory 706 from another storage medium, such as storage device 710. Execution of the sequence of instructions contained in main memory 706 causes processor 704 to perform the processing steps described herein. In alternative embodiments, hard-wired circuitry may be used instead of software instructions or in combination with software instructions.

[0063] As used herein, the term "storage medium" refers to any non-transitory medium that stores data and / or instructions that enable a machine to operate in a particular manner. Such storage media can include non-volatile media and / or volatile media. Non-volatile media include, for example, optical discs 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 media, CD-ROMs, any other optical data storage media, any physical media with a perforated pattern, RAM, PROMs and EPROMs, FLASH-EPROMs, NVRAMs, any other memory chips or cassette tapes, content-addressable memory (CAM), and tri-state content-addressable memory (TCAM).

[0064] Storage media differ from transmission media but can be used in conjunction with them. Transmission media participate in the transfer of information between storage media. For example, transmission media include coaxial cables, copper wires, and optical fibers, including wires containing bus 702. Transmission media can also take the form of sound waves or light waves, such as those generated during radio wave and infrared data communication.

[0065] Various forms of media can involve 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 disk or solid-state drive of a remote computer. The remote computer may load the instructions into its dynamic memory and transmit them over a telephone line using a modem. A modem local to computer system 700 may receive data over the telephone line and convert the data into an infrared signal using an infrared transmitter. An infrared detector may receive the data carried in the infrared signal, and appropriate circuitry may place the data on bus 702. Bus 702 carries the data to main memory 706, from which processor 704 retrieves and executes the instructions. Instructions received by main memory 706 may optionally be stored on storage device 710 before or after execution by 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, which is connected to local network 722. For example, communication interface 718 may be an Integrated Services Digital Network (ISDN) card, a cable modem, a satellite modem, or a modem providing data communication connectivity to a corresponding type of telephone line. As another example, communication interface 718 may be a LAN card providing data communication connectivity to a compatible local area network (LAN). A wireless link may also be implemented. In any such implementation, communication interface 718 transmits and receives electrical, electromagnetic, or optical signals carrying streams of digital data representing various types of information.

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

[0068] Computer system 700 can send messages and receive data, including program code, through one or more networks, network links 720, and communication interfaces 718. In the Internet example, server 730 can transmit requested code for the application through the Internet 728, ISP 726, local network 722, and communication interface 718.

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

[0070] 6. Miscellaneous; Extension

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

[0072] In an embodiment, the non-transitory computer-readable storage medium includes instructions that, when executed by one or more hardware processors, cause to perform any operation described herein and / or set forth in any of the claims.

[0073] Any combination of the features and functionalities described herein may be used according to one or more embodiments. In the foregoing specification, various embodiments have been described with reference to numerous specific details that may vary from one implementation to another. Accordingly, the specification and drawings are to be considered in an illustrative rather than restrictive sense. The unique and exclusive indication of the scope of the invention, and what the applicant intends to define as the scope of the invention, is the literal and equivalent scope of the set of claims generated by this application, in the specific form generated by such claims, 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 including: The application records multiple operations performed by the application, said multiple operations being performed on at least one of a plurality of entities, said multiple operations including: The first operation performed by the application on the first entity among multiple entities; and A second operation performed by the application on a second entity among the plurality of entities, wherein the second operation is performed after the first operation; The first and second operations are recorded in the same operation log by the application in the order of their operation time; The application receives a first instruction, which specifies a first entity and includes a command to perform a first undo operation associated with the first entity; and The first instruction specifies a first entity and includes a command to perform a first undo operation related to the first entity: Search for the most recently performed operation on the first entity in the set of log entries in the operation log that include operations performed on the first entity and the second entity in chronological order of the operation; Identify the first operation stored in the operation log associated with the first entity for performing the first undo operation; and Perform a first undo operation to undo the first operation, but do not undo the second operation that was performed after the first operation.

2. The non-transitory computer-readable storage 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.

3. The non-transitory computer-readable storage medium as described in claim 1, wherein: Before recording the first operation, the application receives a first command to execute the first operation via a first interface, wherein the application executes the first operation in response to the first command; and Before recording the second operation, the application receives a second command to perform the second operation via the same first interface, wherein the application performs the second operation in response to the second command.

4. The non-transitory computer-readable storage medium of claim 3, 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.

5. The non-transitory computer-readable storage medium as claimed in claim 1, wherein: The first instruction specifies the first operation to be undone; as well as The operation also includes: Based on the first instruction and the first and second operations performed by the application on different entities: Identify from the operation log the third operation performed on the first entity and the operation performed after the first operation on the first entity; as well as Perform the second undo operation to undo the third operation.

6. The non-transitory computer-readable storage 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 operation logs includes: In response to detecting the execution of each specific operation among the plurality of operations: Identify the specific entity among the plurality of entities to which the specific operation has been performed; as well as The specific operation is stored in the operation log corresponding to the specific entity among the multiple operation logs.

7. The non-transitory computer-readable storage 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 single operation log includes: In response to detecting the execution of each specific operation among the plurality of operations: Identify the specific entity among the plurality of entities to which the specific operation has been performed; as well as The specific operation, along with the identifier of the specific entity to which the specific operation was performed, is stored in a single operation log.

8. The non-transitory computer-readable storage medium of claim 1, wherein the operation further comprises: The application determines candidate operations to be performed by the application, wherein the candidate operations are not performed on any of the plurality of entities; as well as In response to determining that a candidate operation has not yet been executed on any of the plurality of entities, the candidate operation is avoided from being recorded in the same manner as the plurality of operations.

9. The non-transitory computer-readable storage medium of claim 1, wherein the plurality of entities correspond to a plurality of chapters of the same file.

10. The non-transitory computer-readable storage medium of claim 1, wherein the plurality of entities correspond to a plurality of files modified using the same application.

11. A method comprising: The application records multiple operations performed by the application, said multiple operations being performed on at least one of a plurality of entities, said multiple operations including: The first operation performed by the application on the first entity among multiple entities; and A second operation performed by the application on a second entity among the plurality of entities, wherein the second operation is performed after the first operation; The first and second operations are recorded in the same operation log by the application in the order of their operation time; The application receives a first instruction, which specifies a first entity and includes a command to perform a first undo operation associated with the first entity; and The first instruction specifies a first entity and includes a command to perform a first undo operation related to the first entity: Search for the most recently performed operation on the first entity in the set of log entries in the operation log that include operations performed on the first entity and the second entity in chronological order of the operation; Identify the first operation stored in the operation log associated with the first entity for performing the first undo operation; and Perform a first undo operation to cancel the first operation, but do not undo the second operation that was performed after the first operation. The method is performed by at least one device including a hardware computer processor.

12. The method of claim 11, wherein the first operation and the second operation are recorded by the application in different stacks of the same operation log.

13. The method of claim 11, wherein: Before recording the first operation, the application receives a first command to execute the first operation via a first interface, wherein the application executes the first operation in response to the first command; and Before recording the second operation, the application receives a second command to perform the second operation via the same first interface, wherein the application performs the second operation in response to the second command.

14. The method of claim 13, 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.

15. The method of claim 11, wherein: The first instruction specifies the first operation to be undone; as well as The operation also includes: Based on the first instruction and the first and second operations performed by the application on different entities: Identify from the operation log the third operation performed on the first entity and the operation performed after the first operation on the first entity; as well as Perform the second undo operation to undo the third operation.

16. The method of claim 11, wherein the application maintains a plurality of operation logs respectively associated with the plurality of entities, and wherein maintaining the plurality of operation logs includes: In response to detecting the execution of each specific operation among the plurality of operations: Identify the specific entity among the plurality of entities to which the specific operation has been performed; as well as The specific operation is stored in the operation log corresponding to the specific entity among the multiple operation logs.

17. The method of claim 11, wherein the application maintains a single operation log to store operations performed on any of the plurality of entities, wherein maintaining the single operation log includes: In response to detecting the execution of each specific operation among the plurality of operations: Identify the specific entity among the plurality of entities to which the specific operation has been performed; as well as The specific operation, along with the identifier of the specific entity to which the specific operation was performed, is stored in a single operation log.

18. The method of claim 11, wherein the operation further comprises: The application determines candidate operations to be performed by the application, wherein the candidate operations are not performed on any of the plurality of entities; as well as In response to determining that a candidate operation has not yet been executed on any of the plurality of entities, the candidate operation is avoided from being recorded in the same manner as the plurality of operations.

19. The method of claim 11, wherein the plurality of entities correspond to a plurality of chapters of the same document.

20. The method of claim 11, wherein the plurality of entities correspond to a plurality of files modified using the same application.

21. A system comprising: Hardware processor; and A non-transitory computer-readable storage medium includes program instructions that, when executed by a hardware processor, cause operations to be performed, the operations including: The application records multiple operations performed by the application, said multiple operations being performed on at least one of a plurality of entities, said multiple operations including: The first operation performed by the application on the first entity among multiple entities; and A second operation performed by the application on a second entity among the plurality of entities, wherein the second operation is performed after the first operation; The first and second operations are recorded in the same operation log by the application in the order of their operation time; The application receives a first instruction, which specifies a first entity and includes a command to perform a first undo operation associated with the first entity; and The first instruction specifies a first entity and includes a command to perform a first undo operation related to the first entity: Search for the most recently performed operation on the first entity in the set of log entries in the operation log that include operations performed on the first entity and the second entity in chronological order of the operation; Identify the first operation stored in the operation log associated with the first entity for performing the first undo operation; and Perform a first undo operation to undo the first operation, but do not undo the second operation that was performed after the first operation.

22. The system of claim 21, wherein the first operation and the second operation are recorded by the application in different stacks of the same operation log.

23. The system of claim 21, wherein: Before recording the first operation, the application receives a first command to execute the first operation via a first interface, wherein the application executes the first operation in response to the first command; and Before recording the second operation, the application receives a second command to perform the second operation via the same first interface, wherein the application performs the second operation in response to the second command.

24. The system of claim 23, 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.

25. The system of claim 21, wherein: The first instruction specifies the first operation to be undone; as well as The operation also includes: Based on the first instruction and the first and second operations performed by the application on different entities: Identify from the operation log the third operation performed on the first entity and the operation performed after the first operation on the first entity; as well as Perform the second undo operation to undo the third operation.

26. The system of claim 21, wherein the application maintains a plurality of operation logs respectively associated with the plurality of entities, and wherein maintaining the plurality of operation logs includes: In response to detecting the execution of each specific operation among the plurality of operations: Identify the specific entity among the plurality of entities to which the specific operation has been performed; as well as The specific operation is stored in the operation log corresponding to the specific entity among the multiple operation logs.

27. The system of claim 21, wherein the application maintains a single operation log to store operations performed on any of the plurality of entities, wherein maintaining the single operation log includes: In response to detecting the execution of each specific operation among the plurality of operations: Identify the specific entity among the plurality of entities to which the specific operation has been performed; as well as The specific operation, along with the identifier of the specific entity to which the specific operation was performed, is stored in a single operation log.

28. The system of claim 21, wherein the operation further comprises: The application determines candidate operations to be performed by the application, wherein the candidate operations are not performed on any of the plurality of entities; as well as In response to determining that a candidate operation has not yet been executed on any of the plurality of entities, the candidate operation is avoided from being recorded in the same manner as the plurality of operations.

29. The system of claim 21, wherein the plurality of entities correspond to a plurality of chapters of the same document.

30. The system of claim 21, wherein the plurality of entities correspond to a plurality of files modified using the same application.

Images