System and method for extending legacy application with undo/redo functionality

• US 8,732,677 B2
• Filed: 01/19/2012
• Issued: 05/20/2014
• Est. Priority Date: 09/28/2006
• Status: Active Grant

• Current Assignee: SAP SE
• Original Assignee: SAP AG (SAP SE)
• Inventors: Bohle, Holger
• Primary Examiner(s): Vu, Tuan A
• Application Number:
  US13/353,586
• Publication Number:
  US 20120167104A1
• Time in Patent Office: 852 Days
• Field of Search: 717/105, 717/124, 717/128, 717/135, 717/134, 715/764, 715/853, 715/863, 715/866, 709/205, 709/221, 709/246, 719/315, 719/320, 719/328, 707/999, 345/689, 714/38
• US Class Current: 717/134
• CPC Class Codes: G06F 8/36 Software reuse
• CPC Class Codes: G06F 8/38 for implementing user interfaces
• CPC Class Codes: G06F 8/65 Updates security arrangements therefor G06F21/57
• CPC Class Codes: G06F 8/70 Software maintenance or management

Abstract

In a system and method for recalling a state in an application, a processor may store in a memory data representing a first set of previously executed commands, the first set representing a current application state, and, for recalling a previously extant application state different than the current application state, the processor may modify the data to represent a second set of commands and may execute in sequence the second set of commands.

Claims

1. A method for providing an undo functionality, comprising:

maintaining a first action identification stack that includes a plurality of identifications that each identifies a respective one of a corresponding plurality of previously executed actions, wherein ;

(a) each of the identifications corresponding to a different one of the previously executed actions than all other of the identifications, (b) the identifications are stored in a sequence that corresponds to a sequence in which the previously executed actions were executed, (c) the plurality of previously executed actions include all actions previously executed for progressing from an initial state to a current application state, such that a first of the identifications corresponds to a first of the actions performed in the progression and the last of the identifications corresponds to a last of the actions performed in the progression, and (d) each of the plurality of previously executed actions is separately identified by a different one of the plurality of identifications; and

responding to user input of an undo command to obtain a prior application state instead of a current application state by;

removing, by a computer processor, one of the identifications of previously executed actions from the first action identification stack, wherein the one identification being removed corresponds to one user interface action previously performed and targeted to be undone in response to the user-input undo command;

subsequently traversing, by the processor and in sequence beginning with the first of the identifications, all of the identifications of the first action identification stack that remain after the removal of the one of the identifications; and

during the traversal, for each of the traversed identifications, re-executing, by the processor, the respective action identified by the respective traversed identification, thereby re-executing all of the actions of the progression from the initial state to the prior application state to be obtained, the re-execution (a) not including the action whose identification has been removed from the first action identification stack, and (b) effecting the prior application state;

wherein;

the undo command is input via a user interface of an intermediary application;

the traversal is performed by the processor executing the intermediary application to interact with a legacy application, that does not support the user input undo command, for performing the re-execution; and

the intermediary application intercepts results returned by the legacy application during the re-execution until the prior application state is obtained, at which point a result corresponding to the prior application state is output to the user.

2. The method of claim 1, wherein each of at least one of the identifications of the first action identification stack that identifies a respective one of the re-executed actions is mapped to a plurality of commands, and the re-execution of the action identified by a respective one of the at least one of the identifications includes re-executing the plurality of commands mapped to the respective action.

3. The method of claim 2, wherein the action whose identification has been removed from the first action identification stack is mapped to, and is performable by execution of, a respective plurality of commands which are not executed in the re-execution of the sequence of actions.

4. A method for providing a redo functionality, comprising:

storing in a memory an undo stack that includes identifications of previously executed actions;

storing in the memory a redo stack that includes identifications of previously executed actions that were reversed; and

responding to user input of a redo command to obtain a prior application state instead of a current application state by;

removing, by a computer processor, at least one latest-entered identification of the redo stack, wherein the at least one latest-entered identification being removed corresponds to at least one user interface action previously performed and reversed, and targeted to be redone in response to the user-input redo command;

adding, by the processor, the removed at least one latest-entered identification to the undo stack; and

subsequently re-executing, by the processor and in sequence, the actions identified by remaining identifications of the undo stack, the sequence of actions re-executed (a) including the at least one action whose at least one identification has been removed from the redo stack, and (b) effecting the prior application state.

