Pre-Grant Publication Number: 20080301552
Please help the USPTO examine the application by evaluating the relevance of the publicly submitted prior art to the patent application.
Peer To Patent forwards the Top 10 most relevant prior art submissions and their annotations to the USPTO.
Review this prior art and click on the thumbs up (or down) to indicate whether this submission should be forwarded to the USPTO.
If you login then you can add an annotation by typing in the box at the bottom of the screen to comment on the relevance of the prior art to the claims of the patent application.
Review this prior art and click on the thumbs up (or down) to indicate whether this submission should be forwarded to the USPTO.
If you login then you can add an annotation by typing in the box at the bottom of the screen to comment on the relevance of the prior art to the claims of the patent application.

Prior Art Detail
Summary / Description
| Summary / Description | The patent relates to a Metadata which is defined to create customized user interface (UI) portions for an application. The metadata is created according to a metadata schema that defines mechanisms for data binding application data to the controls of the UI. The metadata may be XML-based and is interpreted and then rendered to implement a customized UI that also supports data binding between data and the UI controls. |
Basic Information
| Type of Prior Art | Issued Patents - US |
| Country | United States of America |
| Patent/Application # | US20070130205 |
| Kind Code | Union of Soviet Socialist... - Inventor's Certificate - A1 |
| Patentee Name | Dengler, Patrick M. (Redmond, WA, US) et. al. |
| Relevant Pages, Columns, or Lines | Mentioned in each section |
| URL | http://www.freepatentsonline.co... |
| Filing Date | May 5, 2006 |
| Additional Information | |
Notes / To Do
| Notes | XML based metadata for customized user interface for application |
Excerpt
Excerpt 1. A computer-readable medium having computer executable instructions for creating a metadata driven user interface, comprising: accessing metadata that is used in defining a user interface, wherein the metadata defines controls within the user interface and wherein the metadata supports binding data to one or more controls of the user interface; and rendering the user interface according to the metadata. (Claim 1)
For example, an application developer can write a metadata file that defines basic as well as custom UI controls, properties of the controls, layout of the controls, and the like. Once created, the metadata is processed by a rendering engine to display the UI controls. An interpreter may be used to interpret the metadata file before it sent to the rendering engine. Neither the rendering engine nor the interpreter needs knowledge of the host application and provides support for arbitrary metadata driven UI. The metadata schema may include mechanisms to create custom controls for the UI; programmatically modify the UI controls by providing access to a code-behind assembly as well as support event handling for the UI controls. (Para 0004)
|
Relevance
Claims
1
Relevance
1. A computer-readable medium having computer executable instructions for creating a metadata driven user interface, comprising: accessing metadata that is used in defining a user interface, wherein the metadata defines controls within the user interface and wherein the metadata supports binding data to one or more controls of the user interface; and rendering the user interface according to the metadata. (Claim 1)
For example, an application developer can write a metadata file that defines basic as well as custom UI controls, properties of the controls, layout of the controls, and the like. Once created, the metadata is processed by a rendering engine to display the UI controls. An interpreter may be used to interpret the metadata file before it sent to the rendering engine. Neither the rendering engine nor the interpreter needs knowledge of the host application and provides support for arbitrary metadata driven UI. The metadata schema may include mechanisms to create custom controls for the UI; programmatically modify the UI controls by providing access to a code-behind assembly as well as support event handling for the UI controls. (Para 0004)
1. A computer-readable medium having computer executable instructions for creating a metadata driven user interface, comprising: accessing metadata that is used in defining a user interface, wherein the metadata defines controls within the user interface and wherein the metadata supports binding data to one or more controls of the user interface; and rendering the user interface according to the metadata. (Claim 1)
For example, an application developer can write a metadata file that defines basic as well as custom UI controls, properties of the controls, layout of the controls, and the like. Once created, the metadata is processed by a rendering engine to display the UI controls. An interpreter may be used to interpret the metadata file before it sent to the rendering engine. Neither the rendering engine nor the interpreter needs knowledge of the host application and provides support for arbitrary metadata driven UI. The metadata schema may include mechanisms to create custom controls for the UI; programmatically modify the UI controls by providing access to a code-behind assembly as well as support event handling for the UI controls. (Para 0004)
Claim Chart
All
2
Relevance
FIG. 2 shows a user interface metadata system. As illustrated, system 200 includes metadata 210 , interpreter 220 , code-behind assembly 225 , rendering engine 230 that renders user interface 240 and back-end data source 250 . Initially, a developer, or some other user, specifies metadata 210 for a given UT Form. Generally, once the metadata has been created and specified, the interpreter 220 accesses the metadata and then passes the UI information to rendering engine 230 such that the UI 240 may be displayed to a user. Although interpreter 220 is illustrated separately from rendering engine 230 its functionality may be included within rendering engine 230 as illustrated by the dashed box surrounding the interpreter 220 and rendering engine 230 .
Metadata 210 allows the developer to specify a set of events 215 for each control 241 - 243 that are included on the user interface 240 . The metadata 210 allows the UI forms developer to specify the controls to be added to the UI; define custom events on these added controls (or add events to the existing controls); and define the event-handlers via code in a code-behind assembly 225 for these new custom events (or modify existing custom-handlers by overriding the default behavior). An Object Model (OM) is exposed that allows the developer to read/modify properties of the controls on the form such that the event-handlers are defined in the code behind assembly 225 . The name and location of the code-behind assembly 225 is captured as part of the metadata 210. (Para 0030, 0031)
FIG. 2 shows a user interface metadata system. As illustrated, system 200 includes metadata 210 , interpreter 220 , code-behind assembly 225 , rendering engine 230 that renders user interface 240 and back-end data source 250 . Initially, a developer, or some other user, specifies metadata 210 for a given UT Form. Generally, once the metadata has been created and specified, the interpreter 220 accesses the metadata and then passes the UI information to rendering engine 230 such that the UI 240 may be displayed to a user. Although interpreter 220 is illustrated separately from rendering engine 230 its functionality may be included within rendering engine 230 as illustrated by the dashed box surrounding the interpreter 220 and rendering engine 230 .
Metadata 210 allows the developer to specify a set of events 215 for each control 241 - 243 that are included on the user interface 240 . The metadata 210 allows the UI forms developer to specify the controls to be added to the UI; define custom events on these added controls (or add events to the existing controls); and define the event-handlers via code in a code-behind assembly 225 for these new custom events (or modify existing custom-handlers by overriding the default behavior). An Object Model (OM) is exposed that allows the developer to read/modify properties of the controls on the form such that the event-handlers are defined in the code behind assembly 225 . The name and location of the code-behind assembly 225 is captured as part of the metadata 210. (Para 0030, 0031)
Claim Chart
Some
3
Relevance
In the given patent application there is method for giving customized user interface based on application. The user interface is a combination of a predefined meta data and a customized metadata
The metadata is created according to a metadata schema that defines mechanisms for data binding application data to the controls of the UI. The metadata may be XML-based and is interpreted and then rendered to implement a customized UI that also supports data binding between data and the UI controls. For example, an application developer can write a metadata file that defines basic as well as custom UI controls, properties of the controls, layout of the controls, and the like. (Summary)
In the given patent application there is method for giving customized user interface based on application. The user interface is a combination of a predefined meta data and a customized metadata
The metadata is created according to a metadata schema that defines mechanisms for data binding application data to the controls of the UI. The metadata may be XML-based and is interpreted and then rendered to implement a customized UI that also supports data binding between data and the UI controls. For example, an application developer can write a metadata file that defines basic as well as custom UI controls, properties of the controls, layout of the controls, and the like. (Summary)
Claim Chart
Some
4
Relevance
It has customized schema for metadata corresponding to different user interfaces which are selectable by user:
As discussed briefly above, the rendering engine 230 also provides a generic framework for hosting custom built controls. According to one embodiment, the framework supports custom .NET winform controls. According to one embodiment, any custom controls derive from the class: ‘System.Windows.Forms.UserControl.’ Each custom control has a default contructor and also implements the ICustomControl interface and the ‘IBindable’ interface so that it can participate in data binding. The following is an exemplary ‘ICustomControl’ interface:
public interface ICustomControl (para 0055)
It has customized schema for metadata corresponding to different user interfaces which are selectable by user:
As discussed briefly above, the rendering engine 230 also provides a generic framework for hosting custom built controls. According to one embodiment, the framework supports custom .NET winform controls. According to one embodiment, any custom controls derive from the class: ‘System.Windows.Forms.UserControl.’ Each custom control has a default contructor and also implements the ICustomControl interface and the ‘IBindable’ interface so that it can participate in data binding. The following is an exemplary ‘ICustomControl’ interface:
public interface ICustomControl (para 0055)
Claim Chart
Some
5
Relevance
It has customized schema for metadata corresponding to different user interfaces which are selectable by user:
As discussed briefly above, the rendering engine 230 also provides a generic framework for hosting custom built controls. According to one embodiment, the framework supports custom .NET winform controls. According to one embodiment, any custom controls derive from the class: ‘System.Windows.Forms.UserControl.’ Each custom control has a default contructor and also implements the ICustomControl interface and the ‘IBindable’ interface so that it can participate in data binding. The following is an exemplary ‘ICustomControl’ interface:
public interface ICustomControl (para 0055)
It has customized schema for metadata corresponding to different user interfaces which are selectable by user:
As discussed briefly above, the rendering engine 230 also provides a generic framework for hosting custom built controls. According to one embodiment, the framework supports custom .NET winform controls. According to one embodiment, any custom controls derive from the class: ‘System.Windows.Forms.UserControl.’ Each custom control has a default contructor and also implements the ICustomControl interface and the ‘IBindable’ interface so that it can participate in data binding. The following is an exemplary ‘ICustomControl’ interface:
public interface ICustomControl (para 0055)
Claim Chart
Some
13
Relevance
1. A computer-readable medium having computer executable instructions for creating a metadata driven user interface, comprising: accessing metadata that is used in defining a user interface, wherein the metadata defines controls within the user interface and wherein the metadata supports binding data to one or more controls of the user interface; and rendering the user interface according to the metadata. (Claim 1)
For example, an application developer can write a metadata file that defines basic as well as custom UI controls, properties of the controls, layout of the controls, and the like. Once created, the metadata is processed by a rendering engine to display the UI controls. An interpreter may be used to interpret the metadata file before it sent to the rendering engine. Neither the rendering engine nor the interpreter needs knowledge of the host application and provides support for arbitrary metadata driven UI. The metadata schema may include mechanisms to create custom controls for the UI; programmatically modify the UI controls by providing access to a code-behind assembly as well as support event handling for the UI controls. (Para 0004)
1. A computer-readable medium having computer executable instructions for creating a metadata driven user interface, comprising: accessing metadata that is used in defining a user interface, wherein the metadata defines controls within the user interface and wherein the metadata supports binding data to one or more controls of the user interface; and rendering the user interface according to the metadata. (Claim 1)
For example, an application developer can write a metadata file that defines basic as well as custom UI controls, properties of the controls, layout of the controls, and the like. Once created, the metadata is processed by a rendering engine to display the UI controls. An interpreter may be used to interpret the metadata file before it sent to the rendering engine. Neither the rendering engine nor the interpreter needs knowledge of the host application and provides support for arbitrary metadata driven UI. The metadata schema may include mechanisms to create custom controls for the UI; programmatically modify the UI controls by providing access to a code-behind assembly as well as support event handling for the UI controls. (Para 0004)
Claim Chart
All
16
Relevance
1. A computer-readable medium having computer executable instructions for creating a metadata driven user interface, comprising: accessing metadata that is used in defining a user interface, wherein the metadata defines controls within the user interface and wherein the metadata supports binding data to one or more controls of the user interface; and rendering the user interface according to the metadata. (Claim 1)
For example, an application developer can write a metadata file that defines basic as well as custom UI controls, properties of the controls, layout of the controls, and the like. Once created, the metadata is processed by a rendering engine to display the UI controls. An interpreter may be used to interpret the metadata file before it sent to the rendering engine. Neither the rendering engine nor the interpreter needs knowledge of the host application and provides support for arbitrary metadata driven UI. The metadata schema may include mechanisms to create custom controls for the UI; programmatically modify the UI controls by providing access to a code-behind assembly as well as support event handling for the UI controls. (Para 0004)
1. A computer-readable medium having computer executable instructions for creating a metadata driven user interface, comprising: accessing metadata that is used in defining a user interface, wherein the metadata defines controls within the user interface and wherein the metadata supports binding data to one or more controls of the user interface; and rendering the user interface according to the metadata. (Claim 1)
For example, an application developer can write a metadata file that defines basic as well as custom UI controls, properties of the controls, layout of the controls, and the like. Once created, the metadata is processed by a rendering engine to display the UI controls. An interpreter may be used to interpret the metadata file before it sent to the rendering engine. Neither the rendering engine nor the interpreter needs knowledge of the host application and provides support for arbitrary metadata driven UI. The metadata schema may include mechanisms to create custom controls for the UI; programmatically modify the UI controls by providing access to a code-behind assembly as well as support event handling for the UI controls. (Para 0004)
Claim Chart
All
0 days left








