`
`
`
`
`
`Ex. 1009
`Ex. 1009
`
`US Patent No. 5,832,505 (“‘Kasso’’)
`US Patent No. 5,832,505 (“Kasso”)
`
`
`
`
`
`

`

`United States Patent
`Kasso et al.
`
`[19]
`
`[54] COMPUTER SYSTEM FOR MANAGING AND
`CONFIGURING APPLICATION PROPERTIES
`AND ENABLING SYSTEM ADMINISTRATOR
`TO OVERRIDE CERTAIN USER-SET OR
`HOST PROPERTIES
`
`Inventors: Chris S. Kasso; Joseph F. DiPol, both
`of Sunnyvale; Linda K. Schneider,
`Campbell, all of Calif.
`Assignee: Sun Microsystems, Inc., Palo Alto,
`Calif.
`
`Appl. No. 829,891
`Filed:
`Apr. 2, 1997
`Int. Cl." ~~~~ G06F 15/177
`U.S. Cl. ................................ 707/104; 707/1; 707/100
`Field of Search ...................................... 707/100–104
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`4/1995 Taylor ..................................... 707/100
`5,410,691
`5,446,575 8/1995 Lysakowski, Jr. ...
`... 707/104
`5,615,372 3/1997 Nishina ................
`... 395/653
`5,664,117 9/1997 Taylor ..........
`. 395/200.5
`5,680,615 10/1997 Marlin et al. ........
`... 707/103
`5,684,996 11/1997 Westerholm et al. ................... 395/712
`OTHER PUBLICATIONS
`Nye, Adrian and O’Reilly, Tim, “X Toolkit Intrinsics Pro
`gramming Manual”, Second Edition for X11, Release 4, vol.
`4, pp. 251–257 (1990).
`J. Di Pol et al., “HotJava Views 1.0 System Overview and
`Applet Integration: A White Paper”, Sun Microsystems, Inc.,
`Mar. 1997.
`
`US005832505A
`[11] Patent Number:
`[45] Date of Patent:
`
`5,832,505
`Nov. 3, 1998
`
`Primary Examiner—Krisna Lim
`Attorney, Agent, or Firm—McDermott, Will & Emery
`[57]
`ABSTRACT
`A method, apparatus, and computer program product for
`managing and configuring program properties of an appli
`cation program by loading properties from several lists,
`applying a set of precedence rules to resolve conflicts among
`properties, and applying the properties to the application
`program. Properties are listed in a plurality of lists including
`a list of default property values, a list of host-specific
`property values, a list of user-specific property values, a list
`of application-specific property values, and final properties
`lists. Values in the final property lists override conflicting
`previously loaded property values. The default properties
`list is loaded, as is a host-specific properties list, but only
`values for the then-current host are loaded. The user-specific
`properties list is loaded. User-defined properties override
`conflicting default properties. The final system-wide prop
`erties list is loaded, its values override any conflicting
`user-selected property, and such final properties may not be
`over-ridden by any user-selected property. A final host
`specific property list is loaded. Values in the final host
`specific property list override any conflicting properties in
`the host-specific properties list, and a user may not override
`such final properties. Values are written into a merged
`property list which is applied to the application program.
`Users may be assigned to user groups. A set of property lists
`can be associated with each group so that consistent property
`values are applied to all users within a group. Property
`values can be defined for specific application programs by
`using a default system properties list for the application
`program, and an overriding system properties list for the
`application program.
`
`47 Claims, 6 Drawing Sheets
`
`312
`
`DOES
`ANY FINAL
`PROPERTY VALUE
`CONFL}CT WITH ANY
`DEFAULT OR
`SPECIFIC
`WALUE 2
`
`
`
`OVERRIDE THE
`PREWHOUSLY
`LOADED WALUE
`
`314
`
`START
`
`y
`LOAD
`DEFAULT
`PROPERTIES
`
`READ
`SPECIFIC
`PROPERTIES
`LIST
`
`
`
`
`
`
`
`
`
`
`
`306
`
`
`
`
`
`
`
`ANY DEFAULT
`PROPERTY CONFLICT
`WiTH ANY
`SPECIFIC
`PROPERTY
`
`YES
`
`- 308
`
`OVERRIDE
`THE CONFLCTING
`DEFAULT
`PROPERTY
`
`READ
`FINAL
`PROPERTY LIST
`
`J-310
`
`

`