5. A method for providing an undo functionality, comprising:

maintaining a first action identification stack that includes a plurality of identifications that each identifies a respective ones of a corresponding plurality of previously executed actions, wherein;

(a) each of the identifications corresponds to a different one of the previously executed actions than all others of the identifications, (b) the identifications are stored in a sequence that corresponds to a sequence in which the previously executed actions were executed, (c) the plurality of previously executed actions include all actions previously executed for progressing from an initial state to a current application state, such that a first of the identifications corresponds to a first of the actions performed in the progression and the last of the identifications corresponds to a last of the actions performed in the progression, and (d) each of the plurality of previously executed actions is separately identified by a different one of the plurality of identifications;

receiving a plurality of user-input undo commands to obtain a prior application state instead of the current application state; and

responding to the plurality of user-input undo commands collectively by;

subsequent to the receipt of all of the plurality of user-input undo commands, removing, by a computer processor and from the first action identification stack, identifications of a plurality of latest-entered ones of the previously executed actions, the number of removed identifications corresponding to a number of the plurality of user-input undo commands, wherein the identifications being removed correspond to a plurality of user interface actions previously performed and targeted to be undone in response to the plurality of user-input undo commands;

subsequent to the removing, traversing, by the processor and in sequence beginning with the first of the identifications, all of the identifications of the first action identification stack that remain after the removal of the identifications of the plurality of latest-entered ones of the previously executed actions; and

during the traversal, for each of the traversed identifications, re-executing, by the processor, the respective action identified by the respective traversed identification, thereby re-executing all of the actions of the progression from the initial state to the prior application state to be obtained;

wherein;

the re-execution (a) does not include re-execution of the actions whose identifications have been removed from the first action identification stack, and (b) effects the prior application state;

the traversal and re-execution is performed only once for all of the plurality of user-input undo commands;

the plurality of user-input undo commands are input via a user interface of an intermediary application;

the traversal is performed by the processor executing the intermediary application to interact with a legacy application, that does not support the plurality of user-input undo commands, for performing the re-execution; and

the intermediary application intercepts results returned by the legacy application during the re-execution until the prior application state is obtained, at which point a result corresponding to the prior application state is output to the user.

6. The method of claim 5, wherein, when the plurality of user-input undo commands, which are collectively responded to, are received, a plurality of user-input undo commands are also separately inputtable for responsively (a) separately removing respective ones of the identifications of the plurality of latest-entered ones of the previously executed actions are separately removable from the first action identification stack and (b) separately undoing respective ones of the plurality of user interface actions.

7. The method of claim 5, wherein the plurality of user-input undo commands are input by separately inputting each of the plurality of user-input undo commands via a separate respective input action, all of the input actions being performed in quick succession.

8. A method for providing an undo functionality, comprising:

maintaining a first action identification stack that includes identifications of previously executed actions;

providing a user interface that includes a first button for inputting a plurality of user-input undo commands and a second button for activating a response to the input of the plurality of user-input undo commands;

receiving the plurality of user-input undo commands to obtain a prior application state instead of a current application state; and

responding to the plurality of user-input undo commands collectively by;

subsequent to the receipt of the plurality of user-input undo commands, removing, by a computer processor and from the first action identification stack, identifications of a plurality of latest-entered ones of the previously executed actions, the number of removed identifications corresponding to a number of the plurality of user-input undo commands, wherein the identifications being removed correspond to a plurality of user interface actions previously performed and targeted to be undone in response to the plurality of user-input undo commands; and

subsequent to the removing, re-executing, by the processor and in sequence, the actions identified by remaining identifications of the first action identification stack, the re-execution being performed only once for all of the plurality of user-input undo commands, and the sequence of actions re-executed (a) not including the actions whose identifications have been removed from the first action identification stack, and (b) effecting the prior application state;

wherein;

the user interface that includes the first and second buttons is a user interface of an intermediary application;

the processor executes the intermediary application to traverse the first action identification stack, and accordingly interact with a legacy application, that does not support the user input undo command, for performing the re-execution; and

the intermediary application intercepts results returned by the legacy application during the re-execution until the prior application state is obtained, at which point a result corresponding to the prior application state is output to the user.

