U.S. patent application number 12/626179 was filed with the patent office on 2011-05-26 for method for extracting font metadata from font files into searchable metadata for package distribution.
This patent application is currently assigned to RED HAT, INC.. Invention is credited to Behdad Esfahbod, Richard Hughes, Andre Nicolas Mailhot.
Application Number | 20110126191 12/626179 |
Document ID | / |
Family ID | 44063048 |
Filed Date | 2011-05-26 |
United States Patent
Application |
20110126191 |
Kind Code |
A1 |
Hughes; Richard ; et
al. |
May 26, 2011 |
METHOD FOR EXTRACTING FONT METADATA FROM FONT FILES INTO SEARCHABLE
METADATA FOR PACKAGE DISTRIBUTION
Abstract
A package installer identifies a font package that facilitates
rendering a font of a file being opened by a user based on font
metadata downloaded from the remote server. The font metadata
includes information identifying one or more font packages
available for download from the remote server. Font metadata
associated with each font package further indicates one or more
fonts supported by the corresponding font package. A graphical user
interface (GUI) is displayed to the user prompting whether the user
desires to install the identified font package. The GUI further
indicates that an additional font needs to be installed in order to
view the file correctly. In response to an input from the user via
the GUI, the package installer downloads the font package from the
remote server for local installation.
Inventors: |
Hughes; Richard; (London,
GB) ; Esfahbod; Behdad; (Toronto, CA) ;
Mailhot; Andre Nicolas; (Paris, FR) |
Assignee: |
RED HAT, INC.
Raleigh
NC
|
Family ID: |
44063048 |
Appl. No.: |
12/626179 |
Filed: |
November 25, 2009 |
Current U.S.
Class: |
717/178 ;
715/269; 715/764 |
Current CPC
Class: |
G06F 9/453 20180201;
G06F 40/10 20200101; G06F 8/61 20130101; G06F 40/109 20200101; G06F
16/5854 20190101 |
Class at
Publication: |
717/178 ;
715/269; 715/764 |
International
Class: |
G06F 9/445 20060101
G06F009/445 |
Claims
1. A machine implemented method for installing a font for a file
distributed from a remote server, the method comprising:
identifying, by a package installer, a font package that
facilitates rendering a font of a file being opened by a user based
on font metadata downloaded from the remote server, the font
metadata having information identifying one or more font packages
available for download from the remote server, wherein font
metadata associated with each font package further indicates one or
more fonts supported by the corresponding font package; displaying
a graphical user interface (GUI) to the user prompting whether the
user desires to install the identified font package, the GUI
further indicating that an additional font needs to be installed in
order to view the file correctly; and in response to an input from
the user via the GUI, downloading, by the package installer, the
font package from the remote server for local installation.
2. The method of claim 1, further comprising: attempting, by the
file handler, to open a file requested from an application operated
by the user; and identifying, by the file handler, at least one
font of the requested file that is not recognized by the file
handler, wherein the GUI is displayed when there is at least one
unrecognized font identified.
3. The method of claim 2, further comprising: invoking the package
installer to identify the font package to be installed locally if
the file handler fails to recognize at least one font of the
requested file; and installing locally, by the package installer,
the font package downloaded from the remote server.
4. The method of claim 3, wherein prior to downloading the
identified font package, a distribution package having the font
package therein is created within the remote server, wherein font
metadata is extracted from the font package and inserted into the
distribution package, the font metadata includes information
identifying one or more fonts supported by the font package.
5. The method of claim 4, wherein the font metadata is inserted
into a header of the font package while a body of the font package
includes one or more font files, each font file corresponding to a
particular font.
6. The method of claim 5, wherein a copy of the font metadata of
the font package is stored in a font metadata file that also
contains font metadata of other font packages available for
download from the remote server.
7. The method of claim 2, further comprising periodically
downloading the font metadata from the remote server to retrieve
the latest font metadata available from the remote server.
8. A computer readable storage medium including instructions that,
when executed by a processing system, cause the processing system
to perform a method comprising: identifying, by a package
installer, a font package that facilitates rendering a font of a
file being opened by a user based on font metadata downloaded from
the remote server, the font metadata having information identifying
one or more font packages available for download from the remote
server, wherein font metadata associated with each font package
further indicates one or more fonts supported by the corresponding
font package; displaying a graphical user interface (GUI) to the
user prompting whether the user desires to install the identified
font package, the GUI further indicating that an additional font
needs to be installed in order to view the file correctly; and in
response to an input from the user via the GUI, downloading, by the
package installer, the font package from the remote server for
local installation.
9. The computer readable storage medium of claim 8, wherein the
method further comprises: attempting, by the file handler, to open
a file requested from an application operated by the user; and
identifying, by the file handler, at least one font of the
requested file that is not recognized by the file handler, wherein
the GUI is displayed when there is at least one unrecognized font
identified.
10. The computer readable storage medium of claim 9, wherein the
method further comprises: invoking the package installer to
identify the font package to be installed locally if the file
handler fails to recognize at least one font of the requested file;
and installing locally, by the package installer, the font package
downloaded from the remote server.
11. The computer readable storage medium of claim 10, wherein prior
to downloading the identified font package, a distribution package
having the font package therein is created within the remote
server, wherein font metadata is extracted from the font package
and inserted into the distribution package, the font metadata
includes information identifying one or more fonts supported by the
font package.
12. The computer readable storage medium of claim 11, wherein the
font metadata is inserted into a header of the font package while a
body of the font package includes one or more font files, each font
file corresponding to a particular font.
13. The computer readable storage medium of claim 12, wherein a
copy of the font metadata of the font package is stored in a font
metadata file that also contains font metadata of other font
packages available for download from the remote server.
14. The computer readable storage medium of claim 9, wherein the
method further comprises periodically downloading the font metadata
from the remote server to retrieve the latest font metadata
available from the remote server.
15. A system, comprising: a file handler to open a file in response
to a user request and to identify an unrecognized font of the file;
a package installer coupled to the file handler to identify a font
package that facilitates rendering a font of a file being opened by
a user based on font metadata downloaded from the remote server,
the font metadata having information identifying one or more font
packages available for download from the remote server, wherein
font metadata associated with each font package further indicates
one or more fonts supported by the corresponding font package; and
a display device coupled to the file handler and the package
installer to display a graphical user interface (GUI) to the user
prompting whether the user desires to install the identified font
package, the GUI further indicating that an additional font needs
to be installed in order to view the file correctly, wherein in
response to an input from the user via the GUI, the package
installer is configured to download the font package from the
remote server for local installation.
16. The system of claim 15, wherein the file handler attempts to
open a file requested from an application operated by the user and
to identify at least one font of the requested file that is not
recognized by the file handler, wherein the GUI is displayed when
there is at least one unrecognized font identified.
17. The system of claim 16, wherein the file handler is configured
to invoke the package installer to identify the font package to be
installed locally if the file handler fails to recognize at least
one font of the requested file, and wherein the package installer
to install locally the font package downloaded from the remote
server.
18. A machine-implemented method for distributing software
packages, the method comprising: scanning, by a package builder,
each font file contained in a font package file having a plurality
of font files packaged therein to extract font metadata associated
with each font file; inserting, by a package builder, the extracted
font metadata into the font package file, the font metadata
including information identifying one or more fonts supported by
the plurality of font files contained within the font package file;
storing, by a metadata manager, the extracted font metadata into a
font metadata file, wherein the font metadata file further includes
font metadata associated with other font package files available
for download; transmitting, by the metadata manager, the font
metadata file to a client over a network in response to a first
request for font metadata from the client; and transmitting, by the
package builder, a particular font package file to the client in
response to a second request for the particular font package file
from the client based on the font metadata, wherein the font
package file is to be installed at the client in response to a
failure to recognize at least one font of a particular file, and
wherein the transmitted font package file facilitates rendering the
unrecognized font.
19. The method of claim 18, wherein the font metadata is inserted
into a header of the font package file while a body of the package
file includes one or more actual font files.
20. The method of claim 18, wherein the font metadata file is
periodically updated in view of the font package files available
for download.
Description
TECHNICAL FIELD
[0001] Embodiments of the invention relate generally to the field
of software application distribution; and more particularly, to
extracting font metadata from font files into searchable metadata
for package distribution.
BACKGROUND
[0002] People often send other users documents and images. These
files are often of different formats or fonts, as a user could send
a Microsoft Word file (.doc file) or a GNU image manipulation
program (GIMP) image (.xcf) via email, instant messaging or even on
physical media.
[0003] Applications can view many different fonts and font scripts
in the same document. For example, a document can be created that
has right-to-left formatted Arabic script in one section and
left-to-right Latin script in another. Due to the nature of how
fonts are created and packaged, not all fonts contain all glyphs.
In addition, often font designers only do the minimum of
characters, such as a-z, A-Z and 1-9. Accented characters such as
`a` may not be included in the font set, and it is even less likely
that characters such as `` will be included. Only a few fonts are
installed by default on most operating system (OS) distributions as
the fonts are relatively large in size.
[0004] Typically in an application, the missing glyphs are shown as
black squares with hexadecimal numbers so that a user is aware that
some characters are not displayable or recognizable. One solution
is for the user to download and install additional fonts that have
the required glyphs, usually a specialist font for that language.
However, the user has to know what font to download, and it may
take the user a few attempts in order to get the right one. As a
result, the user has to stop what he/she is doing, and manually
search for and install the proper font packages.
BRIEF DESCRIPTION OF THE DRAWINGS
[0005] The present invention is illustrated by way of example and
not limitation in the figures of the accompanying drawings in which
like references indicate similar elements.
[0006] FIG. 1 is a block diagram illustrating a network
configuration according to one embodiment of the invention.
[0007] FIGS. 2A and 2B are block diagrams illustrating a package
file according to one embodiment of the invention.
[0008] FIG. 3 is screenshot illustrating an example of graphical
user interface (GUI) which may be used with one embodiment of the
invention.
[0009] FIG. 4 is a flow diagram illustrating a method for building
packages and metadata for download and installation according to
one embodiment.
[0010] FIG. 5 is a flow diagram illustrating a method for
installing packages according to one embodiment.
[0011] FIG. 6 illustrates a diagrammatic representation of a
machine in the exemplary form of a computer system according to one
embodiment.
DETAILED DESCRIPTION
[0012] In the following description, numerous details are set forth
to provide a more thorough explanation of the embodiments of the
present invention. It will be apparent, however, to one skilled in
the art, that embodiments of the present invention may be practiced
without these specific details. In other instances, well-known
structures and devices are shown in block diagram form, rather than
in detail, in order to avoid obscuring embodiments of the present
invention.
[0013] Reference in the specification to "one embodiment" or "an
embodiment" means that a particular feature, structure, or
characteristic described in connection with the embodiment is
included in at least one embodiment of the invention. The
appearances of the phrase "in one embodiment" in various places in
the specification do not necessarily all refer to the same
embodiment.
[0014] When a font package is packaged, each font includes one or
more font files (e.g., true type fonts or open type fonts). By
parsing the font files for glyph matches, each supported language
can be added as a virtual provide to the built font package. This
virtual provide is added to the distribution font metadata which
allows a remote program to query what font package supports a given
mime type by querying the font metadata. For example, in LINUX
operating environment, this can be done using a WhatProvides(
)method, typically using the PackageKit. An example query would be
WhatProvides(":lang=en_GB") which would return a list of all the
not-yet-installed font packages that would be used to view this
language text. By writing a script to extract the mime data at font
package build time, many virtual provides can be added just by
rebuilding all the font packages in a repository. A virtual provide
is a little piece of data about the package that resides in the
distribution metadata, and thus the package does not have to be
installed to query this data.
[0015] By integrating this application programmable interface (API)
into a default font renderer handler (in the case of LINUX, GNOME,
a fontconfig GTK module launched when the gnome-packagekit tools
are started at session start time), an experience can be provided
where when a user opens a document, an application such as a word
processor (e.g., Abiword) tries to view the file and a helper
provides a list of fonts the user can install to view the file
correctly. After the font packages are installed, the application
shows the correct text for the document. In this way a user can
send documents to remote users knowing that they will be able to
view the contents correctly.
[0016] FIG. 1 is a block diagram illustrating a network
configuration according to one embodiment of the invention.
Referring to FIG. 1, network configuration 100 includes a client
101 communicatively coupled to a server 102 over a network. Client
101 can be any kind of computing devices such as desktop, laptop,
personal digital assistant (PDA), or cellular phone, etc. Server
102 may include one or more computing devices such as a Web server
for distributing software packages, such as font packages, that can
be downloaded by client 101 over network 103. Network 103 may be
local area network (LAN) or a wide area network (WAN) such as the
Internet. Note that although one client and one server are shown in
FIG. 1, multiple clients and/or servers may also be
implemented.
[0017] In one embodiment, server 102 includes, among others, a
package builder 104 and metadata manager 105. Package builder 104
is configured to build (e.g., compile and/or link) and manage font
packages 106 that can be downloaded by client 101 for installation
at client 101. A font package is a single file having compressed
therein one or more font files. Once a font package is built,
according to one embodiment, the metadata manager 105 is configured
to scan each font file contained in the font package to extract
certain font metadata from each font file and insert the font
metadata into the font package. Alternatively, a font provider may
provide, together with a font file, a font description file
describing the corresponding font file. In this situation, in
addition to scanning the actual font file, the metadata manager may
also scan the font description file to extract the corresponding
font metadata. For example, when a font author made a mistake and
created a font file that says "I am FontX, Bold" when it is really
"FontXY, Bold", it is much simpler for a package builder to put a
file to be associated with the font file that tells an application
that "this font is really FontXY, Bold" rather than trying to
modify the actual font file. This also can reduce the possible
situations in which some of the glyphs in a font file are bad and
the metadata scanner is unable to recognize that certain resources
present in the font file are not usable by simply scanning the
actual font file. However, such information may be provided by a
font description file, which would allow a user to override the
information in a font file with the information extracted from the
font description file. The added font metadata includes information
indicating a particular font or fonts that are supported by the
associated font package.
[0018] The added font metadata is typically inserted into a header
of the font package, such as, for example, the font package file
200 as shown in FIG. 2A. Referring to FIG. 2A, font package file
200 includes a file header 201 and body 202. File header 201
includes font metadata 203 indicating that the font package file
supports fonts associated with certain languages. File body 202
includes all the individual font files contained in the package
200. As a result, when a file hander (e.g., file handler 112)
attempts to open a file having an unrecognized font, the file
handler can invoke a package installer (e.g., package installer
109) to query the font package to determine whether a particular
font is supported by the font package.
[0019] Referring back to FIG. 1, the package 200 can then be stored
in a storage device associated with server 102 as a part of
packages 106. In addition, metadata manager 105 is configured to
scan each of the font packages 106, to extract all the font
metadata from the font packages 106 (e.g., ":lang=pt" or
":lang=en_GB"), and to save all the font metadata to a font
metadata file as a part of font metadata file 107 in a storage
device. A font metadata file 107 may be an extensible markup
language (XML) compatible data file. This font metadata file 107 is
relatively small compared to the size of the font packages 106 as
it does not contain all the content data; it just contains all the
text font metadata. The font metadata file 107 is compressed and
saved in a storage device.
[0020] Note that the package builder 104 and the font packages 106
do not have to be on the same server as the font metadata 107. For
example, the font packages 106 can be built at another server or
facility, including the font metadata. The font packages 106 can
then be stored at a server accessible from a user network (e.g.,
Internet). The font metadata from individual font packages can then
be extracted (e.g., at the same server or another server). A
pointer is added in the extracted metadata referenced to a location
of those font packagers 106. The resultant extracted metadata can
then be published on a server accessible over a network. Thus,
server 106 could just be a distribution server that hosts the font
metadata 107, while another server or servers are used to host the
actual font packages. Also, it is useful to index font packages on
a master distribution server, and then to copy the font packages
and the extracted metadata indexes to another distribution server
or servers. Other configurations may also be implemented.
[0021] FIG. 2B is a block diagram illustrating an example of a font
metadata file. For example, font metadata file 250 may be
implemented as part of font metadata file 107. Referring to FIG.
2B, font metadata 250 includes metadata extracted from one or more
font packages. For example, metadata 251 includes information
identifying a first font package (e.g., "icelandic-fonts.rpm")
supporting certain languages (e.g., ":lang=pt" and ":lang=en_GB"),
while metadata 252 includes information identifying a second font
package (e.g., "british-fonts.rpm") supporting certain languages
(e.g., ":lang=en_GB"), etc. Note that in this example, the filename
may indicate a type of languages (e.g., British); however, some
other font filenames may not indicate anything at all, dependent
upon specific implementations. For example, a font can be used for
multiple languages, which could be identified by scanning the
corresponding metadata.
[0022] Referring back to FIG. 1, client 101 includes one or more
applications 108 (e.g., word processor) communicatively coupled to
a file handler 112, which provides an application programming
interface (API) to access one or more files 113 (e.g., word
document files). When application 108 attempts to open a file via
file handler 112, if file handler 112 cannot recognize a certain
font of the file that is being opened, the file handler 112 invokes
a package installer 109 to download one or more font packages
and/or the associated font metadata from server 102 over network
103. The resulting font packages 110 include one or more font files
that can be installed at client 101 in order to view certain fonts
of files 113 correctly.
[0023] According to one embodiment, when application 108 attempts
to open a file having a font that is not recognizable, package
installer 109 is invoked, for example, to "find me all font
packages that provide:lang=pt". The package installer 109 can
download the newest font metadata file 107 very quickly from server
102 because the font metadata is relatively small in size. The
package installer 109 then knows about every font package (e.g.,
font packages 106) available for installation from server 102.
Package installer 109 can scan the font metadata looking for
matches, and return a list to the user of the font packages that
match the search (e.g., available for installation for opening the
file with unrecognized font).
[0024] In one embodiment, when a user attempts to open a document
with an unknown font, the font installer (as a part of package
installer 109) displays a GUI 300 of FIG. 3 indicating that an
additional font needs to be installed. GUI 300 may also display a
message identifying a specific font that is required to view a
particular document.
[0025] In response to the GUI displayed, referring back to FIG. 1,
if the user actually wants to install identified font, the package
installer 109 has to match an identifier of the font to a remote
filename using the previously downloaded font metadata (e.g., font
metadata 111), and then download the font package itself (e.g.,
font packages 106). The user can then install the local font file
at client 101. In this way, the package installer 109 can
automatically locate the latest or a specific version of required
font files from server 102 and install them at client 101. As a
result, a user of client 101 does not need to know which font is
needed for opening a particular file and does not need to manually
conduct a search for the required font or fonts over the
network.
[0026] The font metadata 111 stored at the local system can be
periodically updated by downloading the newest font metadata 107
from server 102 onto the local client 101, and then searching
through the font metadata to determine if any of the remote font
packages are newer than the ones that have been installed locally.
In this way the font metadata 111 is kept up to date. Since the
font packages and font metadata are distributed by a centralized
server or servers 102, the client 101 can be sure that the font
packages downloaded and installed are the latest versions.
[0027] FIG. 4 is a flow diagram illustrating a method for building
font packages and font metadata for download and installation
according to one embodiment. Note that method 400 may be performed
by processing logic which may include software, firmware, hardware,
or a combination thereof. For example, method 400 may be performed
by package builder 104 and/or metadata manager 105 of FIG. 1.
Referring to FIG. 4, at block 401, multiple files (e.g., font
files) are packaged into a font package file, such as, for example,
a Red Hat package manager (RPM) file distributed by Red Hat, Inc.
of Raleigh, N.C. The font package can be built locally at the
distribution server or remotely at another server. At block 402,
each font file or the associated font description file in the font
package is scanned and certain font metadata is extracted and added
into the font package, where the font metadata identifies a
specific font or fonts supported by the font package or available
for download. At block 403, all font metadata extracted from the
package is stored in a font metadata file. Subsequently, in
response to a request from a client over a network requesting font
metadata, at block 404, the font metadata is transmitted to the
client. In response to receiving a further request for installing a
specific font package based on the font metadata file from the
client, at block 405, the requested font package is transmitted to
the client for opening a specific file that has an unrecognized
font by the client.
[0028] FIG. 5 is a flow diagram illustrating a method for
installing font packages according to one embodiment. Note that
method 500 may be performed by processing logic which may include
software, firmware, hardware, or a combination thereof. For
example, method 500 may be performed by package installer 109 of
FIG. 1. Referring to FIG. 5, in response to a request from a user
to open a file having an unrecognizable font, at block 501, a
request is transmitted to a remote server over a network requesting
font metadata. Note that if there is an existing font metadata
stored locally, the local font metadata may be examined first
before sending a request for an updated font metadata. As described
above, the font metadata may be periodically updated from the
remote server. At block 502, a font package is identified that is
capable of rendering the unrecognized font based on the font
metadata received from the remote server or alternatively, based on
a local copy of the font metadata. The font package may be
identified by matching font metadata extracted from the file being
opened and the font metadata stored in the font metadata file. At
block 503, a GUI is displayed to the user requesting whether the
user desires to download and install the required font package. In
response to an input received from the user via the GUI, at block
504, the identified font package is downloaded from the server and
installed at the client locally at block 505.
[0029] FIG. 6 illustrates a diagrammatic representation of a
machine in the exemplary form of a computer system 800 within which
a set of instructions, for causing the machine to perform any one
or more of the methodologies discussed herein, may be executed. In
alternative embodiments, the machine may be connected (e.g.,
networked) to other machines in a LAN, an intranet, an extranet,
and/or the Internet. The machine may operate in the capacity of a
server or a client machine in client-server network environment, or
as a peer machine in a peer-to-peer (or distributed) network
environment. The machine may be a personal computer (PC), a tablet
PC, a set-top box (STB), a Personal Digital Assistant (PDA), a
cellular telephone, a web appliance, a server, a network router, a
switch or bridge, or any machine capable of executing a set of
instructions (sequential or otherwise) that specify actions to be
taken by that machine. Further, while only a single machine is
illustrated, the term "machine" shall also be taken to include any
collection of machines that individually or jointly execute a set
(or multiple sets) of instructions to perform any one or more of
the methodologies discussed herein.
[0030] The exemplary computer system 800 includes a processor 802,
a main memory 804 (e.g., read-only memory (ROM), flash memory,
dynamic random access memory (DRAM) such as synchronous DRAM
(SDRAM), etc.), a static memory 806 (e.g., flash memory, static
random access memory (SRAM), etc.), and a data storage device 816,
which communicate with each other via a bus 808.
[0031] Processor 802 represents one or more general-purpose
processors such as a microprocessor, a central processing unit, or
the like. More particularly, the processor may be complex
instruction set computing (CISC) microprocessor, reduced
instruction set computing (RISC) microprocessor, very long
instruction word (VLIW) microprocessor, or processor implementing
other instruction sets, or processors implementing a combination of
instruction sets. Processor 802 may also be one or more
special-purpose processors such as an application specific
integrated circuit (ASIC), a field programmable gate array (FPGA),
a digital signal processor (DSP), network processor, or the like.
The processor 802 is configured to execute the instructions 830 for
performing the operations and steps discussed herein.
[0032] The computer system 800 may further include a network
interface device 822. The computer system 800 also may include a
video display unit 810 (e.g., a liquid crystal display (LCD) or a
cathode ray tube (CRT)), an alphanumeric input device 812 (e.g., a
keyboard), a cursor control device 814 (e.g., a mouse), and a
signal generation device 820 (e.g., a speaker).
[0033] The data storage device 816 may include a
computer-accessible storage medium 824 (also known as a
machine-readable storage medium or a computer-readable medium) on
which is stored one or more sets of instructions or software (e.g.,
packaging tool 830, which may be implemented as part of package
installer 109, package builder 104, and/or metadata manager 105)
embodying any one or more of the methodologies or functions
described herein. The packaging tool 830 may also reside,
completely or at least partially, within the main memory 804 and/or
within the processor 802 during execution thereof by the computer
system 800, the main memory 804 and the processor 802 also
constituting machine-accessible storage media. The packaging tool
830 may further be transmitted or received over a network via the
network interface device 822.
[0034] The computer-readable storage medium 824 may also be used to
store the packaging tool 830 persistently. While the
computer-readable storage medium 824 is shown in an exemplary
embodiment to be a single medium, the term "computer-readable
storage medium" should be taken to include a single medium or
multiple media (e.g., a centralized or distributed database, and/or
associated caches and servers) that store the one or more sets of
instructions. The terms "computer-readable storage medium" shall
also be taken to include any medium that is capable of storing or
encoding a set of instructions for execution by the machine and
that cause the machine to perform any one or more of the
methodologies of the present invention. The term "computer-readable
storage medium" shall accordingly be taken to include, but not be
limited to, solid-state memories, and optical and magnetic
media.
[0035] The modules 828, components and other features described
herein can be implemented as discrete hardware components or
integrated in the functionality of hardware components such as
ASICS, FPGAs, DSPs or similar devices. In addition, the modules 828
can be implemented as firmware or functional circuitry within
hardware devices. Further, the modules 828 can be implemented in
any combination hardware devices and software components.
[0036] In the above description, numerous details are set forth. It
will be apparent, however, to one skilled in the art, that the
present invention may be practiced without these specific details.
In some instances, well-known structures and devices are shown in
block diagram form, rather than in detail, in order to avoid
obscuring the present invention.
[0037] Some portions of the preceding detailed descriptions have
been presented in terms of algorithms and symbolic representations
of operations on data bits within a computer memory. These
algorithmic descriptions and representations are the ways used by
those skilled in the data processing arts to most effectively
convey the substance of their work to others skilled in the art. An
algorithm is here, and generally, conceived to be a self-consistent
sequence of operations leading to a desired result. The operations
are those requiring physical manipulations of physical quantities.
Usually, though not necessarily, these quantities take the form of
electrical or magnetic signals capable of being stored,
transferred, combined, compared, and otherwise manipulated. It has
proven convenient at times, principally for reasons of common
usage, to refer to these signals as bits, values, elements,
symbols, characters, terms, numbers, or the like.
[0038] It should be borne in mind, however, that all of these and
similar terms are to be associated with the appropriate physical
quantities and are merely convenient labels applied to these
quantities. Unless specifically stated otherwise as apparent from
the above discussion, it is appreciated that throughout the
description, discussions utilizing terms such as "identifying" or
"displaying" or "downloading" or "installing" or "invoking" or the
like, refer to the action and processes of a computer system, or
similar electronic computing device, that manipulates and
transforms data represented as physical (electronic) quantities
within the computer system's registers and memories into other data
similarly represented as physical quantities within the computer
system memories or registers or other such information storage,
transmission or display devices.
[0039] Embodiments of the present invention also relate to an
apparatus for performing the operations herein. This apparatus may
be specially constructed for the required purposes, or it may
comprise a general-purpose computer selectively activated or
reconfigured by a computer program stored in the computer. Such a
computer program may be stored in a computer readable medium. A
machine-readable medium includes any mechanism for storing or
transmitting information in a form readable by a machine (e.g., a
computer). For example, a machine-readable (e.g.,
computer-readable) medium includes a machine (e.g., a computer)
readable storage medium (e.g., read only memory ("ROM"), random
access memory ("RAM"), magnetic disk storage media, optical storage
media, flash memory devices), etc.
[0040] The algorithms and displays presented herein are not
inherently related to any particular computer or other apparatus.
Various general-purpose systems may be used with programs in
accordance with the teachings herein, or it may prove convenient to
construct more specialized apparatus to perform the required method
operations. The required structure for a variety of these systems
will appear from the description above. In addition, embodiments of
the present invention are not described with reference to any
particular programming language. It will be appreciated that a
variety of programming languages may be used to implement the
teachings of embodiments of the invention as described herein.
[0041] In the foregoing specification, embodiments of the invention
have been described with reference to specific exemplary
embodiments thereof. It will be evident that various modifications
may be made thereto without departing from the broader spirit and
scope of embodiments of the invention as set forth in the following
claims. The specification and drawings are, accordingly, to be
regarded in an illustrative sense rather than a restrictive
sense.
* * * * *