Patent Publication Number: US-6034701-A

Title: Method and system for displaying mixed sized fonts for character based displays

Description:
TECHNICAL FIELD OF THE INVENTION 
     This invention relates generally to the display of characters on a computer display and more particularly to a method and system for displaying mixed sized fonts for character based displays. 
     BACKGROUND OF THE INVENTION 
     Hand-held computers are used for a variety of purposes. For example, a hand-held computer may be used to determine and display a voltage in a similar manner to a volt meter, or it may be used to execute computer software. An example of a hand-held computer is a SYMBOL® Series 3000 personal data terminal. Many hand-held computers, as well as less portable computers, such as desktop personal computers, utilize a character based display. In a character based display, the display often includes a number of cells for displaying a representation of a character. Each cell is used to display a representation of a single character, such as an alphanumeric character. Such a cell may include a plurality of pixels which may be arranged in a plurality of columns and rows. However, most character based displays cannot display representations of arbitrary lines or curves. 
     Computing systems utilizing character based displays, such as hand-held computers, provide limited display capability. For example, in one implementation, it has been determined that representations of characters on a character based display can take on only one size concurrently. Such a limitation can be detrimental. For example, the user of a hand-held computer may wish to display a voltage associated with an electric voltage being measured in a larger size than associated data in other parts of the screen. Without the ability to display text concurrently in more than one size, either data that would otherwise be displayed must be omitted to allow display space for larger size representation of characters, or characters must sometimes be displayed in a size that is less than optimal for particular applications. 
     SUMMARY OF THE INVENTION 
     From the foregoing it may be appreciated that a need has arisen for a system and method for displaying characters having a mixed size font in a character based display. In accordance with the present invention, a system and method is provided that addresses the disadvantages and problems outlined above. 
     According to one embodiment of the present invention, a method for displaying a representation of a character on a computer display includes receiving a first primary character string. The first primary character string includes at least one character selected from a primary character set. The method also includes receiving a first desired location for displaying a representation of the first primary character string. The method also includes generating a plurality of intermediate character strings corresponding to the first primary character string. The intermediate character strings include at least one intermediate character selected from a predefined intermediate character set. The predefined intermediate character set is defined before receiving the first primary character string and includes a plurality of intermediate characters each corresponding to a fractional portion of a primary character in the primary character set. The method also includes displaying representations of the plurality of intermediate character strings on the computer display in locations sufficient to display the representation of the primary character string at the first desired location. 
     According to another embodiment of the present invention, a computerized system for displaying mixed sized fonts includes a storage medium, a processor coupled to the storage medium, a display coupled to the processor, and a computer program stored in the storage medium. The computer program is operable to run on the processor and is also operable to perform a series of steps associated with displaying representations of characters on the display. For example, the computer program is operable to receive a primary character string including at least one character selected from a primary character set and receive a desired location for displaying a representation of the primary character string. The computer program is also operable to form a plurality of intermediate character strings corresponding to the primary character string. Each intermediate character string includes a plurality of intermediate characters selected from an intermediate character set. The intermediate character set includes characters corresponding to a fractional portion of the primary characters in the primary character set. The computer program is also operable to display representations of the plurality of intermediate character strings on the computer display in locations sufficient to display the representation of the primary character string at the desired location. 
     The present invention provides numerous technical advantages. For example, the present invention allows a display of different size representations of characters on a character based display concurrently. Such a system allows the display of more important, or more immediate, data in a larger size while still allowing concurrent display of ancillary information in smaller size text. This concurrent display of mixed sized fonts allows the display of more information on a limited size screen without losing emphasis of more important data and does not require expensive graphics based displays. Other technical advantages are readily apparent to one skilled in the art from the following figures, descriptions, and claims. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     For a more complete understanding of the present invention and the advantages thereof, reference is now made to the following brief description, taken in connection with the accompanying drawings and detailed description, wherein like reference numerals represent like parts, in which: 
     FIG. 1A is an isometric drawing of a computer system, according to the teachings of the present invention; 
     FIG. 1B is a block diagram of the computer system illustrated in FIG. 1A, showing functional blocks of the computer system; 
     FIG. 2 is an illustration of a computer display of the computer system illustrated in FIGS. 1A and 1B, showing the representation of characters utilizing mixed sized fonts, according to the teachings of the present invention; 
     FIG. 3 is an illustration of the representation of the letter &#34;E&#34; shown in FIG. 2, showing the division of the representation of the &#34;E&#34; into four components; 
     FIG. 4 illustrates the alphanumeric characters 0 through 8 and four intermediate characters for each alphanumeric character 0 through 8, which form a part of a primary character set and an intermediate character set, respectively, according to the teachings of the present invention; 
     FIG. 5 illustrates the alphanumeric characters 9 and A through H and four intermediate characters for each alphanumeric character 9 and A through H, which form a part of a primary character set and an intermediate character set, respectively, according to the teachings of the present invention; 
     FIG. 6 illustrates the alphanumeric characters I through Q and the formation of four intermediate characters for each alphanumeric character I through Q, which form a part of a primary character set and an intermediate character set, respectively, according to the teachings of the present invention; 
     FIG. 7 illustrates the alphanumeric characters R through Z and four intermediate characters for each alphanumeric character R through Z, which form a part of a primary character set and an intermediate character set, respectively, according to the teachings of the present invention; 
     FIG. 8 is an illustration of a number of common punctuation characters and the formation of four intermediate characters corresponding to each punctuation character, which form a part of a primary character set and an intermediate character set, respectively, according to the teachings of the present invention; 
     FIG. 9A is a flowchart showing exemplary steps associated with representing a character string, according to the teachings of the present invention; and 
     FIG. 9B is associated with FIG. 9A and illustrates a representation of a character string &#34;EDS&#34; according to the exemplary steps shown in FIG. 9A. 
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     Embodiments of the present invention and their advantages are best understood by referring to FIGS. 1 through 9B of the drawings, like numerals being used for like and corresponding parts of the various drawings. 
     FIG. 1A is an isometric drawing of a computer system 10. Computer system 10 includes a display 12 for displaying representations of characters. In the embodiment illustrated in FIG. 1A, display 12 is a character based display. In a character based display, the display utilizes a number of cells, with each cell conventionally used to display a single character. Computer system 10 also includes an input device 14 for providing information to computer system 10. In the embodiment illustrated in FIG. 1A, input device 14 comprises a keyboard having a plurality of keys associated with alphanumeric characters. Computer system 10 may utilize standard DOS programming tools, including C and C++ compilers; however, other operating systems and programming tools may be incorporated without departing from the scope of the present invention. One example of a computer system appropriate for use with the present invention is a SYMBOL® Series 3000 portable data terminal. A SYMBOL® Series 3000 portable data terminal is described in Series 3000 Programming Implementation Manual, which is incorporated herein by reference. 
     Display 12 of computer system 10 includes an eight by twenty cell character display for displaying representations of characters; however, other suitable displays may be utilized. Computer system 10 also includes a memory system for storing data and computer software and a processor for manipulating data and executing computer software (not explicitly shown in FIG. 1A). A memory system, associated programming, and a processor associated with computer system 10 is described in greater detail below in conjunction with FIG. 1B. According to the invention, computer system 10 may display mixed sized representations of characters on display 12, as discussed in greater detail below. The ability to display mixed sized representations of characters allows the display of more important data in a more conspicuous manner than less important ancillary data, but it also allows the concurrent display of both types of data. 
     FIG. 1B is a block diagram of computer system 10, according to the teachings of the present invention, showing functional blocks of computer system 10. As illustrated, computer system 10 includes a memory system 16 for storing data and programming. A processor 18 is coupled to display 12, input device 14, and memory system 16. Processor 18 may receive information from a user of computer system 10 through input device 14 and may execute display of information to a user through display 12. Furthermore, processor 18 may execute programming stored in memory system 16, such as mixed font programming 20. Processor 18 may include any suitable processor for use with a computing system. Memory system 16 may include both random access memory, read-only memory, and other suitable types of memory. Mixed font programming 20, in cooperation with the remainder of computer system 10 allows the display of mixed size representations of characters on display 12. In the embodiment of the invention illustrated in FIG. 1B, mixed font programming 20 includes a header, or definitions file 19, and a character display routine 21. As described in greater detail below, definitions file 19 associates a plurality of characters with more easily recognizable variable names to facilitate display of mixed sized fonts, and character display routine 21 displays representations of characters on display 12 by, in one embodiment, combining a plurality of intermediate characters. Memory system 16 also includes character sets 23, which may be stored in mixed font programming 20 or other suitable locations in memory system 16. Character sets 23 provide characters for computer system 10 that may be displayed on display 12. Mixed font programming 20 is described in greater detail below. 
     FIG. 2 is an illustration of computer display 12 showing the representation of characters utilizing mixed sized fonts, according to the teachings of the present invention. As illustrated, display 12 includes a plurality of rows 22 and a plurality of columns 24 of cells 26. According to one embodiment of the invention, display 12 comprises eight rows 22 and twenty columns 24 of cells 26. Cell 26 includes a fixed number of pixels 28, as illustrated in FIG. 3. In the embodiment illustrated in FIG. 3, each cell 26 comprises 48 pixels 28 configured in eight rows 22 and six columns 24; however, other suitable configurations and numbers of pixels 28 may be utilized without departing from the scope of the present invention. 
     Each cell 26 may display a representation of one character by illuminating appropriate pixels 28 to create a pattern within a cell 26 corresponding to a representation of a particular character. A location for displaying the representation of a character or a character string may be identified by the row 22 and the column 24 at which the character or character string is to begin. Alternative locating systems may also be used, including providing the row 22 and column 24 corresponding to the center of the location at which a character string is to be displayed. 
     As illustrated in FIG. 2, a representation 32 of a character string &#34;Mixed&#34; is displayed in a location denoted by a reference numeral 30. Representation 32 of the character string &#34;mixed&#34; comprises a plurality of representations 34 of primary characters, such as primary characters &#34;m,&#34; &#34;i,&#34; &#34;x,&#34; &#34;e,&#34; and &#34;d&#34;. Primary characters 34 represent characters or numbers associated with a standard character set. Representation 32 of the character string &#34;mixed&#34; is displayed in a small font size. In this embodiment, a small font size corresponds to a font size that requires one cell for display of each primary character. 
     FIG. 2 also displays representations of character strings in a large font size. For example, representation 36 of the character string &#34;MIXED&#34; is displayed in a large font size. In this embodiment, a large font size corresponds to a font size that requires four cells to display each primary character. Representation 36 of the character string &#34;MIXED&#34; in a large font size includes a plurality of representations 38 of intermediate characters. According to the invention, representations 38 of intermediate characters correspond to a representation of a fractional portion of a primary character. In the example illustrated in FIG. 2, representations 38 of intermediate characters each represent one-quarter of a primary character. For example, a representation 50 of the primary character &#34;E&#34; includes representation of four intermediate characters corresponding to the quarter sections of the primary character &#34;E&#34;. Representation 50 of the primary character &#34;E&#34; corresponds to a large font size and is described in greater detail below in conjunction with FIG. 3. 
     According to the invention a single character string may be represented concurrently in both large and small font sizes by combining a plurality of representations of character strings of different sizes. For example, representation 40 of the character string &#34;WOW!&#34; includes a representation of a plurality of character strings 42, 44, 46, and 48. Representations 42 and 46 of the &#34;w&#34; and owe character strings each include representation 34 of the primary character &#34;w&#34;. Representations 44 and 48 of the character strings each include four representations 38 of intermediate characters. The representations 38 of intermediate characters that are used to form representation 44 of the primary character &#34;O&#34; each correspond to a quarter portion of the primary character &#34;O&#34;. The representations 38 that are used to form representation 48 of the primary character &#34;!&#34; correspond to quarter portions of the primary character &#34;!.&#34; Representations 42 and 46 each include representations of the primary character &#34;w&#34; in only one cell, and representations 44 and 48 each include representations of the primary characters &#34;O&#34; and &#34;!&#34;, respectively, in four cells. Thus, representations 42 and 46 correspond to characters, and character strings, displayed in a small font, and representations 44 and 48 correspond to characters, and character strings, displayed in a large font. Therefore, by combining representatives 42, 44, 46, and 48, a single representation 40 of a character string having different sized fonts may be effected. 
     According to the invention, a plurality of representations 38 of intermediate characters are displayed in locations to effect a representation of a character in a large font. In addition, on the same display 12, a plurality of representations 34 of characters in a small font are displayed in locations to produce a character string, such as character string 32, having a small font. Thus, by displaying representations of intermediate characteristics that correspond to fractional portions of primary characters, representations of character strings may be displayed in both large and small font sizes concurrently. One method for forming an intermediate character and displaying a plurality of intermediate characters in a way to represent a primary character is described below in conjunction with FIGS. 3 through 9B. 
     FIG. 3 is an illustration of representation 50 of the letter &#34;E&#34; shown in FIG. 2, showing the division of representation 50 of the letter &#34;E&#34; into four components. As shown in FIG. 3, representation 50 includes a representation 52 corresponding to an intermediate character corresponding to a top left portion of the primary character &#34;E,&#34; a representation 54 corresponding to an intermediate character corresponding to a top right portion of &#34;E,&#34; a representation 56 corresponding to an intermediate character corresponding to a bottom left portion of &#34;E,&#34; and a representation 58 corresponding to an intermediate character corresponding to a bottom right portion of &#34;E.&#34; By locating representations 52, 54, 56, and 58 together in the manner illustrated in FIG. 3, representation 50 of a primary character &#34;E&#34; may be displayed on display 12 in a large font. 
     As shown, each intermediate character is displayed in one cell 26 of display 12 with each cell 26 having a plurality of pixels 28. In the embodiment illustrated in FIG. 3, each cell 26 contains eight rows 22 and six columns 24 of pixels 28; however, other numbers of pixels and configurations of pixels may be used. 
     In the illustrated embodiment, the primary character &#34;E&#34; is represented by four representations 52, 54, 56, and 58 of intermediate characters corresponding to fractional portions of the primary character &#34;E.&#34; However, other suitable numbers of intermediate characters may be used to represent a primary character in a font size that is greater than one cell. For example, nine intermediate characters may be arranged in a configuration of three rows 22 and three columns 24 to display an even larger representation of the letter &#34;E.&#34; As described above, the embodiment illustrated in FIG. 2 requires four cells to represent a character in a large font. Each character of an alphabet may be represented in such a manner by a plurality of intermediate characters arranged to form a primary character. 
     FIGS. 4 through 8 illustrate an example primary character set 60 including primary characters 62 corresponding to the numbers 0 through 9 and the letters &#34;A&#34; through &#34;Z.&#34; FIGS. 4 through 8 also illustrate an example intermediate character set 64 including intermediate characters 66 corresponding to the primary character set 60 illustrated in FIGS. 4 through 8. Intermediate character set 64 includes four intermediate characters 66 for each primary character 62 in the primary character set 60. It should be appreciated that FIGS. 2, 3, and 9B illustrate example representations of the actual characters illustrated in FIGS. 4 through 8, and FIGS. 4 through 8 illustrate the actual characters of primary character set 60 and intermediate character set 64. 
     Intermediate characters such as intermediate characters 66 may be formed by determining the appropriate pixels 28 within a cell that must be illuminated to represent the intermediate character. One example of the creation of such a font is described in Chapter 4 &#34;Font Build&#34; of Series 3000 Programming Implementation Manual. 
     To facilitate use of intermediate characters 66 to form primary characters 62, intermediate character 66 may be assigned to replace infrequently used characters in an ASCII character set. This assignment is achieved by assigning the ASCII code for infrequently used ASCII characters to intermediate characters 66. The assignment of ASCII code intermediate characters 66 is described below with reference to Table 1. 
     The below Table 1 illustrates a standard ASCII character set. 
     
                       TABLE 1                                                     
