Summary

No overview generated for 'Mapbuilder.js'

/*
License: LGPL as per: http://www.gnu.org/copyleft/lesser.html
$Id: Mapbuilder.js 3819 2008-02-01 00:31:29Z ahocevar $
*/

/** get a time stamp at start of the page load */
var mbTimerStart = new Date();

/** the global config object */
var config;

if( typeof baseDir == "undefined") {
/** URL of Mapbuilder's lib/ directory. */
var baseDir;
}

/** mapbuilder environement settings, defaults to a .xml extension but is 
  auto-configured by the ant build script to .jsp for tomcat environment 
  the URL to this file will be pre-pended with the baseDir value.
*/
var mbServerConfig = "mapbuilderConfig.xml";
var mbNsUrl = "http://mapbuilder.sourceforge.net/mapbuilder";

// LoadState Constants
var MB_UNLOADED=0;    // Scripts not loaded yet
var MB_LOAD_CORE=1;   // Loading scripts loaded defined in Mapbuilder
var MB_LOAD_CONFIG=2; // Loading scripts loaded defined in Config
var MB_LOADED=3;      // All scripts loaded

/**
 * This Object bootstraps the Mapbuilder libraries by loading the core
 * script files.
 * When Config.js is loaded, the script files for objects described in the
 * Mapbuilder config file are loaded.
 * Objects which have dependencies will trigger the dependancies to load
 * when they are loaded.
 *
 * @constructor
 * @author Cameron Shorter
 * @requires Config
 * @requires Listener
 * @requires ModelBase
 * @requires Sarissa
 * @requires Util
 */
function Mapbuilder() {

  /**
   * Determines which Mapbuilder scripts are loading.
   * TBD: Is it possible to use enumerated types in JS?
   */
  this.loadState=MB_UNLOADED;

  /** Array of objects that are loading.  Don't continue initialisation until
   * all objects have loaded. */
  this.loadingScripts=new Array();
  
  /** Array of scripts that have to be loaded ordered */
  this.orderedScripts = new Array();
  
  /** Timer to load ordered scripts */
  this.scriptLoader = null;

  /** Timer to periodically check if scripts have loaded. */
  this.scriptsTimer=null;

  /**
   * Called periodically and moves onto the next loadState when this round of
   * scripts have loaded.
   * For IE clients, object.readyState is used to check if scripts are loaded.
   * Mozilla works fine without this function - I think it is single threaded.
   */
  this.checkScriptsLoaded=function() {
    if (document.readyState!=null){
      // IE client

      // Scripts are removed from array when they have loaded
      while(this.loadingScripts.length>0
        &&(this.loadingScripts[0].readyState=="loaded"
          ||this.loadingScripts[0].readyState=="complete"
          ||this.loadingScripts[0].readyState==null))
      {
        this.loadingScripts.shift();
      }
      if (this.loadingScripts.length==0 && this.orderedScripts.length == 0){
        this.setLoadState(this.loadState+1);
      }
    }
    else{
      // Mozilla client
      if(this.loadState==MB_LOAD_CORE && config!=null){
        // Config has finished loading
        this.setLoadState(MB_LOAD_CONFIG);
      }
    }
  }

  /**
   * Move onto loading the next set of scripts.
   * @param newState The new loading state.
   */
  this.setLoadState=function(newState){
    this.loadState=newState;
    switch (newState){
      case MB_LOAD_CORE:
        // core scripts have to be loaded in the correct order (needed for IE)
        this.loadOrdered = true;
        this.loadScript(baseDir+"/util/openlayers/OpenLayers.js");
        this.loadScript(baseDir+"/util/sarissa/Sarissa.js");
        this.loadScript(baseDir+"/util/sarissa/javeline_xpath.js");
        this.loadScript(baseDir+"/util/sarissa/javeline_xslt.js");
        this.loadScript(baseDir+"/util/sarissa/sarissa_dhtml.js");
        this.loadScript(baseDir+"/util/sarissa/sarissa_ieemu_xpath.js");
        //this.loadScript(baseDir+"/util/sarissa/sarissa_ieemu_xslt.js");//all deprecated
        this.loadScript(baseDir+"/util/proj4js/proj4js-compressed.js");
        this.loadScript(baseDir+"/util/Util.js");
        this.loadScript(baseDir+"/util/Listener.js");
        this.loadScript(baseDir+"/model/ModelBase.js");
        this.loadScript(baseDir+"/model/Config.js");
        // from now on, scripts can be loaded in any order
        this.loadOrdered = false;
        break;
      case MB_LOAD_CONFIG:
        if(document.readyState){
          // IE
          config=new Config(mbConfigUrl);
          config.loadConfigScripts();
        }else{
          // Mozilla
          this.setLoadState(MB_LOADED);
        }
        break;
      case MB_LOADED:
        window.clearInterval(this.scriptsTimer);
        break;
    }
  }

  /**
   * Dynamically load a script file if it has not already been loaded.
   * @param url The url of the script.
   * that loadScript was called
   */
  this.loadScript=function(url){
    // if we are working with a compressed build, load only scripts that
    // are not part of the compressed build. This check is done by looking
    // into the global namespace for a function that has the same name as
    // the script file (without path and without .js). Because script files
    // in the util dir do not follow that pattern, exclude them from the
    // check separately.
    if(typeof MapBuilder_Release == "boolean") {
      if (url.indexOf(baseDir+"/util/") != -1) {
        return;
      }
      var urlElements = url.split("/");
      var scriptClass = urlElements[urlElements.length-1].replace(/.js$/, "");
      if(typeof window[scriptClass] == "function") {
        return;
      }
    }

    if(!document.getElementById(url)){
      var script = document.createElement('script');
      script.src = url;
      script.id = url;
      script.defer = false;   //not sure of effect of this?
      script.type = "text/javascript";
      if (document.readyState && this.loadOrdered == true) {
        // in IE, mark the script as ordered
        this.orderedScripts.push(script);
        if (!this.scriptLoader) {
          this.scriptLoader = window.setInterval('mapbuilder.loadNextScript()', 50);
        }
      } else {
        // add to dom tree, except if we are using IE and want to load ordered
        document.getElementsByTagName('head')[0].appendChild(script);
      }
      if (document.readyState) {
        // this is only needed for IE
        this.loadingScripts.push(script);
      }
    }
  }
   
  /**
   * loads one script after another - only for IE. This function is run in a
   * 50ms interval and clears its interval if there are no more scripts to
   * load. It actually loads the first script from the orderedScripts array.
   */
  this.loadNextScript = function() {
    if (this.orderedScripts.length == 0) {
      window.clearInterval(this.scriptLoader);
      this.scriptLoader = null;
    } else {
      var script = this.orderedScripts[0];
      if (!script.loading) {
        script.loading = true;
        this.doLoadScript(script);
      }
    }
  }
  
  /**
   * starts script loading by adding the script node to the dom tree - IE only.
   * This function adds a readyState handler to the script node.
   */
  this.doLoadScript = function(script) {
    var objRef = this;
    script.onreadystatechange = function(){objRef.checkScriptState(this)};
    document.getElementsByTagName('head')[0].appendChild(script);
  }
  
  /**
   * readyState handler for scripts - IE only. This will remove the script from
   * the array of scripts that have still to be loaded.
   */
  this.checkScriptState = function(script) {
    if (script.readyState == "loaded" || script.readyState == "complete") {
      for (var i=0; i<this.orderedScripts.length; i++) {
        if (script == this.orderedScripts[i]) {
          this.orderedScripts.splice(i, 1);
          break;
        }
      }
    }
  }

  /**
   * Internal function to load scripts for components that don't have <scriptfile>
   * specified in the config file.
   * @param xPath Xpath match of components from the Config file.
   * @param dir The directory the script is located in.
   */
  this.loadScriptsFromXpath=function(nodes,dir) {
    //var nodes = this.doc.selectNodes(xPath);
    for (var i=0; i<nodes.length; i++) {
      if (nodes[i].selectSingleNode("mb:scriptFile")==null){
        scriptFile = baseDir+"/"+dir+nodes[i].nodeName+".js";
        this.loadScript(scriptFile);
      }
    }
  }

  //derive the baseDir value by looking for the script tag that loaded this file
  if (!baseDir) {
    var head = document.getElementsByTagName('head')[0];
    var nodes = head.childNodes;
    for (var i=0; i<nodes.length; ++i ){
      var src = nodes.item(i).src;
      if (src) {
        //var index = src.indexOf("/Mapbuilder.js");
        // Modified so it will work with original or compressed file
        var index = src.indexOf("/Mapbuilder.js");
        if (index>=0) {
          baseDir = src.substring(0, index);
        } else {
          index = src.indexOf("/MapbuilderCompressed.js");
          if (index>=0) {
            baseDir = src.substring(0, index);
          }
        }
      }
    }
  }

  // Start loading core scripts.
  this.setLoadState(MB_LOAD_CORE);

  // Start a timer which periodically calls checkScriptsLoaded().
  this.scriptsTimer=window.setInterval('mapbuilder.checkScriptsLoaded()',100);
}

