United States Patent
`
`[19]
`
`[11] Patent Number:
`
`6,075,528
`
`Curtis
`
`[45] Date of Patent:
`
`Jun. 13, 2000
`
`US(l(}6U75528A
`
`[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; 707513;
`';{17;g(|3; 7(;9..«33(}; 7(;.g..-gzm
`.
`345x333. 350;
`203; 7{]9I.f'22[]’ 246
`
`Field of Search
`
`[ssj
`
`|5(,
`
`References Cited
`,
`U-S PAFENT DOCUMENTS
`11,.-‘tuna 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
`IPR1 of U.S. Pat. No. 7,765,482
`IPR1 of U.S. Pat. No. 7,765,482
`
`

`
`U.S. Patent
`
`Jun. 13, 2000
`
`Sheet 1 0f 2
`
`6,075,528
`
`111
`
`101
`
`FIG. 1
`
`109
`
`201
`205
`f f // 207 K’
`
`209
`
`> 210
`
`PROCESSOR
`
`
`
`CACHE MEMORY
`
`
`
`SYSTEM MEMORY
`
`MODEM
`
`I
`
`211
`
`/ 203
`
`217
`218
`\ \
`
`219
`X
`
`INPUT
`INTERFACE
`
`NETWORK STORAGE DISKETTE
`INTERFACE
`DEVICE
`DRIVE
`UNIT
`
`21k
`
`P
`220
`?x
`VIDEO
`
`SUBSYTEM
`
`I KEYBOARD I
`
`FIG. 2
`
`0002
`
`

`
`U.S. Patent
`
`Jun. 13,2000
`
`Sheet 2 of2
`
`6,075,528
`
`303
`
`338
`
`304
`
`305
`
`/
`l-
`T
`File Edit ViewGo Bookmarks Options Directory
`307 \p
`
`4
`Back
`
`Folzard
`
`Reload Images
`
`Open
`
`Y A
`
`/309
`
`Print
`
`Find
`
`Stop
`
`L’ Location:
`
`I m Calculatonhtm]
`
`I
`
`310
`
`t
`
`\ 322
`
`K \ ® ® ® I i/SIZ
`was <9 @
`Q) G) G)
`
`llLlkLl |+| LC]
`0 GD @
`m“ 1::
`
`f 316
`
`FIG. 3
`
`0003
`
`

`
`1
`GRAPHICAL USER INTERFACE STREAM
`PROCESSOR
`
`6,075,528
`
`FIELD OF THE INVENTION
`
`The present invention relates generally to information
`processing systems and more particularly to a methodology
`and implementation for facilitating graphical user interface
`changes for user applications.
`
`BACKGROUND OF THE INVENTION
`
`10
`
`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 ?les, 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 effects. 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 associated 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 ?exibility for different JAVA applet user inter
`faces to be readily created When the content of the Web
`server changes dynamically. In general, this hard-coded GUI
`program, Which resides at the site of the server, has been
`dif?cult 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, de-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
`
`15
`
`25
`
`35
`
`45
`
`55
`
`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
`example, 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 modi?ed
`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 effective to facilitate and accommo
`date frequent changes to the displayed interface Whereby a
`GUI interface program may be modi?ed quickly and easily
`by a netWork server in providing a greater selection of GUI
`presentations to netWork users.
`
`SUMMARY OF THE INVENTION
`
`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 HTML
`(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 ?le, CGI (Common GateWay
`Interface) script or servlet 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
`
`A better understanding of the present invention can be
`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 simpli?ed schematic diagram shoWing selected
`components and subsystems of the computer system illus
`trated in FIG. 1; and
`FIG. 3 is an illustration of an exemplary display screen of
`a typical Web page for reference in explaining the present
`invention.
`
`DETAILED DESCRIPTION
`
`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 computer system may include computers con
`?gured 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
`
`

`
`6,075,528
`
`10
`
`15
`
`25
`
`3
`circuits Which are also generally known to those skilled in
`the art, circuit details beyond those shoWn in FIG. 1, are not
`speci?ed 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.
`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. Aprocessor 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 and/or netWork con?gurations.
`A cache memory device 205, and a system memory unit are
`also connected to the bus 203. Amodem 209 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
`35
`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 effec
`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 How 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 if so 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
`and/or the system cache memory 205. Depending on speci?c
`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
`
`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 from 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., ie 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 different
`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 ?eld 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 and/or 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 320 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 URL 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 of the 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 different colors, different pat
`terns or apparent textures, different shapes (round, square,
`oblong etc.) and even different numerical designations.
`Similarly, the function buttons 316 and the backplate 312
`may take on many different appearances. Also text can
`assume different values for font type and/or font siZe.
`Furthermore the combination of the different attributes,
`including different 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
`
`45
`
`55
`
`65
`
`0005
`
`

`
`6,075,528
`
`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
`de?ning the appearance of the calculator. The application
`generally cannot be altered or modi?ed eXcept by Writing a
`neW application program and installing the neW application
`at the server to de?ne and create a neW calculator design.
`With the program and methodology of the present invention,
`the creating program is designed to retrieve a data ?le from
`the server in de?ning the attributes and characteristics of the
`calculator GUI in the present eXample. The data ?le is a
`separate segment of code residing at the server Which may
`be easily modi?ed, by using only a ?le editor, by a netWork
`administrator or program developer to effect 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 myApplet extends Applet {
`// Creats object to save GUI controls into
`Hashtable guiControls = neW Hashtable( );
`// Applet initialization method
`void init() {
`// Open stream to ?le or URL
`Stream stream = openStream(File or URL);
`// Process stream
`processStream(stream);
`stream.close;
`}
`// Process the GUI stream
`void processStream(Stream stream) {
`// Read from stream until all controls are read
`While leof(stream) {
`// Read GUI control class name and attributes
`Vector controlVector = stream.readVector( );
`// Build GUI control
`buildControl(controlVector);
`
`// Build GUI control
`Object buildControl(Vector controlVector) {
`// Get class
`String controlClass = controlVector.elementAt(O);
`// Get unique name of control
`String controlName = controlVector.elementAt(1);
`// Get number of parameters for constructor
`int numConstructorParameters =
`controlVector.elementAt(2)
`// Get parameters for constructor
`int i = 3;
`Vector constructorParameters = neW Vector( );
`for (int j=O; j<numConstructorParameters; j++) {
`constructorParameters.addElement
`(controlVector.elemantAt(i));
`i++;
`
`// Create control
`Object control =
`Class.forName(controlClass).neWInstance
`(constructorParameters);
`// Save unique name and control
`guiControls.put(controlName, control);
`// Set attributes on control
`While (i < control.size(
`{
`String attribute =
`controlVector.elementAt(i);
`int numParameters =
`controlVector.elementAt(i+1);
`Vector parameters = neW Vector( );
`
`1O
`
`15
`
`25
`
`45
`
`55
`
`65
`
`6
`
`-continued
`
`// Biuld parameter list
`for (int j=O; j<numParameters; j++) {
`Object value = controlVector.elementAt(i+2+j);
`// If value is a vector, than it is another
`// control so build it too and return the
`neW control if (value instanceof Vector)
`value = buildControl(value);
`// If We need to pass ourself to a method
`if (value.equals(“this”)) {
`value = this;
`
`// Add this parameter to vector
`parameters.add(value);
`
`// NoW set the attribute. The attribute is
`// the method name to run.
`control.attribute(value);
`
`// Return object created
`return control;
`
`}
`
`* Called When any GUI event occurs
`
`public void actionPerformad(ActionEvent e) {
`// The guiControls object maps the controlName given by
`// the programmar to the control instance known by the
`// running program.
`if (e.getSource() == guiControls.get(“Control1”) {
`
`}
`
`else if (e.getSource() ==
`
`guiControls.get(“ControlN”){
`
`}
`
`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 ?rst element is the class type, the second is the unique
`name, and the third is the number of items in the constructor.
`The ?rst item in the stream Would be decoded as folloWs:
`
`1. The class name is Label.
`2. The unique identi?er this object is knoWn by in the
`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 ?rst 4 integers are points that de?ne
`Where the label is to be placed on the presentation
`space, and the string is the teXt to be draWn on the
`presentation space.
`
`Calc.stream:
`[Iabel, “Company”, 5, 10, 5, 110, 15, “IBM”]
`[RoundButton, “Button7”, 3, 10, 20, “7”]
`[RoundButton, “Button8”, 3, 40, 20, “8”]
`[RoundButton, “Button9”, 3, 70, 20, “9”]
`[RoundButton, “Button4”, 3, 10, 50, “4”]
`[RoundButton, “Button5”, 3, 40, 50, “5”]
`[RoundButton, “Button6”, 3, 70, 50, “6”]
`[RoundButton, “Buttonl”, 3, 10, 80, “1”]
`[RoundButton, “ButtonZ”, 3, 40, 80, “2”]
`[RoundButton, “Button3”, 3, 70, 80, “3”]
`[RoundButton, “Button”, 3, 10, 110, “.”]
`[RoundButton, “ButtonO”, 3, 40, 110, “O”]
`[RoundButton, “Button%”, 3, 70, 110, “%”]
`[SquareButton, “Button/”, 3, 100, 20, “/”]
`[SquareButton, “ButtonX”, 3, 100, 50, “X”]
`
`0006
`
`

`
`7
`
`-continued
`
`6,075,528
`
`8
`
`-continued
`
`[SquareButton, “Button+”, 37 1007 507 “+,,
`[SquareButton, “Button—”, 3, 1007 1107 “_,,]
`[SquareButton, “Button=”, 3, 100, 140, “=”]
`[TeXtField, “Display”, 5, 10, 140, 110, 155, W]
`CalcApplet.java:
`class CalcApplet extends Applet {
`String operand1 = “”;
`String operand2 = “”;
`String operation = “”;
`double result = 0.0;
`// Create object to save GUI controls into
`Hashtable guiControls = neW Hashtable( );
`// Applet initialization method
`void init() {
`// Open stream to ?le or URL
`Stream stream = openStream(“Calc.stream”);
`// Process stream
`processStream(stream);
`
`}
`
`// Process the GUI stream
`void procesStream(Stream stream) {
`// Read from stream until all controls are read
`While (leof(stream)) {
`// Raad GUI control class name and attributes
`Vector controlVector = stream.readVector( );
`// Build GUI control
`buildControl (controlVector);
`// Register for action noti?cation When button pressed
`guiControls.get(“ButtonO”).addActionListener(this);
`guiControls.get(“Button1”).addActionListener(this);
`guiControls.get(“Button2”).addActionListener(this);
`guiControls.get(“Button3”).addActionListener(this);
`guiControls.get(“Button4”).addActionListener(this);
`guiControls.get(“Button5”).addActionListener(this);
`guiControls.get(“Button6”).addActionListener(this),
`guiControls.get(“Button7”).addActionListener(this);
`guiControls.get(“Button8”).addActionListener(this);
`guiControls.get(“Button9”).addActionListener(this);
`guiControls.get(“Button+”).addActionListener(thie);
`guiControls.get(“Button-”).addActionListener(this);
`guiControls.get(“ButtonX").addActionListener(this);
`guiControls.get(“Button/”).addActionListener(this);
`guiControls.get(“Button=”).addActionListener(this);
`guiControls.get(“Button%”).addActionListener(this);
`guiControls.get(“Button.”).addActionListener(this);
`
`}
`
`// Build GUI control
`Object buildControl(Vector controlVector) {
`// Get class
`String controlClase = controlVector.elementAt(O);
`// Get unique name of control
`String controlName = controlVector.elementAt(1);
`// Get number of parameters for constructor
`int numConstructorParameters = controlVector.elementAt(2);
`// Get parameters for constructor
`int i = 3;
`Vector constructorParameters = neW Vector( );
`for (int i=0; j<numConstructorParameters; j++) {
`constructorParameters.addElement(controlVector.
`elementAt(i));
`i++;
`
`// Create control
`Object control =
`Class.forName(controlClass).neWInstance
`(constructorPararneters);
`// Save unique name and control
`guiControls.put(controlName, control);
`// Set attributes on control
`While (i < control.size(
`{
`String attribute = controlVector.elementAt(i);
`int numParameters = controlVector.elementAt(i+1);
`Vector parameters = neW Vector( );
`// Build parameter list
`for (int i=0; l<numParameters; i++) {
`Object value = controlVector.elementAt(i+2+j);
`// If value is a vector, then it is another control
`// so build it too and return the neW control
`
`5
`
`10
`
`if (value instanceof Vector)
`value = buildControl(value);
`// If We need to pass ourself to a method
`if (value.equals(“this”)) {
`value = this;
`
`// Add this paremeter to vector
`parameters.add(value);
`
`// NoW set the attribute. The attribute is the method
`// name to run.
`control.attribute(value);
`
`// Return object created
`return control;
`
`15
`
`/**
`* Called When any GUI event occurs
`*/
`public void actionPerformed(ActionEvent e) {
`// The guiControls object maps the controlName given by
`// tbe programmer to the control instance knoWn by the
`// running program.
`if (e.getSource() == guiControls.get(“ButtonO”)) {
`guiControls.get(“Display”).appendTeXt(“O”);
`
`else if (e.getSource() == guiControls.get(“Button1”)) {
`guiControls.get(“Display”).appendTeXt(“1”);
`
`else if (e.getSource() == guiControls.get(“Button2”)) {
`guiControls.get(“Display”).appendTeXt(“2”);
`
`else if (e.getSource() == guiControls.get(“Button3”)) {
`guiControls.get(“Display”).appendTeXt(“3”);
`
`else if (e.getSource() == guiControls.get(“Button4”)) {
`guiControls.get(“Display”).appendTeXt(“4”);
`
`else if (e.getSource() == guiControls.get(“Button5”)) {
`guiControls.get(“Display”).appendTeXt(“5”);
`
`else if (e.getSource() == guiControls.get(“Button6”)) {
`guiControls.get(“Display”).appendTeXt(“6”);
`
`else if (e.getSource() == guiControls.get(“Button7”)) {
`guiControls.get(“Display”).appendTeXt(“7”);
`
`else if (e.getSource() == guiControls.get(“Button8”)) {
`guiControls.get(“Display”).appendTeXt(“8”);
`
`else if (e.getSource() == guiControls.get(“Button9”)) {
`guiControls.get(“Display”).appendTeXt(“9”);
`
`else if (e.getSource() == guiControls.get(“Button.”)) {
`guiControls.get(“Display”).appendTeXt(“.”);
`
`else if (e.getSource() == guiControle.get(“ButtonX")) (
`operand1 = guiControls.get(“Dieplay”).getTeXt( );
`operation = “X”;
`guiControls.get(“Display”).clearTeXt( );
`
`else if (e.getSource() == guiControls.get(“Button-”)) {
`operend1 = guiControls.get(“Display”).getTeXt( );
`operation =
`,
`
`guiControls.get(“Display”).clearTeXt( );
`
`else if (e.getSource() == guiControls.get(“Button/”)) {
`operand1 = guiControls.get(“Display”).getTeXt( );
`operation = “/”;
`guiControls.get(“Display”).clearTeXt( );
`
`else if (e.getSource() == guiControls.get(ButtonX”)) {
`operand1 = guiControls.get(“Display”).getTeXt( );
`operation = “X”;
`guiControls.get(“Display”).clearTeXt( );
`
`}
`|
`else if ((e.getSource() == guiControls.get(“Button%”)) |
`(e.getSource() == guiControls.get(“Button=”))) {
`operand2 = guiControls.get(“Display”).getTeXt( );
`
`20
`
`25
`
`3O
`
`35
`
`40
`
`45
`
`5O
`
`55
`
`60
`
`65
`
`0007
`
`

`
`9
`
`-continued
`
`if (operation == “+”)
`result = Double(operand1).doubleValue() +
`Double(operand2).doubleValue( );
`else if (operation == “—”
`result = Double(operand1).doubleValue() —
`
`Double(operand2).doubleValue( );
`elee if (operation == “/”)
`result = Double(operand1).doubleValue() /
`
`Double(operand2).doubleValue else if (operation == “X”)
`
`result = Double(operand1).doubleValue() *
`Double(operand2).doubleValue( );
`if (e.getSource() == guiContrals.get(“Button%”))
`result = result / 100;
`operandl = result;
`guiControls.get(“Display”).setText(String(result));
`
`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 results as herein
`illustrated. Although an embodiment of the present inven
`tion has been shoWn and described in detail herein, along
`With certain variants thereof, many other varied embodi
`ments that incorporate the teachings of the invention may be
`easily constructed by those skilled in the art, and even
`included or integrated into a processor or CPU or other
`larger system integrated circuit or chip. The disclosed meth
`odology may also be implemented solely in program code
`stored on a disk or diskette (portable or ?xed), or other
`memory device, from Which it may be executed to achieve
`the bene?cial results as described herein. Accordingly, the
`present invention is not intended to be limited to the speci?c
`form set forth herein, but on the contrary, it is intended to
`cover such alternatives, modi?cations, and equivalents, as
`can be reasonably included Within the spirit and scope of the
`invention.
`What is claimed is:
`1. In a netWork environment including a server device, a
`user terminal and means arranged to selectively connect the
`user terminal to the server device, a method for presenting
`a graphical user interface (GUI), including a plurality of
`GUI controls and attributes, on a display device at the user
`terminal, said method comprising:
`doWnloading a document from the server device to a user
`netWork broWser program, said document including
`GUI stream processor code;
`executing said GUI stream processor code on the user
`terminal;
`requesting a GUI data ?le by the GUI stream processor
`code from the server to the user terminal, said GUI data
`
`6,075,528
`
`10
`?le including data effective to modify predetermined
`non-functional aspects of said controls and attributes of
`said GUI;
`receiving said GUI data ?le 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 ?le, said
`non-functional aspects of said GUI being changeable
`by changing said data in said data ?le.
`2. The method as set forth in claim 1 Wherein said
`assembling is accomplished in presentation memory space
`managed by the user netWork broWser program at said user
`terminal.
`3. The method as set forth in claim 1 Wherein said
`requesting is accomplished by:
`opening a stream from said GUI data ?le to said user
`terminal, said GUI data ?le being present on the server
`device.
`4. The method as set forth in claim 1 Wherein said
`requesting is accomplished by:
`opening a stream from said GUI data ?le to said user
`terminal, said GUI data ?le being present in a servlet on
`the server device.
`5. The method as set forth in claim 1 Wherein said
`requesting is accomplished by:
`opening a stream from said GUI data ?le to said us