______________________________________                                    
ASCII CHARACTER SET                                                       
Ctrl    Dec         Hex      Char    Code                                 
______________________________________                                    
 @      0           00               NUL                                  
 A      1           01               SOH                                  
 B      2           02               STX                                  
 C      3           03       ♡ ETX                                  
 D      4           04       ♦                              
                                     EOT                                  
 E      5           05               ENQ                                  
 F      6           06               ACK                                  
 G      7           07       ♦                              
                                     BEL                                  
 H      8           08               BS                                   
 I      9           09               HT                                   
 J      10          0A               LF                                   
 K      11          0B       ♂  VT                                   
 L      12          0C       ♀                                     
                                     FF                                   
 M      13          0D               CR                                   
 N      14          0E               SO                                   
 O      15          0F                                    
                                     SI                                   
 P      16          10               DLE                                  
 Q      17          11               DC1                                  
 R      18          12               DC2                                  
 S      19          13       !!      DC3                                  
 T      20          14       ¶                                  
                                     DC4                                  
 U      21          15       §  NAK                                  
 V      22          16       ▪                                  
                                     SYN                                  
 W      23          17               ETB                                  
 X      24          18       ↑ CAN                                  
 Y      25          19       ↓                                     
                                     EM                                   
 Z      26          1A       →                                     
                                     SUB                                  
 [      27          1B       ←  ESC                                  
 \                                                              
        28          1C               FS                                   
 ]      29          1D               GS                                   
        30          1E       ▴                             
                                     RS                                   
 .sub.--                                                                  
        31          1F       ▾                             
                                     US                                   
        32          20                                                    
        33          21       !                                            
        34          22       &#34;                                            
        35          23       #                                            
        36          24       $                                            
        37          25       %                                            
        38          26       &amp;                                            
        39          27       &#39;                                            
        40          28       (                                            
        41          29       )                                            
        42          2A       *                                            
        43          2B       +                                            
        44          2C       ,                                            
        45          2D       --                                           
        46          2E       &#39;                                            
        47          2F       /                                            
        48          30       0                                            
        49          31       1                                            
        50          32       2                                            
        51          33       3                                            
        52          34       4                                            
        53          35       5                                            
        54          36       6                                            
        55          37       7                                            
        56          38       8                                            
        57          39       9                                            
        58          3A       :                                            
        59          3B       ;                                            
        60          3C       &lt;                                            
        61          3D       =                                            
        62          3E       &gt;                                            
        63          3F       ?                                            
        64          40       @                                            
        65          41       A                                            
        66          42       B                                            
        67          43       C                                            
        68          44       D                                            
        69          45       E                                            
        70          46       F                                            
        71          47       G                                            
        72          48       H                                            
        73          49       I                                            
        74          4A       J                                            
        75          4B       K                                            
        76          4C       L                                            
        77          4D       M                                            
        78          4E       N                                            
        79          4F       O                                            
        80          50       P                                            
        81          51       Q                                            
        82          52       R                                            
        83          53       S                                            
        84          54       T                                            
        85          55       U                                            
        86          56       V                                            
        87          57       W                                            
        88          58       X                                            
        89          59       Y                                            
        90          5A       Z                                            
        91          5B       [                                            
        92          5C       \                                  
        93          5D       ]                                            
        94          5E                                                    
        95          5F       .sub.--                                      
        96          60       &#39;                                            
        97          61       a                                            
        98          62       b                                            
        99          63       c                                            
        100         64       d                                            
        101         65       e                                            
        102         66       f                                            
        103         67       g                                            
        104         68       h                                            
        105         69       i                                            
        106         6A       j                                            
        107         6B       k                                            
        108         6C       l                                            
        109         6D       m                                            
        110         6E       n                                            
        111         6F       o                                            
        112         70       p                                            
        113         71       q                                            
        114         72       r                                            
        115         73       s                                            
        116         74       t                                            
        117         75       u                                            
        118         76       v                                            
        119         77       w                                            
        120         78       x                                            
        121         79       y                                            
        122         7A       z                                            
        179         B3       |                                   
        180         B4       ┤                                  
        185         B9                                                    
        186         BA                                                    
        187         BB                                                    
        188         BC                                                    
        191         BF                                                    
        192         C0                                                    
        193         C1       ⊥                                       
        194         C2                                                    
        195         C3       ├                                 
        196         C4                                                    
        197         C5                                                    
        200         C8                                                    
        201         C9                                                    
        202         Ca                                                    
        203         CB                                                    
        204         CC                                                    
        205         CD                                                    
        206         CE                                                    
        217         D9                                                    
        218         Da                                                    