`U.S. Patent
`
`Nov. 3, 1998
`
`Sheet 1 of 6
`
`I ºff!. I
`
`
`
`}JOSHIYO
`
`TOHINOO
`
`

`

`U.S. Patent
`
`Nov. 3, 1998
`
`Sheet 2 of 6
`
`5,832,505
`
`200
`
`202
`
`© & ©
`
`210
`
`LAN
`
`206
`
`JBS
`
`203- HTTP
`SERVER
`
`NIS
`SERVER
`
`230
`
`210
`
`204
`
`212
`
`214
`
`PROPERTIES
`
`224_L APP-SPECIFIC
`PROPERTIES
`
`226–1 FINAL APP PROPS
`
`?º
`
`234
`
`FINAL HOST
`PROPERTIES
`
`222
`
`
`
`USER
`218 PROPERTIES
`
`Fig. 2
`
`

`

`U.S. Patent
`
`Nov. 3, 1998
`
`Sheet 3 of 6
`
`5,832,505
`
`START
`
`
`
`LOAD
`DEFAULT
`PROPERTIES
`
`302
`
`
`
`
`
`
`
`
`
`304
`
`
`
`
`
`
`
`312
`
`
`
`
`
`DOES
`ANY FINAL
`PROPERTY VALUE
`CONFLICT WITH ANY
`DEFAULT OR
`SPECIFIC
`VALUE 2
`
`NO
`
`READ
`SPECIFIC
`PROPERTIES
`LIST
`
`
`
`
`
`306
`
`
`
`
`
`
`
`
`
`
`DOES
`ANY DEFAULT
`PROPERTY CONFLICT
`WITH ANY
`SPECIFIC
`PROPERTY
`
`OVERRIDE
`THE CONFLCTING
`DEFAULT
`PROPERTY
`
`
`
`
`
`READ
`FINAL
`PROPERTY LIST
`
`310
`
`
`
`OVERRIDE THE
`PREVIOUSLY
`LOADED VALUE
`
`Fig. 3
`
`

`

`U.S. Patent
`
`Nov. 3, 1998
`
`Sheet 4 of 6
`
`5,832,505
`
`LOAD DEFAULT
`SYSTEM-WIDE
`PROPERTY VALUES
`
`350
`
`READ
`HOST-SPECIFIC
`PROPERTIES LIST
`
`352
`
`STRIP HOST
`NAME FROM
`PROPERTY
`
`354
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`362
`
`DOES ANY
`USER-SPECIFIC
`PROPERTY VALUE
`CONFLICT WITH ANY
`PREVIOUSLY LOADED
`PROPERTY
`VALUE 2
`
`NO
`
`OVERRIDE THE
`CONFL|CTING
`PREVIOUSLY
`LOADED VALUE
`
`READ DEFAULT
`APPLICATION
`SPECIFIC PROPERTIES
`
`366
`
`NO
`
`
`
`
`
`
`
`
`
`DOES
`ANY APP-SPECIFIC
`VALUE CONFLICT WITH
`ANY PRIOR
`VALUE 7
`
`NO
`
`356
`
`
`
`DOES ANY
`DEFAULT PROPERTY
`VALUE CONFLICT WITH
`ANY HOST-SPECIFIC
`PROPERTY
`VALUE
`º
`
`OVERRIDE THE
`CONFL|CTING
`PROPERTY
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`READ USER-SPECIFIC
`SYSTEM-WIDE
`PROPERTIES
`
`360
`
`Fig. 4A
`
`
`
`
`
`
`
`OVERRIDE PRIOR
`VALUE WITH
`APP-SPECIFIC
`VALUE
`
`TO
`F. G. 4B
`
`

`

