GB2331604A

GB2331604A - Dynamic network navigation tree

Info

Publication number: GB2331604A
Application number: GB9821761A
Authority: GB
Inventors: Anil Navkal; Nambiuur S Vidyashanker
Original assignee: Cabletron Systems Inc
Current assignee: Cabletron Systems Inc
Priority date: 1997-10-07
Filing date: 1998-10-06
Publication date: 1999-05-26
Also published as: GB2331604A9; GB9821761D0

Abstract

A navigation tree 32 for a web browser allows dynamic modification of the tree using additional tree portions supplied by nodes on different servers. A tree Java applet associated with a first server constructs and displays a tree using data from the first server. Accessing a node on a different server results in the loading of a modification Java applet and a data transfer JavaScript program from the new server. The modification applet retrieves new tree data from its server. The new tree data is then transferred from the modification applet to the tree applet by the JavaScript program. Thus, dynamic modification of the tree across different servers is achieved. A search and filter function may also be incorporated into the tree applet for simplifying navigation through a large number of tree nodes.

Description

2331604 DYNAMIC NETWORK NAVIGATION TREE

This invention relates generally to the field of navigation through a network-linked set of information nodes. and, more specifically, to the dynamic building of a network navigation aid.

With the advent of large-scale data networks (such as the "Internet"), a strong need exists for tools that allow a user to effectively retrieve information from various points in the network and display them to a user. The need for such a capacity is most apparent in the context of the World Wide Web (WWW). The WWW is a collection of "servers" on the Internet that utilize the Hypertext Transfer Protocol (HTTP). HTTP is a known application protocol that provides users with access to files (which can be in different formats, such as text, graphics, images, sound, and video) using a standard page description language known as Hypertext Markup Language (HTML). The term U server" can refer to a computer, or a software package, that provides a specific kind of service to client software running on another computer. Thus, in the context of this disclosure, "server" refers to an independent host for a servicing software program, such as one which provides data using HTTP.

Information available on the servers of the WWW is organized as independently addressable sections referred to as "pages", each of which is uniquely addressable and uses HTML to define a set of data to be transferred to an interested party. There -may a number of different web pages associated with each "server". Along with basic document formatting functions, HTML allows software developers to specify graphical pointers on displayed web pages (commonly referred to as "hyperlinks") that pointto other web pages. Hyperlinks commonly are displayed as highlighted text or graphical images on the web page. User selection of a hyperlink with a pointing device, such as a computer mouse, causes the local computer to issue a request for the HTML data from the web page identified by the hyperlink. The identified web page may be located locally on the same server, but is often located on a completely different server. Upon receipt of the new HTML data, the browser translates the HTML code and displays the content of the new web page.

When a browser user initiates a hyperlink transfer, common parlance refers to it as the user "going to" the web page identified in the hyperlink, as if the user was transported to the location of the page information, rather than just the opposite. When the user goes to a first web page on a first server, there may be several pages within that server through which the user,.may easily navigate with the assistance of displayed hyperlinks to those other pages. However, when the user goes to a different web page (i.e. on a different server), the ability to esily navigate the pages on the first server is lost. For example, a first page might have hyperlinks to several different servers, each of which has a top level page with links to other pages on that server. When a user executes a hyperlink from the first page to a page on another server, all the information about the other hyperlinks displayed at the first page is lost. Thus, to make use of those other hyperlinks, the user must return to the first page.

Most commercial browsers record a list of page addresses (typically in a "go" menu) in reverse chronological order, and allow a user to select from the list to return to a previously-visited site. However, this list is simply a recorded sequence of visited page addresses, and is not in any logical order. Nor does it allow access to links from the previously visited sites without first returning to those sites.

Prior art servers are sometimes arranged with their sites in some sort of a hierarchical structure. Typically, this hierarchy is a nested tree structure, in which higher level pages have lower level pages "nested"within them. This type of a hierarchy, while not required, provides a notation for the address, or "Universal

Resource Locator" (URL) of pages on a particular server which indicates the hierarchy and thereby allows logical categorization of the material on the various pages. This format also parallels the hierarchical filename structure used in organizing data files in DOS operating systems, making it familiar to many users.