/**
 * copied from sarissa, a function to check browser security setting in IE, 
 * opens a help page if ActiveX objects are disabled.
 */
function checkIESecurity()
{
  var testPrefixes = ["Msxml2.DOMDocument.5.0", "Msxml2.DOMDocument.4.0", "Msxml2.DOMDocument.3.0", "MSXML2.DOMDocument", "MSXML.DOMDocument", "Microsoft.XMLDOM"];
  // found progID flag
  var bFound = false;
  for(var i=0; i < testPrefixes.length && !bFound; i++) {
    try {
      var oDoc = new ActiveXObject(testPrefixes[i]);
      bFound = true;
    }
    catch (e) {
      //trap; try next progID
    }
  }
  if (!bFound) window.open("/mapbuilder/docs/help/IESetup.html");  //TBD: set this URL in config
}

if (navigator.userAgent.toLowerCase().indexOf("msie") > -1) checkIESecurity();
var mapbuilder=new Mapbuilder();

/**
 * Initialise Mapbuilder if script has been loaded, else wait to be called
 * again.
 */
function mapbuilderInit(){
  if(mapbuilder && mapbuilder.loadState==MB_LOADED){
    window.clearInterval(mbTimerId);
    config.parseConfig(config);
    if (Proj4js) {
      Proj4js.libPath = baseDir+"/util/proj4js/";
      Proj4js.proxyScript = config.proxyUrl+'?url=';
    }
    config.callListeners("init");
    var mbTimerStop = new Date();
    //alert("load time:"+(mbTimerStop.getTime()-mbTimerStart.getTime()) );
    if (window.mbInit) window.mbInit();
    config.callListeners("loadModel");
  }
}

/** Timer used when checking if scripts have loaded. */
var mbTimerId;

/**
 * Mapbuilder's main initialisation script.
 * This should be called from the main html file using:
 *   <body onload="mbDoLoad()">
 * @param initFunction Optional - A function reference that will be called after 
 * config.init() has been called.  This is to give application code a chance to
 * do initialization and be guaranteed that all objects exist (inlcuding config).
 */
function mbDoLoad(initFunction) {
  // See if scripts have been loaded every 100msecs, then call config.init().
  mbTimerId=window.setInterval('mapbuilderInit()',100);
  if (initFunction) window.mbInit = initFunction;
}