Dynamic graphical user interface feature-set configuration

• US 6,208,336 B1
• Filed: 03/20/1998
• Issued: 03/27/2001
• Est. Priority Date: 03/20/1998
• Status: Expired due to Term

• Current Assignee: Oracle America, Inc. (Oracle Corporation)
• Original Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Inventors: Carter, Kapono D.
• Primary Examiner(s): Bayerl, Raymond J.
• Assistant Examiner(s): Thai, Cuong T.
• Application Number:
  US09/044,918
• Time in Patent Office: 1,103 Days
• Field of Search: 345/335, 345/333, 345/339, 395/712, 709/302, 709/303
• US Class Current: 715/866
• CPC Class Codes: G06F 9/451 Execution arrangements for user interfaces

Abstract

A system dynamically constructs a graphical user interface associated with an application. A command class library stores command classes that represent additional functions to be integrated with the application. An execution unit attempts to instantiate the command classes at run-time of the application, determines which of the command classes were instantiated successfully, and constructs the graphical user interface for the application such that the graphical user interface contains the additional functions of the successfully instantiated command classes.

Claims

1. A system that dynamically constructs a graphical user interface associated with a program, comprising:

a command class library to store at least one command class, the command class representing an additional function for use with the program; and

an execution unit to attempt to instantiate the command class at run-time of the program without updating the program to determine whether the command class was instantiated successfully, and to construct the graphical user interface such that the graphical user interface contains the additional function corresponding to the successfully instantiated command class, wherein the execution unit includes a configuration component to modify the graphical user interface by inserting visual controls for invoking the additional function of the successfully instantiated command class, and to display the modified graphical user interface on a visual display, without user intervention.

2. The system of claim 1, wherein the command class includes:

a constructor to locate items for successful instantiation of the command class when invoked by the execution unit.

3. The system of claim 2, wherein the constructor includes:

a notification component that informs the execution unit whether all items were located, and when the constructor fails to locate at least one of the items, that informs the execution unit that the additional function of the command class is unavailable.

4. The system of claim 1, wherein the execution unit includes:

a reconfiguration component to modify the graphical user interface by adding or removing visual controls for invoking the additional function of the successfully instantiated command class.

5. The system of claim 1, wherein the execution unit includes:

a display component to display a basic graphical user interface on a visual display when the command class is not successfully instantiated.

6. A computer-implemented method for dynamically constructing a user interface associated with a program, command classes associated with the program representing additional functions for use by the program, comprising the steps of:

attempting to instantiate the command classes without updating the program;

determining which of the command classes are instantiated successfully;

constructing the user interface such that the user interface contains the additional functions corresponding to the successfully instantiated command classes;

modifying the user interface by inserting visual controls for invoking the additional function of the successfully instantiated command class, without user intervention; and

displaying the modified graphical user interface on a visual display.

7. The method of claim 6, wherein the attempting step includes the substeps of:

locating items for successful instantiation of the command classes, and

declaring an instantiation successful when all of the items are located.

8. The method of claim 7, wherein the declaring substep includes the substep of:

determining the instantiation unsuccessful when the locating substep fails to locate at least one of the items.

9. The method of claim 6, wherein the constructing step includes the substep of:

modifying the user interface by adding or removing visual representations for invoking the additional functions of the successfully instantiated command classes.

10. The method of claim 6, wherein the constructing step includes the substep of:

displaying a basic user interface on a visual display when the attempting step fails to successfully instantiate any of the command classes.

11. A computer program product stored on a computer-readable medium for dynamically constructing a user interface associated with a program, command classes associated with the program representing additional functions for use by the program, comprising:

an instantiation module to attempt to instantiate the command classes at run-time of the program without updating the program, and to determine which of the command classes were instantiated successfully; and

a configuration module to construct the user interface such that the user interface contains the additional functions corresponding to the successfully instantiated command classes, wherein the configuration module includes;

a modification component to modify the user interface by inserting visual representations for invoking the additional functions of the successfully instantiated command classes, without user intervention, and

a display component to display the modified user interface on a visual display.

12. The computer program product of claim 11, wherein the instantiation module includes:

a locating component to locate items for successful instantiation of the command classes, and

