Semantic interpretation of software models for generating user interfaces

• US 8,132,147 B2
• Filed: 05/29/2007
• Issued: 03/06/2012
• Est. Priority Date: 05/29/2007
• Status: Active Grant

• Current Assignee: SAP SE
• Original Assignee: SAP AG (SAP SE)
• Inventors: Lochmann, Henrik
• Primary Examiner(s): DENG, ANNA CHEN
• Application Number:
  US11/807,384
• Publication Number:
  US 20080301628A1
• Time in Patent Office: 1,743 Days
• Field of Search: 717104-108
• US Class Current: 717/106
• CPC Class Codes: G06F 8/10 Requirements analysis; Specification techniques
• CPC Class Codes: G06F 8/38 for implementing user interfaces

Abstract

In one embodiment the present invention includes a method of generating a user interface comprising storing an interpretation model that describes program logic corresponding to a user interface for a computer program. Elements of the interpretation model may be bound with one or more user interface fragments. In one embodiment, the UI fragments may be specified in a user interface specification. User interface components may be generated based on said interpretation model, the user interface components comprising a plurality of said user interface fragments. In one embodiment, if the program logic is changed, a new user interface may be generated that works with the changed program logic.

Claims

1. A computerized method of generating a user interface for a computer program, the method comprising:

storing, via a computer system in a non-transitory memory, an interpretation model of program logic, wherein the interpretation model describes the program logic corresponding to the user interface, and the program logic includes information for constructs for a logical behavior of the computer program;

storing, via the computer system in a non-transitory memory, a user interface specification, which includes identifiers for elements included in a set of elements and the elements are associated with user interface fragments, wherein the interpretation model is configured to include one or more elements from the set of elements;

parsing, via the computer system, the user interface specification to identify the elements;

identifying, via a search by the computer system, the one or more elements included in the interpretation model, wherein the one or more elements identified via the search are included in the program logic;

binding, via the computer system, the one or more elements identified in the interpretation model with one or more of the user interface fragments, which are associated with the elements in the user interface specification; and

generating, via the computer system, user interface components based on said interpretation model, the user interface components comprising a plurality of said user interface fragments based on the binding, wherein said user interface fragments include visual user interface fragments and functional user interface fragments, the functional user interface fragments include executable code for implementing the user interface and binding with the program logic, so that particular user interface views and functionality can be implemented at runtime that correspond to the computer program logic to capture and implement the user interface.

2. The method of claim 1 wherein the interpretation model describes the program logic using an ontology.

3. The method of claim 1 wherein the interpretation model describes the program logic as one or more of an object, an event, a state, and an action.

4. The method of claim 1 wherein the interpretation model describes the program logic as one or more of an actuality, an event, a situation, and an action.

5. The method of claim 1 wherein said binding is specified in a user interface specification.

6. The method of claim 1 wherein the interpretation model comprises rules that change the model based on the program logic, and in accordance therewith, the user interface components are automatically adapted to changes in the program logic.

7. The method of claim 1 further comprising searching the interpretation model for specified elements of said interpretation model.

23. The method of claim 1, wherein the user interface fragments include visual user interface fragments.

24. The method of claim 23, wherein the visual user interface fragments include a button, a frame, a menu, a table, or a tree.

25. The method of claim 23, wherein the user interface fragments include functional user interface fragments.

26. The method of claim 25, wherein the functional user interface fragments include executable code for implementing the user interface and binding with the program logic.

8. A computerized method of generating a user interface for a computer program, the method comprising:

storing, in a non-transitory memory, metadata that describes program logic corresponding to the user interface, wherein the program logic includes information for constructs for a logical behavior of the computer program, the metadata describes the program logic using metadata elements comprising one or more of a state, an event, an object, and an action, and wherein the metadata further comprises rules specifying alternative configurations of said program logic and corresponding alternative metadata elements;

receiving a user interface specification, the user interface specification specifying an association between one or more the metadata elements and one or more user interface fragments;

parsing, via the computer system, the user interface specification to identify the metadata elements;

performing a query to search the metadata for the one or more of the metadata elements specified in the user interface specification, wherein the query searches the metadata for the elements specified in the user interface specification in accordance with said rules;

returning a query result comprising metadata elements identified in the metadata via the query;

linking at least some of the identified metadata elements in the query result with some of the user interface fragments based on the association between the one or more of the metadata elements and the one or more of the user interface fragments specified in the user interface specification;

generating first user interface components based on said identified metadata elements in the query result, the first user interface components comprising a first plurality of said user interface fragments based on the linking, wherein said user interface fragments include visual user interface fragments and functional user interface fragments, the functional user interface fragments include executable code for implementing the user interface and binding with the program logic, so that particular user interface views and functionality can be implemented at runtime that correspond to the computer program logic to capture and implement the user interface; and

changing the program logic including;

capturing changes in the program logic by the interpretation model; and

automatically generating second user interface components by translating the changes in the program logic into corresponding changes in the user interface based on the rules specifying alternative configurations of said program logic and corresponding alternative metadata elements in said metadata, the second user interface components comprising a second plurality of said user interface fragments, so that alternative user interface views and functionality can be implemented at runtime that correspond to the changes in computer program logic to capture and implement an alternative user interface.

