U.S. patent application number 13/108617 was filed with the patent office on 2011-11-17 for system and method for platform and language-independent development and delivery of page-based content.
This patent application is currently assigned to Sony Pictures Entertainment Inc.. Invention is credited to Omar Hamoui, Andreas Hjelming, Todd Hollenbeck, Galvin Hsui, Armando Pena, Leslie Spring.
Application Number | 20110283207 13/108617 |
Document ID | / |
Family ID | 29586476 |
Filed Date | 2011-11-17 |
United States Patent
Application |
20110283207 |
Kind Code |
A1 |
Pena; Armando ; et
al. |
November 17, 2011 |
SYSTEM AND METHOD FOR PLATFORM AND LANGUAGE-INDEPENDENT DEVELOPMENT
AND DELIVERY OF PAGE-BASED CONTENT
Abstract
A system and method for platform and language-independent
delivery of page-based content. Content defined in a relatively
abstract format is rendered into multiple platform formats in
client-side applications' user interfaces in multiple human
languages. The relatively abstract format is a subset of XML and is
used to define user interface elements to be displayed on a page. A
Model-View-Controller architecture is implemented comprising a
plurality of servlet filters, a servlet pipeline and a plurality of
rendering processors for client detection, client tracking,
relatively abstract format preprocessing, relatively abstract
format processing and validating, and transforming and rendering of
the relatively abstract format into multiple platform formats in
client-side applications' user interfaces in multiple human
languages. A creation, modification and management tool is also
disclosed for creating, modifying and managing platform and
language-independent page-based content.
Inventors: |
Pena; Armando; (Los Angeles,
CA) ; Spring; Leslie; (Los Angeles, CA) ;
Hjelming; Andreas; (Los Angeles, CA) ; Hsui;
Galvin; (Los Angeles, CA) ; Hollenbeck; Todd;
(Los Angeles, CA) ; Hamoui; Omar; (Los Angeles,
CA) |
Assignee: |
Sony Pictures Entertainment
Inc.
Culver City
CA
Sony Corporation
Tokyo
|
Family ID: |
29586476 |
Appl. No.: |
13/108617 |
Filed: |
May 16, 2011 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
12348815 |
Jan 5, 2009 |
7970944 |
|
|
13108617 |
|
|
|
|
10262600 |
Sep 30, 2002 |
7490167 |
|
|
12348815 |
|
|
|
|
60383338 |
May 22, 2002 |
|
|
|
Current U.S.
Class: |
715/763 |
Current CPC
Class: |
G06F 16/957
20190101 |
Class at
Publication: |
715/763 |
International
Class: |
G06F 3/048 20060101
G06F003/048 |
Claims
1.-81. (canceled)
82. A user interface for use with a content creation, modification
and management system, comprising a user interface (UI) elements
list interface including means for displaying user interface (UI)
elements representing content stored in at least one data source in
a relatively abstract format.
83. The user interface recited in claim 82, further comprising:
means for searching the user interface (UI) elements according to
designated search criteria; means for sorting the user interface
(UI) elements by categories; means for linking the user interface
(UI) elements to editing interfaces; and means for adding selected
user interface (UI) elements to a publishing list.
84. The user interface recited in claim 82, further comprising:
means for creating new user interface (UI) elements; and means for
deleting selected user interface (UI) elements.
85. The user interface recited in claim 82, further comprising: a
"View/Edit" user interface (UI) elements interface comprising:
means for viewing and editing user interface (UI) elements; and
means for saving new and edited user interface (UI) elements to the
at least one data source as content in a relatively abstract
format.
86. The user interface recited in claim 85, further comprising
means for entering metadata to be associated with selected user
interface (UI) elements including at least one of a name, a
description, content, filepath, filename and text, wherein the user
interface (UI) elements are saved along with the associated
metadata.
87. The user interface recited in claim 82, wherein the user
interface (UI) elements include at least one of user interface (UI)
components, actions, copy, and rendering elements.
88. The user interface recited in claim 82, wherein the user
interface (UI) elements are user interface (UI) components and
further comprising means for determining whether the user interface
(UI) components are referenced by other user interface (UI)
components.
89. The user interface recited in claim 88, further comprising a
"Verify" user-selectable operator selectable for updating the
status field.
90. The user interface recited in claim 85, wherein the user
interface (UI) elements include at least one of user interface (UI)
components and actions and further comprising a relatively abstract
format editing window for editing relatively abstract format
code.
91. The user interface recited in claim 82, wherein the categories
include at least one of name, description, status, text,
identification (ID), language, renderer, file type, size, item ID,
and UI element type.
92. The user interface recited in claim 87, wherein the actions
include embedded data for defining links to user interface (UI)
elements including at least one of sub-actions, copy, assets, and
rendering elements.
93. The user interface recited in claim 85, wherein the user
interface (UI) elements include copy elements and further
comprising a copy text editing window for editing copy text.
94. The user interface recited in claim 93, wherein at least two
items of copy text are associated with a named copy element.
95. The user interface recited in claim 93, further comprising
means for selecting one or more languages for which the copy text
will be used during rendering.
96. The user interface recited in claim 93, further comprising
means for selecting one or more renderers for rendering the copy
text.
97. The user interface recited in claim 94, wherein the rendering
elements contain contextual information for displaying content
within a page defined in the relatively abstract format.
98. The user interface recited in claim 92, wherein the rendering
elements include subsets of rendering elements including at least
one of rendering resources and rendering primitives.
99. The user interface recited in claim 92, wherein the rendering
elements include at least one sub-item grouped by at least one of
file, language and renderer.
100. The user interface recited in claim 85, wherein the user
interface (UI) elements include rendering elements and further
comprising means for selecting one or more languages for which the
rendering element will be used during rendering.
101. The user interface recited in claim 85, wherein the user
interface (UI) elements include rendering elements and further
comprising means for selecting one or more renderers for rendering
the rendering element.
102. The user interface recited in claim 82, further comprising a
files list interface including means for displaying files list in
the at least one data source.
103. The user interface recited in claim 102, further comprising:
means for searching the files according to designated search
criteria; means for sorting the files by categories; means for
linking the files to editing interfaces; and means for adding
selected files to a publishing list.
104. The user interface recited in claim 102, further comprising:
means for creating new files; and means for deleting selected
files.
105. The user interface recited in claim 102, further comprising: a
"View/Edit" files interface comprising: means for viewing and
editing files; and means for saving new and edited files to the at
least one data source.
106. The user interface recited in claim 105, further comprising
means for entering metadata to be associated with selected files
including at least one of a name, a description, content, filepath,
and a filename, wherein the files are saved along with the
associated metadata.
107. The user interface recited in claim 82, further comprising a
publishing list interface including means for displaying publishing
list items.
108. The user interface recited in claim 107, further comprising
means for moving publishing list items from the at least one data
source to at least one other data source.
109. The user interface recited in claim 108, further comprising
means for selecting the at least one other data source.
110. The user interface recited in claim 107, further comprising:
means for sorting the publishing list items by categories; and
means for linking the publishing list items to editing
interfaces.
111. The user interface recited in claim 107, further comprising
means for determining a publication status of the publishing list
items.
112. The user interface recited in claim 107, further comprising
means for removing selected publishing list items from the
publishing list interface.
113. The user interface recited in claim 107, further comprising
means for removing all publishing list items from the publishing
list interface.
114. The user interface recited in claim 82, further comprising a
"View/Edit" configuration interface for setting global
configuration data for the content creation, modification and
management system.
115. The user interface recited in claim 114, wherein the global
configuration data includes at least one of IP addresses for
various environments in a publishing pipeline and root file system
paths used to create and manage relative file path data for file
objects within the at least one data source.
116. The user interface recited in claim 114, further comprising
means for setting an error checking level that is applied whenever
at least one of a user interface (UI) component and action is saved
to the at least one data source.
117. The user interface recited in claim 116, wherein the error
checking level includes at least one of ignoring errors, warning
about errors and trapping errors.
118. The user interface recited in claim 114, further comprising
means for selecting for direct editing at least one of an active
environment and a data source environment.
119. The user interface recited in claim 115, further comprising
means for entering an IP address, wherein the IP address defined a
location of instances of services of the content creation,
modification and management system for each stage in the publishing
pipeline.
120. The user interface recited in claim 119, wherein the system
services are a set of Simple Object Access Protocol (SOAP)-based
APIs enabling at least one of the content creation, modification
and management system and network enabled devices to communicate
with the at least one data source in a controlled and well defined
manner.
121. The user interface recited in claim 115, wherein the
publishing pipeline includes multiple stages and wherein for each
stage in the publishing pipeline, a disk-based file system is used
to store physical files that are used by the content creation,
modification and management system.
122. The user interface recited in claim 121, wherein relative file
paths are stored in file objects in the at least one data source
and wherein the user interface further comprises means for entering
root file paths of at least one of an active environment and a
source environment for searching and selecting files in the at
least one of an active environment and a source environment.
123. The user interface recited in claim 122, wherein when files
are selected, the root file paths are stripped from full file paths
of the file to provide the relative file paths, the relative file
paths being saved to the at least one data source.
124. The user interface recited in claim 82, further comprising
means for applying changes made in the user interface.
Description
BACKGROUND OF THE INVENTION
[0001] 1. Field of the Invention
[0002] The present invention relates generally to transfer of
content between a server and multiple network enabled client
devices operating on different platforms over a network such as the
Internet, and more particularly to rendering content in a
relatively abstract format into multiple platform formats in
client-side applications' user interfaces in multiple human
languages.
[0003] 2. Description of Related Art
[0004] The popularity of the Internet has engendered a number of
devices having a capability for providing access to the Internet.
As illustrated in FIG. 1, such devices include desktop and laptop
computers, cellular phones and personal digital assistants
("PDAs"). The various different types of network enabled devices
("NEDs") may each operate with a different platform format
("platform"), for example by operating with different web-based or
non-web-based browser types.
[0005] The term "content" is used herein to refer to all forms of
electronic content (i.e., content that may be read or processed in
an electronic form), including, but not limited to, digital video,
audio, photos, graphics, text and animation. When a provider of
content desires to provide to different platforms access to the
content, the provider may be required to build, for example, custom
web pages or other content containing pages for each specific
platform format. That is, the provider would need to provide pages
or other content resources formatted in HyperText Markup Language
("HTML"), Wireless Markup Language ("WML"), compact HTML ("cHTML"),
and so on, to conform to the device/browser display capabilities.
This is both labor intensive to initially setup and difficult to
maintain as changes are made to the site's data and services.
[0006] Therefore, it can be seen that there is a need for a system
and method for accepting content defined in a relatively abstract
format and transforming the relatively abstract format input into a
specific recognized platform format for a particular device.
SUMMARY OF THE DISCLOSURE
[0007] Therefore, embodiments of the present invention provide a
system and method for platform and language-independent delivery of
page-based content.
[0008] Embodiments of the present invention provide a system and
method for accepting content defined in a relatively abstract
format and transforming the relatively abstract format input into a
specific recognized platform format for a particular device.
[0009] Embodiments of the present invention further provide a
system and process for creating, modifying and managing platform
and language-independent page-based content.
[0010] Embodiments of the present invention further provide a
relatively abstract format for defining content in a data source.
The relatively abstract format may be transformed into multiple
platform formats in client-side applications' user interfaces in
multiple human languages.
[0011] In one embodiment, a system and method for platform and
language-independent delivery of page-based content implements a
Model-View-Controller architecture comprising a plurality of
servlet filters, a servlet pipeline and a plurality of rendering
processors for client detection, client tracking, relatively
abstract format preprocessing, relatively abstract format
processing and validating, and transforming and rendering of the
relatively abstract format into multiple platform formats in
client-side applications' user interfaces in multiple human
languages.
[0012] In another embodiment, a system and method for platform and
language-independent delivery of page-based content implements
creation, modification and management tool that allows a creator or
publishing team to create, modify, and manage platform and
language-independent page-based content. The page-based content can
then be viewed and interacted with by end-users, with embodiments
of the system and method for platform and language-independent
delivery of page-based content being used to display the same
content on multiple platforms, and in multiple languages.
[0013] In yet another embodiment, a format in the form of an
interface definition mark-up language ("IDML") is provided for
defining a relatively abstract format to be transformed into
multiple platform formats in client-side applications' user
interfaces in multiple human languages. In one embodiment, IDML is
a subset of eXstensible Mark-up Language ("XML") and may be fully
compliant with all XML standards. IDML is used to define user
interface elements within embodiments of the system and method for
platform and language-independent delivery of page-based content.
Keywords and rules are defined for IDML which allow a user to
accurately specify a user interface to be rendered by a rendering
group within the system for platform and language-independent
delivery of page-based content.
[0014] These and other features, and advantages of embodiments of
the invention will be apparent to those skilled in the art from the
following detailed description of embodiments of the invention,
when read with the drawings and appended claims.
BRIEF DESCRIPTION OF THE DRAWINGS
[0015] Referring now to the drawings in which like reference
numbers represent corresponding parts throughout:
[0016] FIG. 1 illustrates a number of devices having a browser or
user agent capability communicating with a server over the
Internet;
[0017] FIG. 2 illustrates an exemplary hardware/software
environment wherein, embodiments of the system and process of the
present invention may be employed;
[0018] FIG. 3 illustrates a network environment where a server
communicates with various network enabled devices, each having a
platform-specific language for displaying content within a
browser/user agent, according to embodiments of the present
invention;
[0019] FIG. 4 illustrates an exemplary web page for display on a
client network enabled device, according to embodiments of the
present invention;
[0020] FIG. 5 shows a simplified block diagram illustrating an
exemplary pipeline for platform and language-independent delivery
of page-based content, according to embodiments of the present
invention;
[0021] FIGS. 6A through 6D show exemplary rendering elements that
may be used to populate pages, according to embodiments of the
present invention;
[0022] FIG. 7 shows a high level block diagram illustrating a
server-side backend system for platform and language-independent
delivery of page-based content, according to embodiments of the
present invention;
[0023] FIG. 8 shows a diagram illustrating the functions of an MVC
architecture, according to embodiments of the present
invention;
[0024] FIG. 9 shows a simplified block diagram of a system
including web tier, according to embodiments of the present
invention;
[0025] FIG. 10 shows a flowchart illustrating an HTTP request flow,
according to embodiments of the present invention;
[0026] FIG. 11 shows a simplified block diagram of a system,
showing a relation of a data service layer to a web tier and
database on a server side, and client network-enabled devices and a
.Net client tool on the client side, according to embodiments of
the present invention;
[0027] FIG. 12 shows an exemplary schema of a database for storing
rendering elements, action elements, UI elements and copy,
according to embodiments of the present invention;
[0028] FIG. 13 shows a simplified block diagram of a mark-up
language rendering group within web tier, along with a database and
a data service layer, according to embodiments of the present
invention;
[0029] FIG. 14 shows a simplified block diagram of a Flash
rendering group, along with a database, a data service layer and a
web tier, according to embodiments of the present invention;
[0030] FIG. 15 shows an example IDML document structure, according
to embodiments of the present invention;
[0031] FIG. 16 shows an exemplary UI components list interface,
according to embodiments of the present invention;
[0032] FIG. 17 shows an exemplary "View/Edit" UI component
interface, according to embodiments of the present invention;
[0033] FIG. 18 shows an exemplary actions list interface, according
to embodiments of the present invention;
[0034] FIG. 19 shows an exemplary "View/Edit" action interface,
according to embodiments of the present invention;
[0035] FIG. 20 shows an exemplary copy list interface, according to
embodiments of the present invention;
[0036] FIG. 21 shows an exemplary "View/Edit" copy interface,
according to embodiments of the present invention;
[0037] FIG. 22 shows an exemplary rendering elements list
interface, according to embodiments of the present invention;
[0038] FIG. 23 shows an exemplary "View/Edit" rendering elements
interface, according to embodiments of the present invention;
[0039] FIG. 24 shows an exemplary files list interface, according
to embodiments of the present invention;
[0040] FIG. 25 shows an exemplary "View/Edit" files interface,
according to embodiments of the present invention;
[0041] FIG. 26 shows an exemplary publishing list interface,
according to embodiments of the present invention;
[0042] FIG. 27 shows an exemplary "View/Edit" file configuration
interface, according to embodiments of the present invention.
DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION
[0043] In the following description of embodiments of the
invention, reference is made to the accompanying drawings which
form a part hereof, and in which is shown by way of illustration
specific embodiments in which the invention may be practiced. It is
to be understood that other embodiments may be utilized and
structural changes may be made without departing from the scope of
embodiments of the present invention.
[0044] As discussed above, the present invention relates generally
to a system and process for transferring content between a server
and multiple network enabled client devices operating on different
platforms over a network such as the Internet. Embodiments of the
present invention address the need for a system and method for
accepting content defined in a relatively abstract format and
transforming the relatively abstract format input into a recognized
platform format specific for a particular device.
[0045] A system and process for platform and language-independent
delivery of page-based content, according to embodiments of the
present invention, may be used with various types of
hardware/software combinations. FIG. 2 illustrates an exemplary
hardware/software environment 200 wherein embodiments of the system
and process of the present invention may be employed.
[0046] The system 200 may include a computer workstation 202, a
computer monitor 204, and input devices such as a keyboard 206, and
mouse 208. The workstation 102 may also include input/output
interfaces 212, storage 214, such as a disk 216 and random access
memory (RAM) 218, as well as one or more processors 220. The
workstation 102 may be a computer workstation such as a Windows
NT-type workstation or other suitable computer or computers. The
computer monitor 204, keyboard 206, and mouse 208, as well as other
input devices such as, but not limited to, video tape recorders,
cameras, and hardware accelerators (not shown) may be used to
interact with various software elements of the system residing in
the memory of the workstation 202 to cause processes to be
performed on data. The system 200 in FIG. 2 is shown by way of
illustration and not limitation. Other systems may be used to
implement embodiments of the invention.
[0047] System and device functions and processes described herein
may be implemented with machine-executable instructions. Software
comprising these instructions may be used to program and cause
general-purpose or special-purpose processors to perform the
functions and processes described herein. Alternatively, such
functions and processes may be implemented by firmware, hardware
comprising hardwired logic, or by any combination thereof.
[0048] Embodiments of the invention may be employed in a network
environment where a server communicates with various network
enabled devices (NEDs), each having a platform-specific language
for displaying content within a browser or user agent. Such a
network environment 300 is shown in FIG. 3. Content 302 is provided
via web server 304 and the Internet 306 to NEDs 308, 310 and 312,
each of which may operate with different platforms, for example
HTML, cHTML, WML and so on.
[0049] Embodiments of the invention may be employed with systems
and methods described in co-pending U.S. utility patent
applications entitled "Media Content Creating and Publishing System
and Process," Ser. No. 09/906,024, filed Jul. 13, 2001, "Content
Management System and Process," Ser. No. 09/906,023, filed Jul. 13,
2001, and "Dynamic Graphical Index Of Website Content," Ser. No.
09/915,608, filed Jul. 26, 2001, the content of all of which is
incorporated by reference herein.
[0050] FIG. 4 shows an exemplary web page for display on a client
NED. The exemplary tool application page 400 shown in FIG. 4
provides media creation and editing tools and digital assets that
may be used to create and edit various media. Tool application page
400 comprises tool application area 402, "experience" channel area
404, (comprising user-selectable operators 410 (action), 412
(comedy), 414 (drama), 416 (music), and 418 (science fiction) for
selecting a genre of media content), a "create" user-selectable
operator 406, a "connect" user-selectable operator 408, interactive
advertising space 420, and menu area 422.
[0051] Tool application page 400 may further comprise promotes for
additional tools, such as tool promotes 424, 426, and 428. Tool
application page 400 may also further comprise promotes for
additional asset packs, such as asset pack promotes 430 and 432.
Tool application page 400 may further comprise user-selectable
operators that activate ("launch") tool poppers containing
additional media content creating and editing functionality.
[0052] According to embodiments of the present invention, tool
application page 400 is created with a creation tool that allows a
creator or publishing team to create, modify, and manage platform
and language-independent page-based, graphic, or other content. The
page-based content can then be viewed and interacted with by
end-users on multiple platforms (such as, but not limited to, HTML,
cHTML, WML and Flash), and in multiple human languages (such as,
but not limited to, English, Spanish and Japanese) by rendering
content in a relatively abstract format into multiple platforms and
multiple human languages in user interfaces of client-side
applications.
[0053] In one embodiment, a system and method for platform and
language-independent delivery of page-based content uses a separate
"thin" rendering group for each supported platform, allowing common
user interface ("UI") elements to be shared by multiple platforms
and hardware devices. In other embodiments, a system and method for
platform and language-independent delivery of page-based content
alternatively, or in addition, operates in cooperation with one or
more client-side platform renderers such as, but not limited to, a
Windows application renderer, a Flash renderer and a Playstation 2
("PS2") renderer.
[0054] In one embodiment, the common UI elements may comprise
rendering elements, action elements and UI elements, and copy
elements (titles, paragraphs, etc.) that are used to populate pages
such as tool application page 400 shown in FIG. 4. The common UI
elements may be defined in a relatively abstract format and stored
in a system database. The common UI elements defined in the
relatively abstract format may be accessed by client-side devices
via a system server. The common UI elements in the relatively
abstract format are then transformed by embodiments of the
invention's system and method into multiple platform formats in
client-side applications' user interfaces in multiple human
languages.
[0055] Alternatively, or in addition, the common UI elements or
other data in a relatively abstract format may be obtained from
other data sources besides a system database, including, but not
limited to, another application external to the system itself. As
an example, a shopping cart application could write data in a
relatively abstract format back to the system and the system could
then render it and return it to the shopping cart application in a
particular platform format. As another example, a NED such as a
Bluetooth-enabled digital camera may receive a user interface from
an application on a host computer, enabling the camera to upload
pictures to an external storage device. Furthermore, content may be
provided from multiple data sources using, for example, rendering
dynamic XSLT. The multiple data sources may include, but are not
limited to, databases, 3rd party applications, or any other source
that generates data in a relatively abstract format.
[0056] In one embodiment, the relatively abstract format may be a
proprietary interface definition mark-up language ("IDML"). IDML
may be a subset of XML and may be fully compliant with all XML
standards. However, in other embodiments, the system and method for
platform and language-independent delivery of page-based content
may be modified such that IDML may be defined by other generalized
mark-up languages such as, but not limited to, Standard Generalized
Markup Language ("SGML").
[0057] FIG. 5 shows a simplified block diagram illustrating an
exemplary pipeline for platform and language-independent delivery
of page-based content, according to embodiments of the present
invention. As illustrated by the block diagram shown in FIG. 5, in
one embodiment the UI elements 506, 508 and 510 stored in a
database are specified in the relatively abstract format during
preprocessing and recursion 512. UI elements 506, 508 and 510 are
then rendered into various desired client platforms, for example
Flash client 520, HTML client 522 and any other supported platform
("Any Platform") client 524. In the case of thin clients such as
HTML client 522, the UI elements 506, 508 and 510 defined in the
relatively abstract format may be received by HTML rendering group
516, which renders the UI elements 506, 508 and 510 into the HTML
client platform. Thick clients such as Flash client 520 may
comprise a Flash rendering group 514 that may receive the UI
elements 506, 508 and 510 in the relatively abstract format and
render them into SWF files. In the case of Any Platform client 524
(representing additional supported client platforms such as, but
not limited to, Clie', PS2, and Wireless Application Protocol
("WAP") enabled devices), "Any Platform" rendering group 518 may
receive the UI elements 506, 508 and 510 defined in the relatively
abstract format and render them into the desired "Any Platform"
client platform.
[0058] During preprocessing and recursion 512, a complete page or
other content resource in the relatively abstract format is
assembled from the individual UI elements 506, 508 and 510. In
addition, names of the rendering elements and copy, for example
business names, are resolved based on the client platform and
language. Rendering groups are responsible for translating the
relatively abstract format into the target platform. According to
embodiments of the present invention, one rendering group may be
required for each target platform.
[0059] In one embodiment, rendering elements are the set of
rendering primitives/collections and rendering resources which make
up the pages. Rendering primitives/collections may be platform
specific while rendering resources may be both platform and human
language specific. Rendering elements may be associated with a name
and rendering platform. Rendering resources will additionally be
associated with a human language.
[0060] The rendering primitives may be the actual functional
elements of the pages. "Rendering primitives" may actually include
both primitives and collections. The distinction is that a
collection can contain one or more primitives/collections along
with resources and copy, while a primitive can only contain
rendering resources and copy, but not other primitives. Collections
contain areas called render locations which are the actual areas
that other copy, resources, primitives and collections can
recursively be placed. Primitives also have render locations, but
only copy or resources can be placed in those render locations. A
page or other content resource is considered complete when all
render locations have been filled. An example of a rendering
primitive/collection 434 is shown on tool application page 400
shown in FIG. 4.
[0061] The rendering resources may be the graphical elements that
are used in the pages. Typically this would consist of backgrounds,
button skins, images, animations, and any other graphical elements
in the pages. Rendering resources are defined by a name and they
are language and platform specific.
[0062] Action elements and UI elements may be the set of
generalized mark-up language code, for example XML code, that
defines and parameterizes the pages. According to one embodiment,
UI IDML is used to parameterize the actual UI. Action IDML is used
to parameterize any actions that are taken on the pages. IDML
actions allow a user to, for example, navigate and view web-based
content, including, but not limited to, UI "pages/content
resources" and various media. Actions may also allow users to
submit data for processing to a receiving device. Thus, according
to embodiments of the present invention, actions on a page may be
abstracted as well as the rendered UI of the page.
[0063] Copy is the set of localized text (titles, paragraphs, etc.)
that will be displayed in the pages. Copy will be associated with a
name and rendering platform as well as a human language.
[0064] FIGS. 6A, 6B, 6C and 6D show exemplary rendering elements
that may be used to populate, for example, tool promotes 424, 426,
and 428 or asset pack promotes 430 and 432 of the tool application
page 400 shown in FIG. 4. As shown in FIGS. 6A through 6D, the
rendering elements may be displayed in various platform formats
(Flash, HTML, cHTML, WML, etc.) and in various human languages
(English, Spanish, Japanese, etc.).
[0065] FIG. 7 shows a high level block diagram illustrating a
server-side backend system 700 for platform and
language-independent delivery of page-based content, according to
an embodiment of the present invention. According to embodiments of
the present invention, the server-side backend system 700 may be
implemented in Java.TM. Enterprise Edition ("J2EE.TM."). According
to other embodiments, the server-side backend system 700 may be
implemented in any other suitable server-side programming language,
including, but not limited to, Microsoft.TM. .NET, Visual Basic, C,
C++, Perl, Python, ADA, C#, Common Lisp, Dylan, Eiffel, Elastic C,
Modula 3, SMALLTALK, Mesa, and Tcl/TK.
[0066] The system essentially comprises three levels: a first level
is a database 702 which may store content "logical assets" and
associated metadata defining logical asset attributes. In one
embodiment, the logical assets are defined in IDML. The logical
assets may include, but are not limited to, rendering elements,
action elements and user interface ("UI") elements and copy.
[0067] The second level of the high level block diagram is a data
service layer 704 which may comprise an object bridge layer that
relates data tables to objects, enterprise Java bean ("EJB") schema
domain managers that provide standardized logic to different
application servers and a Simple Object Access Protocol ("SOAP")
interface that allows HTTP commands to be invoked.
[0068] The third level of the high level block diagram is a web
tier 706 which supports multiple client platforms. Types of
platforms supported by the web tier 706 include thin client
platforms such as, but not limited to, HTML, cHTML and WAP. Web
tier 706 further supports thick client platforms such as, but not
limited to, Windows applications, Flash and Playstation 2 ("PS2").
Due to this multiple client platform support capability, changes to
the page flow and presentation requires low maintenance for
software development. In addition, web tier 706 is extensible,
scalable and fault tolerant with regards to state.
[0069] First, web tier 706 will be described in more detail. Web
tier 706, according to one embodiment, uses a known
Model-View-Controller ("MVC") architecture which divides
applications into three layers--model, view, and controller--and
de-couples their respective responsibilities. A diagram
illustrating the functions of an MVC architecture 800 is shown in
FIG. 8.
[0070] Each of the three layers handle specific tasks and has
specific responsibilities relative to the other layers. As shown in
the diagram of FIG. 8, a model 802 may represent business data and
business logic or operations that govern access and modification of
this business data. Often the model 802 serves as a software
approximation to real-world functionality. The model 802 notifies
views when it changes and provides the ability for the view to
query the model 802 about its state. It also provides the ability
for the controller 806 to access application functionality
encapsulated by the model 802.
[0071] A view 804 renders the contents of a model. It accesses data
from the model 802 and specifies how that data should be presented.
It updates data presentation when the model 802 changes. A view 804
also forwards user input to the controller 806.
[0072] The controller 806 defines application behavior. It
dispatches user requests and selects views for presentation. It
interprets user inputs and maps them into actions to be performed
by the model 802. In a stand-alone GUI client, user inputs may
include, for example, button clicks and menu selections. In a Web
application, user inputs may include, for example, HTTP GET and
POST requests to the Web tier. The controller 806 selects the next
view to display based on the user interactions and the outcome of
the model operations. An application typically has one controller
for each set of related functionality. Some applications use a
separate controller for each client type, because view interaction
and selection often vary between client types.
[0073] In software development, most of the high costs of ownership
are not associated with construction (i.e. coding an application),
but maintenance. As business requirements change over time, any
changes to an existing software system will introduce some level of
risk. The adoption of an MVC architecture for the web tier 706
separates responsibilities among model, view, and controller
objects, reduces code duplication and makes applications easier to
maintain. It also makes handling data easier, whether adding new
data sources or changing data presentation, because business logic
is kept separate from data. It is easier to support new client
types, because it is not necessary to change the business logic
with the addition of each new type of client.
[0074] FIG. 9 shows a simplified block diagram of a system 900
including web tier 706, according to embodiments of the present
invention. Web tier 706 is shown as a part of a server side
application in communication with a client network-enabled device
("NED") 902.
[0075] According to embodiments of the present invention, web tier
706 may comprise three parts: servlet filters 904, servlet pipeline
906 and rendering processors 908. These software components work
together to determine the type of client and its specification (for
example, HTML or WAP), store client side information per user and
transform a single input in a relatively abstract format such as,
but not limited to, an IDML format, for platform-specific
display.
[0076] An HTTP request flow 1000, according to embodiments of the
present invention, will now be described in a general manner with
reference to the simplified block diagram of FIG. 9 and the
flowchart shown in FIG. 10. An HTTP request is issued from the user
via NED 902 at S1002. The client-side application may have a "user
agent" or header that is passed to the server which maps to the
right language and platform. Or a user may manually enter the
language and platform information themselves or a client-side or
server-side application may be provided to do this. The HTTP
request is detected by the servlet filters 904 at S1004, and a
determination of a client platform is made and user tracking is
performed. At S1006, the HTTP request is processed in the servlet
pipeline 906 for delegation and rendering. At S1008, the HTTP
request is processed individually by the rendering processor
components. At S1010, the HTTP request is rendered back to the
user's NED 902 according to the user's client platform and human
language.
[0077] The operation and inter-operation of the servlet filters
904, servlet pipeline 906 and rendering processors 908, according
to embodiments of the present invention, will now be described in
more detail. A servlet filter is an object that can transform a
request or modify a response. A servlet filter is not a servlet,
i.e., a servlet filter doesn't actually create a response. Instead,
they are preprocessors of the request before it reaches a servlet,
and/or postprocessors of the response leaving a servlet. A servlet
filter can intercept a servlet's invocation before the servlet is
called. In addition, a servlet filter can examine a request before
a servlet is called and modify the request headers and request data
by providing a customized version of the request object that wraps
the real request. Furthermore, a servlet filter can modify the
response headers and response data by providing a customized
version of the response object that wraps the real response. Also,
a servlet filter can intercept a servlet's invocation after the
servlet is called.
[0078] In the system and method for platform and
language-independent delivery of page-based content according to
embodiments of the present invention, a series of servlet filters
904 acts on the struts controller gateway servlet 920 in the
servlet pipeline 906. In one embodiment, servlet filters 904
comprise basic client detection servlet filter 914, advanced client
detection servlet filter 916 and tracking servlet filter 918.
[0079] Basic client detection servlet filter 914 uses a
browser/user agent compatibility management tool such as, but not
limited to, BrowserHawk.TM., to detect the basic specifics/details
of the client NED 902 such as language supported, plugins supported
and basic HTML properties of the request. Basic client detection
servlet filter 914 may then set client NED 902 information as a
session variable.
[0080] Advanced client detection servlet filter 916 uses advanced
device detection such as, but not limited to, Morphis device
detection, to find the advanced details of the client, namely WAP
device information such as, for example, the WAP phone make and
colors supported. Advanced client detection servlet filter 916 may
then set client NED 902 information as a session variable.
[0081] Tracking servlet filter 918 determines whether or not the
user's NED 902 is known and can be tracked. If so, tracking servlet
filter 918 may log this information to the database 702 (See FIG.
7) and/or run pattern recognition software to determine the user
preferences at a later time.
[0082] Generally, a servlet pipeline may be an extensible
architecture used to perform a series of operations on each
incoming request. In any browser/user agent-server conversation,
the browser/user agent operating on the client's NED will send the
server a request. Usually the server will either find an HTML page
or other content resource and send it back to the browser or user
agent, or call a servlet and send the servlet's output to the
browser. With a servlet pipeline, however, one servlet's output may
be input to a second servlet. The Web server may send the second
servlet's output to the browser, or may input it to a third
servlet, and so on. The output from the last servlet in the chain
may then be sent to the browser.
[0083] The servlet pipeline is a suitable point of integration when
an HTTP or other non-HTTP request is being used as the method of
communication between platforms, or when session-scoped data must
be accessed. However the servlet pipeline should not be made
excessively complex since every request must pass through it; an
inefficient pipeline can compromise an application's
performance.
[0084] According to embodiments of the present invention, servlet
pipeline 906 may comprise a struts controller gateway servlet 920,
a UI preprocessor servlet 922, a UI processor servlet 924, a
Extensible Style Sheet Transformations ("XSLT") processor servlet
926 and a page/content resource compilation processor servlet
928.
[0085] The struts controller gateway servlet 920 communicates with
struts controller 910. Struts controller 910 is the controller 806
in the MVC architecture described above and illustrated in FIG. 8.
The struts controller gateway servlet 920 delegates the servlet
requests to the appropriate action processors and determines the
request servlet flow of an application.
[0086] The UI preprocessor servlet 922 invokes the rendering
preprocessor component given an input IDML document. The
preprocessing step involves resolving external IDML references and
determining primitive and resource paths. The UI processor servlet
924 processes the refined IDML document by, for example, resolving
scriptlet tags and dynamic pieces of IDML via the rendering
processors 908. The UI processor servlet 924 also resolves, for
example, Java Server Page ("JSP") tags and references. JSPs are
text-based documents that execute as servlets.
[0087] The XSLT processor servlet 926 uses the rendering XSLT
transformation component to dynamically change the relatively
abstract format to a platform specific language such as, but not
limited to, HTML, WAP or cHTML. The page/content resource
compilation processor servlet 928 takes the transformed XSLT input
and serializes the output into the output platform/language
specific to the requesting device.
[0088] In the servlet pipeline 906 according to embodiments of the
present invention, the struts controller gateway servlet 920
delegates the flow of the HTTP request. For example, if the struts
controller 910 determines that the request is an "action" type of
request, the struts framework may possibly forward the request
through a completely different pipeline than for a different type
of request. The power and flexibility of struts gives the servlet
pipeline dynamic and stackable capabilities which allow
customization options for multiple scenarios and use cases.
[0089] Rendering processors 908 will now be discussed. As discussed
above, the system and method for platform and language-independent
delivery of page-based content according to embodiments of the
present invention, accepts a common input in a relatively abstract
format and transforms the relatively abstract format input into a
specific recognized platform format for a particular device. For
example, a relatively abstract IDML input can be transformed for
display in various platforms such as, but not limited to, a
web-based or non-web-based browser, a WAP enabled cell phone or a
PDA.
[0090] In one embodiment, rendering processors 908 are pluggable
software components that are bound to an immutable interface. These
processors may be chained together sequentially and may eventually
be exposed as web services. The availability of the rendering
processors 908 as web services gives access to external clients,
such as NED 902, in order to process the relatively abstract format
accordingly. The servlet pipeline 906 employs rendering processors
908 for displaying the client specific output to the user's NED.
Rendering processors 908 communicate with servlets at each stage of
the servlet pipeline 906. In one embodiment, rendering processors
908 comprise a UI preprocessor 930, a UI processor 932 and an XSLT
processor 934.
[0091] UI preprocessor 930 functions to recursively resolve
external relatively abstract format references in the source
relatively abstract format document. These references are then
dynamically inserted into the output relatively abstract format
document. UI preprocessor 930 also resolves the primitive paths,
the resource paths and the copy element texts. All of this
information is dynamically inserted into the output relatively
abstract format document.
[0092] UI processor 932 accepts an input in a relatively abstract
format such as IDML and resolves the scriptlet elements (i.e.
dynamic IDML tags). In one embodiment, UI processor 932 also
handles JSP taglibs and may support, for example, JSP 1.2 template
tag libraries.
[0093] XSLT processor 934, given an input in a relatively abstract
format, dynamically builds a list of XSLT references for the XML
stylesheet. It then performs a transformation on the data to the
desired client platform specification. XSLT processor 934 finds
primitives paths, builds XSLT references using primitive paths and
runs the relatively abstract format with references through the
XSLT transformer.
[0094] According to embodiments of the present invention, the web
tier 706 includes Java objects that act as external interfaces for
processing and validating the elements in the relatively abstract
format. In one embodiment where the relatively abstract format is
IDML, the Java objects include, but are not limited to, an
IDMLActionProcessor, an IDMLPreProcessor, an IDMLProcessor, an
IDMLReferenceProcessor and IDMLXSLTProcessor. Functions of these
Java objects are described below. Details about each Java object
described below may be found in Appendix A. In addition, valid
IO/expected behavior for each of the Java objects is shown in
Appendices B through F, respectively.
[0095] The IDML Action Processor parses IDML markup and returns
back the valid IDML link used for action transitions from page to
page or other content resource (i.e. moving from one IDML page to
the next, similar to a hyperlink). This processor essentially
parses out a defined link location for an IDML Action markup
piece.
[0096] The IDML PreProcessor processes the IDML markup and performs
1) recursed IDML unraveling and 2) Resolution of primitive paths,
copy text and rendering resource paths. The output returned from
this processing call is then contained in a processor result whose
processed status is true.
[0097] The IDML Processor parses IDML markup and resolves the
dynamic content markup tags contained within the IDML. This is
relevant when using JSP tags within the IDML. This processor is
fundamental to displaying dynamically generated pages filled with
content.
[0098] The IDML Reference processor parses IDML markup and
recurses/resolves nested IDML references from the source IDML
document. The end output should be a fully recursed IDML document
without any references to other UI elements of IDML.
[0099] The IDML XSLT Processor processes the IDML markup and
transforms the IDML markup to the corresponding rendering target
type, such as, but not limited to, HTML, cHTML and WAP. If the
transaction request is of a stateless nature, ideally, the
transformation templates should be cached. The output returned from
this processing call is then contained in a processor result whose
processed status is true.
[0100] Data service layer 704 will now be described. FIG. 11 shows
a simplified block diagram of a system 1100 showing a relation of
data service layer 704 to web tier 706 and database 702 on the
server side and client NED types 1108, 1110, 1112 and .Net client
tool 1114 on the client side.
[0101] Object bridge layer 1102 relates data tables to objects and
acts as a mapping tool that automatically implements object
persistence to database 702. SOAP interface 1106 allows exchanges
of information over the Internet based on the XML standard. SOAP
invokes methods using XML and HTTP, allowing applications to
directly communicate with one another over the Internet by allowing
objects created using various different languages to communicate
with one another.
[0102] EJB schema domain managers 1104 provide standardized logic
to different application servers based on an Enterprise Java Beans
("EJB") specification. An EJB receives data from client
applications running on the client NED for processing and retrieves
data from database 702 to be sent back to the client applications
running on the client NED. Data is retrieved from the database 702
in an IDML format and is converted by the rendering group in the
web tier 706 into the particular client language. Data service
layer 704 includes EJBs for performing various functions. A
non-limiting list of EJBs included in data service layer 704, along
with their attributes, roles, public methods and various other
parameters are shown in Tables 1-16 below.
TABLE-US-00001 TABLE 1 Identifier COM-01 Defining The Asset manager
is an EJB can create, remove and Quality update Assets and
associated asset attributes. Name Asset Manager EJB. Attributes
Handling of logical representations of physical files, handling of
asset-attributes (metadata for asset records). Behaviors a. Create
an asset b. Update an asset c. Remove an asset d. Retrieve an asset
e. Retrieve all assets f. Add an attribute to a given asset g.
Remove an attribute from a given asset h. Update an attribute from
a given asset i. Retrieve all attributes from a given asset j. Find
an asset attribute by name Public a. createItem(Asset ) - return:
Asset Methods b. updateItem(Asset) - return: Asset c.
removeItem(Asset) - return: void d. getItem(Integer asset_ id) -
return: Asset e. getAllItems( ) - return: Asset array, or null f.
addAssociatedAttribute(Asset, AssetAttribute) - return: Asset, or
null g. removeAssociatedAttribute(Asset, AssetAttribute) - return:
Asset, or null h. updateAssociatedAttribute(Asset, AssetAttribute)
- return: Asset, or null i. findAssociatedAttributeByName (Asset,
String asset_name) - return: AssetAttribute, or null j.
getAllAssociatedAttributes(Asset) - return: AssetAttribute array,
or null Relationships None. Roles a. Service Asset management
requests (locally) b. Service Asset Attribute management requests
(locally) c. Service Asset management requests (remotely through
SOAP) d. Service Asset Attribute management requests (remotely
through SOAP) State a. Active usage though local interface Groups
b. Active usage though SOAP c. Idle Constraints None. Relates To
n/a
TABLE-US-00002 TABLE 2 Identifier COM-02 Defining The Logical Asset
manager EJB can create, remove and Quality update Logical Assets
and retrieve associated metadata. Name Logical Asset Manager EJB.
Attributes Handling of logical group or individual representations
of user associated assets, handling of logical asset metadata.
Behaviors a. Create a logical asset d. Update a logical asset e.
Remove a logical asset f. Retrieve a logical asset g. Retrieve all
logical assets h. Retrieve a logical asset by given name i.
Retrieve all logical assets by given asset j. Retrieve all
associated metadata from a logical asset k. Retrieve all associated
assets from a logical asset Public a. createItem(LogicalAsset ) -
return: LogicalAsset Methods b. updateItem(LogicalAsset) - return:
LogicalAsset c. removeItem(LogicalAsset) - return: void d.
getItem(Integer logical_asset_id) - return: LogicalAsset e.
getAllItems( ) - return: LogicalAsset array, or null f.
findItemByAsset(Asset) - return: LogicalAsset array, or null g.
getAllAssociatedMetadata(LogicalAsset) - return: Metadata array, or
null h. getAllAssociatedAssets(LogicalAsset) - return: Asset Array,
or null Relationships None. Roles a. Service Logical Asset
management requests (locally) b. Service Logical Asset management
requests (remotely through SOAP) State Groups a. Active usage
though local interface b. Active usage though SOAP c. Idle
Constraints None. Relates To n/a
TABLE-US-00003 TABLE 3 Identi- COM-03 fier Defin- The Metadata
manager EJB can create, remove and update a ing Quality Metadata
item. Metadata can be associated with Logical Assets. Name Metadata
Manager EJB. Attrib- Handling of metadata, that may describe utes
folders/groups associated with logical assets. Metadata usually is,
but does not have to be associated with logical assets. Behav- a.
Create a metadata item iors b. Update a metadata item c. Remove a
metadata item d. Retrieve a metadata item e. Retrieve all metadata
items f. Retrieve a metadata item by given metadata type g.
Retrieve a metadata item by given value Public a.
createItem(Metadata) return: Metadata Methods b.
updateItem(Metadata) - return: Metadata c. removeItem(Metadata) -
return: void d. getItem(Integer metadata_id) - return: Metadata e.
getAllItems( ) - return: Metadata array, or null f.
findItemByType(Metadata) - return: Metadata array, or null g.
findItemByValue(String) - return: Metadata array, or null Relation-
None. ships Roles a. Service Metadata management requests (locally)
b. Service Metadata management requests (remotely through SOAP)
State a. Active usage though local interface Groups b. Active usage
though SOAP c. Idle Con- None. straints Relates n/a To
TABLE-US-00004 TABLE 4 Identifier COM-04 Defining Quality The
Metadata Type manager is an EJB that can create, remove and update
Metadata types. Name Metadata Type Manager EJB. Attributes Handling
of metadata types, that may describe categories of metadata.
Behaviors a. Create a metadata type item b. Update a metadata type
item d. Remove a metadata type item e. Retrieve a metadata type
item f. Retrieve all metadata type items g. Retrieve a metadata
type item by given name Public Methods a. createItem(Metadata Type)
return: Metadata Type b. updateItem(Metadata Type) - return:
Metadata Type c. removeItem(Metadata Type) - return: void d.
getItem(Integer metadata_type_id) - return: Metadata Type e.
getAllItems( ) - return: Metadata Type array, or null f.
findItemByName(String) - return: Metadata Type, or null
Relationships None. Roles a. Service Metadata Type management
requests (locally) b. Service Metadata Type management requests
(remotely through SOAP) State Groups a. Active usage though local
interface b. Active usage though SOAP c. Idle Constraints None.
Relates To n/a
TABLE-US-00005 TABLE 5 Identifier COM-05 Defining Quality The
country manager EJB can create, remove and update a country record,
Name Country Manager EJB. Attributes Handling of country record
management. Behaviors a. Create a country record b. Update a
country record c. Remove a country record d. Retrieve a country
record e. Retrieve all country records f. Retrieve a country record
by given name g. Retrieve a country record by given country code
Public Methods a. createItem(Country) return: Country b.
updateItem(Country) - return: Country c. removeItem(Country) -
return: void d. getItem(Integer country_id) - return: Country e.
getAllItems( ) - return: Country array, or null f.
findItemByName(String) - return: Country, or null g.
findItemByCode(String) - return: Country, or null Relationships
None. Roles a. Service Country management requests (locally) b.
Service Country management requests (remotely through SOAP) State
Groups a. Active usage though local interface b. Active usage
though SOAP c. Idle Constraints None. Relates To n/a
TABLE-US-00006 TABLE 6 Identifier COM-06 Defining Quality The File
manager EJB can create, remove and update a File item. Name File
Manager EJB. Attributes Handling of records representing physical
files. Behaviors a. Create a file item b. Update a file item c.
Remove a file item d. Retrieve a file item e. Retrieve all file
items f. Retrieve a file item by a given name g. Retrieve a file
item by a given name and path h. Retrieve a file item by a given
path Public Methods a. createItem(File) return: File b.
updateItem(File) - return: File c. removeItem(File) - return: void
d. getItem(Integer file_id) - return: File e. getAllItems( ) -
return: File array, or null f. findItemByName(String) - return:
File array, or null g. findItemByPath(String) - return: File array,
or null h. findItemByNameAndPath(String, String) - return: File, or
null Relationships None. Roles a. Service File management requests
(locally) b. Service File management requests (remotely through
SOAP) State Groups a. Active usage though local interface b. Active
usage though SOAP c. Idle Constraints None. Relates To n/a
TABLE-US-00007 TABLE 7 Identifier COM-07 Defining Quality The File
extension manager EJB can create, remove and update a FileType and
the associated extension. Name File Extension Manager EJB.
Attributes Handling of file types and associated extensions.
Behaviors a. Create a file type item b. Update a file type item c.
Remove a file type item d. Retrieve a file type item e. Retrieve
all file type items f. Retrieve a file item by a given name g.
Retrieve a file item by a given file extension h. Add a file
extension i. Add a collection of file extensions j. Retrieve file
extensions k. Remove a file extension l. Remove a collection of
file extensions Public Methods a. createItem(FileType) return:
FileType b. updateItem(FileType) - return: FileType c.
removeItem(FileType) - return: void d. getItem(Integer
file_type_id) - return: FileType e. getAllItems( ) - return:
Filetype array, or null f. findItemByName(String) - return:
FileType, or null g. findItemByExtension(String) - return: FileType
array, or null h. addFileExtension(FileType, String) - return:
FileType, or null i. addFileExtensions(FileType, String array) -
return: FileType, or null j. getFileExtensions(FileType) - return:
FileExtension array, or null k. removeFileExtension(FileType,
String) - return: FileType, or null l.
removeFileExtensions(FileType, String array) - return: FileType, or
null Relationships None. Roles a. Service FileType management
requests (locally) b. Service FileExtension management requests
(locally) c. Service FileType management requests (remotely through
SOAP) d. Service FileExtension management requests (remotely
through SOAP) State Groups a. Active usage though local interface
b. Active usage though SOAP c. Idle Constraints None. Relates To
n/a
TABLE-US-00008 TABLE 8 Identifier COM-08 Defining Quality The User
manager EJB can create, remove and update a user record. Name User
Manager EJB. Attributes Handling of user records. Behaviors a.
Create a user account item b. Update a user account item c. Remove
a user account item d. Retrieve a user account item e. Retrieve all
user account items f. Retrieve a user account item by login name g.
Retrieve a user account password hash a given login name and hash
type Public Methods a. createItem(UserAccount) return: UserAccount
b. updateItem(UserAccount) - return: UserAccount c.
removeItem(UserAccount) - return: void d. getItem(Integer
user_account_id) - return: UserAccount e. getAllItems( ) - return:
UserAccount array, or null f. findItemByLogin(String) - return:
UserAccount array, or null g. findPasswordHashByLogin(String,
String) - return: String, or null Relationships None. Roles a.
Service User management requests (locally) b. Service User
management requests (remotely through SOAP) State Groups a. Active
usage though local interface b. Active usage though SOAP c. Idle
Constraints None. Relates To n/a
TABLE-US-00009 TABLE 9 Identifier COM-09 Defining Quality The UI
Copy manager EJB can create, remove and update a UICopy record.
UICopy records contain actual text content. Name UI Copy Manager
EJB. Attributes Handling of UI Copy records. Behaviors a. Create a
UICopy record b. Update a UICopy record c. Remove a UICopy record
d. Retrieve a UICopy record e. Retrieve all UICopy records f.
Retrieve a UICopy record by given name g. Retrieve a UICopyText
record by given name and renderer type and language Public Methods
a. createItem(UICopy) return: UICopy b. updateItem(UICopy) -
return: UICopy c. removeItem(UICopy) - return: void d.
getItem(Integer ui_copy_id) - return: UICopy e. getAllItems( ) -
return: UICopy array, or null f. findItemByName(String) - return:
UICopy array, or null g.
findUICopyTextItemByNameAndRendererTypeAndLanguage (String,
RendererType, Language) - return: UICopyText, or null.
Relationships None. Roles a. Service UICopy management requests
(locally) b. Service UICopy management requests (remotely through
SOAP) State Groups a. Active usage though local interface b. Active
usage though SOAP c. Idle Constraints None. Relates To n/a
TABLE-US-00010 TABLE 10 Identifier COM-10 Defining Quality The
Renderer Resource manager EJB can create, remove and update a
RendererResource record. A RendererResource record specifies
resource files with specific renderer types. Name Renderer Resource
Manager EJB. Attributes Handling of Renderer Resource records.
Behaviors a. Create a Renderer Resource record b. Update a Renderer
Resource record c. Remove a Renderer Resource record d. Retrieve a
Renderer Resource record e. Retrieve all Renderer Resource records
f. Retrieve a Renderer Resource record by given name g. Retrieve a
Renderer Resource File record by given name and genderer type and
language Public Methods a. createItem(RendererResource) return:
RendererResource b. updateItem(RendererResource) - return:
RendererResource c. removeItem(RendererResource) - return: void d.
getItem(Integer renderer_resource_id) - return: RendererResource e.
getAllItems( ) - return: RendererResource array, or null f.
findItemByName(String) - return: RendererResource array, or null g.
findResourceFileItemByNameAndRendererTypeAndLanguage (String,
RendererType, Language) - return: RenderingResourceFile, or null.
Relationships None. Roles a. Service Rendering Resource management
requests (locally) b. Service Rendering Resource management
requests (remotely through SOAP) State Groups a. Active usage
though local interface b. Active usage though SOAP c. Idle
Constraints None. Relates To n/a
TABLE-US-00011 TABLE 11 Identifier COM-11 Defining Quality The
Renderer Primitive manager EJB can create, remove and update a
RendererPrimitive item. A RendererPrimitive item specifies
primitive files with specific renderer types. Name Renderer
Primitive Manager EJB. Attributes Handling of Renderer Primitive
records. Behaviors a. Create a Renderer Primitive record b. Update
a Renderer Primitive record c. Remove a Renderer Primitive record
d. Retrieve a Renderer Primitive record e. Retrieve all Renderer
Primitive records f. Retrieve a Renderer Primitive record by given
name g. Retrieve a Renderer Primitive File record by given name and
renderer type Public Methods a. createItem(RendererPrimitive)
return: RendererPrimitive b. updateItem(RendererPrimitive) -
return: RendererPrimitive c. removeItem(RendererPrimitive) -
return: void d. getItem(Integer renderer_primitive_id) - return:
RendererPrimitive e. getAllItems( ) - return: RendererPrimitive
array, or null f. findItemByName(String) - return:
RendererPrimitive array, or null g.
findResourceFileItemByNameAndRendererType (String, RendererType) -
return: RenderingPrimitiveFile, or null. Relationships None. Roles
a. Service Rendering Primitive management requests (locally) b.
Service Rendering Primitive management requests (remotely through
SOAP) State Groups a. Active usage though local interface b. Active
usage though SOAP c. Idle Constraints None. Relates To n/a
TABLE-US-00012 TABLE 12 Identifier COM-12 Defining Quality The
Renderer Type manager EJB can create, remove and update a
RendererType item. A RendererType item specifies primitive files
with specific renderer types. Name Renderer Type Manager EJB.
Attributes Handling of Renderer Type records. Behaviors a. Create a
Renderer Type record b. Update a Renderer Type record c. Remove a
Renderer Type record d. Retrieve a Renderer Type record e. Retrieve
all Renderer Type records f. Retrieve a Renderer Type record by
given name Public Methods a. createItem(RendererType) return:
RendererType b. updateItem(RendererType) - return: RendererType c.
removeItem(RendererType) - return: void d. getItem(Integer
renderer_type_id) - return: RendererType e. getAllItems( ) -
return: RendererType array, or null f. findItemByName(String) -
return: RendererType array, or null Relationships None. Roles a.
Service Rendering Type management requests (locally) b. Service
Rendering Type management requests (remotely through SOAP) State
Groups a. Active usage though local interface b. Active usage
though SOAP c. Idle Constraints None. Relates To n/a
TABLE-US-00013 TABLE 13 Identifier COM-13 Defining Quality The
Language manager EJB can create, remove and update a Language item.
A Language item specifies language types. Name Language Manager
EJB. Attributes Handling of Language records. Behaviors a. Create a
Language record b. Update a Language record c. Remove a Language
record d. Retrieve a Language record e. Retrieve all Language
records f. Retrieve a Language record by given name Public Methods
a. createItem(Language) return: Language b. updateItem(Language) -
return: Language c. removeItem(RendererType) - return: void d.
getItem(Integer language_id) - return: Language e. getAllItems( ) -
return: Language array, or null f. findItemByName(String) - return:
Language array, or null Relationships None. Roles g. Service
Language management requests (locally) h. Service Language
management requests (remotely through SOAP) State Groups a. Active
usage though local interface b. Active usage though SOAP i. Idle
Constraints None. Relates To n/a
TABLE-US-00014 TABLE 14 Identifier COM-14 Defining Quality The IDML
UI manager EJB can create, remove and update a IDMLUI item. An IDML
UI item contains unparsed IDML code chunks. Name IDML UI Manager
EJB. Attributes Handling of IDMLUI records. Behaviors a. Create an
IDML UI record b. Update an IDML UI record c. Remove an IDML UI
record e. Retrieve an IDML UI record f. Retrieve all IDML UI
records g. Retrieve an IDML UI record by given name Public Methods
a. createItem(IDMLUI) return: IDMLUI b. updateItem(IDMLUI) -
return: Language c. removeItem(IDMLUI) - return: void d.
getItem(Integer idml_ui_id) - return: IDMLUI e. getAllItems( ) -
return: IDMLUI array, or null f. findItemByName(String) - return:
IDMLUI array, or null Relationships None. Roles a. Service IDML UI
management requests (locally) b. Service IDML UI management
requests (remotely through SOAP) State Groups a. Active usage
though local interface b. Active usage though SOAP c. Idle
Constraints None. Relates To n/a
TABLE-US-00015 TABLE 15 Identifier COM-15 Defining Quality The IDML
Scriptlet manager EJB can create, remove and update a IDML
Scriptlet item. An IDML Scriptlet item contains unparsed IDML
scriptlet code chunks. Name IDML Scriptlet Manager EJB. Attributes
Handling of IDML Scriptlet records. Behaviors a. Create an IDML
Scriptlet record b. Update an IDML Scriptlet record c. Remove an
IDML Scriptlet record d. Retrieve an IDML Scriptlet record e.
Retrieve all IDML Scriptlet records f. Retrieve an IDML Scriptlet
record by given name Public Methods a. createItem(IDMLScriptlet)
return: IDMLScriptlet b. updateItem(IDMLScriptlet) - return:
IDMLScriptlet c. removeItem(IDMLScriptlet) - return: void d.
getItem(Integer idml_scriptlet_id) - return: IDMLScriptlet e.
getAllItems( ) - return: IDMLScriptlet array, or null f.
findItemByName(String) - return: IDMLScriptlet array, or null
Relationships None. Roles a. Service IDML Scriptlet management
requests (locally) b. Service IDMLScriptlet management requests
(remotely through SOAP) State Groups a. Active usage though local
interface b. Active usage though SOAP c. Idle Constraints None.
Relates To n/a
TABLE-US-00016 TABLE 16 Identifier COM-16 Defining Quality The IDML
Action manager EJB can create, remove and update a IDML Action
item. An IDML Action item contains unparsed IDML Action code
chunks. Name IDML Action Manager EJB. Attributes Handling of IDML
Action records. Behaviors a. Create an IDML Action record b. Update
an IDML Action record c. Remove an IDML Action record d. Retrieve
an IDML Action record e. Retrieve all IDML Action records f.
Retrieve an IDML Action record by given name Public Methods a.
createItem(IDMLAction) return: IDMLAction b. updateItem(IDMLAction)
- return: IDMLAction c. removeItem(IDMLAction) - return: void d.
getItem(Integer idml_action_id) - return: IDMLAction e.
getAllItems( ) - return: IDMLAction array, or null f.
findItemByName(String) - return: IDMLAction array, or null
Relationships None. Roles a. Service IDML Action management
requests (locally) b. Service IDML Action management requests
(remotely through SOAP) State Groups a. Active usage though local
interface b. Active usage though SOAP c. Idle Constraints None.
Relates To n/a
[0103] According to embodiments of the present invention, the data
service layer 704 includes EJBs that function as an external
interface. In one embodiment, the external interface EJBs include,
but are not limited to, CountryManager, FileManager,
FileTypeManager, IDMLActionManager, IDMLUIManager, LanguageManager,
RendererTypeManager, RenderingPrimitiveManager,
RenderingResourceManager and UICopyManager. Functions of these EJBs
are described below. Details about each EJB described below may be
found in Appendix G.
[0104] The Country Manager EJB interface manages countries used by
the platform services runtime. Specifically, the country manager
can create, remove, retrieve, query and update countries within the
data service layer.
[0105] The File Manager EJB interface manages files used by the
platform services runtime. Specifically, the file manager can
create, remove, retrieve, query and update soft file references
(with pointers to the actual file content) within the data service
layer.
[0106] The File Type Manager creates a new file type item given a
registered file type name and extension.
[0107] The IDML Action Manager EJB interface manages UI action
items used by the platform services runtime. Specifically, the
action manager can create, remove, retrieve, query and update IDML
action elements for handling "clicks" such as, but not limited to,
links within the presentation layer.
[0108] The IDML UI Manager EJB interface manages UI page items used
by the platform services runtime. Specifically, the UI manager can
create, remove, retrieve, query and update IDML UI page elements
for rendering pages or other content resources within a
presentation layer.
[0109] The Language Manager EJB interface manages languages used by
the platform services runtime. Specifically, the UI manager can
create, remove, retrieve, query and update registered languages for
rendering pages or other content resources in a presentation layer
or, in some embodiments, setting user preferences.
[0110] The Renderer Type Manager EJB interface manages target
renderer types used to define the different rendering views used by
the platform services runtime. Specifically, the renderer type
manager can create, remove, retrieve, query and update registered
renderer types for defining the possible views via a presentation
layer.
[0111] The Rendering Primitive Manager EJB interface manages IDML
primitives used to composite pages used by the IDML UI for the
platform services runtime. Specifically, the rendering primitive
manager can create, remove, retrieve, query and update registered
renderer primitives that are used to implicitly render pages or
other content resources for the presentation layer.
[0112] The Rendering Resource Manager EJB interface manages IDML
resources used to composite pages (including, but not limited to,
gifs and audio files) used by the IDML UI for the platform services
runtime. Specifically, the rendering resource manager can create,
remove, retrieve, query and update registered renderer resources
that are used to implicitly display external resources for pages or
other content resources for a presentation layer.
[0113] The UI Copy Manager EJB interface manages text copy used in
compositing pages (i.e. written text for the language) used by the
IDML UI for the platform services runtime. Specifically, the UI
copy manager can create, remove, retrieve, query and update
registered UI copy text that are used to display written content
for pages or other content resources for the presentation
layer.
[0114] Database 702 will now be described. According to embodiments
of the present invention, rendering elements, action elements and
UI elements, and copy may be stored in a database such that they
are accessible to client applications. In one embodiment, the
database is an Oracle.TM. 8I database. However, other suitable
databases such as, but not limited to, Oracle 9i, FoxPro, DB2,
Informix, Sybase, Access, mySQL, and MS SQL may also be used. An
exemplary schema of the database for storing rendering elements,
action elements and UI elements, and copy, according to one
embodiment of the present invention, is shown in FIG. 12.
[0115] FIG. 13 shows a simplified block diagram of a mark-up
language ("ML") rendering group 1302 within web tier 706, along
with database 702 and data service layer 704, according to
embodiments of the present invention. ML rendering group 1302 may
be any ML rendering group, including HTML rendering group 516 shown
in FIG. 5.
[0116] According to embodiments of the present invention, ML
renderer 1304 performs functions including, but not limited to,
replacing IDML collection styles with ML page styles; embedding ML
templates within a given style based on incoming IDML UI constructs
and actions; performing one-to-one substitution of keyed variables
from IDML to ML templates; maintaining a data "snapshot" of the
current page for rapid incremental updates; recursively requesting
preprocessed IDML from web messaging servlets 1306, which in turn
use the state maintenance/preprocessor beans 1308; fetching
non-IDML primitives and collections (such as, but not limited to,
SWF and .jpg) via the web messaging servlets 1306 using paths
specified in returned, preprocessed IDML; and outputting final ML
pages (such as, but not limited to, HTML, WML and cHTML).
[0117] According to embodiments of the present invention, the state
maintenance/preprocessor beans 1308 perform functions including,
but not limited to, initially tracking only selected rendering
platforms and localization settings; on each request received from
ML rendering group 1302 via the web messaging servlets 1306, using
the data service layer 704 API to retrieve un-modified IDML,
primitives and collections (ASCII data), paths to file based binary
primitives and language specific text (ASCII copy); compositing
paths and text copy into IDML; replacing IDML statement "{%
NAMED_DB_OBJECT:NAMED_ELEMENT %}" with actual database content; and
passing modified IDML and other ASCII data back to the ML rendering
group 1302 via the web messaging servlets 1306.
[0118] According to embodiments of the present invention, ML action
handler 1310 performs functions including, but not limited to,
accepting input from mark-up languages (such as, but not limited
to, HTML, WML and cHTML); retrieving a selected action or actions
through the data service layer 704 API via the web messaging
servlets 1306, which in turn use the state maintenance/preprocessor
beans 1308; scheduling actions to the ML renderer 1304; and on
completion of actions, sending an update command to ML renderer
1304, signaling that a render to the specified mark-up language
should be performed, resulting in a viewable ML page 1312.
[0119] FIG. 14 shows a simplified block diagram of a Flash
rendering group 1402 which may be a self-contained client-side
renderer, along with database 702, data service layer 704 and web
tier 706, according to embodiments of the present invention.
[0120] According to embodiments of the present invention, Flash
renderer 1404 performs functions including, but not limited to,
recursively requesting preprocessed IDML from web messaging
servlets 1306, which in turn uses state maintenance/preprocessor
beans 1308; using web messaging servlets 1306 to fetch non-IDML
primitives and collections (such as, but not limited to, SWF, and
.jpg) using paths specified in returned preprocessed IDML; and
outputting a Flash page.
[0121] According to embodiments of the present invention, Flash
action handler 1410 performs functions including, but not limited
to, accepting input from Flash; retrieving a selected action or
actions through the data service layer 704 via web messaging
servlets 1306, which in turn use state maintenance/preprocessor
beans 1308; handling actions from within the Flash rendering group
1402; triggering updates of Flash pages through the Flash renderer
1404. According to embodiments of the present invention, Flash
action handler 1410 is located within the Flash rendering group
1402 and is thus not a Java servlet.
[0122] As described above, systems and methods for platform and
language-independent delivery of page-based content transform
content in a relatively abstract format into multiple platform
formats in client-side applications' user interfaces in multiple
human languages. In one embodiment, the relatively abstract format
may be IDML.
[0123] The following describes the syntax of IDML and its allowable
use, according to embodiments of the present invention. FIG. 15
shows an example IDML document structure, according to embodiments
of the present invention. An IDML document may always start with a
required <idml> tag. The IDML tag has no allowable
attributes. Allowable nested tags are the UI tag. An example of a
IDML tag is shown below:
TABLE-US-00017 <idml> ... ... </idml>
[0124] After the IDML tag, the <ui> tag is required. The UI
tag has no allowable attributes. Allowable nested tags are
primitive, collection, resource, text, list_wrapper and
primitive_list. An example of a UI tag is shown below:
TABLE-US-00018 <idml> <ui> ... </ui>
</idml>
[0125] A primitive tag is used to parameterize any primitives that
are going to be included in the page. Primitives can only contain
resources and text. Required attributes of the primitive tag are:
name (the business name of the primitive) and render_location (the
render location that the primitive will be placed in). Allowable
attributes of the primitive tag are: idml_id (the name or
identification ("ID") of the IDML element which further defines
this primitive) and action_id (the name or ID of the action
associated with this primitive) and custom attributes (any other
attributes used specifically by this primitive). Allowable nested
tags are: text (copy text used by this primitive) and resource
(rendering resource (graphical element) used by this primitive). An
example of a primitive tag is shown below:
TABLE-US-00019 <idml> <ui> <primitive name =
"page_header" render_location="header_area"> ...
</primitive> </ui> </idml>
[0126] A resource tag is used to specify any rendering resources
that are going to be included in the page. Required attributes of
the resource tag are: name (the business name of the resource) and
render_location (the render location that the resource will be
placed in). The resource tag has no allowable attributes or nested
tags. An example of a resource tag is shown below:
TABLE-US-00020 <idml> <ui> <primitive name =
"page_header" render_location="header_area">
<resource_name="elmacho_header"
render_location="header_resource_area"/> </primitive>
</ui> </idml>
[0127] A text tag is used to specify any copy text that is going to
be included in the page. Required attributes of the text tag are:
copy_id (the business name of the copy text) and render_location
(the render location that the text will be placed in). The text tag
has no allowable attributes or nested tags. An example of a text
tag is shown below:
TABLE-US-00021 <idml> <ui> <primitive name =
"page_header" render_location="header_area"> <resource
name="elmacho_header" render_location="header_resource_area"/>
<text copy_id="elmacho_title"
render_location="header_title_area"/> </primitive>
</ui> </idml>
[0128] A collection tag is used to parameterize any collections
that are going to be included in the page. Collections can contain
primitives or other collections, as well as resources and text.
Required attributes of the collection tag are: name (the business
name of the primitive) and render_location (the render location
that the collection will be placed in). Allowable attributes of the
collection tag are: idml_id (the name or ID of the IDML element
which further defines this primitive), action_id (the name or ID of
the action associated with this primitive) and custom attributes
(any other attributes used specifically by this collection).
Allowable nested tags are: text (copy text used by this primitive),
resource (rendering resource (graphical element) used by this
primitive), collection (a collection contained within this
collection) and primitive (a primitive contained within this
collection). An example of a collection tag is shown below:
TABLE-US-00022 <idml> <ui> <collection
name="main_page_template" render_location="main_area">
<primitive name = "page_header"
render_location="header_area"> ... </primitive>
<primitive name = "page_footer"
render_location="footer_area"> ... </primitive>
</collection> </ui> </idml>
[0129] A list_wrapper tag is used to wrap the primitive_list tag.
This is due to the fact that the primitive_list tag has no
allowable custom attributes. As such, the custom attributes can be
included in the list wrapper. The list_wrapper tag has no required
attributes. Allowable attributes are: custom attributes (any other
attributes used specifically by this list). Allowable nested tags
are: primitive_list (the primitive list which is wrapped by this
list wrapper). An example of a list_wrapper tag is shown below:
TABLE-US-00023 <idml> <ui> <list_wrapper
x_offset="20" y_offset="30"> <primitive_list type="array">
... </primitive list> </list_wrapper> </ui>
</idml>
[0130] A primitive_list is used to parameterize collections that
are iterative in nature such as menus or other lists. Required
attributes of the primitive_list are: type="array". For flash
compatibility, the type="array" attribute must be included. The
primitive_list has no allowable attributes. Allowable nested tags
are: item (lists can contain many items). An example of a
primitive_list is shown below:
TABLE-US-00024 <idml> <ui> <list_wrapper
x_offset="20" y_offset="30"> <primitive_list type="array">
<item> ... </item> <item> ... </item>
</primitive_list> </list_wrapper> </ui>
</idml>
[0131] An item tag is used to wrap the individual items in a
primitive list. The item tag has no required or allowable
attributes. Allowable nested tags are: primitive, collection,
list_wrapper and primitive_list. An example of an item tag is shown
below:
TABLE-US-00025 <idml> <ui> <list_wrapper
x_offset="20" y_offset="30"> <primitive_list type="array">
<item> <primitive name = "button"
render_location="button_area"> <text copy_id =
"drama_button"/> </primitive> </item> <item>
<primitive name = "button" render_location="button_area">
<text copy_id = "action_button"/> </primitive>
</item> </primitive_list> </list_wrapper>
</ui> </idml>
[0132] One of the IDML syntax examples shown above is repeated
below, along with a exemplary data tables 17 and 18, which may be
saved, for example in a data source such as a database. Tables 17
and 18 illustrate a correspondence between the IDML code and the
data tables stored in the data source.
TABLE-US-00026 <idml> <ui> <primitive name =
"page_header" render_location="header_area"> <resource
name="elmacho_header" render_location="header_resource_area"/>
<text copy_id="elmacho_title"
render_location="header_title_area"/> </primitive>
</ui> </idml>
TABLE-US-00027 TABLE 17 (Copy Grid) HTML Flash cHTML English
"elmacho_title" "elmacho_title" "elmacho_title" Spanish . . . . . .
. . . French . . . . . . . . .
TABLE-US-00028 TABLE 18 (Primitive Grid) HTML
"page_header"_HTML.XSLT cHTML "page_header"_cHTML.XSLT Flash
"page_header"_SWF
[0133] In the example IDML code shown above, it can be seen that
the text copy_id in the IDML code="elmacho_title". Thus, in the
exemplary copy grid shown in Table 17 versions of the copy
"elmacho_title" may be implemented in each of the available
platforms and languages (in this example HTML, cHTML and Flash;
English, Spanish and French). The English and French versions
(shown as . . . ) of the referenced copy appear in corresponding
cells of Table 17.
[0134] Similarly, it can be seen that the primitive
name="page_header" in the IDML code". Thus, in the exemplary
primitive grid shown in Table 18, versions of the referenced
primitive name are implemented in each of the available platforms
of the present example. In the case of the HTML and cHTML
platforms, the primitive is implemented in an XSLT format. For the
Flash platform, the primitive is implemented in an SWF format.
[0135] Similar data tables may be implemented for graphics, actions
and other types of elements and other data. For example, different
language versions of graphics formats such as, but not limited to,
JPEG and SWF may be stored in a table in a manner similar to that
shown above.
[0136] Thus, it can be seen that embodiments of the present
invention allow content, such as UI primitives and copy, to be
defined in a relatively abstract format such as IDML that is then
rendered into multiple platform formats in client-side
applications' user interfaces in multiple human languages.
Primitives implementing, for example, web pages or other pages,
could be created for each platform type. When a change is required,
for example adding or deleting a button or other user-selectable
operator, a change made to the IDML or other relatively abstract
format will add or delete the button across every supported
platform, and thus in every device that the pages are rendered in.
The user does not have to modify multiple source definitions of the
pages.
[0137] Also, if a user's content is defined in the relatively
abstract format, then when new content is introduced, the user is
only required to add a new primitive, for example XSLT or SWF, for
each supported device "category" instead of rewriting the new
content for each supported device. This is due to the fact that
devices within a specific device category may share enough
commonality that the fact that they are separate devices may be
transparent to the processed results. Furthermore, when new devices
or device categories appear, new XSLT primitives may be coded
rather than re-coding the exiting content for the new device or
device category. Thus, maintenance of the pages is advantageously
simplified.
[0138] Referring again to FIG. 11, .NET tool 1114 may, according to
embodiments of the present invention, include a creation,
modification and management tool that allows a page creator or
publishing team to create, modify, and manage platform and
language-independent page-based content. The page-based content can
then be viewed and interacted with by end-users, with embodiments
of the system and method for platform and language-independent
delivery of page-based content being used to display the same pages
on multiple platforms, and in multiple languages.
[0139] In one embodiment, a content creation, modification and
management system application may run under Windows 2000
Professional, and interfaces directly with services of the system
for platform and language-independent delivery of page-based
content through SOAP protocols, providing a "toolset" that allows a
user to access, view, and modify one or more databases that adhere
to database specifications defined for the system. In other
embodiments, the creation, modification and management tool may run
under other operating systems, including, but not limited to,
Windows 98, Windows Me, Windows 2000, Windows XP, possible future
implementations on Windows CE, Linux, Solaris, and Java VM.
[0140] According to embodiments of the present invention, embedded
within the toolset is the ability to publish page data FROM one
database instance TO another, using separate instances of the
services. This segment of the toolset may be an implementation of
the "publishing pipeline", defined in the "Screenbiast 2.0 Site
Publishing Functional Specifications," which appears in Appendix
H.
[0141] However, embodiments of the present invention are not
limited to moving content from one database instance to another. As
an example, a publishing pipeline according to embodiments of the
present invention may include the option to move physical files
from one file system to another in conjunction with the database
content transfers. In one embodiment, an alternate physical-file
pipeline for publishing to a "Live" environment may be implmented,
wherein time-stamps (last-modified) of individual files are sampled
on a destination server, followed by a remote initiation of a
server-side file sync process. This is, in turn, followed by
another set of (looped) file-based time-stamp samples. This second
round of samples only terminates when all of the physical files
have been updated, as determined by changed time-stamps. Following
this physical file movement, the database content is moved from the
source database to the destination database in the normal
fashion.
[0142] In one embodiment, UI elements are created by a user, for
example a page developer, and are the elements of the system that
define the overall page structure. UI elements are stored in the
database as IDML code elements and associated data, such as name,
description, etc.
[0143] The IDML in a UI Component can reference other components,
actions, copy, assets, or rendering elements. The UI Components can
be considered the "glue" that binds page elements together.
[0144] An exemplary UI components list interface 1600 is shown in
FIG. 16, according to embodiments of the present invention. UI
components list interface 1600 may show all of the UI components in
a particular database, for example database 702, with links to
editing interfaces, as well as giving the ability to add selected
components to a publishing list. The "Search/Edit" area 1620 of the
interface also allows the user to filter the list display based on
search criteria, and to view, edit, or create UI components within
the database.
[0145] List box 1602 displays all of the UI components in a
particular database. Individual items are selected using a
single-click or other suitable selection method. A Shift-Click
allows the user to select a range of items, and a ctrl-click allows
the selection of additional single items. Double-clicking an item
brings up the "View/Edit" UI component interface 1700 (See FIG. 17)
for that item. Items may be sorted by a particular header category
by clicking or otherwise selecting that category. Clicking again in
a particular category causes the items to be sorted in reverse
order.
[0146] Given a particular search string in the "Search
Name/Description/Content" text box 1604, and given the search area
defined by the selection of either the "Name", "Description", or
"Content" radio buttons generally designated by numeral 1606,
selecting the "Search" user selectable operator 1608 will cause the
list box 1602 to display only the items that match the search
criteria. For instance, entering "comedy" in the search string,
selecting the "Name" radio button, and selecting "Search" user
selectable operator 1608 will cause only those items with the
string "comedy" somewhere in the name to be displayed. Selecting
the "View All" user selectable operator 1610 will negate the search
feature and cause all items to be displayed again until the next
search is performed.
[0147] The "View/Edit" user selectable operator 1612 brings up the
"View/Edit" UI component interface 1700, shown in FIG. 17, for the
selected item in the list box 1602. If no items, or multiple items
are selected, this user selectable operator has no effect.
Double-clicking an item in the list box 1604 has the same effect as
clicking this user selectable operator.
[0148] "New" user selectable operator 1614 brings up the "New"
interface for creating new UI Components in the database. This
interface is almost identical to the "View/Edit" UI component
interface 1700, with the exception of a header, which reads "Create
New UI Component". A default name and description is shown, and the
IDML window is initially empty. Attempting to save with the same
name as an already existing UI component is not allowed.
[0149] "Delete" user selectable operator 1616 deletes all selected
UI Components in the list box. Before deletion, a confirmation
prompt may appear to protect the user against inadvertently
deleting items by mistake.
[0150] "Add to Publish List" user selectable operator 1618 adds all
currently selected UI Components to the list of items in the
publishing queue (see below). If a UI Component is already on the
list, a duplicate instance is not added.
[0151] In one embodiment, on first viewing UI components list
interface 1600, the top row in the UI Components List is
highlighted and "View/Edit" is the default double-click action.
Scroll bars may only be visible if the list exceeds the size of the
list box.
[0152] Referring now to FIG. 17, an exemplary "View/Edit" UI
component interface 1700 will be described in more detail. Through
use of the "View/Edit" UI component interface 1700, the detailed
information in an individual UI Component may be viewed and edited.
When saved, these UI Components are stored in the database as IDML
code components, with the associated data, such as name,
description, etc.
[0153] The "Cancel" user selectable operator 1702 closes the
"View/Edit" UI component interface 1700 and returns the user to the
main interface. Changes that may have been made in the "View/Edit"
UI component interface 1700 are not saved.
[0154] The Name text field 1704 allows the user to change the
business name of the UI Component. When this interface is accessed
by using the "New" user selectable operator 1614 from the main UI
components list interface 1600, this field allows the user to enter
the name of a new UI Component. The "Description" text field 1706
allows the user to enter any extra descriptive information about
the UI Component.
[0155] The Status field 1708 is a read-only text field that
indicates if the UI Component is referenced (USED) by another UI
Component, or if it is not referenced (UNUSED). The status in this
field is updated whenever the "Verify" user selectable operator
(not shown) is clicked or otherwise selected.
[0156] IDML editing window 1710 serves as an editor for a UI
Component's IDML code. If a new component is being created, this
window is initially left blank. "Save" user selectable operator
1712 causes the tool to save the UI Component data to the database.
If creating a new component, saving over an existing component is
not allowed. If editing an existing component, and the component
name has been changed, the tool may launch a confirmation pop-up if
attempting to save over an existing named UI Component. Otherwise,
the save is performed automatically, the "View/Edit" UI component
interface 1700 is closed, and a "UI Component Successfully Saved"
message may appear in a header of the UI components list interface
1600.
[0157] FIG. 18 shows an exemplary actions list interface 1800.
Actions are created by the user, for example a page developer, and
are the elements of the system that define special behaviors within
the overall page. Actions are stored in the database as IDML code
components and associated data, such as name, description, etc.
[0158] The IDML in an action references one or more specific named
low-level actions that cause events to occur within the system.
Other data may be embedded in these actions that define links to
elements such as sub-actions, copy, assets, or rendering elements.
Actions are system elements that "do things" based on user
input.
[0159] The actions list interface 1800 shows all of the actions in
a particular database, for example database 702, with links to
editing interfaces, as well as giving the ability to add selected
actions to a publishing list. The "Search/Edit" area 1802 of the
interface also allows the user to filter the list display based on
search criteria, and to view, edit, or create actions within the
database.
[0160] List box 1804 displays all of the actions in a particular
database. Individual items are selected using a single-click or
other suitable selection method. A shift-click allows the user to
select a range of items, and a ctrl-click allows the selection of
additional single items. Double-clicking an item brings up the
"View/Edit" interface 1900 (See FIG. 19) for that item. Items may
be sorted by a particular header category by clicking on that
category. Clicking again in a particular category causes the items
to be sorted in reverse order.
[0161] "New" user selectable operator 1814 brings up the "New"
interface for creating new UI actions in the database. This
interface is almost identical to the "View/Edit" action interface
1900, with the exception of the header, which reads "Create New
Action". A default name and description is shown, and the IDML
window is initially empty. Attempting to save with the same name as
an already existing action is not allowed.
[0162] "Search Name/Description/Content" text box 1806, "Search"
user selectable operator 1808, "View All" user selectable operator
1810, "View/Edit" user selectable operator 1812, "Delete" user
selectable operator 1818 and "Add to Publish List" user selectable
operator 1820 function in a manner similar to that described above
for similar features on the UI components list interface 1600.
[0163] In one embodiment, on first viewing actions list interface
1800, the top row in the actions list box 1804 is highlighted and
"View/Edit" is the default double-click action. Scroll bars my only
be visible if the list exceeds the size of the list box.
[0164] Referring again to FIG. 19, an exemplary "View/Edit" action
interface 1900 will be described in more detail. Through use of the
"View/Edit" action interface 1900, the detailed information in an
individual UI action may be viewed and edited. When saved, these UI
actions are stored in the database as IDML code components, with
the associated data, such as name, description, etc.
[0165] The "Cancel" user selectable operator 1902 closes the
"View/Edit" action interface 1900 and returns the user to the main
interface. Changes that may have been made in the "View/Edit"
action interface 1900 are not saved.
[0166] The Name text field 1904 allows the user to change the
business name of the UI action. When this interface is accessed by
using the "New" user selectable operator 1814 from the main UI
actions list interface 1800, this field allows the user to enter
the name of a new UI action. The "Description" text field 1906
allows the user to enter any extra descriptive information about
the UI action.
[0167] The Status field 1908 is a read-only text field that
indicates if the UI action is referenced (USED) by another UI
Component, or if it is not referenced (UNUSED). The status in this
field is updated whenever the "Verify" user selectable operator
(not shown) is clicked or otherwise selected.
[0168] IDML editing window 1910 serves as an editor for a UI
action's IDML code. If a new action is being created, this window
is initially left blank. "Save" user selectable operator 1912
causes the tool to save the UI action data to the database. If
creating a new action, saving over an existing action is not
allowed. If editing an existing action, and the action name has
been changed, the tool may launch a confirmation pop-up if
attempting to save over an existing named UI action. Otherwise, the
save is performed automatically, the View/Edit action interface
1900 is closed, and a "UI Component Successfully Saved" message may
appear in a header of the actions list interface 1800.
[0169] FIG. 20 shows an exemplary copy list interface 2000. Copy
(text) is created by a user, for example a page developer, and
comprises the elements of the system that define displayed text
within the overall page. In one embodiment, copy is stored in the
database as 4-byte Unicode text and associated data, such as name,
languages, renderers, etc. However other formats for storing the
copy are possible including, but not limited to, UnicodeBig,
UnicodeBigUnmarked, UnicodeLittle, UnicodeLittleUnmarked, UTF8,
UTF-16. Uses of the system in which internationalization is not
needed could take advantage of language-specific encodings.
[0170] The copy list interface 2000 shows all of the copy in a
particular database, for example database 702, with links to
editing interfaces, as well as giving the ability to add selected
copy items to a publishing list. The "Search/Edit" area 2002 of the
interface also allows the user to filter the list display based on
search criteria, and to view, edit, or create copy items within the
database.
[0171] List box 2004 displays all of the copy items in a particular
database. Individual items are selected using a single-click or
other suitable selection method. A shift-click allows the user to
select a range of items, and a ctrl-click allows the selection of
additional single items. Double-clicking an item brings up the
"View/Edit" copy interface 2100 (See FIG. 21) for that item. Items
may be sorted by a particular header category by clicking on that
category. Clicking again in a particular category causes the items
to be sorted in reverse order. Note that a named copy item within
the database contains multiple sub-items, grouped by text, language
and renderer. The copy list box 2004 displays all sub-items, not
the single named meta-item.
[0172] Given a particular search string in the "Search Name/Text"
text box 2006 text box, and given the search area defined by the
selection of either the "Name" or "Text" radio button, generally
referred to by the numeral 2022, selecting the "Search" user
selectable operator 2008 will cause the list box 2004 to display
only the items that match the search criteria. For instance,
entering "comedy" in the search string, selecting the "Name" radio
button, and selecting "Search" user selectable operator 2008 will
cause only those items with the string "comedy" somewhere in the
name to be displayed. Selecting the "View All" user selectable
operator 2010 will negate the search feature and cause all items to
be displayed again until the next search is performed.
[0173] "New" user selectable operator 2014 brings up the "New"
interface for creating new copy in the database. This interface is
almost identical to the "View/Edit" copy interface 2100, with the
exception of the header, which reads "Create New Copy". A default
name is shown, and the copy text window is initially empty.
Attempting to save with the same name as an already named copy
element is not allowed.
[0174] "View/Edit" user selectable operator 2012, "Delete" user
selectable operator 2018 and "Add to Publish List" user selectable
operator 2020 function in a manner similar to that described above
for similar features on the UI components list interface 1600.
[0175] In one embodiment, on first viewing copy list interface
2000, the top row in the actions list box 2004 is highlighted and
"View/Edit" is the default double-click action. Scroll bars my only
be visible if the list exceeds the size of the list box.
[0176] Referring again to FIG. 21, an exemplary "View/Edit" copy
interface 2100 will be described in more detail. Through use of the
"View/Edit" copy interface 2100, the detailed information in an
individual copy item is viewed and edited. In one embodiment, when
saved, the copy item is stored in the database as 4-byte Unicode
text, with the associated data, such as name, languages, etc.
However other formats for storing the copy are possible including,
but not limited to, UnicodeBig, UnicodeBigUnmarked, UnicodeLittle,
UnicodeLittleUnmarked, UTF8, UTF-16. Uses of the system in which
internationalization is not needed could take advantage of
language-specific encodings.
[0177] "Cancel" user selectable operator 2102 closes the
"View/Edit" copy interface 2100 and returns the user to the main
interface. Changes that may have been made in the "View/Edit" copy
interface 2100 are not saved.
[0178] The "Name" text field 2104 allows the user to change the
business name of the copy item. When this interface is accessed by
using the "New" user selectable operator 2014 from the main viewing
copy list interface 2000, this field allows the user to enter the
name of a new copy item.
[0179] Copy text editing window 2110 serves as an editor for a copy
item's text. If a new copy item is being created, this window is
initially left blank. Multiple text data may be associated with a
single "business named" copy item. This allows for multiple
language and renderer support.
[0180] "Save" user selectable operator 2112 causes the tool to save
the copy item data to the database. If creating a new copy item,
the saving over an existing copy item is not allowed. If editing an
existing copy item, and the copy item's name has been changed, the
tool may launch a confirmation pop-up if attempting to save over an
existing named copy item. Otherwise, the save is performed
automatically, the "View/Edit" copy interface 2100 is closed, and a
"Copy Successfully Saved" message may appear in a header of the
viewing copy list interface 2000.
[0181] Languages checked list box 2114 allows the user to set one
or more languages that the text will be used for during rendering.
At least one language must be selected before saving. In one
embodiment, because there can be more than one piece of text
associated with a named copy item, there must not be a match
between a checked language and checked renderer associated with one
instance of text, and a checked language and renderer associated
with another instance of text in the same named copy item.
[0182] Renderer select box 2116 allows the user to set one or more
renderers that the text will be used for during rendering. At least
one renderer must be selected before saving. In one embodiment,
because there can be more than one piece of text associated with a
named copy item, there must not be a match between a checked
language and checked renderer associated with one instance of text,
and a checked language and renderer associated with another
instance of text in the same named copy item.
[0183] FIG. 22 shows an exemplary rendering elements list interface
2200. Rendering elements are created by created by a user, for
example a page developer, and comprise the elements of the system
that reference renderer and language specific resources and
primitives that are displayed as part of a page. These resources
and primitives are indexed through a file table in a database.
Rendering elements contain the contextual information needed for
the system to correctly display file-based images, flash
animations, etc. within an IDML defined page.
[0184] The rendering elements list interface 2200 shows all of the
rendering elements in a particular database, for example database
702, with links to editing interfaces, as well as giving the
ability to add selected rendering elements to a publishing list.
Search capabilities are enabled in this interface as well.
[0185] List box 2204 displays a subset of the rendering elements in
a particular database. That subset is selected using the "Rendering
Resources" and "Rendering Primitives" radio buttons referred to
generally by the numeral 2222 at the top of rendering elements list
interface 2200. Individual items are selected using a single-click
or other suitable selection method. A shift-click allows the user
to select a range of items, and a ctrl-click allows the selection
of additional single items. Double-clicking an item brings up the
"View/Edit" rendering elements interface 2300 (See FIG. 23) for
that item. Items may be sorted by a particular header category by
clicking on that category. Clicking again in a particular category
causes the items to be sorted in reverse order. Note that a named
rendering element within the database contains multiple sub-items,
grouped by file, language and renderer. The rendering element list
box 2204 displays all sub-items, not the single named
meta-item.
[0186] Given a particular search string in the "Search Name/File
Name/Path" text box 2206, and given the search area defined by the
selection of either the "Name", "File Name", or "Path" radio
buttons, generally referred to by the numeral 2224, selecting the
"Search" user selectable operator 2208 will cause the list box 2204
to display only the items that match the search criteria. For
instance, entering "comedy" in the search string, selecting the
"Name" radio button, and selecting "Search" user selectable
operator 2208 will cause only those items with the string "comedy"
somewhere in the name to be displayed. Selecting the "View All"
user selectable operator 2210 will negate the search feature and
cause all items to be displayed again until the next search is
performed.
[0187] "New" user selectable operator 2214 brings up the "New"
interface for creating new rendering elements in the database. This
interface is almost identical to the "View/Edit" rendering elements
interface 2300, with the exception of the header, which reads
"Create New Rendering Element". A default name and description is
shown, and the file name window is initially empty. Attempting to
save with the same name as an already existing rendering element is
not allowed
[0188] "View/Edit" user selectable operator 2212, "Delete" user
selectable operator 2218 and "Add to Publish List" user selectable
operator 2220 function in a manner similar to that described above
for similar features on the UI components list interface 1600.
[0189] In one embodiment, on first viewing rendering elements list
interface 2200, the top row in the list box 2204 is highlighted and
"View/Edit" is the default double-click action. Scroll bars my only
be visible if the list exceeds the size of the list box.
[0190] FIG. 23 shows an exemplary "View/Edit" rendering elements
interface 2300. "View/Edit" rendering elements interface 2300
allows a user to view and edit detailed information in an
individual rendering element. When saved, the rendering element is
stored in the database as a link to a named file in the file table,
along with any associated data, such as name, languages, etc.
[0191] "Name" text field 2302 allows a user to change the business
name of the rendering element. When this interface is accessed by
using the "New" user selectable operator 2214 from the rendering
elements list interface 2200, this field allows the user to enter
the name of a new rendering element.
[0192] "File" text field 2304 allows the user to enter the name of
a file in the file table to associate with this rendering element.
Alternatively, the user can use the "Browse" user selectable
operator 2306 to browse the file system to find a physical file to
associate with the rendering element. When selected, this physical
file path is compared to the existing file table. If a match is
found, that named file in the table is used, and the name appears
in the "File" text field 2304. If no match is found, an entry in
the file table is created automatically for the user, and that
named entry appears in the "File" text field 2304 instead.
[0193] "Save" user selectable operator 2308 causes the tool to save
the rendering element data to the database. If creating a new
rendering element, the saving over an existing rendering element is
not allowed. If editing an existing rendering element, and the
rendering element's name has been changed, the tool launches a
confirmation pop-up if attempting to save over an existing named
rendering element. Otherwise, the save is performed automatically,
the "View/Edit" rendering elements interface 2300 is closed, and a
"rendering element Successfully Saved" message appears in a header
of the rendering elements list interface 2200.
[0194] "Languages Checked" list box allows the user to set one or
more languages that the rendering element will be used for during
rendering. At least one language must be selected before saving. In
one embodiment, because there can be more than one file associated
with a named rendering element, there must not be a match between a
checked language and checked renderer associated with one file in
the file table, and a checked language and renderer associated with
another file in the same named rendering element.
[0195] "Renderer Select" list box 2312 allows a user to set one or
more renderers that the rendering element will be used for during
rendering. At least one renderer must be selected before saving. In
one embodiment, because there can be more than one file associated
with a named rendering element, there must not be a match between a
checked language and checked renderer associated with one file in
the file table, and a checked language and renderer associated with
another file in the same named rendering element.
[0196] "Cancel" user selectable operator 2314 closes the
"View/Edit" rendering elements interface 2300 and returns the user
to the rendering elements list interface 2200. Changes that may
have been made in the "View/Edit" rendering elements interface
2300.
[0197] FIG. 24 shows an exemplary files list interface 2400. Files
in the database file table are explicitly created by a user, for
example a page developer, or automatically created during the
creation or editing of page elements such as rendering elements or
assets. Files comprise the elements of the system that reference
actual physical files in, for example, a hard-disk based file
system. Files contain the contextual information needed for other
elements of the system to correctly reference physical files for
activities such as the display of file-based images, flash
animations, etc. within an IDML defined page.
[0198] The files list interface 2400 interface shows all of the
files in a particular database, for example database 702, with
links to editing interfaces, as well as giving the ability to add
selected files to a publishing list. Search capabilities may be
enabled in this interface as well.
[0199] List box 2404 displays all of the files in a particular
database. Individual items are selected using a single-click or
other suitable selection method. A shift-click allows the user to
select a range of items, and a ctrl-click allows the selection of
additional single items. Double-clicking an item brings up the
"View/Edit" files interface 2500 (See FIG. 25) for that item. Items
may be sorted by a particular header category by clicking on that
category. Clicking again in a particular category causes the items
to be sorted in reverse order.
[0200] Given a particular search string in "Search Name/File
Name/Path" text box 2406, and given the search area defined by the
selection of either the "Name" or "Path" radio buttons, generally
referred to by the numeral 2224, selecting the "Search" user
selectable operator 2408 will cause the list box 2404 to display
only the items that match the search criteria. For instance,
entering "comedy" in the search string, selecting the "Name" radio
button, and selecting the "Search" user selectable operator 2408
will cause only those items with the string "comedy" somewhere in
the name to be displayed. Selecting the "View All" user selectable
operator 2410 will negate the search feature and cause all items to
be displayed again until the next search is performed.
[0201] "New" user selectable operator 2414 brings up the "New"
interface for creating new files in the database. This interface is
almost identical to the "View/Edit" files interface 2500, with the
exception of the header, which reads "Create New File". A default
name is shown, and the file (path) window is initially empty.
Attempting to save with the same name as an already existing file
is not allowed.
[0202] "View/Edit" user selectable operator 2412, "Delete" user
selectable operator 2418 and "Add to Publish List" user selectable
operator 2420 function in a manner similar to that described above
for similar features on the UI components list interface 1600.
[0203] In one embodiment, on first viewing files list interface
2400, the top row in the list box 2404 is highlighted and
"View/Edit" is the default double-click action. Scroll bars my only
be visible if the list exceeds the size of the list box.
[0204] FIG. 25 shows an exemplary "View/Edit" files interface 2500.
"View/Edit" files interface 2500 allows a user to view and edit
detailed information in an individual file item. When saved, the
file item is stored in the database as a path to a physical file,
along with any associated data, such as name, languages, etc.
[0205] "Name" field 2502 allows the user to change the business
name of the file item. When this interface is accessed by using the
"New" user selectable operator from the files list interface 2400,
this field allows the user to enter the name of a new file
item.
[0206] "File" text field 2504 allows the user to explicitly enter
the path of a physical file. Alternatively, the user can use the
"Browse" user selectable operator 2510 to browse the file system to
find a physical file.
[0207] "Save" user selectable operator 2508 causes the tool to save
the file item data to the database. If creating a new file item,
the saving over an existing file item is not allowed.
[0208] If editing an existing file item, and the file item's name
has been changed, the tool launches a confirmation pop-up if
attempting to save over an existing named file item. Otherwise, the
save is performed automatically, the "View/Edit" files interface
2500 is closed, and a "File Successfully Saved" message appears in
the header of the files list interface 2400.
[0209] "Cancel" user selectable operator 2514 closes the
"View/Edit" files interface 2500 and returns the user to the files
list interface 2400. Changes that may have been made in the
"View/Edit" files interface 2500.
[0210] FIG. 26 shows an exemplary publishing list interface 2600.
Publishing list interface 2600 serves as a sort of "shopping cart",
and contains all of the items that have been added to the
publishing list from other list interfaces described above, using
the "Add to Publish List" user selectable operators. Once this list
has been created to the tool user's satisfaction, the user can then
use the "Publish To . . . " user selectable operator 2608 to move
the listed items from the "Source" database and file system to the
"Destination" database and file system. The "Destination" is
selected from the drop-down list next to the "Publish To . . . "
user selectable operator.
[0211] List box 2610 displays all of the items within the "Source"
database that have been added to the "to be published" list.
Individual items are selected using a single-click or other
suitable selection method. A shift-click allows the user to select
a range of items, and a ctrl-click allows the selection of
additional single items. Double-clicking an item brings up the
"View/Edit" interface for that item. Items may be sorted by a
particular header column category by clicking on that category.
Clicking again in a particular column category causes the items to
be sorted in reverse order. This is not to be confused with the
"Category" header in the list box 2610, which denotes the TYPE of
each element within the list box 2610. Also note that the
publication "Status" of a particular item is either "PENDING" or
"ERROR". "PENDING" means that the item has yet to be published,
whereas "ERROR" means that a prior attempt to publish the item was
unsuccessful.
[0212] "View" user selectable operator 2602 brings up the
"View/Edit" interface for the selected item in the list box. If no
items, or multiple items are selected, this user selectable
operator has no effect. Double-clicking an item in the list box
2610 has the same effect as clicking this user selectable
operator.
[0213] "Clear Selected" user selectable operator 2604 removes all
selected items from the list box 2610, effectively removing them
from the "to be published" list. If no items are selected, this
user selectable operator has no effect.
[0214] "Clear All" user selectable operator 2606 removes all items,
whether selected or not, from the list box 2610, effectively
removing them from the "to be published" list.
[0215] FIG. 27 shows an exemplary "View/Edit" configuration
interface 2700. This "View/Edit" configuration interface 2700 is
opened by selecting "File/Configure" (not shown) from the files
list interface 2400. It allows the user to set and save global
system and file configuration data for the tool. This includes IP
addresses for the various environments in the publishing pipeline,
along with root file system paths that are used to create and
manage relative path data for file objects within the database.
Finally, the tool user can set the error checking level that is
applied whenever an attempt is made to save a UI component or
action to the database.
[0216] Selecting one of "Environment Selection" radio buttons
("Development", "Staging", "QA" and "Live"), generally referred to
by the numeral 2702, allows the user to set the "active" or
"source" environment for direct editing using the tool. Note that
it is good practice to reserve most or all editing tasks for the
Development environment, and only set the source environment to
Staging or QA when the intent is to use the publishing elements of
the tool to move data and files to the next stage in the pipeline.
Potentially, in an "emergency fix" situation, one could edit in the
Development database and directly publish to the Live
environment.
[0217] "Web Service IP Address" text field 2704 allows a user to
enter addresses that tell the tool where to find the instances of
the system services for each stage in the publishing pipeline. Each
instance of a server-side system database within the publishing
pipeline is accessed by a unique instance of the backend
"services". In one embodiment, these services are a set of
SOAP-based APIs that allow the tool and other clients to
communicate with the databases in a controlled and well defined
fashion.
[0218] "Root File Path" text field 2706--For each stage in the
publishing pipeline, a disk-based file system is also used to store
physical files that are used by the system. Since relative paths
are stored in the database file objects, the tool must know how and
where to manipulate (move) physical files whenever items in the
database are published that have associated physical files. Also,
when creating new file-based items in the database, the path of the
"active" or "source" environment is used as the root for the file
search/select interface. When a file is actually selected, this
root path is then stripped from the full path of the file to
provide a relative path that is subsequently saved to the
database.
[0219] "IDML Error Level" radio buttons, generally referred to by
the numeral 2708, set the error-checking level that is applied when
the user attempts to save a UI component or action to the database.
"Ignore" allows the saving of IDML without any warnings or errors.
"Warn" allows the user to know where and why IDML errors occurred,
but allows the user to save anyway, should the user so choose.
"Trap" works like the "Warn" setting, but will not allow the saving
of IDML without the user first correcting the problems. When errors
or warnings DO occur, a list of errors is shown, and the user can
double-click or otherwise select any particular error to be taken
to the relevant line of IDML within the editing interface.
[0220] "Apply" user selectable operator 2710 changes the settings
to reflect any changes that the tool user has made within this
interface. A configuration file is saved as well, so that the
user's new settings will be enabled on startup of the next
session.
[0221] "Cancel" user selectable operator closes the "View/Edit"
file configuration interface 2700 and returns the user to the files
list interface 2400. Changes that may have been made in the
"View/Edit" file configuration interface 2700 are not saved.
[0222] It is to be understood that even though numerous
characteristics and advantages of embodiments of the present
invention have been set forth in the foregoing description,
together with details of the structure and function of embodiments
of the invention, this disclosure is illustrative only. Changes may
be made in detail, especially matters of structure and management
of parts within the principles of the present invention to the full
extent indicated by the broad general meaning of the terms in which
the appended claims are expressed.
[0223] For example, although embodiments of the invention's system
and method have been described wherein particular components of the
system are located on one of either the server-side or the
client-side, these embodiments should not be considered as
limiting, as particular components may be used on either the
server-side or the client-side.
[0224] Furthermore, although embodiments of the present invention
described relate to server systems using a stateless protocol,
statefull protocols are also within the scope of the present
invention. Thus, embodiments of the present invention might be used
in conjunction with a shopping cart application to exchange, for
example order and financial information. Statefull protocols may be
implemented by, for example, augmenting the language defining the
relatively abstract format, such as IDML, with the ability to
execute procedural logic. More specifically, augmenting the
language defining the relatively abstract format with the ability
to handle programmatic elements such as, but not limited to,
variable substitution, short-circuit logic, variable defined loops,
branching, exception handling, function calling, lexical scoping,
method invocations, and reference mechanisms to external pieces of
code written in IDML or other language defining the relatively
abstract format.
[0225] Besides augmenting the IDML or other language defining the
relatively abstract format to handle the aforementioned
programmatic elements, the system itself should be able to process
this new augmented version of the language. This may require the
inclusion of a parser and code generation mechanism that can handle
the parsing of the new elements as well as the generation of
executable code therefrom. An example of such parsing and code
generation mechanism that may be used in the implementation is the
JSP engine that is currently used in other aspects of current
embodiments of the system and method for platform and
language-independent delivery of page-based content. Once the
executable code is generated, systems and methods according to
embodiments of the present invention will then handle
parameterizable programmatic elements that may contain statefull
information. Embodiments of the present invention may contain a
hybrid of stateless and statefull information.
[0226] In addition, although embodiments of the system and method
for platform and language-independent delivery of page-based
content has been described as being implemented by a page
developer, embodiments of the present invention may be offered to
average consumers in the form of a shrink-wrapped user-friendly
product for implementing pages on, for example, personal or small
business websites, or other pages, for example non-HTTP pages.
[0227] Also, embodiments of the present invention may be
implemented wherein advertisements in the form of, for example, a
SWF file enabled to communicate with a system as described above,
would be provided to commercial or other users. The advertisement
may "call back" to the system, for example on a periodic basis, to
be updated. Thus, the advertisement would be syndicated from, for
example, the system server to multiple clients. As an example,
after the original advertisement has been provided to users, the
advertisement may be modified to include a "Free shipping"
announcement. The modification may be propagated by the
advertisements "calling back" to the system. In other embodiments,
an advertisement may be included on a compact disc ("CD") mailed to
consumers. An application or other product distributed on the CD
may then periodically and automatically update itself by contacting
the system.
[0228] Furthermore, embodiments of the present invention may be
implemented wherein a GUI builder translates into the relatively
abstract format, for example IDML, instead of, for example, into an
HTML file. For example, it is possible to build a WYSIWYG (What You
See Is What You Get) GUI system to aid in the generation of IDML
code. This system may allow users to manipulate graphical objects
that are representations of IDML code. This will allow users not
skilled in the generation of IDML to utilize the system
effectively, hence reducing the need for IDML trained personnel to
make use of the system.
[0229] Thus, a system and method for platform and
language-independent delivery of page-based content has been
described. Embodiments of the present invention provide a system
and method for accepting content defined in a relatively abstract
format and transforming the relatively abstract format input into a
specific recognized platform format for a particular device or
device category. Embodiments of the present invention further
provide a system and process for creating, modifying and managing
platform and language-independent pages, which can then be viewed
and interacted with by end-users, the same pages being displayed on
multiple platforms and in multiple languages. Embodiments of the
present invention also provide a relatively abstract format for
defining content in a data source. The relatively abstract format
may be transformed into multiple platform formats in client-side
applications' user interfaces in multiple human languages.
[0230] In one embodiment, a system and method for platform and
language-independent delivery of page-based content implements a
Model-View-Controller architecture comprising a plurality of
servlet filters, a servlet pipeline and a plurality of rendering
processors for client detection, client tracking, relatively
abstract format preprocessing, relatively abstract format
processing and validating, and transforming and rendering of the
relatively abstract format into multiple platform formats in
client-side applications' user interfaces in multiple human
languages.
[0231] In another embodiment, a system and method for platform and
language-independent delivery of page-based content implements a
creation, modification and management tool that allows a page
creator or publishing team to create, modify, and manage platform
and language-independent page-based content. These pages can then
be viewed and interacted with by end-users, with embodiments of the
system and method for platform and language-independent delivery of
page-based content being used to display the same pages on multiple
platforms, and in multiple languages.
[0232] In yet another embodiment, a relatively abstract format in
the form of an interface definition mark-up language ("IDML") is
provided for defining content in a relatively abstract format to be
transformed into multiple platform formats in client-side
applications' user interfaces in multiple human languages. In one
embodiment, IDML is a subset of eXstensible Mark-up Language
("XML") and may be fully compliant with all XML standards. IDML is
used to define user interface elements within embodiments of the
system and method for platform and language-independent delivery of
page-based content. Keywords and rules are defined for IDML which
allow a user to accurately specify a user interface to be rendered
by a rendering group within the system for platform and
language-independent delivery of page-based content.
[0233] Having disclosed exemplary embodiments and the best mode,
modifications and variations may be made to the disclosed
embodiments while remaining within the scope of the invention as
defined by the following claims.
* * * * *