US 20050210445 A1
Methods and systems are disclosed for updating a candidate computer program file. An exemplary method includes loading a first and second revisions of a first computer program file, loading a first revision of a second computer program file, and generating a candidate computer program file. References are made to the first and second revisions of the first computer program file and the first revision of the second computer program file in generating the candidate computer program file.
1. A method for updating a candidate computer program file comprising the steps:
loading first and second revisions of a first computer program file;
loading a first revision of a second computer program file; and
generating said candidate computer program file by making reference to said first and second revisions of said first computer program file and said first revision of said second computer program file.
2. The method of
said first and second revision of said first computer program file are associated with a first and second revision of a computer program file expressed in a first natural language;
said first revision of said second computer program file is associated with a first revision of a computer program file expressed in a second natural language; and
said candidate computer program is associated with a second revision of said second computer program file expressed in said second natural language.
3. A computer system for updating a candidate computer program file comprising:
loading means for loading first and second revisions of a first computer program file;
said loading means also loading a first revision of a second computer program file; and
an editor for generating said candidate computer program file by making reference to said first and second revisions of said first computer program file and said first revision of said second computer program file.
4. The computer system of
said first and second revision of a first computer program file are associated with a first and second revision of a computer program file expressed in a first natural language;
said first revision of said second computer program file is associated with a first revision of a computer program file expressed in a second natural language; and
said candidate computer program is associated with a second revision of said second computer program file expressed in said second natural language.
This disclosure is a divisional of application Ser. No. 10/260,036, filed on Oct. 4, 1999, which is a continuation of application Ser. No. 08/644,413, filed on May 10, 1996 (now abandoned).
The present invention relates generally to graphical user interfaces for computer systems. More particularly, the present invention relates to methods and systems for creating and editing program code which governs the presentation of user guidance information.
The rapid advance of computer technology has enabled programmers to greatly enhance the sophistication of their software programs. Yet an increase in sophistication often brings an increase in application complexity. Such complexity often serves to confuse and frustrate computer users as they attempt to learn a new computer application, especially when the software manuals are large and burdensome to use.
The computer industry has attempted to address the above drawback by designing application programs with user-friendly display interfaces. Generally, the user-friendly paradigm aims to present information in the simplest and most intuitive fashion possible. This may be achieved by organizing information using a series of hierarchical menus or windows. Also, user-friendliness is promoted by including graphical metaphors in the display interface instead of nondescriptive command-line prompts. For example, object-oriented display systems frequently employ images of file folders for storage of information, and graphical depictions of trash containers for disposal (e.g. deletion) of information.
Another way of assisting an unfamiliar operator in using a computer application has been through user guidance interfaces (e.g. “help” interfaces). Such interfaces allow a user to quickly obtain help when unsure how to proceed at a particular juncture in the execution of a program. For example, a user can activate a help icon or menu entry when confused. The system may surmise the user's problem depending on the particular point in the program at which the user has activated the help function. Alternatively, the user may focus his inquiry by placing a cursor over an icon, menu, file folder or display object, whereupon the system responds by displaying an explanation of the selected display object. Still more focused guidance can be obtained by tailoring different help messages to different users. For instance, an expert at a particular application might prefer not to be bothered with a lengthy user guidance message. As such, only a cursory explanation is provided to the expert user. In contrast, a novice user might require a relatively large amount of information to successfully navigate through the application program. Accordingly, the help message given to the novice user may be quite lengthy.
While the above user-interface techniques have greatly enhanced the enjoyment and ease of using complex application programs, developing intricate guidance files for each application has proven very time consuming and burdensome. For example, the guidance files for the Apple family of computers relies on the generation of script files. “Script” is textual high-level program code, usually developed using a word processor or special script editor. User guidance information is often highly repetitive; one program module may employ virtually the same messages as another program module. Hence, the program designer has been forced to tediously duplicate the same script for each separate module. Even when “cut” and “paste” editing commands are employed, the task of creating script is still burdensome.
Further, translating and compiling the word processor's script language takes a considerable amount of time. It is especially cumbersome to re-translate the entire source file every time a revision is made in the source program. This difficulty is compounded by the fact that the translators and compilers sometimes produce errors. According to known techniques, the occurrence of an error typically causes the user to recompile the entire source file.
Accordingly, it would be desirable to produce a graphical interface which is user-friendly to the program designer as well as the end user.
It is more particularly an exemplary object of the present invention to provide an editor of guidance information which relies less on the manual creation and translation of textual script.
These and other exemplary advantageous features are achieved through a graphical editor for creating user guidance programs. The editor employs a database of user guidance program modules, each of which is associated with a component of a guidance display program. The editor allows the user to create and edit user guidance programs by selecting and aggregating different computer program modules. In this manner, the user is required to perform less editing on script text itself. In other words, the user can manipulate the program in units of program modules instead of individual lines of text script.
According to another exemplary aspect of the present invention, each user maintains a customized file of frequently used program modules. Each program module has a graphical icon associated therewith. The user creates a computer program sequence by selecting modules from a customized file and moving the modules to a sequence editor interface. At the sequence interface the user aggregates and arranges the modules to define the desired program function. The movement of modules from the customized file to the sequence editor may be via a “drag-and-drop” procedure.
According to another exemplary embodiment of the present invention, the sequence editor displays a program sequence by showing a graphical representation of the interconnected program modules. The user can edit individual program modules within the above described sequence of program modules by “clicking” on one of the program modules. This invokes a separate editor which displays the contents of the program module. The user can then edit the displayed program module using the separate editor interface. The separate editor may comprise a text editor for modifying the text of a program module, a panel or access editor for editing the graphical layout of panels used in the delivery of help information, and an index editor for editing words and phrases used to access guidance information relating to a particular topic.
The different editors allow the user to review a script program in a variety of different representations. If a user makes modifications to the script program in a particular representation, the system may automatically make corresponding changes in other representations. For example, if a user alters the script program using the graphical representation employed by the sequence editor, the system will make corresponding changes to the individual lines of script code, which may be reviewed using a text editor. In one embodiment, both graphical and textual representations may be presented simultaneously on the graphics display. This allows the user to review, in real-time, how changes made in the sequence editor affect the text of the script program.
When the user is finished editing the computer program, the user closes out the editor(s), whereupon the system compiles any portion of the computer program which was modified. According to another beneficial aspect of the present invention, any errors detected in the compiling operation are stored in association with a graphical icon. Clicking on this icon after the end of compilation provides a display of the erroneous text, whereupon the user may make corrections and recompile the corrected code.
The graphical editors of the present invention are designed to accept program code in parse tree code format, and to output information in the same parse tree format.
The foregoing, and other, objects, features and advantages of the present invention will be more readily understood upon reading the following detailed description in conjunction with the drawings in which:
FIGS. 31A-C illustrate the display of a script file in both textual and graphical representations during an editing sequence.
In the following description, for purposes of explanation and not limitation, specific details are set forth in order to provide a thorough understanding of the invention. However it will be apparent to one of ordinary skill in the art that the present invention may be practiced in other embodiments that depart from these specific details. In other instances, detailed descriptions of well-known methods, devices, and circuits are omitted so as not to obscure the description of the present invention with unnecessary detail.
The computer controlled editor of the present invention may be implemented by the exemplary computer system illustrated in
The CPU (16), in conjunction with program instructions received from memories (4), (8) and/or (20), presents information on the display (26) using the well known window-based display paradigm.
The Macintosh® series of computers sold by Apple Computer, Inc. may be used to implement the above functions. However, it should be apparent that other commercially available computer systems may be used to carry out the present invention.
A. Guidance Interface
The advantageous features of the program editor of the present invention may be best appreciated by first discussing exemplary aspects of the guidance interface itself. One way of invoking the guidance interface of the present invention is through activation of an appropriate guidance related menu entry located in menu bar (32). For example, the menu bar (32) may include a pull down menu (51) including a menu entry entitled “help” associated with the guidance interface. “Clicking” on the “help” menu entry causes the generation of an access window (62) shown in
The access window (62) allows the operator to retrieve information using three different techniques: topic search, index search and “look for” search, each of which will be discussed below.
A.2 Topic Search
The topic search is activated by the user placing the cursor (52) over the “topics” icon (64) and depressing the mouse button (40). The system responds by calling a series of topic titles from memory (4) or CD-ROM (8) and displaying them in the topic area (72). A user may select one of the titles within region (72) by scrolling a sliding bar (70) either up or down until he or she reaches a desired topic. In the specific embodiment of
If the user finds an interrogatory which matches his own query, he places the cursor (52) over the relevant interrogatory, and presses mouse button (40). For instance, in
A.3 Index Search
The same information can be obtained by initially pressing the “index” icon (60) illustrated in
A.4 Look For Search
Still another way of getting the same information is through the “look for” icon (56). Clicking on the “Look For” icon will generate a search box (87), as shown in
A.5 Coach Marks
Returning now to
A.6 Internal Organization
Note from the preceding discussion that the panels relating to a specific query were presented in specific order, referred to herein as a “sequence”. For example, as shown in
The computer system preserves the interconnection between different panels by storing links to interrelated panels in a database (e.g. as stored in memories 4 and/or 8). The database may be conceptualized as having a plurality of component objects which are hierarchically ordered, as illustrated in
On a more global perspective, script files can be written which relate different sequences together. For example, the user guidance file, which consists of a great multitude of different sequence definitions, may be bound by a script file which describes the interrelationship between different sequences, and the manner for navigating from one sequence to another.
By way of simple illustration, consider the following script file:
More details regarding the guidance interface itself may be obtained from the following commonly assigned patents and patent applications, the disclosures of which are incorporated herein in their entirety: Patent Nos. 5,428,731; 5,469,540 and 5,488,685; Ser. No. 08/010,063 filed on Jan. 27, 1993 by Palmer et al. entitled “Method and Apparatus for Providing a Help Based Window System Using Multiple Methods”; Ser. No. 08/010,061 filed On Jan. 27, 1993 by Coleman et al. entitled “Method and Apparatus for Displaying and Scrolling Data in a Window-Based Graphic User Interface”; Ser. No. 08/056,367 filed on Apr. 30, 1993 by Brewer et al. entitled “Method and Apparatus for Generating and Displaying Visual Cues on a Graphics User Interface”.
B. Guidance Editor
The above described user guidance information is created using the editing and compiling system illustrated in
B. 1 Overview
As illustrated, editor (168) includes a plurality of interrelated editors. The editors include a command editor (172) for receiving and displaying a list of script file statements, a graphical sequence editor (176) for creating or modifying a sequence of interconnected guidance panels (and other objects); an access editor for creating or modifying an access window (e.g. such as window 62 in
A script file may be input to the editor (168) in several different ways. For instance, the user can create a new script file using a “New” command under a “File” pull down menu (not shown) in the menu bar (32) of
A script file which was created by a text editor must be converted to parse tree format before loading into the editor. To this end, the script file (138) is sent to a text converter (142) and decompiler (146) for conversion from text editor format to object-oriented parse tree format (to be described below). Once in parse tree code format, the file may be loaded into editor (168).
Once a source file has been properly loaded, the document appears in the command editor. The command editor (e.g.
The user may scroll through the list and choose a command which requires editing. For instance, the user may select a specific sequence entry in the script file by pointing to the sequence entry in the list. Double clicking on the sequence evokes the sequence editor (176).
Presuming a specific editor has been selected, the user then proceeds to perform editing. According to a particularly beneficial aspect of the present invention, all of the editors are interconnected and interrelated, such that the user can access any editor from any other editor. For instance, the user may start by invoking the sequence editor (176) which graphically lists a sequence of icons representing the components of a sequence. One or more of the components within the sequence may comprise panel icons representing panels in the sequence. By clicking on the panel icons a panel editor (184) is invoked. Furthermore, by “clicking” on a word in a text object in a panel in the panel editor, that word is added to the index for the current sequence.
The different editors allow the user to review a script program in a variety of different representations. If a user makes modifications to the script program in a particular representation, the system may automatically make corresponding changes in other representations. For example, if a user alters the script program using the graphical representation employed by the sequence editor, the system will make corresponding changes to the individual lines of script code, which may be reviewed using a text editor. In one embodiment, both graphical and textual representations may be presented simultaneously on the graphics display (using different windows, for instance). This allows the user to review, in real-time, how changes made in the sequence editor affect the text of the script program.
Once the user has finished editing or creating the guidance information file, the user closes out the relevant editor. The editor interface win then instruct the compiler (146) via connection (163) to recompile the information file, but only with respect to the portions that were amended. The recompiled portion is then added to the remainder of the parse tree file in a memory (150). If an error is detected during the recompiling process, the offending text is placed inside a file represented by a visual error indicator, such as a “bug” icon (240) of
If the user wishes to convert the parse tree file back to a text editor format (159), he may decompile the file using decompiler (154) and text converter (160). For instance, the user may desire to use the script file in an application that requires that the file be in a text editor format. More specifically, a document may be exported using an “Export” command contained within the “File” pull down menu (not shown) of menu bar (32).
B.2 Command Editor and the Parse Tree Format
The command editor serves as an initial gateway through which other editors may be accessed. The command editor, as illustrated in exemplary
To further facilitate review of the script file, the command editor can, at the request of the user (e.g. by appropriate menu selection) reorganize the information within the command window. The commands may be sorted, such that all of the <define sequences> are displayed first, followed by all of the <define panels>. This is illustrated in
As mentioned, once the editor (168) is closed, the script program which was modified is recompiled to parse code format. The conversion may be best understood with reference to
An exemplary parse tree is illustrated in
Furthermore, the internal format of the parse tree is tokenized. Strings that are repeated in the source are factored into a single string in a table. Occurrences of the string are replaced with token IDs which require less space.
B.2 Sequence Editor
The sequence editor allows the user to graphically define the relationship between the component objects of a particular guidance help sequence by stringing together a series of icons representing the components.
As illustrated in
The above listing of plug-ins is obviously exemplary in nature. It will be apparent to practitioners in the art that other types of plug-ins will be useful. In fact, the individual user may maintain a customized list of plug-ins providing the panels and script modules which he or she uses most often. This customized list may be associated with the sequence editor shortcuts folder icon (264) shown in
In operation, the user may string together a series of panels (e.g. 224, 228, etc) and script plug-in modules (e.g. 208, 212, etc.) using the graphical interface of the sequence editor. For example, if a pre-existing sequence is displayed, the user can add to the sequence by dragging icons from the sequence editor shortcut panel window (264) to the sequence of icons in the sequence editor. MoFe specifically, suppose that at the time the user started editing, only icons (196), (200), (204) and (208) were in place. At this time the rightmost icon (208) defining an “if” statement would include two “wires” emanating therefrom. To add to the sequence, the user may access the shortcut window (264) and drag desired icons (representing panels or short listings of script code) to the sequence editor screen. The user would then “drop” the icons onto the terminal ends of the “wires” emanating from the “if” statement.
According to particularly beneficial features of the present invention, the user may use the graphical sequence editor as a springboard to perform further editing on individual display plug-ins within the sequence. For instance, the sequence shown in
Alternatively, the sequence editor may interface with the index editor (to be discussed below) through appropriate menu command. This will evoke an index editor window (280 as shown in
B.3 Panel Editor
The panel editor allows the user to edit an existing panel using a series of three windows. As used herein, the term “panel” refers to a data set associated with a display presentation, an example of which is illustrated as panel (74) in
The second window is referred to as the “panel window”. An exemplary panel window (284) is illustrated in
Other display objects within the panel display may be edited in an analogous fashion. Double clicking a button brings up a window to edit the event associated with that button. Double clicking on a picture brings up a graphical object window. Dragging a graphical object from a graphical object window to a panel replaces the existing graphical object in the panel with the new graphical object from the object window. Similarly, dragging a coach mark from a coach mark object window to a panel attaches that coach mark to the panel.
If the panel happens to be a shared panel (as discussed above), then changes to the shared panel occur globally to all panels. The shared panel preferably has a different color in the window's title bar to remind the author that this is a shared panel. If the user is not certain whether a panel is shared, he may investigate this matter through the panel editor interface, which identifies shared objects.
Last, the third window in the panel editor interface provides for the editing of events associated with a panel (e.g. create a panel, show panel, close panel, etc.).
B.4 Access Editor
Clicking on any text object in the access window (320) allows the user to edit that object. Dragging a graphical object from the graphical object window to a graphical object in the access window replaces the existing graphical object with the new graphical object.
To reorder the sequences in the sequence list, the user may drag the sequence to the desired location. To reorder the headers in the sequence list, the user may drag the header to the desired location. To reorder the topics in the topic area list, the user may drag the topic area to the desired location.
To create a new sequence the author chooses a “New Sequence” menu entry (not shown) from the menu bar. A default sequence with one panel is then created, from which the user may then modify and build upon. To create a new header the author chooses a “New Header” menu entry (not shown) from the menu bar.
B.5 Index Editor
The index editor (312) allows the author to edit individual entries in the index of the guidance file. As shown in
To add an index term, the author selects a “New Index” menu item (not shown) from a menu bar. To edit a hidden name, the author clicks on the hidden name. The word “none” in italics indicates that there is no hidden name. To add a synonym, the author selects the index term and chooses a “New Synonym” menu item (not shown). To delete a hidden name, index or synonym, the author selects the term by clicking and then hits the delete key.
The user may associate an index term with a particular sequence by dragging an index term from an object window to the appropriate sequence in a sequence object window. Alternatively, the user may create the association by dragging the sequence term from its object window to the appropriate index term in its index object window.
By “clicking” on a word in a text object in a panel in the panel editor, that word is added to the index for the current sequence. If the author clicks on a selection of words, then that selection becomes an index entry. The author may also drag a text selection from a panel editor window to an index editor window, and the appropriate index terms will be created.
To view what sequences are connected to an index, the user may choose the “Related Objects” menu entry. A window (316) will appear listing the index entries which are associated with a main index, as shown in
The index editor can be used to generate index terms for every item in a sequence or database by using a “Generate Index” menu entry (not shown). In response to activating this command, the index editor will add an index term for every word in the sequence or database. The user may specify a stop word list which specifies words that are not to be included in the index. Words in the sequence are compared with words in the stop list, and not assigned an index term if they match a word in the stop list.
B.6 Localization Tool
A further beneficial feature of the present invention, although not illustrated in
In operation, the user may invoke the localization tool through the command editor interface (such as by clicking on a menu entry devoted to the localization tool). In response thereto, the CPU (16) generates the window illustrated in
The localization tool performs its comparison between U.S. and foreign files by matching statements which share the same IDs. As shown in
As a matter of practice, however, different situations will arise that make it difficult to determine what textual statement to use in the “new loc” window. For example, there may be a textual entry for a statement in the “new US” file, but not in the “old US” file. To cope with these problems, the present invention identifies various permutations which may occur between the three input documents (e.g. “old US”, “new US”, and “old loc”) and decides what information to include with the “new loc” database.
More specifically, the different permutations which may occur are identified with the table below:
Permutation 1 (e.g. event 1) represents the best case scenario. An object exists in both the new U.S. and old U.S. databases and has not changed at all. Also, a representation of that object exists in the old localized version of the file. In this situation, the old localized version is automatically copied to the new localized version of the file, as illustrated in
Permutation 2 represents the situation where an object has changed from the old U.S. to the new U.S. versions of the file, and the old localized version has a representation of the object. In this situation the old localized version is copied, and is flagged as a “wild guess” new localized version of the file. The user is informed that the localization tool is unsure about its decision by displaying “Wild Guess” above the window (336), as illustrated in
Permutation 3 represents the situation where an object is deleted from the database in the new U.S. file. That is, it is present in the old U.S. and the old localized versions of the file, but is not present in the new U.S. version. In this situation, nothing is copied to the new localized version.
Permutation 4 represents a situation where an object exists in the new U.S. version and in the old localized version, but not in the old U.S. version. In this case, the corresponding object in the old localized version is copied to the new localized version and is flagged as a “wild guess”.
Permutation 5 represents the situation where an object exists in the old localized version but is not present in either the new U.S. version or the old U.S. version. This object was presumably added by the localizer who generated the old localized version. In this situation nothing is copied to the new localized file.
Permutation 6 represents the situation where an object exits in the new U.S. version and in the old U.S. version, but not in the localized version. The two representations of the object are identical. In this situation the object in the new U.S. version is copied to the new localized version, and is flagged as “previously deleted”. This indicates that the object was deleted by the localizer before and probably will need to be deleted again when the localizer is adding finishing touches.
Permutation 7 is identical to permutation 6 except that the two representations of the object are not identical in the U.S. files. In this situation, the object in the new U.S. version is copied to the new localized version, and is flagged as “previously deleted”.
Permutation 8 represents the situation where an object exists only in the old U.S. version. Nothing is copied to the new localized version.
Permutation 9 represents the situation where a new object has been added and appears only in the new U.S. version. The object is copied to the new localized version and is flagged as “new”.
B.7 Recording Module
The recording module (192) preferably logs all of the revisions made in any of the other editors. For instance, suppose a French localizer has spent several hours converting the textual messages in a U.S. application guidance help file to their French counterpart. If the recording module is activated, it will track and log all of the modifications made by the French localizer. This information is stored as a script file which can be run to repeat the series of events during the French localizer's editing session.
Now assume that another localizer seeks to convert the U.S. file to another language, such as Spanish. The Spanish localizer may run a script file created by the French localizer, thereby automatically repeating the same operations performed by the French operator. This offers great potential in reducing the workload of the second Spanish localizer. The recording module may be implemented using an Apple Script recording module, as described in Inside Macintosh, by Apple Computer, Inc. However, it will be apparent that other commercially available recording modules may be used.
The attached appendix lists internal data structures to the user guidance editor interface. For instance, the data structures are used by panel editor and the sequence editor to manipulate script source.
The above-described exemplary embodiments are intended to be illustrative in all respects, rather than restrictive, of the present invention. Thus the present invention is capable of many variations in detailed implementation that can be derived from the description contained herein by a person skilled in the art. All such variations and modifications are considered to be within the scope and spirit of the present invention as defined by the following claims.
In particular, the present invention has been discussed in terms of help guidance information to facilitate discussion. However, it will be apparent to one having ordinary skill in the art that the principles disclosed herein are applicable to other programming and editing environments.