______________________________________                                    
 
    
     The shaded characters correspond to characters that may be infrequently used and that are replaced in one embodiment of the invention with intermediate characters 66. As illustrated in FIGS. 4 through 8, each intermediate character is assigned both a decimal and hexadecimal code corresponding to its designation in the ASCII character set shown in Table 1. For example, in FIG. 4, the lower right portion of the character &#34;4&#34; is represented by the intermediate character 66 denoted by 141 and hexadecimal 8D. Therefore, a modified ASCII character set that includes the characters in primary character set 60 and intermediate character set 64 is formed to provide a plurality of characters that may be represented on display 12. Decimal and hexadecimal codes appearing in parentheses in FIGS. 4 through 8n designate that a particular intermediate character 66 may be used to form a portion of more than one primary character 62. This modified ASCII character set may be stored within character set 23, illustrated in FIG. 1B. As described above, representations of primary characters 34 may be displayed concurrently on display 12 in both small and large font by appropriate use of primary characters 62 and intermediate characters 66 in character sets 23. 
     As described above, according to one embodiment of the invention, mixed font programming 20 includes a header, or definitions file 19. Definitions file 19 defines variables in mixed font programming 20 that correspond to each intermediate character 66. A purpose of defining variables in mixed font programming 20 to correspond to intermediate characters 66 is to provide variable names corresponding to the intermediate characters 66 rather than utilizing the associated ASCII hexadecimal code associated with each intermediate character 66. As an example, the variable name &#34;TL --  2&#34; is assigned to the character represented by the hexadecimal ASCII code 82, which as illustrated in FIG. 4 corresponds to the intermediate character 66 corresponding to the top left portion of the primary character 62 &#34;2&#34;. An example definition file 19, which is entitled &#34;MIXDSIZE.H,&#34; is written in the C-programming language and is provided below in Table 2. 
     
                       TABLE 2                                                     
______________________________________                                    
Example of Definitions File 19                                            
______________________________________                                    
/* MIXDSIZE.H                                                             
File Name: mixdsize.h                                                     
Programmer: J. Drebus                                                     
This header file is used in conjunction with the MIXDSIZE() function      
which allows the mixing of character sizes in the character screen        
display of a handheld computer.                                           
The large characters are constructed using four smaller &#34;tiles&#34; that      
have been defined in the font file MIXDSIZE.FNT. Each tile is             
referenced in the MIXDSIZE function by its quandrant abbreviation:        
TL -- top left                                                            
TR -- top right                                                           
BL -- bottom left                                                         
BR -- bottom right                                                        
followed by an underscore and the character which is being constucted.    
The hex number corresponding to the font character of the tile is         
assigned. */                                                              
#define BLANK                                                             
           &#34;\x20&#34;                                               
                   /* blank */                                            
#define TL.sub.-- 0                                                       
           &#34;\x7B&#34;                                               
                   /* number 0 */                                         
#define TR.sub.-- 0                                                       
           &#34;\x7C&#34;                                               
#define BL.sub.-- 0                                                       
           &#34;\x7D&#34;                                               
#define BR.sub.-- 0                                                       
           &#34;\x7E&#34;                                               
#define TL.sub.-- 1                                                       
           &#34;\x7F&#34;                                               
                   /* number 1 */                                         
#define TR.sub.-- 1                                                       
           &#34;\x20&#34;                                               
#define BL.sub.-- 1                                                       
           &#34;\x80&#34;                                               
#define BR.sub.-- 1                                                       
           &#34;\x81&#34;                                               
#define TL.sub.-- 2                                                       
           &#34;\x82&#34;                                               
                   /* number 2 */                                         
#define TR.sub.-- 2                                                       
           &#34;\x83&#34;                                               
#define BL.sub.-- 2                                                       
           &#34;\x84&#34;                                               
#define BR.sub.-- 2                                                       
           &#34;\x85&#34;                                               
#define TL.sub.-- 3                                                       
           &#34;\x86&#34;                                               
                   /* number 3 */                                         
#define TR.sub.-- 3                                                       
           &#34;\x87&#34;                                               
#define BL.sub.-- 3                                                       
           &#34;\x88&#34;                                               
#define BR.sub.-- 3                                                       
           &#34;\x89&#34;                                               
#define TL.sub.-- 4                                                       
           &#34;\x8A&#34;                                               
                   /* number 4 */                                         
#define TR.sub.-- 4                                                       
           &#34;\x8B&#34;                                               
#define BL.sub.-- 4                                                       
           &#34;\x8C&#34;                                               
#define BR.sub.-- 4                                                       
           &#34;\x8D&#34;                                               
#define TL.sub.-- 5                                                       
           &#34;\x8E&#34;                                               
                   /* number 5 */                                         
#define TR.sub.-- 5                                                       
           &#34;\x8F&#34;                                               