`U.S. Patent
`
`Nov. 3, 1998
`
`Sheet 5 of 6
`
`5,832,505
`
`READ USER-DEF'D
`APP-SPECIFIC
`PROPERTY VALUE
`
`373a
`
`373b
`
`
`
`STRIP HOST NAME
`FROM PROPERTY
`
`384
`
`
`
`
`
`
`
`
`
`
`
`DOES ANY
`USER APP-SPECIFIC
`VALUE CONFLICT WITH
`ANY PRIOR
`VALUE 2
`
`
`
`
`
`OVERRIDE PRIOR
`VALUE WITH USER
`APP-SPECIFIC VALUE
`
`
`
`READ FINAL SHARED 374
`SYSTEM-WIDE
`PROPERTY VALUES
`
`
`
`376
`
`ANY FINAL
`VALUE CONFLICT
`WITH ANY PRIOR
`VALUE 7
`
`NO
`
`OVERRIDE PRIOR
`VALUE WITH FiNAL
`VALUE
`
`READ FINAL
`HOST-SPECIFIC
`PROPERTY LIST
`
`380
`
`PICK VALUES ONLY L382
`FOR CURRENT
`HOST
`
`NO
`
`
`
`
`
`386
`
`
`
`
`
`
`
`
`
`DOES ANY
`FINAL HOST VALUE
`CONFLICT WITH ANY
`PRIOR VALUE
`
`
`
`NO
`
`OVERRIDE PRIOR
`VALUE WITH FINAL
`HOST VALUE
`
`
`
`READ FINAL
`APP-SPECIFIC PROPERTY
`VALUES FOR
`CURRENT APP
`
`390
`
`
`
`392
`
`DOES ANY
`FINAL APP-SPECIFIC
`VALUE CONFL|CT WITH
`ANY PRIOR
`VALUE 7
`
`NO
`
`OVERRIDE PRIOR
`VALUE WITH FINAL
`APP-SPECIFIC VALUE
`
`396
`
`DONE
`
`
`
`
`
`
`
`
`
`
`
`
`
`Fig. 4B
`
`

`

`U.S. Patent
`U.S. Patent
`
`Nov. 3, 1998
`
`Sheet 6 of 6
`
`5,832,505
`5,832,505
`
`a©)
`
`SIMIIdONd
`
`| 50/5yº ( )
`
`NWIOINYO
`
`LN08V
`
`
`
`Ocr
`
`!”
`
`“ov20
`
`A) i le bOr
`
`GE
`
`
`
`SMal\\VAVLLOH
`
`
`
`UI fe
`
`¢“BIy
`§ 313
`
`OV
`
`
`

`

