FreshPatents.com Logo
stats FreshPatents Stats
n/a views for this patent on FreshPatents.com
Updated: August 12 2014
newTOP 200 Companies filing patents this week


    Free Services  

  • MONITOR KEYWORDS
  • Enter keywords & we'll notify you when a new patent matches your request (weekly update).

  • ORGANIZER
  • Save & organize patents so you can view them later.

  • RSS rss
  • Create custom RSS feeds. Track keywords without receiving email.

  • ARCHIVE
  • View the last few months of your Keyword emails.

  • COMPANY DIRECTORY
  • Patents sorted by company.

Follow us on Twitter
twitter icon@FreshPatents

Synchronization of form fields in a client-server environment

last patentdownload pdfdownload imgimage previewnext patent


Title: Synchronization of form fields in a client-server environment.
Abstract: A database tier maintains and provides access to a database. An application tier receives and responds to requests for a form. The form includes data defining a first UI control for displaying a first value from the database and a second UI control for displaying a second value from the database that is dependent upon the first value. A client tier renders the form to show the first value in the first UI control and to show the second value in the second UI control. The client tier also detects a modification to the first value and causes an updated second value to be generated in response to detecting the modification to the first value. The updated second value is displayed by way of the second UI control. The updated second value is generated at the client tier, the application tier, the database tier, or at a combined application/database tier. ...


Browse recent Microsoft Corporation patents - Redmond, WA, US
Inventors: Russell Sinclair, Michael Hopkins Smith, Clinton Dee Covington, Jenefer Monroe, Konrad Tupaj
USPTO Applicaton #: #20120102412 - Class: 715747 (USPTO) - 04/26/12 - Class 715 
Data Processing: Presentation Processing Of Document, Operator Interface Processing, And Screen Saver Display Processing > Operator Interface (e.g., Graphical User Interface) >For Plural Users Or Sites (e.g., Network) >Interface Customization Or Adaption (e.g., Client Server) >End User Based (e.g., Preference Setting)

view organizer monitor keywords


The Patent Description & Claims data below is from USPTO Patent Application 20120102412, Synchronization of form fields in a client-server environment.

last patentpdficondownload pdfimage previewnext patent

BACKGROUND

Database applications commonly utilize forms to display database information and for data entry. These forms utilize fields to display information retrieved from a database and to collect data for storage in the database. In certain database systems, it is possible to define a field on a form that is dependent upon another field on the form. For instance, a form may be defined for displaying information from a database regarding a customer order. The form might include a first field for showing a customer name and a second field, dependent upon the first field, for showing the street address of the customer selected in the first field.

When a user modifies the value shown by a form field, the user expects any other fields that are dependent upon the modified field to be updated to reflect the modified value. For instance, if a user modifies the customer shown in the first field in the example given above, the user will expect the second field to be updated to reflect the correct street address of the newly selected customer. If dependent fields are not updated in this manner, the user might be presented with stale information and may become confused.

Certain client-side database applications provide functionality for synchronizing form fields in the manner described above. However, in client-server environments, such as database applications implemented via the World Wide Web (“Web”), it can be very expensive in time and performance to synchronize dependent form fields in this way.

It is with respect to these and other considerations that the disclosure made herein is presented.

SUMMARY

Technologies are described herein for the synchronization of form fields in a client-server environment. Through an implementation of the concepts and technologies presented herein, database forms can be defined for use in a client-server environment that include one or more form fields that are dependent upon other form fields. Values shown by dependent form fields can be updated in an automated fashion in response to the modification of the fields upon which they depend. This can be accomplished utilizing the concepts and technologies presented herein in a client-server environment in a performant manner.

According to one aspect presented herein, functionality is disclosed for defining a database form usable in a client-server environment. Through the use of the design-time functionality disclosed herein, a form can be defined that includes a first user interface (“UI”) control configured to display a first value from a database. The form can also be defined to include a second UI control configured to display a second value from the database, the second value being dependent upon the first value. When a client renders the form, a modification to the first value by way of the first UI control will cause the second UI control to display an updated second value. In this manner, a value displayed by the second UI control is “synchronized” to the value displayed by the first UI control. This can occur without modifying the contents of the database.