#define BL.sub.-- 5                                                       
           &#34;\x88&#34;                                               
#define BR.sub.-- 5                                                       
           &#34;\x7E&#34;                                               
#define TL.sub.-- 6                                                       
           &#34;\x90&#34;                                               
                   /* number 6 */                                         
#define TR.sub.-- 6                                                       
           &#34;\x91&#34;                                               
#define BL.sub.-- 6                                                       
           &#34;\x92&#34;                                               
#define BR.sub.-- 6                                                       
           &#34;\x89&#34;                                               
#define TL.sub.-- 7                                                       
           &#34;\x93&#34;                                               
                   /* number 7 */                                         
#define TR.sub.-- 7                                                       
           &#34;\x94&#34;                                               
#define BL.sub.-- 7                                                       
           &#34;\x95&#34;                                               
#define BR.sub.-- 7                                                       
           &#34;\x20&#34;                                               
#define TL.sub.-- 8                                                       
           &#34;\x96&#34;                                               
                   /* number 8 */                                         
#define TR.sub.-- 8                                                       
           &#34;\x97&#34;                                               
#define BL.sub.-- 8                                                       
           &#34;\x98&#34;                                               
#define BR.sub.-- 8                                                       
           &#34;\x89&#34;                                               
#define TL.sub.-- 9                                                       
           &#34;\x99&#34;                                               
                   /* number 9 */                                         
#define TR.sub.-- 9                                                       
           &#34;\x9A&#34;                                               
#define BL.sub.-- 9                                                       
           &#34;\x9B&#34;                                               
#define BR.sub.-- 9                                                       
           &#34;\x9C&#34;                                               
#define TL.sub.-- A                                                       
           &#34;\x9D&#34;                                               
                   /* letter A */                                         
#define TR.sub.-- A                                                       
           &#34;\x9E&#34;                                               
#define BL.sub.-- A                                                       
           &#34;\x9F&#34;                                               
#define BR.sub.-- A                                                       
           &#34;\xA0&#34;                                               
#define TL.sub.-- B                                                       
           &#34;\xA1&#34;                                               
                   /* letter B */                                         
#define TR.sub.-- B                                                       
           &#34;\x97&#34;                                               
#define BL.sub.-- B                                                       
           &#34;\xA2&#34;                                               
#define BR.sub.-- B                                                       
           &#34;\x98&#34;                                               
#define TL.sub.-- C                                                       
           &#34;\xA3&#34;                                               
                   /* letter C */                                         
#define TR.sub.-- C                                                       
           &#34;\xA4&#34;                                               
#define BL.sub.-- C                                                       
           &#34;\x92&#34;                                               
#define BR.sub.-- C                                                       
           &#34;\xA5&#34;                                               
#define TL.sub.-- D                                                       
           &#34;\xA6&#34;                                               
                   /* letter D */                                         
#define TR.sub.-- D                                                       
           &#34;\xA7&#34;                                               
#define BL.sub.-- D                                                       
           &#34;\xA8&#34;                                               
#define BR.sub.-- D                                                       
           &#34;\x9C&#34;                                               
#define TL.sub.-- E                                                       
           &#34;\xA1&#34;                                               
                   /* letter E */                                         
#define TR.sub.-- E                                                       
           &#34;\xA9&#34;                                               
#define BL.sub.-- E                                                       
           &#34;\xA2&#34;                                               
#define BR.sub.-- E                                                       
           &#34;\xAA&#34;                                               
#define TL.sub.-- F                                                       
           &#34;\xA1&#34;                                               
                   /* letter F */                                         
#define TR.sub.-- F                                                       
           &#34;\xA9&#34;                                               
#define BL.sub.-- F                                                       
           &#34;\x9F&#34;                                               
#define BR.sub.-- F                                                       
           &#34;\x20&#34;                                               
#define TL.sub.-- G                                                       
           &#34;\xAB&#34;                                               
                   /* letter G */                                         
#define TR.sub.-- G                                                       
           &#34;\xAC&#34;                                               
#define BL.sub.-- G                                                       
           &#34;\x92&#34;                                               
#define BR.sub.-- G                                                       
           &#34;\x7E&#34;                                               
#define TL.sub.-- H                                                       
           &#34;\xAD&#34;                                               
                   /* letter H */                                         
#define TR.sub.-- H                                                       
           &#34;\xAE&#34;                                               
#define BL.sub.-- H                                                       
           &#34;\x9F&#34;                                               
#define BR.sub.-- H                                                       
           &#34;\xA0&#34;                                               
#define TL.sub.-- I                                                       
           &#34;\xAF&#34;                                               
                   /* letter I */                                         
#define TR.sub.-- I                                                       
           &#34;\xB0&#34;                                               
#define BL.sub.-- I                                                       
           &#34;\x80&#34;                                               
#define BR.sub.-- I                                                       
           &#34;\x81&#34;                                               
#define TL.sub.-- J                                                       
           &#34;\xB1&#34;                                               
                   /* letter J */                                         
#define TR.sub.-- J                                                       
           &#34;\xB2&#34;                                               
#define BL.sub.-- J                                                       
           &#34;\xB5&#34;                                               
#define BR.sub.-- J                                                       
           &#34;\xB6&#34;                                               
#define TL.sub.-- K                                                       
           &#34;\xB7&#34;                                               
                   /* letter K */                                         
#define TR.sub.-- K                                                       
           &#34;\xB8&#34;                                               
#define BL.sub.-- K                                                       
           &#34;\xBD&#34;                                               
#define BR.sub.-- K                                                       
           &#34;\xBE&#34;                                               
#define TL.sub.-- L                                                       
           &#34;\x8B&#34;                                               
                   /* letter L */                                         
#define TR.sub.-- L                                                       
           &#34;\x20&#34;                                               
#define BL.sub.-- L                                                       
           &#34;\xA2&#34;                                               
#define BR.sub.-- L                                                       
           &#34;\xAA&#34;                                               
#define TL.sub.-- M                                                       
           &#34;\xC6&#34;                                               
                   /* letter M */                                         
#define TR.sub.-- M                                                       
           &#34;\xC7&#34;                                               
#define BL.sub.-- M                                                       
           &#34;\x9F&#34;                                               
#define BR.sub.-- M                                                       
           &#34;\xA0&#34;                                               
#define TL.sub.-- N                                                       
           &#34;\xCF&#34;                                               
                   /* letter N */                                         
#define TR.sub.-- N                                                       
           &#34;\xD0&#34;                                               
#define BL.sub.-- N                                                       
           &#34;\xD1&#34;                                               
#define BR.sub.-- N                                                       
           &#34;\xD2&#34;                                               
#define TL.sub.-- O                                                       
           &#34;\xA3&#34;                                               
                   /* letter O */                                         
#define TR.sub.-- O                                                       
           &#34;\xD3&#34;                                               
#define BL.sub.-- O                                                       
           &#34;\x92&#34;                                               
#define BR.sub.-- O                                                       
           &#34;\x7E&#34;                                               
#define TL.sub.-- P                                                       
           &#34;\xA1&#34;                                               
                   /* letter P */                                         
#define TR.sub.-- P                                                       
           &#34;\x83&#34;                                               
#define BL.sub.-- P                                                       
           &#34;\x9F&#34;                                               
#define BR.sub.-- P                                                       
           &#34;\x20&#34;                                               
#define TL.sub.-- Q                                                       
           &#34;\xA3&#34;                                               
                   /* letter Q */                                         
#define TR.sub.-- Q                                                       
           &#34;\xD3&#34;                                               
#define BL.sub.-- Q                                                       
           &#34;\xD4&#34;                                               
#define BR.sub.-- Q                                                       
           &#34;\xD5&#34;                                               
#define TL.sub.-- R                                                       
           &#34;\xA1&#34;                                               
                   /* letter R */                                         
#define TR.sub.-- R                                                       
           &#34;\x83&#34;                                               
#define BL.sub.-- R                                                       
           &#34;\xBD&#34;                                               
#define BR.sub.-- R                                                       
           &#34;\xBE&#34;                                               
#define TL.sub.-- S                                                       
           &#34;\x99&#34;                                               
                   /* letter S */                                         
#define TR.sub.-- S                                                       
           &#34;\xD6&#34;                                               
#define BL.sub.-- S                                                       
           &#34;\xD7&#34;                                               
#define BR.sub.-- S                                                       
           &#34;\x89&#34;                                               
#define TL.sub.-- T                                                       
           &#34;\xD8&#34;                                               
                   /* letter T */                                         