`1
`COMPUTER SYSTEM FOR MANAGING AND
`CONFIGURING APPLICATION PROPERTIES
`AND ENABLING SYSTEM ADMINISTRATOR
`TO OVERRIDE CERTAIN USER-SET OR
`HOST PROPERTIES
`
`FIELD OF THE INVENTION
`The present invention relates generally to computer
`systems, and more particularly relates to managing and
`configuring properties of computer program applications in
`a context-sensitive way.
`BACKGROUND OF THE INVENTION
`Modem desktop computer systems and computer soft
`ware offer a myriad of settings, parameters, and properties
`which enable individual computer users to customize the
`appearance and behavior of their system and the software
`running on it. Individual computer users now each desire
`and expect to be able to configure their personal computer
`system, its operating system, and application programs
`running on it to suit their personal needs or preferences. For
`example, one user may prefer to use the typeface Helvetica
`as the default font for a certain application program, whereas
`another user prefers a different font.
`Therefore, many currently available application programs
`enable a user to configure fonts and other parameters using
`a configuration or “preferences” feature. The preferences of
`a user can be specified when the user installs the program or
`while the program is operating, and the selected preferences
`are stored in a configuration file in association with the
`application program on the user’s computer system.
`When computer systems are interconnected in a network,
`additional problems arise. If a new computer system or
`“host” is added to the network, the network system admin
`istrator may wish to establish a default set of properties to
`relieve users of the chore of re-configuring commonly
`changed properties which otherwise must be individually
`changed for every new host. Also, in many network
`environments, individual users may need to use several
`different computer systems or “hosts” in different locations.
`Under these conditions, it would be ideal to have the
`application program properties selected by the user follow
`the user from host to host, and be available to the user and
`the application program at any host distributed across the
`network.
`Further, the network system administrator may desire to
`enforce certain policies with respect to definition of prop
`erties. For example, one application program property may
`be the name and location of the printer to which the
`application program directs hard copy output. The user may
`desire always to print on a particular printer, whereas the
`system administrator wishes to require certain hosts to print
`on one specific printer.
`In addition, the system administrator may wish to prevent
`certain users or groups of users from changing particular
`properties. For example, consider an office environment of
`a company that occupies multiple office buildings located
`near one another in a campus. The company may use a pool
`of receptionists who rotate from building to building on a
`periodic basis. To enable smoother personnel rotation, the
`company may desire to have all receptionists view the same
`computer system configuration regardless of what host they
`are using or what building they are working in. In addition,
`the company may need to change or upgrade hosts used by
`the receptionists from time to time. Therefore, it is desirable
`for the company to establish application program properties
`
`10
`
`15
`
`20
`
`25
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`5,832,505
`
`2
`associated with the group of receptionists rather than a
`particular host or user. In this case, the system administrator
`may desire to establish properties for the receptionist group
`and also override any conflicting properties selected by a
`particular member of the group.
`Prior technologies, such as the X Windows System and
`the Common Desktop Environment (CDE), have a facility
`for loading application properties from multiple sources.
`However, these systems have several significant disadvan
`tages. For example, they do not enable a system adminis
`trator to override user-set properties with the assurance that
`a user may not thereafter change the properties again. They
`do not enable a system administrator to organize users into
`groups and set group-specific properties. They do not enable
`a system administrator to set properties for a specific host
`with the assurance that such host-specific properties will not
`be overridden by a user or another individual.
`For all these reasons, there is a need for methods, appa
`ratus and products which can manage and configure appli
`cation program properties by deriving the properties from
`multiple sources and controlling the properties in a flexible
`way, according to predetermined precedence policies or
`rules which assure control by the system administrator.
`There is also a need to adapt the management and
`configuration of application program properties to applica
`tion programs and operating systems used with a new class
`of computers known as “network computers”, “NCs” or
`“Net PCs.” A network computer is generally defined as a
`computer comprising a display, input devices, CPU and
`support circuitry, a main random access memory (RAM),
`and a local area network connection, but lacking a disk drive
`and other expensive and complicated peripherals. NCs offer
`Several significant advantages, namely that they are simpler
`to manufacture and maintain by system administrators.
`However, in general, many application programs and oper
`ating system programs must be loaded into the RAM using
`the network connection rather than a local disk drive. Thus,
`there is a need to provide a way to integrate and load
`application program properties from a variety of sources,
`according to pre-determined precedence policies, and enable
`such properties to be used by a network computer which has
`no local mass storage.
`SUMMARY OF THE INVENTION
`The invention provides a method, apparatus, and com
`puter program product for managing and configuring pro
`gram properties of an application program by loading prop
`erties from several sources, applying a set of precedence
`rules to resolve conflicts among properties, and applying the
`properties to the application program. The precedence rules
`assure the system administrator that designated properties
`will override certain user-selected or host-specific
`properties, and that such overriding properties cannot them
`selves be overridden by a user.
`According to one aspect of the invention, properties are
`listed in a plurality of lists including a list of default
`properties, a list of specific properties (which may be
`prepared by a user), and a final properties list. Rules of
`precedence are used when the property files are loaded. The
`default properties list is loaded, then the specific properties,
`then the final properties. When loaded, specific property
`values override conflicting corresponding default property
`values. Similarly, final property values override conflicting
`corresponding specific property values. In this way, the
`system administrator may prepare the final properties list
`with the assurance that final property values may not be
`overridden by a user.
`
`

`

