Patent Publication Number: US-6912692-B1

Title: Copying a sequence of commands to a macro

Description:
BACKGROUND 
   This invention relates to computer application macros. 
   Most computer applications have macro generators for producing macros for user-definable lists of actions or commands to apply to a data file associated with the application program. Often a user makes changes to a data file and then desires to repeat those changes on subsequent data files. One approach to repeating changes made to a data file is to have the user remember the changes and use the macro generator to produce a macro file with the actions to be applied to the data file. 
   SUMMARY 
   According to one aspect of the invention, a method of producing a macro file for use in an application program includes storing commands, applied to a data file opened in the application program, into a log file and transferring at least one stored command from the log file to a macro file. 
   The transferring can copy or move the action. The log file can be represented as a history palette that stores commands. The history palette can have associated with each command is a command icon that can be dragged from the palette. When the commands are transferred, they can be transferred to an action palette that builds the macro file. The actions can be transfered by dragging icons representing the commands to the action palette. 
   According to another aspect of the invention, a computer program product residing on a computer readable medium for use in an application program including instructions for causing a computer to store commands applied to a data file opening in the application program, into a log file and transfer at least one stored command from the log file to a macro file. 
   One or more advantages are provided from the above embodiments of the inventio. For example, a user can apply a sequence of commands to a data file. Thereafter, the user may decide to make those commands into a macro. The user can retrieve all or selected ones of the actions and place them into a macro generator such as an action palette and produce a macro file. The commands can be saved with the information needed to produce a macro. Therefore, rather, than exclusively using a conventional macro generator, the user can select commands from a log file i.e., history palette by dragging the selected actions to the macro file in the action palette or other macro generator. There is no need for the user to try and recreate the commands applied to a data file since the commands are stored in the history palette or log file in such a manner that they can later be applied by the user to a macro. 

   
     BRIEF DESCRIPTION OF THE DRAWINGS 
       FIG. 1  is a block diagram of a network computer system in a heterogeneous environment; 
       FIG. 2  is a flow chart of a macro generation process; 
       FIG. 3  is a flow chart showing details of the process of  FIG. 2 ; 
       FIG. 4  is a flow chart showing a process to use a macro produced in conjunction with  FIG. 2 ; 
       FIG. 5  is a flow chart showing details of the process of  FIG. 4 ; 
       FIG. 6  is a flow chart showing details of the process of  FIG. 4 ; 
       FIG. 7  is a flow chart showing details of a process used to edit a macro produced in accordance with  FIG. 2 ; 
       FIGS. 8A-8B  are flow charts showing execution of a macro in heterogeneous environments; 
       FIG. 9  is a data structure representing the macro; 
       FIG. 10  is a diagram of a computer desktop including a dialog box; 
       FIG. 11  is a diagram of a computer desktop having a macro file icon and data files; 
       FIG. 12  is block diagram of a computer system; 
       FIGS. 13-16  are diagrams of windows useful in understanding the processes of  FIGS. 13 and 14 ; 
       FIG. 17  is a flow chart of a process to store commands; and 
       FIG. 18  is a flow chart of a process to generate a macro. 
   

   DETAILED DESCRIPTION 
   Referring now to  FIG. 1 , a networked computer system  10  includes a first computer system  11  including a processor  12 , a main memory  14 , display  18 , storage adapter  20  and network adapter  24  coupled via a computer system bus  16 . The storage adapter  23  couples a storage device  22  such as a hard disk drive to the system bus  16 . 
   The first computer system  11  is coupled to a second remote computer system  31  via a link such as network adapters  24  and  34  and network  28 . Remote computer system  31  (e.g., a server for system  11 ) includes a processor  32 , main memory  34 , and storage adapter  35  coupled via a computer system bus  36 . The storage adapter  35  couples a disk drive  37  to the system bus  36 . 
   Computer system  11  can operate under a first operating system such as a windows-type operating system (e.g. Windows 3.1® Windows95®, Windows NT® (Microsoft Corporation, Redmond, Wash.); whereas, computer system  31  can operate under a different windows-type operating system, e.g., Windows95® or a different operating system such as the Macintosh® (Apple Computer, Inc.) operating system or an operating system such as Unix® (The Open Group). 
   Residing on disk drive  22  is a desktop folder  22   a . The desktop folder  22   a  includes a macro file  19  associated with an application program  22   b . The desktop folder  22   a  can include a plurality of files that in conjunction with a computer operating system (not shown) renders a plurality of icons on the computer display  18  such as icon  19 ′. Such icons can be selected by a user to execute application programs (e.g., application program  22   b ) on the computer system  11 . The application program  22   b  also includes one or a plurality of data files  21  that were produced with the application program  22   b . A data file  21  is typically a file generated by a user executing an application program and is any file that the application program  22   b  can understand. The computer disk drive  22  has a second copy of the macro file  19  stored in a second folder  22   c . Folder  22   c  is a general folder in the file system of the operating system (not shown). A folder is a user interface that often corresponds to a directory structure element in the file system. Residing on the disk drive  37  in remote system  31  is a third instance of the macro  19 . 
   As illustrated, a rendition of a desktop  18 ′ is provided on display  18  during operation of the computer system  11 . The desktop rendition  18 ′ includes a plurality of icons (only one of which is shown) that correspond to application programs which can be executed by a user. One of these icons is a macro icon  19 ′ that corresponds to one of the instantiations of the macro file  19 . Three instantiations of macro  19  are illustrated to show that the macro file  19  can be stored in various locations (e.g., within a local folder  22   c  of the computer system  11 , within the desktop folder  22   a  of the computer system  11 , or remotely stored in a folder  37   a . Only one of those instantiations would be associated with icon  19 ′. 
   The user produces a sequence of actions within an application program and stores the sequence of actions as an executable macro file  19 . The icon  19 ′ corresponding to the executable macro file  19  is placed on the desktop  18 ′. The macro file  19  includes an executable macro (e.g., the packaged list of actions) and sufficient executable information to invoke the original application so that when activated, the macro file  19  is executed in the invoked application program and extracts the list of actions and applies the macro, i.e., list of actions to the data file  21 . 
   The icon  19  takes advantage of the so-called drag and drop feature common in window-type operating systems. Therefore, the user can drag any number of data files  21  to the macro icon  19 ′ and the macro file  19  includes a sequence of operations to call a host application that can apply the actions in the macro to each of the data files  21 . 
   Referring now to  FIG. 2 , a process  40  in the application program  22   b  for producing macro file  19  includes producing  42  a macro list of actions in which a user selects the series of actions to apply to a data file. The user can select the action from a list of known actions to produce the macro file  19 . The list of actions can be presented in a palette, for example, or other type of macro generator depending on the application program  22   b . The user can transfer  44  this macro file (or a pointer to the macro file, e.g., a Windows95 shortcut) to a destination that is outside of the memory address space of the application. 
   Referring now to  FIG. 3 , the process  42  for producing the macro file  19  includes producing  50  the list of actions within the application. Within the application program, the list of actions are packaged  52  into an executable file. Executable configuration information is also added  54  to the macro file  19 . The application configuration information includes application code that enables the macro file  19  to invoke or call the original application program that produced the macro. Thus, for example, this type of application configuration information would typically include code such as OLE® (Object Linking and Embedding Microsoft Corp.) type code for Windows® based applications or DDE® (Dynamic Data Exchange, Microsoft Corp.) Apple Events®, for Macintosh operating systems (Apple Computer, Inc.) or CORBA (common object request broker architecture) for Unix® operating systems. 
   In one embodiment, the process  50  inserts  54  configuration code for each operating system environment that the macro can run under. Thus, for example, the macro file  19  can include configuration information for Windows95® operating system and a separate set for another operating system such as Macintosh® or Unix®. Typical combinations include Windows® and Macintosh, and Unix and Macintosh. 
   Referring now to  FIG. 4 , the process  44  for executing the macro includes transferring  46  data files  21  onto the macro file  19 . The action of transferring an application file  21  invokes  48  the host application to execute the macro file and apply the actions to the application file  21 . Transferring  46  application files onto the macro file  19  could involve a process such as dragging icons (not shown) representing the files  21 , and dropping the icons onto the folder containing the macro file  19  or dropping the icons representing the files  21  directly onto the macro file  19 . Alternatively, if the macro file  19  is represented as the icon  19 ′ on the desktop  18 ′, the icons representing the application files can be dropped onto the icon  19 ′. 
   Referring now to  FIG. 5 , the process for transferring the application files  46  includes preparing the application files by providing a string that identifies the file locations and prepares the list of actions. The file locations and list of actions are transferred to the host application in the host application call  64 . The icon  19 ′ has associated with it sufficient information to identify the location of the underlying executable file  19 . The underlying executable file  19  has sufficient information provided by insertion of the executable call to identify the name and location of the host application program associated with the macro file  19 . Therefore, the application program can be remotely stored in a different computing environment than that of computer system  11 . 
   Referring now to  FIG. 6 , the host application executes  48  the macro by retrieving  66  the files, applies  68  the actions obtained from the list of actions to the retrieve files and can store  70  the retrieved files that result from performing the actions. 
   Referring now to  FIG. 7 , a process  80  for editing the macro file  19  includes activating  82  the icon  19 ′ to call the host application and open  84  the macro file  19  in a macro editor in the host application. Activating the macro editor produces the list of actions included in the macro file  19 . The list of actions can be rendered on display  18 . The list is edited  88 , and the edited list is re-packaged  90  and is stored  92 . 
     FIGS. 8A and 8B  show a pair of sequences of operations to invoke an application program across a heterogeneous environment. The macro file  19  that is produced can run in any of a plurality of operating systems. Consider, for example, that the macro file  19  includes both Windows95 and Macintosh code. 
   Referring in particular to  FIG. 8A , application file  21  is shown dropped on macro  19 . The application file  21  is dropped from a Macintosh environment to a Windows environment. Macro file  19  includes Macintosh and Windows executable files. In a Macintosh environment, the file contains 680X0 configuration code in the resource fork and X86 configuration code in the data fork. 
   Data fork and resource fork are file structure conventions in the Macintosh operating system. When the file is moved from the Macintosh to Windows95 environment, the resource fork data is lost. The X86 configuration code remains in the data fork, however. To execute the file, the file is renamed at  102 . 
   Typically, the file is renamed by the user to insure that it has an “*.exe” extension. This extension is the extension that a Windows executable would typically require. The application program finds  104  the code that invokes the application in the data fork and executes  106  the macro file  19 . 
   Referring to  FIG. 8B , file  21  can also be dropped from a Windows environment onto a macro file  19  which is in a Macintosh operating system environment. In the Windows environment, the file only contains the X86 configuration code in the data fork. To move to the Macintosh environment, the process executes  110  the host application and opens  112  the macro in the host application. The host application will detect that the resource fork data is missing and regenerate the Macintosh configuration code and store the code in the resource fork. Thereafter, the host application will store  116  the code and execute  118  the macro. 
   Referring now to  FIG. 9 , the data structure  20  representing macro file  19  includes executable configuration code file  20   a  which stores the OLE or other remote application executable code. Dragging files onto the macro file  19  or icon  19 ′ executes the configuration code in file  19   a  as an operating system process. This code sets up the files  21  and invokes the host application. The data structure  20  also includes an optional check value field  20   b . The check value field  20   b  can be used to test the integrity of the data structure  20 . The check value field  20   b  is populated with a value that is checked prior to execution. The data structure  20  includes a third field  20   c  corresponding to the executable name of the host application. The data structure  20  also includes a script field  20   d  which, when executed, recreates the macro list of operations. One preferred way of implementing the script field  20   d  is to use a Java® (Sun Microsystems) script program to recreate the list of operations. The data structure  20  also includes an application creator code field  20   e  that is used for Macintosh type applications (i.e., storing Apple Events® code) and is the second operating system equivalent to the executable file field  20   a . The data structure  20  may include a second, on time check value field  20   f  again having a value that is checked prior to execution. The data structure  20  includes a pointer  20   g  which points to the end of the executable file  20   a . This identifies to the data structure  20  where the data structure  20  actually starts. 
   Referring now to  FIG. 10 , the computer desktop  18 ′ has a dialog box  130  opened. The dialog box  130  includes a plurality of tabs  132   a - 132   c  having different functions such as “optimze”, “info” and “move options”. In particular, the dialog box  130  includes an icon  134  that is associated with the macro file  19  opened in the application program  22   a . The icon  134  can be dragged from the dialog box  130  and placed on the computer desktop  18 ′. As a result of dragging the icon  134 , the macro file  19  is automatically stored in the desktop folder  22   a  and automatically assigned a name. 
   Referring now to  FIG. 11 , the computer desktop  18 ′ is shown as having the dragged icon  18 ″ (provided from dragging icon  134 ) and three data files  142   a - 142   c . The three data files can be dragged to the icon  18 ″ causing the actions in the macro file  19  associated with the icon  18 ″ to be applied to the data files  142   a - 142   c.    
   Alternatively, the macro file  19  can be moved to the computer desktop or elsewhere in the computer system  11  by pushing the “create” button  136 . The create button  136  can have a second dialog box (not shown) appear having locations for a file name for the icon and a storage location for the icon. 
   Referring now to  FIG. 12 , a computer system  210  includes a processor  212 , a main memory  214 , display  218 , and storage adapter  220  all coupled together via a computer system bus  216 . The storage adapter  220  couples a storage device  230  such as a hard disk drive to the system bus  216 . Computer system  210  operates under an operating system and includes an application program  232  shown on disk drive  230  having associated therewith a macro file  19 . 
   The application program  230  includes a log file such as a history palette  236  that records commands that were executed by a user in modifying the state of a data file  238  associated with the application program  22   a . This history palette  236 , therefore, has a list of all commands generally in the sequence issued by the user that when executed or reversed will modify the state of the data file  238 . The application can also include a macro generator such as an action palette  239  that contains a list of macros that can be applied to a data file. The action palette can be used to record macros and save them in a macro file for later use in the application. 
   Referring to  FIG. 13 , a window  250  is shown in various stages of use. The window  250  has a tool palette  252 , user work space  254 , history palette  256  to store and display actions or commands applied to a data file (not shown), as defined by the user in the work space  254 , and an action palette used to produce macros. The history palette  256  displays the commands  256   a - 256   c  that were applied to the user work space  254 . The action palette has a button  258   a  for initiating a macro record mode. 
   Referring to  FIG. 14 , the window  250  has a dialog box  260  displayed with a record button  262 . Dialog box  260  is a new action (macro) box enabling a user to record a macro and name the macro. It is invoked by a user pressing the button  258   a  (FIG.  13 ). 
   Referring now to  FIG. 15 , the window depicts a stop button  258   b  on the action palette  258 . The assertion of the stop button immediately after the assertion of the record button  262  causes an empty macro file to be generated. Of course, the macro file can be generated to have some commands and additional commands can be added as will be described below. 
   Referring now to  FIG. 16 , the window  250  has the action palette populated with a new action  264  including new commands  264   a  and  264   b  provided by dragging icons  256   b ′ and  256   c ′ (corresponding to commands  256   b  and  256   c ) from the history palette  256 . Icon  256   a ′ is not dragged since a user does not wish to apply the corresponding command  256   a  to the macro. In the action palette  258 , arrows  266  are shown in an open, i.e., down position, so that the details of the commands can be depicted. 
   Referring now to  FIG. 17 , a process  270  for storing commands applied to a data file is shown. A user applies  272  commands to a data file that is opened in the application program  230 . These actions are stored  274  in a log such as the history palette  256  ( FIG. 13 ) which displays a list of the commands applied by the user. Macro information that would be needed to place these commands into a macro file is also stored  276 . 
   Referring now to  FIG. 18 , a process  280  to create a macro file is shown. This process can be used separately or in conjunction with the process described in conjunction with  FIGS. 1-11  above. The user can produce an empty macro file. This can be accomplished by launching the action palette (i.e., pressing button  258   a  ( FIG. 13 ) and pressing record  252  ( FIG. 14 ) and stop  258   b  (FIG.  16 ). Commands are placed  284  from the history palette  258  ( FIG. 13 ) into the empty macro file. These commands can be placed by dragging icons  256   a ′- 256   c ′ ( FIG. 17 ) from the history palette into the action palette or another file associated with a different type of macro generator. The process can be configured to have the action of dragging icons  256   a ′- 256   c ′ either move or copy the icons and hence the underlying commands from the history palette to the action palette. The process  280  retrieves  286 , and adds  287 , the macro data (such as macro data structure  20   FIG. 9 , for example) associated with the command that was placed in the empty macro file. The macro file is packaged and saved  288 . 
   Accordingly, a user can apply a sequence of commands to a data file and thereafter decide to make those commands into a macro by retrieving all or selected ones of the actions and placing them into the action palette producing macro file. Rather, than exclusively using a conventional macro generator, a user can select commands from the history palette by dragging selected actions to the macro file in the action palette or other macro generator. There is no need for the user to try and recreate the commands applied to a data file since the commands are stored in the history palette or log in such a manner that they can later be applied by the user to a macro. As above, the macro file can be represented by a macro icon  19 ′ and icons corresponding to data files can be dragged onto the icon  19 ′ enabling the icon  19 ′ to execute the macro operations defined therein and apply those actions to each one of the files as a batch operation. 
   Other embodiments are within the scope of the following claims.