a reporting component to declare an instantiation of one of the command classes successful when all of the items for the command class are located.

13. The computer program product of claim 12, wherein the reporting component includes:

a determination component to declare the instantiation unsuccessful when the locating component fails to locate at least one of the items for the command class.

14. The computer program product of claim 11, wherein the configuration module includes:

a modification component to modify the user interface by adding or removing visual representations for invoking the additional functions of the successfully instantiated command classes.

15. The computer program product of claim 11, wherein the configuration module includes:

a display component to display a basic user interface on a visual display when the instantiation module fails to successfully instantiate any of the command classes.

16. A data processing system comprising:

a memory including

a program,

a command class area to store a plurality of command classes that represent additional modules for use with the program, and

a runtime environment to attempt to instantiate the command classes at run-time of the program without updating the program, to determine which of the command classes were instantiated successfully, and to construct a graphical user interface for the program by adding or removing visual controls for invoking the additional modules of the successfully instantiated command classes; and

a processor for executing the program and the runtime environment.

17. In a system including a memory containing a command class library storing a plurality of command classes representing additional functions for use with a program, and a runtime environment, the runtime environment comprising:

an instantiation module configured to attempt to instantiate the command classes during execution of the program, without updating the program, and to determine which of the command classes were instantiated successfully; and

a configuration module configured to construct a user interface for the program such that the user interface contains the additional functions corresponding to the successfully instantiated command classes, and

wherein the configuration module includes a modification component to modify the user interface, without user intervention, by inserting visual controls for invoking the additional functions of any successfully instantiated command classes.

18. A method that dynamically constructs a graphical user interface associated with a program, comprising the steps of:

storing a plurality of command classes in a memory, each of the command classes representing a module for use with the program;

executing the program;

attempting to locate items for successful instantiation of the command classes during execution of the program without updating the program;

declaring an instantiation of one of the command classes successful only if all of the items for the command class are located;

constructing the graphical user interface by adding or removing visual controls without user intervention, for invoking the modules associated with the successfully instantiated command classes to or from a basic graphical user interface for the program.

19. A system for dynamically constructing a graphical user interface associated with a program, comprising:

a command class library to store a plurality of command classes, the command classes representing an additional function for use with the program, wherein each command class includes;

a constructor for maintaining a list of required packages that each respective command class requires to perform its associated additional function; and

a package portion for instantiating the packages, and

an execution unit to attempt to instantiate a predetermined number of command classes from the plurality of command classes, to invoke each constructor in the predetermined number of command classes to attempt to locate any packages needed for successful instantiation of each command class, and to construct a graphical user interface that contains functions corresponding to the program and any successfully instantiated command classes.

20. The system of claim 19, wherein the constructor includes:

an exception component for generating an exception in response to each constructor failing to locate a required package for each respective command class.

21. The system of claim 20, wherein the execution unit includes:

an exception receiving component for receiving each exception generated by the exception component and excluding each respective command class associated with a missing required package from the graphical user interface.

22. A method for dynamically constructing a graphical user interface associated with a program, comprising the steps of

storing a plurality of command classes in a memory, each command class representing an additional function for use with the program;

executing the program;

attempting to locate items for successful instantiation of the command classes during execution of the program;

declaring an instantiation of one of the command classes successful only if all of the items for the command class are located;

constructing a default graphical user interface including default program functions in the event none of the command classes are instantiated; and

constructing a second graphical user interface including the default program functions and functions corresponding to any successfully instantiated command classes.

23. The method of claim 22, wherein attempting to locate items includes:

generating an exception in the event one or more items could not be located, wherein the program continues to execute after the exception is generated.

24. A data processing system comprising:

a memory including

a program,

a command class area to store a plurality of command classes that represent additional modules for use with the program, wherein the command class includes a constructor to locate items for successful instantiation of the command class; and

a runtime environment to attempt to instantiate the command classes at run-time of the program without updating the program, to determine which of the command classes were instantiated successfully, and to construct a graphical user interface for the program by adding or removing visual controls for invoking the additional modules of the successfully instantiated command classes, without user intervention; and

a processor for executing the program and the runtime environment.