9. The method of claim 8, wherein none of said plurality of latest-entered ones of the previously executed actions were at any point executed in response to selection of the first button.

10. A method for providing an undo functionality, comprising:

maintaining a first action identification stack that includes identifications of previously executed actions;

receiving a user-input undo command to obtain a prior application state instead of a current application state; and

responding to the user-input undo command by;

subsequent to the receipt of the user-input undo command, removing, by a computer processor and from the first action identification stack, a number of identifications of a plurality of latest-entered ones of the previously executed actions, wherein the identifications being removed correspond to a plurality of user interface actions previously performed and targeted to be undone in response to the user-input undo command; and

subsequent to the removing, re-executing, by the processor and in sequence, the actions identified by remaining identifications of the first action identification stack, the re-execution being performed only once for the user-input undo command, and the sequence of actions re-executed (a) not including the actions whose identifications have been removed from the first action identification stack, and (b) effecting the prior application state;

wherein the user-input undo command is input by a user performing a combination of (i) inputting into a user interface field the number, and (ii) selecting a user interface undo button.

wherein;

the undo command is input via a user interface of an intermediary application;

the processor executes the intermediary application to traverse the first action identification stack, and accordingly interact with a legacy application, that does not support the user input undo command, for performing the re-execution; and

the intermediary application intercepts results returned by the legacy application during the re-execution until the prior application state is obtained, at which point a result corresponding to the prior application state is output to the user.

11. The method of claim 10, wherein the number of identifications removed for executing the user-input undo command is based on the input of the number into the user interface field.

12. A method for providing new interface functionality while providing interaction with a legacy application, the method comprising:

executing, by a processor, an intermediary application for receiving, via a first user interface of the intermediary application, a first user input;

responsive to the first user input, executing, by the processor, the intermediary application causing the processor to automatically interact with the legacy program without presentation of user interfaces of the legacy program to the user, the automatic interaction including performing a series of interactions, by the processor and in place of the user, with the legacy application, wherein each of the series of interactions includes providing a respective input to the legacy application;

for each of the series of interactions, responsive to the respective input of the interaction, executing, by the processor, the legacy application, thereby performing, via the execution of the legacy application, a data processing to produce a respective result data for output to a respective user interface of the legacy application, wherein, for each of a plurality of the series of interactions prior to the final interaction of the series of interactions, the legacy application is configured to output the respective result data to the respective user interface of the legacy application prior to execution of the remainder of the series of interactions; and

executing, by the processor, the intermediary application for;

intercepting the result data so that the result data is not displayed in the respective user interfaces of the legacy application, and such that none of the result data is displayed before completion of all of the series of interactions; and

after completion of the entire series of interactions, outputting a result based on the result data of the series of interactions in a second user interface of the intermediary application;

wherein;

the first user input is a command to undo an operation to obtain a prior application state;

the method further comprises maintaining a first action identification stack that includes a plurality of identifications that each identifies a respective one of a corresponding plurality of previously executed actions, wherein;

(a) each of the identifications corresponds to a different one of the previously executed actions than all others of the identifications, (b) the identifications are stored in a sequence that corresponds to a sequence in which the previously executed actions were executed, (c) the plurality of previously executed actions include all actions previously executed for progressing from an initial state to a current application state, such that a first of the identifications corresponds to a first of the actions performed in the progression and the last of the identifications corresponds to a last of the actions performed in the progression, and (d) each of the plurality of previously executed actions is separately identified by a different one of the plurality of identifications; and

the performance of the series of interactions in response to the command to undo an operation includes;

removing, by the processor, one of the identifications of previously executed actions from the first action identification stack;

subsequently traversing, by the processor and in sequence beginning with the first of the identifications, all of the identifications of the first action identification stack that remain after the removal of the one of the identifications; and

during the traversal, for each of the traversed identifications, causing re-execution, by the processor, of the respective action identified by the respective traversed identification, such that all of the actions of the progression from the initial state to the prior application state are obtained, the re-execution (a) not including the action whose identification has been removed from the first action identification stack, and (b) effecting the prior application state.

13. The method of claim 12, wherein the legacy application is configured to display the first user interface.

14. The method of claim 12, wherein the first user interface is a graphical user interface.