The present invention relates to computer presentation applications and, more particularly, to a presentation development tool and run-time manager for providing character-based and graphic-based presentations for host and host-like applications.
Conventional computer systems interact with computer users via displayed images on a computer monitor. For example, a typical application executed by the computer displays text at predefined areas on the monitor screen and enables a user to input text within the same or other areas.
Early generation applications use a relatively simple display mechanism. For example, text-based programs that operate with 3270 terminals display text and enable a user to enter text in fields defined on the computer screen. Data defining each screen (referred to herein simply as a xe2x80x9cscreenxe2x80x9d) is stored in a data memory. The host application issues a command (with associated data) to display a particular screen, identifying the screen by an identifier. An application reads the identifier, retrieves the corresponding screen and sends it to a terminal (e.g., a 3270 terminal). The terminal processes the screen and the associated data to display the screen and the data in a predefined format.
With the proliferation of personal computers, graphic-based user interfaces have become widely available. Programming languages such as VISUAL BASIC by MICROSOFT and POWERBUILDER by SYBASE enable a software developer to create custom graphical applications with relative ease.
In addition, programming languages such as JAVA have been developed that provide a very flexible operating environment. For example, a client executing on one computer can download any portion of an application from another computer (i.e., a server) as it is needed. This improves the efficiency with which an application may be developed and provided to the computer user.
The advantages provided by these and related developments have not been realized by many legacy applications that run on a host computer (e.g., a mainframe computer, an IBM AS/400 computer, a UNIX-based computer, a DEC VAX computer and the like). For simplicity, these applications will be referred to hereafter as host applications. A large number of host applications such as accounting and other database programs are based on software that was designed for the older data character-based displays.
Typically, the user of a system that uses these applications may not upgrade the system to use a newer graphical interface due to the relatively high cost and risks associated with upgrading the system. For example, it may take a long time and cost a significant amount of money to re-write the existing application to support the new features.
In addition, many users have a significant investment in the old software in terms of organizational know-how. For example, the user""s software developers are familiar with the old software. It may take a long time and be relatively expensive, particularly in terms of lost productivity, to retrain these personnel.
Moreover, existing code typically is relatively stable. Thus, a user may be reluctant to switch to new, relatively unproven software. As a result of these issues, a significant number of character-based applications are still in use today.
One proposed solution to these problems involves the use of an intermediary program between the imbedded host application and the newer graphical presentation systems. An intermediary program provides the traditional interface to the host applications, i.e., it accepts screens and responds in the manner that the host applications expect. Thus, the host applications typically do not need to be modified. The intermediary program also provides an interface to the newer presentation programs. Again, the intermediary program performs the necessary operations to provide the presentation programs with the commands and data they expect and to receive commands and data from the presentation programs.
Despite these advances, conventional systems still have several shortcomings. For example, to use some conventional intermediary programs, the user must design the desired graphic-based presentation according to the character-based screens. Thus, the capabilities of the graphics in these systems may be limited in some respects to the capabilities of the character-based screens. Moreover, processing and development resources are wasted creating screens that are not presented to the user.
In addition, some organizations may chose to add the newer graphic-based systems to their current systems, rather than simple replacing their current systems. Thus, these organizations will need to support both the graphic-based and character-based formats. Conventional systems may not provide an efficient way to support both formats. For example, they may use a separate host application for each format.
Finally, as the architectures of the host and presentation applications evolve, there is a need for an efficient way to upgrade existing systems and create new host applications with new presentations (e.g., GUI) without making extensive changes in the existing host applications. In view of the above, a need exists for an improved presentation system for host applications.
A presentation development tool and run-time manager provides character-based and graphic-based presentations for host applications. The development tool enables a user to generate character-based and graphic-based presentations for the host applications. The run-time manager accepts conventional or modified presentation commands from a host application and presents a presentation in the appropriate format to a client. The client typically is a computer or a terminal and may support character-based or graphic-based presentations.
During run-time, graphic presentation definitions may be obtained directly from a database without using a screen definition. As a result, the system can provide graphic-based presentations more efficiently than conventional systems because the steps of generating and retrieving screens may be eliminated.
In one embodiment, the manager may automatically determine whether the client is text-based or graphic-based. For example, when a session is established with a client, the run-time manager identifies the client-type using a pre-defined table or some other method.
Thus, when a presentation is to be presented to that client, the manager can automatically provide the appropriate presentation type (e.g., character-based or graphic-based) to the client. Specifically, the manager retrieves the appropriate presentation definition (e.g., a screen or a window definition) from a database, processes the definition as necessary and provides the definition to the client.
Thus, the invention provides an improved presentation system for host applications. A user may program a presentation using JAVA and other advanced programming languages and invoke the presentation in the host application without using limiting intermediary processes. Accordingly, the invention brings the presentation level and the host application together in an efficient and logical manner.
USPTO Backgrounds
USPTO Backgrounds