#define TR.sub.-- T                                                       
           &#34;\xDB&#34;                                               
#define BL.sub.-- T                                                       
           &#34;\xDC&#34;                                               
#define BR.sub.-- T                                                       
           &#34;\x20&#34;                                               
#define TL.sub.-- U                                                       
           &#34;\x8B&#34;                                               
                   /* letter U */                                         
#define TR.sub.-- U                                                       
           &#34;\xDD&#34;                                               
#define BL.sub.-- U                                                       
           &#34;\x92&#34;                                               
#define BR.sub.-- U                                                       
           &#34;\x7E&#34;                                               
#define TL.sub.-- V                                                       
           &#34;\x8B&#34;                                               
                   /* letter V */                                         
#define TR.sub.-- V                                                       
           &#34;\xDD&#34;                                               
#define BL.sub.-- V                                                       
           &#34;\xDE&#34;                                               
#define BR.sub.-- V                                                       
           &#34;\x9C&#34;                                               
#define TL.sub.-- W                                                       
           &#34;\xDF&#34;                                               
                   /* letter W */                                         
#define TR.sub.-- W                                                       
           &#34;\xDD&#34;                                               
#define BL.sub.-- W                                                       
           &#34;\xE0&#34;                                               
#define BR.sub.-- W                                                       
           &#34;\x7E&#34;                                               
#define TL.sub.-- X                                                       
           &#34;\xE1&#34;                                               
                   /* letter X */                                         
#define TR.sub.-- X                                                       
           &#34;\xE2&#34;                                               
#define BL.sub.-- X                                                       
           &#34;\xE3&#34;                                               
#define BR.sub.-- X                                                       
           &#34;\xE4&#34;                                               
#define TL.sub.-- Y                                                       
           &#34;\xE5&#34;                                               
                   /* letter Y */                                         
#define TR.sub.-- Y                                                       
           &#34;\xE6&#34;                                               
#define BL.sub.-- Y                                                       
           &#34;\xE7&#34;                                               
#define BR.sub.-- Y                                                       
           &#34;\xE8&#34;                                               
#define TL.sub.-- Z                                                       
           &#34;\x93&#34;                                               
                   /* letter Z */                                         
#define TR.sub.-- Z                                                       
           &#34;\x94&#34;                                               
#define BL.sub.-- Z                                                       
           &#34;\xE9&#34;                                               
#define BR.sub.-- Z                                                       
           &#34;\xAA&#34;                                               
#define TL.sub.-- DEC                                                     
           &#34;\x20&#34;                                               
                   /* decimal point */                                    
#define TR.sub.-- DEC                                                     
           &#34;\x20&#34;                                               
#define BL.sub.-- DEC                                                     
           &#34;\xEA&#34;                                               
#define BR.sub.-- DEC                                                     
           &#34;\xEA&#34;                                               
#define TL.sub.-- COM                                                     
           &#34;\x20&#34;                                               
                   /* comma */                                            
#define TR.sub.-- COM                                                     
           &#34;\x20&#34;                                               
#define BL.sub.-- COM                                                     
           &#34;\xEC&#34;                                               
#define BR.sub.-- COM                                                     
           &#34;\xED&#34;                                               
#define TL.sub.-- NEG                                                     
           &#34;\xEE&#34;                                               
                   /* negative sign */                                    
#define TR.sub.-- NEG                                                     
           &#34;\xEF&#34;                                               
#define BL.sub.-- NEG                                                     
           &#34;\x20&#34;                                               
#define BR.sub.-- NEG                                                     
           &#34;\x20&#34;                                               
#define TL.sub.-- POS                                                     
           &#34;\xF0&#34;                                               
                   /* positive sign*/                                     
#define TR.sub.-- POS                                                     
           &#34;\xF1&#34;                                               
#define BL.sub.-- POS                                                     
           &#34;\xF2&#34;                                               
#define BR.sub.-- POS                                                     
           &#34;\x20&#34;                                               
#define TL.sub.-- NUM                                                     
           &#34;\xF3&#34;                                               
                   /* number (or pound) */                                
#define TR.sub.-- NUM                                                     
           &#34;\xF4&#34;                                               
#define BL.sub.-- NUM                                                     
           &#34;\xF5&#34;                                               
#define BR.sub.-- NUM                                                     
           &#34;\x8D&#34;                                               
#define TL.sub.-- DOL                                                     
           &#34;\xF6&#34;                                               
                   /* dollar sign */                                      
#define TR.sub.-- DOL                                                     
           &#34;\xF7&#34;                                               
#define BL.sub.-- DOL                                                     
           &#34;\xF8&#34;                                               
#define BR.sub.-- DOL                                                     
           &#34;\xF9&#34;                                               
#define TL.sub.-- PER                                                     
           &#34;\xFA&#34;                                               
                   /* percent sign */                                     
#define TR.sub.-- PER                                                     
           &#34;\xFB&#34;                                               
#define BL.sub.-- PER                                                     
           &#34;\xFC&#34;                                               
#define BR.sub.-- PER                                                     
           &#34;\xFD&#34;                                               
#define TL.sub.-- EXC                                                     
           &#34;\xFE&#34;                                               
                   /* exclamation point */                                
#define TR.sub.-- EXC                                                     
           &#34;\x20&#34;                                               
#define BL.sub.-- EXC                                                     
           &#34;\xFF&#34;                                               
#define BR.sub.-- EXC                                                     
           &#34;\x20&#34;                                               
#define TL.sub.-- QUE                                                     
           &#34;\x82&#34;                                               
                   /* question mark */                                    
#define TR.sub.-- QUE                                                     
           &#34;\x83&#34;                                               
#define BL.sub.-- QUE                                                     
           &#34;\xFF&#34;                                               
#define BR.sub.-- QUE                                                     
           &#34;\xE8&#34;                                               
______________________________________                                    
 
    
     Thus, definitions file 19 allows other portions of mixed font programming 20 to utilize intermediate characters 66 corresponding to quarter portions of primary characters 62 through logical variable names. 
     Intermediate characters 66 that are used to form a primary character are associated with the corresponding primary character by mixed font programming 20. For example, character display routine 21, of mixed font programming 20, associates primary characters 62 of primary character set 60 with the corresponding intermediate characters 66 of intermediate character set 64. This association is performed using a &#34;switch&#34; and &#34;case&#34; function in the C-programming language. 
     Table 3 recites portions of an example of character display routine 21 with particularly pertinent portions in bold face type. In Table 3 the &#34;case `1`&#34; function is utilized to associate the variable names for the intermediate characters 66 that correspond to the upper left, upper right, lower left, and lower right positions of the primary characters 62 &#34;1&#34;, and therefore associate the primary character 62 &#34;1&#34; with the intermediate characters 66 corresponding to the primary character 62 &#34;1.&#34; 
     
                       TABLE 3                                                     
______________________________________                                    
Pertinent Portions of an Example of                                       
Character Display Routine 21                                              
______________________________________                                    
void mixdsize(unsigned char lin,unsigned char col,char *input.sub.--      
str,                                                                      
  unsigned char video)                                                    
 unsigned int count = 0;                                                  
 char top.sub.-- line[20 + 1] = {0};                                      
                  /* top line to be printed */                            
 char btm.sub.-- line[20 + 1] = {0};                                      
                  /* btm line to be printed */                            
 static char top.sub.-- char[3] = {0};                                    
                  /* 2 top tiles of character */                          
 static char btm.sub.-- char[3] = {0};                                    
                  /* 2 btm tiles of character */                          
 static char cur.sub.-- char;                                             
                  /* current character */                                 