The use of a collection of related web pages lends itself to the construction of a hierarchical tree of web pages based on some predetermined order. The components of the tree may be displayed in an expandable tree format similar to a WIN DOWS11 file manager format (WINDOWS" is a registered trademark of the Microsoft Corporation, Redmond, WA). An example of this is shown in the tree configuration displayed by the web page shown in FIG. 1.

FIG. 1 is a printed image fr9m a computer display (a uscreenshot") that is produced using a web browser that is displaying data from the web page having the URL uhftp://ww.microsoft.com/visualj/", as of the date of this application. The screen display includes different "frames" of displayed data, as is known in the art. In a frame to the left of the display is depicted a tree structure identifying a number of different web pages in a tree structure. A first page 10 is identified by the name "Microsoft Visual J++", and represents a "parent" node on the tree structure. Below this part of the tree display is a list of additional "nodes" 12 which are "children" of the first node. Of these children nodes, those that have "children" of there own (i.e. have additional sites subcategorized under the node in question) are designated with a plus sign adjacent to the icon representing that node in the tree.

The functionality of the tree structure shown in FIG. 1 is such that in a graphical user interface (GUI) environment, a user may select from the pages shown in the tree structure-with, for example, a "mouse". The user may highlight and select either the icon identifying the web page, or the plus sign adjacent to it (if it has children). Upon selection of the icon, the user is "taken" to the page identified by that icon, that iaTthe data from that page is transferred to the user's browser and displayed in another frame of the browser display. Upon selection of a plus sign, the tree is expanded to show the children organized under the icon to which the plus sign is adjacent. Once expanded, the user then has the option to select any of the children web pages as well. As the user navigates through the different pages identified by the tree, the tree remains displayed by the browser in a separate frame. Thus, the tree provides the user with the opportunity to access any of the web pages identified by the tree regardless of which page is currently being displayed.

Although prior art tree structures used for navigation in this manner provide auser with a convenient method of proceeding to any of the pages displayed by the tree, the tree itself is derived from a single web server source. That is, the entire tree is loaded into the user's browser in ope or more pieces while the user is accessing pages from only one server. As long as the pages being accessed are limited to a single server (that is, information for extending the tree comes from the same server as the original tree), new tree segments may be provided and added to the existing tree structure. However, prior art trees allow no such dynamic when the pages to be included in the tree reside with different servers.

According to one aspect of the invention there is provided method of generating a network navigation tree, the tree being graphical representation of a plurality of information sites on a network that may be accessed by a user via the network, the method comprising: retrieving information regarding a first set of information sites via the network, constructing the tree using the retrieved information, displaying the tree to a user, retrieving information regarding a second set of information sites via the network, modifying the tree based on the information regarding the second set of information sites, and displaying the modified tree to the user.

1 According to another aspect of the invention there is provided a computer comprising a memory for holding data defining work navigation tree and a program for generating data defining network navigation tree, and an execution unit for executing said program and generating said data, the tree being a graphical representation of a plurality of information sites on the network that may be accessed by the user via the network, wherein the execution unit executes a first component of the program which retrieves information regarding a first set of information sites via the network, constructs the tree using the retrieved information, holds the data defining the tree in said memory and initiates the display of the tree to the user, a second component of the program which retrieves information regarding a second set of information sites via the network, and a third component of the program which gets information regarding the second set of the information sites from the second component and transfers it to the first component for use in modifying a tree, wherein the computer is further operable to hold the data defining the modified tree in said memory and to generate a display of the modified tree to the user.

The present invention provides a network navigation tree which is dynamically extendible when accessing new nodes, even those located on remote servers. This is achieved by using three components for modifying the tree structure while navigating the network. The first component is a tree program that constructs and displays the tree according to a desired hierarchical format. The second component is a modification program that retfieves new tree data from a newly accessed site. Finally, the third component is a data transfer program that transfers the new node data from the modification program to the tree program. In the preferred embodiment, the tr-ee program runs within the context of a typical web browser, and displays the tree as a graphical, hierarchical arrangement of nodes depicted by icons. Preferably, the tree program and the modification program are both Java applets, and the data transfer program is a JavaScript program.

The use of a JavaScript program to communicate between the two Java applets allows the tree to be updated from the new server without violating Java security restrictions. These security restrictions prevent an unsigned Java applet from communicating with any server other than the one from which it originated, and prevent its communicating with any other Java applet. However, in the present invention, the modification applet and theL JavaScript program are both loaded from the new server, and the modification applet can therefore communicate with the new server to acquire the new tree data. The new tree data is then passed from the modification applet to the tree applet via the JavaScript program. The tree is therefore updated with data from a different server than that from which it originated.

The tree applet is interactive, and allows users to navigate the nodes of the tree by selecting the nodes in the graphical display using a graphical input device, such as a mouse. Selection of a node causes the web browser to load the data from the page identified by that node. The tree also uses a "child indication icon" which is a graphical indicator that a node has children. If the children are not currently displayed in the tree, the icon takes one form (such as a plus sign "+"), while if the children are currently displayed, the icon takes a different form (such as a minus sign "-"). The icon is also selectable by the user with a graphical input device, and results in either expansion of the tree to show the children (if they are not already shown), or collapse of the tree to hide the children (if they are already shown).

When the node with the tree applet (e.g. the "home" page) is accessed by the users browser, the HTML file for that page is loaded. It instructs the browser to divide the display into separate frames, including a frame for displaying the tree. The KTML code then loads two other pieces from HTML code from the server. One of these loads the tree applet into the tree frame, and the other loads whatever other material is to be presented by the browser. When the tree applet has been loaded, it is executed and retrieves the site map data from the server. This site map data is then used by the tree applet to create its tree data structure, which h then displays in the desired hierarchical graphical format.

If the tree is already in the browser, accessing another node that has additional tree data results in several actions. The HTML for the new page contains a modification applet, a JavaScript program and whatever display material is to be displayed by the browser for that page. The JavaScript program includes an instruction that causes it to wait until all other browser actions are complete before executing. Thus, the modification applet runs first, and loads the new she map data from the new server. When the JavaScript program runs, it transfers the site map data from the modification applet to the tree applet, which uses it to augment its existing tree data structure to include the new tree nodes. Thus, the user can use the modified tree to access any of the nodes included in the modified tree structure, including those of either server.

In an alternative embodiment, the tree applet includes a search and filter function that allows a user to input keyword terms. The tree applet then compares the input search terms to information fields (such as "topic" fields) maintained in its data structure for each node. Each of those nodes having a matching term is tagged by setting an associated flag. The tree may then be reoisplayed to show only the tagged nodes in a modified hierarchical arrangements. This allows the user to more quickly search through a large number of tree nodes.

For a better understanding of the present invention and to show how the same may be carried into effect, reference will now be made by way of example to the accompanying drawings in which:

FIG. 1 is a printed version of the screen display of a web browser showing-a prior art navigation tree.

FIG. 2 is a schematic view of a network connection via the Intemet between a local computer and several remote web servers.

FIG. 3 is a printed version of the screen display of a web browser showing a navigation tree according to the present invention.

FIG. 4 is a printed version of a screen display similar to that of FIG. 3 in which a user action has caused the modification of the displayed tree.

FIG. 5 is a schematic view of a number of related nodes on a network which implement a navigation tree according to the present invention.

FIG. 6 is a flowchart depicting an overview of the operation of a navigation tree applet of the present invention.

FIG. 7 is a flowchart depicting an overview of the operation of a tree modification applet of the present invention.

FIG. 8 is a flowchart depicting an overview of the operation of a JavaScript program of the present invention.

FIG. 2 is a schematic depiction of a local computer that has access to a number of remote servers 18, 20, 22 via a data network, in this case "the Internet" 16. The remote servers are identified in the figure with numerical designations (i.e. 1, 2,... M), and each has a unique address by which it may be accessed by the computer 14. When one of servers 18, 20, 22 is accessed by the computer 14, data from the server is transferred via the network 16 to the computer where it is executed or displayed according to the application running at the local computer, typically a "web browser".

To provide easy navigation from one web page to the next, the present invention provides the software code for creating a navigation tree in one portion of the browser display. This tree displays, in a hierarchical format, headings for a page (or "node7) that is initially accessed, and for each of a number of related pages. Headings that do not -B- provide an URL to a page, but which are used to organize some of the node headings, may also be displayed. Unlike prior art navigation trees, however, the tree of the present invention is updated when the user connects to a web page which is on a different server and which implements the necessary components of the invenfion. This continued updating allows the expansion of an existing tree to include both the initial web pages, and the new pages which the user has accessed, regardless of whether they may be located on another server.

An example of the tree structure displayed using the present invention is shown in FIG. 3, which shows the display on a computer screen when visiting a site that implements the present invention. In this figure, the browser used is "Internet Explorer", a product of the Microsoft Corporation, Redmond, WA. However, those skilled in the art will recognize that the invention may be used with any web browser capable of implementing Java applets and JavaScript programs.

"Java" and "JavaScript" are well-known programming languages that may be used to create programs that are downloaded into a web browser and executed to manipulate data being controlled by the browser. Particularly relevant to the preferred embodiment of the invention are Java "applets" and JavaScript programs. Java applets, are application programs in Java that may be loaded into the browser from a web page when the page is accessed by a user. The applet is then executed by the browser to perform the desired operations. While capable of Manipulating data in the browser, security limitations of the known versions of Java applicable to this 6mbodiment (i.e. versions 1.02, 1.1 and 1.2) prevent an unsigned Java applet from communicating with any server but the one from which it was downloaded. As will become apparent, this creates a barrier for providing manipulation of the navigation tree when moving from a page on a first server to another page on a different server.

JavaScript programs are programs in the JavaScript language that are interpreted (not compiled) by the browser. Rather than being distinct from HTML and accessed from HTML, JavaScript Programs are integrated with, and embedded in, HTML code. They are also incapable of reading or writing files when executed from a browser. However, JavaScript programs can communicate with most objects in the browser, and are therefore useful for doing manipulations of manipulating objects already in the browser. The JavaScript program of the preferred embodiment uses either of versions 1. 1 and 1.2 of the JavaScript language.

Referring again to FIG. 3, the Java and JavaScript programs of the present invention result in the browser arranging its display window as shown, with page content being displayed in region 30, and the navigation tree being displayed in region 32. As shown, the tree structure is similar in appearance to prior art trees or file menus, in that it uses descriptive titles to represent different pages (or "nodes") in the tree, and represents "child" nodes in an indented column under the parent node title. For example, in the tree of FIG. 3, the node 34 (entitled "MultiSwitch 900") is parent to the nodes identified by the indented column list beneath it, such as node 36, "PORTswitch9OOTP", and node 38, "VNswitch9OOEA". Notably, while node 34 is parent to other nodes, including nodes 36 and 38, it is also itself a child to node 40, "MultiSwitch Platforms", along with its "sibling" node 42, "MultiSwitch 600".

Shown in FIG. 4 is the display of FIG. 3 after a user has selected one of the child nodes under node 34 (typically, the selection is done using a "point-and-click" graphical input device such as a "mouse"). By pointing to and selecting node 38 from the display, the user causes a request from the web browser to be sent to the page represented by this node, and the data from that page to be loaded and displayed by the browser. This action also causes the tree to expand to show the child nodes under node 38. In this case, node 44 ('VNswitch 900EA Device...") is displayed as a result. The user then has the option to select node 44 as the destination node, as well as any of the other nodes displayed in the tree. The user may also expand other child nodes on the-tree to show additional destination nodes.

One of the features of the display is the use of a selectable icon in the form of a plus ("+") or minus ("-') sign to the left of th3se nodes that have children. A plus sign is displayed when the node adjacent to it has children which are currently not displayed in the tree. Selection of the plus sign with an input device causes the tree to be expanded at that point, such that it displays the children nodes of the adjacent node. When the children nodes are displayed in the tree, the plus sign symbol is changed to a minus sign symbol. Thereafter, the user may use an input device to select the minus sign, which then causes the tree to be collapsed at that point, such that the children of the adjacent node are no longer displayed. For example, node 42 in FIG. 4 has a plus sign adjacent to it, indicating that a selection of the plus sign will result in an expansion of the tree to display the children nodes beneath node 34. Node 34 also has children nodes, which are currently displayed in the tree. Thus, the symbol adjacent to it is a minus sign. If the user selects the minus sign, the tree will be collapsed to no longer display the children nodes, and the minus sign will be changed to a plus sign.

Whether the plus symbol is initially displayed adjacent to a child node when it is first itself displayed, depends on whether the children of that child node are part of the tree structure currently known to the navigation tree applet. If the node information known to the tree includes those children, the plus sign is displayed, indicating the presence of children nodes. However, if the children are not yet known to the tree applet, the plus sign is not displayed. For example, when the children nodes of node 34 are first shown inthe tree of FIG. 3, node 38 does not show a plus sign, because the information about the existence of the children has not yet been added to the tree. However, once the user selects node 38, the browser displays the data from that web page. In addition, "site map" data regarding the location of the children of node 38 is transferred to the browser, and used to update the data structure of the tree. Thus, an indicator sign (a minus sign in FIG. 4, since the child node of node 38 is being displayed) is then displayed adjacent to node 38. The child of node 38 (node 44) also -11 shows a plus sign adjacent to its position, thus indicating that it too has children. If the user has just e):panded the list of children under node 38 for the first time, then the she map data regarding the children of node 44 was passed to the tree applet when node 38 was selected.

The tree applet draws the entire tree structure in a known manner, providing the structural arrangement of nodes according to the site map data it receives, which it uses to build a datastructure for its use in generating the display. The individual icons that represent the nodes in the tree may.take any form that the user desires. However,in the preferred embodiment, the icons are drawn by the tree applet itself using known icon generation code, rather than being loaded from the server. This prevents unnecessary delays each time the tree is drawn.

When the user selects a node on the tree, the contents of that node (i.e. the web page HTML) are displayed in the display region 30. If the selected node resides on a server already accessed by the user, then the portion of the tree corresponding to the nodes on that server may already be included in the navigation tree that is displayed in region 32. However, if the selected node resides on a different server, one that has not yet been accessed by the user, the hierarchy of pages on the other server is typically not yet part of the displayed navigation tree. If the selected page has the necessary components of the invention, then a new tree section is added to the existing tree structure at that node to expand the scope of the navigation tree. That is, a new tree section, one showing the interconnection of nodes having connections from pages on the new server, is transferred from the selected node to the browser and used to further build the navigation tree. The manner in which this is accomplished is described more fully below.

Referring again to FIG. 2, the remote servers 18, 20, 22 shown in the figure each have pages that are configured to implement the invention. To do so, a number-of the pages residing with each of these servers must have a certain set of Java and JavaScript components such that, when a user accesses one of those pages, the navigation tree program is loaded and, when another page is accessed after the tree program is loaded, the tree is properly expanded. A collection of related web pages 24a-24p is depicted schematically in FIG. 5. The pages reside with different servers 18, 20, 22, as indicated by'dashed lines in the figure. Solid lines are used to depict hierarchical relationships between the pages of the tree. This arrangement of pages might, for example, represent a set of pages associated with a single World Wide Web host. In many cases, although it is not necessary to do so, such a host has a specific web page that serves as the "home" page, providing connection (directly or indirectly) to the other pages associated with that host. For example, the web page having the URL "hftp://www.dec.com/" is a home page for a group of pages forming a web "site" controlled by Digital Equipment Corporation. In the case of the arrangement of pages in FIG. 5, the home page is page 24a, which serves as the parent to all the other pages.

When a user goes (i.e. sends a request via a web browser) to home page 24a, a Java applet 50 is loaded into the user's web browser. Applet 50 is the program which directs the construction and display of the tree by the browser. The tree displayed by the applet 50, however, is dynamically modified when the user directs the browser to certain other web pages. Additional site map data may be stored at these other web pages, allowing the tree to be expanded by the addition of site map data regarding the selected node (and sometimes other nodes related to it) to the existing site map data used by the tree. This additional site map data is transferred to the tree applet 50 using a second Java applet (the "tree modification" applet) and a JavaScriPt program, both of which are located at the node that is supplying the new site map data. Thus, when the browser contacts the new node, the modification applet and the JavaScript program are loaded into the browser and executed.

i 1 FIG. 5 indicates not only how the web pages are arranged, but also how the different components of the invention may be distributed among them. For example, home page 24a provides the browser With the tree applet 50, site map data 52a, HTML file 54a, which includes instructions 53a to the browser for assembling the display window for that page, and HTML file 55a, which is responsible for loading tree applet 50 into the browser.

Accessing page 24a results in the loading of the HTML file associated with that page, which includes HTML code that divides the browser display area into two frames, one for the tree and one for displaying the data of HTML file 54a. HTML files 54a and 55a are then loaded into the browser by the HTML code of page 24a. HTML file 54a retrieves the display data 53a from the server and assembles it in the display frame. HTML file 55a contains the "tree" HTML code and, when executed by the browser, calls the tree applet 50, allowing it to be loaded and executed within the browser. The tree applet retrieves the site map data 52a from the server and constructs the navigation tree.

When the user instructs the browser to proceed to page 24b, the existing tree may be updated to also contain the children nodes of page 24b. Asindicated by the figure, page 24b has a tree relationship to each of pages 24g and 24h, which are considered "child" nodes of node 24b for the purposes of this hierarchical structure. Thus, to update the tree, node 24b must provide a modification applet 59b, a JavaScript program 61 b and a new set of site map data 52b. The modification applet 59b and the JavaScript program 61b are both located in HTML file 54b along with the display instructions 53b associated with the usual display for that page. In FIG. 5, modification applet 59b (identifiedukb"), JavaScript program 61b (identified "JS,,') and display data 53b (identified Db) are all shown as being within HTML file 54b.

The HTML file 54b is loaded into the web browser in response to the initiated request. The site map data 52b remains on the server, but is later loaded by the modification applet. Once loaded, the modification applet 59b and the JavaScript progrLm 61 b combine to provide the new site map data 52b to the tree applet 50 already running in the browser. This allows the tree to then display the children nodes of node 24b, i.e. nodes 24g and 24h.

As shown in FIG., 5, neither of pages 24g or 24h provides anything but the conventional HTML file (i.e. HTML file 54g or 54h containing display data 53g or 54h, respectively) for the browser display. This is because these pages are "dead end" pages, that is, they do not provide any additional structure to the tree. As such, neither of these pages has any children nodes, and therefore would have no need to update the navigation tree. Other dead end pages (24c, 24e, 24j, 24m, 24n, 24o, 24p) likewise do not incorporate any of the components of the invention, since there is no additional site map data to be acquired from these nodes. Page 24i, while having children nodes, also does not supply any site map data. Notably, it is not necessary to construct the invention such that every node with child nodes supplies new site map data. In this case, the site map information regarding the children nodes of node 24i may be supplied by page 24d, which can include this information within its own she map data 52d.

As apparent from the embodiment shown in FIG. 5, the manner in which site map data is distributed throughout the pages implementing the navigation tree is largely a matter of user preference. One of the places where such a distribution becomes a concern is in the use of multiple servers. Any unsigned Java applet has the restriction that it can communicate only with the server from which it originated, and can not communicate with other applets. This makes it impossible to do dynamic building of the navigation tree with a single applet, if the tree spans more than one server. As shown in FIG. 5, home page 24a is located on server 18, while some of the nodes to be included in the tree are located on server 20, and still others are located on seroer 22. However, despite this distribution of nodes of the tree on different servers, the present invention allows the tree to nonetheless be dynamically updated. This is accomplished by using the tree modification applet to retrieve the site map data from the new server, and by using the JavaScript as a communication conduit between the tree applet and the modification applet, as is described more fully below.

For each of FIGS. 6-9, the flowchart displayed provides a visual overview of the functions performed by one of the software components of the invention. These flowcharts do not represent machine-level operationjs, but only a graphical representation of the tasks performed by the invention. This higher level depiction allows the invention to be readily understood, while providing all the detail necessary for one skilled in the art to practice the invention.

Referring to FIG. 6, once the tree applet 50 is loaded into the browser and executed (as is well-known in the art), the applet contacts the server from which it was loaded, and requests transfer of the site map data for use in constructing the initial portion of the tree (step 602). The server then sends the site map data. In the preferred embodiment, the server has means for determining the type of user With, for example, password information or the IP address from which the browser request is sent. In such a case, the site map data sent to the requesting browser may be customized for that user. In this way, secure site links can be withheld form unauthorized users, or tree arrangements can be used to facilitate the user's navigation based on some assumption regarding the user's profile.

Once the site map data is received, the applet 50 uses it to construct the tree (step 604). Java language programs for constructing trees with imported data are known in the art, and each of the different formats available is considered to be within the scope of this invention. The applet then displays the tree in the desired format (step 606). The tree is displayed in its own separate frame of the browser display. The arrangement of browser displays is well-known in the art, and is therefore not discussed herein in any detail.

Once the tree has been loaded and displayed, that portion of the display remains static untl one of several actions takes place. The response of the applet to each of these actions is depicted in FIG. 6 as a loop through a set of conditions. However, those skilled in the art Will recognize that this is for descriptive purposes, and that the software need not function in this manner. In step 608, the applet responds to a user input indicating selection of the one of the displayed icons representing the nodes of the tree. Since graphical user interface (GUI) inputs in that region of the display containing the tree are under the control of the tree applet, it controls the manner of response to a selection by a user in that area (e.g. region 32 in FIGS. 3 and 4). If the user selects an area of the display in which a representation of one of the nodes resides, the applet 50 initiates a browser request to load the web page having the URL associated with the selected node (step 610). The contents of the new web page are then loaded by the browser into the window allocated for the display of web page data (e.g. display region 30 of FIGS. 3 and 4).

If, in step 612, a user selects one of the "tree expansion" or Iree collapse" icons in the tree display (for example, the "+" or'-" in FIGS. 3 and 4), the applet modifies the display of the tree accordingly (step 614). If the icon is an expansion icon (e.g. "+"), the display is modified to show beneath the node adjacent to the icon the hidden branch representing the child nodes. If the icon is a collapse icon (e.g. "-"), the display is modified to no longer display the children nodes beneath the node adjacent to the icon.

If the applet receives additional site map data (step 616) from the JavaScript associated with the present invention, it updates the tree structure and (correspondingly) the display of the tree (step 618). (While shown as a separate action by the tree applet, those skilled in the art will recognize that steps 616 and 618 might as easily be accomplished by giving the JavaScript program access to the data structure of the tree applet.) As indicated above, operation of a tree modification applet and a JavaScript program does not occur until a user selects a node at which additional site map data is present. When the user initiates a browser request to such a node, an HTML file is processed which contains the tree modification applet and JavaScript program for that node. The HTML code causes both the modification applet and the JavaScript program to be loaded into the browser. Using known software controls (e.g. the "onLoado" event handier in JavaScript), the JavaScript program is not called until after the site map is loaded by the tree modification applet. At this point, the JavaScript program can safely begin the data transfer.

As shown in FIG. 7, the modification applet first contacts the server on which the accessed page is located, and retrieves the new site map data (step 702). The modification applet is then dormant until being contacted. In the context of the preferred embodiment, it "waits" for the JavaScript request (step 703). The modification applet later responds to a query from the JavaScript program and transfers the site map information (step 704).

FIG. 8 gives an overview of the function of the JavaScript program. The JavaScript program is called by the browser after the modification applet obtains the site map data. The JavaScript program then sends a request to the tree modification applet for the site map data (step 802). Once the JavaScript program has received the site map data,.it then initiates communication with the tree applet, and transfers to it the new site map data (step 804). The tree applet then proceeds to update its existing tree structure as mentioned above. Thus, the tree is dynamically updated, even from a new server, without violating Java security restrictions.

The implementation of the present invention lends itself to several different embodiments that incorporate different features into the tree. One of these is the use of a search and filter function. If many nodes are present on several different serv6r-s, the size of the tree can grow very rapidly, and might become unwieldy to navigate by a user. However, in the preferred embodiment, the data structure for the tree contains some information about each of the pages, including a field for each page containing the topic of the page. While this information is not displayed to the user, it may be used to do a keyword search of the site map file, identify the pages which have text in their topic field matching any (or all) of the keywords, and draw a modified tree that includes only those pages which were identified in the search.

Search and filter programs are well known in the art, and the specifics of the identifying and matching of data will not be repeated here. The general method of searching and filtering implemented with the present embodiment is shown in FIG. 9. The function is initiated by the user with a known input means such as selection of an icon in the tree frame using a graphical input device, and keyboard input of the desired search terms into a generated dialog box. Upon input of the desired search terms, the search and filter routine compares the input search terms with the topic fields of the node data in the existing tree data structure (step 902). Those nodes which have matching terms in their topic fields are then tagged, typically by setting a flag for each of those nodes in the data structure (step 904). The tree applet then redraws the tree, displaying only those nodes that have been tagged, such that the user has a new tree display showing only the matching nodes in a hierarchical tree structure. This allows the user to quickly and easily navigate only those nodes which are identified in the searching function. Furthermore, the user may be given the ability to control whether the tree applet recognizes or ignores the data structure tags. Thus, the display of the tree is easily toggled between the full tree or the filtered tree. Naturally, the use of multiple flags for each of the nodes in the data structure allows a user to perform multiple searches and toggle between any of the resulting filtered formats.

The search and function method of the present embodiment may be implemented in a number of different ways, each of which are considered to be Within the scope of the invention'. In the preferred version of this embodiment, the function is part of the tree applet itself, and the method shown in FIG. 9 would therefore be part of the applet code of FIG. 6. However, those skilled in the art will recognize that the search and filter function could also be a separate software object which communicates With the tree applet only when necessary.

While the invention has been shown and described with reference to a preferred embodiment thereof, it will be recognized by those skilled in te art that various changes in form and detail may be made herein without departing from the spirit and scope of the invention as defined by the appended claims. For example, the invention has been described herein with regard to a first home page at which the tree applet is loaded, and a number of other pages lower in a related hierarchy. However, those skilled in the art will recognize that.the tree applet may be loaded at any of the given pages, thus making sure the tree is supplied if a user goes to that page first. Futhermore, nodes not considered in an original hierarchy may still be appended to the tree in some predetermined manner to allow unpredicted expansion (and possible restructuring) of the tree.

Claims

1. A computer program product for generating a network navigation tree and displaying it to a user, the tree being a graphical representation of a plurality of information sites-on the network that may be accessed by the user via the network, the computer program product comprising: a first program product component that retrieves information regarding a first set of said information sites via the network, constructs the tree using the retrieved information, and initiates a display of the tree to the user; a second program product component that retrieves information regarding a second set of said information sites via the network; and a third program product component that gets the information regarding the second set of said information sites from the second program component and transfers it to the first program component for use in modifying the tree.

2. A computer program product according to Claim 1 wherein the first, second and third program product components are executed within the context of a network navigation program.

A computer program product according to Claim 2 wherein the network navigation program is a web browser.

A computer program product according to Claim 1 wherein the first program product component comprises a first Java applet.

A computer program product according to Claim 4 wherein the second program product component comprises a second Java applet.

6. A computer program product according to Claim 5 wherein the third program product component comprises a JavaScript program.

7. A computer program product according to Claim 1 wherein the first program product component displays the tree as part of a graphical user interface which allows a user to select different regions of the tree with a graphical input device.

8. A computer program product according to Claim 7 wherein one of said selectable tree regions is an icon representing one of said sites which, when selected, results in the browser loading data present at that site.

9. A method of generating a network navigation tree, the tree being a graphical representation of a plurality of information sites on a network that may be accessed by a user via the network, the method comprising: retrieving information regarding a first set of information sites via the network, constructing the tree using the retrieved information, displaying the tree to a user, retrieving information regarding a second set of information sites via the network, modifying the tree based on the information regarding the second set of information sites, and displaying the modified tree to the user.

10. A computer comprising a memory for holding data defining a work navigation tree and a program for generating data defining a network navigation tree, and an execution unit for executing said program and generating said data, the tree being a graphical representation of a plurality of information sites on the network that may be accessed by the user via the network, wherein the execution unit executes a.first component of the program which retrieves information regarding a first set of information sites via the network, constructs the tree using the retrieved information, holds the data defining the tree in said memory and initiates the display of the tree to the user, a second component of the program which retrieves information regarding a second set of information sites via the network, and a third component of the program which gets information regarding the second set of the information sites from the second component and transfers it to the first component for use in modifying a tree, wherein the computer is further operable to hold the data defining the modified tree in said memory and to generate a display of the modified tree to the user.

11. A computer program product substantially as hereinbefore described with reference to the accompanying drawings.

A method of generating a network navigation tree substantially as hereinbefore described with reference to the accompanying drawings.

-23