// Copyright 1999 Microsoft Corporation. All rights reserved. 
// Author: Steve Isaac, Microsoft Corporation
//
// DHTML Toolbar Package
//
// This file (along with the companion toolbars.css file) implements full featured
// toolbars completely in DHTML.
//
// See tutorial.htm in the Doc directory for full info on how to use this package.
//
//
//=================================================================================================
//

// Public Style Classes
// --------------------
// tbToolbar:    Toolbar
// tbButton:     Toolbar button
// tbIcon:       Toolbar or menu icon
// tbSeparator:  Toolbar or menu separator
// tbMenu:       Pulldown menu
// tbMenuItem:   Menu item
// tbSubmenu:    Submenu
// tbGeneral:    Arbitrary HTML element in a toolbar.
// tbContentElement: Identifies an HTML element as the page body. One and only one 
//               element on the page must have this class. The element must also have 
//               its ID set to "tbContentElement".
//
// Public Attributes
// -----------------
// TBTYPE: Special type of element. Possible values are:
//   Elements: toggle
//             radio
//             <not specified> - Simple button
//
//   Toolbars: noMouseOver
//             <not specified> - Mouseover supported
//
// TBSTATE: State of the element. Possible values are:
//   Elements: gray (Disabled)
//             checked
//             unchecked
//             
//   Toolbars: dockedTop
//             dockedBottom
//             hidden
//
// tbOnMenuShow: Event handler that is called immediately prior to showing a menu or 
//   submenu. Hosts use this to set the state of menu items. This attribute can either
//   be set on individual menus and submenus, or on a toolbar in which case it is
//   fired for every menu and submenu within that toolbar. The menu that is about
//   to be shown is given in tbEventSrcElement (see below).
//
// Public Functions
// ----------------
// TBSetState(element, newState)
//   Sets the state of an element.
//     element: element to set. This is an object.
//     newState: state to set. This is a string, same values as TBSTATE.
//
// TBRebuildToolbar(toolbar, rebuildMenus)
//   Use this routine to change the contents of a toolbar on the fly. Make all changes
//   (adding, removing and modifying toolbar elements), then call this routine once.
//	 This routine can also be used to add an entirely new toolbar.
//     toolbar: toolbar to rebuild. This is an object.
//     rebuildMenus: Should the menus in this toolbar also be rebuilt? Only set this
//       to true if there have been changes; its an expensive operation.
//
// TBRebuildMenu(menu, rebuildSubmenus)
//   Use this routine to change the contents of a menu or a submenu on the fly. Make all changes
//   (adding, removing and modifying menu items), then call this routine once.
//     menu: menu to rebuild. This is an object.
//     rebuildSubmenus: Should the submenus also be rebuilt? Only set this
//       to true if there have been changes; its expensive.
//
// Public Globals
// --------------
// tbEventSrcElement: Contains the element that an event was fired on. The toolbar
// package doesn't support the event object; this object performs a similar function.
var tbEventSrcElement;

//
// Public Error Return Values
// --------------------------
TB_STS_OK = "OK" // Success return
TB_E_INVALID_CLASS = "Invalid class value" // An element has an unrecognized class attribute (probably a misspelling)
TB_E_INVALID_TYPE = "Invalid TBTYPE value"
TB_E_INVALID_STATE = "Invalid TBSTATE value"
TB_E_NO_ID = "Element does not have an ID"

//
//=================================================================================================
// 
// Private Attributes
// ------------------
// TBTOOLBARWIDTH: Width of the toolbar (in px)
// TBUSERONCLICK: Temporary storage of an element's original onclick handler
//
// Private Constants. These can be used along with toolbar.css to change the look of the toolbar package.
// -----------------
TB_DISABLED_OPACITY_FILTER = "alpha(opacity=25)"
TB_HANDLE_WIDTH = 10
TB_HANDLE = '<DIV class=tbHandleDiv style="LEFT: 3"> </DIV>' +
            '<DIV class=tbHandleDiv style="LEFT: 6"> </DIV>'

TB_TOOLBAR_PADDING = 4
TB_SEPARATOR_PADDING = 5
TB_CLIENT_AREA_GAP = 0

