 |
Description  |
|
|
A portion of the disclosure of this patent document contains material that
is subject to copyright protection. The copyright owner has no objection
to the facsimile reproduction by anyone of the patent disclosure, as it
appears in the Patent and Trademark Office patent files or records, but
otherwise reserves all copyright rights whatsoever.
FIELD OF THE INVENTION
The present invention generally relates to client/server computing in a
World Wide Web ("Web") environment, and more particularly to a method for
supporting enterprise application binding within a Web Browser.
BACKGROUND OF THE INVENTION
With the rising popularity of client/server computing and the Web,
businesses are looking for even better ways to increase their competitive
advantage. Information is one of businesses most precious commodities.
Accordingly, there is a need for flexibility to position information in
ways that best support business organizations and their customers.
Client/server technology offers graphical user interfaces (GUI's) a choice
of open systems, rapid application development, increased end-user
productivity and much more. By combining this technology with the Internet
and intranets, a powerful system is made available to distribute
information throughout the business and customer communities. The world
Wide web is a purely client/server environment that can bring business to
customers. Even if a business has information that needs to be kept within
the organization, the Web technology is still available as an Intranet,
which is a web site behind a firewall and made available only to employees
of the organization. The term "firewall" as used herein refers to a
combination of hardware and software that prevents access to secured data
over a network. The idea is to protect a cluster of more loosely
administered machines hidden behind the firewall from hackers.
There is also a need to make the move to client/server and Internet
technologies without having to migrate from existing host applications.
The best way to build new client/server applications that can be
integrated with current applications is to combine the dependability of
enterprise-wide computing systems with the flexibility of distributed
processing.
Early attempts at capitalizing on the advantages of the client/server
applications involved the use of the PC as a "dumb terminal", or a
character-based network terminal, that interacted directly with legacy
programs operating on a mainframe or host computer. This approach was
unsatisfactory because the user was limited to a character-mode display.
Later attempts included such solutions as the Designer Workbench product
(which is a software tool now referred to as PowerClient and available
from Unisys Corporation, assignee of this patent). The PowerClient product
gives the user the ability to capture Forms descriptions that are on the
mainframe, and to convert character-based fields into Windows-based visual
elements such as edit fields, buttons, etc. A language called SCL (Screen
Control Language) was created for describing the visual elements as well
as indicating processing that will be performed on the client PC's.
With reference to various types of legacy programs operating on the host,
LINC (i.e., "Logical Information Network Compiler") allows Screen Control
Language ("SCL") to be generated directly. SCL is created with the use of
the PowerClient product for third generation languages (3GL) such as COBOL
or ALGOL legacy programs; and, in the case of MAPPER, which is a third
system and language for legacy programs, there is no way to generate SCL.
For MAPPER, the user must use a forms designer tool (such as the
Development Studio product) for drawing visual elements to generate the
required SCL that matches the MAPPER application.
More recently, it was possible to take SCL definitions of a Form and turn
them into a Visual Basic or a PowerBuilder executable program. For an
amplification of this method reference is made to a copending patent
application entitled A METHOD FOR GENERATING CODE FOR MODIFYING EXISTING
EVENT ROUTINES FOR CONTROLS ON A FORM, Ser. No. 08/803,137, filed Feb. 19,
1997 by the same inventors hereof and assigned to the same assignee
hereof. PowerBuilder is a product of PowerSoft Company (which has recently
merged with Sybase, Inc. of Emeryville, Calif.), and Visual Basic is a
product of Microsoft Corporation of Redmond, Wash. However, since the
Visual Basic and PowerBuilder client builder products generate
executables, there is no way to incorporate the presentation functionality
they provide into a Web browser, which is a client-side software module
for accessing a Web server.
The PowerClient product has the capability of displaying forms from legacy
host applications in the PC environment. While it is possible to display
forms in their original, character-based format, it is also possible, via
the PowerClient Development Studio product, to add modern GUI Controls,
such as command buttons, list boxes and images to these forms. The Forms
thus developed are stored in the PowerClient product environment and are
accessed and displayed as needed when the user is interacting with the
legacy application. The initial data received from the legacy application
for the Form is displayed, and then the user of the legacy application
enters data into the GUI Controls contained in the Form. When the user
completes the interaction, the PowerClient product gathers the data from
these GUI controls into a buffer and formats it for transmission to the
host in such a way that the legacy host application can continue to use
its character-based interface and is unaware of these changes. The host
legacy application then supplies the initial data for the next Form, and
the process repeats.
In order to "Web-enable" such a legacy application, i.e. allow it to work
within the World Wide Web internet or intranet environment, it is
necessary that: 1) the host application continue to be unaware that an
agency is intervening in the display of its Forms and 2) these Forms need
to have a "look and feel" similar to the PC version in order that
development and training costs be minimized.
The current state of the art for displaying Forms in the World Wide Web is
the Hypertext Markup Language (HTML). This language is an instance of SGML
(Standard Generalized Markup Language). HTML has the concept of the FORM,
which is a means of displaying GUI controls for user interaction. When the
user submits the HTML Form, the contents of these controls are gathered by
the Web browser and sent as part of a Universal Resource Locator (URL)
sent to the Web server in the form of control name/control value pairs.
The HTML FORM construct was originally considered for implementation of
PowerClient product Forms in the web environment and considerable effort
was expended in an effort to make it work. However, it was ultimately
found that there were numerous shortcomings of this approach, foremost of
which is the inability to simultaneously specify the caption for a control
and the name of the host data element with which it is associated. This
limitation made it impossible to use the HTML FORM construct to support
PowerClient product legacy forms in the web environment. Moreover, while
the set of available components included most of the PowerClient product's
GUI Control set, there were still some which either were not supported or
were of limited functionality vis-a-vis the PowerClient product set.
Additionally, there was no way to control where on the Form the control
was positioned. HTML Version 2.0 added the concept of FRAMEs, which gives
some control over positioning. These were evaluated for the PowerClient
product's environment and found insufficient to control locations on the
PowerClient product Form.
SUMMARY OF THE INVENTION
It is therefore an object of the method of the present invention to provide
an evolutionary approach to client/server technology so that a user can
retain their existing information technology investment in legacy
programs, yet move to client/server computing on the Web. A user can
increase productivity and reduce development and training costs because
using the present invention does not require any changes to the legacy
programs.
A feature of the present invention is that the generated SCL is dynamically
embedded within the HyperText Markup Language (HTML) for each legacy Form.
Another feature of the present invention is that Form data from a host
legacy application can be associated with GUI controls on a Form displayed
in the Web environment.
Yet another feature of the present invention is that Form data can be
obtained from GUI Controls in the Web environment and returned to a legacy
host application.
An advantage of the present invention is that a user is able to turn off
the HTML presentation altogether and effectively use the browser as a
transport layer for other ClientBuilder product applications with the data
binding functionality. Moreover, a user can hide the browser and execute a
Visual Basic application, which would communicate with the browser and the
user never sees the browser.
Another advantage of the present invention is that the SCL can set various
states of GUI Controls and associate data with them. The current state of
the HTML has a limited subset of what is doable in terms of data logic
handling.
Still other objects, features and advantages of the present invention will
become readily apparent to those skilled in the art from the following
detailed description, wherein is shown and described only the preferred
embodiment of the invention, simply by way of illustration of the best
mode contemplated of carrying out the invention. As will be realized, the
invention is capable of other and different embodiments, and its several
details are capable of modifications in various obvious respects, all
without departing from the invention. Accordingly, the drawings and
description are to be regarded as illustrative in nature, and not as
restrictive, and what is intended to be protected by Letters Patent is set
forth in the appended claims.
BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a block diagram of a system that could be used to develop files
and to execute the same employing the steps of the method of the present
invention.
FIG. 2 is a print of a computer screen display from a 3GL legacy
application Form for TRIPS, a report for tracking employee expenses, which
is convertible by using the method of the present invention.
FIG. 3 is a print of a computer screen display of the same Form for TRIPS
after adding visual controls using the Development Studio.
FIG. 4 is a print of a computer screen display after employment of the
method of the present invention.
FIGS. 5A through 5C combined Form a flow chart illustrating the process for
development of files for use with the method of the present invention.
FIGS. 6A through 6K (intentionally omitting "6II") illustrate a run-time
process that includes the steps performed by the method of the present
invention.
FIG. 7 is a diagram of the process of the present invention.
DETAILED DESCRIPTION OF ONE EMBODIMENT
The present invention integrates the popular Web browsers with legacy
applications in order to provide Form presentation capabilities not
supported using HTML, which is today's most popular Web language. This
means that one can create a unified GUI front-end "look and feel" for even
the most complex applications. The disclosed method is ideal for building
and interfacing powerful desktop client applications with 3GL and LINC
legacy applications.
The SCL language is used by the PowerClient product to control the display
of Forms in the PC environment. Since this language completely
characterizes a legacy Form for the purposes of display in the normal PC
environment, including the legacy host application data field with which
each GUI element is associated, a decision was made to use it as the means
by which the Form is displayed in a Web browser. SCL Text is embedded into
an HTML page for display in a Web browser environment, and the data
entered by the user is returned to the legacy application.
In order to display embedded HTML and communicate with the legacy
application on a host, two cooperating programs are required. For the Web
browser environment, an ActiveX control was developed and is referred to
herein as SCL Web Control ("SWC") program. The SWC program is an ActiveX
compliant control used to communicate with either a Netscape or Microsoft
Web browser. ActiveX is a software technology sponsored by Microsoft
Corporation.
ActiveX controls are invoked in the browser environment by a particular
HTML construct (the OBJECT tag). To generate an HTML page with the OBJECT
tag, a program was developed that can be invoked by a Web server, which is
referred to herein as a Web Agent program. The Web Agent program also
communicates with the legacy host application to act as a communications
switch for data going from the host application to the SWC program for
display to the user and from the SWC program to the host application when
the user submits the Form.
The OBJECT tag construct allows the passing of parameters to an ActiveX
control when it is invoked. Therefore, SCL Text is included for a legacy
Form as one of the parameters to the SWC program. A second parameter to
the SWC program is the initial data for the Form received from the host
legacy application. The SCL Text passed to the SWC program contains GUI
Control specifications. A part of each such specification is the name of
the host legacy application data element with which the GUI control is
associated.
The SWC constructs a set of GUI Controls corresponding to the GUI Control
specifications in the SCL Text. Using the part of each such specification
that indicates which application data field with which the control is
associated, it places initial data from the initial data list into the GUI
control. The initial form data is in the format of name/value pairs, where
the name is that of a legacy application data element, so it is necessary
for the control to make an association between this data name and the GUI
Control.
When the user completes interaction with the Form, the SCL Web Control acts
much as it does in PowerClient in that it gathers data from those GUI
Controls associated with Data Names and formats it for return to the host
legacy application. In this case, since the environment is the Web, the
formatting is different than in the PowerClient product. The GUI
Control-data name associations are used to locate those controls
containing data for the legacy application. These values are extracted
from the GUI Controls. A URL is then constructed, containing name/value
pairs, where the name is the application Data Name. The URL also contains
information about the name of the Form and its host application. The URL
is sent to the Web Agent program, which reformats the URL into the normal
PowerClient product host application data buffer as described in a problem
statement.
At this juncture of the description several definitions are added to assist
in the understanding of the present invention.
Application shall mean a program written by a user which accomplishes some
operation.
Command shall mean an instruction to perform an operation. In the Web Agent
(defined hereafter) context, the Command operation is to obtain ("Open") a
host Form or to send the results of an entry of data into the Form back to
the application ("Transmit").
Data Name shall mean the name of a host application datum. That is, is the
identification given to a field on a host screen.
Data Value shall mean the value of a host application datum. That is, the
value associated with a field on a host screen.
Form shall mean the visual display elements of an application containing
fields for entry and display of the application.
GUI Control shall mean a visual element of a GUI display, such as an edit
box or a list box. Other examples include buttons, list boxes, check boxes
and combo boxes.
Host Reply Definition (HRD) shall mean a file used in the PowerClient 3GL
environment that maps characters in the data stream from the host with the
fields and their Data Names in the modernized Form.
Partition or Partition Name shall mean a space in a repository, thereby
providing a means for categorizing data in the repository. In particular,
it shall mean a name given to represent a series of Forms associated with
a 3GL/LINC (i.e., Legacy) application.
Repository Object shall mean such things as SCL Text (defined hereafter),
list box data, an image, etc.
SCL Construct shall mean a valid production of the SCL language's grammar,
i.e., an SCL Text (defined hereafter) statement.
SCL Control shall mean an SCL Construct that describes a particular GUI
Control, such as an edit field, list box, etc.
SCL Web Control shall mean an ActiveX based control used in a PowerClient
run-time environment.
SCL Text shall mean a collection of SCL Constructs. SCL is a Unisys
proprietary language. SCL Text is used to describe GUI Controls to be
rendered within a browser.
SCL Files shall mean those files that contain SCL Text, which are referred
to as an object in a repository.
Script shall mean a sequence of instructions used to establish connectivity
with a host computer and a specific application of the host.
Uniform Resource Locator (URL) shall mean an identifier for locating a
resource on the Web.
Web Agent shall mean the PowerClient module that interprets special URL
requests passed to it by the Web Server (defined hereafter). It uses
information in the special URL to obtain data from the host for a
particular Form and returns it to the Web Control via the Web Server and
Web browser. It is also a series of both client/server components that
permit LINC/3GL applications to have access over the Web.
Workstation Driver File (WDF) shall mean a file used in the PowerClient
LINC environment that maps characters in the data stream from the host
with the fields and their Data Names in the LINC Form.
Referring now to FIG. 1, a client/server system configuration is
illustrated wherein a host or mainframe 10 has terminals 11 and 12 coupled
thereto and network connection 13 coupling to clients 14, 15 and 16. The
network connection 13 may typically comprise a TCP/IP or any other
proprietary protocol. The host 10 could be any computing system capable of
operating in a client/server environment, such as for example any Unisys
or IBM computer. The host 10 is coupled to a network server repository 17,
the client 14 (also referred to herein as an NT Web Server) is connected
to a client repository 18; and, the client 16, which in the illustrated
embodiment is used for development, is coupled to a development repository
19. The clients 14, 15 and 16 could typically be any currently available
PC capable of executing the Windows 95 or NT operating system. However, it
is required that the client 14 be able to execute the Windows NT operating
system.
The host 10 is capable of executing software programs including LINC and
3GL legacy programs. The client 14 is capable of executing software
programs including INFOConnect (transports), PowerClient and Web Agents.
The client 15 is capable of executing software programs such as SCL Web
Control and Web browsers. The client 16 is capable of executing software
programs such as PowerClient and INFOConnect. In addition to those
programs alluded to hereinabove, the client 16 is capable of executing
many of the more popular and widely-used programs such as PowerBuilder and
Visual Basic.
The Web Server repository 18 stores Forms that are distributed to clients
using Web browsers. The repository 18 is the database that contains LINC
Form objects, image objects, Script files and data files that are
down-loadable from the host system, as required.
The network server repository 17 holds host application Forms, and it
provides version control for Development Studio Forms.
The Development Repository 19 is used as a database for the development
process and in particular stores LINC Form objects, image objects, data
files and scripts. Moreover, the development repository 19 contains the
objects and scripts necessary to develop and properly display Forms in the
Web browser. As one begins modernizing their applications, developers can
take advantage of the repository 19 to share tasks. When a new Form is
stored in this repository, it is immediately available to other
development environment users.
The INFOConnect program includes three parts of a suite that runs with
PowerClient, and they are the Unisys MT Emulator, the UTE Emulator and the
IBM 3270, all of which are available from DCA, Inc., of Cincinnati, Ohio.
PowerClient is a program available from Unisys Corporation of Blue Bell,
Pa., assignee of the present invention. PowerClient includes 10
components: Code Generation Assistants (two), 3GL Work Bench, LINC Work
Bench, MAPPER, Development Studio, Repositories on the Mainframe (two),
CBT and Web Agent.
Referring now to FIG. 2, a print of a screen display of a Form for a 3GL
legacy application is illustrated. When a client user calls up the
INFOConnect and logs onto the server and specifies TRAVEL, this particular
Form entitled TRIPS appears on the screen. It is a typical Form to be
completed by an employee of an organization for reimbursement of travel
expenses. Each field of this Form is depicted by a space between opposing
arrowheads. For example, the field entitled EMPLOYEE SSN is that space 20
between opposing arrowheads 21 and 22, and includes a display screen
cursor 23. The next field LAST NAME is that space 24 between opposing
arrowheads 25 and 26. The remaining fields of the Form are similarly
depicted. There are a total of fifteen (15) fields on this Form.
Preparatory to modifying the TRIPS Form using the method of this invention,
the user captures this Form using the combined facilities of the
INFOConnect Emulator and the PowerClient Development Studio (PDS). The
user then creates Data Names for each field of the Form. SCL syntax will
contain each of the Data Names created. For example, for the Form shown in
FIG. 2, the following information will be created and stored in the
development repository 19, and is to be used in the SCL generation
process. The user would indicate the data entry fields and the static text
in the Form.
______________________________________
SCL SCL OFFSETS
DATANAMES Row Column Length
______________________________________
EMPSSN 3 19 20
LASTNAME 4 19 25
CREATOR 5 19 10
.cndot.
.cndot.
.cndot.
______________________________________
The user/creator has a great deal of flexibility and can create a push
button or a window for a specific field, can change names or use previous
text, etc. The output is stored in the development repository 19.
Referring now to FIG. 3, a print illustrates a computer screen display of a
modernized version of the 3GL form shown in FIG. 2 and described
hereinabove. Notice that this modernized Form includes windows for
entering data, wherein window 20 corresponds to the space 20 in FIG. 2 for
entry of an Employee SSN. Window 24 corresponds to the space 24 in FIG. 2.
A TRANSMIT button 28 is added by the modernizing process.
Referring now to FIG. 4, the modernized Form shown in FIG. 3 is now
embedded within a Web browser display, having been stored in the
repository 18 and retrieved by a Web browser at client 15 using the method
of this invention. Corresponding reference numbers identify like
components.
Referring now to FIG. 5A, which is the first of a three-sheet drawing
showing a flow chart of the process for development of files for use with
the method of the present invention. The process begins in the client 16
with a start bubble 50 followed by an inquiry as to whether or not Forms
for the host application exist in the development repository 19 (diamond
51). If the answer to this inquiry is yes, then the Development Studio is
invoked (block 52). On the other hand, if the Forms do not exist in the
development repository, another inquiry is made as to whether or not Forms
for the host application exist in the host repository 17 (diamond 53). If
the Forms do not exist on the host, then the Development Studio is invoked
(block 54) and with the use of the Development Studio, the host
application is invoked (block 55).
If the host application Form does exist in the host repository 17 (yes leg
of the diamond 53), then the PowerClient software is used to request a
download of the Forms and the corresponding HRD/WDF files from the host
repository 17 (block 56). Next, the Forms and the HRD/WDF files are placed
in the development repository 19 (block 57). After this, the Development
Studio is invoked (block 58). Upon completion of the step 52 or the step
58 a branch is made to a later point in the process at a connector A,
which will be described shortly. Upon completion of the step 55 a branch
is taken to FIG. 5B at a connector B.
Referring now to FIG. 5B at the connector B, the next step in the
development process is to capture a Form by interaction with the host
application (block 60). For the Form thus captured, an SCL Text and an HRD
file are generated using the Development Studio (block 61). Following
this, the SCL Text and the HRD file are placed in the development
repository 19 (block 62). An inquiry is then made as to whether or not
there are more Forms (diamond 63). If the answer is yes, then a return is
made back to the process block 60. This cycle repeats itself until all
Forms have been processed, and an exit is taken on the no leg of the
diamond 63.
The process of updating and modifying of the Forms begins when an inquiry
is made as to whether or not there are more Forms in the Partition to be
modified (diamond 64). Note that the connector A from the preceding FIG.
5A is also an input to the diamond 64. If the answer to the diamond 64
inquiry is yes, then the developer or user opens the Form by using the
Development Studio (block 65). On the other hand, if there are no more
Forms in the Partition to be modified, then a branch is made to a later
point in the process as illustrated by a connector C. Next, the developer
modifies the GUI Controls as desired (block 66). Following this, the
process illustration continues on the next sheet of the drawings, FIG. 5C
in particular, as illustrated by a connector D.
Referring now to FIG. 5C at the connector D, an inquiry is made as to
whether or not there are more Data Names in the Form (diamond 68). If the
answer to this inquiry is yes, then the developer verifies that there is
an associated GUI Control and assigns a Data Name to the GUI Control
(block 69). Once all of the Data Names in the process have been verified,
then an exit is taken from the no leg of the diamond 68 to another step in
which the developer uses the Development Studio to generate a new SCL Text
(block 70). Following this, the developer uses the Development Studio to
place the new SCL Text in the development repository 19 (block 71). On
completion of this step, a return is made back to that part of the process
illustrated in FIG. 5B at the connector A, and in particular to the
inquiry in the diamond 64. Once all of the Forms in the Partition have
been modified, then an exit is taken from the no leg of the diamond 64 at
the connector C and continues in FIG. 5C, whereupon the Partition
containing the SCL Files and the HRD/WDF files is exported from the
Development Repository 19 (block 72). The exported Partition is imported
into the Web Server repository 18 (block 73) and the process ends (bubble
74).
At this juncture the SCL Text for the Forms in the last application have
been developed in accordance with the directions of the developer/user.
Referring now to FIG. 6A, the first of a ten-sheet drawing is shown that
illustrates the run-time process, which includes the steps of the present
invention. The process begins in the client 15 with a start bubble 80
followed by a process step performed in response to entry or selection of
an URL that contains certain elements, among which are an open Command, a
Form name, a Script name and a Partition name. A Web browser forwards the
URL to the Web server 14 without otherwise interpreting it (block 81).
Next, within the Web Server 14, the URL is passed to the Web Agent (to
which it is addressed) and awaits for a response from the Web Agent (block
82).
The Web Agent then parses the URL from the Web Server 14 to obtain the
Command which is embedded within it (block 83). Next, an inquiry is made
as to whether or not the Command is "Open" (diamond 84). If the answer to
this inquiry is no, then a branch is taken to a later point in the process
as depicted by a connector R. On the other hand, if the answer to this
inquiry is yes, then the Web Agent further parses the URL (block 85) to
obtain the following:
1.) the Partition in the repository 18 to be used; and,
2.) the Script for communicating with the host.
The process illustration continues in FIG. 6B at a connector G.
Referring now to FIG. 6B at the connector G, an inquiry is made as to
whether or not an open connection to the application on the host 10 exists
(diamond 88). If the answer to this inquiry is yes, then the Web Agent
uses the Script information to locate an open connection to the
application on the host | | |
