Process of designing user's interfaces for application programs

Claims

What is claimed is:

1. A method for invoking a user interface for use with an application operating in a computer system comprising the steps of:

providing in the computer system a generic object class that corresponds to a class of function performed with the user interface;

specifying in the application instance data in the form of a generic object specification that corresponds to the generic object class, the instance data including attribute criteria, which are criteria that must be met by a specific user interface implementation that is selected using the instance data, and hint criteria, which are criteria that are permitted but not required to be specified in the instance data, and if specified, are permitted but not required to be met by a specific user interface implementation that is selected using the instance data;

providing in the computer system a specific use interface toolbox and controller that operates in the computer system to provide a selection of possible specific user interface implementations for use in performing the class of function; and

providing in the computer system an interpreter for the specific user interface toolbox and controller, the interpreter operating in the computer system to select a specific user interface implementation from the selection of possible specific user interface implementations, such that a selected specific user interface implementation satisfies both the attribute criteria and hint criteria specified for the generic object class, except if no specific user interface implementation satisfies both the attribute criteria and hint criteria specified for the generic object class then the interpreter being operable to select another specific user interface implementation that satisfies the attribute criteria but not all of the hint criteria that have been specified for the generic object class.

2. The method of claim 1 wherein said step of providing a generic object class in the computer system includes providing a library of generic objects classes, each respective generic object class in said library representing a respective class of functions.

3. The method of claim 1 wherein:

said step of providing a generic object class in the computer system includes providing in the computer system multiple generic object classes, each of which corresponds to a different class of function performed with the user interface; and

said step of specifying instance data includes specifying in the application multiple respective generic object specifications.

4. The method of claim 3 wherein said step of specifying multiple respective generic object specifications includes specifying a tree hierarchy relationship among the multiple respective generic object classes.

5. The method of claim 3 wherein:

said step of specifying multiple respective generic object specifications includes specifying a tree hierarchy relationship among the multiple respective generic object classes; and

said tree hierarchy provides an indication of which visual user interface components are to be in plain view and which such visual user interface components are to be hiddend by other such components.

6. The method of claim 1 wherein the generic object class is of a GenListClass that encompasses the generic user interface functionality of selecting from among multiple choices.

7. The method of claim 1 wherein the generic object class is of a GenTriggerClass that encompasses the generic user interface functionality of using a screen image to invoke an action.

8. A method for invoking a user interface for use with an application operating in a computer system comprising the steps of:

providing in the computer system multiple respective generic object classes that respectively correspond to respective classes of function performed with the user interface;

specifying in the application instance data in the form of a generic object specification that corresponds to a designated one of the respective generic object classes provided in the computer system, the instance data including respective attribute criteria, which are criteria that must be met by a specific user interface implementation that is selected using the instance data nd respective hint criteria, which are criteria that are permitted but not required to be specified in the instance data, and if specified, are permitted but not required to be met by a specific user interface implementation that is selected using the instance data; and

providing in the computer system a specific user interface toolbox and controller that operates in the computer system to provide a selection of possible specific user interface implementations for use in performing the class of function of the designated generic object class; and

providing in the computer system an interpreter that corresponds to the specific user interface toolbox and controller, the interpreter operating in the computer system to select a specific user interface implementation from the selection of possible specific user interface implementations, such that a selected specific user interface implementation satisfies both the respective attribute criteria and the respective hint criteria specified for the designated generic object class, except if no specific user interface implementation satisfies both the respective attribute criteria and the respective hint criteria specified for the designated generic object class then the interpreter being operable to select another specific user interface implementation that satisfies the respective attribute criteria but not all of the hint criteria that have been specified for the designated generic object class.

9. A method for designating a user interface for use with an application operating in a computer system comprising the steps of:

providing in the computer system a first generic object class and a second generic object class wherein each such respective generic object class corresponds to a respective class of function to be performed using the user interface;

specifying in the application first instance data in the form of a first generic object specification that corresponds to the first generic object class, the first instance data including first attribute criteria, which are criteria that must be met by a specific user interface implementation that is selected using the first instance data, and first hint criteria, which are criteria that are permitted but not required to be specified in the first instance data and if specified, are permitted but not required to be met by a specified user interface implementation that is selected using the first instance data;