while (count &lt; strlen(input.sub.-- str))                                  
 {                                                                        
 memset(top.sub.-- char,0,2);                                             
                  /* clear top.sub.-- char */                             
 memset(btm.sub.-- char,0,2);                                             
                  /* clear btm.sub.-- char */                             
 cur.sub.-- char = input.sub.-- str[count];                               
                  /* next character */                                    
 switch (cur.sub.-- char)                                                 
   {                                                                      
  case `0`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 0;                                     
                  /* Each large character is */                           
   top.sub.-- char[1] = *TR.sub.-- 0;                                     
                  /* constructed from four small */                       
   btm.sub.-- char[0] = *BL.sub.-- 0;                                     
                  /* &#34;tiles&#34;. */                                          
   btm.sub.-- char[1] = *BR.sub.-- 0;                                     
   break;                                                                 
  case `1`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 1;                                     
   top.sub.-- char[1] = *TR.sub.-- 1;                                     
   btm.sub.-- char[0] = *BL.sub.-- 1;                                     
   btm.sub.-- char[1] = *BR.sub.-- 1;                                     
   break;                                                                 
strcat(top.sub.-- line, top.sub.-- char);                                 
                  /* add char to top line */                              
strcat(btm.sub.-- line, btm.sub.-- char);                                 
                  /* add char to btm line */                              
count++;                                                                  
}                                                                         
______________________________________                                    
 
    
     In the example of character display routine 21 listed in Table 3, a variable having a name &#34;input --  str&#34; stores a primary character string for display on display 12, and a variable having a name &#34;cur --  char&#34; stores, in succession, each primary character 62 in the primary character string stored in &#34;input --  str.&#34; By using a &#34;switch&#34; and &#34;case&#34; function of the C programming language, each primary character 62 of the primary character string to be displayed, which is temporarily stored within the variable &#34;cur --  char,&#34; is associated with four intermediate characters 66 corresponding to the primary character 62 stored in the variable &#34;cur --  char.&#34; For example, if the variable &#34;cur --  char&#34; stores the primary character 62 &#34;1,&#34; the &#34;case `1`&#34; function detects that the variable &#34;cur --  char&#34; stores the primary character 62 &#34;1&#34; and assigns the intermediate characters 66 that correspond to the primary character 62 &#34;1,&#34; which are &#34;TL --  1,&#34; &#34;TR --  1,&#34; &#34;BL --  0,&#34; &#34;BR --  1,&#34; to temporary variables &#34;top --  char[o],&#34; &#34;top --  char[1],&#34; &#34;btm --  char[o],&#34; and &#34;btm --  char[1],&#34; respectively. These temporary variables are then used to produce character strings that are used to display a representation of the primary character string, as discussed in greater detail in conjunction with FIGS. 9A and 9B. 
     Therefore, according to the invention, a primary character 62 such as the letter &#34;E&#34; may be represented by, for example, four intermediate characters 66 representing a top left, a top right, a bottom left, and a bottom right portion of the primary character 62. Formation of a character or a character string utilizing intermediate characters 66 to form a representation of a character having large font size, such as representation 50 of the character &#34;E&#34; or representation 36 of the character string &#34;MIXED,&#34; is described in greater detail in conjunction with FIGS. 9A and 9B. A complete listing of one example of character display routine 21 is provided below in TABLE 4. 
     
                       TABLE 4                                                     
______________________________________                                    
Example of Character Display Routine 21                                   
______________________________________                                    
void mixdsize(unsigned char lin,unsigned char col,char *input.sub.--      
str,                                                                      
  unsigned char video)                                                    
strcat(top.sub.-- line, top.sub.-- char);                                 
                  /* add char to top line */                              
strcat(btm.sub.-- line, btm.sub.-- char);                                 
                  /* add char to btm line */                              
count++;                                                                  
}                                                                         
 unsigned int count = 0;                                                  
 char top.sub.-- line[20 + 1] = {0};                                      
                  /* top line to be printed */                            
 char btm.sub.-- line[20 + 1] = {0};                                      
                  /* btm line to be printed */                            
 static char top.sub.-- char[3] = {0};                                    
                  /* 2 top tiles of character */                          
 static char btm.sub.-- char[3] = {0};                                    
                  /* 2 btm tiles of character */                          
 static char cur.sub.-- char;                                             
                  /* current character */                                 