According to another aspect, one or more user interfaces may also be provided for specifying at design-time whether the updated second value should be generated at a client tier, such as a Web browser application program, or at a server computer. An application tier, a database tier, or a combined application/database tier executing at the server computer may be utilized to generate the updated second value. Based upon information provided at design-time, the updated second value will be generated at either the client tier or at the server computer.

According to another aspect, a system is provided for synchronizing database form fields in a client-server environment. In one embodiment, the system includes a database tier, an application tier, and a client tier. The database tier is configured to maintain and provide access to a database. The application tier is configured to receive and respond to requests for a form, the form including data defining a first UI control for displaying a first value from the database and a second UI control for displaying a second value from the database that is dependent upon the first value. The application and database tiers may be combined into a single application/database tier.

The client tier is configured to render the form to show the first value in the first UI control and to show the second value in the second UI control. The client tier is further configured to detect a modification to the first value and to cause an updated second value to be generated in response to detecting the modification to the first value. The updated second value is displayed by way of the second UI control. As discussed above, the updated second value may be generated at the client tier, at the application tier, at the database tier, or at a combined application/database tier. The updated second value may also be generated without modifying the contents of the database.

In one embodiment, the client tier is further configured to remove the display of the second value following receiving the modification to the first value and prior to displaying the updated second value. In this manner, a user is not presented with stale information while the updated second value is being generated.

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 that this Summary be used to limit the scope of the claimed subject matter. Furthermore, the claimed subject matter is not limited to implementations that solve any or all disadvantages noted in any part of this disclosure.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a software architecture diagram showing one illustrative architecture presented herein for synchronizing form fields in a client-server environment;

FIG. 2 is a network and computer system architecture diagram showing an architecture utilized in one embodiment disclosed herein for synchronizing form fields in a client-server environment;

FIG. 3 is a flow diagram showing aspects of a method provided in one embodiment disclosed herein for creating a form having fields that can be synchronized in a client-server environment;

FIGS. 4A-4C are flow diagrams showing aspects of a method provided in one embodiment disclosed herein for run-time processing for providing synchronization of form fields in a client-server environment;

FIGS. 5A-5C are user interface diagrams showing the synchronization of several form fields in a client-server environment according to one embodiment disclosed herein; and

FIG. 6 is a computer architecture diagram showing an illustrative computer hardware and software architecture for a computing system capable of implementing the various embodiments presented herein.

DETAILED DESCRIPTION

The following detailed description is directed to technologies for synchronization of form fields in a client-server environment. As discussed briefly above, a database tier is disclosed herein that maintains and provides access to a database. An application tier is also provided that receives and responds to requests for a form. The form includes data defining a first UI control for displaying a first value from the database and a second UI control for displaying a second value from the database that is dependent upon the first value. A client tier is also disclosed that renders the form to show the first value in the first UI control and to show the second value in the second UI control. The client tier also detects a modification to the first value and causes an updated second value to be generated in response to detecting the modification to the first value. The updated second value is displayed by way of the second UI control. The updated second value is generated at the client tier, the application tier, the database tier, or at a combined application/database tier

While the subject matter described herein is presented in the general context of program modules that execute in conjunction with the execution of an operating system and application programs on a computer system, those skilled in the art will recognize that other implementations may be performed in combination with other types of program modules. Generally, program modules include routines, programs, components, data structures, and other types of structures that perform particular tasks or implement particular abstract data types. Moreover, those skilled in the art will appreciate that the subject matter described herein may be practiced with other computer system configurations, including hand-held devices, multiprocessor systems, microprocessor-based or programmable consumer electronics, minicomputers, mainframe computers, and the like.

