United States Patent
`
`[19]
`
`[11] Patent Number:
`
`6,075,528
`
`Curtis
`
`[45] Date of Patent:
`
`Jun. 13, 2000
`
`US(l(}6075528A
`
`[54 GRAPHICAL USER IN'l‘l€RFACI£ STREAM
`I’R( )C ESSOR
`
`Attorney. Agent. or i‘i'irm—Robcrt V. Wilder; I. .cs]ic A. Van
`I .ccuwc|1
`
`|7S
`
`lnvcntor: Bryce Allen Curtis. Rounrl Ruck. Tax.
`
`[S7]
`
`/\BS’l‘R!\C'l‘
`
`[7'3: Assigncc:
`
`International Business Machines
`(jurpnratinn, Armnnk, N.Y.
`
`i3'
`APP1-N0-1039543647
`I33 W‘:
`°'~'*- 2"» “'97
`|5l
`Int. Cl.’ .................................................... .. G06l*‘ 15300
`[52‘ U.S. Cl.
`........................ .. 345,333; 345..-"356; 707x513;
`';{17;g(|3; 7(;9..«33(}; 7(;.g..-gzm
`.
`345x333. 356;
`203; 7{]9I.f'22[]’ 246
`
`Field of Search
`
`[ssj
`
`|5(,
`
`References Cited
`,
`U-S PAFENT DOCUMENTS
`11,.-‘tans Van llnft‘
`................................ 1013513
`
`:'~..*m2_.53n
`
`A mclhud and implementing computer system is provitlctl in
`which a function (If applcl for example may be downlttaclcd
`from a network st.-rvcr and graphical user interface (GUI)
`processor interprets a data stream consisting of GUI controls
`and attributes, and places the controls and attributes in a
`iiIZTli§l?“§?t.§_‘S§‘§t°‘£2.51“ fFE§‘§3S.T§I“’~f;‘E§E
`l.am_1uagc) from a GUI (Graphical User Interface) slrcam
`pwcv-War apple! from ‘H W--‘b sUW<:r- The web browser Ihvn
`loads lhc (jUI stream |JrUCUS.‘5U]' (USP) from the web server
`and hcsins cxecuting Ihc GSP- The G3!’ then rcqucsls Ihc
`(EU! slrcam l'mrn the web st.-rvcr by opening a stream In a
`lilc, (TGI (Common Gateway Intcrfacc) script or scrvlcl on
`the server. The USP than receives the GUI stream and
`amcntlalcs the user interface in the JAVA applet presentation
`space managed by the browser. The G51’ may pcriotiically
`“|“1“'° il-“‘—'1H’3' r“|’°"‘i“L-‘- “'1” 1*‘-5‘ ‘W0 5‘°I”9'
`
`."’rimmj_r I-.';t‘r.'mimer—Ba lluynh
`
`15 Claims, 2 Drawing Sheets
`
`303
`
`3"“
`
`304
`
`305
`
`File Edit ViewGo Bookmarks Options Directory
`
`;-
`
`«W»
`K—»
`sssss
`
`an
`
`0001
`0001
`
`Apple/Twitter
`Apple/Twitter
`Ex. 1023
`Ex. 1023
`IPR2 of U.S. Pat. No. 8,612,515
`IPR2 of U.S. Pat. No. 8,612,515
`
`

`
`U.S. Patent
`
`Jun. 13, 2000
`
`Sheet 1 of 2
`
`6,075,528
`
`
`
`,.-— 201
`
`-. 205
`
`2/
`
`-/
`
`/” m
`
`‘J 209
`
`-210
`
`W
`
`//,..-2o3
`
`21: __fi_\
`
`\
`
`2”
`
`\
`
`IN?{IT
`FACE
`
`NETWORK
`INTERFACE
`
`223-,‘
`
`KEYBOARD
`
`’'___F 2
`
`ZIB -
`
`219 _‘
`
`\\
`STORAGE
`DEVICE
`
`X
`\I
`
`]]]s1{E']']'E
`BRWE
`
`"MT
`
`/fix 220
`
`VEDEO
`SWSWEM
`
`-221
`
` —/
`
`FIG. 2
`
`0002
`0002
`
`

`
`U.S. Patent
`
`Jun. 13, 2000
`
`Sheet 2 of 2
`
`6,075,528
`
`308
`.
`
`.,—- 304
`
`HUI!
`
`305K’
`"" M
`
`Jvlll
`
`0003
`0003
`
`

`
`6,075,528
`
`1
`G RAPHICAI. USER INTERFACE STREAM
`l’R()CESS()R
`
`FIELD ()F TI-IE INVENTION
`
`invention relates generally to information
`The present
`processing systems and more particularly to a methodology
`and implementation for facilitating graphical user interface
`changes for user applications.
`BACKGROUND OF THE INVENTION
`
`In network computer systems. a plurality of computers are
`connected together and one or more of the computers
`generally perform the function of a network server. A
`network may be established through the hard-wired inter-
`connection of a plurality of computer terminals in a local
`network or on a wider scale such as the Internet or world
`wide web which may include telecommunication links. In
`any case, the network server acts as the central control unit
`for providing access to files, programs and program execu-
`tion to the individual computers connected within the net-
`work.
`In general, a networked computer
`terminal will
`.logon. to the network and obtain access to a network server.
`The network server will download a homepage presentation
`on the user’s terminal which may include and audio and
`video ellects. From the initial screen display, a user may
`designate any other .address. to get to another .location. or
`screen display. The user may also select from a plurality of
`functions which may be presented for user selection on the
`initial display.
`Generally, almost all screen displays include designated
`selection areas on the screen where the user may point a
`selection device such as a mouse-controlled pointer, and
`.click. on the designated screen area to invoke a displayed
`function. or menu for other function selection options. When
`the homepage or selection screen is downloaded from the
`server, many small programs or applets. are also down-
`loaded at
`the same time to the user’s terminal memory.
`Those applets are amociated with different ones of the
`designated screen selection areas and are executed when a
`user makes a selection or clicks on one of the selection areas
`on the display. The applets,
`in turn, may call
`for the
`presentation of a new user interface screen, or a new or
`different section of a portion of the screen, such as a pop-up
`menu or other graphical user interface (GUI) which may be
`within a
`framed or windowed sub—section of the main
`homepage.
`The GUI presentation is typically designed and custom-
`ized to present an attractive display and facilitate use of the
`computer interface by a user in making subsequent selec-
`tions or executing selected functional aspects associated
`with the GUI presentation. The GUI display is typically
`displayed as the end result of the execution of a program
`downloaded from the server in response to the user selection
`of a designated screen area. The design and display of the
`GUI screen is typically determined in advance and .hard-
`coded. by a programmer. Thus, on the Internet for example,
`there is no flexibility for different JAVA applet user inter-
`faces to be readily created when the content of the web
`server changes dynamically. In general, this hard—oodcd GUI
`program, which resides at the site of the server, has been
`dilficult and time consuming to modify or make even the
`smallest change. If the GUI presentation screen needed to be
`changed in any aspect, the GUI program would have to be
`re-written, dc-bugged, hard-coded and re-installed on the
`server. Further, if other aspects of the GUI presentation
`needed to be changed at a later time. the same process would
`
`ll!
`
`15
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`2
`apply. As a result, the GUI screens tend to remain the same
`without ever changing to any great extent. This is unattrac-
`tive to a user who may wish to look at different screens to
`minimize an otherwise tedious search on the Internet for
`exampie, and also cumbersome to a network provider who
`may wish to change GUI screen appearance’s on a regular
`basis to enhance the appeal of the particular function with
`which the GUI is associated. Moreover, with an improved
`methodology for changing GUI presentations,
`the GUI
`displays to the user can be more easily and quickly modified
`with relative ease and cost to a network provider. Further,
`sponsorship for GUI displayed functions may be incorpo-
`rated and readily changed at short notice to accommodate
`various sponsoring entities or functional program providers
`or contributors.
`
`Thus, there is a need for an improved GUI presentation
`methodology which is el1"ective to facilitate and accommo-
`date frequent changes to the displayed interface whereby a
`GUI interface program may be modified quickly and easily
`by a network server in providing a greater selection of GUI
`presentations to network users.
`
`SUMMARY OI-" Tl-II}. INVl:lN'I'ION
`
`A method and implementing computer system is provided
`in which a GUI stream processor interprets a data stream
`consisting of GUI controls and attributes, and places the
`controls and attributes in a presentation space. In an exem-
`plary embodiment, a web browser program loads an I-ITML
`(Hypertext Markup Language) from a GUI (Graphical User
`Interface) stream processor applet from a web server. ‘the
`web browser then loads the GUI stream processor (GSP)
`from the web server and begins executing the GSP. The GSP
`then requests the GUI stream from the web server by
`opening a stream to a
`file, CGI {Common Gateway
`Interface) script or servlct on the server. The GSP then
`receives the GUI stream and assembles the user interface in
`the JAVA applet presentation space managed by the browser.
`The GSP may periodically update itself by repeating the last
`two steps.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`invention can be
`A better understanding of the present
`obtained when the following detailed description of a pre-
`ferred embodiment is considered in conjunction with the
`following drawings, in which:
`FIG. 1 is a diagram of a computer system in which the
`present invention may be implemented;
`FIG. 2 is a simplified schematic diagram showing selected
`components and subsystems of the computer system illus-
`trated in FIG. I; and
`FIG. 3 is an illustration of an exemplary display screen of
`a typical web page for reference in explaining the present
`invention.
`
`Dl£'l'All.IjD DESCRI I-’I'lON
`
`With reference to FIG. 1, the various methods discussed
`herein may be implemented within a computer network
`including a computer terminal 101, which may comprise
`either a workstation or a PC for example. In general, an
`implementing eomputersystem may include computers eon-
`figured with a plurality of processors in a multi—bus system
`in a network of similar systems. However, since the work-
`station or computer terminal 101 implementing the present
`invention in an exemplary embodiment, is generally known
`in the art and composed of electronic components and
`
`0004
`0004
`
`

`
`6,075,528
`
`3
`circuits which are also generally known to those skilled in
`the art, circuit details beyond those shown in FIG. I, are not
`specified to any greater extent than that considered neces-
`sary as illustrated, for the understanding and appreciation of
`the underlying concepts of the present invention and in order
`not to obfuscate or distract from the teachings of the present
`invention.
`
`I0
`
`15
`
`30
`
`35
`
`40
`
`In FIG. 1, the computer system includes a processor unit
`103 which is typically arranged for housing a processor
`circuit along with other component devices and subsystems
`of the computer terminal 101. The computer terminal 101
`also includes a monitor unit 105, a keyboard 107 and a
`mouse or pointing device 109, which are all interconnected
`with the computer terminal
`illustrated. Also shown is a
`connector 111 which is arranged for connecting a modem
`within the computer terminal to a communication line such
`as a telephone line in the present example. The present
`invention may also be implemented in a cellular system.
`Several of the major components of the terminal 101 are
`illustrated in FIG. 2. A processor circuit 201 is connected to .
`a system bus 203 which may be any host system bus. It is
`noted that the processing methodology disclosed herein will
`apply to many different bus andior network configurations.
`A cache memory device 205, and a system memory unit are
`also connected to the bus 203. A modern 2209 is arranged for _
`connection 210 to a communication line, such as a telephone
`line, through a connector 111 (FIG. 1}. The modem 209. in
`the present example, selectively enables the computer ter-
`minal 101 to establish a communication link and initiate
`communication with network server. such as the Internet.
`The system bus 203 is also connected through an input
`interface circuit 211 to a keyboard 213 and a mouse or
`pointing device 215. The bus 203 may also be coupled
`through a hard-wired network interface subsystem 217. A
`diskette drive unit 219 is also shown as being coupled to the
`bus 203. A video subsystem 220, which may include a
`graphics subsystem, is connected to a display device 221. A
`storage device 218, which may comprise a hard drive unit,
`is also coupled to the bus 203. The diskette drive unit
`provides a means by which individual diskette programs
`may be loaded on to the hard drive, or accessed directly, for
`selective execution by the computer terminal 101. As is well
`known, program diskettes containing application programs
`represented by magnetic indicia on the diskette, may be read
`from the diskette drive, and the computer system is selec-
`tively operable to read such magnetic indicia and create
`program signals. Such program signals are selectively elIec-
`tive to cause the computer system to present displays on the
`screen of a display device and respond to user inputs in
`accordance with the functional
`flow of the application
`program on the diskette.
`In running an Internet access program or browser program
`on the computer terminal 101, the access program is typi-
`cally stored in the storage device 218 and either selectively
`or automatically, partially or totally, loaded into the system
`memory 207 when the system is initially powered-on, or at
`a later time ifso desired by a user. The browser is selectively
`operable to access and execute a site selection program, as
`herein described, either directly from a diskette in the
`diskette drive unit 219 or directly from a copy of the site
`selection program stored on the hard drive unit 218. As a
`program is running, either a portion of the program or the
`entire program may be loaded into the system memory 207
`andfot‘ the system cache memory 205. Depending on specillc
`program design,
`the system may store any information
`accessed from a database in the storage unit 218, the cache
`memory 205. the system memory 207 or directly from a
`
`45
`
`50
`
`55
`
`60
`
`65
`
`0005
`0005
`
`4
`diskette loaded into the diskette drive 219. Assuming a user
`has started-up the system, and is actively running a browser
`program for example, from memory, a series of screens will
`be displayed to the user on the display device 221. Each
`screen typically has one or more selections for the user to
`make in navigating through the program. In general, a user
`will make selections [mm a home page display screen using
`the keyboard 213 or the mouse or pointer device 215. In an
`Internet operating program, the selections made by the user
`will determine .where. the user .goes., i.e. to what .site. or
`.webpage., and also, in some cases, the communications link
`or the path taken to get to the site selected.
`FIG. 3 illustrates a typical program screen display 301 in
`an Internet operating session. The browser screen generally
`includes a mode row 303 which displays several difierent
`modes which the user may select such as the .File. selection
`308 and the .Bookmarks. selection 304. Another row 305
`may be displayed to help a user quickly move through
`documents, sites, or pages in a network application. An
`address or .location. section 307 enables a user to key-in,
`and also displays the name of, an internet address of a site
`to be, or being, visited. In the present example, the location
`designation is a .calculator. function which may be keyed
`into the location tleld 307 or clicked on by means of an icon
`from a previous page. Other quick access buttons may be
`implemented on the screen for quick access to other selected
`network services andlor network functions such as .What’s
`New. or .Net Search. In general, any of the illustrated items
`may be selected through a .point and click. methodology
`associated with the mouse device 215, and a cursor or
`pointer 32:0 visible on the display screen. For example, a
`download of data from a remote site may be immediately
`terminated during the transmission by pointing to the .Stop.
`button and clicking on a designated mouse button. Similarly,
`the .Back. and .Forward. buttons may be used to return to the
`last screen display or go forward to the next screen display,
`respectively.
`In the FIG. 3 example, the .location. or Uniform Resource
`Locator (URL) designation is illustrated as .
`.
`. Calcula-
`tor.html. The exemplary webpage shows a calculator func-
`tion and image which has been downloaded from a server in
`response to a user selection of the appropriate URI. or
`.location. The illustrated calculator function includes a cal-
`culator outer frame or edge 310. Also illustrated is a face-
`plate 312. Within the face ofthe illustrated calculator frame
`310 are typical buttons including numerical buttons 314 and
`function buttons 316 as well as a results. area 318 for
`displaying the results of entered calculations. Also illus-
`trated is a display area 322 which may be used to display the
`identity of a sponsoring entity. Typically. a user will use a
`selector arrow 320 to select numbers and functions to
`perform a desired calculation. It is noted that even the simple
`calculator example includes many attributes and variables
`which may be changed in the display of the calculator
`image. For example, the numerical .buttons. 314 can assume
`a variety of aspects such as dilferent colors, different pat-
`terns or apparent textures, different shapes (round, square,
`oblong etc.) and even dillbrent numerical designations.
`Similarly, the function buttons 316 and the hackplate 312
`may take on many different appearances. Also text can
`assume different values for font
`type andfor
`font size.
`1-‘urthennore the combination of the diiferent attributes,
`including diflerent colors, shapes, sizes and fonts may be
`varied to present a large number of possible combination
`presentations of the displayed GUI screen.
`The calculator display shown in FIG. 3 is typically
`generated by a program or application or applet
`that
`is
`
`

`
`6,075,528
`
`6
`
`-continued
`
`I.’ Biuld parameter list
`for (int jztl: j<nun1l’arameters: j++,1 {
`Objw. value = control\r'ector.e|cmcnL-\t(i+.‘£+j,1;
`It If value is a vector, than it is another
`It control so build it too and return the
`new control if (value instanccof Vector}
`value -x buildContrUl(\'aiuc);
`it If we need to pass ourself to a method
`if (value.equa|s(“tl1is"J,t {
`value .. this:
`
`}i
`
`t Add this parameter to vector
`paramctcrs.ad.rl(valttc):
`
`}i
`
`t‘ Now set the attribute. The attribute is
`It the method name to run.
`control.attrihute(valueJ;
`
`}i
`
`f Return object created
`return control:
`
`}
`I,"
`' Called when any GUI event occurs
`J
`
`public void actionPcrformad(Aclionf3\.'cnt c) {
`ali"Tl1e guiC'ontrI:Ils object maps the controlNamI: given by
`if the programmar to the control instance known by the
`it running program.
`if (e.getSource( J -- guiControls.get("Contrr:-I1") {
`
`guiContro|s.get(“('.‘o ntroIN"}{
`
`l -
`
`else if (e.getSourcc( J ==-
`
`Pseudocode which may be implemented to provide the
`calculator example shown in FIG. 3 is illustrated below. This
`is the stream that is read by CalcApplet. For this encoding,
`the first element is the class type, the second is the unique
`name, and the third is the number of items in the constructor.
`The lirst item in the stream would be decoded as follows:
`1. The class name is l..:1bel.
`
`is known by in the
`
`2. The unique identifier this object
`program is “Company”.
`3. The constructor for Label takes 5 parameters.
`4. The constructor is called with new Label(10, 5, 110, 15,
`'“IBM’’), where the first 4 integers are points that define
`where the label is to be placed on the presentation
`space, and the string is the text to be drawn on the
`presentation space.
`
`C‘a|c.$trcam:
`[].abcl, “Company"_. 5, ll], 5, 110, I5, “ll3M"]
`[RoundBu.tton_. "ButtonT’_. 3, 10, 10. ‘‘t'‘']
`[RoundButton_. "Button8"_. 3. 40, 20. "S"]
`[RoundButton, "Button‘J", 3, "F0, 2!
`"9"]
`[RoundButton, "l3utton4", 3, ll), 50, ‘-1"]
`[Roundl.iutton, "Buttons", 3, 40, 50, "5"]
`[Rountll3utton, “l3uttont’:", 3, ‘ID, 50, *6"
`"l
`[Roundl3utton, “Button1“, 3, ll], 80,
`“
`.2-
`[RoundButton, ‘Button?’ 3, 4t], 80.
`'
`..3-
`[Rounc|l3ulton_. “'Button3' 3, ”.FD, 30.
`'
`
`[Re-undButton_. “Button.
`_. JD, 110, “."
`[Round|3utton_. “‘l3utton0' 3, 40, 110, ''U‘']
`[RoundButton, "Button%"_. 3, T0, 110,
`[SquareButton, "Buttoni"", 3, 100, 20, ".-'"l
`[SquareButton, "Buttonx", 3, 100, 50, ''X‘']
`
`JJll]
`
`an
`
`ID
`
`30
`
`40
`
`60
`
`5
`downloaded from a network server and executed at the user
`terminal in response to a calculator-related screen selection
`entered by the user. The downloaded application program
`generally includes hard code for all of the information
`defining the appearance of the calculator. The application
`generally cannot be altered or modified except by writing a
`new application program and installing the new application
`at the server to define and create a new calculator design.
`With the program and methodology of the present invention,
`the creating program is designed to retrieve a data tile l"rorn
`the server in defining the attributes and characteristics of the
`calculator GUI in the present example. The data file is a
`separate segment of code residing at the server which may
`be easily modified. by using only a file editor, by a network
`administrator or program developer to etfect a changed
`appearance or display of the calculator function when it is
`downloaded by a user. The calculator application or applet
`is opened after which the code is processed, the calculator
`image is built or created and the user is then able to use the
`calculator displayed at the user’s terminal.
`One of many possible pseudocode listings which could be
`implemented to practice the disclosed methodology is pre-
`sented below.
`
`class rnyfitpplet extends Applet {
`it (‘teats object to save GUI controls into
`Haslttahle guiControls = new l-lashIabIe( 1:
`it Applet initialization method
`void Lnit() {
`.t'.I' Open stream to file or URL
`Stream stream =- opcnStream(Filc or URL);
`,r',-' Process stream
`proucssStream(strcam}:
`}
`strearnclose:
`.-5" Process the GUI stream
`void proocssStrcan1(Strearri stream] [
`it Read front stream until all controls are read
`while leoftstreamj
`{
`ta’ Read GUI control class name and attributes
`Vector controwector - strean:.readVeetor( I:
`if Build GUI control
`buildControl(contro|\"ectorJ;
`
`l
`}
`.0’ Build GUI control
`Object l:n1ildC'ontro|[Vcctor contrUlVcctor] {
`it’ Get class
`String contro|Class -= controlVcctor.e1cmcntAt(0;:
`fa’ Get unique name of control
`String contro|Nante - contro|Vec1or.elementAt(1J:
`it’ Get number of parameters for constructor
`int numConstructorI‘arameters -
`control\r’e-ctor.elemcntAt(2J
`it’ Get parameters for constructor
`int i = 3:
`Vector consIructorI’arametem =- new \-"ector( ):
`for (int
`j<numConstructorParamctcrs: j-I-I-j {
`consLIuctorPataI1Ictcr5.:1cldElc.mcnt
`(col'tt1'o|\«"cctor.c|I:Ir1anL.t\t(i)):
`i-H:
`
`li
`
`t’ Create control
`Object control -
`ClassforNamc(contro|Class'J.ncwLnstance
`(eon.-;tmctorParan'tetcrs);
`it Save unique name and control
`guiCorttro|s.put(oonIrolNamc, oontrol}:
`I.-' Set attributes on control
`while (I < controt.siz.e( }} {
`String attribute ..
`control\'lcctor.::tcrncntAt(i);
`int nLtmParameters x=
`controlvector.elemerttAt(l+1J:
`Vector parameters - new \-"ector( ):
`
`0006
`0006
`
`

`
`8
`
`-continued
`
`if (value imtanoeof Vector]
`value - l:uiJdContro|[va|uc}:
`If If we need to pass ourself to a method
`if (v=t|ue.equa1s("t.his")) {
`value - this;
`
`}
`
`It Add this parameter to vector
`paran'1eters.add(\'atue):
`t Now set the attribute. The attribute is the method
`It name to run.
`e-ontroI.attribt1Le(va|ue):
`
`}I
`
`6,075,528
`
`7
`
`-continued
`
`}
`I.-’ Return object created
`return control;
`
`}[run
`" Called when any GUI event occurs
`‘J
`public void actionPerformed(ActionEvent e) {
`.n'.-' The gtIiContro|s object maps the controlhiame given by
`H the programmer to the control instance known by the
`it running program.
`if (c.getSoun:c( ] nu: gn.ICDntruI5.get.{"Bt1ltDulT‘)) {
`}
`gt1iC.'orIlrnls.gcl(“DIsplny"').appcncIFcJtt(“U");
`else if (e.getSource(j - guiContro]s.get(“ButtonI")‘) {
`guiControts.get(“Disp|ny").append'T'ext("1"]:
`
`}e
`
`lse if (e.getSouIoe( J -- guiContro]s.get(“Button..")} {
`goiContro1s.get("Dis3|ay").appendText(“2”):
`
`lse if [e.getSource() =-= g_uiControls.get("Button3")) {
`gI.uContro1s.get("DJ.s3|ay").append'I‘ext[".3”):
`}
`else if (e.gelSouIce() aw guicontrois.gcl(‘Button4")) {
`guiC‘ontre-ls.g<:l(“D'ls:|ay")_appendText(“4"):
`
`} e
`
`le
`
`le
`
`}e
`
`le
`
`lse if (e.getSoutce( J - guiContro1s.get(“Button5")) {
`goiC‘ontro]s.get(“Dis:|ay").appenrIf‘cxt(“S"):
`
`lse if (e.gelSource(] -- guiControls.get("Button6")] {
`guiConlrols.get(“DEsa|a)r").nppend'l"ext(“5"):
`
`lse if (e.getSouvce(] -- guiContro1s.gel("Buttonit"); {
`guiC‘ontro1s._get("DIs3|ay").appencfI‘ext(“'.I'"):
`
`lse if (e.getSouroe() -= guiCo11tro1s.get('Butt.on8")) {
`guiContro1s._get("Dis3|ay").append'I‘ext("8"]:
`
`lse if [c.gclSDu.rue() -an guiCuntrols.gel("Button9"}} {
`guiC‘untro1s.get("Dis3Iay"}.appcndTcxL(“9"):
`
`le
`
`}e
`
`}e
`
`lse if (e.getSource() - guiContro].s.get("Button.")} {
`guiContro]s.get(“Disp|a)r").append'1"cxt("."J;
`}
`else if (e.getSource(J -- guiContro1e.gel(“ButtonX")) [
`operand] -= guiC‘ontro1s.get("Diep1ay").getText( "J:
`operation -= "X":
`gu{Controls.get('‘Disp|ay‘').c|ea1’I‘extf );
`
`lse if (agelSnun'.v3() - guiC'ontIo1s.get(“Button-")) {
`crpcrendl -= guiCunLru1s_get("Disp1ay").gc1Text( )_;
`operation w “-":
`goiContm]s.gel("lJisplay").cIearTcxt( ):
`
`}e
`
`lse if (e.gelSou:oe() -- guiContro]s.get(“Button.I"')) {
`operandl - guiContro1s.get("Display").getText( ):
`operation -- ‘‘.-''‘;
`guicontre-ls.get(‘Disp|ay").e|ea1’I‘cxt( "J:
`}
`else if [e.getSoun:e() —=- gui-Controls.get(BultonX")) {
`operandl - guiContro1s.get("Disp1ay").gelText( );
`operation - "X":
`guiControts.get(“Disp|ay")_e|earText( ]_:
`}
`|
`else if [(e.geISor.1roe( J -an guiControIs.get(“Button’X5-")) |
`(e.3,etSource( J an guiControIs.get(“Button-="))) {
`operartd2 - guiContro1s.get("Display").getText( );
`
`10
`
`IS
`
`25
`
`30
`
`40
`
`55
`
`60
`
`65
`
`[SquarcBtttlon, “Bt1tton+", 3, 100, 50, ‘+"]
`[SquarcButton, “Button—", 3, 100, 110, “—"]
`[SquareButlon, “Button-", 3, 100, 140, “-="]
`[TextFie1d, "Display", 5, 10, 140, no, 155, “'1
`CaIcApp|et.j:1va:
`.u._
`class Cailcattpplet extends Applet {
`.4»
`String operandi -
`.
`String operand! -=
`:
`String operation at
`.
`double result 2: 0.0;
`It Create object to save GUI controls into
`I-Iashtable gui(3ontrols as new HashLabIc( ):
`H Applet initialization method
`void init( 3 {
`If Open stream to file or URL
`Stream stream - openStream(“Ca|c.stream"J:
`H Process stream
`processStream(strean1):
`3'! Process the GUI‘. stream
`void prooesStrean1(Stream stream) {
`:":" Read from stream until all controls are read
`while fleoftstrearrfl) {
`H Read GUI control class name and attributes
`Vector conlru1\-Ector -= sl:'eam.rl:n:lV'a:t:ior( );
`.Il.Il Btfild GUI control
`bui|dContro| (control\r'eclor)'.
`If Register for action notification when button pressed
`guiContIols.get(“Button0").acld.Actionlistenerfihis);
`guiC‘.ontro|s.gel("Bulton1"].add.ActionI.istener(ll1is):
`guiC‘ontro|s.get("Button2").add.ActionListcner[tl1is);
`guiC‘ontro|s.get("liutton3").add.ActionListener(tl1is);
`guiC‘ontro|s.get("Button4").addActionListener[tl1is);
`guiContro|s.get("ButtonS").addActionListener(tl1is);
`guiControIs.gcl("Button6").edd.ActionI.istuncr(this),
`guiCDnlrD|s.gcl("Bull011'!").a.dcla|\Ctl0nListoncr(this):
`guiCcInlrD|s.gcl("Bulton8").ndd.r\t:t.ionListcncr(ll'tis);
`gt:iCnnlroIs.gcl("Bulton9").adclJ’\ct.ionListcI1cr(ll1is);
`guiC‘ontroIs.get["Buttort+"].addAct{onListener(ll1ieJ:
`gt:iC‘ontroIs.gct("Button—“).addAr:tionListener(th.is);
`guiC‘ontroIs.gct("ButtonX“,1.adclActionListener(t11is_J:
`guiConlroIs.get("Button.l”).adclActionLi.stener(ll1is]:
`guiConlro|s.get("ButIon-"}.addActionLisI.ener(lhis]:
`guiControls.get("Button%").add.ActionI.islener[this):
`guiConlrols.gel("Bulton.").addAclionListener(this}:
`
`l
`}
`It Build GUI control
`Object b1.Ii|dControl(Vector oontro|\-Iector] {
`H Gel class
`String uDntrolClasae = controlWclor.clcmenlAl(fl):
`H Get unique name of control
`String oontro|Narne -= onntroIVt:etor.clernz:nLAt{I):
`If Get number of parameters for constructor
`int numConstructorP:Irameters - contro1Vector.e1ementAt(2):
`I.-" Get pammeters for constructor
`int I - 3-;
`\-Vector oonstructorhrameters -= new \-’ector( ):
`for (int i=0; j<nun1ConstructorParamcters: j+t-) {
`construct.orParan1eters.addE1ement(oontrolwclor.
`e1ementAt[i))',
`iv!-I-;
`
`}H
`
`Create control
`Objccl control -z
`Class.forNan1e(contro1C|ass).newlnstance
`(_const1'uctorP:Irarneters):
`If Save unique name and control
`gt:iC‘ontrols.pt1t(oontroINan1c, control]:
`it Set attributes on control
`while (i < control.-3ize( )J {
`String attribute - oon1rol\-Ector.e|erncntAl(iJ:
`int nurnParan1eters - contro]Vector.e1ernenI.At(i+]);
`Vector parameters - new V-'ector( ):
`a’.-' Build paranlctcr list
`for (int i-U; I<uumParan1elers_: i++'_I {
`Object value an control\"ector.e|ementAt(i+2+j);
`H‘ [I value is :1 vector, then it is another control
`If so build it too and return the new control
`
`0007
`0007
`
`

`
`6,075,528
`
`9
`
`-continued
`
`if (operation = “+"]-
`result = Dottblc(operandl}.doubic\-‘a|ue( J +
`I.‘)oub|e(opcranti3}.douhlc\.-‘n|ue( ,1:
`else if (operation -- ‘‘-'',1
`result - Double(operandl).dcuhle\«-‘aIuc( J -
`l}Dub|e(opcrand3}.doublc\«"a|uc( J:
`else if (operation “I "i""l
`result = Double(operandl }.dotIble\t'a|1.te( J I
`Double-.(operand2).dotIble\-"a|ue ( J:
`else if (operation -= ''X’'}
`result 2: Double(operandl).dotIble\"a|ue(J “
`Doublc(cIpcrand3}.dot.Iblc\«"aIt.Ic[ J:
`if (e.gt:tSotJ.rcc() == goiContrals.get(“Button‘3i3“})
`result = result I IUD:
`operand] - result:
`guiffontrols.get("Disp|:1y").setText(String(Icsu|tJ,1;
`
`ll)
`
`15
`
`10
`file including data elIective to modify predetermined
`non-functional aspects ofsaid controls and attributes of
`said GUI;
`receiving said GUI data file by said user terminal; and
`assembling said GUI for display on the display device,
`said assembling being accomplished using said GUI
`data stream processor code and said GUI data file, said
`non-functional aspects of said GUI being changeable
`by changing said data in said data lile.
`2. The method as set
`forth in claim I wherein said
`
`assembling is accomplished in presentation memory space
`managed by the user network browser program at said user
`terminal.
`forth in claim I wherein said
`3. The method as set
`requesting is accomplished by:
`opening a stream from said GUI data llle to said user
`terminal, said GUI data file being present on the server
`device.
`forth in claim I wherein said
`4. The method as set
`requesting is accomplished by:
`opening a stream from said GUI data file to said user
`terminal, said GUI data file being present in a servlet on
`the server device.
`forth in claim I wherein said
`5. The method as set
`requesting is accomplished by:
`opening a stream from said GUI data lile to said user
`terminal, said GUI data llle being present
`in a GUI
`related common gateway interface on the server device.
`6. The method as set forth in claim 1 and further includ-
`mg:
`periodically repeating said requesting, receiving and said
`assembling steps to update said GUI.
`7. A network system comprising:
`a server device;
`a user terminal; and
`connection means arranged to selectively connect said
`server device to said user terminal, said user terminal
`further including a display device, said user terminal
`being selectively operable for running a network
`browser program, said display device being arranged to
`display a graphical user iriterface (GUI), including a
`plurality of GUI controls and attributes, said user
`terminal being selectively operable for downloading a
`document from the server device to the user network
`browser program, said document including GUI stream
`processor code;
`said user terminal being operable for executing said GUI
`stream processor code and requesting a GUI data lile
`from the server. said GUI data file including data
`elfective to modify predetermined non-functional
`aspects of said controls and attributes of said GUI;
`said user terminal being operable for receiving said GUI
`data file and assembling said GUI for display on the
`display device, said assembling being accomplished
`using said GUI data stream processor code and said
`GUI data file, said non-functional aspects of said GUI
`being changeable by changing said data in said data
`file.
`8. The network system as set forth in claim 7 wherein said
`assembling is accomplished in presentation memory space
`managed by the user network browser program at said user
`tcnninal.
`9. The network system as set forth in claim 7 wherein said
`requesting is accomplished by opening a stream from said
`GUI data file to said user terminal, said GUI data file being
`present on the server device.
`
`The GUI processor disclosed herein allows the web server
`to show a new user interface under the control of the server.
`Thus there is only one application or applet that is needed for
`any placement and operation of any GUI controls.
`Accordingly, an application or applet ’s user interface can be
`easily generated by a tool, or dynamically by the web server —
`using methods such as servlets or CGI scripts for example.
`The processor allows the web server to show a new user
`interface under the control of the server. Thus there is only
`one application or applet that is needed for any placement
`and operation of any GUI controls. Accordingly, an appli-
`cation or applet’s user interface can be easily generated by
`a tool, or dynamically by the web server using methods such
`as servlets or CGI scripts for example.
`The method and apparatus of the present invention has
`been described in connection with a preferred embodiment
`as disclosed herein. The disclosed methodology may be
`implemented in a wide range of sequences, menus and
`screen designs to accomplish the desired resul