CA2256931A1 - Source editing in a graphical hierarchical environment - Google Patents
Source editing in a graphical hierarchical environment Download PDFInfo
- Publication number
- CA2256931A1 CA2256931A1 CA002256931A CA2256931A CA2256931A1 CA 2256931 A1 CA2256931 A1 CA 2256931A1 CA 002256931 A CA002256931 A CA 002256931A CA 2256931 A CA2256931 A CA 2256931A CA 2256931 A1 CA2256931 A1 CA 2256931A1
- Authority
- CA
- Canada
- Prior art keywords
- edit
- user
- control
- display
- source code
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/33—Intelligent editors
Abstract
This invention relates to a method for viewing, writing, and modifying source code in an integrated development environment (IDE). When source code is being edited in a graphical environment, windows in the development environment display the code structure of a project allowing for the visualization of the relationships between components of the project. This invention discloses a system and method that permits editing to be performed directly in the graphical environment where the code structure is being displayed. In the preferred embodiment, editing of the source is performed directly within the graphical environment where a hierarchical model of the code structure of a project at various levels (module, class, function, etc.) is displayed.
Description
SOURCE EDITING IN A GRAPHICAL HIERARCHICAL ENVIRONMENT
FIELD OF THE INVENTION
This invention relates to integrated development environments (IDES). This invention also relates to a method for editing source code in a graphical environment, where the interdependencies between components of a program are modeled and displayed in a graphical view.
In particular, this invention relates to a method for editing source code directly in the graphical view where the interdependencies between components of a program are modeled.
BACKGROUND OF THE INVENTION
Current integrated development environments (IDES) typically comprise separate windows or panes for the display of the code structure in a project, and for the editing of source files.
Typically, the window which displays the code structure in a project provides for a graphical, hierarchical model of the interdependencies between various components of the underlying program(s). For example, in certain object-oriented programming environments, the display may reveal which packages may be contained in a specific project, which classes or modules may be contained within such packages or projects, and which methods, functions, procedures, or other subroutines may be defined within those classes or modules. In some instances, the interactions between the various methods (functions, procedures, or other subroutines), namely, whether or not they call themselves or each other, may also be apparent from the graphical display.
In these environments, when it is necessary to read, write, or modify the source code for a particular component, a separate window will be created for this purpose. This window appears disjointed from the graphical model where the relationships between the various program components are being displayed. The user must utilize and separately examine each of the multiple windows, and navigate between them when performing an editing task. As a result, the modifications performed on the various components are not done within the context of the overall program structure.
United States patent No. 5,490,246 discloses a graphics editor which permits complex graphical images to be formed and edited. The graphics editor generates a graph with nodes that represent image fragments, image transformations, and outputs (viewable images). Each of these nodes can be displayed in a separate viewing window and may be modified.
Although the interdependencies of the various components are graphically displayed, the window displaying a component is not opened directly or positioned appropriately on the graph which models the relationships between the components. Furthermore, the invention is for editing graphic images and not for editing source code.
United States patent No. 5,642,475 discloses an apparatus and method for editing multiple graphic images displayed on a screen and correlated to each other. The invention relates to hierarchically structured graphics formed from other graphics, where changes in the view of one graphic may be performed in response to changes on another graphic which it relates to. This invention does not address the fact that the component windows are being displayed out of the context of the overall hierarchy, and further, the invention is for editing graphic images and not for editing source code.
European patent application EP 753814-A2 discloses a method and apparatus for analyzing source code to determine the dynamic properties of a program. In one embodiment of the invention, a flow graph may also be generated from the output of a source code analyzer.
This invention does not relate to the editing of source code, nor does it allow for such editing to occur in windows situated appropriately on the flow graph.
United States patent, No. 5,671,416 discloses an apparatus and method for searching through a parse tree of source code of a program, to allow for easier and more efficient debugging and modification of the program. Although this invention relates to the editing of source code, it does not provide a graphical, abstract view of the interdependencies of the components of the program, and further, does not allow for editing of the source code directly in that view.
It will be appreciated by those skilled in the art, that program comprehension will be enhanced where the interdependencies between various components of a program are made readily apparent. Furthermore, code maintenance and development can be made easier if the scope of desired changes can be readily determined during the editing process, by providing an interface that displays the source code of a program in a view where the interdependencies of the program components are displayed.
SUMMARY OF THE INVENTION
It is an object of the present invention to provide a system where modifications performed on various components of a computer program are done directly in the context of the overall program structure.
The invention provides for a system and method that allows for the view of the interdependencies of the components of a program to be combined with a view of the source code of the program in the visual interface of a programming environment.
According to one aspect of the invention, the interdependencies of the components of a program are displayed in a graph where the nodes of the graph represent sub-components of components of the program, and where the edges of the graph represent interdependencies between the sub-components displayed as nodes. The source code of a sub-component of a component of the program can be viewed and edited in a window that replaces the node in the graph that represents the sub-component.
Thus, the present invention is directed to a system for editing a computer program which comprises a plurality of source code components. The system includes a browser, a graphical layout control accessible to and invokable by the browser to display the relationships between said source code components as interconnected nodes, and an edit control accessible to the browser. The edit control has a plurality of edit views and edit windows. Each of the edit views corresponds to a portion (which could be the entirety) of one of said source code components and each of the edit windows provides a user interface to one of the source code components corresponding to an edit view, which enables the user to edit one of said source code components.
According to a further aspect, the present invention provides a method for editing a computer program which consists of the steps of displaying to a user a hierarchical relationship between source code components of the computer program in which each component is represented as a node, and repetitively providing means to allow the user to select one of the nodes for editing and replacing the selected node with an edit window displaying the source code component in order to permit the user to edit the source code component while viewing the hierarchical relationship.
In yet a further aspect, the present invention provides a system for editing a computer program having a browser, and a graphical layout control accessible to the browser. The graphical layout control May be invoked by the browser to provide a display of relationships between components of said computer program. The system also includes an edit control accessible to the browser. The edit control provides an interface to permit a user to select a component from within the display. An edit window containing the contents of the selected component is also provided.
This window replaces the selected component within the display, for the purpose of allowing the user to edit the contents of the selected component while viewing the display of relationships.
Media embodying program instructions for use in the execution in a computer to perform the invention described herein, is a further aspect of the invention.
BRIEF DESCRIPTION OF THE DRAWINGS
A preferred embodiment of the present invention will now be described, by way of example only, with reference to the accompanying drawings, in which:
Figure 1 is a screen capture illustrating a series of dependent nodes;
Figure 2 is a screen capture illustrating a series of dependent nodes with two nodes expanded;
Figure 3 is a screen capture illustrating a series of dependent nodes with four nodes expanded;
Figure 4 is a conceptual diagram of the components of the present invention;
Figure 5 is a flow diagram illustrating how the components of a program are displayed by the present invention; and Figure 6 is a flow diagram illustrating the steps in a typical operational scenario of the present invention.
FIELD OF THE INVENTION
This invention relates to integrated development environments (IDES). This invention also relates to a method for editing source code in a graphical environment, where the interdependencies between components of a program are modeled and displayed in a graphical view.
In particular, this invention relates to a method for editing source code directly in the graphical view where the interdependencies between components of a program are modeled.
BACKGROUND OF THE INVENTION
Current integrated development environments (IDES) typically comprise separate windows or panes for the display of the code structure in a project, and for the editing of source files.
Typically, the window which displays the code structure in a project provides for a graphical, hierarchical model of the interdependencies between various components of the underlying program(s). For example, in certain object-oriented programming environments, the display may reveal which packages may be contained in a specific project, which classes or modules may be contained within such packages or projects, and which methods, functions, procedures, or other subroutines may be defined within those classes or modules. In some instances, the interactions between the various methods (functions, procedures, or other subroutines), namely, whether or not they call themselves or each other, may also be apparent from the graphical display.
In these environments, when it is necessary to read, write, or modify the source code for a particular component, a separate window will be created for this purpose. This window appears disjointed from the graphical model where the relationships between the various program components are being displayed. The user must utilize and separately examine each of the multiple windows, and navigate between them when performing an editing task. As a result, the modifications performed on the various components are not done within the context of the overall program structure.
United States patent No. 5,490,246 discloses a graphics editor which permits complex graphical images to be formed and edited. The graphics editor generates a graph with nodes that represent image fragments, image transformations, and outputs (viewable images). Each of these nodes can be displayed in a separate viewing window and may be modified.
Although the interdependencies of the various components are graphically displayed, the window displaying a component is not opened directly or positioned appropriately on the graph which models the relationships between the components. Furthermore, the invention is for editing graphic images and not for editing source code.
United States patent No. 5,642,475 discloses an apparatus and method for editing multiple graphic images displayed on a screen and correlated to each other. The invention relates to hierarchically structured graphics formed from other graphics, where changes in the view of one graphic may be performed in response to changes on another graphic which it relates to. This invention does not address the fact that the component windows are being displayed out of the context of the overall hierarchy, and further, the invention is for editing graphic images and not for editing source code.
European patent application EP 753814-A2 discloses a method and apparatus for analyzing source code to determine the dynamic properties of a program. In one embodiment of the invention, a flow graph may also be generated from the output of a source code analyzer.
This invention does not relate to the editing of source code, nor does it allow for such editing to occur in windows situated appropriately on the flow graph.
United States patent, No. 5,671,416 discloses an apparatus and method for searching through a parse tree of source code of a program, to allow for easier and more efficient debugging and modification of the program. Although this invention relates to the editing of source code, it does not provide a graphical, abstract view of the interdependencies of the components of the program, and further, does not allow for editing of the source code directly in that view.
It will be appreciated by those skilled in the art, that program comprehension will be enhanced where the interdependencies between various components of a program are made readily apparent. Furthermore, code maintenance and development can be made easier if the scope of desired changes can be readily determined during the editing process, by providing an interface that displays the source code of a program in a view where the interdependencies of the program components are displayed.
SUMMARY OF THE INVENTION
It is an object of the present invention to provide a system where modifications performed on various components of a computer program are done directly in the context of the overall program structure.
The invention provides for a system and method that allows for the view of the interdependencies of the components of a program to be combined with a view of the source code of the program in the visual interface of a programming environment.
According to one aspect of the invention, the interdependencies of the components of a program are displayed in a graph where the nodes of the graph represent sub-components of components of the program, and where the edges of the graph represent interdependencies between the sub-components displayed as nodes. The source code of a sub-component of a component of the program can be viewed and edited in a window that replaces the node in the graph that represents the sub-component.
Thus, the present invention is directed to a system for editing a computer program which comprises a plurality of source code components. The system includes a browser, a graphical layout control accessible to and invokable by the browser to display the relationships between said source code components as interconnected nodes, and an edit control accessible to the browser. The edit control has a plurality of edit views and edit windows. Each of the edit views corresponds to a portion (which could be the entirety) of one of said source code components and each of the edit windows provides a user interface to one of the source code components corresponding to an edit view, which enables the user to edit one of said source code components.
According to a further aspect, the present invention provides a method for editing a computer program which consists of the steps of displaying to a user a hierarchical relationship between source code components of the computer program in which each component is represented as a node, and repetitively providing means to allow the user to select one of the nodes for editing and replacing the selected node with an edit window displaying the source code component in order to permit the user to edit the source code component while viewing the hierarchical relationship.
In yet a further aspect, the present invention provides a system for editing a computer program having a browser, and a graphical layout control accessible to the browser. The graphical layout control May be invoked by the browser to provide a display of relationships between components of said computer program. The system also includes an edit control accessible to the browser. The edit control provides an interface to permit a user to select a component from within the display. An edit window containing the contents of the selected component is also provided.
This window replaces the selected component within the display, for the purpose of allowing the user to edit the contents of the selected component while viewing the display of relationships.
Media embodying program instructions for use in the execution in a computer to perform the invention described herein, is a further aspect of the invention.
BRIEF DESCRIPTION OF THE DRAWINGS
A preferred embodiment of the present invention will now be described, by way of example only, with reference to the accompanying drawings, in which:
Figure 1 is a screen capture illustrating a series of dependent nodes;
Figure 2 is a screen capture illustrating a series of dependent nodes with two nodes expanded;
Figure 3 is a screen capture illustrating a series of dependent nodes with four nodes expanded;
Figure 4 is a conceptual diagram of the components of the present invention;
Figure 5 is a flow diagram illustrating how the components of a program are displayed by the present invention; and Figure 6 is a flow diagram illustrating the steps in a typical operational scenario of the present invention.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT
Within this specification including the claims, the following terms will be used:
Edit Control An Edit Control is an object that co-ordinates and links together a number of related Edit Views and Edit Windows.
Edit View An Edit View comprises essentially all the data structures that manipulate a document loaded in an editor. That is, an Edit View is a snapshot of a portion of the whole of a document or a segment of a document without the visual window to show it.
Edit Window The Edit Window gives an Edit View a window frame and provides the interface between the user and the document or segment of the document contained in the associated Edit View.
Graph View A Graph View is a graphical representation of a structure that can be modeled using a combination of nodes and links connecting the nodes.
In the preferred embodiment, the present invention provides the facility to expand a graphical node representing a segment of source code in a graphical hierarchical envirorunent (hereinafter referred to as a "browser") into a fully-featured Edit Window which displays the text of the segment of source code.
The browser is, for example, a static navigator, a class browser, or a design application that displays the block diagram or the flowchart of a program or a project. The browser application that implements the present invention utilizes a graphical layout control. The expansion of a graphical node as described above can be performed upon a user's request, typically by moving a cursor over a target node and selecting that node by clicking the pointing device (e.g.
mouse) or by executing one or several keystrokes. Both operational and navigational capabilities of the browser as well as source code editing capabilities are preserved and fully integrated into one browser application window.
Prior to discussing the implementation details of the present invention, reference will be made to Figures 1-3 which illustrate a sample scenario of editing source code within the browser as described above.
Within this specification including the claims, the following terms will be used:
Edit Control An Edit Control is an object that co-ordinates and links together a number of related Edit Views and Edit Windows.
Edit View An Edit View comprises essentially all the data structures that manipulate a document loaded in an editor. That is, an Edit View is a snapshot of a portion of the whole of a document or a segment of a document without the visual window to show it.
Edit Window The Edit Window gives an Edit View a window frame and provides the interface between the user and the document or segment of the document contained in the associated Edit View.
Graph View A Graph View is a graphical representation of a structure that can be modeled using a combination of nodes and links connecting the nodes.
In the preferred embodiment, the present invention provides the facility to expand a graphical node representing a segment of source code in a graphical hierarchical envirorunent (hereinafter referred to as a "browser") into a fully-featured Edit Window which displays the text of the segment of source code.
The browser is, for example, a static navigator, a class browser, or a design application that displays the block diagram or the flowchart of a program or a project. The browser application that implements the present invention utilizes a graphical layout control. The expansion of a graphical node as described above can be performed upon a user's request, typically by moving a cursor over a target node and selecting that node by clicking the pointing device (e.g.
mouse) or by executing one or several keystrokes. Both operational and navigational capabilities of the browser as well as source code editing capabilities are preserved and fully integrated into one browser application window.
Prior to discussing the implementation details of the present invention, reference will be made to Figures 1-3 which illustrate a sample scenario of editing source code within the browser as described above.
Figure 1 shows a browser application window 50 for a C programming language source file, named sample.c, as indicated in the title bar 51. Within the browser application window 50 is an initial Graph View 60. The information in the initial Graph View 60 is based upon information stored in a database within a file system about the program sample.c. The Graph View 60 presented in the browser application window 50 serves as a function-level overview of the source file contents, and as a starting point for editing operations in the source file.
In an alternative embodiment of the invention, the Graph View 60 may be embedded in a higher-level graph. For example, a graph that represents a program comprising multiple source files may in turn be embedded in a graphical representation of an entire project.
Referring to Figure 1, the program source sample.c consists of seven functions. The program source code consists of the following functions: main, functionl, function2, function3, function4, functions and function6. The initial Graph View 60 provides a hierarchical graphical representation of how these functions relate to each other through the presence of links 52.
In this figure, the root represents main, and is illustrated as root node 53. Links 52 are directed and indicate where a function represented by a node calls the function of the node to which the link 52 is directed. Thus main calls both functionl and function2, functionl calls both function3 and function4, and function2 calls each of function4, functions and function6.
Referring to Figure 2, a new Graph View 61 is shown with two source nodes 54 opened for browsing. A pop-up menu 55 associated with a source node 54 is opened for browsing or editing the segment of code that the selected source node 54 represents, or for browsing or editing the segment of code for any other function that calls or is called by the component represented by the selected source node 54 as indicated by the links 52. The choices available in the pop-up menu 55 comprise:
a) normal editing actions, for example: Cut, Copy, Paste, Find selection, Deselect all, Filter selection, Show all; and b) options normally available in a Graph View 61, for example:
i) a list of other components which call on a component associated with a source node 54 which can be opened for editing from a pop-up menu 55;
ii) an action that opens a new window (not shown) displaying the topology of the current file or project;
and iii) an action to refresh the Graph View 61, to reflect changes made to the components of the program.
In the preferred embodiment of the invention, the topology of a file or project consists of statistical information (e.g. total number of functions in a file), and information with respect to callers and callees (e.g. who calls whom).
As shown in Figure 2, the user has opened the source node 54 representing a function named function3 forediting, resulting intheopening ofanewEditWindow56 wherethecodefor function3 is displayed. Once the source node 54 is selected by the user, an underlying Edit Control (not shown in Figure 2) is initialized. This initialization begins with the loading of the file sample.c into the Edit Control. A parser registered to the underlying Edit Control tokenizes and colorizes the file according to C-language syntax. The Edit Window 56 is made to display only the segment of code that is contained within the source node 54, in this case, the source code for function3. Menu items are added to the menus of the Edit Window 56 for C-related user actions in the Edit View.
These menu items may consist of (but are not limited to) the following:
a) Actions->Build: compiles edited code;
b) Actions->Reformat: reformats the source code text in accordance to coding standards;
c) View->Outline Logic: shows the logical outline of the code; and d) Help->C Language Reference: displays reference manual entries.
The Edit Window 56 is then resized and replaces the source node 54 representing function3 in the Graph View 61.
The user has also opened a source node 54 representing the function function4 for editing, which resulted in the opening of a new Edit Window 56 where the code for function4 is displayed.
As shown, Edit Window 56 displaying the code for function4 has the current focus, while Edit Window 56 displaying the code for function3 is in the background. As each Edit Window 56 is displayed, any links 52 that pointed to or from a node replaced by that Edit Window 56 are redrawn to point to or from that Edit Window 56.
Referring to Figure 3, a new Graph View 61 is shown after the user opened two more source nodes 54 for editing. Figure 3 illustrates three background Edit Windows 56 and an Edit Window 56 with the current focus. The links 52 between the source nodes 54 and Edit Windows 56 have been redrawn to show which components are being called by which other components in the source file.
The user may navigate between root node 53, source nodes 54 and Edit Windows 56 using navigational keys and key combinations, thereby causing the current focus to switch from component to component. If the current focus is on an unopened root node 53 or source node 54, the user will have the option of opening an Edit Window 56 for the component associated with the selected root node 53 or source node 54.
Referring to Figure 4, a conceptual diagram of the components of the present invention is shown generally as 100. A browser application 110 will typically create a frame window 112 (implemented, for example, as a browser application window 50 with a title bar 51 as shown in Figures 1-3) within which it will set up its initial graphical layout control 113. The graphical layout control 113 consists of a graph manager and related data structures 114 required to implement a Graph View (e.g. 60 of Figure 1). The graphical layout control 113 also contains node controls 115 which contain the data and methods necessary to implement nodes (for instance, root nodes 53 or source nodes 54 as shown in Figures 1-3) which are to be displayed graphically. The graphical layout control 113 also contains link controls 116 which contain the data and methods necessary to implement links (for instance, links 52 of Figures 1-3). The contents to be displayed within a S graphical layout control 113 may be based on project information saved in a database, which for example, may be stored in a file system (not shown). It will be appreciated by those skilled in the art that such a database is not necessary for the implementation of this invention, but if used, the database may store information which includes, but is not limited to, the functions found in a specific module and their calling relationships. Alternatively, the contents to be displayed within a graphical layout control 113 may be based on a run-time analysis of the source code involved at the appropriate level of detail (e.g. project, class, module, function).
The run-time analysis information may be generated, for example, through the total parse carried out by a live, incremental parser that parses a file when the file is loaded into the browser application 110. This information records, for example, the functions found in the file, the boundaries of the code of the functions in the source document, and the hierarchical relationship between the functions (which functions are being called by themselves or other functions). The browser application 110 updates this information from time to time, in conjunction with the document updates monitored by Edit Controls 118 (description to follow) and its attached parsers (not shown).
In the preferred embodiment of the invention, a separate Edit Control 118 is created that keeps track of the Edit Views 119 and Edit Windows 120 associated with each specific level of detail (e.g. one ofproject, program, source file, function). When the methods of a node control 115 in the graphical layout control 113 are called by the browser application 110 to open a node (e.g. source node 54) in a Graph View for editing, and where an Edit Control 118 associated with the level of detail represented by the Graph View has not yet been opened, a new Edit Control 118 is created.
For example, an Edit Control 118 may be associated with all functions comprising a source file. In this case, the Edit Control 118 will have associated with it, Edit Views 119 each corresponding to a function in the source file. Code for one of the functions can be edited in an Edit Window 120 that is associated with the Edit View 119 for that function. The Edit Window 120 provides the associated Edit View 119 a frame (e.g. space on a windowing system with a border, system menu, toolbar, command menus) and allows for user interaction (e.g.
editing, mouse clicks, toolbar button pressing, resizings) of the frame and the segment of code that corresponds to the Edit View 119.
Also associated with an Edit Control 118 is an Edit Manager 121 and various other components and data structures (122-131) which keep track of information relating to the specific instance of the Edit Control 118. The other components and data structures associated with the Edit Control 118 will be further described below.
In another embodiment of the invention, a single Edit Window 120 may alternately display selected Edit Views 119 while the nodes themselves are rendered as regular graphic nodes. In this embodiment, the Edit Control 118 consists of one Edit Window 120, associated with any of a number of Edit Views 119. The graphical links to the Edit Window 120 will be updated according to the Edit View 119 assigned to the Edit Window 120 at a given time.
The browser application 110 will, from time to time, update the nodes (e.g.
root node 53 or source node 54 in Figures 1-3) and links (e.g. links 52 in Figures 1-3) being displayed in a Graph View by calling appropriate methods in the corresponding node controls 115 and link controls 116, to reflect any changes made to the code displayed in an Edit Window 120 for editing.
Properties of an Edit Window 120 will depend on the component being modified, and the Edit Window 120 may be composed of a number of menus, buttons, and display areas. In the preferred embodiment of the invention, the Edit Window 120 replaces the corresponding node control 115 in the Graph View. The user will also interact with the graphical layout control 113 in order to navigate, browse, and initiate editing in the various components displayed in the Graph View.
External programs may also affect the contents of Edit Windows 120. In an alternate use of the present invention, after program compilation, the user may select a command to display compiler error messages that may have been generated. The browser application 110 would then cause all Edit Windows 120 associated with Edit Views 119 corresponding to segments of code containing errors to be opened. The corresponding error messages may be displayed as read only lines intermixed with the text they refer to, or as lines in a separate display area of the respective Edit Windows 120.
Referring to Figure 5, a flow diagram is provided that illustrates how the components of a program are displayed by the present invention. It will be obvious to those skilled in the art that there may be variations in the names, nature and number of levels in this diagram depending on the application, and this invention is intended to include those alternatives.
In the preferred embodiment of the invention, the graphical layout control 113 (Figure 4) causes a hierarchical model (i.e. Graph View) of a project to be displayed at Step 132, which is a graphical representation ofprograms within a project. At this level, nodes in a Graph View (e.g. root nodes 53 or source nodes 54 of Figures 1-3) will represent programs within a project, and links in a Graph View (e.g. links 52 of Figures 1-3) will signify a relationship between programs.
Upon selecting a node that represents a specific program at Step 133, where such selection may be performed either by the user (for example, by pointing and clicking on the node using a mouse) or by an external program application (for example, by a debugger), a new Graph View is displayed at Step 134. The Graph View displayed at Step 134 is a conceptual model of the program as selected at Step 133, and may be embedded in the Graph View of the project displayed at Step 132, or alternatively, may replace the Graph View of the project displayed at step 132.
In a new Graph View displayed at Step 134, the nodes in the Graph View represent the source files of the program selected at Step 133, of the project being displayed at Step 132, and the links in the Graph View signify a relationship between source files. Upon selecting a node in the Graph View that represents a specific source file at Step 135, a new Graph View, such as shown in Figure 1 for the file "sample.c" is displayed at Step 136.
In the new Graph View displayed at Step 136, the nodes in the Graph View represent functions (or procedures, methods, etc. as the case may be) which are contained in the source file selected at Step 135, and each link in the Graph View signifies a calling relationship between a function and another function, or in the case of a recursive call, a function and itself. Upon selecting a node in the Graph View that represents a specific function at Step 137, the code of the function as selected is displayed for editing within that node in the Graph View, such as shown in Figure 2, at Step 138.
Referring to Figure 6, a flow diagram illustrating the steps in a typical operational scenario of the present invention is provided. The operations performed in the preferred embodiment of the invention are described below. Furthermore, a more detailed description of the main components of a typical Edit Control 118 (Figure 4) and a typical graphical layout control 113 (Figure 4) are provided below, with emphasis on implementation details.
Starting the Browser Application A browser application is loaded by the system and run at Step 150. A browser application window 112 (Figure 4) is initialized and opened, the source code is read and parsed, and the initial Graph View is set up and displayed. Pseudo-code related to the implementation of this step is provided in Appendix "A".
The graphical layout control referred to in the pseudo-code of Appendix "A", is the graphical layout control 113 of Figure 4. The graphical layout control 113 of Figure 4 is implemented using a set of API (Application Programming Interface) functions utilized by the browser to create Graph Views comprising nodes (e.g. root nodes 53 or source nodes 54 of Figures 1-3) and links (e.g. links 52 ofFigures 1-3). The graphical layout control 113 also automatically computes a layout such that the nodes in a Graph View are displayed in a balanced way and with minimal crossing of links in the Graph View. Manipulation of properties of the Graph View controlled by the graphical layout control 113 is also performed through the graphical layout control 113. For example, the user can select nodes and links in the Graph View to change their graphical attributes like colours, size, position, etc.
The Graph View is initially constructed from information stored in a database, or created dynamically (for example, by parsing the source code involved), which includes information about the nodes and links represented by their associated node controls 115 and link controls 116 respectively, and various default settings such as background, highlight, and selection colours, fill patterns, etc. Nodes and links in the Graph View are created and positioned in the Graph View according to the styles and methods that are supported by the graphical layout control 113, and any application-specific criteria.
Information on a node in the Graph View maintained by the graphical layout control 113 comprises:
a) the name and ID of the node;
b) graphic properties (the values needed to draw the node);
c) contents (internal structure comprising text, a nested graph, etc.);
d) internal and external labels for the node;
e) state data (the type of the node, visibility information, sizing style);
fj sizing data; and g) user-data pointers for applications to maintain information related to the node.
Information on a link in the Graph View maintained by the graphical layout control 113 comprises:
a) the name and ID of the link;
b) graphic attributes (colour, line type, line width, coordinates);
c) arrow head information (source, destination);
d) a text label;
e) state data; and f) a user-data pointer.
User-interaction capabilities are also implemented in the graphical layout control 113 including: scrolling of the graph, zooming in and out, querying of the graph objects found at a particular location (for example, used by an application to identify the node in the Graph View activated upon selection by the user).
As previously noted, in the preferred embodiment of the present invention, the graphical layout control 113 also allows for the replacement of a node in a Graph View with an Edit Window 120 (Figure 4) where the code corresponding to a component (i.e. an Edit View 119 of Figure 4) may be edited. The graphical layout control 113 handles the processing and passing of system event notifications to and from the graphical layout control 113, but it otherwise treats the Edit Window 120 replacing the node in the Graph View as a node for other purposes including the laying out of the graph and the maintenance of links in the Graph View.
Alternatively, a node in the Graph View being opened for editing may be designated as application-controlled. The graphical layout control 113 handles the resizing and repositioning of a node, but an external application would maintain its own window in that space. The application will create and position the window and maintain two-way communication with the graphical layout control 113 regarding the size, position, and status of this window.
The appropriate source segment represented by a node in the Graph View (an entire source file, a class, or a function) is determined and set up by the browser application 110. This is done in conjunction with a live parser (not shown) attached to the Edit Control 118 for the particular file, which classifies and bounds (delimits) structural elements in the source. The visibility of the segment of interest is accomplished by marking the particular areas) of interest in the file text, and hiding the rest through mark visibility settings in the Edit View 119. This process is further described in the next section.
The boundaries of the source segment represented by the node in the Graph View are maintained during editing by a live parser, which keeps the information up-to-date through incremental parsing.
Opening Nodes) for Editing / Editing Code in Opened Nodes) Referring again to Figure 6, the user requests at Step 152 that a node in the Graph View be opened for editing. In Step 152, an event observer (not shown) running under the control of the browser application 110 receives notification of the user's selection and request for the opening of a node in the Graph View for editing. The code of the component corresponding to the node in the Graph View can be subsequently edited. Pseudo-code related to the implementation of this Step is provided in Appendix "B".
As disclosed earlier, the Edit Control 118 (Figure 4) referred to in the pseudo-code of Appendix "B", is a control that allows the user to browse and edit source code. It allows access to all the existing internal and external commands, profiles, and macros (stored in a profiles and macros data structure 130) of a stand alone editor.
An instance of the Edit Control 118 may consist of any number of these objects:
a) Edit View 119 This object controls one view of an edit document (e.g., a file or portion thereof loaded in the Edit Control 118). It allows the browser application 110 to manipulate the edit document through internal edit commands and external edit commands loaded in and run from the Edit Control 118, and through edit profiles and macros (stored in a profiles and macros structure 130, description to follow). The Edit View 119 is implemented by defining a class that comprises:
I) a constructor comprising the following parameters:
i. edit document name: if the file is not yet opened, it is loaded, otherwise, a new view of the document is created;
ii. optional pointer to associated Edit Window 120 object;
iii. optional document type; and iv. other implementation-dependent options (e.g. edit profiles in the profiles and macro structure 130 to be run, and an end-of line indicator).
II) class methods (not associated to a specific instance of the Edit View 119) comprising:
i. setInstance(name): sets up an instance for the Edit View 119 objects) to be created;
ii. currentEditView(): returns a pointer to the Edit View 119 object associated with the current Edit View 119; and iii. editCommand(edit command, parameters):
executes an edit command which is not specific to a particular Edit View 119.
III) object methods comprising:
i. editWindow(): returns an object pointer for the Edit Window 120 object associated with the Edit View 119, if any;
ii. setEditWindow(pointer to EditWindow): associates a specified Edit Window 120 with the current Edit View 119;
iii. command (edit command, parameters): executes an edit command setting or queries an edit command setting; and iv. activate(): a virtual function implemented in the application and called when the user has performed an action that would normally activate the Edit View 119, but where there is no Edit Window 120 associated with the Edit View 119. This function allows the application to associate an Edit Window 120 with the Edit View 119 and give it focus, which may be useful in implementing navigation between the entities in a Graph View.
IV) notification members comprising:
i. focusId: an identifier provided to observers of an Edit View 119, when the Edit Window 120 associated with the Edit View 119 receives or loses focus.
b) Edit Window 120 This object is a window that provides a user interface for an Edit View 119.
An Edit Window 120 can be opened and resized in any of three sizes:
a) minimized - the original size of a node in a Graph View:
This is the graphical rendering of the node in a Graph View (e.g. as illustrated in Figures 1-3 as a root node 53 or source node 54), labeled with the name of the entity which it represents (e.g. a function name).
b) regular - the node in a Graph View is an Edit View 119:
The links in the Graph View (e.g. as illustrated in Figures 1-3 as links 52) to and from other nodes in the Graph View or Edit Views 119 (shown in Edit Windows 120) are displayed. This is the default editing mode in the preferred embodiment of the invention.
c) maximized - the node in a Graph View is an Edit View 119, enlarged up to the maximum application window size, or reasonably maximized inside the frame window 112 of the browser application 110.
Several Edit Windows 120 simultaneously open can be displayed as tiled or overlapping.
An Edit Window 120 is implemented by defining a class comprising:
1 S I) a constructor comprising the following parameters:
i. ID of the Edit Window 120;
ii. parent/owner windows) pointers;
iii. the initial size and position for the Edit Window 120;
iv. optional pointers to various control objects to be used by the Edit Window (e.g, title bar, menu bar, toolbars, pop-up window, application-owned scroll bars, message bar); and v. other implementation-dependent options (e.g. Edit Window 120 characteristics such as borders and other properties).
II) object methods comprising:
i. setlremove control objects: e.g. setTitleBar, setMenuBar; and ii. textWindow: returns a pointer to the main text entry window, to allow the application to provide its own keyboard and mouse handlers (not shown). An Edit Window 120 will normally comprise several display areas (not shown), where the main text entry window is used to display the code being edited and to accept keyboard and mouse input. The handlers may use a method to map back a text entry display area to an Edit Window 120 from which they were called.
c) Edit Manager 121 The Edit Manager 121 is responsible for the instantiation and management of the various components of an Edit Control 118. Each instance of an Edit Control 118 supports and links a number ofrelated Edit Views 119 and Edit Windows 120. All the EditViews 119 and Edit Windows 120 in the Edit Control 118 can access information about each other. They are also affected by changes to global edit settings and parameters, and allow navigation between themselves.
The Edit Manager 121 processes the internal commands of the programming environment.
For example, the Edit Manager 121 handles the binding of internal commands or external commands and edit macros to key actions (stored in a key actions structure 131, description to follow), mouse acti_o_n_s;andmenu~tems. When~naction isreceived,it involves thecommand boundtothe action, if any.
d) Text Processing Component 122 The Text Processing component 122 handles the loading of documents into an edit buffer 126 (described below), all text editing and formatting operations, and the saving of the documents.
Committed changes to the document are recorded in a stack for subsequent processing by a live parser (not shown). For example, this information may consist of pointers to the text elements that changed, to those that were added, and to a text element located before a text element that was deleted. The live parser will be invoked with these pointers, and will reparse these areas of the document.
e) Graphical User Interface Control 123 The Graphical User Interface Control 123 controls, builds and renders an Edit View 119 within an Edit Window 120. It manages the display attributes of the rendered elements as set up by an Edit Instance 118 and its attached tools. Examples of the display attributes managed by the Graphical User Interface Control 123 include the tokenization and colourization of the text associated with the Edit View 119 by a live parser, the non-document display-only elements and embedded messages within the Edit Window 120 (e.g. the error messages generated during compilation), and the filtering of elements in or out of the display as specified by the user or the browser application 110. Various events received within the browser application 110 as a result of the user manipulating the screen (e.g. window resizing and repositioning, and mouse-button actions) are processed, and the event notifications are passed on to, or generated for, the parent window that instantiated an Edit Window 120.
f) Command/Macros Interface 124 This component controls an interface to internal edit commands, external commands (code that is loaded in and run from an Edit Control 118), and edit macros, including live incremental parsers.
g) Edit Manager Structure 125 This data structure stores the global data associated with an Edit Control 118.
h) Edit Buffer 126 An edit buffer 126 comprises a linked list (or other suitable data structure) of all the text elements (as stored in element structures 127 described below) of a particular document.
i) Element Structures 127 These data structures store the text elements that make up an edit buffer 126.
Different classes of text elements can be defined for a particular document (e.g. CODE, SPACE, SEMICOLON, - FUNCTION, BRACE, FWDLINK, BWDLINK, ERROR, COMMENT, CONTROL). The text elements are obtained from the contents of the file loaded in an Edit Control 118. A text element can belong to one or more classes. Navigation between the elements through their classes (e.g., NEXT CLASS FUNCTION to move active point to the next element that belongs to class FUNCTION) is possible within an Edit Window 120.
In the preferred embodiment of the invention, the display attributes for each character in the text displayed in an Edit Window 120, are set by the tokenizer of a live parser (not shown) attached to the Edit Control 118. An element structure contains text contents, formatting flags and display attributes, and class information.
j) Document Control Structure 128 This data structure contains information to control the operations on a document in an Edit Control 118. One such structure is created for each document being edited.
Classes are used to filter out text elements in the display of code in an Edit Window 120, and are used by the parsers to interpret the contents of an edit buffer 126 at various degrees of detail.
k) View Control Structure 129 This data structure contains data related to the control of an Edit View 119 for one document in an Edit Window 120. This includes, for example, display attributes defined for the Edit View 119, the size of the.Edit View 119, the required visibility of text elements (for filtering/zooming in), and screen fields for the components of the edit buffer 126 being displayed in the Edit View 119.
1) Profiles and Macros Structure 130 This data structure stores the profiles and macros associated with an Edit Control 118. The profiles include information on default and user-specific settings and are set by the browser application 110, when, for example, an Edit Control 118 is instantiated or when a new document is opened. Settings in the Edit Control 118 that need to be adjusted when working with different platforms, file types, and applications can also be saved in a profile. A live parser is also attached to the Edit Control 118 using the particular edit profile that is invoked based on the specified type of the file loaded, or on its file name extension.
m) Key Actions Structure 131 This data structure stores the default actions for keys, key combinations, and mouse actions.
These actions can be redefined, for example through an edit profile, macro, or external command, to activate any series of commands.
Navigating Between Windows Returning now to Figure 6, the user may wish to navigate between successive Edit Windows 120 in a Graph View as in Step 154. Pseudo-code related to the implementation of Step 154 is provided in Appendix "C". For example, navigation between successive Edit Windows 120 in a Graph View is necessary when the user wishes to switch from editing code in one Edit Window 120 to editing code in a different Edit Window 120.
The order in which Edit Windows 120 receive the current focus when a user navigates between Edit Views 119 of a document displayed in the Edit Windows 120, is dependent upon the order in which the Edit Views 119 were created. The order in which Edit Windows 120 receive the current focus may also depend upon user or application-specified settings and management options relating to how navigation between successive Edit Views 119 of the Edit Windows 120 is to be performed. For example, Edit Control 118 navigational keys can be redefined to allow for "hierarchical" navigation (i.e. moving between Edit Views 119 according to the calling relationships between components displayed in the Graph View).
In the preferred embodiment of the invention, once a document (i.e. the contents of an Edit Window 120) is updated, the Graph View in the Edit Window 120 is modified accordingly, if necessary.
Closing an Edit Window Referring to Figure 6, the user requests that an Edit Window 120 be closed as in Step 156.
Pseudo-code related to the implementation of this step is provided in Appendix "D".
In the preferred embodiment of the invention, the graphical layout control 113 (Figure 4) maintains a series of nested graphs, where a Graph View can replace a node in a higher-level Graph View, and each Graph View maintains its own structure of nodes and links. Each node in a function-level Graph View can be opened to display the underlying source code corresponding to the component represented by the node in the Graph View, which can be edited in an associated Edit Window 120 (Figure 4).
In another embodiment of the invention, the graphical layout control 113 will permit the user upon selecting any node in a Graph View, to either display a new Graph View corresponding to the component represented by the node in the Graph View, or to display an Edit Window 120 that allows for the underlying source code corresponding to the component represented by the node in the Graph View to be edited, even if the node in the Graph View could, alternatively, be replaced by a separate Graph View.
The preferred embodiment of the disclosed invention can be implemented with a customizable edit control such as LPEX (the IBM Live Parsing Extensible editor), and a graphical hierarchical environment such as NARC/DG (the Nodes and Arcs/Directed Graph) graphical layout libraries, modified to support the properties of the invention herein described.
It will be apparent to those skilled in the art, that the application of the invention herein disclosed is not limited to programs based on the C programming language, nor is it limited to the graphical user interface or graphical layout used in the illustrations provided herein.
It can be appreciated that variations to this invention would be readily apparent to those skilled in the art, and this invention is intended to include those variations.
In an alternative embodiment of the invention, the Graph View 60 may be embedded in a higher-level graph. For example, a graph that represents a program comprising multiple source files may in turn be embedded in a graphical representation of an entire project.
Referring to Figure 1, the program source sample.c consists of seven functions. The program source code consists of the following functions: main, functionl, function2, function3, function4, functions and function6. The initial Graph View 60 provides a hierarchical graphical representation of how these functions relate to each other through the presence of links 52.
In this figure, the root represents main, and is illustrated as root node 53. Links 52 are directed and indicate where a function represented by a node calls the function of the node to which the link 52 is directed. Thus main calls both functionl and function2, functionl calls both function3 and function4, and function2 calls each of function4, functions and function6.
Referring to Figure 2, a new Graph View 61 is shown with two source nodes 54 opened for browsing. A pop-up menu 55 associated with a source node 54 is opened for browsing or editing the segment of code that the selected source node 54 represents, or for browsing or editing the segment of code for any other function that calls or is called by the component represented by the selected source node 54 as indicated by the links 52. The choices available in the pop-up menu 55 comprise:
a) normal editing actions, for example: Cut, Copy, Paste, Find selection, Deselect all, Filter selection, Show all; and b) options normally available in a Graph View 61, for example:
i) a list of other components which call on a component associated with a source node 54 which can be opened for editing from a pop-up menu 55;
ii) an action that opens a new window (not shown) displaying the topology of the current file or project;
and iii) an action to refresh the Graph View 61, to reflect changes made to the components of the program.
In the preferred embodiment of the invention, the topology of a file or project consists of statistical information (e.g. total number of functions in a file), and information with respect to callers and callees (e.g. who calls whom).
As shown in Figure 2, the user has opened the source node 54 representing a function named function3 forediting, resulting intheopening ofanewEditWindow56 wherethecodefor function3 is displayed. Once the source node 54 is selected by the user, an underlying Edit Control (not shown in Figure 2) is initialized. This initialization begins with the loading of the file sample.c into the Edit Control. A parser registered to the underlying Edit Control tokenizes and colorizes the file according to C-language syntax. The Edit Window 56 is made to display only the segment of code that is contained within the source node 54, in this case, the source code for function3. Menu items are added to the menus of the Edit Window 56 for C-related user actions in the Edit View.
These menu items may consist of (but are not limited to) the following:
a) Actions->Build: compiles edited code;
b) Actions->Reformat: reformats the source code text in accordance to coding standards;
c) View->Outline Logic: shows the logical outline of the code; and d) Help->C Language Reference: displays reference manual entries.
The Edit Window 56 is then resized and replaces the source node 54 representing function3 in the Graph View 61.
The user has also opened a source node 54 representing the function function4 for editing, which resulted in the opening of a new Edit Window 56 where the code for function4 is displayed.
As shown, Edit Window 56 displaying the code for function4 has the current focus, while Edit Window 56 displaying the code for function3 is in the background. As each Edit Window 56 is displayed, any links 52 that pointed to or from a node replaced by that Edit Window 56 are redrawn to point to or from that Edit Window 56.
Referring to Figure 3, a new Graph View 61 is shown after the user opened two more source nodes 54 for editing. Figure 3 illustrates three background Edit Windows 56 and an Edit Window 56 with the current focus. The links 52 between the source nodes 54 and Edit Windows 56 have been redrawn to show which components are being called by which other components in the source file.
The user may navigate between root node 53, source nodes 54 and Edit Windows 56 using navigational keys and key combinations, thereby causing the current focus to switch from component to component. If the current focus is on an unopened root node 53 or source node 54, the user will have the option of opening an Edit Window 56 for the component associated with the selected root node 53 or source node 54.
Referring to Figure 4, a conceptual diagram of the components of the present invention is shown generally as 100. A browser application 110 will typically create a frame window 112 (implemented, for example, as a browser application window 50 with a title bar 51 as shown in Figures 1-3) within which it will set up its initial graphical layout control 113. The graphical layout control 113 consists of a graph manager and related data structures 114 required to implement a Graph View (e.g. 60 of Figure 1). The graphical layout control 113 also contains node controls 115 which contain the data and methods necessary to implement nodes (for instance, root nodes 53 or source nodes 54 as shown in Figures 1-3) which are to be displayed graphically. The graphical layout control 113 also contains link controls 116 which contain the data and methods necessary to implement links (for instance, links 52 of Figures 1-3). The contents to be displayed within a S graphical layout control 113 may be based on project information saved in a database, which for example, may be stored in a file system (not shown). It will be appreciated by those skilled in the art that such a database is not necessary for the implementation of this invention, but if used, the database may store information which includes, but is not limited to, the functions found in a specific module and their calling relationships. Alternatively, the contents to be displayed within a graphical layout control 113 may be based on a run-time analysis of the source code involved at the appropriate level of detail (e.g. project, class, module, function).
The run-time analysis information may be generated, for example, through the total parse carried out by a live, incremental parser that parses a file when the file is loaded into the browser application 110. This information records, for example, the functions found in the file, the boundaries of the code of the functions in the source document, and the hierarchical relationship between the functions (which functions are being called by themselves or other functions). The browser application 110 updates this information from time to time, in conjunction with the document updates monitored by Edit Controls 118 (description to follow) and its attached parsers (not shown).
In the preferred embodiment of the invention, a separate Edit Control 118 is created that keeps track of the Edit Views 119 and Edit Windows 120 associated with each specific level of detail (e.g. one ofproject, program, source file, function). When the methods of a node control 115 in the graphical layout control 113 are called by the browser application 110 to open a node (e.g. source node 54) in a Graph View for editing, and where an Edit Control 118 associated with the level of detail represented by the Graph View has not yet been opened, a new Edit Control 118 is created.
For example, an Edit Control 118 may be associated with all functions comprising a source file. In this case, the Edit Control 118 will have associated with it, Edit Views 119 each corresponding to a function in the source file. Code for one of the functions can be edited in an Edit Window 120 that is associated with the Edit View 119 for that function. The Edit Window 120 provides the associated Edit View 119 a frame (e.g. space on a windowing system with a border, system menu, toolbar, command menus) and allows for user interaction (e.g.
editing, mouse clicks, toolbar button pressing, resizings) of the frame and the segment of code that corresponds to the Edit View 119.
Also associated with an Edit Control 118 is an Edit Manager 121 and various other components and data structures (122-131) which keep track of information relating to the specific instance of the Edit Control 118. The other components and data structures associated with the Edit Control 118 will be further described below.
In another embodiment of the invention, a single Edit Window 120 may alternately display selected Edit Views 119 while the nodes themselves are rendered as regular graphic nodes. In this embodiment, the Edit Control 118 consists of one Edit Window 120, associated with any of a number of Edit Views 119. The graphical links to the Edit Window 120 will be updated according to the Edit View 119 assigned to the Edit Window 120 at a given time.
The browser application 110 will, from time to time, update the nodes (e.g.
root node 53 or source node 54 in Figures 1-3) and links (e.g. links 52 in Figures 1-3) being displayed in a Graph View by calling appropriate methods in the corresponding node controls 115 and link controls 116, to reflect any changes made to the code displayed in an Edit Window 120 for editing.
Properties of an Edit Window 120 will depend on the component being modified, and the Edit Window 120 may be composed of a number of menus, buttons, and display areas. In the preferred embodiment of the invention, the Edit Window 120 replaces the corresponding node control 115 in the Graph View. The user will also interact with the graphical layout control 113 in order to navigate, browse, and initiate editing in the various components displayed in the Graph View.
External programs may also affect the contents of Edit Windows 120. In an alternate use of the present invention, after program compilation, the user may select a command to display compiler error messages that may have been generated. The browser application 110 would then cause all Edit Windows 120 associated with Edit Views 119 corresponding to segments of code containing errors to be opened. The corresponding error messages may be displayed as read only lines intermixed with the text they refer to, or as lines in a separate display area of the respective Edit Windows 120.
Referring to Figure 5, a flow diagram is provided that illustrates how the components of a program are displayed by the present invention. It will be obvious to those skilled in the art that there may be variations in the names, nature and number of levels in this diagram depending on the application, and this invention is intended to include those alternatives.
In the preferred embodiment of the invention, the graphical layout control 113 (Figure 4) causes a hierarchical model (i.e. Graph View) of a project to be displayed at Step 132, which is a graphical representation ofprograms within a project. At this level, nodes in a Graph View (e.g. root nodes 53 or source nodes 54 of Figures 1-3) will represent programs within a project, and links in a Graph View (e.g. links 52 of Figures 1-3) will signify a relationship between programs.
Upon selecting a node that represents a specific program at Step 133, where such selection may be performed either by the user (for example, by pointing and clicking on the node using a mouse) or by an external program application (for example, by a debugger), a new Graph View is displayed at Step 134. The Graph View displayed at Step 134 is a conceptual model of the program as selected at Step 133, and may be embedded in the Graph View of the project displayed at Step 132, or alternatively, may replace the Graph View of the project displayed at step 132.
In a new Graph View displayed at Step 134, the nodes in the Graph View represent the source files of the program selected at Step 133, of the project being displayed at Step 132, and the links in the Graph View signify a relationship between source files. Upon selecting a node in the Graph View that represents a specific source file at Step 135, a new Graph View, such as shown in Figure 1 for the file "sample.c" is displayed at Step 136.
In the new Graph View displayed at Step 136, the nodes in the Graph View represent functions (or procedures, methods, etc. as the case may be) which are contained in the source file selected at Step 135, and each link in the Graph View signifies a calling relationship between a function and another function, or in the case of a recursive call, a function and itself. Upon selecting a node in the Graph View that represents a specific function at Step 137, the code of the function as selected is displayed for editing within that node in the Graph View, such as shown in Figure 2, at Step 138.
Referring to Figure 6, a flow diagram illustrating the steps in a typical operational scenario of the present invention is provided. The operations performed in the preferred embodiment of the invention are described below. Furthermore, a more detailed description of the main components of a typical Edit Control 118 (Figure 4) and a typical graphical layout control 113 (Figure 4) are provided below, with emphasis on implementation details.
Starting the Browser Application A browser application is loaded by the system and run at Step 150. A browser application window 112 (Figure 4) is initialized and opened, the source code is read and parsed, and the initial Graph View is set up and displayed. Pseudo-code related to the implementation of this step is provided in Appendix "A".
The graphical layout control referred to in the pseudo-code of Appendix "A", is the graphical layout control 113 of Figure 4. The graphical layout control 113 of Figure 4 is implemented using a set of API (Application Programming Interface) functions utilized by the browser to create Graph Views comprising nodes (e.g. root nodes 53 or source nodes 54 of Figures 1-3) and links (e.g. links 52 ofFigures 1-3). The graphical layout control 113 also automatically computes a layout such that the nodes in a Graph View are displayed in a balanced way and with minimal crossing of links in the Graph View. Manipulation of properties of the Graph View controlled by the graphical layout control 113 is also performed through the graphical layout control 113. For example, the user can select nodes and links in the Graph View to change their graphical attributes like colours, size, position, etc.
The Graph View is initially constructed from information stored in a database, or created dynamically (for example, by parsing the source code involved), which includes information about the nodes and links represented by their associated node controls 115 and link controls 116 respectively, and various default settings such as background, highlight, and selection colours, fill patterns, etc. Nodes and links in the Graph View are created and positioned in the Graph View according to the styles and methods that are supported by the graphical layout control 113, and any application-specific criteria.
Information on a node in the Graph View maintained by the graphical layout control 113 comprises:
a) the name and ID of the node;
b) graphic properties (the values needed to draw the node);
c) contents (internal structure comprising text, a nested graph, etc.);
d) internal and external labels for the node;
e) state data (the type of the node, visibility information, sizing style);
fj sizing data; and g) user-data pointers for applications to maintain information related to the node.
Information on a link in the Graph View maintained by the graphical layout control 113 comprises:
a) the name and ID of the link;
b) graphic attributes (colour, line type, line width, coordinates);
c) arrow head information (source, destination);
d) a text label;
e) state data; and f) a user-data pointer.
User-interaction capabilities are also implemented in the graphical layout control 113 including: scrolling of the graph, zooming in and out, querying of the graph objects found at a particular location (for example, used by an application to identify the node in the Graph View activated upon selection by the user).
As previously noted, in the preferred embodiment of the present invention, the graphical layout control 113 also allows for the replacement of a node in a Graph View with an Edit Window 120 (Figure 4) where the code corresponding to a component (i.e. an Edit View 119 of Figure 4) may be edited. The graphical layout control 113 handles the processing and passing of system event notifications to and from the graphical layout control 113, but it otherwise treats the Edit Window 120 replacing the node in the Graph View as a node for other purposes including the laying out of the graph and the maintenance of links in the Graph View.
Alternatively, a node in the Graph View being opened for editing may be designated as application-controlled. The graphical layout control 113 handles the resizing and repositioning of a node, but an external application would maintain its own window in that space. The application will create and position the window and maintain two-way communication with the graphical layout control 113 regarding the size, position, and status of this window.
The appropriate source segment represented by a node in the Graph View (an entire source file, a class, or a function) is determined and set up by the browser application 110. This is done in conjunction with a live parser (not shown) attached to the Edit Control 118 for the particular file, which classifies and bounds (delimits) structural elements in the source. The visibility of the segment of interest is accomplished by marking the particular areas) of interest in the file text, and hiding the rest through mark visibility settings in the Edit View 119. This process is further described in the next section.
The boundaries of the source segment represented by the node in the Graph View are maintained during editing by a live parser, which keeps the information up-to-date through incremental parsing.
Opening Nodes) for Editing / Editing Code in Opened Nodes) Referring again to Figure 6, the user requests at Step 152 that a node in the Graph View be opened for editing. In Step 152, an event observer (not shown) running under the control of the browser application 110 receives notification of the user's selection and request for the opening of a node in the Graph View for editing. The code of the component corresponding to the node in the Graph View can be subsequently edited. Pseudo-code related to the implementation of this Step is provided in Appendix "B".
As disclosed earlier, the Edit Control 118 (Figure 4) referred to in the pseudo-code of Appendix "B", is a control that allows the user to browse and edit source code. It allows access to all the existing internal and external commands, profiles, and macros (stored in a profiles and macros data structure 130) of a stand alone editor.
An instance of the Edit Control 118 may consist of any number of these objects:
a) Edit View 119 This object controls one view of an edit document (e.g., a file or portion thereof loaded in the Edit Control 118). It allows the browser application 110 to manipulate the edit document through internal edit commands and external edit commands loaded in and run from the Edit Control 118, and through edit profiles and macros (stored in a profiles and macros structure 130, description to follow). The Edit View 119 is implemented by defining a class that comprises:
I) a constructor comprising the following parameters:
i. edit document name: if the file is not yet opened, it is loaded, otherwise, a new view of the document is created;
ii. optional pointer to associated Edit Window 120 object;
iii. optional document type; and iv. other implementation-dependent options (e.g. edit profiles in the profiles and macro structure 130 to be run, and an end-of line indicator).
II) class methods (not associated to a specific instance of the Edit View 119) comprising:
i. setInstance(name): sets up an instance for the Edit View 119 objects) to be created;
ii. currentEditView(): returns a pointer to the Edit View 119 object associated with the current Edit View 119; and iii. editCommand(edit command, parameters):
executes an edit command which is not specific to a particular Edit View 119.
III) object methods comprising:
i. editWindow(): returns an object pointer for the Edit Window 120 object associated with the Edit View 119, if any;
ii. setEditWindow(pointer to EditWindow): associates a specified Edit Window 120 with the current Edit View 119;
iii. command (edit command, parameters): executes an edit command setting or queries an edit command setting; and iv. activate(): a virtual function implemented in the application and called when the user has performed an action that would normally activate the Edit View 119, but where there is no Edit Window 120 associated with the Edit View 119. This function allows the application to associate an Edit Window 120 with the Edit View 119 and give it focus, which may be useful in implementing navigation between the entities in a Graph View.
IV) notification members comprising:
i. focusId: an identifier provided to observers of an Edit View 119, when the Edit Window 120 associated with the Edit View 119 receives or loses focus.
b) Edit Window 120 This object is a window that provides a user interface for an Edit View 119.
An Edit Window 120 can be opened and resized in any of three sizes:
a) minimized - the original size of a node in a Graph View:
This is the graphical rendering of the node in a Graph View (e.g. as illustrated in Figures 1-3 as a root node 53 or source node 54), labeled with the name of the entity which it represents (e.g. a function name).
b) regular - the node in a Graph View is an Edit View 119:
The links in the Graph View (e.g. as illustrated in Figures 1-3 as links 52) to and from other nodes in the Graph View or Edit Views 119 (shown in Edit Windows 120) are displayed. This is the default editing mode in the preferred embodiment of the invention.
c) maximized - the node in a Graph View is an Edit View 119, enlarged up to the maximum application window size, or reasonably maximized inside the frame window 112 of the browser application 110.
Several Edit Windows 120 simultaneously open can be displayed as tiled or overlapping.
An Edit Window 120 is implemented by defining a class comprising:
1 S I) a constructor comprising the following parameters:
i. ID of the Edit Window 120;
ii. parent/owner windows) pointers;
iii. the initial size and position for the Edit Window 120;
iv. optional pointers to various control objects to be used by the Edit Window (e.g, title bar, menu bar, toolbars, pop-up window, application-owned scroll bars, message bar); and v. other implementation-dependent options (e.g. Edit Window 120 characteristics such as borders and other properties).
II) object methods comprising:
i. setlremove control objects: e.g. setTitleBar, setMenuBar; and ii. textWindow: returns a pointer to the main text entry window, to allow the application to provide its own keyboard and mouse handlers (not shown). An Edit Window 120 will normally comprise several display areas (not shown), where the main text entry window is used to display the code being edited and to accept keyboard and mouse input. The handlers may use a method to map back a text entry display area to an Edit Window 120 from which they were called.
c) Edit Manager 121 The Edit Manager 121 is responsible for the instantiation and management of the various components of an Edit Control 118. Each instance of an Edit Control 118 supports and links a number ofrelated Edit Views 119 and Edit Windows 120. All the EditViews 119 and Edit Windows 120 in the Edit Control 118 can access information about each other. They are also affected by changes to global edit settings and parameters, and allow navigation between themselves.
The Edit Manager 121 processes the internal commands of the programming environment.
For example, the Edit Manager 121 handles the binding of internal commands or external commands and edit macros to key actions (stored in a key actions structure 131, description to follow), mouse acti_o_n_s;andmenu~tems. When~naction isreceived,it involves thecommand boundtothe action, if any.
d) Text Processing Component 122 The Text Processing component 122 handles the loading of documents into an edit buffer 126 (described below), all text editing and formatting operations, and the saving of the documents.
Committed changes to the document are recorded in a stack for subsequent processing by a live parser (not shown). For example, this information may consist of pointers to the text elements that changed, to those that were added, and to a text element located before a text element that was deleted. The live parser will be invoked with these pointers, and will reparse these areas of the document.
e) Graphical User Interface Control 123 The Graphical User Interface Control 123 controls, builds and renders an Edit View 119 within an Edit Window 120. It manages the display attributes of the rendered elements as set up by an Edit Instance 118 and its attached tools. Examples of the display attributes managed by the Graphical User Interface Control 123 include the tokenization and colourization of the text associated with the Edit View 119 by a live parser, the non-document display-only elements and embedded messages within the Edit Window 120 (e.g. the error messages generated during compilation), and the filtering of elements in or out of the display as specified by the user or the browser application 110. Various events received within the browser application 110 as a result of the user manipulating the screen (e.g. window resizing and repositioning, and mouse-button actions) are processed, and the event notifications are passed on to, or generated for, the parent window that instantiated an Edit Window 120.
f) Command/Macros Interface 124 This component controls an interface to internal edit commands, external commands (code that is loaded in and run from an Edit Control 118), and edit macros, including live incremental parsers.
g) Edit Manager Structure 125 This data structure stores the global data associated with an Edit Control 118.
h) Edit Buffer 126 An edit buffer 126 comprises a linked list (or other suitable data structure) of all the text elements (as stored in element structures 127 described below) of a particular document.
i) Element Structures 127 These data structures store the text elements that make up an edit buffer 126.
Different classes of text elements can be defined for a particular document (e.g. CODE, SPACE, SEMICOLON, - FUNCTION, BRACE, FWDLINK, BWDLINK, ERROR, COMMENT, CONTROL). The text elements are obtained from the contents of the file loaded in an Edit Control 118. A text element can belong to one or more classes. Navigation between the elements through their classes (e.g., NEXT CLASS FUNCTION to move active point to the next element that belongs to class FUNCTION) is possible within an Edit Window 120.
In the preferred embodiment of the invention, the display attributes for each character in the text displayed in an Edit Window 120, are set by the tokenizer of a live parser (not shown) attached to the Edit Control 118. An element structure contains text contents, formatting flags and display attributes, and class information.
j) Document Control Structure 128 This data structure contains information to control the operations on a document in an Edit Control 118. One such structure is created for each document being edited.
Classes are used to filter out text elements in the display of code in an Edit Window 120, and are used by the parsers to interpret the contents of an edit buffer 126 at various degrees of detail.
k) View Control Structure 129 This data structure contains data related to the control of an Edit View 119 for one document in an Edit Window 120. This includes, for example, display attributes defined for the Edit View 119, the size of the.Edit View 119, the required visibility of text elements (for filtering/zooming in), and screen fields for the components of the edit buffer 126 being displayed in the Edit View 119.
1) Profiles and Macros Structure 130 This data structure stores the profiles and macros associated with an Edit Control 118. The profiles include information on default and user-specific settings and are set by the browser application 110, when, for example, an Edit Control 118 is instantiated or when a new document is opened. Settings in the Edit Control 118 that need to be adjusted when working with different platforms, file types, and applications can also be saved in a profile. A live parser is also attached to the Edit Control 118 using the particular edit profile that is invoked based on the specified type of the file loaded, or on its file name extension.
m) Key Actions Structure 131 This data structure stores the default actions for keys, key combinations, and mouse actions.
These actions can be redefined, for example through an edit profile, macro, or external command, to activate any series of commands.
Navigating Between Windows Returning now to Figure 6, the user may wish to navigate between successive Edit Windows 120 in a Graph View as in Step 154. Pseudo-code related to the implementation of Step 154 is provided in Appendix "C". For example, navigation between successive Edit Windows 120 in a Graph View is necessary when the user wishes to switch from editing code in one Edit Window 120 to editing code in a different Edit Window 120.
The order in which Edit Windows 120 receive the current focus when a user navigates between Edit Views 119 of a document displayed in the Edit Windows 120, is dependent upon the order in which the Edit Views 119 were created. The order in which Edit Windows 120 receive the current focus may also depend upon user or application-specified settings and management options relating to how navigation between successive Edit Views 119 of the Edit Windows 120 is to be performed. For example, Edit Control 118 navigational keys can be redefined to allow for "hierarchical" navigation (i.e. moving between Edit Views 119 according to the calling relationships between components displayed in the Graph View).
In the preferred embodiment of the invention, once a document (i.e. the contents of an Edit Window 120) is updated, the Graph View in the Edit Window 120 is modified accordingly, if necessary.
Closing an Edit Window Referring to Figure 6, the user requests that an Edit Window 120 be closed as in Step 156.
Pseudo-code related to the implementation of this step is provided in Appendix "D".
In the preferred embodiment of the invention, the graphical layout control 113 (Figure 4) maintains a series of nested graphs, where a Graph View can replace a node in a higher-level Graph View, and each Graph View maintains its own structure of nodes and links. Each node in a function-level Graph View can be opened to display the underlying source code corresponding to the component represented by the node in the Graph View, which can be edited in an associated Edit Window 120 (Figure 4).
In another embodiment of the invention, the graphical layout control 113 will permit the user upon selecting any node in a Graph View, to either display a new Graph View corresponding to the component represented by the node in the Graph View, or to display an Edit Window 120 that allows for the underlying source code corresponding to the component represented by the node in the Graph View to be edited, even if the node in the Graph View could, alternatively, be replaced by a separate Graph View.
The preferred embodiment of the disclosed invention can be implemented with a customizable edit control such as LPEX (the IBM Live Parsing Extensible editor), and a graphical hierarchical environment such as NARC/DG (the Nodes and Arcs/Directed Graph) graphical layout libraries, modified to support the properties of the invention herein described.
It will be apparent to those skilled in the art, that the application of the invention herein disclosed is not limited to programs based on the C programming language, nor is it limited to the graphical user interface or graphical layout used in the illustrations provided herein.
It can be appreciated that variations to this invention would be readily apparent to those skilled in the art, and this invention is intended to include those variations.
Claims (15)
1. A system for editing a computer program, said program comprising a plurality of source code components, said system comprising:
a) a browser;
b) a graphical layout control accessible to said browser, said graphical layout control being invoked by said browser to display the relationships between said source code components as interconnected nodes;
c) an edit control accessible to said browser, said edit control having a plurality of edit views and edit windows;
d) each of said edit views corresponding to a portion of one of said source code components;
and e) each of said edit windows providing a user interface to said portion of one of the source code components corresponding to an edit view, thereby enabling the user to edit one of said source code components.
a) a browser;
b) a graphical layout control accessible to said browser, said graphical layout control being invoked by said browser to display the relationships between said source code components as interconnected nodes;
c) an edit control accessible to said browser, said edit control having a plurality of edit views and edit windows;
d) each of said edit views corresponding to a portion of one of said source code components;
and e) each of said edit windows providing a user interface to said portion of one of the source code components corresponding to an edit view, thereby enabling the user to edit one of said source code components.
2. The system of claim 1 wherein any of said edit views corresponding to a portion of one of said source code components corresponds to an entirety of one of said source code components.
3. A method for editing a computer program, said method comprising the steps of:
a) displaying to a user a hierarchical relationship between source code components of the computer program, each component being represented as a node;
b) providing means to allow the user to select one of said nodes for editing;
c) replacing said selected node with an edit window displaying said source code component, thereby permitting the user to edit said source code component while viewing the hierarchical relationship; and d) repeating steps b) to c).
a) displaying to a user a hierarchical relationship between source code components of the computer program, each component being represented as a node;
b) providing means to allow the user to select one of said nodes for editing;
c) replacing said selected node with an edit window displaying said source code component, thereby permitting the user to edit said source code component while viewing the hierarchical relationship; and d) repeating steps b) to c).
4. The method of claim 3 further comprising applying the method to a project such that prior to step a) the user is presented with the hierarchy of the programs within said project, each of said programs represented as a node, and providing means to allow the user to select a node, the selection of which displays the hierarchical structure of the program represented by the selected node.
5. The method of claims 3 or 4 further comprising the step of updating the display of said hierarchical relationship if changes made to said source code component edited by the user modify said hierarchical relationship.
6. The method of claim 5 further comprising the step of displaying to the user a pop-up menu associated with said edit window, said pop-up window providing the user with a plurality of editing and display options for the source code component displayed in said edit window.
7. The method of claim 6 further comprising the step of providing to the user a hierarchical navigation interface, said interface providing means to allow the user to navigate between the nodes in the order defined by said hierarchical relationship.
8. The method of claim 6 wherein said editing and display options comprises:
a) editing options for: cut, copy, paste, find, deselect all, filter, and show all;
b) a callers option that displays all nodes that call the selected node;
c) a topology option that displays the topology of the components within a program or the programs within a project; and d) an option to refresh the display of the hierarchical relationship, to display any relationship changes that may have occurred during editing.
a) editing options for: cut, copy, paste, find, deselect all, filter, and show all;
b) a callers option that displays all nodes that call the selected node;
c) a topology option that displays the topology of the components within a program or the programs within a project; and d) an option to refresh the display of the hierarchical relationship, to display any relationship changes that may have occurred during editing.
9. A system for editing a computer program, said system comprising:
a) a browser;
b) a graphical layout control accessible to said browser, said graphical layout control being invoked by said browser to provide a display of relationships between components of said computer program;
c) an edit control accessible to said browser, said edit control providing an interface permitting a user to select a component from within said display; and d) an edit window containing the contents of said selected component, said window replacing said selected component within said display, for the purpose of allowing the user to edit the contents of said selected component while viewing said display of relationships.
a) a browser;
b) a graphical layout control accessible to said browser, said graphical layout control being invoked by said browser to provide a display of relationships between components of said computer program;
c) an edit control accessible to said browser, said edit control providing an interface permitting a user to select a component from within said display; and d) an edit window containing the contents of said selected component, said window replacing said selected component within said display, for the purpose of allowing the user to edit the contents of said selected component while viewing said display of relationships.
10. The system of claim 9 wherein said edit control permits the user upon selecting a component, to display one of the hierarchy of source code segments within the selected component, and to display the entirety of the selected component for editing.
11. The system of claim 1 or claim 9 wherein said graphical layout control comprises:
a) a graphical manager, said graphical manager controlling the display of a graph view;
b) a plurality of node controls accessible to said graphical manager, to implement the display of nodes within said graph view; and c) a plurality of link controls accessible to said graphical manager, to implement the display of directional links between said nodes of said graph view.
a) a graphical manager, said graphical manager controlling the display of a graph view;
b) a plurality of node controls accessible to said graphical manager, to implement the display of nodes within said graph view; and c) a plurality of link controls accessible to said graphical manager, to implement the display of directional links between said nodes of said graph view.
12. The system of claim 11 further comprising a plurality of nested graph layout controls, so that any graph view implemented by a graph layout control may replace a node in a higher-level graph view.
13. The system of claim 12 further comprising a plurality of edit controls, each of said edit controls controlling a set of edit views and corresponding edit windows, said set corresponding to a specific level of detail within the source code being edited.
14. The system of claim 13 wherein said edit control further comprises:
a) an edit manager, said edit manager controlling the instantiation and management of the components within said edit control;
b) a text processing component, said text processing component controlling the loading of source code segments to be edited within an edit view;
c) a graphical user interface, said graphical user interface controlling the rendering of an edit view within an edit window;
d) a commands/macros interface, said commands/macros interface providing an interface between internal and external edit commands and said edit control;
e) an edit buffer, said edit buffer comprising a plurality of element structures, said element structures comprising text elements accessed by the text processing component;
f) a document control structure, said document control structure controlling which text elements of said edit buffer are to be displayed in said edit window;
g) a view control structure, providing control data for the display of an edit view;
h) a profiles and macros structure, said structure storing the profile information for an edit view; and i) a key actions structure, said structure storing the default actions for keys and mouse selection for said edit control.
a) an edit manager, said edit manager controlling the instantiation and management of the components within said edit control;
b) a text processing component, said text processing component controlling the loading of source code segments to be edited within an edit view;
c) a graphical user interface, said graphical user interface controlling the rendering of an edit view within an edit window;
d) a commands/macros interface, said commands/macros interface providing an interface between internal and external edit commands and said edit control;
e) an edit buffer, said edit buffer comprising a plurality of element structures, said element structures comprising text elements accessed by the text processing component;
f) a document control structure, said document control structure controlling which text elements of said edit buffer are to be displayed in said edit window;
g) a view control structure, providing control data for the display of an edit view;
h) a profiles and macros structure, said structure storing the profile information for an edit view; and i) a key actions structure, said structure storing the default actions for keys and mouse selection for said edit control.
15. A computer readable memory for storing the instructions for use in the execution in a computer of any one of the methods of claims 3 to 8.
Priority Applications (3)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CA002256931A CA2256931A1 (en) | 1998-12-23 | 1998-12-23 | Source editing in a graphical hierarchical environment |
| US09/399,235 US6792595B1 (en) | 1998-12-23 | 1999-09-16 | Source editing in a graphical hierarchical environment |
| DE19957780A DE19957780A1 (en) | 1998-12-23 | 1999-12-01 | Computer program editing system has editing effected in graphic environment by use of browser accessing layout control and editing control with editing icons and editing windows |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CA002256931A CA2256931A1 (en) | 1998-12-23 | 1998-12-23 | Source editing in a graphical hierarchical environment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CA2256931A1 true CA2256931A1 (en) | 2000-06-23 |
Family
ID=4163116
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CA002256931A Abandoned CA2256931A1 (en) | 1998-12-23 | 1998-12-23 | Source editing in a graphical hierarchical environment |
Country Status (3)
| Country | Link |
|---|---|
| US (1) | US6792595B1 (en) |
| CA (1) | CA2256931A1 (en) |
| DE (1) | DE19957780A1 (en) |
Cited By (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2006031640A2 (en) * | 2004-09-10 | 2006-03-23 | Graphlogic Inc. | Object process graph application development system |
| US7316001B2 (en) | 2004-06-05 | 2008-01-01 | Graphlogic Inc. | Object process graph system |
| US7328426B2 (en) * | 2003-08-13 | 2008-02-05 | International Business Machines Corporation | Editor with commands for automatically disabling and enabling program code portions |
| US7360209B2 (en) | 2004-07-16 | 2008-04-15 | Graphlogic Inc. | Object process graph application controller-viewer |
| US7493335B2 (en) | 2004-07-02 | 2009-02-17 | Graphlogic Inc. | Object process graph relational database interface |
| US20140344773A1 (en) * | 2013-04-15 | 2014-11-20 | Massively Parallel Technologies, Inc. | System And Method For Communicating Between Viewers Of A Hierarchical Software Design |
Families Citing this family (102)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6662356B1 (en) * | 1999-06-30 | 2003-12-09 | Microsoft Corporation | Application program interface for transforming heterogeneous programs |
| US20110191747A1 (en) | 1999-10-05 | 2011-08-04 | Borland Software Corporation | Supporting and deploying distributed computing components |
| US6763497B1 (en) * | 2000-04-26 | 2004-07-13 | Microsoft Corporation | Method and apparatus for displaying computer program errors as hypertext |
| JP3613554B2 (en) * | 2000-08-24 | 2005-01-26 | インターナショナル・ビジネス・マシーンズ・コーポレーション | Data display method, computer system for performing data display, and recording medium |
| US7191405B1 (en) * | 2000-11-22 | 2007-03-13 | Adobe Systems Incorporated | System and method for editing information |
| US6836884B1 (en) * | 2001-06-04 | 2004-12-28 | Microsoft Corporation | Method and system for editing software programs |
| JP4344105B2 (en) * | 2001-09-12 | 2009-10-14 | セイコーエプソン株式会社 | Source file generator |
| US7203925B1 (en) * | 2001-09-14 | 2007-04-10 | Emc Corporation | Graphical compiler |
| US6965990B2 (en) * | 2001-10-23 | 2005-11-15 | International Business Machines Corporation | Method and apparatus for providing programming assistance |
| US7243334B1 (en) * | 2002-01-16 | 2007-07-10 | Prelude Systems, Inc. | System and method for generating user interface code |
| US7299451B2 (en) * | 2002-01-24 | 2007-11-20 | International Business Machines Corporation | Remotely driven system for multi-product and multi-platform testing |
| JP2003241964A (en) * | 2002-02-13 | 2003-08-29 | Fujitsu Ltd | Software maintenance data generation device and generation program |
| US7089534B2 (en) * | 2002-05-01 | 2006-08-08 | International Business Machines Corporation | Model based test generation for validation of parallel and concurrent software |
| CA2391719A1 (en) * | 2002-06-26 | 2003-12-26 | Ibm Canada Limited-Ibm Canada Limitee | Editing files of remote systems using an integrated development environment |
| US20040003373A1 (en) * | 2002-06-28 | 2004-01-01 | Van De Vanter Michael L. | Token-oriented representation of program code with support for textual editing thereof |
| US20040006763A1 (en) * | 2002-06-28 | 2004-01-08 | Van De Vanter Michael L. | Undo/redo technique with insertion point state handling for token-oriented representation of program code |
| US7543281B2 (en) * | 2002-07-22 | 2009-06-02 | National Instruments Corporation | Disabling and conditionally compiling graphical code in a graphical program |
| US7305629B2 (en) * | 2002-09-26 | 2007-12-04 | International Business Machines Corporation | Consolidation of computer documentation |
| US20040143812A1 (en) * | 2003-01-14 | 2004-07-22 | Vladimir Bernstein | Automatic software design tool for building web and other applications wherein components are linked through connected command and control and data variables |
| AU2003272256A1 (en) * | 2003-03-05 | 2004-09-28 | Expert Consultants, Inc. | System and method for building a component-based architecture |
| US20040225998A1 (en) * | 2003-05-06 | 2004-11-11 | Sun Microsystems, Inc. | Undo/Redo technique with computed of line information in a token-oriented representation of program code |
| US20040225997A1 (en) * | 2003-05-06 | 2004-11-11 | Sun Microsystems, Inc. | Efficient computation of line information in a token-oriented representation of program code |
| US20040225960A1 (en) * | 2003-05-09 | 2004-11-11 | Microsoft Corporation | System for hosting graphical layout/presentation objects |
| US7607099B2 (en) * | 2003-11-03 | 2009-10-20 | Intentional Software Corporation | Method and system for reversible design tree transformations |
| US20050114832A1 (en) * | 2003-11-24 | 2005-05-26 | Microsoft Corporation | Automatically generating program code from a functional model of software |
| US7293232B2 (en) * | 2003-11-26 | 2007-11-06 | Microsoft Corporation | Source code editor for editing multilanguage documents |
| US7412689B1 (en) * | 2004-06-25 | 2008-08-12 | Sun Microsystems, Inc. | Method and apparatus for creating a hierarchical model to facilitate identifying components in a programming language file |
| US7457671B2 (en) * | 2004-09-30 | 2008-11-25 | Rockwell Automation Technologies, Inc. | Systems and methods that facilitate management of add-on instruction generation, selection, and/or monitoring during execution |
| US7631290B1 (en) * | 2004-10-27 | 2009-12-08 | Adobe Systems Incorporated | Enhanced navigation for visual design editing |
| US10216372B1 (en) * | 2004-12-06 | 2019-02-26 | The Mathworks, Inc. | Automatic import to a graphical model |
| US8185868B1 (en) * | 2004-12-20 | 2012-05-22 | The Mathworks, Inc. | System and method for cell-based code editing and publishing |
| US7412649B2 (en) * | 2005-01-24 | 2008-08-12 | International Business Machines Corporation | Viewing and editing markup language files with complex semantics |
| US7484203B2 (en) * | 2005-03-21 | 2009-01-27 | International Business Machines Corporation | Automated interaction diagram generation using source code breakpoints |
| US8812964B2 (en) * | 2005-03-31 | 2014-08-19 | International Business Machines Corporation | Managing evelopment of an enterprise application |
| US8365086B2 (en) * | 2005-05-03 | 2013-01-29 | The Mathworks, Inc. | System and method for building graphical instrument panels |
| US8327343B2 (en) * | 2005-10-20 | 2012-12-04 | Cisco Technology, Inc. | Method and system for optimizing source code |
| US8042065B2 (en) * | 2005-11-17 | 2011-10-18 | Microsoft Corporation | Smart copy/paste of graphical nodes |
| US20070180049A1 (en) * | 2006-01-31 | 2007-08-02 | Microsoft Corporation | Code hyperlinks |
| US20070234278A1 (en) * | 2006-03-02 | 2007-10-04 | Microsoft Corporation | Managing source code in a model-based development environment |
| US20070220481A1 (en) * | 2006-03-20 | 2007-09-20 | Microsoft Corporation | Limited source code regeneration based on model modification |
| US8065168B2 (en) * | 2006-04-25 | 2011-11-22 | Acs State And Local Solutions, Inc. | Method, system and computer program code for automatically generating software for reformatting incoming data |
| US7856617B2 (en) * | 2006-04-25 | 2010-12-21 | Acs State And Local Solutions, Inc. | Method, system and computer program product for creating software for processing an insurance claim |
| US20070256054A1 (en) * | 2006-04-28 | 2007-11-01 | Paul Byrne | Using 3-dimensional rendering effects to facilitate visualization of complex source code structures |
| US8141035B2 (en) * | 2006-07-05 | 2012-03-20 | International Business Machines Corporation | Method for accessing internal states of objects in object oriented programming |
| US8762834B2 (en) * | 2006-09-29 | 2014-06-24 | Altova, Gmbh | User interface for defining a text file transformation |
| US7949949B2 (en) * | 2006-11-20 | 2011-05-24 | Intentional Software Corporation | Domain transformation languages |
| US9645915B2 (en) | 2006-12-27 | 2017-05-09 | The Mathworks, Inc. | Continuous evaluation of program code and saving state information associated with program code |
| US9015671B2 (en) * | 2006-12-27 | 2015-04-21 | The Mathworks, Inc. | Integrating program construction |
| US8762956B1 (en) | 2007-01-31 | 2014-06-24 | The Mathworks, Inc. | Generating a report document from code |
| US7735019B2 (en) | 2007-04-25 | 2010-06-08 | International Business Machines Corporation | Method for providing functional context within an actively scrolling view pane |
| CN101681263B (en) * | 2007-05-16 | 2013-12-04 | 国际商业机器公司 | A consistent method system for developing software asset based solutions |
| US8484611B2 (en) * | 2007-10-15 | 2013-07-09 | International Business Machines Corporation | Method and system for simplified assembly of information processing applications |
| US8356287B2 (en) * | 2007-10-24 | 2013-01-15 | International Business Machines Corporation | Device, system and method of debugging computer programs |
| US8495100B2 (en) * | 2007-11-15 | 2013-07-23 | International Business Machines Corporation | Semantic version control system for source code |
| US8312426B2 (en) * | 2008-01-07 | 2012-11-13 | International Business Machines Corporation | Method and system for simplified service composition in web environment |
| US8239828B2 (en) * | 2008-01-08 | 2012-08-07 | International Business Machines Corporation | Method of recovering from software failures using replanning |
| US8245122B2 (en) * | 2008-01-08 | 2012-08-14 | International Business Machines Corporation | Method and system for modeling user requests, applications and components used in dynamic application assembly |
| US8640149B2 (en) * | 2008-03-26 | 2014-01-28 | International Business Machines Corporation | Method and apparatus for dynamic web service composition and invocation |
| US9098626B2 (en) * | 2008-04-01 | 2015-08-04 | Oracle International Corporation | Method and system for log file processing and generating a graphical user interface based thereon |
| US8949140B2 (en) * | 2008-04-21 | 2015-02-03 | International Business Machines Corporation | Method and system for dynamic software reconfiguration triggered by component- or system- initiated events |
| US8898624B2 (en) * | 2008-05-05 | 2014-11-25 | International Business Machines Corporation | Method and apparatus for simplified assembly of parametric information processing applications |
| US20090327862A1 (en) * | 2008-06-30 | 2009-12-31 | Roy Emek | Viewing and editing markup language files with complex semantics |
| US8762969B2 (en) * | 2008-08-07 | 2014-06-24 | Microsoft Corporation | Immutable parsing |
| US9123093B1 (en) | 2008-08-29 | 2015-09-01 | Cognex Corporation | Vision inspection programming method and apparatus |
| US8694959B2 (en) * | 2008-09-30 | 2014-04-08 | Ics Triplex Isagraf Inc. | Multi language editor |
| US8453112B1 (en) * | 2008-11-13 | 2013-05-28 | Adobe Systems Incorporated | Systems and methods for collaboratively creating applications using a multiple source file project that can be accessed and edited like a single file |
| US8561015B2 (en) * | 2009-06-15 | 2013-10-15 | Microsoft Corporation | Source code semantic zoom and spatial layout |
| US8689126B2 (en) * | 2010-06-24 | 2014-04-01 | Adobe Systems Incorporated | Displaying graphical indications to indicate dependencies between scripts |
| US8607191B2 (en) * | 2010-06-30 | 2013-12-10 | International Business Machines Corporation | Automated discovery of programmatic resources |
| US9558525B2 (en) * | 2010-10-06 | 2017-01-31 | The Board Of Trustees Of The Leland Stanford Junior University | Process communication method and system |
| JP5613118B2 (en) * | 2011-07-22 | 2014-10-22 | インターナショナル・ビジネス・マシーンズ・コーポレーションＩｎｔｅｒｎａｔｉｏｎａｌ Ｂｕｓｉｎｅｓｓ Ｍａｃｈｉｎｅｓ Ｃｏｒｐｏｒａｔｉｏｎ | Conversion rule generation support apparatus, method, and program |
| JP2013059969A (en) * | 2011-09-15 | 2013-04-04 | Kyocera Document Solutions Inc | Data processing apparatus and data file |
| JP5804898B2 (en) * | 2011-10-31 | 2015-11-04 | 三菱電機株式会社 | Software development support apparatus and program |
| US20130227396A1 (en) * | 2012-02-24 | 2013-08-29 | Microsoft Corporation | Editing content of a primary document and related files |
| US8856766B2 (en) * | 2012-05-11 | 2014-10-07 | International Business Machines Corporation | Generating layouts for graphs of data flow applications |
| US9286032B2 (en) | 2013-03-15 | 2016-03-15 | International Business Machines Corporation | Automated software composition |
| US20140189650A1 (en) * | 2013-05-21 | 2014-07-03 | Concurix Corporation | Setting Breakpoints Using an Interactive Graph Representing an Application |
| US8990777B2 (en) | 2013-05-21 | 2015-03-24 | Concurix Corporation | Interactive graph for navigating and monitoring execution of application code |
| US9734040B2 (en) | 2013-05-21 | 2017-08-15 | Microsoft Technology Licensing, Llc | Animated highlights in a graph representing an application |
| WO2014189553A1 (en) * | 2013-05-21 | 2014-11-27 | Concurix Corporation | Graph for navigating application code |
| US9547505B2 (en) * | 2013-06-04 | 2017-01-17 | Sap Se | Adaptive contextual graphical representation of development entities |
| US9280841B2 (en) | 2013-07-24 | 2016-03-08 | Microsoft Technology Licensing, Llc | Event chain visualization of performance data |
| US9477463B2 (en) * | 2013-08-12 | 2016-10-25 | Khan Academy, Inc. | Systems and methods for creating a program spin-off |
| US9292415B2 (en) | 2013-09-04 | 2016-03-22 | Microsoft Technology Licensing, Llc | Module specific tracing in a shared module environment |
| US9053228B1 (en) | 2013-10-22 | 2015-06-09 | The Mathworks, Inc. | Determining when to evaluate program code and provide results in a live evaluation programming environment |
| US10346292B2 (en) | 2013-11-13 | 2019-07-09 | Microsoft Technology Licensing, Llc | Software component recommendation based on multiple trace runs |
| US9501205B2 (en) * | 2013-12-16 | 2016-11-22 | Sap Se | Nature inspired interaction paradigm |
| US9519398B2 (en) | 2013-12-16 | 2016-12-13 | Sap Se | Search in a nature inspired user interface |
| CN105320504B (en) * | 2014-06-25 | 2018-08-17 | 成都普中软件有限公司 | A kind of visual software modeling method constructing software view based on software member view |
| US9910647B2 (en) * | 2015-02-13 | 2018-03-06 | Unisys Corporation | Field size calculation and color coding display options usable in an emulated integrated development environment (IDE) |
| US11144283B2 (en) | 2015-05-20 | 2021-10-12 | Ab Initio Technology Llc | Visual program specification and compilation of graph-based computation |
| US10540449B2 (en) * | 2015-09-22 | 2020-01-21 | Oath Inc. | In-context translation review |
| WO2017086721A1 (en) * | 2015-11-18 | 2017-05-26 | Samsung Electronics Co., Ltd. | Method and apparatus for navigation in webpage |
| US10713015B2 (en) * | 2016-05-15 | 2020-07-14 | Servicenow, Inc. | Visual programming system |
| US10782963B2 (en) * | 2017-09-11 | 2020-09-22 | Siemens Industry Software GmbH | Introducing artifact information system and method |
| EP3588257A1 (en) * | 2018-06-26 | 2020-01-01 | ABB Schweiz AG | Adaptive visualization of device symbols by computers that control a technical system |
| JP7105683B2 (en) * | 2018-12-07 | 2022-07-25 | 株式会社東芝 | Electronic computer, method and program |
| US10937213B2 (en) * | 2019-06-27 | 2021-03-02 | Fuji Xerox Co., Ltd. | Systems and methods for summarizing and steering multi-user collaborative data analyses |
| CN110780897B (en) * | 2019-08-26 | 2022-05-10 | 华为云计算技术有限公司 | Code changing method and device |
| CN111427562A (en) * | 2020-03-27 | 2020-07-17 | 天津光电通信技术有限公司 | Integrated development environment editor suitable for single function |
| US11930013B1 (en) * | 2020-11-23 | 2024-03-12 | Amazon Technologies, Inc. | Access control list (ACL) based static analysis of software application artifacts |
| WO2022221418A1 (en) * | 2021-04-14 | 2022-10-20 | Nvidia Corporation | Application programming interface to locate incomplete graph code |
Family Cites Families (26)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5544067A (en) * | 1990-04-06 | 1996-08-06 | Lsi Logic Corporation | Method and system for creating, deriving and validating structural description of electronic system from higher level, behavior-oriented description, including interactive schematic design and simulation |
| AU4279893A (en) * | 1992-04-10 | 1993-11-18 | Avid Technology, Inc. | A method and apparatus for representing and editing multimedia compositions |
| JP2768412B2 (en) * | 1992-07-15 | 1998-06-25 | 財団法人ニューメディア開発協会 | User adaptive system and adaptive method |
| US5379366A (en) * | 1993-01-29 | 1995-01-03 | Noyes; Dallas B. | Method for representation of knowledge in a computer as a network database system |
| US5689641A (en) * | 1993-10-01 | 1997-11-18 | Vicor, Inc. | Multimedia collaboration system arrangement for routing compressed AV signal through a participant site without decompressing the AV signal |
| CA2134059C (en) * | 1993-10-29 | 2009-01-13 | Charles Simonyi | Method and system for generating a computer program |
| US5511158A (en) * | 1994-08-04 | 1996-04-23 | Thinking Machines Corporation | System and method for creating and evolving directed graphs |
| US5729674A (en) * | 1995-04-07 | 1998-03-17 | Computer Humor Systems, Inc. | Method and apparatus for producing personalized graphics and personalized text printed materials |
| US5872974A (en) * | 1995-04-19 | 1999-02-16 | Mezick; Daniel J. | Property setting manager for objects and controls of a graphical user interface software development system |
| US5692184A (en) * | 1995-05-09 | 1997-11-25 | Intergraph Corporation | Object relationship management system |
| US5794006A (en) * | 1995-08-18 | 1998-08-11 | Microsoft Corporation | System and method for editing content in an on-line network |
| US5815717A (en) * | 1995-10-27 | 1998-09-29 | Authorgenics, Inc. | Application program and documentation generator system and method |
| US5960447A (en) * | 1995-11-13 | 1999-09-28 | Holt; Douglas | Word tagging and editing system for speech recognition |
| US6029182A (en) * | 1996-10-04 | 2000-02-22 | Canon Information Systems, Inc. | System for generating a custom formatted hypertext document by using a personal profile to retrieve hierarchical documents |
| DE69808632T2 (en) * | 1997-07-25 | 2003-06-12 | British Telecomm | Creation of software systems |
| US6185591B1 (en) * | 1997-07-29 | 2001-02-06 | International Business Machines Corp. | Text edit system with enhanced undo user interface |
| GB9726654D0 (en) * | 1997-12-17 | 1998-02-18 | British Telecomm | Data input and retrieval apparatus |
| US6269275B1 (en) * | 1998-03-31 | 2001-07-31 | Michael G. Slade | Method and system for customizing and distributing presentations for user sites |
| US6167406A (en) * | 1998-05-08 | 2000-12-26 | Allen-Bradley Company, Llc | System, method and article of manufacture for building an enterprise-wide data model |
| US6237135B1 (en) * | 1998-06-18 | 2001-05-22 | Borland Software Corporation | Development system with visual design tools for creating and maintaining Java Beans components |
| US6377259B2 (en) * | 1998-07-29 | 2002-04-23 | Inxight Software, Inc. | Presenting node-link structures with modification |
| US6263339B1 (en) * | 1998-08-25 | 2001-07-17 | Informix Software, Inc. | Dynamic object visualization and code generation |
| US6493868B1 (en) * | 1998-11-02 | 2002-12-10 | Texas Instruments Incorporated | Integrated development tool |
| US6243859B1 (en) * | 1998-11-02 | 2001-06-05 | Hu Chen-Kuang | Method of edit program codes by in time extracting and storing |
| US6473794B1 (en) * | 1999-05-27 | 2002-10-29 | Accenture Llp | System for establishing plan to test components of web based framework by displaying pictorial representation and conveying indicia coded components of existing network framework |
| US6601233B1 (en) * | 1999-07-30 | 2003-07-29 | Accenture Llp | Business components framework |
-
1998
- 1998-12-23 CA CA002256931A patent/CA2256931A1/en not_active Abandoned
-
1999
- 1999-09-16 US US09/399,235 patent/US6792595B1/en not_active Expired - Fee Related
- 1999-12-01 DE DE19957780A patent/DE19957780A1/en not_active Ceased
Cited By (11)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7328426B2 (en) * | 2003-08-13 | 2008-02-05 | International Business Machines Corporation | Editor with commands for automatically disabling and enabling program code portions |
| US8255872B2 (en) | 2003-08-13 | 2012-08-28 | International Business Machines Corporation | Editor with commands for automatically disabling and enabling program code portions |
| US8898631B2 (en) | 2003-08-13 | 2014-11-25 | International Business Machines Corporation | Editor with commands for automatically disabling and enabling program code portions |
| US7316001B2 (en) | 2004-06-05 | 2008-01-01 | Graphlogic Inc. | Object process graph system |
| US7493335B2 (en) | 2004-07-02 | 2009-02-17 | Graphlogic Inc. | Object process graph relational database interface |
| US7360209B2 (en) | 2004-07-16 | 2008-04-15 | Graphlogic Inc. | Object process graph application controller-viewer |
| WO2006031640A2 (en) * | 2004-09-10 | 2006-03-23 | Graphlogic Inc. | Object process graph application development system |
| WO2006031640A3 (en) * | 2004-09-10 | 2006-06-01 | Graphlogic Inc | Object process graph application development system |
| US7536676B2 (en) | 2004-09-10 | 2009-05-19 | Newalliance Bank | Object process graph application controller-viewer |
| US20140344773A1 (en) * | 2013-04-15 | 2014-11-20 | Massively Parallel Technologies, Inc. | System And Method For Communicating Between Viewers Of A Hierarchical Software Design |
| US9158502B2 (en) * | 2013-04-15 | 2015-10-13 | Massively Parallel Technologies, Inc. | System and method for communicating between viewers of a hierarchical software design |
Also Published As
| Publication number | Publication date |
|---|---|
| DE19957780A1 (en) | 2000-07-06 |
| US6792595B1 (en) | 2004-09-14 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US6792595B1 (en) | Source editing in a graphical hierarchical environment | |
| US8386919B2 (en) | System for displaying an annotated programming file | |
| US6915301B2 (en) | Dynamic object properties | |
| US6175364B1 (en) | Framework and method for interfacing a GUI, container with a GUI component | |
| Reiss | Interacting with the FIELD environment | |
| US5339433A (en) | Symbol browsing in an object-oriented development system | |
| AU768367B2 (en) | Property based context portals | |
| Wong | Rigi user’s manual | |
| US7908550B1 (en) | Dynamic tree control system | |
| US5220675A (en) | Method and system for customizing a user interface in an integrated environment | |
| AU699292B2 (en) | Apparatus for visualizing program slices | |
| US6976209B1 (en) | Activemark mechanism in a live parsing editor | |
| US6263339B1 (en) | Dynamic object visualization and code generation | |
| US7039875B2 (en) | Computer user interfaces that are generated as needed | |
| EP0696770B1 (en) | Class library for use in graphics programming | |
| US20030067481A1 (en) | System and method for computer-aided graph-based dependency analysis with integrated documentation | |
| EP0622729A2 (en) | A user interface builder for a user interface server | |
| US20050125787A1 (en) | Convertible runtime graphical user interface | |
| JPH07168710A (en) | System and method for constitution of program | |
| US5802334A (en) | Method for displaying object oriented class information and content information | |
| US20030081007A1 (en) | Object oriented explorer type environment | |
| Möller | User interface management systems: the CLIM perspective | |
| Berlage | The GINA Interface Builder | |
| Guarna et al. | A portable user interface for a scientific programming environment | |
| Graham | The Clock Language |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| EEER | Examination request | ||
| FZDE | Discontinued |