In the following detailed description, references are made to the accompanying drawings that form a part hereof, and which are shown by way of illustration specific embodiments or examples. Referring now to the drawings, in which like numerals represent like elements through the several figures, aspects of a computing system and methodology for synchronizing form fields in a client-server environment will be described.

Turning now to FIG. 1, details will be provided regarding one embodiment presented herein for synchronization of form fields in a client-server environment. In particular, FIG. 1 is a software architecture diagram showing one illustrative architecture presented herein for synchronizing form fields in a client-server environment. As shown in FIG. 1, an illustrative architecture 100 for implementing the embodiments presented herein includes a client tier 102, an application tier 104, and a database tier 106. Each of these components will be described in detail below.

The database tier 106 illustrated in FIG. 1 represents one or more software components executing on a computer system that are configured to maintain and provide access to a database 116. In one implementation, the database 116 is a relational database. It should be appreciated, however, that other types of database technologies might be utilized.

The architecture 100 shown in FIG. 1 also includes an application tier 104. The application tier 104 is one or more software components executing on a computer system that are configured to receive and respond to requests for a form 108. For instance, as described in greater detail below, the application tier 104 might include a Web server component executing a Web application that is configured to provide forms, such as the form 108, in a client-server environment.

The form 108 is configured for use in a client-server environment and includes data defining a first UI control for displaying a first value from the database 116 and data defining a second UI control for displaying a second value from the database 116. The second value may be dependent upon the first value. The form 108 also includes display code 110 and form logic 112 in one embodiment.

The display code 110 is program code that may be rendered or executed on the client tier 102 and that is configured for receiving data values from the database 116 and displaying the data values. The form logic 112 is executable code configured to execute on the client tier 102 that manages interaction with the form 108 and that communicates with the application tier 104 and/or the database tier 106 to retrieve the values from the database 116 that are displayed by the form 108. Additional details regarding the functionality provided by the display code 110 and the form logic 112 will be provided below.

As also illustrated in FIG. 1, the architecture 100 includes a client tier 102 that is configured to render the form 108. In particular, a form display 118 is generated when the client tier 102 renders the form 108. For instance, the form display 118 may be displayed on a display screen connected to a computer executing a Web browser program capable of rendering the form 108. As described briefly above, the form 108 defines one or more UI controls 120A-120C (which may be referred to collectively as UI controls 120 or individually as UI control 120) that are displayed in the form display 118. As also discussed above, certain UI controls, such as the dependent UI control 120C, may be dependent upon values displayed by other UI controls. For instance, in the example shown in FIG. 1, the dependent control 120C may be configured to display a value from the database 116 that is dependent upon a value displayed by the UI controls 120A and/or 120B.

According to embodiments presented herein, the client tier 102 is further configured to detect a modification to a value generated by a UI control 120 and, in response to detecting such a modification, to cause an updated value to be displayed by any UI controls that are dependent upon the modified UI control. For instance, in the example shown in FIG. 1, if the dependent control 120C is dependent upon the UI control 120A, a modification to the value shown by the control 120A will cause an updated value to be generated and displayed by the dependent control 120C.

According to embodiments presented herein, the updated value displayed by the dependent control 120C may be generated at the client tier 102, the application tier 104, or the database tier 106. In another implementation, the application tier 104 and the database tier 106 are combined. In this embodiment, the updated value displayed by the dependent control 120C may be generated by the combined application/database tier. Additionally, as will be described in greater detail below, the updated value displayed by the dependent control 120C may be displayed by the client tier 102 without modifying the database 106.

As will also be described in greater detail below, a graphical user interface may be provided for use at the client tier 102 that allows a designer of the form 108 to specify whether updated values are generated at the client tier 102 or at a server computer, such as a server computer executing at the application tier 104, the database tier 106, or a combined application/database tier. This information is used at runtime (i.e. the time at which the form 108 is rendered by the client tier 102) to determine whether the updated value shown by a dependent UI control should be calculated at the client tier 102 or at a server computer executing the application tier 104 or the database tier 106. Additional details regarding one design time process for specifying the location at which updated values should be calculated will be provided below with respect to FIG. 3.

