// **********************************************************
// **
// ** RESIZE BACKGROUND FONCTION
// **
// **********************************************************
NS4 = (document.layers);
IE4 = (document.all);
scaleWidth = true;
scaleHeight = true;
imSRC800 ="images/background800.jpg";
imSRC1024 = "images/background1024.jpg";
imSRC1280 = "images/background1280.jpg";
if (NS4) window.onload = setResize;
function setResize(){
setTimeout("window.onresize=reDo;",500);
}
function reDo(){
window.location.reload()
}
if (IE4) window.onresize = reDoIE;
function reDoIE(){
imBG.width = document.body.clientWidth;
imBG.height = document.body.clientHeight;
}
function makeIm() {
winWid = (NS4) ? innerWidth : document.body.clientWidth;
winHgt = (NS4) ? innerHeight : document.body.clientHeight;
if (document.body.clientWidth <= 1280) imSRC = imSRC1280;
if (document.body.clientWidth <= 1024) imSRC = imSRC1024;
if (document.body.clientWidth <= 800) imSRC = imSRC800;
imStr = ""
+ "
"
// + "
 imStr += )
' + popInd + '
';
}
// For NS4, if a border is assigned, add a spacer to push border out to layer edges.
// Add a link both to generate an onClick event and to stop the ugly I-beam text cursor appearing.
if (isNS4) itemStr += (outBorder ? '' : '') +
'' + text + '';
// IE4+/NS6 is an awful lot easier to work with sometimes.
else itemStr += '' +
text + '
';
}
return itemStr;
}}
// The main menu creation/update routine. The first parameter is 'true' if you want the script
// to use document.write() to create the menus. Second parameter is optionally the name of one
// menu only to update rather then create all menus.
function popUpdate(docWrite, upMN) { with (this)
{
// 'isDyn' (set at the very top of the script) signifies a DHTML-capable browser.
if (!isDyn) return;
// Loop through menus, using properties of menu description object (array index 0)...
for (mN in menu) with (menu[mN][0])
{
// If we're updating one specific menu, only run the code for that.
if (upMN && (upMN != mN)) continue;
// Variable for holding HTML for items.
var str = '';
// Remember, items start from 1 in the array (0 is menu object itself, above).
// Also use properties of each item nested in the other with() for construction.
for (var iN = 1; iN < menu[mN].length; iN++) with (menu[mN][iN])
{
// An ID for divs/layers contained within the menu.
var itemID = myName + '_' + mN + '_' + iN;
// Now is a good time to assign another menu's parent to this if we've got a popout item.
var targM = menu[href];
if (targM && (type == 'sm:'))
{
targM[0].parentMenu = mN;
targM[0].parentItem = iN;
}
// Have we been given a background image? It'll have a period in its name if so...
var isImg = (outCol.indexOf('.') != -1) ? true : false;
// NS6 uses a different cursor name for the 'hand' cursor than IE.
if (!isIE && normCursor=='hand') normCursor = 'pointer';
// Create a div or layer text string with appropriate styles/properties.
// OK, OK, I know this is a little obtuse in syntax, but it's small...
// At the end we set the alpha transparency (if specified) and the mouse cursor.
if (isDOM || isIE4)
{
str += '' +
getHTML(mN, iN, false) + (isNS4 ? '' : '
');
// End loop through items and with(menu[mN][iN]).
}
// The parent frame for this menu, if any.
var eP = eval(par);
// Do not ask me why Opera makes me set a timeout now rather than later, or in fact have
// to set a timeout at all to get references to the divs we are about to create.
// But, it makes the cross-frame version of the script actually work, so there's a benefit.
setTimeout(myName + '.setupRef(' + docWrite + ', "' + mN + '")', 50);
// Initial menu visibility, hidden unless tweaked otherwise.
var mVis = visNow ? 'visible' : 'hidden';
// For Fast creation mode (default for IE, NS6, Opera), write the menus to the document now.
// I'm adding a bit to the widths for safety as borders are different across browsers.
if (docWrite)
{
// Find the right target frame.
var targFr = (eP && eP.navigator ? eP : window);
targFr.document.write('' + str + extraHTML + '
');
}
else
{
// Create a new layer/div object dynamically using my setLyr() function above.
// If we've got a layer created already, there's no use creating another!.
// In IE4, we must shrink the menus to stop them sizing to the full body size -- thanks
// to Jeff Blum and Paul Maden for debugging this for me :). If the layer has been created,
// we've got to set a timeout to fix up IE4 again for some obscure reason.
if (!lyr || !lyr.ref) lyr = setLyr(mVis, menuW, eP);
else if (isIE4) setTimeout(myName + '.menu.' + mN + '[0].lyr.sty.width=' + (menuW+2), 50);
// Give it a high Z-index, and write its content.
with (lyr) { sty.zIndex = 1000; write(str + extraHTML) }
}
// End loop through menus and with (menu[mN][0]).
}
}}
function popSetupRef(docWrite, mN) { with (this) with (menu[mN][0])
{
// Get a reference to a div, only needed for Fast creation mode.
if (docWrite || !lyr || !lyr.ref) lyr = getLyr(myName + '_' + mN + '_Div', eval(par));
// Loop through menu items again to set up individual references.
for (var i = 1; i < menu[mN].length; i++)
menu[mN][i].lyr = getLyr(myName + '_' + mN + '_' + i, (isNS4?lyr.ref:eval(par)));
// Call the 'oncreate' method of this menu if it exists (e.g. to show root menu).
if (menu[mN][0].oncreate) oncreate();
}}
// *** POPUP MENU MAIN OBJECT CONSTRUCTOR ***
function PopupMenu(myName)
{
// These are the properties of any PopupMenu objects you create.
this.myName = myName;
// Manage what gets lit and shown when.
this.showTimer = 0;
this.hideTimer = 0;
this.showDelay = 0;
this.hideDelay = 500;
this.showMenu = '';
// 'menu': the main data store, contains subarrays for each menu e.g. pMenu.menu['root'][];
this.menu = new Array();
// litNow and litOld arrays control what items get lit in the hierarchy.
this.litNow = new Array();
this.litOld = new Array();
// The item the mouse is currently over. Used by click processor to help NS4.
this.overM = 'root';
this.overI = 0;
// The active menu, to which addItem() will assign its results.
this.actMenu = null;
// Functions to create and manage the menu.
this.over = popOver;
this.out = popOut;
this.changeCol = popChangeCol;
this.position = popPosition;
this.click = popClick;
this.startMenu = popStartMenu;
this.addItem = popAddItem;
this.getHTML = popGetHTML;
this.update = popUpdate;
this.setupRef = popSetupRef;
// Default show and hide functions, overridden in the example script by the clipping routine.
this.showMenu = new Function('mName', 'this.menu[mName][0].lyr.vis("visible")');
this.hideMenu = new Function('mName', 'this.menu[mName][0].lyr.vis("hidden")');
}
// ******************************************************
// ** SCROLLER OBJECT SETUP -- START EDITING HERE,
// ** keep reading until bottom of file
// **
// ******************************************************
// First, you have to create one or more scroller objects, syntax:
// var name = new DHTMLScroller('name');
var mainDiv = new DHTMLScroller('mainDiv');
// Then, working with its properties, we tell it the names of the relevant divs below we want it
// to use. This is accomplished by the 'divs' array, to which we add new items like so:
//
// divs[number] = new ScrDiv('id of div below', 'x', 'y', 'width', 'height', 'parent');
//
// As you can see, the second through to fourth parameters are the positions and dimensions of the
// divs, declared here rather than as properties to the divs below. They are strings containing
// either plain numbers, or formulae using global variables or functions to calculate
// special positions, e.g. centring or sizing with the window. Pass an empty string '' to tell
// the script not to set that particular parameter.
// The 'parent' parameter is optional. Use it if you're nesting the scroller divs within other
// divs, by passing a string that when evaluated, returns a reference to the parent layer of the
// div, e.g. 'getRef("containerDiv")', which is similar to 'document.all.containerDiv'. If you're
// just editing this template script, don't bother about it.
// The first three divs are special -- divs[0] is the scroller area itself into which files are
// loaded, divs[1] = the scrollbar background area itself, and divs[2] = the scrollbar thumb (the
// draggable bit). Anything after that is positioned and sized by the scroller engine on window
// resize but does not have any special properties.
with (mainDiv)
{
// This example uses my page object, included with this script. It provides two functions,
// page.winW() and page.winH(), which return the current width and height of the window.
// These positioning functions are useful, as although you can't create a scroller within a table
// cell, you can set it to hover over the cell -- be inventive with the formulae you use!
// This scrolls a div with an ID 'mainDivContent', which is positioned at (x=50, y=50) and is
// most of the window wide and high. If you want to centre the div, try something like:
// divs[0] = new ScrDiv('mainDivContent', 'page.winW()/2 - 300', 'page.winH()/2 - 200', '600', '400');
divs[0] = new ScrDiv('mainDivContent', 'page.winW()/5', 'page.winH()/3.5', 'page.winW()-(page.winW()/5)-30', 'page.winH()-(page.winH()/3.5)');
// Our scrollbar itself is positioned towards the right edge of the window and takes up most
// of the page height.
divs[1] = new ScrDiv('mainDivBar', 'page.winW() - 20', 'page.winH()/3.5', '15', 'page.winH()-(page.winH()/3.5)');
// Don't pass Y or Height thumb settings, these are set automatically when it's dragged.
divs[2] = new ScrDiv('mainDivThumb', 'page.winW() - 19', '', '13', '');
// These are the up and down arrow divs, positioned on resize accordingly...
divs[3] = new ScrDiv('mainDivUpArrows', 'page.winW() - 95', '50', '', '');
divs[4] = new ScrDiv('mainDivDownArrows', 'page.winW() - 95', 'page.winH() - 85', '', '');
// Add divs[5] onwards the same way, to position/show any other DIVs on load and resize.
// Once you've done that, here's some of extra settings to further customise the script.
// Uncomment them and tweak the numbers to see if any are useful.
//
// You can set scroller padding at the top and bottom of loaded files like this:
//padTop = 100;
//padBot = 50;
// If your web host sticks banner ads at the top of every page you load, you could always
// declare 'padTop' to be slightly negative... don't say you heard it from me... :)
//
// Perhaps try this... set to a decimal between 0 and 1 for 'sticky' scrolling mode.
// You might was to set small values on the padding values above if you do this.
//stick = 0.25;
//
// Another useful optional property is minimum thumb height. The default is:
//minThmHeight = 20;
//
// The page object mentioned above can have minimum sizes set. By default, the winW() and winH()
// functions just return the window area, but you can set minima like so:
page.minW = 400;
page.minH = 300;
// I highly recommend doing this otherwise interesting crashes can result when the window sizes
// too small and objects start to overlap and get negative heights etc.
// Next we can assign scroller events. They are 'onbeforeload', 'onload', 'onscroll', 'onsetup',
// 'onlayout', 'onthumbdown' and 'onthumbup'. The load events fire whenever a file is loaded into
// the scroller, and the thumb events whenever you start or stop dragging the thumb. The scroll
// event fires when you scroll or drag, the setup event fires when the scroller is initialised
// but hasn't loaded its first file, and the layout event fires whenever the layout function is
// called (on load and resize). By default, the only one you need is a function to show the
// scroller once it's finished loading a file, and hide the 'loading' message:
onload = loadFunction;
// I've also set the onlayout event to hide and show the scrollbar thumb as needed.
onlayout = thumbVis;
}
// Here's the example onload function, which gets called every time the scroller loads a file
// and shows/hides the appropriate divs. Note it is a property of the scroller and hence we use
// 'with (this)' to get at its other properties. You can just leave this alone, or you can dig
// into the source code and make other functions to show/hide loading messages, light up the
// scroller thumb as it is being dragged, use the onload to build a browsable history etc...
function loadFunction() { with (this)
{
// Hide loading message...
getSty('loadMessage').visibility = 'hidden';
// And show the rest of the divs apart from the scrollbar thumb (which is divs[2]).
// You could modify this function to do the reverse on the 'onbeforeload' event perhaps...?
for (var i = 0; i < divs.length; i++) if (i != 2) divs[i].lyr.vis('visible');
// Now call the layout function (thumbVis) below to show/hide thumb depending on content size.
onlayout();
}}
function thumbVis() { with (this)
{
// Only show the thumb when the actual content height exceeds the clipping area.
// If you want to, hide divs[3] onwards to hide the scrollbar and arrows as well.
divs[1].lyr.vis(div.h() > cHeight ? 'visible' : 'hidden');
divs[2].lyr.vis(div.h() > cHeight ? 'visible' : 'hidden');
divs[3].lyr.vis(div.h() > cHeight ? 'visible' : 'hidden');
}}
// Capture events -- make sure you combine this with any other scripts which also capture these
// events e.g. Popup Menus. You call the .setup() function onload with the name of a default file,
// in this case its readme, but you'll probably want something like "home.html". Alternatively,
// you can pass a blank string "" to scroll the content already in the div, but you must manually
// specify a width on the div below via style="width: xyz" for Netscape 4.
// Note we also call a small 'bug check' function to stop Netscape 4 dying when you resize the
// window. Use this one in preference to the one in my Popup Menu script if you're combining them.
// window.onevent=function(){....} is essentially the same as
// Make sure you don't assign events either way later in your page, otherwise these get overridden.
window.onload = function()
{
mainDiv.setup('bienvenue.htm');
pMenu.update();
//anotherMenu.update();
}
var nsWinW = window.innerWidth, nsWinH = window.innerHeight, popOldOR = window.onresize;
window.onresize = function()
{
ns4BugCheck();
mainDiv.layout();
if (popOldOR) popOldOR();
if (isNS4 && (nsWinW!=innerWidth || nsWinH!=innerHeight)) history.go(0);
pMenu.position();
//anotherMenu.position();
}
window.onscroll = function()
{
pMenu.position();
//anotherMenu.position();
}
// Capture mouse movement for dragging. Combine this with other scripts if needed!
// Make sure to capture and route these events for NS4 as we should.
if (isNS4) document.captureEvents(Event.MOUSEMOVE | Event.MOUSEUP);
if (isNS4)
{
document.captureEvents(Event.CLICK);
document.onclick = function(evt)
{
with (pMenu) if (overI) click(overM, overI);
//with (anotherMenu) if (overI) click(overM, overI);
return document.routeEvent(evt);
}
}
document.onmousemove = function(evt)
{
var ret = scrThumbMove(evt);
return (ret ? (isNS4?document.routeEvent(evt):true) : false);
}
document.onmouseup = function(evt)
{
scrThumbUp(evt);
if (isNS4) return document.routeEvent(evt);
}
// Activate the window.onscroll() event in non-Microsoft browsers.
if (!isIE || isOp)
{
var nsPX=pageXOffset, nsPY=pageYOffset;
setInterval('if (nsPX!=pageXOffset || nsPY!=pageYOffset) ' +
'{ nsPX=pageXOffset; nsPY=pageYOffset; window.onscroll() }', 50);
}
// Check for NS4 resize, reload if that's the case and pass current loaded file as query.
var nsWinW = window.innerWidth, nsWinH = window.innerHeight;
function ns4BugCheck()
{
if (isNS4 && (nsWinW!=innerWidth || nsWinH!=innerHeight))
{
// NS4 cannot handle resizes, so reload -- but use URL query mechanism to keep the loaded file.
var fileName = location.href;
// Trim existing URL query string out of the current location, if any.
if (fileName.indexOf('?') != -1) fileName = fileName.substring(0, fileName.indexOf('?'));
// If you've got multiple scrollers, add the URLs of each and separate with '&' signs.
location.href = fileName + '?mainDiv=' + mainDiv.loadedFile;
}
}
// *** SCROLLING BY KEYPRESS HANDLER - delete this if you want ***
// You must 'hardcode' a scroller name here, as only one can respond to keys.
function scrKeyDown(evt) { with (mainDiv)
{
if (!loaded) return;
// Find the correct event object and property.
var evt = evt?evt:window.event;
var key = evt.keyCode?evt.keyCode:(evt.charCode?evt.charCode:evt.which);
//alert(key);
// Depending on key press (capital || lowercase || function key), scroll div.
// Uncomment the above 'alert(key)' line to figure out your own keycodes.
if (key==84 || key==116 || key==36) scrollTo(0); // 'T', 't' or 'Home'
if (key==83 || key==115 || key==33) scrollBy(0-cHeight); // 'S', 's' or 'PgUp'
if (key==65 || key==97 || key==38) scrollBy(-10); // 'A', 'a' or 'Up'
if (key==90 || key==122 || key==40) scrollBy(10); // 'Z', 'z' or 'Down'
if (key==88 || key==120 || key==34) scrollBy(cHeight); // 'X', 'x' or 'PgDn'
if (key==66 || key==98 || key==35) scrollTo(divHeight); // 'B', 'b' or 'End'
}}
// Capture key presses.
if (isIE) document.onkeydown = scrKeyDown;
else
{
if (isNS4) document.captureEvents(Event.KEYPRESS);
document.onkeypress = scrKeyDown;
}
// *** SCROLLING BY MOUSEWHEEL IN IE6+ *** delete if this isn't needed.
if (isIE) document.onmousewheel = function()
{
// Just call the scrollBy methods of the appropriate scrollers.
// You may wish to adjust the scrolling amount, just change the number.
mainDiv.scrollBy(event.wheelDelta / -3);
// Disable scrolling in the document, as we're handling this event.
return false;
}
// ******************************************************
// **
// ** POPUP MENU SECTION EDITING
// ** START EDITING HERE, READ THIS SECTION CAREFULLY!
// **
// ******************************************************
//
//
// Before you start, make sure you've read the "Conditions Of Use" in this HTML document
// or on my site. Anyway, this menu script is split up into several sections. They are:
//
// (1) ITEMSTYLES - These define the colour and size of menu items. Required to run.
// (2) MENU DATA - These specify the text and links in the menu. Required to run.
// (3) MENU EFFECTS - Want to remove, or change borders, shadows and animation? Edit them here,
// or you can delete this section entirely to remove extra effects.
// (4) EVENTS - Activate the menu(s), and choose creation mode (Dynamic / Fast) etc. I recommend
// you read it, but you only really need to change it if you want multiple menus on one page,
// or are trying to combine this with other JavaScripts. Required to run.
// (5) OPTIONAL CODE - Extra features like adding clicking to 'sm:' items or status messages on
// mouseover. Animation/effects functions are here too. You can skip or delete this entirely.
// (6) FRAMESET README - If you're using a frameset, read this, it explains what you need to do.
// *** (1) ITEMSTYLES ***
var defOver = '#bcc5d6', defBack = '#ebeef3', deflength = 170; defHaut = 20 ;
var hBar = new ItemStyle(deflength, 1, '', 0, 0, defOver, defOver, 'highText', 'highText', '', '',
null, null, 'hand', 'default');
// The 'sub Menu' items: 22px long, 0px spacing, a 'greater than' sign for a popout indicator
// (you may wish to use an image tag?), the popout indicator is positioned 15px from the right
// edge of the item, items have 3px padding, some colours, it uses 'lowText' as the dimmed text
// class but 'highText' when it is moused over, and 'itemBorder' as the border stylesheet class.
// No opacity is used, and they have the same cursors as the above ItemStyle.
var subM = new ItemStyle(defHaut, 0, '>', -15, 3, defBack, defOver, 'lowText', 'highText',
'', '', null, null, 'hand', 'default');
// 'subBlank' is similar, but has an 'off' border the same colour as its background so it
// appears borderless when dim, and 1px spacing between items to show the hover border.
var subBlank = new ItemStyle(defHaut, 1, '>', -15, 3, defBack, defOver, 'lowText', 'highText',
'', '', null, null, 'hand', 'default');
// The purplish 'button' style also has 1px spacing to show up the fancy border, and it has
// different colours/text and less padding. They also have translucency set -- these items
// are 80% opaque when dim and 95% when highlighted. It uses the 'crosshair' cursor for items.
var button = new ItemStyle(defHaut, 1, '>', -15, 2, defBack, defOver, 'buttonText', 'buttonHover',
'buttonBorder', 'buttonBorderOver', 80, 95, 'crosshair', 'default');
// *** (2) MENU DATA ***
//
// A PopupMenu() object must be passed its own name so it can reference itself when the menu
// is active. We also use a 'with' block to work with its properties and functions below.
var pMenu = new PopupMenu('pMenu');
with (pMenu)
{
// *** MOVE OR CENTRE THE MENU HERE ***
startMenu('root', false, 0, 'page.winH()/5', defHaut, hBar);
// The text is a space then 'File', and this item pops out the 'mFile' submenu when moused over
// as we've set 'sm:' as the action type. If you want to assign a click action (e.g. navigating to
// a file) to one of these 'sm:' items, see the 'Optional Code' section below.
addItem(' ', 'blanc', 'sm:');
addItem('Entreprise', 'entreprise', 'sm:');
addItem('Produits et Services', 'quebec', 'sm:');
addItem("International", 'intl', 'sm:');
addItem('Support', 'support', 'sm:');
addItem(' ', 'blanc', 'sm:');
// Next is an example of a Javascript function embedded in the menu, to open a new window...
// Also, note the extra optional 4th and 5th parameters -- this menu item is 80px long,
// rather than the default length from the ItemStyle.
// addItem(' Support', 'window.open("http://www.twinhelix.com")', 'js:', hBar, 80);
startMenu('blanc', true, 0, defHaut, deflength, subM);
// This is a vertical menu positioned 0px across and defHautpx down from its trigger, and is deflengthpx wide.
startMenu('entreprise', true, 0, defHaut, deflength, subM);
// The URLs are set to # here, be sure to replace them with your path/file names or JS functions!
// Also note how all the types are '', indicating these links open in the current frame.
addItem('Profil corporatif', 'mainDiv.load("profil.htm")', 'js:');
addItem('Salle de presse', 'mainDiv.load("presse.htm")', 'js:');
addItem('Liste d\'envoi', 'window.open("http://www.infoserv.d2g.com/listecourriel/addliste.php")', 'js:');
addItem('Carrière', 'mainDiv.load("carrieres.htm")', 'js:');
addItem('Contacts', 'mainDiv.load("contacts.htm")', 'js:');
startMenu('quebec', true, 0, defHaut, deflength, subM);
// addItem('Matériel informatique', 'mainDiv.load("materielinfo.htm")', 'js:');
addItem('Gestion de parcs', 'mainDiv.load("gestionparcs.htm")', 'js:');
// addItem('Borne interactive', 'mainDiv.load("borne.htm")', 'js:');
// addItem('Mesures de secours', 'mainDiv.load("mesures_secours.htm")', 'js:');
// addItem('Câblage et fibre optique', 'mainDiv.load("cablage.htm")', 'js:');
// addItem("Solutions d'impression", 'mainDiv.load("impression.htm")', 'js:');
addItem("Service d'audit", 'mainDiv.load("audit.htm")', 'js:');
// addItem('Solutions de sécurité', 'mainDiv.load("securite.htm")', 'js:');
// addItem('Formation en entreprise', 'mainDiv.load("formation.htm")', 'js:');
startMenu('intl', true, 0, defHaut, deflength, subM);
addItem('Profil', 'mainDiv.load("intl_profil.htm")', 'js:');
addItem('Notre Mission', 'mainDiv.load("intl_mission.htm")', 'js:');
addItem("Nos Services", 'mainDiv.load("intl_services.htm")', 'js:');
addItem('Partenaires', 'mainDiv.load("intl_partenaires.htm")', 'js:');
addItem('Réalisations', 'mainDiv.load("intl_realisations.htm")', 'js:');
startMenu('support', true, 0, defHaut, deflength, subM);
// addItem('Appels de service en ligne', 'window.open("http://205.205.40.244/intranet/as")', 'js:');
addItem('Foire aux Questions', 'mainDiv.load("faq.htm")', 'js:');
addItem('Étapes de diagnostique', 'mainDiv.load("diag.htm")', 'js:');
addItem('Contactez-nous', 'mainDiv.load("contactsupport.htm")', 'js:');
addItem('Support à distance', 'mainDiv.load("epgclient.exe")', 'js:');
}
// You can create another menu object here if you want multiple menus on a page.
// Every menu object MUST have a menu named 'root' in it, as that's always visible.
// You can name the other menus in it anything you want.
//var anotherMenu = new PopupMenu('anotherMenu');
//with (anotherMenu)
//{
// startMenu('root', .....);
// ... make menus here ...
//}
// *** (5) OPTIONAL CODE *** DELETE IF YOU'RE NOT USING THESE!
// MOUSE EVENTS:
//
// If you want, you can assign functions to handle mouse events like mouse over/out/click.
// You'll want to use these for assigning click actions to 'sm:' items or status messages etc.
// 'with (this)' means use the properties of the menu object, and it's passed the current
// menu name (mN) and item number (iN) you can use to calculate the active item.
// To uncomment and activate, delete the /* and */ at the start and end.
/*
pMenu.onclick = function(mN, iN) { with (this)
{
// Do actions depending on the item that the mouse was over at the time of the click.
// You may with to use nested IFs or 'switch' statements etc. if you're familiar with JS.
if (mN == 'root')
{
if (iN == 1) status = 'Congratulations, you\'ve mastered clicking!';
// Click on second item in root menu will navigate to 'edit.html'. Copy and paste this for
// each menu item to add click actions to 'sm:' items...
if (iN == 2) location.href = 'edit.html';
if (iN == 3) location.href = 'help.html';
}
}}
// Set the status message to the URL if the 'action type' is nothing, and clear on mouseout.
pMenu.onmouseover = function(mN, iN) { with (this)
{
// By now, you either have my JS Object Browser script from my site or you need it... try
// embedding in an IFrame and typing 'pMenu' into its Go To field to see the menu internals.
with (menu[mN][iN]) if (!type) status = href;
}}
pMenu.onmouseout = function() { status = '' }
*/