WO2002003255A2

WO2002003255A2 - Configurable browser system

Info

Publication number: WO2002003255A2
Application number: PCT/US2001/021150
Authority: WO
Inventors: Gary Macdougall; Dudley Bryan; Nezam Khan; Mehamood Hosein
Original assignee: Electronic Marketing Technologies
Priority date: 2000-06-30
Filing date: 2001-07-02
Publication date: 2002-01-10
Also published as: WO2002003255A3; AU2001271798A1; WO2002003255A9

Abstract

A configurable browser system is offered. A multipane graphical user interface's appearance and function are controlled by a configuration file. Multiple panes may combine to appear to a user as a unitary browser. Commands executed on one pane may effect the display of another. Custom browser configuration files are created by an affinity source using rules established in a system provided development kit. Requests for content by the individual browsers may be routed through a back-end controller which may alter the request according to the browser settings in the configuration file. The back-end controller may update configuration files without having to install an entirely new graphical user interface.

Description

CONFIGURABLE BROWSER SYSTEM

Related Application

Pursuant to 35 U.S.C. § 119(e) this application claims the priority of provisional application serial number 60/215,502, filed on June 30, 2000.

Field of the Invention

This invention relates to web browsers and related controlling technology.

Background Almost every user who browses a computer network, whether it be the World

Wide Web, an intranet, or other kind of network regularly uses a web browser. The most common web browsers are Internet Explorer by Microsoft Corporation and Navigator and Communicator by Netscape. These browsers offer a look, feel, and functionality that users have become accustomed to. The typical browsing functions such as back, forward, refresh/reload are expected to be available to users when using a browser. These browsers, however functional and familiar, offer very little in terms of configurability except for setting certain options. Typically users operate the browsers as given by the publisher and do not attempt much personalization.

Browsers are used for viewing pages of content usually provided by servers. Such servers may be local, as is often true in the case of an intranet of a company or other organization, or remote, as is often true in the case of the Internet. The content of pages viewed on browsers may include textual and graphical information, both static and dynamic. The publisher of a particular page may generate revenue by selling to others the right to display advertising on a part of the page. Schemes have been devised, such as through using small pieces of program code called "cookies," to tailor such advertising to a viewer. Such advertising is often in the form of an on-screen "banner."

The effectiveness of this form of advertising has disappointed some, in part because viewers may quite rapidly change displayed pages as they follow "links" to other web pages. Consequently, from an advertising perspective, there is an acknowledged desire on the part of advertisers and web publishers to create ways to increase the amount of time a viewer is exposed to an advertisement.

Summary

An information presentation system is offered comprising a configuration file and a graphical user interface comprising at least one configurable pane whose display contents and command functions made available to a user are controlled according to the configuration file, at least one browser window which displays content in response to a user selection of a site, and a browser engine that receives command information from one of the at least one configurable pane and in response thereto effects the display of one of the at least one browser window or another of the at least one configurable pane.

In a further embodiment the information presentation system further comprises a back end controller comprising a back end engine capable of exchanging at least some commands with the graphical user interface for effecting operation or appearance of at least one of said panes. In a further embodiment the back end controller further comprises the configuration file and the back end engine effects operation or appearance of at least one pane in response to the contents of the configuration file. In another embodiment the back end controller is operated to update the configuration file. In another embodiment the back end controller further comprises a connection to a network. In a further embodiment the browser engine further comprises a connection to a network. In a further embodiment the at least one browser window is configured by the graphical user interface to not accept input from a user.

In alternate embodiment a computer-readable medium is offered, the medium including thereon computer-readable instructions for creating on a computer, alone or in combination with instructions separately stored in the computer, a graphical user interface comprising at least one configurable pane whose display contents and command functions made available to a user are controlled according to a configuration file, at least one browser window which displays content in response to a user selection of a site, and a browser engine that allows command information from one of the at least one configurable pane to effect the display of one of the at least one browser window or another of the at least one configurable pane. In a further embodiment the graphical user interface further comprises a connection to a back end controller. In a further embodiment the instructions further create on a computer the configuration file.

In another alternate embodiment a method of operating a graphical user interface is offered, the method comprising: in accordance with a configuration file, entering a command on a configurable pane; and effecting the display on another configurable pane in response to the command. In a further embodiment the act of effecting the display is executed by a browser engine. In a further embodiment the act of effecting the display is executed by a back end controller. In a further alternate embodiment a method of doing business is offered, the method comprising: providing a user with a web browser system configured to display content selected by a particular affinity source; and remote from the user, controlling the appearance and functionality of portions of the browser; and deriving value by requiring others to provide compensation in return for providing to them the right to control, at least in part, for at least a time, said browser appearance or functionality.