specifying in the application second instance data in the form of a second generic object specification that corresponds to the second generic object class, the second instance data including second attribute criteria, which are criteria that must be met by a specific user interface implementation that is selected using the second instance data and second hint criteria, which are criteria that are permitted but not required to be specified in the second instance data, and if specified, are permitted but not required to be met by a specific user interface implementation that is selected using the second instance data;

providing in the computer system a specific user interface toolbox and controller that operates in the computer system to provide, for each of the first and second generic object classes, a respective selection of multiple possible specific user interface implementations;

providing in the computer system an interpreter that corresponds to the specific user interface toolbox and controller, the interpreter including a first generic object class interpreter and a second generic object class interpreter;

producing a first specific user interface interpretation for the first generic object class from the specific user interface toolbox and controller using the first generic object class interpreter, such that the first specific user interface interpretation satisfies both the first attribute criteria and the first hint criteria, except if no first specific user interface interpretation satisfies both the first attribute criteria and the first hint criteria, then using the first generic object class interpreter to produce another first specific user interface interpretation that satisfies the first attribute criteria but not all of the first hint criteria that have been specified; and

producing a second specific user interface interpretation for the second generic object class from the specific user interface toolbox and controller using the second generic object class interpreter, such that the selected second specific user interface interpretation satisfies both the second attribute criteria and the second hint criteria, except if no second specific user interface interpretation satisfies both the second attribute criteria and the second hint criteria, then using the second generic object interpreter to select another second specific user interface interpretation that satisfies the second attribute criteria but not all of the second hint criteria that have been specified.

10. A method for designating a user interface for use with an application operating in a computer system comprising the steps of:

providing in the computer system a generic object class that corresponds to a class of function that is to be performed with the user interface;

specifying in the application instance data that corresponds to the generic object class, the instance data including attribute criteria, which are criteria that must be met by a specific user interface implementation that is selected using the instance data, and hint criteria, which are criteria that are permitted but not required to be specified in the instance data, and if specified, are permitted but not required to be met by a specific user interface implementation that is selected using the instance data;

providing in the computer system a first specific user interface toolbox and controller that is operable in the computer system to provide a first selection of multiple possible first specific user interface implementations for use in performing the class of function;

providing in the computer system a second specific user interface toolbox and controller that is operable in the computer system to provide a second selection of multiple possible second specific user interface implementations for use in performing the class of function;

providing in the computer system a first interpreter that corresponds to the first specific user interface toolbox and controller, the first interpreter operable in the computer system to select a first specific user interface implementation from the first selection of possible first specific user interface implementations, such that a selected first specific user interface implementation from the first selection satisfies both the attribute criteria and the hint criteria specified for the generic object class, except if no first specific user interface implementation from the first selection satisfies both the attribute criteria and hint criteria specified for the generic object class then the first interpreter being operable to select another first specific user interface implementation from the first selection that satisfies the attribute criteria but not all of the hint criteria that have been specified for the generic object class;

providing in the computer system a second interpreter that corresponds to the second specific user interface toolbox and controller, the second interpreter operable in the computer system to select a second specific user interface implementation from the second selection if possible second specific user interface implementations, such that a selected second specific user interface implementation from the second selection satisfies both the attribute criteria and the hint criteria specified for the generic class, except if no second specific user interface implementation from the second selection satisfies both the attribute criteria and hint criteria specified for the generic object class then the second interpreter being operable to select another second specific user interface implementation from the second selection that satisfies the attribute criteria but not all of the hint criteria that have been specified for the generic object class;

selecting one of the first and second specific user interface toolbox and controllers and a corresponding one of the first and second interpreters; and

producing one of a first specific user interface implementation and a second specific user interface implementation using the selected controller and the selected interpreter.

11. A method for designating a user interface for use with an application operating in a computer system comprising the steps of:

A. providing in the computer system a first generic object class that corresponds to a first class of function and a second generic object class that corresponds to a second class of function;

