US8244774B2 - Automated creation of web GUI for XML servers - Google Patents

Automated creation of web GUI for XML servers Download PDF

Info

Publication number
US8244774B2
US8244774B2 US11/132,648 US13264805A US8244774B2 US 8244774 B2 US8244774 B2 US 8244774B2 US 13264805 A US13264805 A US 13264805A US 8244774 B2 US8244774 B2 US 8244774B2
Authority
US
United States
Prior art keywords
data
gui
element
elements
xml
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active, expires
Application number
US11/132,648
Other versions
US20050278622A1 (en
Inventor
Christopher Betts
Trudi Ersvaer
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
CA Inc
Original Assignee
CA Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority to US57345104P priority Critical
Application filed by CA Inc filed Critical CA Inc
Assigned to COMPUTER ASSOCIATES THINK, INC. reassignment COMPUTER ASSOCIATES THINK, INC. ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: BETTS, CHRISTOPHER, ERSVAER, TRUDI
Priority to US11/132,648 priority patent/US8244774B2/en
Publication of US20050278622A1 publication Critical patent/US20050278622A1/en
Assigned to CA, INC. reassignment CA, INC. MERGER (SEE DOCUMENT FOR DETAILS). Assignors: COMPUTER ASSOCIATES THINK, INC.
Publication of US8244774B2 publication Critical patent/US8244774B2/en
Application granted granted Critical
Application status is Active legal-status Critical
Adjusted expiration legal-status Critical

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/451Execution arrangements for user interfaces
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/90Details of database functions independent of the retrieved data types
    • G06F16/95Retrieval from the web
    • G06F16/958Organisation or management of web site content, e.g. publishing, maintaining pages or automatic linking
    • G06F16/972Access to data in other repository systems, e.g. legacy data or dynamic Web page generation

Abstract

A method for automatically generating a GUI program for displaying XML data, includes parsing the XML data to identify one or more data elements within the XML data, generating a GUI element for each data element having a primitive data type by applying a pre-programmed GUI element, generating a GUI element for each data element having a custom data type by combining two or more pre-programmed GUI elements, and combining the generated GUI elements to form the GUI program.

Description

REFERENCE TO RELATED APPLICATION

The present disclosure is based on and claims the benefit of Provisional Application Ser. No. 60/573,451 filed May 21, 2004, the entire contents of which are herein incorporated by reference.

BACKGROUND

1. Technical Field

The present disclosure relates to GUI creation and, more specifically, to automated creation of web GUI for XML servers.

2. Description of the Related Art

Web based applications, for example, web services, are quickly transforming the way modern businesses interact and share information. Web services are software systems for providing particular functionality over a computer network, for example, the Internet. Web services can generally be identified by Universal Resource Identifiers (URI) in a fashion that may be analogous to the way websites may be identified by Uniform Resource Locators (URLs). Web services generally contain public interfaces and bindings that enable human users and other software systems such as other web services to utilize the functionality of the web services. In this way, web services enhance the way computers communicate with users and each other.

Graphical User Interfaces provide a way to communicate information to and from a user. A GUI may be in the form of web pages, allowing a user to read and manipulate data on a web browser. Since web pages are written in the standard language HTML, and since most personal computers have a web browser installed, a GUI in the form of a web page is convenient and popular. Web browsers use the HTTP protocol to receive and to send data to web servers.

Extensible Markup Language (XML) is a popular language by which web services communicate with one another and with human users. XML is a human readable programming language. XML instructions can be read and understood by a human, as opposed to, for example, computer languages that send instructions as binary data.

Because XML is human readable, instructions formulated in XML may be read and interpreted by any computer utilizing any platform. This stands in contrast to computer languages, such as assembly language, that are hardware specific and not human readable. This ability to be interpreted across platforms makes XML a very good tool for communicating with web services.

Unlike Hypertext Markup Language (HTML) where programs use predefined markup symbols to describe data that is communicated, XML allows for the use of customized markup symbols that may be user defined. Definitions of customized XML markup symbols comprise an XML schema. The XML schema is therefore an important element for interpreting data communicated using XML.

While data communicated in XML, for example, data that has been provided to a user form a web service, may be human readable, raw XML data may not be easily understood by the average user who is not a computer programmer. It is therefore desirable to use a GUI to display XML data in a more palatable format.

A GUI may be developed for interpreting XML data from a particular web service. The GUI may be programmed to display anticipated data elements in a predefined format. GUIs may be web browser based, allowing a user to view XML data via a web browser. However, GUIs, for example web browser based GUIs, may be difficult and/or time consuming to develop. Additionally, these GUIs are generally specific for displaying data from a particular data source, for example, a particular web service. After a GUI has been developed, the GUI is reprogrammed when the user desires to change the look and/or feel of the GUI.

It is therefore desirable to be able to automatically interpret XML data and automatically generate a suitable GUI for displaying the interpreted XML data in a sensible and customizable format.

Java Architecture for XML Binding (JAXB), from Sun Microsystems, as well as the Castor project (castor.org) allow for the parsing and conversion of XML data into Java. This system allows XML data to be interpreted and converted into a set of Java classes so XML data can be displayed and manipulated in Java. However, a GUI may still have to be programmed to implement the display and manipulation of the data.

HTML documents may include data, such as text, as well as markup symbols (tags) that may communicate details about how the data is to be displayed. An HTML browser, such as a web browser, is able to interpret the tags and use them to display the HTML data in an appropriate fashion. HTML data can be used to describe the basic format of a user interface, such as the color and font of text as well as the size and position of links and controls. However, HTML does not have the versatility of XML. HTML, while suitable for the display of standard web pages, may not be suitable for the communication of web service data. Additionally, the user interface of HTML data is generally pre-programmed by an HTML programmer and as such a GUI is not automatically generated.

More recent approaches have been developed for the description of GUIs using XML based languages. For example, User Interface Markup Language (UIML) is an XML based language for defining user interfaces. However these XML based GUI description languages still require significant programmer input to design the various GUI details such as item placement, colors, page layout and so on.

There is therefore a need for a way of automatically generating a user interface for the display and manipulation of data, for example XML and/or web service data, even when no user interface information is included in the data.

The present disclosure provides a method for automatic generation of a GUI program from a XML schema. The GUI program may be a web page, allowing the user to read and manipulate data on a web browser.

Once a GUI program is created, it is desirable to provide a two-way interactive communication between the GUI and the web service. To achieve this, it is desirable that a server program (or server programs) perform a translation function between the GUI and the XML web service. A server program will take the data the user created or changed through a web page and map it to an XML message, to be sent to the web service. The data the user created on the web page may be obtained from an HTTP GET or POST operation derived from the HTML web page form. If a response from the web service comes, a server program will take the XML message and transform it to HTML information to be displayed on the web GUI. These server programs are referred to as “translation servers”. However, manually writing these server programs from scratch for every web service message is repetitive, cumbersome and error prone.

As noted above, a number of tools (e.g. ‘Castor’ from castor.org, ‘JAXB’ from sun.com) provide for automatic creation of Java classes from XML schema. These Java classes provide programmers with an automated way of translating XML data into data structures that can be easily used within a program. However, these schema derived Java classes are simply containers for data, and do not provide any automated way for processing HTTP data from a web page GUI to construct the final XML. This step is still done manually.

There are also numerous tools (e.g. Apache Axis and Microsoft .NET) that will construct XML descriptions from existing server programs. However, there is no corresponding mechanism to do the reverse step, to automatically create server programs from XML descriptions. The present practice is to do the writing manually.

There is therefore a need for a way of automatically generating server programs that will translate data created through a GUI, specifically, data derived from a web page, to all XML message, to be sent to the web service, and also to do the reverse mapping of XML messages to information to be displayed in the GUI. There is a need for a way for allowing two-way interactive communication between the web page and the web service.

SUMMARY

A method for automatically generating a GUI program for displaying XML data, including parsing the XML data to identify one or more data elements within the XML data, generating, a GUI element for each data element having a primitive data type by applying a pre-programmed GUI element, generating a GUI element for each data element having a custom data type by combining two or more pre-programmed GUI elements, and combining the generated GUI elements to form the GUI program.

A system for automatically generating a GUI program for displaying XML data, including a parsing unit for parsing the XML data to identify one or more data elements within the XML data, a primitive-generating unit for generating a GUI element for each data element having a primitive data type by applying a pro-programmed GUI element, a custom-generating unit for generating a GUI element for each data element having a custom data type by combining two or more pre-programmed GUI elements, and a combining unit for combining the generated GUI elements to form the GUI program.

A computer system comprises a processor and a computer recording medium including computer executable code executable by the processor for automatically generating a GUI program for displaying XML data, the computer executable code comprising code for parsing the XML data to identify one or more data elements within the XML data, code for generating a GUI element for each data element having a primitive data type by applying a pre-programmed GUI element, code for generating a GUI element for each data element having a custom data type by combining two or more pre-programmed GUI elements and code for combining the generated GUI elements to form the GUI program.

BRIEF DESCRIPTION OF THE DRAWINGS

A more complete appreciation of the present disclosure and many of the attendant advantages thereof will be readily obtained as the same becomes better understood by reference to the following detailed description when considered in connection with the accompanying drawings, wherein:

FIG. 1 is an example of XML data that may be sent by a web service;

FIG. 2 is an example of a GUI element created to show the statement instance described in the XML data of FIG. 1 according to an embodiment of the present disclosure;

FIG. 3 is an example of a GUI element showing statement instances;

FIG. 4 is all example of multiple GUI windows that may be opened at the same time according to an embodiment of the present disclosure;

FIG. 5 is an example of a GUI element with forward and back navigation functions according to an embodiment of the present disclosure;

FIG. 6 is an example of a GUI element where the four field names have been simplified by merging a description with the automatically created GUI from FIG. 2;

FIG. 7 is a flowchart showing the automatic generation of a GUI from XML data according to an embodiment of the present disclosure;

FIG. 8 depicts a translation server according to an embodiment of the present disclosure;

FIG. 9 shows exemplary data of a simple bank transaction;

FIG. 10 shows XML data corresponding to the data depicted in FIG. 9;

FIG. 11 shows an XML template according to an embodiment of the present disclosure;

FIG. 12 shows an XML response message according to an embodiment of the present disclosure;

FIG. 13 shows a template for extracting key data from the XML response message, according to an embodiment of the present disclosure; and

FIG. 14 is an exemplary computer system capable of implementing various embodiments of the present disclosure.

DETAILED DESCRIPTION

In describing the preferred embodiments of the present disclosure illustrated in the drawings, specific terminology is employed for sake of clarity. However, the present disclosure is not intended to be limited to the specific terminology so selected, and it is to be understood that each specific element includes all technical equivalents which operate in a similar manner.

Embodiments of the present disclosure are capable of automatically generating a Graphical User Interface (GUI) for the display and manipulation of data, for example XML and/or web service data, even when no user interface information is included in the data.

While this XML data is human readable, users who are not computer programmers may have a very difficult time making sense of the data, and may not be able to adequately manipulate the data into a desired form. However, the highly-standardized nature of XML may be used as a basis for which a GUI may be automatically generated.

XML includes various basic markup symbols that represent various primitive data types. These primitive data types may include, for example: string, boolean, decimal, float, double, duration, data Time, time, date, etc. A more complete list of primitive XML data types are described in the XML Schema Specification, as set by the World Wide Web Consortium. XML data may include on or more data elements that may be defined by primitive data types. For example, a data element called total Weight may have a decimal data type and a value of 37×10−4.

As stated above, XML allows for the definition of custom markup symbols that correspond with custom data types. Custom data types may be more complex that the primitive data types. Custom data types may be formed from various combinations of primitive data types. For example, a data type called personnelFile may be made up of an employee name data element called employeeName that may have a string data type and a value of “Jim”, a data-of-birth data element called DateOfBirth that may have a date data type and a value of 1975-05-14, and a social security number data element called socialSecurity that may have a decimal data type and a value of 567287364×100.

Embodiments of the present disclosure automatically parse and interpret the XML data to isolate the data type and value of data elements within the XML data. For example, if XML data included an element with a totalWeight data type, parsing the data would include determining the presence of a data element with a data type of totalWeight, determining that the data type is a decimal, and determining that the value of this data element is 37×10−4.

Where the XML data to parse includes a data element with a custom data type such as personnelFile, parsing the XML data would include parsing each data element with a primitive data type within the data element with the custom type, and then parsing the data element with the custom type with respect to the primitive data types.

A GUI element may be automatically created for each data element within the XML data in accordance with pre-determined criteria. A basic GUI element may be a screen or a window that displays the data element in a manner that is consistent with the data element's data type. A basic GUI element may also provide for the manipulation of the displayed data. For example, displayed data may be sorted, altered, printed, saved, etc.

Basic GUI elements can be automatically generated for the display of XML data by creating a GUI element for each data element having a primitive data type. For example, a test field may be generated for displaying string data, a numeric field may be generated for displaying decimal data, and a calendar may be generated for displaying date data. For example, one way to create a basic GUI element is to apply a pre-programmed basic GUI element to the data element based on its primitive data type where a pre-programmed basic GUI element is available for each primitive data type defined

Custom GUI elements can be automatically generated for the display of XML data by automatically creating a GUI element for each element of data having a custom data type. Because custom data types are generally formed from various combinations of primitive data types, custom GUI elements can be generated using various combinations of primitive GUI elements. For example, a GUI element generated for data having a personelFile data type, as described above, may be a window displaying a heading titled “personelFile” along with a text field labeled “employeeName” for displaying string data, a numeric field labeled “socialSecurity” for displaying decimal data, and a calendar field labeled “dateOfBirth” for displaying date data. The fields may be filled in with their respective values.

Custom GUI elements may display data elements in the same order as they are listed in the XML data. In addition, the names of the data elements may be displayed along with the GUI elements to give the listed GUI elements some basic context.

FIG. 1 is an example of XML data 100 that could be sent by a web service. The XML data 100-128 describes a financial transaction statements (TransactionStatement) data element having one statement instance (Statementinstance) data element 105-127. The statement instance data element 105-127 has a transaction amount (TransactionAmount) data element 106-108, transaction source (TransactionSource) data element 109-114, transaction destination (TransactionDestination) data element 115-120, and a transaction date (TransactionDate) data element 121-126. The statement instance 105-127 is of a custom data type made up of data elements defined by primitive data types. Here, transaction amount may be a decimal data type 107, transaction source may be a string data type 112, transaction destination may be a string data type 118, and transaction date may be a dateTime data type 124.

FIG. 2 is an example GUI element that can show the statement instance 105-127 according to an embodiment of the present disclosure. A GUI element for displaying a transaction statement 20 is automatically created. Four field names 21 are created for each of the four data elements that may appear as part of the statement instance 105-127. Four fields 22 are created for displaying the values associated with each of the four data elements. These fields may be programmed to display the associated XML data elements in a manner that is appropriate for their primary data types. For example, transaction amount may be a decimal data type and may therefore be displayed as a number.

XML data may be hierarchical. For example, a transaction statement may include multiple statement instances that are nested with the transaction statement. Where multiple statement instances exist, a GUI element may automatically be created that lists all of the statement instances, however, the GUI element need not display the data elements that comprise the listed statement instances. Each statement instance may be expandable such that when selected by a user, the data elements within the selected statement instance may be displayed.

FIG. 3 is an example GUI element 30 showing four statement instances 31. If each statement instance is named within the XML data, those names may appear in corresponding value fields 32. Alternatively, the first data element value within the statement instance is displayed in the corresponding value field. For example, the transaction amount data element value may be displayed. When a particular instance is selected by the user, a GUI element representing that particular statement instance data element may be displayed as shown in FIG. 2.

Expanded GUI elements may be collapsible. By collapsing a GUI element, a user may return to the GUI element listing statement instances 30. By expanding and collapsing GUI elements, a user may navigate through displays of hierarchical data.

Alternatively, expanding GUI elements may open new GUI element windows while leaving the original GUI window present. GUI windows may then be closed by the user as desired. FIG. 4 is an example of multiple GUI windows 40-43 that may be open at the same time.

GUI Wizards may be used to present GUI elements to the user. For example, GUI elements may be displayed to the user sequentially along with navigation information. Here complex data may be presented as stages, each stage being displayed separately. Navigation functions such as “forward”, “back”, and/or “stage x of N” may be provided. FIG. 5 is an example of a GUI element 50 with forward 51 and back 52 navigation functions.

According to embodiments of the present disclosure, GUI elements are created automatically based on the XML data. This has the advantage of ensuring that all XML data elements may be displayed unlike manually created GUIs that may contain errors or omissions.

While GUI elements may be automatically created, it may still be possible for a user to adjust the manner in which XML data is displayed. According to some embodiments of the present disclosure, a user may customize display settings. According to one such embodiment, the user may manually adjust the code of the automatically generated GUI after it has been generated. According to another such embodiment, the user may create a separate description of the required changes, for example as XML code, and these changes may be merged into the automatically generated GUI. This embodiment has the advantage of allowing the description to be merged with any number of automatically created GUIs without having to recreate the description. Descriptions may be used to adjust any display settings or provide for additional GUI functionality. For example, descriptions may be used to provide help menus, expanded descriptions of GUI elements, changes to layouts, for example, font colors, links to other products and programs, and branding mad marketing logos and links. FIG. 6 depicts an example GUI element 60 where the four field names 61 have been simplified by merging a description with the automatically created GUI from FIG. 2.

FIG. 7 is a flowchart showing the automatic generation of a GUI from XML data according to an embodiment of the present disclosure. First, the XML data is automatically parsed (Step S70). This may include identifying various data elements from the XML data, identifying a data type of each of the various identified data elements, and identifying values for each of the various identified data elements.

Next, GUI elements are generated to display the identified data elements (Step S71). Each GUI element may be automatically generated to display the data elements in a manner appropriate for its data type. Where data elements may be hierarchical, respective GUI elements may display the data elements as expandable and/or collapsible. Navigation tools may also be provided for the user to easily navigate the various GUI elements.

The created GUI elements may be combined to form a GUI program for the XML data (Step S72). This GUI program may be written in a computer language, such as, for example, Java. The created GUI program may incorporate tools for manipulating the displayed data.

Finally, the GUI program may be merged with a description of customized features (Step S73). This description may be a file created by a user that incorporates customizations that the user would like to apply to the GUI program.

A web service is an XML aware application, usually accepting XML data embedded in Simple Object Access Protocol (SOAP).

As noted above, although XML data is human readable, users who are not computer programmers may have a very difficult time manipulating data in XML form. Therefore, it is desirable to provide GUIs, specifically, web pages, for users to interact with web services. To communicate information back and forth between the GUI and a web service, a backend or translation server according to an embodiment of the present disclosure is utilized. The translation server receives data obtained from web pages, maps the data to XML message, and sends the message to a web service. When and XML response message is received, the translation server does the reverse mapping and sends the received data to the web interface.

The highly-standardized nature of XML allows automatic generation of the core code of the translation server. Such automatically generated translation servers can produce complete, legal XML messages, avoiding the risk that developers may accidentally make mistakes in writing the server program, or leave functionality out due to time pressures.

Embodiments of the present disclosure automatically generate translation server programs that can take information from a web page and map it to an XML message, which can then be sent to a web service. The information can be obtained from an HTTP GET or POST operation derived from an HTML web page form. When an XML response message is sent from the web service, the translation server maps it to an HTTP based message and sends it to the web browser. Therefore, embodiments of the present disclosure provide the relatively automatic generation of translation server programs that enable a two-way interactive communication between a web page and a web service.

FIG. 8 illustrates an embodiment of the present disclosure showing the relationship between the translation server, the web page, and the web service, showing the basic functions performed by a translation server 80. As shown, the translation server 80 takes information from user GUI 82, maps HTTP data to XML fragments (84), constructs the full XML message 82, and sends it to the destination serve 88 in this case target web service 90. Translation server 80 also receives replies 92 from target web service 90, extracts specific data from the XML message 94 and returns it 96 to user GUI 82.

As described earlier, a GUI program such as, for example, a web page, can be automatically generated for the display of XML data. The present disclosure also provides a relatively automated construction of an interactive user interface for a web service.

FIG. 9 is an example of a GUI 82 including data representing a simple bank transaction. Presented in a web page form, it is very easy for the user to view and manipulate the presented data. This compares favorably with the XML representation of the data, illustrated in FIG. 10. In FIG. 10, the XML data 300-328 describes a financial transaction statements (TransactionStatement) data element having one statement instance (Statementinstance) data element 305-327. The statement instance data element 305-327 has a transaction amount (TransactionAmount) data element 306-308, transaction source (TransactionSource) data element 309-314, transaction destination (TransactionDestination) data element 315-320, and a transaction date (TransactionDate) data element 321-326. The statement instance 305-327 is a custom data type made up of data elements defined by primitive data types. Here, transaction amount may be a decimal data type 307, transaction source may be a string data type 312, transaction destination may be a string data type 318, and transaction date may be a dateTime data type 324. The XML example code contains further information, such as the transaction date, the currency type, and so on, but this information can usually be added by the program without explicitly asking the user.

Once the user enters the information requested by the GUI 82, the information is sent to the translation sever 80 via a HTTP GET or POST operation. The translation server 80 will parse the HTTP message and extract the data elements. In this example, this involves parsing the HTML form data to extract the Name, the Amount, and the Destination Bank data elements. Parsing an HTTP message can be done in a standard manner. The present system may generate code to parse messages.

The translation server 80 then maps the data elements into XML data. This may be performed in a number of ways. For example, one way is to use a text template method. FIG. 11 is an example of such a template, where the text string “amount” is a place holder tag alerting the server to replace the tag with a value. There are a number of standard computer science techniques for writing such templates. Once the translation server has extracted the Amount data element, it can replace the place holder tag with the data value. When all three data elements have been merged with the template, the result is the XML data shown in FIG. 10.

Another way of performing mapping is to utilize automatically generated code representing the XML data structure and fill in the data structure with data elements extracted in the previous step. The code representing the XML data structure may be a Java class automatically generated from the XML schema. Tools such as ‘Caster’ from the Apache organization and ‘JAXB’ from Sun Microsystems can perform this code generation. The Java class generated is a data container, representing the XML data structure (the “Document Object Model Tree”, or the “DOM Tree”). The data elements extracted from the previous step can then be used to initialize the data objects contained in the Java container class. The Java data objects can then be used to generate the XML data file.

In both of these mapping methods, the server program does not need to be manually coded, resulting in significant labor savings. Using automatically generated Java objects (e.g. from JAXB) may simplify things further as there will be no need to create the text templates, and the objects may be automatically recreated whenever the schema chances.

The mapping from the information obtained from a web page to XML data is performed according to predetermined criteria. In other words, the mapping is possible because there is a predetermined relationship between the information obtained from the web page and the corresponding XML schema. In the case where the web page is generated from XML data utilizing one or more of the above-described embodiments, this mapping criteria can be determined in accordance with the process of GUI program generation descried.

Some extra work may be required to initialize environment variables (such as the current date). In the case of templates, standard methods may be used to insert date and time values. In the case of JAXB created objects, standard code libraries can be created to automatically initialize environment variables such as the current date.

Once the XML data is created, and XML message can be assembled from the XML data. This may involve adding message headers (such as HTTP headers or SOAP headers) to the raw XML data. Code generation for this assembling function is possible due to the standard nature of the assembly. The XML message may then be sent via HTTP/SOAP or the equivalent to the destination web service. The location of the destination of the web service may be pre-configured, or it can be obtained by standard techniques such as interrogation of a UDDI server.

FIG. 12 is an example of an XML response message sent by the web service 90. Translation server 80 transforms the XML data into a form that can be received and displayed by the web GUI 82.

The mapping of raw XML data to relevant data elements may be performed in a number of ways. For example, a template may be used to extract key data from the XML data. FIG. 13 shows a template according to an embodiment of the present disclosure, which contains wild cards and tags 603, 606 for key data positions. The XML data is processed until a match for the key data is obtained and that data extracted. Another example is to use a XML stylesheet transformation. This transformation performs the same function as the template method, but in a standard manner using standard tools. Yet another example involves parsing the XML data using automatically generated code (e.g. via JAXB). Once the XML data is parsed, relevant user data may be extracted directly from pre-determined code objects.

The data fragments extracted from the mapping can then be passed back to the user. The data fragments may be assembled into an HTTP based message or information format and passed to a subsidiary server that would assemble the web page HTML. This could also be done via an XSLT stylesheet.

The present disclosure thus provides for the automatic generation of web GUI programs based on XML data. In addition, the present disclosure provides for the automated generation of translation server code, allowing a two-way interactive communication between the web GUI and the web service. This provides a relatively automated construction of an interactive user interface for a web service.

FIG. 14 shows and example of a computer system which may implement the method and system of the present disclosure. The system and method of the present disclosure may be implemented in the form of a software application running on a computer system, for example, a mainframe, personal computer (PC), handheld computer, server, etc. The software application may be stored on a recording media locally accessible by the computer system and accessible via a hard wired or wireless connection to a network, for example, a local area network, or the Internet.

The computer system referred to generally as system 1000 may include, for example, a central processing unit (CPU) 1001, random access memory (RAM) 1004, a printer interface 1010, a display unit 1011, a local area network (LAN) data transmission controller 1005, a LAN interface 1006, a network controller 1003, an internal buss 1002, and one or more input devices 1009, for example, a keyboard, mouse etc. As shown, the system 1000 may be connected to a data storage device, for example, a hard disk, 1008 via a 1002.

The above specific embodiments are illustrative, and many variations can be introduced on these embodiments without departing from the spirit of the disclosure or from the scope of the appended claims. For example, elements and/or features of different illustrative embodiments may be combined with each other and/or substituted for each other within the scope of this disclosure and appended claims.

Claims (24)

1. A method for automatically generating a GUI program for displaying XML data, comprising:
parsing the XML data to identify one or more data elements within the XML data, wherein parsing the XML data comprises identifying a value for the one or more data elements within the XML data;
generating a GUI element for each data element having a primitive data type by applying a pre-programmed GUI element;
generating a GUI element for each data element having a custom data type by combining two or more pre-programmed GUI elements, the custom data type comprising two or more nested primitive data types, the GUI element for each data element having the custom data type comprising a collapsible GUI element;
combining the generated GUI elements to form the GUI program that displays the generated GUI elements and the value associated with each generated GUI elements; and
merging a user customization of at least one of the generated GUI elements into the GUI program.
2. The method of claim 1, wherein parsing the XML data comprises identifying the data type of the one or more data elements within the XML data.
3. The method of claim 1, wherein one or more pre-programmed GUI elements have been pre-programmed to display data elements having a plurality of corresponding primitive data types defined by XML standards and each of the pre-programmed GUI elements is specifically tailored for displaying data of its corresponding data type.
4. The method of claim 1, wherein generating a GUI element for each data element having a custom data type by combining two or more pre-programmed GUI elements comprises:
identifying two or more data elements with primitive data types within the data element with the custom data type;
utilizing a pre-programmed GUI element for each of the two or more data element having a primitive data type within the data element with the custom data type; and
combining the utilized pre-programmed GUI elements to form the GUI element for each data element having a custom data type.
5. The method of claim 4, wherein one or more pre-programmed GUI elements have been pre-programmed to display data elements having a plurality of corresponding primitive data types defined by XML standards and each of the pre-programmed GUI elements is specifically tailored for displaying data of its corresponding data type.
6. The method of claim 1, wherein the formed GUI program is web browser based.
7. The method of claim 1, wherein the formed GUI program allows for the manipulation of the displayed XML data.
8. The method of claim 1, wherein the formed GUI program provides navigation functions.
9. A system for automatically generating a GUI program for displaying XML data, comprising:
a computer-readable medium; and
a processor, the processor operable to execute a program of instructions encoded on the computer-readable medium, the program of instructions comprising:
a parsing unit for parsing the XML data to identify one or more data elements within the XML data, wherein parsing the XML data comprises identifying a value for the one or more data elements within the XML data;
a primitive-generating unit for generating a GUI element for each data element having a primitive data type by applying a pre-programmed GUI element;
a custom-generating unit for generating a GUI element for each data element having a custom data type by combining two or more pre-programmed GUI elements, the custom data type comprising two or more nested primitive data types, the GUI element for each data element having the custom data type comprising a collapsible GUI element;
a combining unit for combining the generated GUI elements to form the GUI program, the GUI program displaying the generated GUI elements and the value associated with each generated GUI elements; and
the combining unit further for merging a user customization of at least one of the generated GUI elements into the GUI program.
10. The system of claim 9, wherein parsing the XML data comprises identifying the data type of the one or more data elements within the XML data.
11. The system of claim 9, wherein one or more pre-programmed GUI elements have been pre-programmed to display data elements having a plurality of corresponding primitive data types defined by XML standards and each of the pre-programmed GUI elements is specifically tailored for displaying data of its corresponding data type.
12. The system of claim 9, wherein the custom-generating unit comprises:
an identifying unit for identifying two or more data elements with primitive data types within the data element with the custom data type;
a utilizing unit for utilizing a pre-programmed GUI element for each of the two or more data element having a primitive data type within the data element with the custom data type; and
a custom-combining unit for combining the utilized pre-programmed GUI elements to form the GUI element for each data element having a custom data type.
13. The system of claim 12, wherein one or more pre-programmed GUI elements have been pre-programmed to display data elements having a plurality of corresponding primitive data types defined by XML standards and each of the pre-programmed GUI elements is specifically tailored for displaying data of its corresponding data type.
14. The method of claim 9, wherein the formed GUI program is web browser based.
15. The method of claim 9, wherein the formed GUI program allows for the manipulation of the displayed XML data.
16. The method of claim 9, wherein the formed GUI program provides navigation functions.
17. A computer system comprising:
a processor; and
a computer recording medium including computer executable code executable by the processor for automatically generating a GUI program, for displaying XML data, the computer executable code comprising:
code for parsing the XML data to identify one or more data elements within the XML data, wherein the code for parsing the XML data comprises code for identifying a value for the one or more data elements within the XML data;
code for generating a GUI element for each data element having a primitive data type by applying a pre-programmed GUI element;
code for generating a GUI element for each data element having a custom data type by combining two or more pre-programmed GUI elements, the custom data type comprising two or more nested primitive data types, the GUI element for each data element having the custom data type comprising a collapsible GUI element;
code for combining the generated GUI elements to form the GUI program, the GUI program displaying the generated GUI elements and the value associated with each generated GUI elements; and
code for merging a user customization of at least one of the generated GUI elements into the GUI program.
18. The computer system of claim 17, wherein the code for parsing the XML data comprises code for identifying the data type of the one or more data elements within the XML data.
19. The computer system of claim 17, wherein one or more pre-programmed GUI elements have been pre-programmed to display data elements having a plurality of corresponding primitive data types defined by XML standards and each of the pre-programmed GUI elements is specifically tailored for displaying data of its corresponding data type.
20. The computer system of claim 17, wherein the code for generating a GUI element for each data element having a custom data type by combining two or more pre-programmed GUI elements comprises:
code for identifying two or more data elements with primitive data types within the data element with the custom data type;
code for utilizing a pre-programmed GUI element for each of the two or more data element having a primitive data type within the data element with the custom data type; and
code for combining the utilized pre-programmed GUI elements to form the GUI element for each data element having a custom data type.
21. The computer system of claim 20, wherein one or more pre-programmed GUI elements have been pre-programmed to display data elements having a plurality of corresponding primitive data types defined by XML standards and each of the pre-programmed GUI elements is specifically tailored for displaying data of its corresponding data type.
22. The method of claim 17, wherein the formed GUI program is web browser based.
23. The method of claim 17, wherein the formed GUI program allows for the manipulation of the displayed XML data.
24. The method of claim 17, wherein the formed GUI program provides navigation functions.
US11/132,648 2004-05-21 2005-05-19 Automated creation of web GUI for XML servers Active 2030-12-22 US8244774B2 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US57345104P true 2004-05-21 2004-05-21
US11/132,648 US8244774B2 (en) 2004-05-21 2005-05-19 Automated creation of web GUI for XML servers

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US11/132,648 US8244774B2 (en) 2004-05-21 2005-05-19 Automated creation of web GUI for XML servers

Publications (2)

Publication Number Publication Date
US20050278622A1 US20050278622A1 (en) 2005-12-15
US8244774B2 true US8244774B2 (en) 2012-08-14

Family

ID=34971620

Family Applications (2)

Application Number Title Priority Date Filing Date
US11/132,703 Active 2026-10-20 US7562307B2 (en) 2004-05-21 2005-05-19 Automated creation of web page to XML translation servers
US11/132,648 Active 2030-12-22 US8244774B2 (en) 2004-05-21 2005-05-19 Automated creation of web GUI for XML servers

Family Applications Before (1)

Application Number Title Priority Date Filing Date
US11/132,703 Active 2026-10-20 US7562307B2 (en) 2004-05-21 2005-05-19 Automated creation of web page to XML translation servers

Country Status (3)

Country Link
US (2) US7562307B2 (en)
EP (1) EP1769338A1 (en)
WO (2) WO2005114401A1 (en)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN104219249A (en) * 2014-09-26 2014-12-17 广州市问道文化传播有限公司 Method and device for returning different contents according to configuration information of server

Families Citing this family (33)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20050235272A1 (en) * 2004-04-20 2005-10-20 General Electric Company Systems, methods and apparatus for image annotation
US20070150821A1 (en) * 2005-12-22 2007-06-28 Thunemann Paul Z GUI-maker (data-centric automated GUI-generation)
US20070300141A1 (en) * 2006-06-22 2007-12-27 Melyssa Barrett Method and system for document interaction
US20080028374A1 (en) * 2006-07-26 2008-01-31 International Business Machines Corporation Method for validating ambiguous w3c schema grammars
US9128727B2 (en) * 2006-08-09 2015-09-08 Microsoft Technology Licensing, Llc Generation of managed assemblies for networks
US7831919B1 (en) * 2006-12-18 2010-11-09 Symantec Corporation Generic web service frontend
JP2008242873A (en) * 2007-03-28 2008-10-09 Hitachi Ltd Software automatic configuring device and method
US8407297B2 (en) * 2007-10-22 2013-03-26 Sap Ag Systems and methods to receive information from a groupware client
KR101362224B1 (en) * 2007-12-03 2014-02-13 연세대학교 산학협력단 Apparatus and method for generating user interface based on task service
JP4185159B1 (en) * 2008-01-30 2008-11-26 株式会社三菱東京Ufj銀行 Application development support device and program
US8200742B2 (en) 2008-02-13 2012-06-12 Robert Kocyan Apparatus, system, and method for facilitating data flow between a first application programming interface and a second application programming interface
JP4613214B2 (en) * 2008-02-26 2011-01-12 日立オートモティブシステムズ株式会社 Software auto-configuration system
US8365147B2 (en) * 2008-02-27 2013-01-29 Accenture Global Services Limited Test script transformation architecture
US8516442B2 (en) * 2008-02-27 2013-08-20 Accenture Global Services Limited Graphical user interface metadata evolution tool
US8490050B2 (en) * 2008-04-17 2013-07-16 Microsoft Corporation Automatic generation of user interfaces
US20100149215A1 (en) * 2008-12-15 2010-06-17 Personal Web Systems, Inc. Media Action Script Acceleration Apparatus, System and Method
US8487941B2 (en) * 2008-12-15 2013-07-16 Leonovus Usa Inc. Media action script acceleration apparatus
US8487942B2 (en) * 2008-12-15 2013-07-16 Leonovus Usa Inc. Media action script acceleration system
US8229937B2 (en) * 2008-12-16 2012-07-24 Sap Ag Automatic creation and transmission of data originating from enterprise information systems as audio podcasts
US8200710B2 (en) * 2009-07-28 2012-06-12 Sap Ag System and method for runtime rendering of web-based user interfaces for master data management
US8713540B2 (en) * 2010-07-29 2014-04-29 National Instruments Corporation Generating and modifying textual code interfaces from graphical programs
US20120272233A1 (en) * 2010-12-20 2012-10-25 Won Jae Lee Automatic creating method of group application and couple application
US20130067432A1 (en) * 2011-09-12 2013-03-14 Microsoft Corporation Application development toolkit
US9372844B2 (en) * 2011-10-01 2016-06-21 Oracle International Corporation Automatically generating a business process flow GUI using a symbolic annotation language
US8930810B2 (en) * 2012-02-13 2015-01-06 International Business Machines Corporation User interface (UI) color scheme generation and management according to visual consistency of visual attributes in the color scheme
US20130311974A1 (en) * 2012-05-16 2013-11-21 Zoltan Albrecht Debugger integration of reporting tool renderer
WO2015116225A2 (en) * 2014-01-31 2015-08-06 Hewlett-Packard Development Company, L.P. Test automation modeling
US9342300B2 (en) * 2014-03-11 2016-05-17 Blue Wolf Group, LLC Analyzing components related to a software application in a software development environment
US20160117068A1 (en) * 2014-10-09 2016-04-28 Wrap Media, LLC Wrapped packages of cards for conveying a story-book user experience with media content, providing application and/or web functionality and engaging users in e-commerce
EP3311265A4 (en) 2015-06-18 2019-02-20 The Joan & Irwin Jacobs Technion-Cornell Innovation Institute A computing platform and method thereof for searching, executing, and evaluating computational algorithms
US20170235563A1 (en) * 2016-02-12 2017-08-17 Nutanix, Inc. Virtualized File Server Rolling Upgrade
WO2018022430A1 (en) * 2016-07-25 2018-02-01 The Joan and Irwin Jacobs Technion-Cornell Institute Method and system for automatically providing graphical user interfaces for computational algorithms described in printed public
CN107239318B (en) * 2017-06-13 2018-09-04 腾讯科技(深圳)有限公司 Application conversion method, apparatus and equipment

Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20020085020A1 (en) * 2000-09-14 2002-07-04 Carroll Thomas J. XML-based graphical user interface application development toolkit
EP1291766A2 (en) 2001-06-15 2003-03-12 Microsoft Corporation Systems and methods for creating and displaying a user interface for displaying hierarchical data
US20040046789A1 (en) * 2002-08-23 2004-03-11 Angelo Inanoria Extensible user interface (XUI) framework and development environment
US6717593B1 (en) * 2000-09-12 2004-04-06 Avaya Technology Corp. Mark-up language implementation of graphical or non-graphical user interfaces
JP2004110650A (en) 2002-09-20 2004-04-08 Hitachi Information Systems Ltd Extensible markup language document processor

Family Cites Families (13)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US163603A (en) * 1875-05-25 Harbison ogborn
US18661A (en) * 1857-11-17 nettleton
US6404445B1 (en) * 1999-12-30 2002-06-11 Cybrant Corporation Method and system for modeling data
US7284239B1 (en) * 2000-06-06 2007-10-16 Adobe Systems Incorporated Transforming server-side processing grammars
US6961900B1 (en) * 2000-08-28 2005-11-01 Microsoft Corporation Rendering data according to a present schema from an origin response message
US6948133B2 (en) * 2001-03-23 2005-09-20 Siemens Medical Solutions Health Services Corporation System for dynamically configuring a user interface display
US7152090B2 (en) * 2001-06-01 2006-12-19 Sun Microsystems, Inc. Metadata-aware enterprise application integration framework for application server environment
US20030018661A1 (en) * 2001-07-19 2003-01-23 Darugar Parand Tony XML smart mapping system and method
US7962925B2 (en) * 2002-02-22 2011-06-14 Oracle International Corporation System and method for XML data binding
US20030172193A1 (en) * 2002-03-07 2003-09-11 Olsen Jesse Dale User interface generator and method of automatically generating a user interface
US7409674B2 (en) * 2002-12-26 2008-08-05 Research In Motion Limited System and method of creating and communicating with component based wireless applications
EP1460533A1 (en) * 2003-03-17 2004-09-22 Alcatel Extensible graphical user interface development framework
US20060236254A1 (en) * 2005-04-18 2006-10-19 Daniel Mateescu System and method for automated building of component based applications for visualizing complex data structures

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6717593B1 (en) * 2000-09-12 2004-04-06 Avaya Technology Corp. Mark-up language implementation of graphical or non-graphical user interfaces
US20020085020A1 (en) * 2000-09-14 2002-07-04 Carroll Thomas J. XML-based graphical user interface application development toolkit
EP1291766A2 (en) 2001-06-15 2003-03-12 Microsoft Corporation Systems and methods for creating and displaying a user interface for displaying hierarchical data
US20040046789A1 (en) * 2002-08-23 2004-03-11 Angelo Inanoria Extensible user interface (XUI) framework and development environment
JP2004110650A (en) 2002-09-20 2004-04-08 Hitachi Information Systems Ltd Extensible markup language document processor

Non-Patent Citations (11)

* Cited by examiner, † Cited by third party
Title
Ali et al. "Building Multi-Platform User Interfaces With UIML" Nov. 8, 2001 Virginia Tech University Department of Computer Science. *
DataX: an Approach to Ubiquitous Database Access; Hui Lei, et al.; IBM Thomas J. Watson Research Center; XP-10323393; pp. 70 to 79, 1999.
Goodman, Danny. JavaScript & DHTML Cookbook. Chapter 10, Section 11. O'Reilly, Apr. 2003. ISBN 0-596-00467-2. *
Heather Kreger, "Web Services Conceptual Architecture (WSCA 1.0)" IBM Software Group, (XP002203346), 42 pages, May 2001.
IBM Technical Disclosure Bulletin; XP-000303300; Custom Data Entry Form System for Software Applications; vol. 34, No. 11, pp. 384 and 385, Apr. 1992.
Jianguo Lu et al., "Extensible Information Brokers", International Journal on Artificial Intelligence Tools, World Scientific, Singapore, vol. 11, No. 1. (XP002344137) pp. 95-115, Mar. 2002.
Notification of Transmittal of the International Search Report for application PCT/US2005/017790 (7 pages), Sep. 28, 2005.
PCT Invitation to Pay Additional Fees for Application No. PCT/US2005/017578, filed May 19, 2005, (8 pages), Nov. 2, 2005.
Sahuguet et al., "Looking at the Web Through XML Glasses", Cooperative Information Systems, COOPIS '99, Proceedings, International Conference on Edinburgh, UK, (XP010351848), pp. 148-159, Sep. 1999.
Written Opinion of the International Searching Authority for application PCT/US2005/017790 (5 pages), Sep. 28, 2005.
XP-002345155; The DIANA Approach to Mobile Computing; Arthur M. Keller, et al.; pp. 1 to 17.

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN104219249A (en) * 2014-09-26 2014-12-17 广州市问道文化传播有限公司 Method and device for returning different contents according to configuration information of server
CN104219249B (en) * 2014-09-26 2018-11-27 广州市问道文化传播有限公司 The server returns the configuration information of different contents according to a method and apparatus

Also Published As

Publication number Publication date
WO2005114401A1 (en) 2005-12-01
US20060004768A1 (en) 2006-01-05
WO2005114479A2 (en) 2005-12-01
US7562307B2 (en) 2009-07-14
EP1769338A1 (en) 2007-04-04
WO2005114479A3 (en) 2006-05-18
US20050278622A1 (en) 2005-12-15

Similar Documents

Publication Publication Date Title
Abrams et al. UIML: an appliance-independent XML user interface language
US7739665B2 (en) Dynamic conversion of object-oriented programs to tag-based procedural code
JP4467205B2 (en) Handling of postback input by the server-side control object
JP5363506B2 (en) The method for customizing and distributing existing applications using browser-based proxy servers, systems, and computer program (browser-based proxy server to customize and distribute existing applications)
US6973625B1 (en) Method for creating browser-based user interface applications using a framework
JP4929704B2 (en) Computer processing method and a computer processing unit
US6560621B2 (en) World wide web formatting for program output through print function
Esselink A practical guide to localization
JP4339554B2 (en) System and method for creating and displaying a user interface for displaying hierarchical data
US6865593B1 (en) Dynamic integration of web sites
US10237371B2 (en) Content management and transformation system for digital content
CN1257473C (en) Active ALT tag method and system in HTML documents to increase the accessibility
EP1350180B1 (en) Authoring arbitrary xml documents using dhtml and xslt
JP4344693B2 (en) System and method for the browser of the document editing
US8200780B2 (en) Multiple bindings in web service data connection
AU2010201376B2 (en) Increasing portability of document-based user interface software objects
US6262729B1 (en) Method and apparatus for binding user interface objects to application objects
CN100421375C (en) Data sharing system, method and software tool
US7313757B2 (en) Method and system for cross-platform form creation and deployment
US20030050931A1 (en) System, method and computer program product for page rendering utilizing transcoding
KR101409673B1 (en) Persistent saving portal
JP5099982B2 (en) Method and apparatus for generating a user interface based on automation with full flexibility
US20020101448A1 (en) Generating a declarative user interface
US20060200749A1 (en) System and method for conversion of generic services' applications into component based applications for devices
US6718515B1 (en) Method of populating a dynamic HTML table from a set of data objects through a common interface

Legal Events

Date Code Title Description
AS Assignment

Owner name: COMPUTER ASSOCIATES THINK, INC., NEW YORK

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:BETTS, CHRISTOPHER;ERSVAER, TRUDI;REEL/FRAME:016583/0831

Effective date: 20050315

AS Assignment

Owner name: CA, INC., NEW YORK

Free format text: MERGER;ASSIGNOR:COMPUTER ASSOCIATES THINK, INC.;REEL/FRAME:028231/0341

Effective date: 20120327

STCF Information on status: patent grant

Free format text: PATENTED CASE

FPAY Fee payment

Year of fee payment: 4