In another alternate embodiment a method of delivering information is offered, the method comprising: providing to a user one or more computer programs which when executed by a computer having a display screen establish a configurable browser system adapted to display on the display screen at least one pane configured with content provided from a configuration file; and providing to the configurable browser system a configuration file containing configuration information comprising at least one of data and instructions for configuring the at least one pane to be configured.

In a further embodiment the providing a configuration file further includes receiving from an affinity source entity information defining at least one graphic design to be displayed in the at least one pane and encoding said information in the configuration file so that the at least one graphic design is displayed when the configuration file is read by the configurable browser system.

In a further embodiment the providing a configuration file further includes receiving from an affinity source entity information defining at least one functional change to be made to the user interface of at least one pane of the configurable browser system and encoding said information in the configuration file so that a changed user interface is displayed when the configuration file is read by the configurable browser system. In a further embodiment the configuration file is provided to a plurality of configurable browser systems.

In a further embodiment said information defining at least one functional change is sent in a script language and encoding said information is achieved by the configurable browser system generating a new configuration file from said information defining at least one functional change.

Brief Description of the Drawings

Fig. 1 shows an overview of a configurable browser system; Fig. 2 A shows a more detailed overview of a configurable browser system according to one aspect of an illustrative embodiment of the invention:

Fig. 2B shows a more detailed overview of a configurable browser system according to one aspect of an illustrative embodiment of the invention;

Fig. 3 A shows an example of a configurable browser display according to one aspect of an illustrative embodiment of the invention;

Fig. 3B shows an example of a configured browser according to one aspect of an illustrative embodiment of the invention;

Fig. 3C shows an example of a configured browser according to one aspect of an illustrative embodiment of the invention; Fig.4 shows a further overview of the configurable browser system according to one aspect of an illustrative embodiment of the invention;

Fig.5 shows how a back function is handled according to one aspect of an illustrative embodiment of the invention; Fig. 6 shows an overview of the back-end controller according to one aspect of an illustrative embodiment of the invention;

Fig. 7 shows how a web page access request is handled by the configurable browser system according to one aspect of an illustrative embodiment of the invention; Fig. 8 shows a browser script update according to one aspect of an illustrative embodiment of the invention.

Detailed Description

A configurable browser system as taught herein offers a system of highly customizable modular browsers and browser combinations (e.g., browsers for viewing pages on the World Wide Web portion of the global Internet or on intranets, extranets, or the like) whose appearance and functionality are controlled by a configuration file(s). An individual or group (known as an "affinity source") which wishes to create a special "themed" browsing experience creates a configuration file(s) according to the system and the configuration file is distributed to users who wish to have a themed browsing experience as created by the affinity source. (Typical affinity sources include performing artists, sports teams, trade unions, colleges, museums, etc.) The flexible and modular construction of the configurable browser system allows the affinity source to remotely control a user's browsing experience (e.g. the visual presentation or environment thereof). Moreover, the browsing experience may be changed by the affinity source without the user needing to install a new executable program.

The configurable browser system may appeal to a user because it offers the user a browsing experience closely affiliated with an affinity source of the user's choice. The system gives an affinity source control over highly valued desktop space on users' browsers. This control may be used to entertain and inform users, direct them to new channels and sites, provide greater persistence of advertising or simply provide them with a more comfortable browsing experience. It thus creates opportunities for generating revenue by "renting out" that desktop space and for enhancing the affinity relationship by delivering affinity related content to a receptive audience. The system may also allow advertisers (or other organizations) to more easily target users who share a particular affinity.

Fig. 1 shows the configurable browser system 100 and a user 200. Note that the browsers according to the invention may be referred to from time to time as "web" browsers but this is not meant to suggest or imply that they are only for browsing the World Wide Web. Indeed, they may be used to browse content on other networks (such as intranets). More specifically, Fig. 2 shows the configurable browser system 100 as typically divided into two main components: a multipane graphical user interface (GUI) 102 which exists on users' machines, and a back-end controller 104 which is typically located on a server(s) (which may be local or remote to the user). A network 106, which for exemplary purposes is shown as the Internet. The multipane GUI, Internet, and back- end controller interact to display the appropriate information as requested by the user 200 or intended by the operator of the back-end controller. Here, the back-end controller 104 interacts with both the multipane GUI 102 and the Internet 106 to control what the user 200 sees.

The configurable browser system is not limited to Internet applications and does not require connection to the Internet. It may function in an internal intranet environment, or in a closed environment where the multipane GUI's access is limited to only internal sites with no network access.

For purposes of this description "configurable" means the ability to control the appearance and functionality of a display, including the display's shape, size, placement, and/or content. Configurability does not necessarily mean changeability or re- configurability, though configurable interfaces as taught herein may (but need not) be changeable and re-configurable. The configuration of an interface is controlled mainly by a particular data file or files, (discussed herein as a configuration file(s)) not by a page served up in correspondence to a URL. Although the appearance of a configurable interface or browser window may be altered by the contents at a URL, it is the configuration file(s) which most defines the nature of the multipane GUI display.