//
// Private Globals
// ---------------
var TBInitialized = false; // Set to true when the package has initialized.
var tbToolbars = new Array();  // Array of all toolbars.
var tbContentElementObject = null; // Content element.
var tbContentElementTop = 0;  // Y pixel coordinate of the top of the content element.
var tbContentElementBottom = 0; // Y pixel coordinate of the bottom of the content element.
var tbLastHeight =0; // Previous client window height (before resize in process).
var tbLastWidth = 0; // Previous client window width. 
var tbRaisedElement = null; // Current toolbar button that is being shown raised.
var tbOnClickInProcess;	// Executing user's onClick event.
var tbMouseOutWhileInOnClick;  // An onmouseout event occurred while executing the user's onClick event.

//
// Functions
//

// Public function for changing an element's state. 
function TBSetState(element, newState) {

  newState = newState.toLowerCase();
  switch (element.className) {
    case "tbToolbar" :
      if ((newState != "dockedtop") && (newState != "dockedbottom") && (newState != "hidden")) {
        return TB_E_INVALID_STATE;    
      }
      element.TBSTATE = newState;
      if (newState == "hidden") {
        element.style.visibility = "hidden";
      } else {
        element.style.visibility = "visible";
      }
      TBLayoutToolbars();
      TBLayoutBodyElement();      
    break;
    
    case "tbButton" :
    case "tbButtonDown" :
    case "tbButtonMouseOverUp" :
    case "tbButtonMouseOverDown" :
    case "tbMenuItem" :
      if ((newState != "gray") && (newState != "checked") && (newState != "unchecked")) {
        return TB_E_INVALID_STATE;
      }
        
      currentState = element.TBSTATE;
      if (currentState == "") {
        currentState = "checked";
      }
      
      if (newState == currentState) {
        return;
      }

      if (element.className != "tbMenuItem") {
        image = element.children.tags("IMG")[0];
     
        // Going into disabled state  
        if (newState == "gray") {
          element.className = "tbButton";  
          image.className = "tbIcon";  
          element.style.filter = TB_DISABLED_OPACITY_FILTER;
        }
      
        // Coming out of disabled state. Remove disabled look.
        if (currentState == "gray") {
          element.style.filter = "";
        }
      
        if (newState == "checked") {
           element.className = "tbButtonDown";  
           image.className = "tbIconDown";
        } else { //unchecked
           element.className = "tbButton";  
           image.className = "tbIcon";
        }  
      }

      if ((element.TBTYPE == "radio") && (newState == "checked")) {
        radioButtons = element.parentElement.children;
        for (i=0; i<radioButtons.length; i++) {
          if ((radioButtons[i].NAME == element.NAME) && (radioButtons[i] != element)) {
            radioButtons[i].TBSTATE = "unchecked";
            
            if (element.className != "tbMenuItem") {
              radioButtons[i].className = "tbButton";
              radioButtons[i].children.tags("IMG")[0].className = "tbIcon";
            }
          }
        }
      }
      
      element.TBSTATE = newState;
      break;
      
    default :
      return TB_E_INVALID_CLASS;
  }
  return TB_STS_OK;
} //TBSetState


// Event handler for tbContentElementObject onmouseover events.
function TBContentElementMouseOver() {
return;
  if (tbRaisedElement) {
    switch (tbRaisedElement.className) {
    case "tbMenu" :
      // Note: TBShowNormal is in tbmenus.js.
      TBShowNormal(tbRaisedElement);
      break;
    case "tbButtonMouseOverUp" :
      tbRaisedElement.className = "tbButton";
      break;
    case "tbButtonMouseOverDown" :
      tbRaisedElement.className = "tbButtonDown";
      break;
    }
    tbRaisedElement = null;
  }
}


// Global onmouseup handler.
function TBGlobalMouseUp() {
}


// Global onmousedown handler.
function TBGlobalMouseDown() {
  // Always bring down any menus that are being displayed.
  if (typeof(tbMenu) != "undefined") {
    TBHideMenus();
  }
} 


//Global ondragstart and onselectstart handler.
function TBGlobalStartEvents() {
}

//Global mouse move handler.
function TBGlobalMouseMove() {
}


// Hander that simply cancels an event
function TBCancelEvent() {
  event.returnValue=false;
  event.cancelBubble=true;
}