while (count &lt; strlen(input.sub.-- str))                                  
 {                                                                        
 memset(top.sub.-- char,0,2);                                             
                  /* clear top.sub.-- char */                             
 memset(btm.sub.-- char,0,2);                                             
                  /* clear btm.sub.-- char */                             
 cur.sub.-- char = input.sub.-- str[count];                               
                  /* next character */                                    
 switch (cur.sub.-- char)                                                 
  {                                                                       
  case `0`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 0;                                     
                  /* Each large character is */                           
   top.sub.-- char[1] = *TR.sub.-- 0;                                     
                  /* constructed from four small */                       
   btm.sub.-- char[0] = *BL.sub.-- 0;                                     
                  /* &#34;tiles&#34;. */                                          
   btm.sub.-- char[1] = *BR.sub.-- 0;                                     
   break;                                                                 
  case `1`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 1;                                     
   top.sub.-- char[1] = *TR.sub.-- 1;                                     
   btm.sub.-- char[0] = *BL.sub.-- 1;                                     
   btm.sub.-- char[1] = *BR.sub.-- 1;                                     
   break;                                                                 
  case `2`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 2;                                     
   top.sub.-- char[1] = *TR.sub.-- 2;                                     
   btm.sub.-- char[0] = *BL.sub.-- 2;                                     
   btm.sub.-- char[1] = *BR.sub.-- 2;                                     
   break;                                                                 
  case `3`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 3;                                     
   top.sub.-- char[1] = *TR.sub.-- 3;                                     
   btm.sub.-- char[0] = *BL.sub.-- 3;                                     
   btm.sub.-- char[1] = *BR.sub.-- 3;                                     
   break;                                                                 
  case `4`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 4;                                     
   top.sub.-- char[1] = *TR.sub.-- 4;                                     
   btm.sub.-- char[0] = *BL.sub.-- 4;                                     
   btm.sub.-- char[1] = *BR.sub.-- 4;                                     
   break;                                                                 
  case `5`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 5;                                     
   top.sub.-- char[1] = *TR.sub.-- 5;                                     
   btm.sub.-- char[0] = *BL.sub.-- 5;                                     
   btm.sub.-- char[1] = *BR.sub.-- 5;                                     
   break;                                                                 
  case `6`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 6;                                     
   top.sub.-- char[1] = *TR.sub.-- 6;                                     
   btm.sub.-- char[0] = *BL.sub.-- 6;                                     
   btm.sub.-- char[1] = *BR.sub.-- 6;                                     
   break;                                                                 
  case `7`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 7;                                     
   top.sub.-- char[1] = *TR.sub.-- 7;                                     
   btm.sub.-- char[0] = *BL.sub.-- 7;                                     
   btm.sub.-- char[1] = *BR.sub.-- 7;                                     
   break;                                                                 
  case `8`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 8;                                     
   top.sub.-- char[1] = *TR.sub.-- 8;                                     
   btm.sub.-- char[0] = *BL.sub.-- 8;                                     
   btm.sub.-- char[1] = *BR.sub.-- 8;                                     
   break;                                                                 
  case `9`:                                                               
   top.sub.-- char[0] = *TL.sub.-- 9;                                     
   top.sub.-- char[1] = *TR.sub.-- 9;                                     
   btm.sub.-- char[0] = *BL.sub.-- 9;                                     
   btm.sub.-- char[1] = *BR.sub.-- 9;                                     
   break;                                                                 
  case `A`:                                                               
   top.sub.-- char[0] = *TL.sub.-- A;                                     
   top.sub.-- char[1] = *TR.sub.-- A;                                     
   btm.sub.-- char[0] = *BL.sub.-- A;                                     
   btm.sub.-- char[1] = *BR.sub.-- A;                                     
   break;                                                                 
  case `B`:                                                               
   top.sub.-- char[0] = *TL.sub.-- B;                                     
   top.sub.-- char[1] = *TR.sub.-- B;                                     
   btm.sub.-- char[0] = *BL.sub.-- B;                                     
   btm.sub.-- char[1] = *BR.sub.-- B;                                     
   break;                                                                 
  case `C`:                                                               
   top.sub.-- char[0] = *TL.sub.-- C;                                     
   top.sub.-- char[1] = *TR.sub.-- C;                                     
   btm.sub.-- char[0] = *BL.sub.-- C;                                     
   btm.sub.-- char[1] = *BR.sub.-- C;                                     
   break;                                                                 
  case `D`:                                                               
   top.sub.-- char[0] = *TL.sub.-- D;                                     
   top.sub.-- char[1] = *TR.sub.-- D;                                     
   btm.sub.-- char[0] = *BL.sub.-- D;                                     
   btm.sub.-- char[1] = *BR.sub.-- D;                                     
   break;                                                                 
  case `E`:                                                               
   top.sub.-- char[0] = *TL.sub.-- E;                                     
   top.sub.-- char[1] = *TR.sub.-- E;                                     
   btm.sub.-- char[0] = *BL.sub.-- E;                                     
   btm.sub.-- char[1] = *BR.sub.-- E;                                     
   break;                                                                 
  case `F`:                                                               
   top.sub.-- char[0] = *TL.sub.-- F;                                     
   top.sub.-- char[1] = *TR.sub.-- F;                                     
   btm.sub.-- char[0] = *BL.sub.-- F;                                     
   btm.sub.-- char[1] = *BR.sub.-- F;                                     
   break;                                                                 
  case `G`:                                                               
   top.sub.-- char[0] = *TL.sub.-- G;                                     
   top.sub.-- char[1] = *TR.sub.-- G;                                     
   btm.sub.-- char[0] = *BL.sub.-- G;                                     
   btm.sub.-- char[1] = *BR.sub.-- G;                                     
   break;                                                                 
  case `H`:                                                               
   top.sub.-- char[0] = *TL.sub.-- H;                                     
   top.sub.-- char[1] = *TR.sub.-- H;                                     
   btm.sub.-- char[0] = *BL.sub.-- H;                                     
   btm.sub.-- char[1] = *BR.sub.-- H;                                     
   break;                                                                 
  case `I`:                                                               
   top.sub.-- char[0] = *TL.sub.-- I;                                     
   top.sub.-- char[1] = *TR.sub.-- I;                                     
   btm.sub.-- char[0] = *BL.sub.-- I;                                     
   btm.sub.-- char[1] = *BR.sub.-- I;                                     
   break;                                                                 
  case `J`:                                                               
   top.sub.-- char[0] = *TL.sub.-- J;                                     
   top.sub.-- char[1] = *TR.sub.-- J;                                     
   btm.sub.-- char[0] = *BL.sub.-- J;                                     
   btm.sub.-- char[1] = *BR.sub.-- J;                                     
   break;                                                                 
  case `K`:                                                               
   top.sub.-- char[0] = *TL.sub.-- K;                                     
   top.sub.-- char[1] = *TR.sub.-- K;                                     
   btm.sub.-- char[0] = *BL.sub.-- K;                                     
   btm.sub.-- char[1] = *BR.sub.-- K;                                     
   break;                                                                 
  case `L`:                                                               
   top.sub.-- char[0] = *TL.sub.-- L;                                     
   top.sub.-- char[1] = *TR.sub.-- L;                                     
   btm.sub.-- char[0] = *BL.sub.-- L;                                     
   btm.sub.-- char[1] = *BR.sub.-- L;                                     
   break;                                                                 
  case `M`:                                                               
   top.sub.-- char[0] = *TL.sub.-- M;                                     
   top.sub.-- char[1] = *TR.sub.-- M;                                     
   btm.sub.-- char[0] = *BL.sub.-- M;                                     
   btm.sub.-- char[1] = *BR.sub.-- M;                                     
   break;                                                                 
  case `N`:                                                               
   top.sub.-- char[0] = *TL.sub.-- N;                                     
   top.sub.-- char[1] = *TR.sub.-- N;                                     
   btm.sub.-- char[0] = *BL.sub.-- N;                                     
   btm.sub.-- char[1] = *BR.sub.-- N;                                     
   break;                                                                 
  case `O`:                                                               
   top.sub.-- char[0] = *TL.sub.-- O;                                     
   top.sub.-- char[1] = *TR.sub.-- O;                                     
   btm.sub.-- char[0] = *BL.sub.-- O;                                     
   btm.sub.-- char[1] = *BR.sub.-- O;                                     
   break;                                                                 
  case `P`:                                                               
   top.sub.-- char[0] = *TL.sub.-- P;                                     
   top.sub.-- char[1] = *TR.sub.-- P;                                     
   btm.sub.-- char[0] = *BL.sub.-- P;                                     
   btm.sub.-- char[1] = *BR.sub.-- P;                                     
   break;                                                                 
  case `Q`:                                                               
   top.sub.-- char[0] = *TL.sub.-- Q;                                     
   top.sub.-- char[1] = *TR.sub.-- Q;                                     
   btm.sub.-- char[0] = *BL.sub.-- Q;                                     
   btm.sub.-- char[1] = *BR.sub.-- Q;                                     
   break;                                                                 
  case `R`:                                                               
   top.sub.-- char[0] = *TL.sub.-- R;                                     
   top.sub.-- char[1] = *TR.sub.-- R;                                     
   btm.sub.-- char[0] = *BL.sub.-- R;                                     
   btm.sub.-- char[1] = *BR.sub.-- R;                                     
   break;                                                                 
  case `S`:                                                               
   top.sub.-- char[0] = *TL.sub.-- S;                                     
   top.sub.-- char[1] = *TR.sub.-- S;                                     
   btm.sub.-- char[0] = *BL.sub.-- S;                                     
   btm.sub.-- char[1] = *BR.sub.-- S;                                     
   break;                                                                 
  case `T`:                                                               
   top.sub.-- char[0] = *TL.sub.-- T;                                     
   top.sub.-- char[1] = *TR.sub.-- T;                                     
   btm.sub.-- char[0] = *BL.sub.-- T;                                     
   btm.sub.-- char[1] = *BR.sub.-- T;                                     
   break;                                                                 
  case `U`:                                                               
   top.sub.-- char[0] = *TL.sub.-- U;                                     
   top.sub.-- char[1] = *TR.sub.-- U;                                     
   btm.sub.-- char[0] = *BL.sub.-- U;                                     
   btm.sub.-- char[1] = *BR.sub.-- U;                                     
   break;                                                                 
  case `V`:                                                               
   top.sub.-- char[0] = *TL.sub.-- V;                                     
   top.sub.-- char[1] = *TR.sub.-- V;                                     
   btm.sub.-- char[0] = *BL.sub.-- V;                                     
   btm.sub.-- char[1] = *BR.sub.-- V;                                     
   break;                                                                 
  case `W`:                                                               
   top.sub.-- char[0] = *TL.sub.-- W;                                     
   top.sub.-- char[1] = *TR.sub.-- W;                                     
   btm.sub.-- char[0] = *BL.sub.-- W;                                     
   btm.sub.-- char[1] = *BR.sub.-- W;                                     
   break;                                                                 
  case `X`:                                                               
   top.sub.-- char[0] = *TL.sub.-- X;                                     
   top.sub.-- char[1] = *TR.sub.-- X;                                     
   btm.sub.-- char[0] = *BL.sub.-- X;                                     
   btm.sub.-- char[1] = *BR.sub.-- X;                                     
   break;                                                                 
  case `Y`:                                                               
   top.sub.-- char[0] = *TL.sub.-- Y;                                     
   top.sub.-- char[1] = *TR.sub.-- Y;                                     
   btm.sub.-- char[0] = *BL.sub.-- Y;                                     
   btm.sub.-- char[1] = *BR.sub.-- Y;                                     
   break;                                                                 
  case `Z`:                                                               
   top.sub.-- char[0] = *TL.sub.-- Z;                                     
   top.sub.-- char[1] = *TR.sub.-- Z;                                     
   btm.sub.-- char[0] = *BL.sub.-- Z;                                     
   btm.sub.-- char[1] = *BR.sub.-- Z;                                     
   break;                                                                 
  case `.`:                                                               
   top.sub.-- char[0] = *TL.sub.-- DEC;                                   
   top.sub.-- char[1] = *TR.sub.-- DEC;                                   
   btm.sub.-- char[0] = *BL.sub.-- DEC;                                   
   btm.sub.-- char[1] = *BR.sub.-- DEC;                                   
   break;                                                                 
  case `,`:                                                               
   top.sub.-- char[0] = *TL.sub.-- COM;                                   
   top.sub.-- char[1] = *TR.sub.-- COM;                                   
   btm.sub.-- char[0] = *BL.sub.-- COM;                                   
   btm.sub.-- char[1] = *BR.sub.-- COM;                                   
   break;                                                                 
  case `-`:                                                               
   top.sub.-- char[0] = *TL.sub.-- NEG;                                   
   top.sub.-- char[1] = *TR.sub.-- NEG;                                   
   btm.sub.-- char[0] = *BL.sub.-- NEG;                                   
   btm.sub.-- char[1] = *BR.sub.-- NEG;                                   
   break;                                                                 
  case `+`:                                                               
   top.sub.-- char[0] = *TL.sub.-- POS;                                   
   top.sub.-- char[1] = *TR.sub.-- POS;                                   
   btm.sub.-- char[0] = *BL.sub.-- POS;                                   
   btm.sub.-- char[1] = *BR.sub.-- POS;                                   
   break;                                                                 
  case `#`:                                                               
   top.sub.-- char[0] = *TL.sub.-- NUM;                                   
   top.sub.-- char[1] = *TR.sub.-- NUM;                                   
   btm.sub.-- char[0] = *BL.sub.-- NUM;                                   
   btm.sub.-- char[1] = *BR.sub.-- NUM;                                   
   break;                                                                 
  case `$`:                                                               
   top.sub.-- char[0] = *TL.sub.-- DOL;                                   
   top.sub.-- char[1] = *TR.sub.-- DOL;                                   
   btm.sub.-- char[0] = *BL.sub.-- DOL;                                   
   btm.sub.-- char[1] = *BR.sub.-- DOL;                                   
   break;                                                                 
  case `%`:                                                               
   top.sub.-- char[0] = *TL.sub.-- PER;                                   
   top.sub.-- char[1] = *TR.sub.-- PER;                                   
   btm.sub.-- char[0] = *BL.sub.-- PER;                                   
   btm.sub.-- char[1] = *BR.sub.-- PER;                                   
   break;                                                                 
  case `!`:                                                               
   top.sub.-- char[0] = *TL.sub.-- EXC;                                   
   top.sub.-- char[1] = *TR.sub.-- EXC;                                   
   btm.sub.-- char[0] = *BL.sub.-- EXC;                                   
   btm.sub.-- char[1] = *BR.sub.-- EXC;                                   
   break;                                                                 
  case `?`:                                                               
   top.sub.-- char[0] = *TL.sub.-- QUE;                                   
   top.sub.-- char[1] = *TR.sub.-- QUE;                                   
   btm.sub.-- char[0] = *BL.sub.-- QUE;                                   
   btm.sub.-- char[1] = *BR.sub.-- QUE;                                   
   break;                                                                 
  default:                                                                
   top.sub.-- char[0] = *TL.sub.-- *BLANK;                                
   top.sub.-- char[1] = *TR.sub.-- *BLANK;                                
   btm.sub.-- char[0] = *BL.sub.-- *BLANK;                                
   btm.sub.-- char[1] = *BR.sub.-- *BLANK;                                
   break;                                                                 
  }                                                                       
  strcat(top.sub.-- line, top.sub.-- char);                               
                  /* add char to top line */                              
  strcat(btm.sub.-- line, btm.sub.-- char);                               
                  /* add char to btm line */                              
  count++;                                                                
  }                                                                       