Because of the modular nature of the configurable browser system, it is not necessary to create a new executable program each time a feature of the browsing experience is to be changed. In order to change the multipane GUI display a change needs only to be made to the configuration file. For example, if an affinity source wished to change the look of its multipane GUI, the configurable browser system could do so by simply updating the configuration file, preferably using higher level code such as Java script or hyper text markup language (HTML). In order to change the look of a conventional browser, the browser would need to be rewritten or recompiled, typically using lower level code such as C++.

A configurable (web) browser system typically comprises a multipane GUI and a back-end controller. The user has little interaction with the back-end controller and interacts almost exclusively with the multipane GUI. The display of the multipane GUI is made up of several panes which may appear (as a unit) to function similarly to normal browsers except insofar as a portion of a screen— i.e. one or more panes — contains content the user does not control and which may not be dependent on the user's choice of sites to view. Users may operate the configurable interfaces which comprise the multipane GUI display to view "sites" (such as web pages, file download locations, "chat rooms," or other on-line locations or activities).

The multipane GUI display typically comprises at least one browser engine, at least one configurable interface and at least one browser window. What a user sees through the browser window is a result of whatever is served up when the user directs the multipane GUI to a URL (uniform resource locator) or URN (uniform resource name) and the related site contents are served up and displayed. However, the look and feel of the at least one configurable interface and at least one browser window may be controlled by a back-end controller or browser engine and for the most part is not under user or viewed site control. Extra functionality, configurable interface appearance, exclusive channels, and other features may all be changed or monitored by a server(s) which controls the back-end controller with which the multipane GUI interacts. These features and related graphics may be stored (in a configuration file or files) locally to or remotely from the multipane GUI.

Fig. 3 A shows a typical display presented by a multipane GUI, that users might see when using the configurable browser system. The configurable interfaces B and C (304 and 306) are typically displayed according to a prearranged manner and with content determined by a configuration file via the back-end controller or browser engine, while the content of the display in browser window A (302) is left to the user selection of a URL or URN selected by the user.

The panes of the multipane GUI are individual instances of basic browsers configured according to the configuration file. To create the panes of the multipane GUI display only one core instance of browser code is necessary. The panes are formed by opening instantiations of that core code. Applications known and open to developers, such as, for example, Microsoft's IWebBrowser 2, may be used for this purpose. The particular instantiations will format their individual appearance and function according to the configuration file.. In this manner, only one instance of core code is necessary. Multiple instances of code may be used in other embodiments, but it is not necessary to do so.

As shown in Fig. 3 A, each display 300 includes a set of at least one browser window 302, and at least one configurable interface, there being two configurable interfaces 304 and 306 shown. Each of these panes may act as a separate browser which may be independently controlled by the back-end controller or by a browser engine (described below). The browser window and configurable interfaces are preferably arranged so that their combination appears to a user much as one unitary, conventional browser, though each browser window and configurable interface is configured individually and has its own functionality, as prescribed by the configuration file. Depending on the content a multipane GUI is configured to display, the associated browser window and configurable interfaces are configured to appear with the graphics and information stored in the configuration file. When the configurable interfaces are configured to appear as a unitary browser, browser window A (302) typically shows the content of the page selected for viewing by the user; configurable interface B (304) typically shows user controls (such as back, forward, stop, etc.) applicable to window A, and additional graphics and functions as supplied by the configuration file; configurable interface C (306) typically shows streaming information, links (channels) to other web sites, and other information as outlined in the configuration file. The configuration file may control what is shown in, and what functionality is given to, each configurable interface and browser window; thus, the foregoing construct is exemplary only.

As further shown in Fig. 3 A, a possible embodiment of the display 300 also consists of a title bar 308, an address bar 310, and a status bar 312. The title bar 308 may provide the functionality most users expect of a title bar on when using a browser. Typically, in the standard Microsoft Windows family operating systems format, for example, the title bar includes an icon, a title text string, and Windows control buttons which allow the user to move, resize, or close the display. The address bar 310 may display the address which the user is currently viewing or loading. The status bar 312 may provide additional information to the user, such as target sites of links, a progress bar which shows downloading status or other information as provided by the user's individual computer or the configurable browser system. Any of these utility bars may also incorporate other functionality that is found in other common browsers or is unique to the configurable browser system or particular configuration. The appearance and function of the configurable interfaces and browser windows may be configured to create a "themed" browsing experience where the graphics, appearance and content in interfaces B and C all relate to a central idea, such as, for example, an identifiable individual, affinity group or organization like a performer, music group, sports team, product or company (any of which shall be referred to as an "affinity source"). The affinity source (or its representative) provides information to the system to format one or more of configurable interfaces B and C according to its specifications, and any user who so desires may use that particular configuration for his/her browsing needs. ^■ Fig. 3B shows a configured multipane GUI with the musical group "Hanson" as the affinity source.

