(12) United States Patent
`US 7,814,423 B2
`(0) Patent No.:
`Musson etal.
`Oct. 12, 2010
`(45) Date of Patent:
`
`US007814423B2
`
`(54)
`
`(75)
`
`(73)
`
`(*)
`
`(21)
`
`(22)
`
`(65)
`
`METHOD FOR PROVIDING A GRAPHICAL
`USER INTERFACE
`Inventors: Scott Musson, Arvada, CO (US);
`Christopher Jolley, Broomfield, CO
`(US); George Murnock, Longmont, CO
`(US); Subrahmanyam Allamaraju,
`Longmont, CO (US); Brodi Beartusk,
`Lafayette, CO (US); Robert Bergman,
`Denver, CO (US); James D’Ambrosia,
`Westminster, CO (US); Kevin Blair
`Frender, Longmont, CO (US); Stephen
`Hetzel, Boulder, CO (US);
`Purushotham Babu Naidu,Lafayette,
`CO (US); Sameer Sawant, Boulder, CO
`(US)
`Assignee: BEA Systems, Inc., Redwood Shores,
`CA (US)
`
`Notice:
`
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.154(b) by 790 days.
`Appl. No.: 10/788,876
`od.
`Filed:
`
`Feb. 27, 2004
`
`Prior Publication Data
`US 2005/0108647 Al
`May19, 2005
`
`(56)
`
`References Cited
`U.S. PATENT DOCUMENTS
`5,295,243 A *
`3/1994 Robertsonet al. ces 715/848
`6.115.040 A
`9/2000 Bladowet al
`622, 145 B1*
`4/2001 Hearst
`........cececeeeeeeeees 703/22
`6,249,291 Bl
`6/2001 Poppetal.
`
`........... 715/744
`6,268,852 BL*
`7/2001 Lindhorst et al.
`6,327,628 BL* 12/2001 Anuffetal. occ 719/311
`6,486,895 Bl
`11/2002 Robertsonetal.
`6,671,853 Bl
`12/2003 Burkett etal.
`6,778,193 B2*
`8/2004 Biebesheimeretal. ...... 715/805
`6,961,750 Bl
`11/2005 Burd etal.
`7,028,261 B2*
`4/2006 Smythetal. wo. 715/744
`
`(Continued)
`OTHER PUBLICATIONS
`
`Hunteret al., “Java Servlet Programming”, Apr. 2001, 19 pages, 2nd.
`Edition.
`
`(Continued)
`ontinue
`Primary Examiner—Dennis-Doon Chow
`Assistant Examiner—Anil N Kumar
`(74) Attorney, Agent, or Firm—Flicsler Meyer LLP
`
`(57)
`
`ABSTRACT
`
`Related U.S. Application Data
`
`(60)
`
`Provisional application No. 60/450,991, filed on Feb.
`28, 2003.
`
`
`
`A method for rendering a portal graphical user interface
`(GUI), comprising providing for the representation of a GUI
`desktop, a GUI look and feel, and a GUI book as a set of
`controls wherein the controls can be organized in a logical
`hierarchy, traversing the representation, wherein the travers-
`Int. Cl.
`(51) ing comprises associating a theme withafirst control in the
`GO6F 3/048
`(2006.01)
`set of controls, rendering the first control according to the
`theme, rendering any descendentsofthe first control accord-
`G06F 3/00
`(2006.01)
`ing to the theme, wherein any descendentsofthe first control
`US. CL. ccc 715/744; 715/778; 715/779;
`can override the theme, and whereinoneofthe set of controls
`715/746; 715/747
`can communicate with another of the set of controls.
`Field of Classification Search................. 715/744,
`715/778, 779, 747, 746
`See application file for complete search history.
`
`(52)
`
`(58)
`
`40 Claims, 9 Drawing Sheets
`
`Process Request
`
`200.
`Map Requesttoa
`Control Tree
`Factory
`
`302
`Generate a Control
`Treefrom the
`Factory
`
` Done
`
`
`Evaluate the
`Control Tree based
`on the Request
`308
`Provide a
`Response
`
`Page 1 of 25
`
`GOOGLEEXHIBIT 1032
`
`Page 1 of 25
`
`GOOGLE EXHIBIT 1032
`
`

`