BiosPutStrStay( lin,col,strlen(top.sub.-- line),top.sub.-- line,video);   
BiosPutStrStay(++lin,col,strlen(btm.sub.-- line),btm.sub.-- line,video);  
};/* End of mixdsize() */                                                 
______________________________________                                    
 
    
     FIG. 9A is a flowchart, showing exemplary steps associated with representing a character string according to the teachings of the present invention. FIG. 9B is associated with FIG. 9A illustrating a representation of a character string &#34;EDS&#34; according to the exemplary steps shown in FIG. 9A. As described above, the example of character display routine 21 recited in Table 4 associates a primary character in a primary character string to be displayed with four intermediate characters corresponding to the primary character and stores the four intermediate characters in four temporary variables. Display of a primary character through the use of intermediate characters is described below in conjunction with FIGS. 9A and 9B. 
     The example of character display routine 21 illustrated in Table 4 allows the representation of primary characters in display 12 utilizing intermediate characters selected from an intermediate character set, such as the intermediate character set illustrated in FIGS. 4 through 8. As a first step in displaying a primary character string in a large font, the example of character display routine 21 illustrated in Table 4 receives four parameters: a line number of the desired location for display of a primary character string, a column number of a left edge of the desired location for display of the primary character string, a string value to be displayed in a large font size, and the video mode of the string. The video mode of the string corresponds to whether a string will be displayed in normal or reverse mode. The receipt by the example of character display routine 21 illustrated in Table 4 of a character string, such as &#34;EDS,&#34; is illustrated in FIG. 9A at step 102. A step 102 is implemented in the example of character display routine 21 illustrated in Table 4 by the function mixdsize (unsigned char lin, unsigned char col, char *input --  str, unsigned char video). 
     At a step 104 a check is performed to determine if all characters within the desired character string have been examined. Step 104 is implemented in the example of character display routine 21 illustrated in Table 3 by the C programming language function &#34;while (count&lt;strlen (input --  str)).&#34; If all characters in the primary character string have not been examined, a step 106 of identifying a next character in the character string is performed. For example, referring to FIG. 9B, the character string &#34;EDS&#34; is desired to be displayed in a large size font. Therefore, the example of character display routine 21 illustrated in Table 4 identifies the primary character &#34;E&#34; for display. In a step 108, two intermediate characters corresponding to the upper portion of the primary character &#34;E&#34; are selected. Representations 70 and 72 of the intermediate characters corresponding to the upper portion of primary character &#34;E&#34; are illustrated in FIG. 9B. The intermediate characters corresponding to the upper portion of the primary character &#34;E&#34; are illustrated in FIG. 5 and are identified by reference numerals 74 and 76. 
     At a step 110, the two intermediate characters corresponding to the lower portion of the primary character &#34;E&#34; are identified. Representations 80 and 82 of the lower left and lower right portions of the primary character &#34;E&#34; are illustrated in FIG. 9E. The intermediate characters corresponding to the lower left and lower right portions of the primary character &#34;E&#34; are illustrated in FIG. 5 and denoted by reference numerals 84 and 86, respectively. The selection of the intermediate characters corresponding to the primary character &#34;E&#34; is performed as described above in connection with the description of the &#34;switch&#34; and &#34;case&#34; functions of the example of character display routine 21 illustrated in Table 4, and therefore the top left, top right, bottom left, and bottom right portions of the primary character &#34;E&#34; are assigned to temporary variables within the example of character display routine 21 illustrated in Table 3 having the variable names &#34;top --  char[o],&#34; &#34;top --  char[1],&#34; &#34;btm --  char[o],&#34; and &#34;btm --  char[1].&#34; 
     According to the invention, each of the intermediate characters corresponding to the upper portion of a primary character string are combined to produce an intermediate character string that will represent an upper portion of the received primary character string and will be used to facilitate representation of the received character string on display 12. In this example, at a step 112 intermediate characters 74 and 76 illustrated in FIG. 9B, which correspond to the upper portion of the primary character &#34;E,&#34; are added to a variable that corresponds to an upper character string. Similarly, intermediate characters 84 and 86 illustrated in FIG. 5, which correspond to the lower portion of the primary character &#34;E,&#34; are added to an intermediate character string in a variable corresponding to the intermediate character string representing the lower portion of the character string to be displayed. The adding of intermediate characters 84 and 86 is illustrated in FIG. 9A by a step 114. In the example of character display routine 21 illustrated in Table 3 the adding of intermediate characters is performed through the C programming language functions &#34;strcat(top --  line, top --  char);&#34; and &#34;strcat(btm --  line, btm --  char);&#34;. This process is repeated until the end of the received character string is reached. 
     As illustrated in FIG. 9B, a representation 94 of the received character string is displayed on display 12 by displaying a representation of an intermediate character string corresponding to the upper portion of the received character string, which in this example is the upper portion of the character string &#34;EDS.&#34; Such a representation is illustrated in FIG. 9B by a representation 96. The step of displaying an intermediate character string corresponding to portion of the primary character string at an appropriate location on display 12 is illustrated in FIG. 9A by a step 116. Similarly, an intermediate character string corresponding to the lower portion of the received character string &#34;EDS&#34; is displayed at an appropriate location. The step of displaying a string corresponding to the lower portion of the character string &#34;EDS&#34; is illustrated in FIG. 9A by a step 118. The representation of this intermediate character string is illustrated by a representation 98 of the lower character string corresponding to the lower half of the character string &#34;EDS.&#34; 
     Thus, by utilizing an intermediate character set, such as intermediate character set 64, having characters representing fractional portions of a primary character set, a character-based display may display representations of primary characters in at least two different font sizes, as illustrated in FIG. 2. 
     Thus, it is apparent that there has been provided, in accordance with the present invention, a method and system that satisfies the advantages set forth above. Although an embodiment has been described in detail, it should be understood that various and numerous changes, substitutions, and alterations can be made herein without the departing from the scope of the present invention. Other examples of changes, substitutions, and alterations are readily ascertainable by one skilled in the art and could be made without departing from the spirit and scope of the present invention as defined by the following claims.