As described above, Fig. 3B shows a multipane GUI display configured (to convey a unitary appearance) for the affinity source "Hanson." While the display depicted in Fig. 3B appears like an ordinary browser with only a different look, the function of the panes behind the display differs greatly from a conventional web browser. The configurable interfaces 320 and 330 are displayed according to their settings in the configuration file. In this example of a configured display the first configurable interface 320 offers graphics corresponding to the particular affinity source, as well as a set of known browser buttons whose activation would cause a change in the appearance of the browser window 340. For example, if the "back" button were activated at configurable interface 320 the browser engine would cause the browser window 340 to display the page previously displayed by the browser window. Fig. 3C shows the browser window displaying the previous page 342. Configurable interface 330 shows a set of "channels" provided by the affinity source to provide exclusive content to the users who subscribe to the particular affinity's multipane GUI.

One or more multipane GUIs may exist on user machines and communicate with the back-end controller 104. For example, a user computer may have two multipane GUIs which are affiliated with sports teams and one with which is affiliated with a political organization. Each multipane GUI may have a different appearance and feature set from the next, as dictated by the configuration data being used by the multipane GUI. As shown in Fig. 4, the multipane GUI 102 is made up of a browser engine 400 and a display 300. Typically, a configuration file 402 is also part of the multipane GUI 102. A configuration file 402 is a prescribed set of data used to control the appearance and functionality of the multipane GUI. (For simplicity of explanation, the singular term "file" is used, it being understood that a "configuration file" actually may be one or more files or as a matter of design choice, the singular "file" being used to mean "file or files.") The configuration file may, for example, be put on the user's machine by removable media or it may be downloaded. More than one configuration file may be present as part of the configurable browser system on a user's computer, but typically only one configuration file is used at a time to configure an instance of the multipane GUI.

The multipane GUI is controlled by a browser engine 400. The browser engine, as described below, is software which controls the receiving of data to the multipane GUI as well as the interaction between the configurable interfaces and the browser windows. . For purposes of illustration, the browser engine is referred to in the singular; however, several pieces of software may combine to control the display. For example, each configurable interface and browser window may have its own dedicated software which controls its interactions within the configurable browser system. For discussion purposes this software is collectively referred to as "the browser engine."

The user may acquire a multipane GUI either on-line or off-line. The user may obtain the multipane GUI on-line by downloading the multipane GUI from a designated web site. The user may obtain the multipane GUI off-line by uploading the browser from media which contains a copy of the multipane GUI. This media may, for example, be a CD, card, or disk linked to or published by a particular affinity source. The configurable browser system allows users to choose the appearance and functionality of their particular multipane GUI by selecting the configuration of a preferred affinity (e.g., a favorite entertainer or sports team). The configurable browser system also allows the back-end controller to determine what information appears to the user in the display dedicated to the affinity source.

To obtain a multipane GUI, the user installs the browser engine 400 (and typically at least one configuration file) onto a computer. The browser engine 400 takes the configuration file 402 (or obtains one from the back-end controller 104) and formats the display 300 on the user's machine. The browser engine 400 controls the user's browsing experience using the configuration file 402 and the back-end controller 104. It configures the display 300 to as prescribed by the configuration file 402. The engine 400 itself typically is relatively small, compared to the configuration file 402, which stores all the information used by the engine 400 to format the individual display 300.

As shown in Fig. 4 the browser engine 400 interacts with the display 300 and the configuration file 402, to maintain and control the user's browsing experience. The browser engine 400 handles calls between the display 300 and the configuration file 402, as well as between the multipane GUI 102 and the back-end controller 104. The browser engine may also have a connection to an external network 106 if it is set up to do so by the configuration file. The browser engine 400 may change the appearance of any of the configurable interfaces 304, 306 based on commands from the back-end controller 104, the configurable interfaces 304, 306 themselves or the configuration file 402. The browser engine 400 may also reconfigure the display 300 based on a different configuration file 402 if instructed to do so by the user 200, back-end controller 104 or other command source.

The illustrated arrangement of configurable interfaces, browser windows and functional bars is exemplary only; it is by no means the only arrangement which will be useful in accordance with these teachings. Configurable interfaces, browser windows and utility bars may be formatted and arranged in any manner permitted by the configurable browser system. However, the illustrated arrangement, with the configurable interfaces and browser windows contiguous and forming a rectangle, presents to the user the appearance or impression of a standard unitary browser

(particularly since the user controls the content of only one window or pane). Other embodiments may — but need not necessarily — produce a similar impression. An affinity source may desire to create a configuration file so that its display does not appear to the user as a unitary browser. This is one option of the configurable browser system. The unitary browser presentation is for illustrative purposes only.