`US7,814,423 B2
`Page 2
`
`U.S. PATENT DOCUMENTS
`
`
`
`
`
`Hunter, “Java Servlet Programming”, 2001, pp. 261-267, O’Reilly &
`Co.
`
`Hunter, “Java Servlet Programming”, 1998, 27 pages, O’Reilly,
`9/2006 Ballard et al.
`7,111,243 BL*
`........
`vee 715/744
`
`Copyright 2001.
`7,155,678 B2* 12/2006 Cooperetal. ..
`. 715/744
`Knudsen,ei al., “Learning Java”, May 2000, 48 pages, O'Reilly &
`vee T15/765
`7,203,909 B1*
`4/2007 Horvitz et al.
`Associates,Inc.
`7,548,946 B1*
`6/2009 Saulpaugh etal.
`.......... 709/203
`Hunter, “Java Servlet Programming”, 1998, pp. 485-486, O'Reilly,
`2001/0037287 Al
`11/2001 Broadbentet al.
`Copyright 2001.
`2002/0118226 Al
`8/2002 Hough etal.
`
`2002/0188729 Al—12/2002 Zhouet al. Meckler, “Java and Inter-Applet Communication’, Oct. 1, 1997, 11
`2003/0014442 Al
`1/2003 Shiigi etal.
`pages, Dr. Dobb’s Journal. http://www.ddj.com/java/184410295.
`2003/0023628 Al
`1/2003 Girardotetal.
`Geary, “Graphic JAVA Mastering the JFC”, 1999, 10 pages, Sun
`2003/0055868 Al
`3/2003 Fletcheret al.
`Microsystems,Inc.
`2003/0126558 Al
`7/2003 Griffin
`Bontrager, “Creating A ‘lab Panel”, Bontrager Connection LLP,
`2004/0098360 Al
`5/2004 Witweret al.
`2006, 10 pages. Retrieved from http://willmaster.com/library/tutori-
`2004/0125124 Al
`7/2004 Kim etal.
`als/creating_a_tab_panel.php.
`2004/0133660 Al
`7/2004 Junghuberet al.
`Andersen, “mhtTabPane”, 2002, 10 pages. Retrieved from http://
`2006/0282451 Al
`12/2006 Zhangetal.
`users.cybercity.dk/~ds]58854/articles/mhaTabPane.html, http://us-
`ers.cybercity.dk/~ds158854/articles/mhaTab/readme. html.
`Schildt. The Complete Ref
`, 2002,
`pp. 654-656, Fifth Ed.,
`Foe Tee * PP
`'
`McGraw Hill/Osborne.
`
`OTHER PUBLICATIONS
`
`Moss, “JavaServlets”, 1999, 26 pages, McGraw-Hill.
`
`* cited by examiner
`
`Page 2 of 25
`
`Page 2 of 25
`
`

`

`U.S. Patent
`
`Oct. 12, 2010
`
`Sheet 1 of 9
`
`US 7,814,423 B2
`
`OPEN A HOME EQUITY LOAN TODAY!
`
`STOCKS
`
`CKING ACCOUNTS
`
`ALL ACCOUNTSFDIC INSURED
`
`ABC? 2
`EFG Vv 17
`JKM Y 7
`
`XXXX - $XXX.XX
`XXXX - $XXX.XX
`XXXX -
`$XXX.XXK
`
`Figure 1
`
`Page 3 of 25
`
`Page 3 of 25
`
`

`

`U.S. Patent
`
`Oct. 12, 2010
`
`Sheet 2 of 9
`
`US 7,814,423 B2
`
`Application
`
`200
`
`
`
` Bookiet
`
`206
`
`Theme
`212
`
`Ton
`
`Booklet
`216
`
`
`
`
`Look & Feel
`210
`
`
`
`
`Skeleton
`222
`
`
`
`
`
`
`
`Placeholder
`228
`
`0..n
`
`Portlet
`230
`
`0..n
`
`Booklet
`232
`
`Figure 2
`
`Page 4 of 25
`
`Page 4 of 25
`
`

`

`U.S. Patent
`
`Oct. 12, 2010
`
`Sheet 3 of 9
`
`US 7,814,423 B2
`
`Process Request
`
`Map Requestto a
`Control Tree
`Factory
`
`Generate a Control
`Tree from the
`Factory
`
`Evaluate the
`Control Tree based
`on the Request
`
`Response
`
`Provide a
`
`Figure 3
`
`Page 5 of 25
`
`Page 5 of 25
`
`

`

`U.S. Patent
`
`Oct. 12, 2010
`
`Sheet 4 of 9
`
`US 7,814,423 B2
`
`——_______»»
`Request 470
`
`Container
`
`Figure 4
`
`Page 6 of 25
`
`Page 6 of 25
`
`

`

