The menu at left appears and acts very much like the Explorer menu on Windows machines. Clicking
on an item loads an associated link. Clicking on a folder will also toggle it open or close it,
revealing or hiding a submenu. To close all the folders, you can click on the root at top.
Feb. 18, 1999 - Improved response time and added options to change menu colors and graphics directory.
If you have a previous version you can use this one by downloading the new versions of treeMenu.html and treeMenuCode.js. Then update your version of myMenu.js by adding values for the new page colors and the image directory variables.
Using Tree Menu
This section describes how to set up and create your own tree menu.
The main file defines the frameset and contains all the code. Below is a list of all the files used and their purpose:
Setting Up the Menu
To create your menu, you need to build your own version of myMenu.js. Before you start defining the menu itself, you need to set some global variables:
Note that all the above variable should be defined and set with a value. Leaving any out will cause the menu to fail.
Defining the Menu
First, define the top-level menu using the treeMenu global variable:
var treeMenu = new TreeMenu();
Now create some items for it by defining some TreeMenuItem() objects. You specify one to four arguments for an item. The first is the text used in the menu display. The rest apply to the link for the item. They are:
Then you use the addItem method to attach an item to a menu. Here is the code to define and add the main menu items:
Note that the items will be displayed in the order they are added. The first three items here will be submenus, so only the text is given. For links you can leave off the icon value if you wish to use the default images.
We can then reference each item in this menu using the .items array, where treeMenu.items is 'Dynamic HTML', treeMenu.items is 'Java Applets', etc.
Defining and Attaching Submenus
We create submenus just like the main menu, using new variables. Here we'll create the 'Dynamic HTML' submenu:
var dhtml = new TreeMenu(); dhtml.addItem(new TreeMenuItem("References")); dhtml.addItem(new TreeMenuItem("Asteroids", "../dhtml/asteroids/index.html", "blank")); dhtml.addItem(new TreeMenuItem("Cross-Browser DHTML Library", "../dhtml/cbdhtml.html", "blank")); dhtml.addItem(new TreeMenuItem("Dynamic HTML", "../dhtml.html", "main"));
Now, to attach this submenu to the main menu, we first reference the main menu item we want to attach it to and use .makeSubmenu() passing the submenu variable as the argument:
var java = new TreeMenu(); java.addItem(...); java.addItem(...); ... treeMenu.items.makeSubmenu(java); // Attach to second item of main menu. var js = new TreeMenu(); js.addItem(...); js.addItem(...); ... treeMenu.items.makeSubmenu(js); // Attach to third item of main menu.
Now, to go a level deeper, we want to make submenus for 'References' and 'Sites' in the 'Dynamic HTML'submenu. So we create a new menus called dhtml_refs and dhtml_sites and attach them by referencing the first item and second items of dhtml:
var dhtml_refs = new TreeMenu(); dhtml_refs.addItem(new TreeMenuItem(...)); dhtml_refs.addItem(new TreeMenuItem(...)); ... dhtml.items.makeSubmenu(dhtml_refs); // Attach to first item of dhtml menu. var dhtml_sites = new TreeMenu(); dhtml_sites.addItem(new TreeMenuItem(...)); dhtml_sites.addItem(new TreeMenuItem(...)); ... dhtml.items.makeSubmenu(dhtml_sites); // Attach to second item of dhtml menu.
var js_ex = new TreeMenu(); js_ex.addItem(...); js_ex.addItem(...); ... js.items.makeSubmenu(js_ex); // Attach to first item of js menu. var js_refs = new TreeMenu(); js_refs.addItem(...); js_refs.addItem(...); ... js.items.makeSubmenu(js_refs); // Attach to second item of js menu. var js_sites = new TreeMenu(); js_sites.addItem(...); js_sites.addItem(...); ... js.items.makeSubmenu(js_sites); // Attach to third item of js menu.
For your own menus, you can define as many items as you want in each menu and nest menus as deep as you want.
Customizing Colors and Icons
To change the menu colors, edit the treeMenu.html file to change the background and link colors in the <body> tag. To change the colors used to highlight the selected item, edit the definition of the all.selected style.
You can also change the graphics and icons used for each of the menu parts, see the list of images at the bottom of the page.
The TreeMenu and TreeMenuItem Objects
These are the the key to setting up and displaying the menu. The TreeMenu object consists simply of an array to store the items and a method to add them.
The TreeMenuItem object contains variables to store the item's display text, icon image source (if specified) and data for it's associated link (if any). It also has a flag to indicate if it is itself a menu and a variable that points to the TreeMenu object to be used. The makeSubmenu() method is what set's these values. It also has an index variable which relates it to the proper value in the menu state cookie (see below) so we can track which folder items are open and which are closed.
Using these, the menu is built when the top-level page is first loaded, creating a hierarchial structure in the global treeMenu variable.
Menu State Data
One cookie is used to track which folders in the menu are open and which are closed. Every item has a boolean value associated with it in this cookie. The values are read in just before the menu is drawn and the values are updated every time the user clicks on an item.
A separate cookie is used to keep track of which item was last clicked, allowing it to be highlighted when drawn. It is also used to determine how far the window needs to be scrolled if that item falls outside of the menu frame's viewable region.
Note that if you update your menu, you should also change the value of treeMenuName so new cookies will be created from scratch.
Drawing the Menu
The file treeMenu.html uses the onLoad event in the <BODY> tag to call the treeMenuDisplay() function located in the parent file. This function rewrites HTML code of the menu frame to build the menu display based on the current menu state. This new HTML also includes an onLoad call but this time it runs the treeMenuScroll() function to scroll the page so that the selected item will be in view.
treeMenuDisplay() works as follows. First, it fetches the cookie data so we will know which folders are to be open and which item was selected last. Then some global variables are set to track where we are in the menu hierarchy and help with the graphics placement.
Then the menu frame document is cleared using the document.open() method. This allows it to completely rewrite the HTML code of the frame. It generates the proper HTML tags to define style sheets and set the page colors. It also adds a call to treeMenuScroll() in the onLoad event of the body tag so the page will scroll to put the currently selected item in view, if necessary.
Then, we start the display with a <table> tag. The first row just contains the root icon and text. Each following row will contain a menu item.
Here, the recursive nature of the tree menu objects is what makes the display drawing work. We make a call to treeMenuListItems() passing it the top level menu (the treeMenu variable). When it returns, all the items will have been drawn and we just finish with the closing </table> tag.
treeMenuListItems() is very simple, it just takes the given menu and loops thru each item making a call to treeMenuDisplayItem() to write it out. It also passes a flag to indicate whether the item being passed is the last one in the menu or not.
treeMenuDisplayItem() is the workhorse. It writes out the proper images and text for the given item as a table row. Some global variables are used to track how far to indent the item and what images are needed to create the tree layout. Then, based on the properties of the menu item, it displays the proper icon (folder, file icon, custom icon, etc.) and it's text.
If an item happens to be a submenu it checks the cookie data to determine if it should be expanded or not. If so, it makes a recursive call to treeMenuListItems() passing it the item's submenu.
In this function, we also update the global scrolling values if the given item is the selected one.
Once the menu is finally drawn, some closing tags are output and the menu frame will now reflect the proper menu view.
Making the Menu Interactive
Each item is written as a hypertext link with a call to treeMenuClick() that will cause a redisplay of the menu if the item is clicked. The function is passed the items's index value, so we can update the cookie data and a couple of boolean flags letting it know if the item links to another page and if it is a folder.
The function updates the cookie values, toggling the folder open or closed if it's a submenu and marking the item as the selected one. It then makes a call to treeMenuDisplay() which results in an updated display of the menu.
For the menu root, we call treeMenuRootClick() instead which simply deletes the cookies and redraws the menu frame. This causes it to start with all folders closed and no item selected.
The source for each file can be viewed using these links:
The images for the menu tree are shown below:
You can also download treeMenu.zip which contains all the above files.