Commands sent to or from a browser window or configurable interface, such as the one described above in reference to Figs. 3B and 3C, preferably are executed as "scripts" which may be run by the browser engine or by the back-end controller or in part by each of them. The scripts of one configurable interface or browser window⁷ may relate to and control the display produced by another configurable interface or browser window. This modular construction of commands and display allows commands to be sent to another location (e.g., the back end controller) before they are executed. This diversion of commands, for example, may allow the back-end controller to alter commands or filter content, as further described below.

Fig. 5 shows how a typical command from one configurable interface may change the appearance of another configurable interface or a browser window. In this example a "back" button executed on configurable interface B 304 resulting in an update of browser window A 302 (note that before the actions in Fig. 5 the configuration file has properly configured the configurable interfaces and browser window). At time Tl a user clicks on an on-screen button on a configurable interface. The button click is fed to a browser engine 400 associated with that interface. At time T2 the browser engine 400 interprets the click and checks the associated configurations file for the proper script to execute. At time T3 the browser engine 400 then executes the script and updates the relevant browser window 302 and/or configurable interface 304/306 accordingly. As an alternative the script may instead be passed to and executed by the back-end controller 104, depending on the system configuration. In this manner input to one configurable interface or browser window may be used effectively to control another, with the result that together the configurable interfaces 304/306 and browser window(s) 302 may appear to the user as a unitary browser system.

Using this approach a configurable interface or browser window may even reconfigure itself as a result of a user command. For example, a button may be provided on a configurable interface or browser window for causing the configurable interface or browser window to change its configuration to reveal new functions. One or more of the configurable interfaces or browser windows may also have functionality which controls functions on the user's machine, such as, for example, audio volume or application launching. The configurable interface and browser window functionality may be dictated by the configuration file.

In a less complex embodiment, the configurable interfaces may be implemented simply as clickable graphics with relatively little functionality. As described, commands or requests for pages executed by the user may be sent to the back-end controller before they are implemented.

The back-end controller 104 is typically, though not necessarily, located on a separate (often remote) server though it may be located on a user's PC. The back-end controller 104 provides the configurable browser system with extra functionality that is invisible to the user. The back-end controller may store configuration files of one or more preconfigured browser systems, promulgate and distribute rules for creating configuration files, provide connections to the Internet or other networks and communicate with the multipane GUIs. The back-end controller 104 may regularly update configuration files and send those updates to the appropriate multipane GUIs via command scripts, or, alternatively, the back-end controller 104 may notify users of updated data available for download. The back-end controller 104 may also keep records of the behavior of certain configuration files and how users operate the multipane GUIs.

The back-end controller 104 may also control at least aspects of the operation and visual appearance of the individual multipane GUIs. The back-end controller 104 may change the appearance of a particular multipane GUI or set of multipane GUIs as frequently as desired. The back-end controller 104 may display video or animation on a display that is configured to do so, change graphics, add and/or take away functions, display messages, or perform any other desired operation. In an illustrative implementation, a back-end controller 104 may connect to (i.e., communicate with) the multipane GUIs over the Internet, through standard Internet protocols. The back-end controller 104 may also connect to the multipane GUIs via other communications networks or protocols, such as wide- or local-area networks. The back-end controller 104 may even be on the same computer as the multipane GUIs and connect with them via internal communication paths.

As shown in Fig. 6, the back-end controller 104 may have an architecture comprised of three components: a back-end engine 500, a content library (CL) 502, and a content developer's kit (CDK) 504. Only the back-end engine is necessary for there to be a back-end controller; the other components are optional. The back-end engine 500 communicates with the multipane GUI 102 and transports requested information from the back-end controller 104 and Internet to the multipane GUIs. The CL 502 is a library of preconfigured content which may be used by the back-end controller to configure the function and/or appearance of the configurable interfaces and browser windows. The CDK 504 contains tools used to create the configuration files contained in the CL.

The back-end engine 500 may control the flow of information to and from the back-end controller 104. The back-end engine 500 may control the sending and receiving of configuration data, network data, CDK data and user data. The back-end engine may handle the communication tasks among the internal back-end controller 104 components as well as between the back-end controller 104 and the configurable browsers. The back- end engine 500 may send and receive updates to the multipane GUIs, and generally control the flow of data in the back-end controller 104. If present, the CL 502 is a library which contains configuration files. Each configuration file 402 contains information which controls the appearance and functionality of one or more multipane GUIs. A configuration file 402 may typically be downloaded onto a user machine and may be used by the browser engine 400 to create and present the configured display on the user's machine. The configuration file 402 may contain any combination of browser-related information, including HTML code, executable scripts, animation, graphics, links, text or any other kind of data.

