Patent Application
20150356065
Computer systems are currently in wide use. Many computer systems have forms or other display mechanisms by which information in the computer system is presented to a user.
As one example, some computer systems include business systems. Business systems can include, for instance, enterprise resource planning (ERP) systems, customer relations management (CRM) systems, line-of-business (LOB) systems, among others. These types of systems can have hundreds or thousands of different forms that are presented to users in different contexts. Each form can have many different controls. Some forms also have associated logic, data, state information, and other behavioral information.
Business systems are but one example of such systems. For instance, electronic mail or other messaging systems, as well as electronic storefronts, document management systems and a large variety of other computer systems have forms or similar mechanisms that present data to users as well.
In order to develop a form, a developer often models the form in a development environment. The modeled form is then compiled into a serializable format (such as XML) and saved to a data store.
During runtime, the form may be used in a server-based system (such as a server-based business system). When a user requests the form in a browser, a request is sent to the server with a name of the form that needs to be opened. The server then uses the XML representation to create and initialize the form and its controls, and to execute any runtime code that is associated with the form. After all the code has been executed, the server generates the form according to a format in which it can be sent to a client application, and sends the form to the client. In some systems, the server generates a representation of the form using descriptors of the full form. For instance, the server can generate a JavaScript Object Notation (JSON) representation of the form. This is interpreted by code in the browser to generate the structure and markup language format which is used to render the form in the browser. Thus, the server generates the entire representation of the form and transmits it to the client for rendering in the browser.
The discussion above is merely provided for general background information and is not intended to be used as an aid in determining the scope of the claimed subject matter.
A request for a form is received on a client device. A static representation of the form, that includes structural information defining an overall structure of the form, as well as attribute information, is received on the client device, and a browser on the client device generates a renderable, markup language representation of the form based upon the static representation. Behavioral and state information is received from a server and is used to augment the renderable version of the form. The browser then renders the augmented, renderable version of the form.
This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter. The claimed subject matter is not limited to implementations that solve any or all disadvantages noted in the background.
Development system 102, itself, illustratively includes processor 110, user interface component 112, metadata authoring functionality 114, form compiler 116, and it can include other items 118 as well. Data store 104 illustratively includes a static (e.g., markup language) form representation 120 for each form modeled by user 102. It also illustratively includes a server representation 122. The static form representation 120 illustratively includes structural information 124 that defines an overall hierarchical structure of the corresponding form. It can include attribute information 126, and other information 128 as well. Also, in one example, it can include some data binding information indicative of data sources that are bound to the corresponding form.
Server representation 122 can include logic 130, data and other data binding information 132, state and behavioral information 134 corresponding to the form and it can include other items 136 as well.
Before describing the overall operation of environment 100 in more detail, a brief overview will be provided. User interface component 112, either itself or under the control of other items in development system 102, illustratively generates user interface displays 106 with user input mechanisms 108. User 103 illustratively uses user input mechanisms 108 in order to access metadata authoring functionality 114 to author metadata that represents a given form. Metadata authoring functionality 114 is illustratively functionality provided in development system 102 or in another development tool that allows user 103 to author metadata or other data that defines forms or other representation mechanisms. For the sake of the present discussion, in one example, the term “form” will be used to mean any mechanism by which information is displayed to a user.
Form compiler 116 illustratively compiles the metadata input by user 102 in developing forms into static form representation 120 and the server representation 122. The static representation 120 can illustratively be a representation that the server can use to send the form to a requesting client. For example, it can be a JSON representation of the form. In one example, it contains the form control hierarchy (defined by structural information 124) along with a set of properties and other optional data binding information (defined by attribute information 126) that can be used by a browser in a runtime environment in order to generate a renderable version of the form, in the browser. Compiler 116 also illustratively generates a markup language (e.g., XML) version of the form represented by server representation 122.
Thus, as described in greater detail below with respect to
User interface component 112 then displays a form authoring display so that user 103 can access metadata authoring functionality 114 in order to author the form. Displaying the form authoring display is indicated by block 156. It can include a metadata display 158, a property display 160, and other display sections 162.
Development system 102 receives inputs on metadata authoring functionality 114 in order to author the form. This is indicated by block 172 in the flow diagram of
At some point, form compiler 116 compiles the authored form. In one example, this can be performed every time the user saves the form that is being authored. In another example, compiler 116 can automatically compile the form intermittently, or on a periodic basis. Of course, the compiling can be performed at other times as well. Receiving a compile input indicating that form compiler 116 is to compile the form is indicated by block 174 in the flow diagram of
Form compiler 116 then compiles the authored form, as indicated by block 166. In doing so, as discussed above, form compiler 116 generates static form representation 120, server representation 122, and it can generate other items 178, as well. Compiler 116 reflects over the metadata in hierarchical structure 168 to generate the static version 120 of the form. The static version 120 can be represented, for example, using a JSON string or other descriptors that are understandable by a runtime browser that will be rendering the form. In any case, the static representation 120 can be used by the browser to create a markup language form (e.g., an HTML form) that is a complete representation of the modeled form, but does not have the results of the logic, all the data bindings, and the state and behavior information, for the form. This information will be provided by the server during runtime.
Table 1 below shows one example of a compiled file that represents a static form representation 204 of the example form shown in
Form compiler 116 then stores the compiled form in data store 104, for runtime use. This is indicated by block 180 in
Server environment 184 illustratively includes one or more processors 196, application server component 198, form processing component 200, and it can include other items 202 as well. Data store 188 illustratively stores the static form representations 204 and server representations 206 of the forms that are used by the application run by application server component 198. It can include data sources 208, and other items 210 as well. Client device 186 illustratively includes browser 210 that includes a form rendering component 212. Client device 186 can also include processor 214, user interface component 216, display device 218, and it can include other items 220 as well. Before describing the overall operation of environment 182 in more detail, a brief overview will be provided.
Application server component 198 illustratively runs applications (such as business system applications or other applications) that use the forms and data represented by the various representations and data stored in data store 188. Form processing component 200 illustratively processes requests for forms. Client application component 213 illustratively runs a client side portion of the applications served by application server component 198. Thus, user 194 can request the display of forms 192 through client application 213. User interface component 216 illustratively, either by itself or under the control of other items, generates the user interface displays 190 on a display device 218 on client device 186.
When user 194 requests the presentation of a form 192, browser 210 provides this request to server environment 184. Form processing component 200 retrieves the static form representation 204 for the requested form and provides it directly to client device 186. Form rendering component 212 generates a markup language, renderable, version of the requested form using the static form representation. That renderable version of the form will illustratively be a complete rendering of a form, less the results of any logic that is to be run with respect to the form, and less the behavior and state information (and some data and data bindings) that are generated by application server component 198 based on the server representation 206. The server representation 206 is provided to application server component 198 where the other information is generated (e.g., the logic associated with the form is run, the data and data bindings are obtained, the behavioral and state information is obtained, etc.). That additional information is then provided to form rendering component 212 where it is merged with the renderable version of the form that has already been generated (or that is being generated) by form rendering component 212. Once merged, the entire form is rendered by form rendering component 212, within browser 210, for display to user 194.
Client application component 213, in conjunction with application server component 198, then generates user interface displays 190 that allow user 194 to control and manipulate the server-based application. At some point, the user 194 will provide an input requesting the display of a given form 192. Receiving such an input is indicated by block 236 in the flow diagram of
This request will illustratively be provided from browser 210 to form processing component 200 in server environment 184. Form processing component 200 then retrieves the static form representation 204 for the requested form and provides it to form rendering component 212 on client device 186. It also illustratively obtains the server representation 206 for the requested form and provides it to application server component 198 so that component 198 can perform any server-side processing that is needed to obtain dynamic information that is used to completely render the form, with its current data, state information, behavior information, etc. Retrieving the server representation 206 and static form representation 204 and providing them to server environment 184 in client device 186, respectively, is indicated by block 238 in
At this point in
At the same time, a request is sent to application server component 198 by form processing component 200, requesting any additional state or behavior information, requesting server component 198 to perform any logic associated with the form, and to obtain any additional data, if it exists, for the requested form. Receiving the request at application server component 198 is indicated by block 244 in
Form rendering component 212 then augments the already-created, renderable version of the requested form with any information received from the application server component 198. This is done by merging that information with the already-created form in order to obtain an updated visualization and state of the requested form. This is indicated by block 252. The merging is illustratively done by applying the deltas obtained from the dynamic information sent by the server to the already-created form. Form rendering component 212 then renders the requested form in browser 210 for display on user interface displays 190 to user 194. Rendering the form is indicated by block 254.
It can this be seen that compiling an authored form into a static representation and its corresponding server-based representation can be used to improve form rendering performance. While the browser 210 waits for server application component 198 to run and execute all the logic and then return the results to browser 210, the form rendering component 212 in browser 210 can begin creating the document object model, or other structure, for the form on the client side using the static representation. These two types of processing can be performed in parallel. Therefore, when the application server component 198 returns any additional descriptors for the form, then only the deltas (the changes between what has already been generated as a renderable form and the additional information) are applied. The description can be sent as deltas or the deltas can be identified on the client. This improves rendering performance. The same can be done as the user interacts with the form.
The present discussion has mentioned processors and servers. In one embodiment, the processors and servers include computer processors with associated memory and timing circuitry, not separately shown. They are functional parts of the systems or devices to which they belong and are activated by, and facilitate the functionality of the other components or items in those systems.
Also, a number of user interface displays have been discussed. They can take a wide variety of different forms and can have a wide variety of different user actuatable input mechanisms disposed thereon. For instance, the user actuatable input mechanisms can be text boxes, check boxes, icons, links, drop-down menus, search boxes, etc. They can also be actuated in a wide variety of different ways. For instance, they can be actuated using a point and click device (such as a track ball or mouse). They can be actuated using hardware buttons, switches, a joystick or keyboard, thumb switches or thumb pads, etc. They can also be actuated using a virtual keyboard or other virtual actuators. In addition, where the screen on which they are displayed is a touch sensitive screen, they can be actuated using touch gestures. Also, where the device that displays them has speech recognition components, they can be actuated using speech commands.
A number of data stores have also been discussed. It will be noted they can each be broken into multiple data stores. All can be local to the systems accessing them, all can be remote, or some can be local while others are remote. All of these configurations are contemplated herein.
Also, the figures show a number of blocks with functionality ascribed to each block. It will be noted that fewer blocks can be used so the functionality is performed by fewer components. Also, more blocks can be used with the functionality distributed among more components.
The description is intended to include both public cloud computing and private cloud computing. Cloud computing (both public and private) provides substantially seamless pooling of resources, as well as a reduced need to manage and configure underlying hardware infrastructure.
A public cloud is managed by a vendor and typically supports multiple consumers using the same infrastructure. Also, a public cloud, as opposed to a private cloud, can free up the end users from managing the hardware. A private cloud may be managed by the organization itself and the infrastructure is typically not shared with other organizations. The organization still maintains the hardware to some extent, such as installations and repairs, etc.
In the embodiment shown in
It will also be noted that environment 182, or portions of it, can be disposed on a wide variety of different devices. Some of those devices include servers, desktop computers, laptop computers, tablet computers, or other mobile devices, such as palm top computers, cell phones, smart phones, multimedia players, personal digital assistants, etc.
Under other embodiments, applications or systems are received on a removable Secure Digital (SD) card that is connected to a SD card interface 15. SD card interface 15 and communication links 13 communicate with a processor 17 (which can also embody processors 110, 196 or 214 from
I/O components 23, in one embodiment, are provided to facilitate input and output operations. I/O components 23 for various embodiments of the device 16 can include input components such as buttons, touch sensors, multi-touch sensors, optical or video sensors, voice sensors, touch screens, proximity sensors, microphones, tilt sensors, and gravity switches and output components such as a display device, a speaker, and or a printer port. Other I/O components 23 can be used as well.
Clock 25 illustratively comprises a real time clock component that outputs a time and date. It can also, illustratively, provide timing functions for processor 17.
Location system 27 illustratively includes a component that outputs a current geographical location of device 16. This can include, for instance, a global positioning system (GPS) receiver, a LORAN system, a dead reckoning system, a cellular triangulation system, or other positioning system. It can also include, for example, mapping software or navigation software that generates desired maps, navigation routes and other geographic functions.
Memory 21 stores operating system 29, network settings 31, applications 33, application configuration settings 35, data store 37, communication drivers 39, and communication configuration settings 41. Memory 21 can include all types of tangible volatile and non-volatile computer-readable memory devices. It can also include computer storage media (described below). Memory 21 stores computer readable instructions that, when executed by processor 17, cause the processor to perform computer-implemented steps or functions according to the instructions. Similarly, device 16 can have a client application component 213 which can run various business applications, and browser 210. Processor 17 can be activated by other components to facilitate their functionality as well.
Examples of the network settings 31 include things such as proxy information, Internet connection information, and mappings. Application configuration settings 35 include settings that tailor the application for a specific enterprise or user. Communication configuration settings 41 provide parameters for communicating with other computers and include items such as GPRS parameters, SMS parameters, connection user names and passwords.
Applications 33 can be applications that have previously been stored on the device 16 or applications that are installed during use, although these can be part of operating system 29, or hosted external to device 16, as well.
Additional examples of devices 16 can also be used. For instance, device 16 can be a smart phone or mobile phone 45. The phone can include a set of keypads for dialing phone numbers, a display capable of displaying images including application images, icons, web pages, photographs, and video, and control buttons for selecting items shown on the display. The phone can include an antenna for receiving cellular phone signals such as General Packet Radio Service (GPRS) and 1Xrtt, and Short Message Service (SMS) signals. In some examples, the phone also includes a Secure Digital (SD) card slot that accepts a SD card.
The device can also be a personal digital assistant (PDA) or a multimedia player or a tablet computing device, etc. (hereinafter referred to as PDA. The PDA can include an inductive screen that senses the position of a stylus (or other pointers, such as a user's finger) when the stylus is positioned over the screen. This allows the user to select, highlight, and move items on the screen as well as draw and write. The PDA can also include a number of user input keys or buttons which allow the user to scroll through menu options or other display options which are displayed on the display, and allow the user to change applications or select user input functions, without contacting the display. Although not shown, the PDA can include an internal antenna and an infrared transmitter/receiver that allow for wireless communication with other computers as well as connection ports that allow for hardware connections to other computing devices. Such hardware connections are typically made through a cradle that connects to the other computer through a serial or USB port. As such, these connections are non-network connections.
Note that other forms of the devices 16 are possible.
Computer 810 typically includes a variety of computer readable media. Computer readable media can be any available media that can be accessed by computer 810 and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. Computer storage media is different from, and does not include, a modulated data signal or carrier wave. It includes hardware storage media including both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by computer 810. Communication media typically embodies computer readable instructions, data structures, program modules or other data in a transport mechanism and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. Combinations of any of the above should also be included within the scope of computer readable media.
The system memory 830 includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM) 831 and random access memory (RAM) 832. A basic input/output system 833 (BIOS), containing the basic routines that help to transfer information between elements within computer 810, such as during start-up, is typically stored in ROM 831. RAM 832 typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit 820. By way of example, and not limitation,
The computer 810 may also include other removable/non-removable volatile/nonvolatile computer storage media. By way of example only,
Alternatively, or in addition, the functionality described herein can be performed, at least in part, by one or more hardware logic components. For example, and without limitation, illustrative types of hardware logic components that can be used include Field-programmable Gate Arrays (FPGAs), Program-specific Integrated Circuits (ASICs), Program-specific Standard Products (ASSPs), System-on-a-chip systems (SOCs), Complex Programmable Logic Devices (CPLDs), etc.
The drives and their associated computer storage media discussed above and illustrated in
A user may enter commands and information into the computer 810 through input devices such as a keyboard 862, a microphone 863, and a pointing device 861, such as a mouse, trackball or touch pad. Other input devices (not shown) may include a joystick, game pad, satellite dish, scanner, or the like. These and other input devices are often connected to the processing unit 820 through a user input interface 860 that is coupled to the system bus, but may be connected by other interface and bus structures, such as a parallel port, game port or a universal serial bus (USB). A visual display 891 or other type of display device is also connected to the system bus 821 via an interface, such as a video interface 890. In addition to the monitor, computers may also include other peripheral output devices such as speakers 897 and printer 896, which may be connected through an output peripheral interface 895.
The computer 810 is operated in a networked environment using logical connections to one or more remote computers, such as a remote computer 880. The remote computer 880 may be a personal computer, a hand-held device, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer 810. The logical connections depicted in
When used in a LAN networking environment, the computer 810 is connected to the LAN 871 through a network interface or adapter 870. When used in a WAN networking environment, the computer 810 typically includes a modem 872 or other means for establishing communications over the WAN 873, such as the Internet. The modem 872, which may be internal or external, may be connected to the system bus 821 via the user input interface 860, or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer 810, or portions thereof, may be stored in the remote memory storage device. By way of example, and not limitation,
It should also be noted that the different embodiments described herein can be combined in different ways. That is, parts of one or more embodiments can be combined with parts of one or more other embodiments. All of this is contemplated herein.
Example 1 is a computing system, comprising:
a display device; and
a form rendering component on a client device configured to obtain, from a server, a static representation of a form that represents a structure of display elements on the form, generate a renderable representation of the form, merge dynamic information for the form, received from the server, into the renderable representation of the form to obtain a form visualization, and render the form visualization on the display device.
Example 2 is the computing system of any and all previous examples wherein the form rendering component is configured to receive the dynamic information and to apply differences between the renderable representation, prior to merging the dynamic information, and the dynamic information, to the renderable representation to obtain the form visualization.
Example 3 is the computing system of any and all previous examples wherein the form rendering component receives the dynamic information as a server representation of the form and identifies the differences for application to the renderable representation.
Example 4 is the computing system of any and all previous examples wherein the form rendering component receives the dynamic information from the server with the differences identified by the server.
Example 5 is the computing system of any and all previous examples wherein the form rendering component generates the renderable representation of the form, from the static representation, as a functional representation of the form, without the dynamic information.
Example 6 is the computing system of any and all previous examples wherein the form rendering component comprises a browser on the client device.
Example 7 is the computing system of any and all previous examples and further comprising:
a client application component configured to receive a user input requesting display of a form and send a request to the server to obtain the static representation of the form and to send a request to the server to obtain the dynamic information.
Example 8 is a computing system, comprising:
an application server component, on a server, configured to receive a client request, from a client, requesting a form and to, in response, send the client a static representation of the form; and
a form processing component, on the server, configured to generate, based on the client request, dynamic information for the form and send the dynamic information to the client, separately from the static representation.
Example 9 is the computing system of any and all previous examples wherein the application server component is configured to send the static representation of the form in a descriptor format that describes a functional representation of the form.
Example 10 is the computing system of any and all previous examples wherein the form processing component is configured to generate the dynamic information in the descriptor format.
Example 11 is the computing system of any and all previous examples wherein the form processing component is configured to obtain a server representation of the form, that is different from the static representation of the form, and generate the dynamic information from the server representation.
Example 12 is the computing system of claim 11 wherein the form processing component is configured to generate the dynamic information by obtaining data that populates the form.
Example 13 is the computing system of any and all previous examples wherein the form processing component is configured to generate the dynamic information to include form state information indicative of a state of controls on the form.
Example 14 is the computing system of any and all previous examples wherein the form processing component is configured to generate the dynamic information by running runtime logic corresponding to the form to obtain logic results.
Example 14 is a method, comprising:
receiving form authoring inputs, in a development system, indicative of metadata defining a form;
generating a static representation of the form based on the metadata, the static representation of the form including structural information indicative of a control structure on the form and attribute information indicative of properties of the form; and
generating, separately from the static representation, a server representation of the form based on the metadata, the server representation being indicative of dynamic information for the form.
Example 15 is the method of any and all previous examples and further comprising:
receiving a compile user input and generating the static and server representations in response to the compile user input.
Example 16 is the method of any and all previous examples and further comprising:
saving the static and server representations in a data store for runtime access.
Example 17 is the method of any and all previous examples wherein generating the static representation comprises:
reflecting over the metadata to identify the structural information and the attribute information.
Example 18 is the method of any and all previous examples wherein generating the static representation comprises:
generating the static representation with sufficient information for rendering a functional version of the form, based on the static representation.
Example 19 is the method of any and all previous examples wherein generating the static representation comprises generating the static representation in a descriptor format and wherein generating the server representation comprises generating the server representation in the descriptor format.
Example 20 is the method of any and all previous examples and further comprising:
displaying a form preview of the form in the development system, based on the static representation.
Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.
The present application is based on and claims the benefit of U.S. provisional patent application Ser. No. 62/009,667, filed Jun. 9, 2014, the content of which is hereby incorporated by reference in its entirety.
| Number | Date | Country | |
|---|---|---|---|
| 62009667 | Jun 2014 | US |