B. specifying in the application first instance data in the form of a first generic object specification that corresponds to the first generic object class, the first instance data including attribute criteria, which are criteria that must be met by a specific user interface implementation that is selected using the first instance data, and hint criteria, which are criteria that are permitted but not required to be specified in the first instance data, and if specified, are permitted but not required to be met by a specific user interface implementation that is selected using the first instance data;

C. specifying in the application second instance data in the form of a second generic object specification that corresponds to the second generic object class, the second instance data including attribute criteria, which are criteria that must be met by a specific user interface implementation that is selected using the second instance data, and hint criteria, which are criteria that are permitted but not required to be specified in the second instance data, and if specified, are permitted but not required to be met by a specific user interface implementation that is selected using the second instance data;

D. providing in the computer system a first specific user interface toolbox and controller that is operable in the computer system to provide, for each of the first and second generic object classes, a respective first selection of multiple possible first specific user interface implementations;

E. providing in the computer system a second specific user interface toolbox and controller that is operable in the computer system to provide, for each of the first and second generic object classes, a respective second selection of multiple possible second specific user interface implementations;

F. providing in the computer system a first interpreter that corresponds to the first specific user interface toolbox and controller,

i. wherein the first interpreter is operable to select from the first specific user interface toolbox and controller a respective first specific user interface implementation for the first generic object class, such that a selected first specific user interface implementation satisfies both the attribute criteria and hint criteria specified for the respective first generic object class, except if no first specific user interface implementation satisfies both the attribute criteria and hint criteria specified for the first generic object class then the first interpreter being operable to select another first specific user interface implementation from the first selection that satisfies the attribute criteria but not all of the hint criteria that have been specified for the first generic object class, and

ii. wherein the first interpreter is operable to select from the first specific user interface toolbox and controller a respective first specific user interface implementation for the second generic object class, such that a selected first user interface implementation satisfies both the attribute criteria and hint criteria specified for the second generic object class, except if no first specific user interface implementation satisfies both the attribute criteria and hint criteria specified for the second generic object class then the first interpreter being operable to select another first specific user interface implementation from the first selection that satisfies the attribute criteria but not all of the hint criteria that have been specified for the second generic object class;

G. providing in the computer system a second interpreter that corresponds to the second specific user interface toolbox and controller,

i. wherein second interpreter is operable to select from the second specific user interface toolbox and controller a respective second specific user interface implementation for the first generic object class, such that a selected second specific user interface implementations satisfies both the attribute criteria and hint criteria of the respective first generic object class, except if no second specific user interface implementation satisfies both the attribute criteria and hint criteria of the first generic object class then the second interpreter being operable to select another second specific user interface implementation from the second selection that satisfies the attribute criteria but not all of the hint criteria that have been specified for the first generic object class, and

ii. wherein the second interpreter is operable to selected from the second specific user interface toolbox and controller a respective second specific user interface implementation for the second generic object class, such that a selected second user interface implementation satisfies both the attribute criteria and hint criteria of the second generic object class, except if no second specific user interface implementation satisfies both the attribute criteria and hint criteria of the second generic object class then the second interpreter being operable to select another second specific user interface implementation from the second selection that satisfies the attribute criteria but not all of the hint criteria that have been specified for the second generic object class;

H. selecting one of the first and second specific user interface toolbox and controllers;

i. in the event of the selection of the first specific user interface toolbox and controller, using the first interpreter to select respective first specific user interface implementations for the first generic object class and the second generic object class, and

i. in the event of the selection of the second specific user interface toolbox and controller, using the second interpreter to select respective second specific user interface implementations for the first generic object class and the second generic object class.

BACKGROUND OF THE INVENTION

1. Field of the Invention

In general, the present invention relates to an application program operating in a computer and, more particularly, the invention relates to a process for designating a user interface of an application program.

2. Description of the Related Art Applications

An application (or program) is a tool which allows a person to use a computer to accomplish a task. For example, a word processor provides the user of a computer with a way to write, store, and print out letters. A drawing program allows him to create charts, diagrams, and organizational charts. As far as the user is concerned, the application is the interface between him and the computer hardware. However, from the application's perspective, there is another layer.