The configuration files may typically be created externally to the configurable browser system. An entity that wishes to create a specialized (e.g., affinity) browser system compiles data (such as graphics, animation, command scripts, etc.) into a configuration file according to a set of rules may create one (the entity may also delete configuration files that it no longer wants active). That configuration file 402 is then added to the CL 502. Configuration files may be updated as frequently, and at whatever time, as the entity desires. Entities may also create multiple configuration files for different desired browser configurations (e.g. "home" and "visitor" browsers for the same sports team).

As discussed above, Fig. 3B shows a display as configured according to a configuration file to create a specialized, configured browser system for the currently well-known musical group Hanson. The configuration file contains information regarding the size, appearance, and function of the buttons, the configurable interfaces 320 and 330, and the browser window 340. A configuration file may be distributed to users over removable media, such as compact or floppy disks, or may be sent to a user (e.g., by email or downloaded from a web site or via a persistent "push" channel where data is uploaded to affiliated multipane GUIs) when the user makes a request to the system for that particular configuration file. The CL 502 stores the configuration files with the back-end controller 104 of the configurable browser system.

An affmity source which creates a configuration file has a great deal of flexibility in designing its particular browser configuration(s). The graphics and functionality that go into the configuration file 402 may create almost any kind of browser environment. The entity may design its configuration file(s) so that the functional buttons feature animated graphics; sound may be added to particular features on the display; features may even be removed if the designer of the configuration file so desires. For example, a particular affmity source may limit the content viewable on its multipane GUI by creating its configuration file 402 so that no address bar 310 should be present in the display, thereby limiting the user to only viewing sites accessible by selecting particular channels offered in one of the browser windows, automatically limiting the user's exposure to material. An affmity source may also limit the content viewable on its multipane GUI by creating its configuration file 402 so that the configuration file prevents users of that multipane GUI from viewing certain sites. This technique may be used, for example, to prevent a company's configured multipane GUI from being used to access a competitor's website. It may also be used to prevent a multipane GUI configured for an affinity source directed toward children from accessing adult material. Commercial filters may be used by the configuration file for this purpose, or the affinity source may create its own filtering program to be executed by the configurable browser system. These methods, and or others, may be used by an affinity source to further create a specific browsing experience.

The configuration file 402 may also provide a mechanism to establish live connections (preferably through the back-end controller 104) to allow the users using a particular affinity source's multipane GUI to chat online, or it may call for a live video display to be output to all its users on one of the configurable interfaces or browser windows. The possibilities are virtually limitless.

The graphics and information for each configuration file may be separately created and formatted for use by the system using tools such as those of the CDK 504. Because the configurable browser system creates browsers modularly, all an affinity source need do to create a multipane GUI is to create the specific "modules" necessary to configure a multipane GUI. Optionally, a set of tools is provided for that purpose.

The CDK, if available, exists to make the creation of configuration files simpler for affinity sources. The CDK 504 contains tools used to create the configuration files. The CDK is an optional means by which an affinity source may create a configuration file. The CDK is analogous to an application programming interface (API) which is provided by a software creator to assist other entities in using the software to create individualized programs.

Any affinity source that wishes to create a configuration file may upload the CDK or use it on-line. The CDK preferably contains the tools necessary to structure content (such as graphics, sound, functionality, etc.) in a manner that may be stored in a configuration file and applied by user end multipane GUIs. The CDK also may includes a layout editor. In the layout editor, the creator of a configured browser may send the materials it wants to use on its multipane GUIs to the system to preview what its display will look like. The CDK may also offer tools that may be used for marking particular multipane GUIs so that the marked multipane GUIs will then only work with certain configuration files.

The CDK provides rules that allow the configuration information to be easily stored into a configuration file. It provides rules for formatting graphics, text, sound, animation, user controls, and back-end controller interaction. For example, the CDK may have executable scripts for common functions already written and available for creating entities to use, such as "back", "forward" or "refresh". The CDK may also have common menus available for creating entities to use in title bar(s). The CDK may also give creating entities the proper formats for graphics data and text data. One of the purposes of the CDK is to allow entities as much freedom as possible to create configuration files and still ensure that these files will work with the configurable browser system. The existence of the CDK may give any entity that wants to have its own browser system the ability to create a configuration on its own. Once a configuration file is complete, it may be uploaded to the back-end controller and incorporated the configurable browser system. The back-end controller 104 may distribute completed configuration files to users as instructed by the affinity source. Preferably, the back-end retains a copy of a configuration file so that it may reference the file without having to access a particular multipane GUI.

The back-end controller 104 may control several multipane GUIs at once, even if each has a different configuration. Preferably, all (or at least most) requests for and transmissions of content between the multipane GUI and the network goes through the back-end controller. This path may give the configurable browser system the ability to create private "web sites" that are only visible to multipane GUIs that are associated with a particular affinity. For example, the back-end may store certain content (preferably in the content library) which are only viewable to "channels" which are accessed on one of the configurable interfaces of the multipane GUI display. This content may be unreachable by conventional browsers. Creating specific "affinity only" content may motivate users to use the configurable browser system created by a particular affmity. This feature may be combined with a configuration, as described above, which removes the address bar from the multipane GUI. This combination would create an entirely "affinity only" browser which may be used for myriad purposes, such as, for example, to create an entirely child-friendly browsing experience.