9. The method of claim 8 wherein the user interface specification is a template executed on a template engine.

10. The method of claim 8 wherein the user interface components comprise XML files describing a user interface.

11. The method of claim 8 wherein the user interface components comprise controllers for interfacing with the program logic.

12. A non-transitory computer-readable medium containing instructions for controlling a computer system to perform a method of generating a user interface for a computer program, the method comprising:

storing metadata that describes program logic corresponding to the user interface, wherein the program logic includes information for constructs for a logical behavior of the computer program, and the metadata describes the program logic using metadata elements including one or more of a situation, an event, an actuality, and an action, wherein the metadata further comprises rules specifying alternative configurations of said program logic and corresponding alternative metadata elements;

receiving a user interface specification, the user interface specification specifying an association between one or more the metadata elements and one or more user interface fragments;

parsing, via the computer system, the user interface specification to identify the one or more of the metadata elements;

performing a query to search the metadata for the one or more elements specified in the user interface specification;

returning a query result comprising metadata elements identified in the metadata via the query;

linking the identified metadata elements in the query result with a plurality of interface fragments based on the association between the one or more of the metadata elements and the one or more of the user interface fragments specified in the user interface specification;

generating first user interface components based on said identified metadata elements in the query result, the first user interface components comprising a first plurality of said user interface fragments based on the linking, wherein said user interface fragments include visual user interface fragments and functional user interface fragments, the functional user interface fragments include executable code for implementing the user interface and binding with the program logic, so that particular user interface views and functionality can be implemented at runtime that correspond to the computer program logic to capture and implement the user interface; and

changing the program logic including,

capturing changes in the program logic by the interpretation model; and

automatically generating second user interface components by translating the changes in the program logic into corresponding changes in the user interface based on the rules specifying alternative configurations of said program logic and corresponding alternative metadata elements in said metadata, the second user interface components comprising a second plurality of said user interface fragments, so that alternative user interface views and functionality can be implemented at runtime that correspond to the changes in computer program logic to capture and implement an alternative user interface.

13. The non-transitory computer-readable medium of claim 12 wherein the metadata describes the program logic using an ontology.

14. The non-transitory computer-readable medium of claim 12 wherein the metadata describes the program logic as one or more of an object, an event, a state, and an action.

15. The non-transitory computer-readable medium of claim 12 wherein the metadata describes the program logic as one or more of an actuality, an event, a situation, and an action.

16. The non-transitory computer-readable medium of claim 12 wherein said binding is specified in a user interface specification.

17. The non-transitory computer-readable medium of claim 12 wherein the metadata comprises rules that change the model based on the program logic, and in accordance therewith, the user interface components are automatically adapted to changes in the program logic.

18. The non-transitory computer-readable medium of claim 12 further comprising searching metadata for one or more specified metadata elements.

19. A computer system including software for generating a user interface for a computer program, the system comprising:

a non-transitory computer-readable medium configured to store;

a computer program comprising program logic, wherein the program logic includes information for constructs for a logical behavior of the computer program;

an interpretation model that describes said program logic corresponding to a user interface for said computer program as a plurality of model elements, wherein the interpretation model further comprises rules specifying alternative configurations of said program logic and corresponding alternative interpretation model elements;

one or more of user interface fragments;

a user interface specification, the user interface specification specifying an association between one or more of the model elements and the one or more of the user interface fragments;

computer code for parsing the user interface specification to identify the model elements;

computer code for identifying via a search the one or more of the model elements, from the user interface specification, included in the program logic;

computer code for binding the one or more model elements from the interpretation model with the one or more of the user interface fragments; and

a user interface component generator for generating first user interface components based on said association between the one or more of the model elements and the one or more of the user interface fragments, the first user interface components comprising a first plurality of said user interface fragments based on the binding, wherein said user interface fragments include visual user interface fragments and functional user interface fragments, the functional user interface fragments include executable code for implementing the user interface and binding with the program logic, so that particular user interface views and functionality can be implemented at runtime that correspond to the computer program logic to capture and implement the user interface;

computer code for changing the program logic including;

computer code for capturing changes in the program logic by the interpretation model; and

the user interface component generator automatically generating second user interface components by translating the changes in the program logic into corresponding changes in the user interface based on the rules specifying alternative configurations of said program logic and corresponding alternative metadata elements in said metadata, the second user interface components comprising a second plurality of said user interface fragments, so that alternative user interface views and functionality can be implemented at runtime that correspond to the changes in computer program logic to capture and implement an alternative user interface.

20. The computer system of claim 19 wherein the interpretation model describes the program logic using an ontology.

21. The computer system of claim 19 wherein the interpretation model describes the program logic using elements comprising one or more of a state, an event, a object, and an action.

22. The computer system of claim 19 further comprising a query, wherein the query performs search for model elements specified in the user interface specification, and wherein the query searches the interpretation model for the model elements specified in the user interface specification in accordance with said rules and returns a query result comprising model elements, and wherein model elements in the query result are linked with the one or more user interface fragments based on the association specified in the user interface specification.