According to one implementation, the application tier 104 provides control dependency data 114 to the client tier 102. The control dependency data 114 is data that indicates when a UI control, such as the UI control 120C is dependent upon another UI control, such as UI controls 120A and/or 120B. As will be discussed in greater detail below, the client tier 102 utilizes the control dependency data 114 at the time a value displayed by a UI control 120 is modified to determine whether any other UI controls 120 depend upon the modified value. If, using the control dependency data 114, the client tier 102 determines that another UI control depends upon the modified value, the client tier 102 will cause an updated value to be generated for display by the dependent control. As discussed above, the updated value may be generated at the client tier 102, the application tier 104, the database tier 106, or a combined application/database tier. Additional details regarding this process will be provided below.

Referring now to FIG. 2, a network and computer system architecture diagram will be described that shows an architecture utilized in one embodiment disclosed herein for synchronizing form fields in a client-server environment. In the embodiment shown in FIG. 2, the client tier 102 is implemented at a client computer 202. In this example, the application tier 104 and database tier 106 are implemented at a server computer 204. It should be appreciated that while a single client computer 202 and a single server computer 204 have been illustrated in FIG. 2, many such computing systems might be utilized in other embodiments. Additionally, it should be appreciated that although the application tier 104 and database tier 106 are illustrated in FIG. 2 as being implemented at a single server computer 204, these components may be executed at multiple or different server computers 204. For instance, a server farm utilizing many such server computers 204 might be utilized to implement the application tier 104 and the database tier 106 in other embodiments.

As also shown in FIG. 2, the client computer 202 and the server computer 204 are interconnected by way of a data communications network 206. According to one implementation, the network 206 is the Internet. It should be appreciated, however, that other types of networks might be utilized, including local area networks, wide area networks, wireless networks, and others.

In the example shown in FIG. 2, the application tier 104 is implemented by a Web server component 210. The Web server component 210 is an executable software component configured for execution on the server computer 204 that, among other things, is configured to receive and respond to requests from a Web browser application 208 for the form 108. The Web server component 210 might also provide other functionality. For instance, the Web server component 210 may be implemented as Web application for providing for particular functionality. For instance, a Web application may be created for customer relationship management, performing accounting functions, and providing other types of functionality.

The Web server component 210 may utilize a database tier 106 that is implemented by a database component 214 in the example shown in FIG. 2. The database component 214 provides functionality for maintaining and providing access to the database 116. As discussed above, the database component 214 may be a software component configured to provide relational database services or another type of database component configured to provide access to another type of database. In one implementation, the database component 214 is configured to expose a database application programming interface (API) 212 for providing access to services provided by the database component 214. Details regarding the functionality provided by the database API 212 will be provided below.

In the example shown in FIG. 2, the client tier 102 is implemented by Web browser application 208. As known to those skilled in the art, a Web browser application 208 is an application configured to receive and render Web pages. In the example presented herein, the Web browser application 208 is also configured to request the form 108 from the Web server component 210, to receive the form 108, and to render the form to generate a form display 118. As discussed above, the form display 118 may be displayed on a display device connected to the client computer 202. In the example shown in FIG. 2, the form display 118 includes three UI controls 120A-120C. The UI control 120C is dependent upon one or more of the UI controls 120A-120B.

As also described briefly above, in order to render the form 108, the display code 110 is rendered and/or executed by the Web browser application 208. The display code 110 communicates with the server computer 204 to retrieve values from the database 116 that are displayed by the UI controls 120A-120C. The Web browser application 208 is also configured to execute the form logic 112. As discussed above, the form logic manages client-side interaction and communicates with the database API 212 to retrieve data from the database 116. Additional details regarding the operation of the display code 110 and the form logic 112 will be provided below.

