Abstract:
The present invention is directed to the use of custom templates to generate user interface screens in computer systems. In embodiments of the present invention, a data structure for supporting user interfaces may include a base template created by a developer for particular display devices and a delta file defining changes to the base templates manifested when the user interface screen is generated. Exemplary applications include small display devices having display, memory, and processing power limitations

Description:
FIELD OF INVENTION  
       [0001]     This invention is in the area of computer user interface screens and, more particularly, user interface screen generation from custom templates.  
       BACKGROUND OF THE INVENTION  
       [0002]     Developers generally create computer user interface screens from either pre-defined templates, known as “patterns,” or from freestyle development (from scratch). Generally, pre-defined templates are created and supplied by an application software vendor. When using these pre-defined templates, a developer typically selects a template, pre-defined to perform a particular function, that the developer wants to use as a user interface screen. The benefit of pre-defined templates is that they provide screen consistency across applications. Also, the developer is able to design user interface screens quickly and easily. But the disadvantage is that the developer has little flexibility in tailoring the user interface screen to the application and/or display device that uses the user interface screen. This limitation is particularly troublesome for small display devices that have display size, memory, and processing power constraints. That is, the pre-defined templates may be spatially oversized or have configurations that are too complex for the small display device&#39;s memory and/or processing power. Further, for the small display devices, screen sizes differ among different products, which makes it difficult to design a small set of templates having broad application.  
         [0003]     In contrast, freestyle development provides maximum flexibility to the developer to create user interface screens specifically tailored for the display device. When creating user interface screens from scratch, the developer typically designs all the controls, layout, attributes, colors, fonts, etc., for the user interface screens. This avoids the problem of pre-defined templates in small display devices. However, the disadvantage is that freestyle development is much slower and more labor-intensive for the developer. Also, screen consistency between applications is lost. Since the freestyle-developed screens are designed for particular devices and/or applications, they are typically not reusable between devices and applications.  
         [0004]     During runtime, pre-defined templates have additional advantages. They generally display quickly because the parameters used to generate a display based on the templates are static and pre-defined. As such, the application need only retrieve and apply the parameters&#39; values to generate the user interface screen.  
         [0005]     In contrast, for freestyle development, the user interface screens created from scratch are typically not saved as templates. As such, during runtime, the application must create the user interface screen controls, as designed by the developer, and initialize the controls as the user interface screen is displayed. Hence, screens built from scratch generally display slowly. This means that the application must perform complex calculations, make numerous memory searches, etc., to display screens created from scratch.  
         [0006]     There is a need in the art for computer user interface screen development that combines the benefits of pre-defined templates and freestyle development without their respective disadvantages. 
     
    
     BRIEF DESCRIPTION OF DRAWINGS  
       [0007]      FIG. 1  illustrates systems for which custom templates may be used according to embodiments of the present invention.  
         [0008]      FIG. 2  is a block diagram of an example architecture for displaying user interface screens according to an embodiment of the present invention.  
         [0009]      FIG. 3  is a flowchart of a runtime method for displaying user interface screens according to an embodiment of the present invention.  
         [0010]      FIG. 4  is a block diagram of an example architecture for creating custom templates upon which user interface screens are based, according to an embodiment of the present invention.  
         [0011]      FIG. 5  is a flowchart of a design method for creating custom templates upon which user interface screens are based, according to an embodiment of the present invention.  
     
    
     DETAILED DESCRIPTION  
       [0012]     This invention is drawn to custom templates. Custom templates may be created from base templates that are customized with delta files for a particular display device and/or application. Base templates may be definitions of elements of computer user interface screens, e.g., screen controls, fonts, colors, layout, etc., used by applications to generate user interface screens. The base templates may be created for either a generic or specific display device and/or application. Delta files may include customized modifications to the definitions in the base templates. The delta files and the base templates together may form custom templates. These custom templates then may be used at runtime to generate user interface screens.  
         [0013]     Custom templates may be particularly suited for use in small display devices, such as personal digital assistants (PDAs), tablet computers, laptops, smart phones, and portable terminals. Compared to desktop computers, these small display devices are more limited in screen size, memory capacity, and processing power. Therefore, pre-defined templates used in screen development for desktop computers generally are not portable to small display devices. Custom templates allow the developer to design templates to meet the requirements of these small display devices, store these templates, and then reuse them in screen development. As such, the developer need not create user interface screens from scratch every time. Instead, the developer may use a custom template that is created from a base template and modified to further customize, as needed, for a particular device and/or application.  
         [0014]     In embodiments of the present invention, developers may create base templates from scratch, as in freestyle development, and then use them multiple times with different delta files to create custom templates that are then used to generate user interface screens, just as pre-defined templates do. Hence, custom templates provide the advantages of both pre-defined templates and freestyle development without their respective disadvantages.  
         [0015]     Alternatively, developers may select an existing base template, add definitions to the template, and then save as a new base template.  
         [0016]      FIG. 1  illustrates systems for which custom templates may be used according to embodiments of the present invention. In this system, a developer may use a design tool on design computer  110  to design and store base templates and to design and separately store delta files for the base templates. The developer may then link the delta files to their respective underlying base templates. After completing the base templates and delta files, the developer may transmit them to the appropriate small display devices  1 ,  2 , . . . ,  n . The small display devices may then use them during runtime to generate user interface screens.  
         [0017]     The design computer may be any type of computer capable of performing the design tool operations according to embodiments of the present invention. The transmission media may be any type capable of sending and receiving data between the design tool and the small display devices according to embodiments of the present invention.  
         [0018]      FIG. 2  is a block diagram of an example architecture for displaying user interface screens according to an embodiment of the present invention. This architecture, which may be resident in the small display device that is to display user interface screens, may include application  210 , delta files  220 - 1 , . . . ,  220 - n , and base templates  230 - 1 ,  230 - 2 . Base templates  230  may be created using the design tool. A base template may include definitions of elements of a user interface screen for the device and element default values. Examples of screen elements include the controls to be used, the screen layout, the screen properties, e.g., fonts, colors, etc., and the data binding information.  
         [0019]     Controls are objects on the screen that can be manipulated by the user to enter commands to the device. Typical controls include buttons, scroll bars, pull-down menus, etc. Data binding information provides the bounds of the controls, such as the routines that are called to perform the user-selected actions when the user manipulates the controls, the type of editor through which the user manipulates the controls, e.g., a text editor, an input field, a radio button, etc., and the data type of the controls&#39; values, e.g., text, value, selectKey, etc.  
         [0020]     It is to be understood that screen elements are not limited to those described here, but may include any elements capable of being used in user interface screens.  
         [0021]     Delta files  220  of  FIG. 2  may also be created using the design tool. A delta file may include modifications to base templates  230  for the particular device and/or application. A delta file  220  may include modifications to the definitions and values of the elements defined in an underlying base template  230 . The delta file may also include a pointer to the base template. Optionally, the delta file may include additional elements not defined in the base template. These additional elements may be treated as freestyle development during runtime, such that the application may retrieve the template-defined elements and then create and initialize the additional elements.  
         [0022]     Several delta files  220  may have pointers to the same base template  230 . For example, in  FIG. 2 , delta files  220 - 1  and  220 - 3  have pointers to base template  230 - 1 . As such, a custom template may be created from delta file  220 - 1  making changes to base template  230 - 1 . A different custom template may created from delta file  220 - 3  making different changes to base template  230 - 1 .  
         [0023]     To display a user interface screen based on the delta file and base template, the application may retrieve the delta file, which points to the base template, and then retrieve the base template.  
         [0024]     This architecture advantageously conserves memory on the small display device by providing multiple delta files for a common base template that generate multiple user interface screens.  
         [0025]      FIG. 3  is a flowchart of a runtime method for displaying user interface screens according to an embodiment of the present invention. During application runtime, the application may request the creation of a user interface screen ( 305 ). The application may determine whether the screen is to be created from a base template ( 310 ). If so, the application may perform as follows.  
         [0026]     The application may retrieve the desired user interface screen&#39;s delta file from memory and read the delta file pointer to determine the underlying base template. The application may then retrieve the base template ( 325 ). The application may modify the elements of the base template with the delta file ( 335 ). The application may then display the modified base template, i.e., the custom template, as a user interface screen ( 345 ). The application may place the retrieved base template into cache memory for later quick retrieval.  
         [0027]      FIG. 4  is a block diagram of an example architecture for creating custom templates upon which user interface screens are based, according to an embodiment of the present invention. This architecture, which may be resident in design computer  110  that creates the base templates and delta files, may include design tool  410 , delta files  420 - 1 , . . . ,  420 - n , and base templates  430 - 1 , . . . ,  430 - m . Design tool  410  may create the base templates from scratch and then store them in memory. Alternatively, design tool  410  may create new base templates from existing base templates. Design tool  410  may also create delta files  420  based on a base template  430 , create a pointer to the underlying base template  430 , and store the delta file  420  in memory. One or more delta files  420  may point to the same base template  430 .  
         [0028]     Upon completion of a delta file and base template, the design application may transmit them to the appropriate small display devices to be used there to generate user interface screens.  
         [0029]      FIG. 5  is a flowchart of a design method for creating custom templates upon which user interface screens are based, according to an embodiment of the present invention.  
         [0030]     The design tool may receive the developer&#39;s inputs to create and store a base template in memory ( 505 ). The inputs may include all the controls to be used, the screen layout, the screen properties such as font, colors, etc, and the data binding information. The base template may be stored under a name supplied by the developer so that the template can be readily identified for use.  
         [0031]     The design tool may then receive an input from the developer about whether the developer wants to use the stored base template to create user interface screens ( 510 ). If not, the design tool may then receive an input from the developer about whether the developer wants to create and store another base template ( 515 ). If so, the design tool repeats the create and store operation ( 505 ). Otherwise, the design tool exits.  
         [0032]     To create user interface screens from a stored base template, the design tool may display a list or table of the stored templates from which the developer may select ( 520 ). After receiving the developer&#39;s template selection, the design tool may then receive an input from the developer about whether the developer wants the user interface screen to be a modified version of the selected base template ( 525 ). If not, the design tool may exit.  
         [0033]     If the developer wants the user interface screen to be a modified version of the base template, the design tool may receive the developer&#39;s inputs that include changes to the elements and values defined in the base template and store the changes in a delta file ( 530 ). Optionally, the developer&#39;s inputs may include definitions of new elements not in the base template to be stored in the delta file. The design tool may then create a pointer from the delta file to the base template and store the delta file in memory ( 535 ).  
         [0034]     This method may be repeated for as many times as needed to use custom templates comprising base templates and delta files for user interface screens.  
         [0035]     Embodiments of the present invention may be implemented using any type of computer, such as a general-purpose microprocessor, programmed according to the teachings of the embodiments. The embodiments of the present invention thus also includes a machine readable medium, which may include instructions used to program a processor to perform a method according to the embodiments of the present invention. This medium may include, but is not limited to, any type of disk including floppy disk, optical disk, and CD-ROMs.  
         [0036]     It may be understood that the structure of the software used to implement the embodiments of the invention may take any desired form, such as a single or multiple programs. It may be further understood that the method of an embodiment of the present invention may be implemented by software, hardware, or a combination thereof.  
         [0037]     The above is a detailed discussion of the preferred embodiments of the invention. The full scope of the invention to which applicants are entitled is defined by the claims hereinafter. It is intended that the scope of the claims may cover other embodiments than those described above and their equivalents.