`5,832,505
`
`3
`In another aspect of the invention, specific properties are
`expressed in a user-specific properties list, a host-specific
`properties list, and an application-specific properties list.
`Corresponding final properties lists are provided for the
`host-specific properties list and the application-specific
`properties list. One or more of such specific lists may be
`omitted depending on the needs of the environment. In this
`aspect, the default properties list is loaded, then the host
`specific properties file. From the host-specific properties list,
`only properties for the then-current host are loaded. The
`user-specific properties list is then loaded. User-defined
`properties override conflicting default properties. The
`application-specific properties list is loaded; from it, only
`property values corresponding to the currently executing
`application program are loaded. The final system-wide prop
`erties list file is loaded. Properties in the final properties list
`override any conflicting user-selected property, and such
`final properties may not be over-ridden by any user-selected
`property. A final host-specific property list is loaded. Prop
`erties in the final host-specific property list override any
`conflicting property value from any previously loaded list,
`and a user may not override such final properties.
`Properties are written into a merged property list that is
`stored in association with the then-current host. The merged
`property list is applied to the then-executing application
`program. Attributes of the application program are modified
`in accordance with the properties.
`Users may be assigned to user groups. A set of property
`lists can be associated with each group. In this way, con
`sistent properties can be applied to all users within a group.
`Using the application-specific properties list, property
`values can be defined for specific application programs by
`using a default properties list for the application program,
`and an over-riding or “final” properties list for the applica
`tion program.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`The present invention is illustrated by way of example,
`and not by way of limitation, in the figures of the accom
`panying drawings and in which like reference numerals refer
`to similar elements and in which:
`FIG. 1 is a block diagram of a computer system on which
`the invention may be implemented;
`FIG. 2 is a block diagram of a networked computer
`environment in which the invention may be implemented;
`FIG. 3 is a flow diagram illustrating one aspect of the
`invention using default, specific and final property list files;
`FIG. 4A and FIG. 4B are a flow diagram illustrating
`another aspect of the invention using multiple property list
`files; and
`FIG. 5 is a diagram showing a screen displayed by one
`embodiment of the invention.
`
`DETAILED DESCRIPTION OF THE
`PREFERRED EMBODIMENT
`A method, apparatus and computer program product for
`managing and configuring application program properties is
`described. In the following description, for the purposes of
`explanation, numerous specific details are set forth in order
`to provide a thorough understanding of the present inven
`tion. It will be apparent, however, to one skilled in the art
`that the present invention may be practiced without these
`specific details. In other instances, well-known structures
`and devices are shown in block diagram form in order to
`avoid unnecessarily obscuring the present invention.
`
`4
`HARDWARE OVERVIEW
`Referring to FIG. 1, it is a block diagram of a computer
`system 100 upon which an embodiment of the present
`invention can be implemented. Computer system 100
`includes a bus 101 or other communication mechanism for
`communicating information, and a processor 102 coupled
`with bus 101 for processing information. Computer system
`100 further comprises a random access memory (RAM) or
`other dynamic storage device 104 (referred to as main
`memory), coupled to bus 101 for storing information and
`instructions to be executed by processor 102. Main memory
`104 also may be used for storing temporary variables or
`other intermediate information during execution of instruc
`tions by processor 102. Computer system 100 also com
`prises a read only memory (ROM) and/or other static storage
`device 106 coupled to bus 101 for storing static information
`and instructions for processor 102. Data storage device 107
`is coupled to bus 101 for storing information and instruc
`tions.
`A data storage device 107 such as a magnetic disk or
`optical disk and its corresponding disk drive can be coupled
`to computer system 100. Computer system 100 can also be
`coupled via bus 101 to a display device 121, such as a
`cathode ray tube (CRT), for displaying information to a
`computer user. Computer system 100 further includes a
`keyboard 122 and a cursor control 123, such as a mouse.
`The present invention is related to the use of computer
`system 100 to manage and configure application program
`properties. According to one embodiment, the management
`and configuration of application program properties is per
`formed by computer system 100 in response to processor
`102 executing sequences of instructions contained in
`memory 104. Such instructions may be read into memory
`104 from another computer-readable medium, such as data
`storage device 107. Execution of the sequences of instruc
`tions contained in memory 104 causes processor 102 to
`perform the process steps that will be described hereafter. In
`alternative embodiments, hard-wired circuitry may be used
`in place of or in combination with software instructions to
`implement the present invention. Thus, the present invention
`is not limited to any specific combination of hardware
`circuitry and software.
`NETWORK COMPUTER ENVIRONMENT
`An alternate hardware environment is shown in FIG. 2. A
`plurality of network computers 200, 202 each is coupled
`using a conventional network communication link 210 to a
`local area network 204. Each of the network computers may
`be configured in the form of computer system 100, except
`without data storage device 107. The term “host” is also used
`herein to refer to the network computers. A host is used by
`one or more human users.
`A JavaOS boot server (JBS) 206 is also coupled to the
`local area network. The JBS 206 provides or distributes an
`operating system program, such as the JavaOS operating
`system available from Sun Microsystems, Inc., to a client
`that is logically remote from the JBS 206, such as an NC
`200. This enables the NC 200, which has no local non
`volatile storage device, to receive the operating system, load
`it, and begin executing it. An HTTP server 208 is also
`coupled to the local area network. The HTTP server has a
`mass storage device that stores documents for delivery and
`display by a client logically remote from the HTTP server
`208, such as the NC 200. The documents stored on the HTTP
`server 208 can be files formatted using the Hypertext
`Markup Language (HTML), i.e., World Wide Web pages, or
`
`10
`
`15
`
`20
`
`25
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`