Operating Systems

An operating system is a program which acts as an interface between applications and the computer hardware. It provides an environment in which a user may execute programs. Operating systems attempt to make the computer system easy and efficient to use. Operating systems in conjunction with the computer hardware are often called environments. These principles are discussed by James Peterson and Abraham Silberschatz in "Operating System Concepts".

User Interfaces

A user interface (UI) is a set of rules and conventions by which a computer system communicates with the person operating it. Initially, operating systems (such as UNIX or MS-DOS) featured text-based command line interfaces. Users were expected to use and remember complicated, forgettable commands such as "enscript-2Gr-Plw." Different applications all had different user interfaces--to print the current document, a user might have to press the function key F7 in a word processor and the keys Ctrl-Alt-P in a database program. Computers were difficult to learn, difficult to use, and, worst of all, inconsistent. In the pursuit of the often-coined property known as "user friendliness," much work was done in terms of improving user interfaces. Just as the personal computer market as a whole is changing rapidly and drastically, so too are user interface standards. Through the years, operating systems have evolved from complicated text-based, command line interfaces, like UNIX or MS-DOS, to graphical, windowing interfaces such as the Apple Macintosh and Microsoft Windows. These new graphical user interfaces (GUIs) feature menus, buttons, and windows accessed by a mouse. The graphical, intuitive nature of these interfaces solved many of the problems inherent in earlier operating systems. GUIs typically provide a large tool kit of user interface gadgets such as windows, buttons, and menus. Applications make use of these UI items to implement their interaction with the user. In order to avoid inconsistent application interfaces, companies develop rules and conventions for using the UI gadgets. Documents known as style guides are provided in an attempt to instruct application designers in the appropriate usage of the user interface gadgets offered by a system (see "Style Guides" for more detailed information). Some examples of such user interface standards are OSF/Motif, OpenLook, CUA, NewWave, and Macintosh. Each of these standards shall be referred to herein as a specific user interface.