Routing content requests through the back-end controller also gives the browser system the ability to filter certain web sites or their content according to parameters established by the back-end controller or by an individual configuration file. For example, as described in further detail above, a multipane GUI associated with a children's activity may have functionality built in to filter out adult content.

Routing content request through the back-end controller also gives the browser system the ability to track the content requested by a particular multipane GUI or user. The back-end controller may also allow advertisers to direct advertisements to users who share a particular affinity. The operator of the back-end controller may also record which users share affinities and may effectively allow affinities to share user information. Conversely, the configurable browser system also allows for the affinities to keep their information separate if desired.

As shown in Fig. 7, the methodology for obtaining a web page using the configurable browser system differs markedly from that of a standard browser. The process begins at time Tl with a user 200 inputting to the multipane GUI 102 a request for a page. The request is typically sent by a user to a configurable interface. The request is handled by the browser engine 400. If configured to do so the browser engine 400 may then retrieve the page from the network and/or Internet 106; however, typically the browser engine will send the request to the back-end controller 104 as indicated for time T2. The back-end controller may then evaluate the request according to the configuration file to determine if and how the browser engine should access the desired page. If the back-end controller 104 determines that the request is acceptable, then the back-end controller interacts via a communications channel (e.g., the Internet) with the appropriate server to retrieve the page at time T3. The back-end controller 104 then sends the page to the multipane GUI at time T4. The browser engine 400 receives the page and delivers it to the display 300 at time T5. The display 300 then serves up the requested page to the user 200 at time T6. If the user requests a page which is located on an intranet rather than on the Internet the process as described above in reference to Fig. 7 is repeated identically, except that an intranet (or other internal network) takes the place of the Internet.

It is possible for the multipane GUI to operate "off-line," i.e., when not connected to a network or the Internet. When not connected to a network the multipane GUI maintains its appearance but all commands are handled by the browser engine and not sent to the back-end controller. The multipane GUI may still function as when connected to a network but it will be unable to access any pages than aren't located locally to the computer running the multipane GUI.

It is also possible for a user to operate the configurable browser system if the multipane GUI is not connected to the back-end controller. This "disconnected" state may occur if the configuration file does not require that the multipane GUI be connected to the back-end controller or if the back-end controller is temporarily unavailable. If the configuration file allows for disconnected operation the browser engine may handle all user requests for externally located pages. Here, the multipane GUI 102 would have a connection to an external network, as shown in Fig. 2 A. In this disconnected case the browser engine would handle all requests for pages (though the browser engine would still have to be able to access the page without disagreement from the configuration file). If disconnected from the back end, the multipane GUI would not be able to receive automatic updates or other data from the back-end as described below; however the configuration file may allow the multipane GUI to connect with the back-end on an occasional basis for the exchange of data.

The multipane GUI may also be disconnected from the back-end because the back-end is temporarily unavailable (whether due to a down Internet connection, etc.). In this case, if the multipane GUI is configured to do so (and the configuration file allows) the browser engine may temporarily handle external page requests as described above until the back-end becomes available. The configuration may give the browser engine authority to access only intranet or cached pages if the back-end is unavailable. In that case the browser engine will be restricted to intranet or cached pages only. If the browser engine is not authorized to handle any network page requests the disconnected multipane GUI may revert to "off-line" status as described above.

As described above, command scripts may be used to alter the appearance and functionality of a multipane GUI at any time. Command scripts may originate at a number of places in the system. For example, they may come from the user, from the configuration file, from configurable interfaces or browser windows, or from the back- end controller. Command scripts may be used to alter the appearance or functionality of the configurable interfaces or browser windows. For example, a configurable browser system of a sports team affinity source may change the display in its configurable interfaces and browser windows from a home game design to an away game design as the result of a command being sent from the back end controller to the multipane GUI.

Fig. 8 shows how a typical update script may operate. For purposes of describing the example, the affinity source in question is a sports team which wishes to update its affiliated multipane GUIs to reflect the "away game" browser configuration. At a particular time (when the team is scheduled to visit an opposing team) a configuration file located in the content library (CL) 502 at the back-end is used to update a configuration of the multipane GUIs associated with the particular affinity source (not shown) already in existence. At time Tl the back-end engine 500 receives notification from the file in the CL 502 that a new configuration should be used. At time T2 the back-end controller 104 then sends updated information (which in this example is a new configuration file, but may take the form of a specific command, a portion of a new configuration file, etc.) along with a command script to the affiliated multipane GUIs. At time T3 the browser engine of a receiving multipane GUI uses the command information and new configuration file to update the display and to replace the old configuration file. The multipane GUI is then reconfigured to display the "away game" arrangement and the user may continue to interact with the multipane GUI. In this manner the configuration of a multipane GUI may be changed by the sponsor / affmity source (even while in use), browser engines may be controlled to switch a display from one configuration file to another, and/or several multipane GUIs may be reconfigured simultaneously.