// Toolbar button onmouseover handler
function TBButtonMouseOver() 
{
  var element, image;

  image = event.srcElement;
  element = image.parentElement;
  
  if (element.TBSTATE == "gray") {
    event.cancelBubble=true;
    return;
  }
  // Change button look based on current state of image.
  if (image.className == "tbIcon") {
    element.className = "tbButtonMouseOverUp";
    tbRaisedElement = element;
  } else if (image.className == "tbIconDown") {
    element.className = "tbButtonMouseOverDown";
  }

  event.cancelBubble=true;
} // TBButtonMouseOver


// Toolbar button onmouseout handler
function TBButtonMouseOut() {
  var element, image;
  
  image = event.srcElement;
  element = image.parentElement;
  if (element.TBSTATE == "gray") {
    event.cancelBubble=true;
    return;
  }
  
  tbRaisedElement = null;
  
  // Are we in the middle of an onClick event? Set a flag for the onclick handler and return if so.
  if (tbOnClickInProcess) {
    tbMouseOutWhileInOnClick = true;
    return;
  }

  switch (image.className) {
    case "tbIcon" :
      // Is the user cancelling unchecking a toggle/radio button by moving out?
      if (((element.TBTYPE == "toggle") || (element.TBTYPE == "radio")) && (element.TBSTATE == "checked")) {
        element.className = "tbButtonDown";
        image.className = "tbIconDown";
      } else {
        element.className = "tbButton";
      }
    break;
      
    case "tbIconDown" :
      // Is the user cancelling checking a toggle/radio button by moving out?
      if (((element.TBTYPE == "toggle") || (element.TBTYPE == "radio")) && (element.TBSTATE == "unchecked")) {
        element.className = "tbButton";
        image.className = "tbIcon";
      } else {
        element.className = "tbButtonDown"
      }
    break;
      
    case "tbIconDownPressed" :
      // The only time we'll see this is if the user is cancelling unchecking a checked toggle/radio
      element.className = "tbButtonDown";
      image.className = "tbIconDown";
    break;  
  }
  event.cancelBubble=true;
} // TBButtonMouseOut


// Toolbar button onmousedown handler
function TBButtonMouseDown() {
  var element, image;
  
  if (typeof(tbMenu) != "undefined") {
    TBHideMenus();
  }
  
  if (event.srcElement.tagName == "IMG") {
    image = event.srcElement;
    element = image.parentElement;
  } else {
    element = event.srcElement;
    image = element.children.tags("IMG")[0];
  }
  if (element.TBSTATE == "gray") {
    event.cancelBubble=true;
    return;
  }
  switch (image.className) {
    case "tbIcon" :
      element.className = "tbButtonMouseOverDown";
      image.className = "tbIconDown";
    break;
      
    case "tbIconDown" :
      if ((element.TBTYPE == "toggle") || (element.TBTYPE == "radio")) {
        image.className = "tbIconDownPressed";
      } else {
        element.className = "tbButton";
        image.className = "tbIcon";
      }
    break;
  }   
  
  event.cancelBubble=true;
  return false;
   
} //TBButtonMouseDown

// Toolbar button onmouseup handler
function TBButtonMouseUp() {
  var element, image, userOnClick, radioButtons, i;
  if (event.srcElement.tagName == "IMG") {
    image = event.srcElement;
    element = image.parentElement;
  } else {
    element = event.srcElement;
    image = element.children.tags("IMG")[0];
  }
  
  if (element.TBSTATE == "gray") {
    event.cancelBubble=true;
    return;
  }

  // Make sure this is one of our events
  if ((image.className != "tbIcon") && (image.className != "tbIconDown") && (image.className != "tbIconDownPressed")) {
    return;
  }

  // Initialize tbEventSrcElement so that the user's onClick handler can find out where the
  // event is coming from
  tbEventSrcElement = element;
  
  // Execute the  onclick handler that was on the event originally (user's onclick handler).
  // This is a little tricky; we have to call the anonymous function wrapper that was put around
  // the event by IE. Also, we set a global flag so that we can find out if a mouseout event occurs
  // while processing the user's onclick handler. mouseout and onclick behavior have to change
  // if this happens.
  tbOnClickInProcess = true;
  tbMouseOutWhileInOnClick = false;
  if (element.TBUSERONCLICK) {
    eval(element.TBUSERONCLICK + "anonymous()");
  }
  tbOnClickInProcess = false;
  
  // Is the nomouseover flag set on the toolbar?
  if (element.parentElement.TBTYPE == "nomouseover") {
    tbMouseOutWhileInOnClick = true;
  }