`

`25
`
`5
`other data files such as the property lists described herein.
`The HTTP server executes operating system software which
`uses the Hypertext Transfer Protocol (HTTP) to communi
`cate the Web pages over the local area network. A Network
`Information Server (NIS) 230 is coupled, locally or remotely
`over a wide area network (WAN) or equivalent, to local area
`network 204.
`Other servers may be coupled to the local area network,
`and the network itself may be coupled or “inter-networked”
`to other networks. For example, a file server 232 can be
`coupled using a Network File System (NFS) link 234 to the
`local area network 204. Using methods that are well known
`in this art, the file server 232 can be remotely “mounted” to
`a client such as NC 200 under control of NFS, so that the file
`server 232 is available to the NC 200 as if physically
`attached thereto. The JBS 206 and HTTP server 208 can be
`inter-networked to local area network 204, or connected to
`a WAN or other geographically remote link.
`BOOT SEQUENCE
`When a user applies power to a host, such as network
`computer 200, the host executes a bootstrap loader routine
`stored in its read-only memory. During the boot procedure
`the host searches for the JBS 206, establishes a network
`connection to the JBS 206, and downloads the JavaOS
`operating system from the JBS 206 into the RAM of the
`host. The host also downloads an application program, such
`as Selector, available from Sun Microsystems, Inc. Selector
`is embedded in the boot image which is loaded from the JBS
`206 into the host. The boot image also includes other
`parameters that enable the host to begin operating, for
`example, the Uniform Resource Locator (URL) of a startup
`or initial Web page.
`The host then begins executing JavaOS. JavaOS next
`displays a login screen requesting a user to log in. The user
`logs in by entering his or her username and password.
`JavaOS requests the Network Information System (NIS) 230
`to verify the validity of the username and password, by
`connecting to NIS 230 over the local area network 204 and
`presenting the usemame and password for approval. If the
`username or password is incorrect or invalid, access to the
`system is denied. If they are correct or valid, then JavaOS
`requests the name of the user’s home directory from an
`“auto.home” table mounted on the NIS server 230.
`JavaOS is designed to execute a single application pro
`gram. Accordingly, JavaOS next passes program control to
`the designated application program, such as Selector, and the
`host begins executing that application program. In the fol
`lowing description, as an example we describe operation of
`an embodiment of the invention in which Selector is the
`application program; however, any suitable application can
`be used.
`Selector establishes an HTTP connection to the HTTP
`server 208 and requests the initial Web page identified by the
`55
`URL contained in the boot image. Selector also requests a
`set of configuration files from the HTTP server 208. The
`HTTP server 208 responds by delivering the requested web
`page and files.
`Selector can access a set of application programs 240,
`each of which is implemented as a Java applet stored in
`association with an HTML page on the HTTP server 208.
`Selector displays a main screen 402, shown in FIG. 4. Each
`application program 240 is represented in the main screen by
`an icon 404, 406 in the application icon pane 410 of the
`Selector main screen 402. Each icon is associated with a
`URL identifying the HTML page that contains the applet
`
`6
`represented by the icon. For example, the mailbox icon 404
`is associated with a URL identifying an HTML page on the
`HTTP server that contains a Mail View applet. The Mail View
`applet implements an electronic mail program. Thus, when
`a user clicks the mailbox icon 406, from HTTP server 208
`Selector loads the HTML, page associated with the icon and
`which contains the Mail View Java applet. The associated
`HTML page is loaded and graphically displayed in the
`display pane 420 of the main screen 402. The application
`icon pane 410 remains visible at all times. The applet loads
`itself into RAM of the host, and then executes and runs on
`the user’s host.
`Applications 240 may also be an HTML page without an
`applet, or a set of forms tied to Common Gateway Interface
`(CGI) scripts.
`
`CONFIGURING APPLICATION PROGRAM
`PROPERTIES
`The appearance and behavior of the user’s host and the
`currently executing application are governed by configura
`tion files or property lists. In one embodiment, the property
`lists are implemented as text files 214, 216, 220, 222 that
`reside on the HTTP server 208. A user property list 218 is
`stored on a logically remote file server 232. During the boot
`process, the remote file server 232 is mounted using the NFS
`protocol so that the file server 232 is accessible by to the
`local host such as NC 200. The user property list can be
`stored in a home directory exclusively assigned to a par
`ticular user and located on the NFS-mounted file server 232.
`When the bootstrap loader program of the host is running,
`it receives from the JBS 206 a URL representing an initial
`Selector configuration file. For example, the URL may be:
`http://webserver/jdt/props/Selector.init
`where “webserver” refers to an HTTP server such as HTTP
`server 208. The file “selectorinit-> is used to rendezvous
`with the HTTP server where a set of properties lists are
`installed. For example, the “selector.init-> file can contain a
`text string that specifies the HTTP server where properties
`files are installed, such as HTTP server 208. Selector estab
`lishes an HTTP connection to that server, and loads the
`properties files. These files are assumed to be in the same
`location as the “selectorinit-> file.
`The term “properties” refers broadly to application pro
`gram attributes, parameters, preferences, and environmental
`variables, e.g., any aspect of an application program that an
`end user may configure or adjust. Examples of properties are
`display fonts, the identity and location of external resources
`such as printers, servers, and other input/output devices,
`methods of alerting a user such as through an alarm or bell,
`window location and size, and language used by an appli
`cation.
`In one embodiment, the properties lists comprise a plu
`rality of files. In this description, the terms “list” and “file”
`are used interchangeably to refer to property lists, because
`one way to implement list is a set of text strings stored in a
`file. However, property lists as described herein may be
`stored in any convenient form; use of files is not required.
`One file has a list of default properties. The second is a list
`of specific properties. The third is a list of final properties.
`As shown in FIG. 2, as an example, a default properties list
`214 and two exemplary specific properties lists (host prop
`erties list 216, and application properties list 224) are each
`stored on a mass storage device 212 associated with the
`HTTP server 208. Another exemplary specific properties
`list, user properties list 218, is stored on a remote file server
`232. The mass storage device 212 also stores a final system
`
`5,832,505
`
`10
`
`15
`
`20
`
`30
`
`35
`
`40
`
`45
`
`50
`
`60
`
`65
`
`