The example update of Fig. 8 where content is pushed to a multipane GUI is preferably executed by a command script written in a language such as Javascript. Updates may also be carried out by less active means, such as sending a communication (e.g. an email message) to a user of a multipane GUI affiliated with a particular affinity source to notify the user that updated data is available for the user to access at the user's convenience. The user may then download the updated data from a particular website. An update script of this manner may be called by a particular component of the configurable browser system or may be programmed to execute based on certain parameters (e.g., time, date, weather, etc.). These scripts may be sent at any time, allowing precise control over the appearance of the multipane GUI.

Having thus described the invention and various illustrative embodiments of the invention, some of its advantages and optional features, it will be apparent that such embodiments are presented by way of example only and not by way of limitation. Those persons skilled in the art will readily devise alterations and improvements on these embodiments, as well as additional embodiments, without departing from the spirit and scope of the invention. It is impossible to enumerate all of the variations that will quite quickly occur to those in the art. Accordingly, the invention is limited only as defined in the following claims and equivalents thereto.

Claims

What is claimed is:

1. An information presentation system comprising: a configuration file; a graphical user interface comprising at least one configurable pane whose display contents and command functions made available to a user are controlled according to the configuration file, at least one browser window which displays content in response to a user selection of a site, and a browser engine that receives command information from one of the at least one configurable pane and in response thereto effects the display of one of the at least one browser window or another of the at least one configurable pane.

2. The information presentation system of claim 1 further comprising: a back end controller comprising a back end engine capable of exchanging at least some commands with the graphical user interface for effecting operation or appearance of at least one of said panes.

3. The information presentation system of claim 2 wherein the back end controller further comprises the configuration file and the back end engine effects operation or appearance of at least one pane in response to the contents of the configuration file.

4. The information presentation system of claim 2 wherein the back end controller is operated to update the configuration file.

5. The information presentation system of claim 2 wherein the back end controller further comprises a connection to a network.

6. The information presentation system of claim 1 or 2 wherein the browser engine further comprises a connection to a network.

7. The information presentation system of claim 1 wherein the at least one browser window is configured by the graphical user interface to not accept input from a user.

8. A computer-readable medium including thereon computer-readable instructions for creating on a computer, alone or in combination with instructions separately stored in the computer: a graphical user interface comprising at least one configurable pane whose display contents and command functions made available to a user are controlled according to a configuration file, at least one browser window which displays content in response to a user selection of a site, and a browser engine that allows command information from one of the at least one configurable pane to effect the display of one of the at least one browser window or another of the at least one configurable pane.

9. The computer-readable medium of claim 8 wherein the graphical user interface further comprises a connection to a back end controller.

10. The computer-readable medium of claims 8 or 9 wherein the instructions further create on a computer the configuration file.

11. A method of operating a graphical user interface, the method comprising: in accordance with a configuration file entering a command on a configurable pane; and effecting the display on another configurable pane in response to the command.

12. The method of claim 11 wherein the act of effecting the display is executed by a browser engine.

13. The method of claim 11 wherein the act of effecting the display is executed by a back end controller.

14. A method of doing business comprising: providing a user with a web browser system configured to display content selected by a particular affinity source; and remote from the user, controlling the appearance and functionality of portions of the browser; and deriving value by requiring others to provide compensation in return for providing to them the right to control, at least in part, for at least a time, said browser appearance or functionality.

15. A method of delivering information, comprising: providing to a user one or more computer programs which when executed by a computer having a display screen establish a configurable browser system adapted to display on the display screen at least one pane configured with content provided from a configuration file; and providing to the configurable browser system a configuration file containing configuration information comprising at least one of data and instructions for configuring the at least one pane to be configured.

16. The method of claim 15, wherein providing a configuration file further includes receiving from an affinity source entity information defining at least one graphic design to be displayed in the at least one pane and encoding said information in the configuration file so that the at least one graphic design is displayed when the configuration file is read by the configurable browser system.

17. The method of claim 15, wherein providing a configuration file further includes receiving from an affinity source entity information defining at least one functional change to be made to the user interface of at least one pane of the configurable browser system and encoding said information in the configuration file so that a changed user interface is displayed when the configuration file is read by the configurable browser system.

18. The method of claim 16 or 17 further comprising providing the configuration file to a plurality of configurable browser systems.

19. The method of claim 17, wherein said information defining at least one functional change is sent in a script language and encoding said information is achieved by the configurable browser system generating a new configuration file from said information defining at least one functional change.