`U.S. Patent
`
`Oct. 12, 2010
`
`Sheet 5 of 9
`
`US 7,814,423 B2
`
` cnSOOo
`
`JSP Page
`502
`
`JSP Parser Variant
`504
`
`
`
`
`
`Standard JSP Compiler
`506
`
`
`
`Metadata
`
`508
`
`
`JSP Page
`Impl.
`
`510
`
`Request 516
`
`Response 578
`
`
`
`
`Instantiation
`Service
`512
`
`Wire-up
`514
`
`Figure 5
`
`Page 7 of 25
`
`Page 7 of 25
`
`

`

`U.S. Patent
`
`Oct. 12, 2010
`
`Sheet6 of 9
`
`US 7,814,423 B2
`
`
`
`Metadata
`
`602 Wireup Generator
`
`606
`
`
`
`
`JSP Page
`604
`
`
`
`
`Standard JSP Compiler
`608
`
`
` Instantiation
`
`Request 670
`Service
`
`614
`
`
`Response 612
`
`
`
`JSP Page
`Impl.
`618
`
`Figure 6
`
`Page 8 of 25
`
`Page 8 of 25
`
`

`

`U.S. Patent
`
`Oct. 12, 2010
`
`Sheet 7 of 9
`
`US 7,814,423 B2
`
`Request 714
`
`/ 704
`doStartTag()
`getControlTree()
`
`CreateContext()
`
`y 706
`
`J 708
`
`doEndTag() 742
`
`+...
`
`SSResponse 776
`
`RunLifecycleToComplete()
`
`J 710
`
`Figure 7
`
`Page 9 of 25
`
`Page 9 of 25
`
`

`

`U.S. Patent
`
`Oct. 12, 2010
`
`Sheet 8 of 9
`
`US 7,814,423 B2
`
`Interchangeable
`Lifecycle Driver
`804
`
`Interchangeable
`Persistence Driver
`806
`
`Porlet Container
`802
`
`Control Factory
`808
`
`800
`
`Control Tree Container
`
`Response
`
`Request
`
`Client
`810
`
`Figure 8
`
`Page 10 of 25
`
`Page 10 of 25
`
`

`

`U.S. Patent
`
`Oct. 12, 2010
`
`Sheet 9 of 9
`
`US 7,814,423 B2
`
`<%@page
`import="com.bea.netuix.serviets.controls.window.WindowPresentationContext;com.bea.netu
`ix.serviets.contrals.window.TitlebarContext"
`%>
`<%@ taglib uri="render.tld” prefix="render" %>
`<% WindowPresentationContext window =
`WindowPresentationContext.getWindowPresentationContext(request);
`TitlebarContext titlebar
`= (TitlebarContext) window.getFirstChild(“window:titlebar’);
`String expandWidth = "100%";
`x%>
`
`<render:beginRender>
`<div
`<renderwriteAttribute name="id" value="<%= window.getPresentationId() %>"/>
`<render:writeAttribute name="class” value="<%= window.getPresentationClass() %>"
`defaultValue="bea-portal-window'/>
`<render‘writeAttribute name="style” value="<%= window.getPresentationStyle() %>"/>
`<render:writeAttribute name="width"
`value="<%= window.isPacked() ? null : expandWidth %>"/>
`
`> <
`
`%if (titlebar != null) { %>
`<render:renderChild presentationContext="<%= titlebar %>"/>
`<% } %>
`<div class="bea-portal-window-content'>
`</render:beginRender>
`<render:endRender>
`</div>
`</div>
`</render:endRender>
`
`Figure 9
`
`Page 11 of 25
`
`Page 11 of 25
`
`

`