`

`5,832,505
`
`8
`7
`For example, the HTTP server can store an application-
`wide properties list 220, a final host-specific properties list
`specific property list file 224 for Selector or another appli-
`222, and a final application-specific properties list 226.
`cation. If the system administrator wishes to establish final
`One feature of this invention is a method enabling the
`properties for that application, the system administrator can
`system administrator to override certain user-selected prop-
`prepare and store on the server a final application-specific
`erties with the assurance that neither the user nor any other
`property list file 226. The discussion below of Selector-
`individual can override the system administrator’s property
`specific property files is another example of using the
`decisions. Accordingly, rules of precedence are used when
`invention to establish application program-specific
`the property files are loaded.
`properties, but property list files can be provided for par-
`One aspect of the invention is a method shown in the
`ticular application programs other than Selector. For
`flowchart of FIG. 3. As shown in step 302 of FIG. 3, when
`example, in one embodiment, the serverstores a file named/
`a computer program or process implementing the invention
`(for example, Selector or another application program call-
`props/<group>/<app>.props where <app> is the nameof an
`ing methods in the JDTProperties class, described below)
`application program. Sucha file containsalist of properties
`loads property files, it begins by loadinga first list of default
`governing the named application program, and such prop-
`properties, such as the default properties list 214. The term
`erties would apply to all users in the group <group>. In
`“load” refers, by way of example, to reading a property list
`addition, stored in a user’s home directory,
`there is a
`file and writing each property string found in the file to a
`user-defined application-specific property list
`file called
`“SHOME/<app>.props”in whicha particular user sets prop-
`merged property list. The merged property list can be stored
`in the RAM memory of the network computer on which
`erties for a particular application <app>. There is a final
`Selector is running (such as NC 200),or in files on a mass
`application-specific property list
`file called “/props/
`storage device of a server such as the HTTPserver 208 or
`<group>/<app>.final” which contains properties that over-
`JBS 206, or in the RAM memory of the server. The merged
`ride the user-defined application-specific properties. The
`property list may be organized in any convenient data
`pathname given for this final file is relative to the system
`install area.
`structure or data object which is accessible to and readable
`by the application programs 240. In one embodiment, the
`merged property list
`is maintained by a JDTProperties
`object, which is described in more detail below.
`Next, as shown in step 304, a second list of specific
`properties is read, such as the host-specific properties file
`216, the user properties list 218, or the application-specific
`properties list 224. As shown in step 306, as the specific
`property values are read, they are compared to the previ-
`ously loaded default property list values. If any value in the
`default property list conflicts with a corresponding value in
`the specific properties list (for example, if both lists attempt
`to set a system font parameter to different values), then as
`shownin step 308, the conflicting default property list value
`is overridden with the corresponding specific property list
`value.
`Thereafter, and if the test of step 306 is negative, control
`is passed to step 310 in which the final property list values
`are read. As shownin step 306, as the final property values
`are read, they are comparedto all previously loaded default
`property list values and the specific list values. If any value
`in the final property list conflicts with a corresponding value
`in any previously loaded properties list, then as shown in
`step 314, the conflicting property list value is overridden
`with the corresponding final property list value.
`The default property list and the final property list are
`prepared by a system administrator and store