As also described briefly above, the Web server component 210 is configured in one implementation to generate control dependency data 114 at the time the form 108 is provided to the Web browser application 208. The form logic 112 executing in the Web browser application 208 is configured to utilize the control dependency data 114 to determine whether an updated value for a dependent control 120C should be generated at the client computer 202 or at the server computer 204. Additional details regarding the process will be provided below.

As also discussed briefly above with respect to FIG. 1, the client computer 202 also provides functionality for allowing a designer of the form 108 to specify whether updated values for dependent UI controls 120C should be generated at the client computer 202 or at the server computer 204. In particular, according to one implementation, the client computer 202 is configured to execute a database client application 220.

In one embodiment, the database client application 220 is configured to provide a graphical user interface for defining the form 108. As part of the functionality provided by the graphical user interface, a user may be able to specify that an updated value for a dependent UI control 120C should be generated at the client computer 202 or at the server computer 204. In one embodiment, if the user specifies that an updated value for a dependent UI control 120C should be generated at the client computer 202, then a form designer user interface 222 is provided for allowing the user to specify the manner in which the updated value should be generated at the client computer 202. If the user specifies that an updated value for a dependent UI control 120C should be generated at the server computer 204, a query designer user interface 224 may be provided for allowing the user to specify the manner in which the updated value for the dependent UI control 120C should be generated at the server computer 204.

As discussed briefly above, when the Web browser application 202 detects a modification to one of the UI controls 120A-120C, the Web browser application 208 is configured to determine whether an updated value for dependent controls should be generated at the client computer 202 or the server computer 204. The Web browser application 208 is then configured to cause the updated value for the dependent control 120C to be generated in the appropriate location and to display the updated value in the dependent UI control 120C. Additional details regarding this process will be provided below.

According to one implementation, the form designer UI 222 may allow a user of the client computer 202 to specify a form expression to be utilized for computing the value displayed by a dependent UI control 120C at the Web browser application 208. The form expression may specify one or more operations to be performed on values retrieved from the database 116. The operations are executed at the Web browser application 208. For instance, a form expression may specify that two or more values retrieved from the database 116 should be concatenated and displayed in a dependent UI control 120C. Other types of operations may be defined in a similar manner. By specifying a form expression, a designer of the form 108 makes an implicit request that the value for a dependent UI control 120C utilizing the form expression be generated at the client computer 202.

According to implementations, a user of the client computer 202 may utilize the query designer UI 224 to specify that a value to be generated by dependent control 120C be generated at the server computer 204 in a number of different ways. For instance, a user of the query designer UI may define a calculated field for display by the dependent control 120C that is generated by an underlying query. For example, a query may be defined that is performed by the database component 214 that performs a concatenation operation on two or more values from the database 116. Another way in which a user of the query designer UI 224 may specify that the server computer 204 generate a value for dependent control 120C is through the use of calculated columns and base tables maintained by the database component 214. In this example, calculated columns containing values displayed by dependent control 120C are stored as part of a base table maintained by the database component 214.

Another mechanism that a user of the query designer UI 224 may utilize to specify that values displayed by dependent controls 120C are to be generated at the server computer 204 are join dependencies. As known to those skilled in the art, a join dependency exists in a query that joins two or more tables in a database 116. A user may also specify UI controls 120A-120C that display values from duplicate fields. For instance, a form 108 may be defined that has two fields on the form that utilize the same value from the database 116. If a user of the form 108 changes one of the values, then the other value should also change. By specifying duplicate fields in this manner, a user of the client computer 202 may implicitly request that the server computer 204 generate an updated value for the duplicate controls.