However, even applications developed for a "user friendly" environment like Windows or Macintosh sometimes can be difficult to use. As applications have become more and more powerful, some have also become more and more difficult to use. There are so many fascinating and complex things users can do with these new programs that it can be very difficult to create a user interface that is always easy to use. A new concept in the GUI community attempts to come to terms with this problem. It is the scalable graphic user interface. Such a GUI allows the same applications to be accessed at various levels of functionality. These levels range from an appliance mode, where users are only required to push a few buttons, to a novice computer interface (such as Tandy's Deskmate.TM.), to a full-fledged professional graphic user interface like the Motif.TM. interface. Users, as their skills and needs grow, may simply switch interface levels to access more powerful features. So, for example, if users only want to quickly type a letter or envelope, they do not have to wade through a program designed to produce newsletters involving multiple columns of text running from page to page and graphics placed randomly throughout the document. They can merely run the word processor in appliance mode and type a simple letter without having to set many different options and to pick their way through a a number of extra features (See "Style Guides" for how scalability relates to style guides).

Applications Development

Applications have always been difficult and time-consuming to develop. However, because of the volatile and diverse nature of the computer software industry, creating applications which execute under different specific user interface standards often can be exceptionally challenging. In the past, much or all of the application often was rewritten in order to conform to the various standards, and each version often was offered for sale separately.

Some applications have implemented the scalable GUI concept to some extent. Programs such as Microsoft Word have "full and short menu" modes; novices may choose "short menus," which hides advanced functionality by simply removing advanced commands from the main menu. The user still has to contend with multiple windows and pull-down menus, difficult enough concepts in their own right. However, very few programs even feature this limited scalability. Usually, if users would like both a simple word processor and an advanced word processor, they would have to purchase two separate packages (in fact, some software publishers offer several similar packages of varying complexity in their product line.

Conventional Application Design Process

The typical process of writing an application is as follows. An environment is chosen (e.g., UNIX workstation running Motif). The functional goals of the program are specified (e.g., a powerful word processor). Then the user accessibility goals are specified (e.g., must be easy and intuitive to use and follow Motif guidelines). A programmer or team of programmers implements the functionality, and a human interface expert or team (perhaps the same programmers) designs the user interface to conform with the style guide for the environment.

We will focus on the user interface designer. The interface designer balances human/computer interaction design considerations, application input and output requirements, and the style guide for the specific user interface to create a specific interface description (typically in the form of user interface objects with attributes) for the application. The graphical user interface system software then implements this specific description, creating an on-screen representation.

If an operating system could somehow interpret the user interface needs of an application and provide a good implementation of one or more style guides, both application developers and users would benefit.

SUMMARY OF THE INVENTION

It is an objective of the present invention to provide a new process for generating on-screen application interface for an application program.

It is another objective of the present invention to provide a new process for generating user interfaces for application programs.

It is another objective of the present invention to provide a new process for generating the on-screen application interface in such a way that the application is largely independent of changes in specific user interfaces. Developing an application is a challenging and time-consuming project. One essential aspect of this process is the design and implementation of the application's user interface. In the traditional process of interface design, the developer defines application input/output requirements and a list of human-to-computer design considerations associated with those requirements. Referring to the style guide for the specific user interface (e.g. Motif, OpenLook, or Windows) for which the application is being designed, the designer melds all three considerations together when defining the user interface. He makes selections from the gadget toolkit offered by the specific UI and decides how those objects should be arranged on the screen. These selections and decisions are made with an eye toward subjective design considerations. The exact final interface design is then stored in data structures, which are later faithfully rendered on screen by system software. To run the application under a different specific UI, the design process would have to be repeated from scratch, yielding a new executable version of the application.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates a conventional application design process.

FIG. 2 illustrates a application design process according to the present invention.

FIG. 3 illustrates a dialogue box.

FIG. 4 illustrates a menu.

FIG. 5 illustrates pixels on a screen.

FIG. 6 illustrates a scroll bar.

FIG. 7 illustrates a scrolling list.

FIG. 8 illustrates a submenu.

FIG. 9 illustrates hierarchy of objects in tree data structure.

FIG. 10 illustrates a window.

FIG. 11 illustrates the salesman example.

FIG. 12 illustrates a GenTrigger class of generic user interface object and two objects in that class.

FIG. 13 illustrates a sample generic user interface tree.

FIG. 14 illustrates an on-screen realization of the sample user interface tree of FIG. 13.

FIG. 15 illustrates a sample user interface screen of a prior art Macintosh application.

FIG. 16 illustrates a sample user interface screen of a prior art OS/2 application.

FIG. 17 illustrates a conventional user interaction.

FIG. 18 illustrates a user interaction according to the present invention.

FIG. 19 illustrates an easy to use layout for print dialogue box that can be more difficult to use.

FIG. 20 illustrates a poor layout for print dialogue box.

FIG. 21 illustrates a computer system incorporating elements in accordance with the present invention.

FIG. 22 illustrates a prior art computer system.

FIG. 23 illustrates a document control object.

FIG. 24 illustrates a NewWave.TM. interpretation of the document control object of FIG. 23.

FIG. 25 illustrates an OpenLook.TM. interpretation of the document control object of FIG. 23.

FIG. 26 illustrates a Motif.TM. interpretation of the document control object of FIG. 23.

FIG. 27 illustrates a list object and some possible hints that can be used as instance data for that object.

FIG. 28 illustrates a NewWave.TM. interpretation of the list object of FIG. 27.

FIG. 29 illustrates an OpenLook.TM. interpretation of the list object of FIG. 27.

FIG. 30 illustrates a Motif.TM. interpretation of the list object of FIG. 27.

FIG. 31 illustrates a style guide interpreter that provides three possible gadget choices (Abbreviated Menu Button, Exclusive Settings and Scrolling List) with an example of a screen display and style guide interpreter interpretation rules for each.

FIG. 32 illustrates a style guide interpreter that provides two possible gadget choices for a hypothetical user interface (Graphical Radio Buttons and Scrolling List) with an example of a screen display and style guide interpreter interpretation rules for each.

FIG. 33 illustrates a generic user interface specification for the GenList object and an OpenLook.TM. user interface interpretation and a hypothetical user interface interpretation of the generic GenList object.

FIG. 34 illustrates a sample generic user interface specification.

FIG. 35 illustrates an interpretation of an object having the specification of FIG. 34 under Motif.TM. or OpenLook.TM..

FIG. 36 illustrates an interpretation of an object having the specification of FIG. 34 under a hypothetical user interface style guide.

FIG. 37 illustrates an interpretation of an object having the specification of FIG. 34 under a hypothetical user interface of the future in an advanced mode.

FIG. 38 illustrates an interpretation of an object having the specification of FIG. 34 under a hypothetical user interface of a future in a novice mode.

FIG. 39 illustrates an implementation of the principles of the invention using procedural programming rules.

FIG. 40 illustrates an implementation of the principles of the invention using objects using pointers to methods.

FIG. 41 illustrates an implementation of the principles of the invention using objects having class pointers to class structures.

FIG. 42 illustrates a prior art user interaction with an application to produce an action in a computer system.

FIG. 43 illustrates a user interaction with an application in accordance with the present invention to produce an action in a computer system.

FIG. 44 illustrates prior art development and use of a specific user interface specification for a particular user interface.

FIG. 45 illustrates development and use of a generic user interface specification for use with any of multiple specific user interface interpreters (Motif.TM., NewWave.TM. and OpenLook.TM., for example), and the use of such generic user interface to produce different on-screen displays using such different specific user interface interpreters.

FIG. 46 illustrates a one-choice element of a control area or a menu, used in various ways such as to execute commands, display pop up windows, and display means.

FIG. 47 illustrates a non-exclusive setting that shows a checkmark in a square box when a setting is chosen.

DETAILED DESCRIPTION OF PREFERRED EMBODIMENT

Before explaining the principles in the present invention, it is useful to define a group of terminologies as follows.

gadget toolkit

set of components such as windows, menus, buttons, scrolling lists, radio buttons, scroll bars, etc. A portion of every specific user interface's style guide concerns itself with the enumeration, definition, and uses of these components

generic UI object class

group of generic UI objects with identical types of data and methods

generic UI object

uI component representing an input/output need of an application (as opposed to a visual specification such as a scrolling list). Examples include document control, exclusive list selection, and viewing areas.

generic UI object library

set of generic UI objects and hints available for specifying an interface independent of any particular gadget toolkit

generic user interface specification

interface designed for a particular application based on objects from the generic UI object library, including the selection and organization of objects and hints

generic to specific UI interpreter (UI Interpreter)

software which interprets a generic UI specification to create the on-screen representation of the application in such a way that a specific UI's style guide requirements and recommendations are met

hint

embodiment of human/computer interface criteria for an application, stored digitally. Examples of such criteria follow:

"infrequently used feature"

"advanced feature"

"should be displayed as large as possible"

specific user interface

the look and feel ONLY of a particular user interface specification, such as Motif, Open Look, Windows, or Macintosh, as denoted by that user interface's style guide (i e the end user's perception of the user interface, separated from the API and software)

specific user interface specification

interface designed for a particular application based on gadgets from a specific user interface's gadget toolkit

Conventional Application Design Process

The process of the present invention has redefined how application user interfaces are developed. The illustrative drawings of FIG. 1 shows a representative conventional process for developing an application. In contrast to the conventional process, a designer using a new process in accordance with the present invention does not attempt to define the final, gadget-level interface to the application. Instead, referring to FIG. 2, he selects objects from a generic UI object library based solely on the input/output requirements of the application, and groups them according to function within the application. Subjective design considerations associated with those requirements, which would ordinarily be weighed by the designer in order to pick specific gadgets, are instead stored digitally along with the generic UI objects. The designer's job is done, as everything short of the style guide has been considered and stored as part of the UI specification for the application. This data is later interpreted in software by any one of a number of UI interpreters, which map the selected generic UI objects and hints into an interface implementation which meets the specific UI's style guide requirements. The final interface for the application is then presented on-screen.

GEOS Application Design Process

The process of the present invention allows the same application executable to come up with the look and feel of any number of specific user interfaces, meeting the style guide requir