`US 7,814,423 B2
`
`1
`METHODFOR PROVIDING A GRAPHICAL
`USER INTERFACE
`
`CLAIM OF PRIORITY
`
`This application claims priority from the following appli-
`cation, which is hereby incorporated by reference in its
`entirety:
`U.S. Application No. 60/450,991, FRAMEWORK FORA
`PERSONALIZED PORTAL,Inventors: Daryl Olander,et al.,
`filed on Feb. 28, 2003.
`
`COPYRIGHT NOTICE
`
`A portion of the disclosure of this patent document con-
`tains material which is subject to copyright protection. The
`copyright owner has no objection to the facsimile reproduc-
`tion by anyone ofthe patent documentor the patent disclo-
`sure, as it appears in the Patent and Trademark Office patent
`file or records, but otherwise reserves all copyright rights
`whatsoever.
`
`
`CROSS REFERENCE TO RELATED
`APPLICATIONS
`
`‘This application is related to the following co-pending
`applications which are cach hereby incorporated by reference
`in their entirety:
`US. application Ser. No. 10/788,803, Inventors: Scott
`Musson, et al., filed on Feb. 27, 2004, SYSTEM AND
`
`METIHIOD FOR CONTAINING PORTLETS.
`US. application Ser. No. 10/788,530, Inventors: Scott
`Musson,et al., filed on Feb. 27, 2004, METHOD FOR ENTI-
`
`TLING A USER INTERFACE.
`USS. application Ser. No. 10/789,970, Inventors: Daryl B.
`Olander, et al., filed on Feb. 27, 2004, GRAPHICAT, USFR
`INTERFACE NAVIGATION METHOD.
`
`US. application Ser. No. 10/789,016, Inventors: Daryl B.
`Olander, et al., filed on Feb. 27. 2004, METHOD FOR UTI-
`LIZING LOOK AND FEEL IN A GRAPHICAL USER
`INTERFACE.
`
`
`
`
`
`
`
`U.S. application Ser. No. 10/788,801, Inventors: Scott
`Musson,et al.. filed on Feb. 27, 2004, METHOD FOR PORT-
`
`LET INSTANCE SUPPORT IN A GRAPHICAL USER
`INTERFACE.
`
`
`
`USS. application Ser. No. 10/789,135, Inventors: Daryl B.
`
`Olander, et al., filed on Feb. 27, 2004, CONTROL-BASED
`
`GRAPHICAL USER INTERFACE FRAMEWORK.
`
`USS. application Ser. No. 10/789,140, Inventors: Daryl B.
`Olander, et al., filed on Feb. 27, 2004, SYSTEM AND
`METHOD FOR DYNAMICALLY GENERATING A
`GRAPHICAL USER INTERFACE.
`
`US. application Ser. No. 10/789,137 Inventors: Daryl B.
`Olander, et al., filed on Feb. 27, 2004, METHOD FOR
`PROPAGATING LOOK AND FEEL IN A GRAPHICAL
`USER INTERFACE.
`
`BACKGROUND
`
`Developing graphical user interfaces (GUIs) for distrib-
`uted applications such as web portals can present manychal-
`lenges. Not only do end-users expect to customize the content
`a given GUI presents to them, they might also expect to
`customize the look and feel of the GUI. Such customization
`can be coarse-grained, as in changing an overall color
`scheme, but they can also be fine-grained wherein an end-user
`may desire to change the textures, arrangement, behaviors
`
`Page 12 of 25
`
`2
`and other characteristics of the GUI. This presents many
`design challenges, especially if such a GUI 1s deployed in a
`clustered, multi-threaded runtime environment.
`
`FIELD OF THE DISCLOSURE
`
`The present disclosure relates generally to graphical user
`interface development.
`
`
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`
`
`FIG. 1is an illustration of an exemplary web graphical user
`interface in accordance to an embodiment.
`FIG. 2 is an illustration of a web contro] taxonomy in
`accordance to an embodiment.
`PIG.3 is an illustration ofrequest processing in an embodi-
`ment.
`
`FIG.4 is diagram of container processing in accordanceto
`one embodiment.
`FIG. 5 is diagram of a control tree factory having a JSP
`page description implementation in accordanceto an embodi-
`ment.
`
`FIG.6 is diagram of a control tree factory having a meta-
`data page description implementation accordance to an
`embodiment.
`
`FIG. 71s diagram ofa control tree factory having a pure JSP
`page description implementation accordance to an embodi-
`ment.
`
`FIG. 81s a diagram ofa system in accordanceto an embodi-
`ment.
`
`FIG. 9 is asample skeleton JavaServer Page in accordance
`
`to an embodiment. DETAILED DESCRIPTION
`
`The inventionis illustrated by way of example and not by
`way oflimitation in the figures ofthe accompanying drawings
`in whichlike references indicate similar elements. It should
`be noted that references to “an”’ or “one” embodimentin this
`
`disclosure are not necessarily to the same embodiment, and
`such references mean at least one.
`FIG. 1is an illustration of an exemplary web graphical user
`interface in accordance to one embodimentof the invention.
`
`In one embodiment, by wayof example, page 16 is rendered
`upondisplay area 12, which can be a regioninthe display area
`of a device for displaying images and/or producing sounds
`(e.g., a computer monitor). Page 16 is comprised of several
`elements. Page selection tabs 20-28 can cach be selected bya
`user to render a different page. Pages can be thought of as
`panels or panes that can be swappedinto and out ofa display
`region ofthe available portal real estate. By wayof a non-
`limiting example, selection of a GUI element can be accom-
`plished with an input device such as a mouse, a motion detec-
`tor, voice commands, handor eye gestures, etc. Iftab 20 were
`selected, for example, the page corresponding to that tab
`could be rendered. Although the tabs 20-28 in ['IG. 1 are
`displayed horizontally, in another embodimentthe tabs could
`be displayed vertically or using some other suitable scheme
`such as a hierarchical menu.
`
`Within page 16 is display area 10, which includes portlets
`(18, 30, 32) and other elements. A portlet is an application that
`manages its own GUI. Portlets can communicate with each
`other and with other software and hardware components(e.g.,
`Enterprise Java Beans™, Java™ Beans, servlets, applets,
`etc.). The Java™programming language, its libraries, envi-
`ronment, and toolkits are available from Sun Microsystems,
`Inc. of Santa Clara, Calif. The other software and hardware
`
`10
`
`15
`
`20
`
`30
`
`35
`
`40
`
`45
`
`30
`
`55
`
`60
`
`65
`
`Page 12 of 25
`
`

`

`US 7,814,423 B2
`
`3
`components maybepart of the same execution environment
`as the portlet or may be in a different execution environment.
`In one embodiment, a portlet can be implemented with Jav-
`aServer Pages™. By wayof a non-limiting example, portlet
`30 displays real-time stock ticker information. A user could
`configure such a portlet to displaycertain stocks, for example.
`In another embodiment, the user can select a given stock
`displayedin portlet 30 and receive more detailed information,
`such astheprice history, price to earningsratio, etc.
`Portlet 30 can handle user input and responding accord-
`ingly. Portlet 32 displays up-to-date informationpertaining to
`a user’s checking accounts. I ikewise, portlet 32 could pro-
`vide detailed information on transactions if the user were to
`select an account. Advertisement portlet 18 displays an adver-
`tisement that could be directed specifically to the current user
`based on demographicsor other information. Forinstance, if
`a user had an outstanding home loan in goodstanding, the
`advertisement could be for a home equity loan. Likewise, if
`the user had an appropriate amountin a savings account, the
`advertisement could be for a new car loan. Static area 14
`
`4
`customized a desktop. A desktop’s appearance can be deter-
`mined by a Look and Feel control 210. ‘The look and feel
`control can contain a skin component 220 and a skeleton
`component 222. Skins can provide the overall colors, graph-
`ics, and styles used by all components in a desktopinterface.
`Tn one embodiment, skins can include collections of graphics
`and cascading style sheets (CSS) that allow changes to be
`madeto the look and feel ofthe GUI without modifying other
`componentsdirectly. References to images and styles can be
`made in the skin rather than being hard-coded into a GUI
`definition. A look and feel component can provide a path to a
`skin directory to be used.
`The look and feel file can also provides a path to the
`skeleton directory ta be used. Everytype of component, from
`a desktop to a portlet’s title bar, can have an associated JSP
`(Java ServerPages™)file, called a skeletonfile, that renders
`it. For example, each desktop uses a skeletonfile called shell-
`jsp that simply provides the opening and closing <HTML>
`(Hypertext Markup Language) tags to render the desktop. A
`portlet title bar, on the other hand, can have a skeleton file
`calledtitlebar.jsp that is more complex.It contains Java calls
`to various windowing methods in the API, references the
`button graphics to use on the title bar, and determines the
`placementoftitle bar elements with an IITMLtable defini-
`tion.
`
`contains text or an image with text.
`FIG. 2 is anillustration of a control taxonomy in accor-
`dance to an embodiment. One embodimentprovidesa set of
`controls that represent corresponding graphical and func-
`tional clements in web applications. Controls can have prop-
`erties that can be read and set, and controls caninteract with
`A desktopalso can containa booklet control 206. A booklet
`each other through an eventnotification mechanism.In addi-
`control represents a set of pages linked by a page navigator
`tion to properties and events, controls can also have methods
`(menu 214) having a user selectable graphical representation
`which provide services and which maybe overriddento pro-
`(e.g., a series of tabs wherein each tab corresponds to a
`vide specialization of the control. In one embodiment, a con-
`different page, a series of buttons, a menu, or other suitable
`trol can be implemented as one or moreclasses in an object-
`means.) A booklet can provide an indication of the currently
`oriented programming paradigm. Such an arrangement
`selected page through visual clues such as highlighting a
`allows for new properties, events and/or specialized control
`currently sclected tab, displaying text and/or graphicsto indi-
`methods to be provided by extending base control classes
`cate the current page, etc. Booklets can be nested to nlevels.
`related to these features. In a framework, controls can also
`A booklet can optionally include a theme control 212. In one
`serve as containers for other controls. By way of a non-
`embodiment, a theme contro] represents a subset of a skin
`limiting example, a page maycontain a booklet andaportlet,
`componentand can provide a way of using a different set of
`the booklet may contain one or more pages, the portlet may
`styles for individual desktop components. The booklet con-
`trol can also contain other booklets 216.
`contain a window, the window maycontain a title bar which
`may contain a close button, etc.
`Atthe top of the taxonomy, there can be one or more web
`applications 200. A web application represents a collection of
`resources and components that can be deployed as a unit in
`one or more web/application servers. In one embodiment, a
`
`webapplication can represent a J2EE (Java 2 Platform, Enter-
`prise Edition) Enterprise Application. In various embodi-
`ments, a web application can contain one or more controls
`202 representing one or moreportals. 'rom an end-user per-
`spective, a portal is a website whose pages can be navigated.
`From an enterprise perspective, a portal is a container of 5
`resources and functionality that can be made available to
`end-users. Portals can provide a point of access to applica-
`tions and information and maybe one of many hosted within
`a web/application server. In one embodiment,a portal can be
`
`a J2EEapplication consisting of EJB (Enterprise Java Bean)
`components and a set of Web applications.
`In another
`embodiment, a portal can be defined by an XML(Extensible
`Markup Language) file. The portal file can contain all ofthe
`components that make up that particular instance, such as
`booklets, pages, portlets, and look and feel components.
`A GUI can contain one or more desktop controls 204. A
`desktop control in turn can contain one or more personalized
`viewsoruser views (not shown). A user can have one or more
`personalized user views of a desktop. In one embodiment, a
`user view can result from customizing the layout, content,
`number, and appearance of elements within a desktop. A
`default user view can be provided for users who havenotyet
`
`A shell control 208 can render anything surrounding the
`booklet 206 in the desktop 204. For example, a shell control
`might render a desktop’s header and footer. These areas usu-
`ally display such things as personalized content, banner
`graphics, legal notices, and related links.
`A booklet also contains zero or more page controls 218. A
`page control can represent a web page in an embodiment. A
`page is an area of a GUI upon which other elements having
`GUIs, suchas booklets and portlets, can be placed. Pages can
`also contain booklets and other pages, and canbeidentified/
`navigated to by a control such as a menu 214. A page control
`can also hold a theme control 224 and a layout control 226. A
`layout control determines the physical locations of portlets
`and other elements on a page. In one embodiment, a layoutis
`can be implemented as an HTMLtable.
`A layout can contain a placeholder control 228 whichis
`comprised ofindividualcells in a layout in whichportlets are
`placed. A placeholder can contain zero or more booklets 232
`and zero or more portlets 230. A portlet is a self-contained
`application that can render ils own GUI. A portlet is a self-
`contained application that is responsible for rendering its own
`content ona page. By wayofa non-limiting example,a portlet
`might bea display ofcurrent news headlines, wherein ifa user
`selects a headline the portlet retrieves and the underlying
`story and displays it for the user. Portlets can communicate
`with other portlets and with back-end processes such as
`legacy software, databases, content management systems,
`
`40
`
`45
`
`
`
`Page 13 of 25
`
`Page 13 of 25
`
`

`

`US 7,814,423 B2
`
`6
`made to data and raise events before either redirecting to a
`new page or simply displaying the same page again. In one
`embodiment, multiple control scopes can be provided as
`described in Table 1.
`
`5
`In addition, multiple
`enterprise business services, etc.
`instances of a portlet can execute simultaneously. A portlet
`can also contain a theme 234.
`A control tree can represent a particular instance of the
`control taxonomy. In one embodiment, each node inthe con-
`TABLE 1
`trol tree can be a subclass of a Control class in an object-
`oriented paradigm. A control tree can be created with both —_—
`
`statically created controls and dynamically created controls.ObvetScopesinanEmbodiment
`Statically created controls are created during a construction
`SCOPE
`DESCRIPTION
`(or “wire-up”) phase of the control tree and, in one embodi-
`ment, can be based onstatic markup. Dynamically created
`Request
`An object is accessible forthelife of the request.
`controls are created during a control tree lifecycle, many
`Page
`An objcct is acecssible across subsequent requests
`:
`:
`:
`:
`“e
`to a page. In one embodiment, a pagehas a lifetime
`timesin reaction to state, context, and events. Both kinds of
`that can inchide a postbackcycle.
`controls can create content either dynamically (c.g., by bind-
`An object is accessible for thelife of the session. (This is
`ing to a database table) or statically (e.g., by containing a 15
`available for protocols that suppor! session.)
`literal string).
`An object is accessible within a named scope defined by a
`ca:
`:
`webflow. A Webflow is a set ofstates that control
`Controls within a contro] tree can have unique names. In
`navigation
`f
`b
`oS
`vigation from one web page to another.
`:
`”
`addition, controls can have local namesthat are qualified into
`Application An object is accessible globally within the application.
`a scope. This can allow for controls to be searched for based
`.
`upon their “local” name within a naming scope. In one 20
`Tn one embodiment, manyofthe classes can be sub-classed
`embodiment, the system can use a control’s unique name for
`to provide specializations and custom features. It will be
`identifying it in operations such as saving andrestoring state
`apparent to those skilled in the art that many more such
`during the cycle of HTML postbacksto the page. Postback
`
`occurs whena form onapagetargets the same page. Whenthe classes are within the scope andspirit of the present disclo-
`form is submitted, the second request for the page is called a 25
`sure. Table 2 provides an overview of classes in one embodi-
`postback. The postback allows the page to handle changes
`ment.
`
`5
`
`10
`
`Session
`
`Webflow
`
`TABLE 2
`
`Framework Controls in an Embodiment
`
`DESCRIPTION
`
`
`
`CLASS/
`INTERFACE
`
`Control
`
`Lifecycle
`
`NamingScope
`
`Context
`
`Page 14 of 25
`
`The basic framework building block. The base Control class
`defines a set of services available to all controls. This class
`defines and provides a set of services to subclasses including
`lifecycle, naming, and child management.
`A lifecycle driver will drive the control-tree through a well
`definedset of states. For a control, the lifecycle is defined by a
`set of methods representing stages in the lifecycle. A control
`can override methodsofthe lifecycle in order to provide
`specialized behavior. For example, most controls will override
`beginRenderto renderits specific representation to an output
`stream. The stages provide well defined places to acquire
`resources, managestate, raise events, tender themselves, etc.
`Mostlifecycle stages consist oftwo methods that are called by
`the lifecyele driver. The naming pattern of the two methods is
`Xxxx and fireXxxx. The Xxxx methodis overridden by
`subclasses to specialize the lifecycle stage. The fireXxxx
`methodis overridden if a control wants to change howthe event
`associated with the lifecycle stage is fired.
`Defines methods called during the control’s lifecycle. There are
`two methods for most lifecycle events. The lifecycle method
`xxx is called first to provide the lifecycle service for the control.
`Then an onXxx methodis called to raise an event. In one
`embodiment, all of the lifecycle stages prior to rendering raise
`events through the onXxx method.
`The Control and the NamingScopeinterface interact to provide
`support for uniquely naming a control within a tree. Unique
`names are generated automatically when controls are added to
`an existing control-tree. Unique namesare usedforstate
`management. Controls have three types of names:
`Id - This is a user assigned value that should be unique within a
`name scope.
`Scopeld - ‘This is a generated namethat is unique within a
`scope.It is either the Id or a generated name.
`Uniqueld - Thisis the globally unique nameof the control.
`This nameis typically used to identify state and identify the
`control within a HTML Form.
`Context is an abstract class providing services to controls in the
`tree. In one embodiment, these services are protocol-
`independent.It is the container’s responsibility to create the
`context object. The container can create an objcct that
`
`
`
`
`
`Page 14 of 25
`
`

`

`US 7,814,423 B2
`
`7
`
`TABLE2-continued
`
`Framework Controls in an Embodiment
`
`CLASS/
`INTERFACE
`
`DESCRIPTION
`
`subclasses Context and provides container aware controls with
`additional services such as information about the framework andor protocol.
`By way ofa non-limiting example, a container can be a servlet
`providing a framework. The Context can contain both HTTP-
`specific information and web application-specific information.
`A Portlet control that is portal-aware can cast the Context into
`the subclass and access these services. Well-designed controls,
`which are aware cf one or more containers, can be written to
`work orfail gracefully when they are used within the context of
`the generic Context.
`Context provides the following services:
`Access to the Abstract Data Layer - Context will provide an
`object implementing the interface providing an abstract data
`layer.
`Request Type - The Context contains properties indicating what
`type of request is happening such as “newrequest”, “postback”,
`etc.
`Request Information - The Context provides information that
`comes from the request such as request parameters, requested
`URL,etc. This information may be unavailable for protocols
`that don’t support it.
`Generic Services - The context allows controls to access and
`register as service providers to other controls. For example, a
`StyleBlock control may register as the StyleHandler object that
`will create a single style sheet for an output IITML document.
`Other controls may pushstyle definitions into the StyleHandler.
`These services will typically be used by a set of framework
`aware controls and will support things such as styles, URL
`rewriting, etc.
`Rendereris an interface that allows a class to be created and
`which acts as a rendering proxy for a control. A control has
`rendering methods allowing the control to outputits
`representation into a stream. There are two primary methods for
`rendering; beginRender( ) and endRender( ). Default rendering
`can be overriddenby setting a control’s renderer by providing
`an object implementing the Renderer interface.
`
`Renderer
`
`FIG.3 is an illustration ofrequest processing in an embodi-
`ment. Although this figure depicts functional steps in a par-
`ticular order for purposes of illustration, the process is not
`limited to any particular order or arrangement of steps. One
`skilled in the art will appreciate that the various steps por-
`trayed in this figure could be omitted, rearranged, combined
`and/or adapted in various ways.
`In one embodiment, a GUI is rendered in response to a
`request (e.g., an HTML request originating from a web
`browser). In step 300, a process (c.g., a web/application
`server or other suitable process) can accept the request and
`map it to a control tree factory. In step 302, the identified
`factory can be used to generate a controltree representing the
`GUI. In step 304, the control tree can be evaluated based on
`the contents of the request. In doing so, the control tree can be
`driven through a sequence oflifecycles that allow for indi-
`vidual controls in the tree to, by way of a non-limiting
`example, process the request, interact with each other and a
`context provided by the container, and produce a response.
`Finally, in step 306 the process can provide a responseto the
`sender of the request. In one embodiment, this response can
`contain output for GUI rendering (e.g., HTMLorother suit-
`able GUIdescription) from one or more controls.
`In one embodiment a container (not shown) can run the
`control tree through a sequence of one or morelifecycles by
`employingthe services of an interchangeablelifecycle driver
`(not shown). In one embodiment, a control or a container can
`customizethe lifecycle. Customization can include removing
`and/or reordering defined lifecycle stages and/or adding new
`
`40
`
`45
`
`60
`
`65
`
`stages. All of the controls in the control tree can participate in
`the lifecycle, but do not have to. The purpose ofthe lifecycle
`is to advance the control tree thougha set of states. These
`states permit controls to obtain their state and resources,raise
`and handle events, save their state, communicate with other
`controls, render themselves, and free resources. The lifecycle
`is external to the control tree and can be provided bythe
`container. This allows for easy modificationofthe lifecycle.
`In one embodiment, controls can register to raise and catch
`events to perfect
`inter-control communication. An event
`mechanism allows controls to specify (or register for) events
`that they will raise and/or listen for. In one embodiment, this
`can be accomplished with two methods. A method named
`“xxxx” represents the lifecycle methoditself and is usually
`sub-classedto provide specialized behavior for the control. A
`method named “‘fireXxxx” can be invoked to cause an event
`
`notification that the lifecycle method xxxx has run on the
`control. This method can be overriddento provide specializa-
`tion of event firing. By way of a non-limiting example, a
`control could suppressfiring of an event by overriding it and
`doing nothing. When an eventis raised, all controls that have
`registered to receive it will be given an opportunity to handle
`the event(e.g., through a call-back mechanism). There is no
`limit on the numberofeventsthat can be raised or caught. By
`way of a non-limiting example, a form control couldraise an
`event when a user enters text in a text field of a GUI repre-
`sentation of the form. This event could be caught by a button
`on the same pageas the form. The button could then un-dim
`
`Page 15 of 25
`
`Page 15 of 25
`
`

`

`US 7,814,423 B2
`
`9
`itself based on a determination of whether a user entered a
`valid character sequenceinto the form.
`Controls can be dynamically addedto thetree at any stage
`of the lifecycle up until a pre-render stage. When controls are
`added to an existing tree dynamically, these newcontrols can
`participate in the full lifecycle. In one embodiment, a life-
`cycle catch-up process can drive the new controls through the
`lifecycle until they catch-up to the current stage. All lifecycle
`stages before the rendering stage can raise events. In one
`embodiment, a container can implementthe lifecycle stages
`i