According to one implementation, the query designer UI 224 may also be utilized to specify UI controls 120A-120C on a form that include default values. For instance, a form 108 may be defined such that when a new row is created, default values are displayed in the UI controls 120A-120C. As an example, a form 108 may be defined for creating an order. When a user of the form 108 clicks a button for creating a new order, the form 108 is configured to show default values, such as a customer name, address, and other details, for the new order. In this example, the values for the controls 120C showing the default values are also generated at the server computer 204. It should be appreciated, therefore, that by specifying default values at design time a user of the client computer 202 may implicitly request that the default values be computed at the server computer 204. Additional details regarding the design time process for creating the form 108 will be provided below with respect to FIG. 3.

Turning now to FIG. 3, additional details will be provided regarding the embodiments presented herein for synchronizing form fields in a client-server environment. In particular, FIG. 3 shows a routine 300 that illustrates aspects of a method provided in one embodiment disclosed herein for creating a form 108 having fields that can be synchronized in a client-server environment.

It should be appreciated that the logical operations described herein with respect to FIG. 3 and the other FIGURES are implemented (1) as a sequence of computer implemented acts or program modules running on a computing system and/or (2) as interconnected machine logic circuits or circuit modules within the computing system. The implementation is a matter of choice dependent on the performance and other requirements of the computing system. Accordingly, the logical operations described herein are referred to variously as operations, structural devices, acts, or modules. These operations, structural devices, acts and modules may be implemented in software, in firmware, in special purpose digital logic, and any combination thereof. It should also be appreciated that more or fewer operations may be performed than shown in the figures and described herein. These operations may also be performed in a different order than those described herein.

The routine 300 begins at operation 302, where the client computer 202 executes the database client application 220. As discussed above, the database client application 220 is configured to provide a graphical user interface (“GUI”) for defining the form 108. It should be appreciated that other types of applications might also provide functionality for designing the form 108, including applications executing on the server computer 204. From operation 302, the routine 300 proceeds to operation 304.

At operation 304, the database client application 220 provides a GUI for defining the layout of the form 108. For instance, the databases client application 220 might provide a GUI for specifying the location of the UI controls 1210A-120C and other elements to be displayed on the form 108. From operation 304, the routine 300 proceeds to operation 306.



Download full PDF for full patent description/claims.

Advertise on FreshPatents.com - Rates & Info


You can also Monitor Keywords and Search for tracking patents relating to this Synchronization of form fields in a client-server environment patent application.
###
monitor keywords



Keyword Monitor How KEYWORD MONITOR works... a FREE service from FreshPatents
1. Sign up (takes 30 seconds). 2. Fill in the keywords to be monitored.
3. Each week you receive an email with patent applications related to your keywords.  
Start now! - Receive info on patent apps like Synchronization of form fields in a client-server environment or other areas of interest.
###


Previous Patent Application:
Method and apparatus for monitoring user interactions with selectable segments of a content package
Next Patent Application:
Content production
Industry Class:
Data processing: presentation processing of document
Thank you for viewing the Synchronization of form fields in a client-server environment patent info.
- - - Apple patents, Boeing patents, Google patents, IBM patents, Jabil patents, Coca Cola patents, Motorola patents

Results in 0.75027 seconds


Other interesting Freshpatents.com categories:
Nokia , SAP , Intel , NIKE ,

###

Data source: patent applications published in the public domain by the United States Patent and Trademark Office (USPTO). Information published here is for research/educational purposes only. FreshPatents is not affiliated with the USPTO, assignee companies, inventors, law firms or other assignees. Patent applications, documents and images may contain trademarks of the respective companies/authors. FreshPatents is not responsible for the accuracy, validity or otherwise contents of these public document patent application filings. When possible a complete PDF is provided, however, in some cases the presented document/images is an abstract or sampling of the full patent application for display purposes. FreshPatents.com Terms/Support
-g2-0.2586
     SHARE
  
           

FreshNews promo


stats Patent Info
Application #
US 20120102412 A1
Publish Date
04/26/2012
Document #
12910875
File Date
10/25/2010
USPTO Class
715747
Other USPTO Classes
International Class
/
Drawings
11



Follow us on Twitter
twitter icon@FreshPatents