// Copyright and licensing information in this Javascript source code is declared at the beginning of each section of code (and ends at the occurence of the next copyright notice).





var PEnvironment = {
	apiUrl: 'http://api.gis.policymap.com',
	apiVersion: '1.3',
	chartUrl: 'http://indicator.gis.policymap.com/servlet',
	custId: 284,
	geocoderUrl: 'http://geocode.gis.policymap.com',
	indicatorUrl: 'http://indicator.gis.policymap.com/servlet',
	kamapUrl: 'http://api.gis.policymap.com/api/1.3/kamap4p/htdocs/',
	lineUrl: 'http://line.gis.policymap.com/api/1.3/kamap4p/htdocs',
	pinUrl: 'http://pin.gis.policymap.com',
	placeUrl: 'http://place.gis.policymap.com',
	printUrl: 'http://print.gis.policymap.com/api/1.3',
	restUrl: 'http://rest.gis.policymap.com',
	tileDirect: 'api/1.3/kamap4p/htdocs/tile_r.pl',
	tileUrls: ['http://dl1.gis.policymap.com/tilecache','http://dl2.gis.policymap.com/tilecache','http://dl3.gis.policymap.com/tilecache','http://dl4.gis.policymap.com/tilecache']
};

/* ***********************************************************
Example 4-3 (DHTMLapi.js)
"Dynamic HTML:The Definitive Reference"
2nd Edition
by Danny Goodman
Published by O'Reilly & Associates  ISBN 1-56592-494-0
http://www.oreilly.com
Copyright 2002 Danny Goodman.  All Rights Reserved.
************************************************************ */
// DHTMLapi.js custom API for cross-platform
// object positioning by Danny Goodman (http://www.dannyg.com).
// Release 2.0. Supports NN4, IE, and W3C DOMs.

// Global variables
var isCSS, isW3C, isIE4, isNN4;
// initialize upon load to let all browsers establish content objects
function initDHTMLAPI() {
    if (document.images) {
        isCSS = (document.body && document.body.style) ? true : false;
        isW3C = (isCSS && document.getElementById) ? true : false;
        isIE4 = (isCSS && document.all) ? true : false;
        isNN4 = (document.layers) ? true : false;
        isIE6CSS = (document.compatMode && document.compatMode.indexOf("CSS1") >= 0) ? true : false;
    }
}
// set event handler to initialize API
//window.onload = initDHTMLAPI;

// Seek nested NN4 layer from string name
function seekLayer(doc, name) {
    var theObj;
    for (var i = 0; i < doc.layers.length; i++) {
        if (doc.layers[i].name == name) {
            theObj = doc.layers[i];
            break;
        }
        // dive into nested layers if necessary
        if (doc.layers[i].document.layers.length > 0) {
            theObj = seekLayer(document.layers[i].document, name);
        }
    }
    return theObj;
}

// Convert object name string or object reference
// into a valid element object reference
function getRawObject(obj) {
    var theObj;
    if (typeof obj == "string") {
        if (isW3C) {
            theObj = document.getElementById(obj);
        } else if (isIE4) {
            theObj = document.all(obj);
        } else if (isNN4) {
            theObj = seekLayer(document, obj);
        }
    } else {
        // pass through object reference
        theObj = obj;
    }
    return theObj;
}

// Convert object name string or object reference
// into a valid style (or NN4 layer) reference
function getObject(obj) {
    var theObj = getRawObject(obj);
    if (theObj && isCSS) {
        theObj = theObj.style;
    }
    return theObj;
}

// Position an object at a specific pixel coordinate
function shiftTo(obj, x, y) {
    var theObj = getObject(obj);
    if (theObj) {
        if (isCSS) {
            // equalize incorrect numeric value type
            var units = (typeof theObj.left == "string") ? "px" : 0;
            theObj.left = x + units;
            theObj.top = y + units;
        } else if (isNN4) {
            theObj.moveTo(x,y);
        }
    }
}

// Move an object by x and/or y pixels
function shiftBy(obj, deltaX, deltaY) {
    var theObj = getObject(obj);
    if (theObj) {
        if (isCSS) {
            // equalize incorrect numeric value type
            var units = (typeof theObj.left == "string") ? "px" : 0;
            theObj.left = getObjectLeft(obj) + deltaX + units;
            theObj.top = getObjectTop(obj) + deltaY + units;
        } else if (isNN4) {
            theObj.moveBy(deltaX, deltaY);
        }
    }
}

// Set the z-order of an object
function setZIndex(obj, zOrder) {
    var theObj = getObject(obj);
    if (theObj) {
        theObj.zIndex = zOrder;
    }
}

// Set the background color of an object
function setBGColor(obj, color) {
    var theObj = getObject(obj);
    if (theObj) {
        if (isNN4) {
            theObj.bgColor = color;
        } else if (isCSS) {
            theObj.backgroundColor = color;
        }
    }
}

// Set the visibility of an object to visible
function show(obj) {
    var theObj = getObject(obj);
    if (theObj) {
        theObj.visibility = "visible";
    }
}

// Set the visibility of an object to hidden
function hide(obj) {
    var theObj = getObject(obj);
    if (theObj) {
        theObj.visibility = "hidden";
    }
}

// Retrieve the x coordinate of a positionable object
function getObjectLeft(obj)  {
    var elem = getRawObject(obj);
    var result = 0;
    if (document.defaultView) {
        var style = document.defaultView;
        var cssDecl = style.getComputedStyle(elem, "");
        result = cssDecl.getPropertyValue("left");
    } else if (elem.currentStyle) {
        result = elem.currentStyle.left;
    } else if (elem.style) {
        result = elem.style.left;
    } else if (isNN4) {
        result = elem.left;
    }
    return parseInt(result);
}

// Retrieve the y coordinate of a positionable object
function getObjectTop(obj)  {
    var elem = getRawObject(obj);
    var result = 0;
    if (document.defaultView) {
        var style = document.defaultView;
        var cssDecl = style.getComputedStyle(elem, "");
        result = cssDecl.getPropertyValue("top");
    } else if (elem.currentStyle) {
        result = elem.currentStyle.top;
    } else if (elem.style) {
        result = elem.style.top;
    } else if (isNN4) {
        result = elem.top;
    }
    return parseInt(result);
}

// Retrieve the rendered width of an element
function getObjectWidth(obj)  {
    var elem = getRawObject(obj);
    var result = 0;
    if (elem.offsetWidth) {
        result = elem.offsetWidth;
    } else if (elem.clip && elem.clip.width) {
        result = elem.clip.width;
    } else if (elem.style && elem.style.pixelWidth) {
        result = elem.style.pixelWidth;
    }
    return parseInt(result);
}

// Retrieve the rendered height of an element
function getObjectHeight(obj)  {
    var elem = getRawObject(obj);
    var result = 0;
    if (elem.offsetHeight) {
        result = elem.offsetHeight;
    } else if (elem.clip && elem.clip.height) {
        result = elem.clip.height;
    } else if (elem.style && elem.style.pixelHeight) {
        result = elem.style.pixelHeight;
    }
    return parseInt(result);
}


// Return the available content width space in browser window
function getInsideWindowWidth() {
    if (window.innerWidth) {
        return window.innerWidth;
    } else if (isIE6CSS) {
        // measure the html element's clientWidth
        return document.body.parentElement.clientWidth;
    } else if (document.body && document.body.clientWidth) {
        return document.body.clientWidth;
    }
    return 0;
}
// Return the available content height space in browser window
function getInsideWindowHeight() {
    if (window.innerHeight) {
        return window.innerHeight;
    } else if (isIE6CSS) {
        // measure the html element's clientHeight
        return document.body.parentElement.clientHeight;
    } else if (document.body && document.body.clientHeight) {
        return document.body.clientHeight;
    }
    return 0;
}


// XMLhttpRequest stuff
var aXmlHttp = new Array();
var aXmlResponse = new Array();
function xmlResult()
{
    for(var i=0;i<aXmlHttp.length;i++)
    {
        if(aXmlHttp[i] && aXmlHttp[i][0] && aXmlHttp[i][0].readyState==4&&aXmlHttp[i][0].responseText)
        {
            //must null out record before calling function in case
            //function invokes another xmlHttpRequest.
            var f = aXmlHttp[i][2];
            var o = aXmlHttp[i][1];
            var s = aXmlHttp[i][0].responseText;
            aXmlHttp[i][0] = null;
            aXmlHttp[i][1] = null;
            aXmlHttp[i] = null;
            f.apply(o,new Array(s));
        }
    }
}

// u -> url
// o -> object (can be null) to invoke function on
// f -> callback function
// p -> optional argument to specify POST
function call(u,o,f)
{
	//alert("calling: " + u + " " + o + "." + f);
    var method = "GET";
    var dat;
    if (arguments.length==4){
      method = "POST";
      tmp = u.split(/\?/);
      u = tmp[0];
      dat = tmp[1];

    }
    var idx = aXmlHttp.length;
    for(var i=0; i<idx;i++)
    if (aXmlHttp[i] == null)
    {
        idx = i;
        break;
    }
    aXmlHttp[idx]=new Array(2);
    aXmlHttp[idx][0] = getXMLHTTP();

    aXmlHttp[idx][1] = o;
    aXmlHttp[idx][2] = f;
    if(aXmlHttp[idx])
    {
        aXmlHttp[idx][0].open(method,u,true);
        if(method == "POST"){
          aXmlHttp[idx][0].setRequestHeader("Content-Type", "application/x-www-form-urlencoded");

          aXmlHttp[idx][0].send(dat);
        }
        aXmlHttp[idx][0].onreadystatechange=xmlResult;
        
       if(method =="GET"){ aXmlHttp[idx][0].send(null);}
    }
}

function getXMLHTTP()
{
    var A=null;
    if(!A && typeof XMLHttpRequest != "undefined")
    {
        A=new XMLHttpRequest();
    }
    if (!A)
    {
        try
        {
            A=new ActiveXObject("Msxml2.XMLHTTP");
        }
        catch(e)
        {
            try
            {
                A=new ActiveXObject("Microsoft.XMLHTTP");
            }
            catch(oc)
            {
                A=null;
            }
        }
    }    
    return A;
}

function drawNull(s)
{
    eval(s);
    return false;
}

function bypassCall(baseUrl, file, o, f)
{
	// o = name of object - a string not reference
	// f = name of function - a string not a reference
	//alert("bypass call: " + baseUrl + "->" + file + " callback: " + o + "." + f);
	var s = document.createElement('script');
	s.src = baseUrl + 'bypass.php?file=' + file + '&o=' + o + '&f=' + f;
	var h = document.getElementsByTagName('head').item(0);
	h.appendChild(s);
}

var goExpanderManager = new cExpanderManager();

/*
 * class to manage top level expander state between page
 * loads
 */
function cExpanderManager()
{
    this.expanders = new Array();
    this.formElement = null;
    
    this.add = cExpanderManager_Add;
    this.initialize = cExpanderManager_Initialize;
    this.registerOpen = cExpanderManager_RegisterOpen;
    this.registerClose = cExpanderManager_RegisterClose;
    this.isVisible = function() { return true; };
    this.isElementVisible = cExpanderManager_IsElementVisible;
    
    this.expandAll = cExpanderManager_ExpandAll;
    this.collapseAll = cExpanderManager_CollapseAll;
}

function cExpanderManager_Add( oExpander )
{
    this.expanders[this.expanders.length] = oExpander;
    oExpander.manager = this;
}

function cExpanderManager_Initialize()
{
    if (this.formElement == null)
        return;
        
    for(var i=0; i < this.expanders.length; i++)
    {
        if (this.expanders[i].bIsOpen)
            this.registerOpen( this.expanders[i] );
        this.expanders[i].initialize( this.isElementVisible( this.expanders[i].element.id ));
    }
}

function cExpanderManager_RegisterOpen( oExpander )
{
    if (this.formElement == null)
        return;

    if (this.formElement.value.indexOf( oExpander.element.id ) < 0 )
    {
        if (this.formElement.value != '')
            this.formElement.value += ",";
        this.formElement.value += oExpander.element.id;
    }  
}

function cExpanderManager_RegisterClose( oExpander )
{
    if (this.formElement == null)
        return;

    var rx = new RegExp( oExpander.element.id, '' );
    var text = this.formElement.value;
    text = text.replace( rx, '' );
    text = text.replace( /,,/g, ',' );
    if (text.substr(0, 1) == ',')
        text = text.slice( 1 );
    if (text.substr(-1) == ',')
        text = text.slice( 0, -1);
    this.formElement.value = text;
}

function cExpanderManager_IsElementVisible( id )
{
    rx = new RegExp( id, '' );
    return rx.test( this.formElement.value );
}

function cExpanderManager_ExpandAll()
{
    for(var i=0; i < this.expanders.length; i++)
    {
        this.expanders[i].expandAll();
    }
}

function cExpanderManager_CollapseAll()
{
    for(var i=0; i < this.expanders.length; i++)
    {
        this.expanders[i].collapseAll();
    }
    return true;
}

/*
 * basic expander class to handle an expandable element
 * that expands or contracts child elements.
 */
function cExpander( elm )
{
    this.element = elm;
    this.element.expander = this;
    this.children = new Array();
    this.bIsOpen = false;
    this.manager = null; 
    this.img = null;
    this.szExpandImgSrc = '';
    this.szCollapseImgSrc = '';
    
    this.addElement = cExpander_AddElement;
    this.open = cExpander_Open;
    this.close = cExpander_Close;
    this.expandAll = cExpander_ExpandAll;
    this.collapseAll = cExpander_CollapseAll;
    this.expand = cExpander_Expand;
    this.contract = cExpander_Contract;
    this.toggle = cExpander_Toggle;
    this.initialize = cExpander_Initialize;
    this.registerOpen = cExpander_RegisterOpen;
    this.registerClose = cExpander_RegisterClose;
    this.isVisible = cExpander_IsVisible;
}

function cExpander_AddElement( elm )
{
    this.children[this.children.length] = elm;
    elm.manager = this;
    return true;
}

function cExpander_Open()
{
    for( var i=0; i<this.children.length; i++)
    {
        this.children[i].element.style.display = 'block';
        if (this.children[i].bIsOpen)
        {
            this.children[i].open();
        }
    }
    if (this.img != null && this.szCollapseImgSrc != '')
    {
        this.img.src = this.szCollapseImgSrc;
    }
    return true;
}

function cExpander_Close()
{
    for( var i=0; i<this.children.length; i++)
    {
        this.children[i].element.style.display = 'none';
        this.children[i].close();
    }
    if (this.img != null && this.szExpandImgSrc != '')
    {
        this.img.src = this.szExpandImgSrc;
    }
    return true;
}

function cExpander_ExpandAll()
{
    for( var i=0; i<this.children.length; i++)
    {
        this.children[i].expandAll();
    }
    this.expand();
    return true;
}

function cExpander_CollapseAll()
{
    for( var i=0; i<this.children.length; i++)
    {
        this.children[i].collapseAll();
    }
    this.contract();
    return true;
}

function cExpander_Expand()
{
    this.bIsOpen = true;
    this.registerOpen( this );
    this.open();
    return true;
}

function cExpander_Contract()
{
    this.bIsOpen = false;
    this.registerClose( this );
    this.close();
    return true;
}

function cExpander_Toggle()
{
    if (this.bIsOpen)
        this.contract();
    else
        this.expand();
    return true;
}

/* intialize this and all children recursively */
function cExpander_Initialize( bState )
{
    this.bIsOpen = bState;
    for( var i=0; i<this.children.length; i++)
    {
        var child = this.children[i];
        if (this.isVisible())
            child.element.style.display = 'block';
        
        if (child.bIsOpen)
            this.registerOpen( child );
       
        this.children[i].initialize( goExpanderManager.isElementVisible( child.element.id ));
    }
    if( this.img != null )
    {
        if (this.bIsOpen && this.szCollapseImgSrc != '')
        {
            this.img.src = this.szCollapseImgSrc;
        }
        else if (!this.bIsOpen && this.szExpandImgSrc != '')
        {
            this.img.src = this.szExpandImgSrc;
        }
    }
    return true;
}

/* cascade registration to top level manager */
function cExpander_RegisterOpen(elm)
{
    if (this.manager != null)
        this.manager.registerOpen( elm );
        
    return true;
}

function cExpander_RegisterClose(elm)
{
    if (this.manager != null)
        this.manager.registerClose( elm );

    return true;
}

/* determine if all elements in heirarchy are also open */
function cExpander_IsVisible()
{
    var bVisible = this.bIsOpen;
    if (this.manager != null)
        bVisible = bVisible && this.manager.isVisible();
    return bVisible;
}

/******************************************************************************
 * This file has been modified by Piergiorgio Navone 
 *
 * $Id: excanvas.js,v 1.1 2006/05/31 11:09:08 pspencer Exp $
 *****************************************************************************/

// Copyright 2006 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// TODO: Patterns
// TODO: Radial gradient
// TODO: Clipping paths
// TODO: Coordsize
// TODO: Painting mode
// TODO: Optimize
// TODO: canvas width/height sets content size in moz, border size in ie
// TODO: Painting outside the canvas should not be allowed

// only add this code if we do not already have a canvas implementation
if (!window.CanvasRenderingContext2D) {

(function () {

  var G_vmlCanvasManager_ = {
    init: function (opt_doc) {
      var doc = opt_doc || document;
      if (/MSIE/.test(navigator.userAgent) && !window.opera) {
        var self = this;
        doc.attachEvent("onreadystatechange", function () {
          self.init_(doc);
        });
      }
    },

    init_: function (doc, e) {
      if (doc.readyState == "complete") {
        // create xmlns
        if (!doc.namespaces["g_vml_"]) {
          doc.namespaces.add("g_vml_", "urn:schemas-microsoft-com:vml");
        }

        // setup default css
        var ss = doc.createStyleSheet();
        ss.cssText = "canvas{display:inline-block;/*overflow:hidden;*/" +
            "text-align:left;}" +
            "canvas *{behavior:url(#default#VML)}";

        // find all canvas elements
        var els = doc.getElementsByTagName("canvas");
        for (var i = 0; i < els.length; i++) {
          if (!els[i].getContext) {
            this.initElement(els[i]);
          }
        }
      }
    },

    fixElement_: function (el) {
      // in IE before version 5.5 we would need to add HTML: to the tag name
      // but we do not care about IE before version 6
      var outerHTML = el.outerHTML;
      var newEl = document.createElement(outerHTML);
      // if the tag is still open IE has created the children as siblings and
      // it has also created a tag with the name "/FOO"
      if (outerHTML.slice(-2) != "/>") {
        var tagName = "/" + el.tagName;
        var ns;
        // remove content
        while ((ns = el.nextSibling) && ns.tagName != tagName) {
          ns.removeNode();
        }
        // remove the incorrect closing tag
        if (ns) {
          ns.removeNode();
        }
      }
      el.parentNode.replaceChild(newEl, el);
      return newEl;
    },

    /**
     * Public initializes a canvas element so that it can be used as canvas
     * element from now on. This is called automatically before the page is
     * loaded but if you are creating elements using createElement yuo need to
     * make sure this is called on the element.
     * @param el {HTMLElement} The canvas element to initialize.
     */
    initElement: function (el) {
      el = this.fixElement_(el);
      el.getContext = function () {
        if (this.context_) {
          this.context_.m_ = createMatrixIdentity();
          return this.context_;
        }
        return this.context_ = new CanvasRenderingContext2D_(this);
      };

      var self = this; //bind
      el.attachEvent("onpropertychange", function (e) {
        // we need to watch changes to width and height
        switch (e.propertyName) {
          case "width":
          case "height":
            // coord size changed?
            break;
        }
      });

      // if style.height is set

      var attrs = el.attributes;
      if (attrs.width && attrs.width.specified) {
        // TODO: use runtimeStyle and coordsize
        // el.getContext().setWidth_(attrs.width.nodeValue);
        el.style.width = attrs.width.nodeValue + "px";
      }
      if (attrs.height && attrs.height.specified) {
        // TODO: use runtimeStyle and coordsize
        // el.getContext().setHeight_(attrs.height.nodeValue);
        el.style.height = attrs.height.nodeValue + "px";
      }
      //el.getContext().setCoordsize_()
      
      return el;
    }
  };

  G_vmlCanvasManager_.init();

  // precompute "00" to "FF"
  var dec2hex = [];
  for (var i = 0; i < 16; i++) {
    for (var j = 0; j < 16; j++) {
      dec2hex[i * 16 + j] = i.toString(16) + j.toString(16);
    }
  }

  function createMatrixIdentity() {
    return [
      [1, 0, 0],
      [0, 1, 0],
      [0, 0, 1]
    ];
  }

  function matrixMultiply(m1, m2) {
    var result = createMatrixIdentity();

    for (var x = 0; x < 3; x++) {
      for (var y = 0; y < 3; y++) {
        var sum = 0;

        for (var z = 0; z < 3; z++) {
          sum += m1[x][z] * m2[z][y];
        }

        result[x][y] = sum;
      }
    }
    return result;
  }

  function copyState(o1, o2) {
    o2.fillStyle     = o1.fillStyle;
    o2.lineCap       = o1.lineCap;
    o2.lineJoin      = o1.lineJoin;
    o2.lineWidth     = o1.lineWidth;
    o2.miterLimit    = o1.miterLimit;
    o2.shadowBlur    = o1.shadowBlur;
    o2.shadowColor   = o1.shadowColor;
    o2.shadowOffsetX = o1.shadowOffsetX;
    o2.shadowOffsetY = o1.shadowOffsetY;
    o2.strokeStyle   = o1.strokeStyle;
  }

  function processStyle(styleString) {
    var str, alpha = 1;

    styleString = String(styleString);
    if (styleString.substring(0, 3) == "rgb") {
      var start = styleString.indexOf("(", 3);
      var end = styleString.indexOf(")", start + 1);
      var guts = styleString.substring(start + 1, end).split(",");

      str = "#";
      for (var i = 0; i < 3; i++) {
        str += dec2hex[parseInt(guts[i])];
      }

      if ((guts.length == 4) && (styleString.substr(3, 1) == "a")) {
        alpha = guts[3];
      }
    } else {
      str = styleString;
    }

    return [str, alpha];
  }

  function processLineCap(lineCap) {
    switch (lineCap) {
      case "butt":
        return "flat";
      case "round":
        return "round";
      case "square":
      default:
        return "square";
    }
  }

  /**
   * This class implements CanvasRenderingContext2D interface as described by
   * the WHATWG.
   * @param surfaceElement {HTMLElement} The element that the 2D context should
   * be associated with
   */
   function CanvasRenderingContext2D_(surfaceElement) {
    this.m_ = createMatrixIdentity();
    this.element_ = surfaceElement;

    this.mStack_ = [];
    this.aStack_ = [];
    this.currentPath_ = [];

    // Canvas context properties
    this.strokeStyle = "#000";
    this.fillStyle = "#ccc";

    this.lineWidth = 1;
    this.lineJoin = "miter";
    this.lineCap = "butt";
    this.miterLimit = 10;
    this.globalAlpha = 1;
  };

  var contextPrototype = CanvasRenderingContext2D_.prototype;
  contextPrototype.clearRect = function() {
    this.element_.innerHTML = "";
    this.currentPath_ = [];
  };

  contextPrototype.beginPath = function() {
    // TODO: Branch current matrix so that save/restore has no effect
    //       as per safari docs.

    this.currentPath_ = [];
  };

  contextPrototype.moveTo = function(aX, aY) {
    this.currentPath_.push({type: "moveTo", x: aX, y: aY});
  };

  contextPrototype.lineTo = function(aX, aY) {
    this.currentPath_.push({type: "lineTo", x: aX, y: aY});
  };

  contextPrototype.bezierCurveTo = function(aCP1x, aCP1y,
                                            aCP2x, aCP2y,
                                            aX, aY) {
    this.currentPath_.push({type: "bezierCurveTo",
                           cp1x: aCP1x,
                           cp1y: aCP1y,
                           cp2x: aCP2x,
                           cp2y: aCP2y,
                           x: aX,
                           y: aY});
  };

  contextPrototype.quadraticCurveTo = function(aCPx, aCPy, aX, aY) {
    // VML's qb produces different output to Firefox's
    // FF's behaviour seems to have changed in 1.5.0.1, check this
    this.bezierCurveTo(aCPx, aCPy, aCPx, aCPy, aX, aY);
  };

  contextPrototype.arc = function(aX, aY, aRadius,
                                  aStartAngle, aEndAngle, aClockwise) {
    if (!aClockwise) {
      var t = aStartAngle;
      aStartAngle = aEndAngle;
      aEndAngle = t;
    }

    var xStart = aX + (Math.cos(aStartAngle) * aRadius);
    var yStart = aY + (Math.sin(aStartAngle) * aRadius);

    var xEnd = aX + (Math.cos(aEndAngle) * aRadius);
    var yEnd = aY + (Math.sin(aEndAngle) * aRadius);

    this.currentPath_.push({type: "arc",
                           x: aX,
                           y: aY,
                           radius: aRadius,
                           xStart: xStart,
                           yStart: yStart,
                           xEnd: xEnd,
                           yEnd: yEnd});

  };

  contextPrototype.rect = function(aX, aY, aWidth, aHeight) {
    this.moveTo(aX, aY);
    this.lineTo(aX + aWidth, aY);
    this.lineTo(aX + aWidth, aY + aHeight);
    this.lineTo(aX, aY + aHeight);
    this.closePath();
  };

  contextPrototype.strokeRect = function(aX, aY, aWidth, aHeight) {
    // Will destroy any existing path (same as FF behaviour)
    this.beginPath();
    this.moveTo(aX, aY);
    this.lineTo(aX + aWidth, aY);
    this.lineTo(aX + aWidth, aY + aHeight);
    this.lineTo(aX, aY + aHeight);
    this.closePath();
    this.stroke();
  };

  contextPrototype.fillRect = function(aX, aY, aWidth, aHeight) {
    // Will destroy any existing path (same as FF behaviour)
    this.beginPath();
    this.moveTo(aX, aY);
    this.lineTo(aX + aWidth, aY);
    this.lineTo(aX + aWidth, aY + aHeight);
    this.lineTo(aX, aY + aHeight);
    this.closePath();
    this.fill();
  };

  contextPrototype.createLinearGradient = function(aX0, aY0, aX1, aY1) {
    var gradient = new CanvasGradient_("gradient");
    return gradient;
  };

  contextPrototype.createRadialGradient = function(aX0, aY0,
                                                   aR0, aX1,
                                                   aY1, aR1) {
    var gradient = new CanvasGradient_("gradientradial");
    gradient.radius1_ = aR0;
    gradient.radius2_ = aR1;
    gradient.focus_.x = aX0;
    gradient.focus_.y = aY0;
    return gradient;
  };

  contextPrototype.drawImage = function (image, var_args) {
    var dx, dy, dw, dh, sx, sy, sw, sh;
    var w = image.width;
    var h = image.height;

    if (arguments.length == 3) {
      dx = arguments[1];
      dy = arguments[2];
      sx = sy = 0;
      sw = dw = w;
      sh = dh = h;
    } else if (arguments.length == 5) {
      dx = arguments[1];
      dy = arguments[2];
      dw = arguments[3];
      dh = arguments[4];
      sx = sy = 0;
      sw = w;
      sh = h;
    } else if (arguments.length == 9) {
      sx = arguments[1];
      sy = arguments[2];
      sw = arguments[3];
      sh = arguments[4];
      dx = arguments[5];
      dy = arguments[6];
      dw = arguments[7];
      dh = arguments[8];
    } else {
      throw "Invalid number of arguments";
    }

    var d = this.getCoords_(dx, dy);

    var w2 = (sw / 2);
    var h2 = (sh / 2);

    var vmlStr = [];

    // For some reason that I've now forgotten, using divs didn't work
    vmlStr.push(' <g_vml_:group',
                ' coordsize="100,100"',
                ' coordorigin="0, 0"' ,
                ' style="width:100px;height:100px;position:absolute;');

    // If filters are necessary (rotation exists), create them
    // filters are bog-slow, so only create them if abbsolutely necessary
    // The following check doesn't account for skews (which don't exist
    // in the canvas spec (yet) anyway.

    if (this.m_[0][0] != 1 || this.m_[0][1]) {
      var filter = [];

      // Note the 12/21 reversal
      filter.push("M11='", this.m_[0][0], "',",
                  "M12='", this.m_[1][0], "',",
                  "M21='", this.m_[0][1], "',",
                  "M22='", this.m_[1][1], "',",
                  "Dx='", d.x, "',",
                  "Dy='", d.y, "'");

      // Bounding box calculation (need to minimize displayed area so that
      // filters don't waste time on unused pixels.
      var max = d;
      var c2 = this.getCoords_(dx+dw, dy);
      var c3 = this.getCoords_(dx, dy+dh);
      var c4 = this.getCoords_(dx+dw, dy+dh);

      max.x = Math.max(max.x, c2.x, c3.x, c4.x);
      max.y = Math.max(max.y, c2.y, c3.y, c4.y);

      vmlStr.push(" padding:0 ", Math.floor(max.x), "px ", Math.floor(max.y),
                  "px 0;filter:progid:DXImageTransform.Microsoft.Matrix(",
                  filter.join(""), ", sizingmethod='clip');")
    } else {
      vmlStr.push(" top:", d.y, "px;left:", d.x, "px;")
    }

    vmlStr.push(' ">' ,
                '<g_vml_:image src="', image.src, '"',
                ' style="width:', dw, ';',
                ' height:', dh, ';"',
                ' cropleft="', sx / w, '"',
                ' croptop="', sy / h, '"',
                ' cropright="', (w - sx - sw) / w, '"',
                ' cropbottom="', (h - sy - sh) / h, '"',
                ' />',
                '</g_vml_:group>');

    this.element_.insertAdjacentHTML("BeforeEnd",
                                    vmlStr.join(""));
  };

  contextPrototype.stroke = function(aFill) {
    var lineStr = [];
    var lineOpen = false;
    var a = processStyle(aFill ? this.fillStyle : this.strokeStyle);
    var color = a[0];
    var opacity = a[1] * this.globalAlpha;

    lineStr.push('<g_vml_:shape',
                 ' fillcolor="', color, '"',
                 ' filled="', Boolean(aFill), '"',
                 ' style="position:absolute;width:10;height:10;"',
                 ' coordorigin="0 0" coordsize="10 10"',
                 ' stroked="', !aFill, '"',
                 ' strokeweight="', this.lineWidth, '"',
                 ' strokecolor="', color, '"',
                 ' path="');

    var newSeq = false;
    var min = {x: null, y: null};
    var max = {x: null, y: null};

    for (var i = 0; i < this.currentPath_.length; i++) {
      var p = this.currentPath_[i];

      if (p.type == "moveTo") {
        lineStr.push(" m ");
        var c = this.getCoords_(p.x, p.y);
        lineStr.push(Math.floor(c.x), ",", Math.floor(c.y));
      } else if (p.type == "lineTo") {
        lineStr.push(" l ");
        var c = this.getCoords_(p.x, p.y);
        lineStr.push(Math.floor(c.x), ",", Math.floor(c.y));
      } else if (p.type == "close") {
        lineStr.push(" x ");
      } else if (p.type == "bezierCurveTo") {
        lineStr.push(" c ");
        var c = this.getCoords_(p.x, p.y);
        var c1 = this.getCoords_(p.cp1x, p.cp1y);
        var c2 = this.getCoords_(p.cp2x, p.cp2y);
        lineStr.push(Math.floor(c1.x), ",", Math.floor(c1.y), ",",
                     Math.floor(c2.x), ",", Math.floor(c2.y), ",",
                     Math.floor(c.x), ",", Math.floor(c.y));
      } else if (p.type == "arc") {
        lineStr.push(" ar ");
        var c  = this.getCoords_(p.x, p.y);
        var cStart = this.getCoords_(p.xStart, p.yStart);
        var cEnd = this.getCoords_(p.xEnd, p.yEnd);

        // TODO: FIX (matricies (scale+rotation) now buggered this up)
        //       VML arc also doesn't seem able to do rotated non-circular
        //       arcs without parent grouping.
        var absXScale = this.m_[0][0];
        var absYScale = this.m_[1][1];

        lineStr.push(Math.floor(c.x - absXScale * p.radius), ",",
                     Math.floor(c.y - absYScale * p.radius), " ",
                     Math.floor(c.x + absXScale * p.radius), ",",
                     Math.floor(c.y + absYScale * p.radius), " ",
                     Math.floor(cStart.x), ",", Math.floor(cStart.y), " ",
                     Math.floor(cEnd.x), ",", Math.floor(cEnd.y));
      }


      // TODO: Following is broken for curves due to
      //       move to proper paths.

      // Figure out dimensions so we can do gradient fills
      // properly
      if(c) {
        if (min.x == null || c.x < min.x) {
          min.x = c.x;
        }
        if (max.x == null || c.x > max.x) {
          max.x = c.x;
        }
        if (min.y == null || c.y < min.y) {
          min.y = c.y;
        }
        if (max.y == null || c.y > max.y) {
          max.y = c.y;
        }
      }
    }
    lineStr.push(' ">');

    if (typeof this.fillStyle == "object") {
      var focus = {x: "50%", y: "50%"};
      var width = (max.x - min.x);
      var height = (max.y - min.y);
      var dimension = (width > height) ? width : height;

      focus.x = Math.floor((this.fillStyle.focus_.x / width) * 100 + 50) + "%";
      focus.y = Math.floor((this.fillStyle.focus_.y / height) * 100 + 50) + "%";

      var colors = [];

      // inside radius (%)
      if (this.fillStyle.type_ == "gradientradial") {
        var inside = (this.fillStyle.radius1_ / dimension * 100);

        // percentage that outside radius exceeds inside radius
        var expansion = (this.fillStyle.radius2_ / dimension * 100) - inside;
      } else {
        var inside = 0;
        var expansion = 100;
      }

      var insidecolor = {offset: null, color: null};
      var outsidecolor = {offset: null, color: null};

      // We need to sort 'colors' by percentage, from 0 > 100 otherwise ie
      // won't interpret it correctly
      this.fillStyle.colors_.sort(function (cs1, cs2) {
        return cs1.offset - cs2.offset;
      });

      for (var i = 0; i < this.fillStyle.colors_.length; i++) {
        var fs = this.fillStyle.colors_[i];

        colors.push( (fs.offset * expansion) + inside, "% ", fs.color, ",");

        if (fs.offset > insidecolor.offset || insidecolor.offset == null) {
          insidecolor.offset = fs.offset;
          insidecolor.color = fs.color;
        }

        if (fs.offset < outsidecolor.offset || outsidecolor.offset == null) {
          outsidecolor.offset = fs.offset;
          outsidecolor.color = fs.color;
        }
      }
      colors.pop();

      lineStr.push('<g_vml_:fill',
                   ' color="', outsidecolor.color, '"',
                   ' color2="', insidecolor.color, '"',
                   ' type="', this.fillStyle.type_, '"',
                   ' focusposition="', focus.x, ', ', focus.y, '"',
                   ' colors="', colors.join(""), '"',
                   ' opacity="', opacity, '" />');
    } else if (aFill) {
      lineStr.push('<g_vml_:fill color="', color, '" opacity="', opacity, '" />');
    } else {
      lineStr.push(
        '<g_vml_:stroke',
        ' opacity="', opacity,'"',
        ' joinstyle="', this.lineJoin, '"',
        ' miterlimit="', this.miterLimit, '"',
        ' endcap="', processLineCap(this.lineCap) ,'"',
        ' weight="', this.lineWidth, 'px"',
        ' color="', color,'" />'
      );
    }

    lineStr.push("</g_vml_:shape>");

    this.element_.insertAdjacentHTML("beforeEnd", lineStr.join(""));

    //this.currentPath_ = [];
  };

  contextPrototype.fill = function() {
    this.stroke(true);
  }

  contextPrototype.closePath = function() {
    this.currentPath_.push({type: "close"});
  };

  /**
   * @private
   */
  contextPrototype.getCoords_ = function(aX, aY) {
    return {
      x: (aX * this.m_[0][0] + aY * this.m_[1][0] + this.m_[2][0]),
      y: (aX * this.m_[0][1] + aY * this.m_[1][1] + this.m_[2][1])
    }
  };

  contextPrototype.save = function() {
    var o = {};
    copyState(this, o);
    this.aStack_.push(o);
    this.mStack_.push(this.m_);
    this.m_ = matrixMultiply(createMatrixIdentity(), this.m_);
  };

  contextPrototype.restore = function() {
    copyState(this.aStack_.pop(), this);
    this.m_ = this.mStack_.pop();
  };

  contextPrototype.translate = function(aX, aY) {
    var m1 = [
      [1,  0,  0],
      [0,  1,  0],
      [aX, aY, 1]
    ];

    this.m_ = matrixMultiply(m1, this.m_);
  };

  contextPrototype.rotate = function(aRot) {
    var c = Math.cos(aRot);
    var s = Math.sin(aRot);

    var m1 = [
      [c,  s, 0],
      [-s, c, 0],
      [0,  0, 1]
    ];

    this.m_ = matrixMultiply(m1, this.m_);
  };

  contextPrototype.scale = function(aX, aY) {
    var m1 = [
      [aX, 0,  0],
      [0,  aY, 0],
      [0,  0,  1]
    ];

    this.m_ = matrixMultiply(m1, this.m_);
  };

  /******** STUBS ********/
  contextPrototype.clip = function() {
    // TODO: Implement
  };

  contextPrototype.arcTo = function() {
    // TODO: Implement
  };

  contextPrototype.createPattern = function() {
    return new CanvasPattern_;
  };

  // Gradient / Pattern Stubs
  function CanvasGradient_(aType) {
    this.type_ = aType;
    this.radius1_ = 0;
    this.radius2_ = 0;
    this.colors_ = [];
    this.focus_ = {x: 0, y: 0};
  }

  CanvasGradient_.prototype.addColorStop = function(aOffset, aColor) {
    aColor = processStyle(aColor);
    this.colors_.push({offset: 1-aOffset, color: aColor});
  };

  function CanvasPattern_() {}

  // set up externs
  G_vmlCanvasManager = G_vmlCanvasManager_;
  CanvasRenderingContext2D = CanvasRenderingContext2D_;
  CanvasGradient = CanvasGradient_;
  CanvasPattern = CanvasPattern_;

})();

} // if

/******************************************************************************
 *
 * kaMap! javascript code
 *
 * $Id: kaMap.js,v 1.61 2006/01/19 14:38:09 pspencer Exp $
 *
 ******************************************************************************
 *
 * Copyright (c) 2005 DM Solutions Group Inc.
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 * Modified by Andrea Cappugi and Lorenzo Becchi toload to track layer visibility at diferent
 * scale, to load only visible layer
 * 22/12/2005
 *****************************************************************************/


var LAYER_ALGO = "RANDOM"; // can be CENTER or RANDOM. Any other value will use the old code.



/**
 * kaMap! events
 */
var gnLastEventId = 0;
var KAMAP_ERROR = gnLastEventId ++;
var KAMAP_WARNING = gnLastEventId ++;
var KAMAP_NOTICE = gnLastEventId++;
var KAMAP_INITIALIZED = gnLastEventId ++;
var KAMAP_MAP_INITIALIZED = gnLastEventId ++;
var KAMAP_EXTENTS_CHANGED = gnLastEventId ++;
var KAMAP_SCALE_CHANGED = gnLastEventId ++;
var KAMAP_SCALE_CHANGE_START = gnLastEventId ++; 
var KAMAP_LAYERS_CHANGED = gnLastEventId ++;
var KAMAP_DRAG = gnLastEventId ++;
var KAMAP_DRAG_START = gnLastEventId ++;
var KAMAP_DRAG_END = gnLastEventId ++;
var KAMAP_MOVE = gnLastEventId ++;
var KAMAP_MOVE_START = gnLastEventId ++;
var KAMAP_CONTEXT_MENU = gnLastEventId ++;

/******************************************************************************
 * kaMap main class
 *
 * construct a new kaMap instance.  Pass the id of the div to put the kaMap in
 *
 * this class is the main API for any application.  Only use the functions
 * provided by this API to ensure everything functions correctly
 *
 * szID - string, the id of a div to put the kaMap! into
 *
 *****************************************************************************/
function kaMap( szID )
{
    this.isCSS = false;
    this.isW3C = false;
    this.isIE4 = false;
    this.isNN4 = false;
    this.isIE6CSS = false;

	if (document.images) {
        this.isCSS = (document.body && document.body.style) ? true : false;
        this.isW3C = (this.isCSS && document.getElementById) ? true : false;
        this.isIE4 = (this.isCSS && document.all) ? true : false;
        this.isNN4 = (document.layers) ? true : false;
        this.isIE6CSS = (document.compatMode && document.compatMode.indexOf("CSS1") >= 0) ? true : false;
    }
    
    this.domObj = this.getRawObject( szID );
    this.domObj.style.overflow = 'hidden';
    
    this.hideLayersOnMove = false;
    //if true layer not checked are loaded if false aren't loaded
    this.loadUnchecked=false;

   /**
     * initialization states
     * 0 - not initialized
     * 1 - initializing
     * 2 - initialized
     */
    this.initializationState = 0;

    //track mouse down events
    this.bMouseDown = false;

    //track last recorded mouse position
    this.lastx = 0;
    this.lasty = 0;

    //keep a reference to the inside layer since we use it a lot
    this.theInsideLayer = null;

    //viewport width and height are used in many calculations
    this.viewportWidth = safeParseInt(this.domObj.style.width);
    this.viewportHeight = safeParseInt(this.domObj.style.height);

    //track amount the inside layer has moved to help in wrapping images
    this.xOffset = 0;
    this.yOffset = 0;

    //track current origin offset value
    this.xOrigin = 0;
    this.yOrigin = 0;

    //the name of the current map
    this.currentMap = '';

    //the current width and height in tiles
    this.nWide = 0;
    this.nHigh = 0;

    //current top and left are tracked when the map moves
    //to start the map at some offset, these would be set to
    //the appropriate pixel value.
    this.nCurrentTop = 0; //null;
    this.nCurrentLeft = 0; //null;

    //keep a live reference to aPixel to help with caching problems - hish
    this.aPixel = new Image(1,1);
    // make sure aPixel is never used. p9 hack
    //this.aPixel.src = 'images/a_pixel.gif'; // p9 hack

    //error stack for tracking images that have failed to load
    this.imgErrors = new Array();

    //an array of available maps
    this.aMaps = new Array();

    //tile size and buffer size determine how many tiles to create
    this.tileWidth = null;
    this.tileHeight = null;
    this.nBuffer = 1;

    this.baseURL = '';
    
    //size of a pixel, geographically - assumed to be square
    this.cellSize = null;

    //image id counter - helps with reloading failed images
    this.gImageID = 0;

    //event manager
    this.eventManager = new _eventManager();

    //slider stuff
    this.as=slideid=null;
    this.accelerationFactor=1;
    this.pixelsPerStep = 30;
    this.timePerStep = 25;

    // animated zoom stuff
    this.slideSteps = 3; // steps in the slide
    this.animatedZoomingIntervalID = null;
    this.animatedZoom = false;

    // CUSTOM: Allow kamap to request tiles as urls to images not tile.php.  (speed up).
    // Set this in config.php
    this.isDirectTileAccess = null;
 
    //this is a convenience to allow redirecting the client code to a server
    //other than the one that this file was loaded from.  This may not
    //work depending on security settings, except for loading tiles since
    //those come directly from a php script instead of an XmlHttpRequest.
    //
    //by default, if this is empty, it loads from the same site as the
    //page loaded from.  If set, it should be a full http:// reference to the
    //directory in which init.php, tile.php and the other scripts are located.
    this.server = '';

    // attach to _layer instead
    // this.tileServers = new kaServers();

    //similarly, this is the global initialization script called once per page
    //load ... the result of this script tell the client what other scripts
    //are used for the other functions
    this.init = "init.pl";

    //these are the values that need to be initialized by the init script
    this.tileURL = null;

    this.aObjects = [];
    this.aCanvases = [];
    this.layersHidden = false;

    this.aTools = [];

    /* register the known events */
    for (var i=0; i<gnLastEventId; i++)
    {
        this.registerEventID( i );
    }
    this.createLayers();

	// CUSTOM: determines if the same-source javascript policy is bypassed when making asynchronous calls to the server
	// DEPRECATED: don't need this for now as async init has been worked around
	this.shouldBypassSameSourcePolicy = false;

}

//CUSTOM: function for handling multiple tile servers
kaMap.prototype.setTileServers = function(servs)
{
	this.tileServers.setServers(servs);
}

kaMap.prototype.seekLayer = function(doc, name) {
    var theObj;
    for (var i = 0; i < doc.layers.length; i++) {
        if (doc.layers[i].name == name) {
            theObj = doc.layers[i];
            break;
        }
        // dive into nested layers if necessary
        if (doc.layers[i].document.layers.length > 0) {
            theObj = this.seekLayer(document.layers[i].document, name);
        }
    }
    return theObj;
}

// Convert object name string or object reference
// into a valid element object reference
kaMap.prototype.getRawObject = function(obj) {
    var theObj;
    if (typeof obj == "string") {
        if (this.isW3C) {
            theObj = document.getElementById(obj);
        } else if (this.isIE4) {
            theObj = document.all(obj);
        } else if (this.isNN4) {
            theObj = seekLayer(document, obj);
        }
    } else {
        // pass through object reference
        theObj = obj;
    }
    return theObj;
}

// Convert object name string or object reference
// into a valid style (or NN4 layer) reference
kaMap.prototype.getObject = function(obj) {
    var theObj = this.getRawObject(obj);
    if (theObj && this.isCSS) {
        theObj = theObj.style;
    }
    return theObj;
}

// Retrieve the rendered width of an element
kaMap.prototype.getObjectWidth = function(obj)  {
    var elem = this.getRawObject(obj);
    var result = 0;
    if (elem.offsetWidth) {
        result = elem.offsetWidth;
    } else if (elem.clip && elem.clip.width) {
        result = elem.clip.width;
    } else if (elem.style && elem.style.pixelWidth) {
        result = elem.style.pixelWidth;
    }
    return parseInt(result);
}

// Retrieve the rendered height of an element
kaMap.prototype.getObjectHeight = function(obj)  {
    var elem = this.getRawObject(obj);
    var result = 0;
    if (elem.offsetHeight) {
        result = elem.offsetHeight;
    } else if (elem.clip && elem.clip.height) {
        result = elem.clip.height;
    } else if (elem.style && elem.style.pixelHeight) {
        result = elem.style.pixelHeight;
    }
    return parseInt(result);
}

/**
 * kaMap.zoomTo( lon, lat [, scale] )
 *
 * zoom to some geographic point (in current projection) and optionally scale
 *
 * lon - the x coordinate to zoom to
 * lat - the y coordinate to zoom to
 * scale - optional. The scale to use
 */
kaMap.prototype.zoomTo = function( cgX, cgY ) {
    var oMap = this.getCurrentMap();
    var inchesPerUnit = new Array(1, 12, 63360.0, 39.3701, 39370.1, 4374754);
    var newScale;
    var bScaleChanged = false;
    if (arguments.length == 3)
    {
        newScale = arguments[2];
        bScaleChanged = (newScale != this.getCurrentScale());
        if(bScaleChanged) this.triggerEvent(KAMAP_SCALE_CHANGE_START, newScale );
	// check for zoom animation (animation only occurs one zoom in or out)
	if (this.animatedZoom) {
		if ((this.aMaps[this.currentMap].aScales[this.aMaps[this.currentMap].currentScale+1] && newScale == this.aMaps[this.currentMap].aScales[this.aMaps[this.currentMap].currentScale+1]) || (this.aMaps[this.currentMap].aScales[this.aMaps[this.currentMap].currentScale-1] && newScale == this.aMaps[this.currentMap].aScales[this.aMaps[this.currentMap].currentScale-1])) {
			this.zoomTo(cgX, cgY);
			this.zoomToScale(newScale);
			return;
		}
	}
    }
    else
    {
        newScale = this.getCurrentScale();
    }
    
    this.cellSize = newScale/(oMap.resolution * inchesPerUnit[oMap.units]);
    var nFactor = oMap.zoomToScale( newScale );
    this.setMapLayers();
    var cpX = cgX / this.cellSize;
    var cpY = cgY / this.cellSize;

    var vpLeft = Math.round(cpX - this.viewportWidth/2);
    var vpTop = Math.round(cpY + this.viewportHeight/2);

    //figure out which tile the center point lies on
    var cTileX = Math.floor(cpX/this.tileWidth)*this.tileWidth;
    var cTileY = Math.floor(cpY/this.tileHeight)*this.tileHeight;

    //figure out how many tiles left and up we need to move to lay out from
    //the top left and have the top/left image off screen (or partially)
    var nTilesLeft = Math.ceil(this.viewportWidth/(2*this.tileWidth))*this.tileWidth;
    var nTilesUp = Math.ceil(this.viewportHeight/(2*this.tileHeight))*this.tileHeight;

    this.nCurrentLeft = cTileX - nTilesLeft;
    this.nCurrentTop = -1*(cTileY + nTilesUp);

    this.xOrigin = this.nCurrentLeft;
    this.yOrigin = this.nCurrentTop;

    this.theInsideLayer.style.left = -1*(vpLeft - this.xOrigin) + "px";
    this.theInsideLayer.style.top = (vpTop + this.yOrigin) + "px";

    var layers = oMap.getLayers();
    for( var k=0; k<layers.length; k++)
	init_layer(this, layers[k]); // p9 hack
    this.checkWrap( );
    this.updateObjects();
    if (bScaleChanged) this.triggerEvent( KAMAP_SCALE_CHANGED, this.getCurrentScale() );
    this.triggerEvent(KAMAP_MOVE);
    this.triggerEvent( KAMAP_EXTENTS_CHANGED, this.getGeoExtents() );
}

/**
 * kaMap.zoomToExtents( minx, miny, maxx, maxy )
 *
 * best fit zoom to extents.  Center of extents will be in the center of the
 * view and the extents will be contained within the view at the closest scale
 * available above the scale these extents represent
 *
 * minx, miny, maxx, maxy - extents in units of current projection.
 */
kaMap.prototype.zoomToExtents = function(minx, miny, maxx, maxy)
{

    /* calculate new scale from extents and viewport, then find closest
     * scale and calculate new extents from centerpoint and scale.  Then
     * move theInsideLayer and all the images to show that centerpoint at
     * the center of the view at the given scale
     */
    var inchesPerUnit = new Array(1, 12, 63360.0, 39.3701, 39370.1, 4374754);
    var oMap = this.getCurrentMap();

    //the geographic center - where we want to end up
    var cgX = (maxx+minx)/2;
    var cgY = (maxy+miny)/2;

    var tmpCellSizeX = (maxx - minx)/this.viewportWidth;
    var tmpCellSizeY = (maxy - miny)/this.viewportHeight;
    var tmpCellSize = Math.max( tmpCellSizeX, tmpCellSizeY );

    var tmpScale = tmpCellSize * oMap.resolution * inchesPerUnit[oMap.units];
    var newScale = oMap.aScales[0];
    for (var i=1; i<oMap.aScales.length; i++)
    {
        if (tmpScale >= oMap.aScales[i])
        {
            break;
        }
        newScale = oMap.aScales[i];
    }

    // return scale if argument specified
    if (arguments[4])
    	return newScale;
    
    this.triggerEvent( KAMAP_SCALE_CHANGE_START, newScale ); 
    
    //now newScale has our new scale size
    this.cellSize = newScale/(oMap.resolution * inchesPerUnit[oMap.units]);
    var nFactor = oMap.zoomToScale( newScale );
    this.setMapLayers();
    var cpX = cgX / this.cellSize;
    var cpY = cgY / this.cellSize;

    var vpLeft = Math.round(cpX - this.viewportWidth/2);
    var vpTop = Math.round(cpY + this.viewportHeight/2);


    //figure out which tile the center point lies on
    var cTileX = Math.floor(cpX/this.tileWidth)*this.tileWidth;
    var cTileY = Math.floor(cpY/this.tileHeight)*this.tileHeight;


    //figure out how many tiles left and up we need to move to lay out from
    //the top left and have the top/left image off screen (or partially)
    var nTilesLeft = Math.ceil(this.viewportWidth/(2*this.tileWidth))*this.tileWidth;
    var nTilesUp = Math.ceil(this.viewportHeight/(2*this.tileHeight))*this.tileHeight;

    this.nCurrentLeft = cTileX - nTilesLeft;
    this.nCurrentTop = -1*(cTileY + nTilesUp);

    this.xOrigin = this.nCurrentLeft;
    this.yOrigin = this.nCurrentTop;

    this.theInsideLayer.style.left = -1*(vpLeft - this.xOrigin) + "px";
    this.theInsideLayer.style.top = (vpTop + this.yOrigin) + "px";

    var layers = oMap.getLayers();
    for( var k=0; k<layers.length; k++)
    {
	init_layer(this, layers[k]);
    }
    this.checkWrap( );
    this.updateObjects();
    this.triggerEvent( KAMAP_SCALE_CHANGED, this.getCurrentScale() );
    this.triggerEvent( KAMAP_EXTENTS_CHANGED, this.getGeoExtents() );
}

/**
 * kaMap.createDrawingCanvas( idx )
 *
 * create a layer on which objects can be drawn (such as point objects)
 *
 * idx - int, the z-index of the layer.  Should be < 100 but above the map
 * layers.
 */
kaMap.prototype.createDrawingCanvas = function( idx )
{

    var d = document.createElement( 'div' );
    d.style.position = 'absolute';
    d.style.left = '0px';
    d.style.top = '0px';
    d.style.width= '3000px';
    d.style.height = '3000px';
    d.style.zIndex = idx;
    this.theInsideLayer.appendChild( d );
    this.aCanvases.push( d );
    d.kaMap = this;
    return d;
}

kaMap.prototype.removeDrawingCanvas = function( canvas )
{

    for (var i=0; i<this.aCanvases.length;i++)
    {
        if (this.aCanvases[i] == canvas)
        {
            this.aCanvases.splice( i, 1 );
        }
    }
    this.theInsideLayer.removeChild(canvas);
    canvas.kaMap = null;
    canvas = null;
    return true;
}


/**
 * kaMap.addObjectGeo( canvas, lon, lat, obj )
 *
 * add an object to a drawing layer and position it at the given geographic
 * position.  This is defined as being in the projection of the map.
 *
 * TODO: possibly add ability to call a reprojection service (xhr request?) to
 * convert lon/lat into the current coordinate system if not lon/lat.
 *
 * canvas - object, the drawing canvas to add this object to
 * x - int, the x position in pixels
 * y - int, the y position in pixels
 * obj - object, the object to add (an img, div etc)
 *
 * returns true
 */
kaMap.prototype.addObjectGeo = function( canvas, lon, lat, obj )
{

    obj.lon = lon;
    obj.lat = lat;
    var aPix = this.geoToPix( lon, lat );
    return this.addObjectPix( canvas, aPix[0], aPix[1], obj );
}

/**
 * kaMap.addObjectPix( canvas, x, y, obj )
 *
 * add an object to the map canvas and position it at the given pixel position.
 * The position should not include the xOrigin/yOrigin offsets
 *
 * canvas - object, the canvas to add this object to
 * x - int, the x position in pixels
 * y - int, the y position in pixels
 * obj - object, the object to add (an img, div etc)
 *
 * returns true;
 */
kaMap.prototype.addObjectPix = function( canvas, x, y, obj )
{

    var xOffset = (obj.xOffset) ? obj.xOffset : 0;
    var yOffset = (obj.yOffset) ? obj.yOffset : 0;
    var top = (y - this.yOrigin + yOffset);
    var left = (x - this.xOrigin + xOffset);
    obj.style.position = 'absolute';
	if (top != '-Infinity') obj.style.top = top + "px";
	if (left != '-Infinity') obj.style.left = left + "px";
    obj.canvas = canvas;
    canvas.appendChild( obj );
    this.aObjects.push( obj );

    return true;
}

/**
 * kaMap.shiftObject( x, y, obj )
 *
 * move an object by a pixel amount
 *
 * x - int, the number of pixels in the x direction to move the object
 * y - int, the number of pixels in the y direction to move the object
 * obj - object, the object to move
 *
 * returns true
 */
kaMap.prototype.shiftObject = function( x, y, obj )
{

    var top = safeParseInt(obj.style.top);
    var left = safeParseInt(obj.style.left);

    obj.style.top = (top + y) + "px";
    obj.style.left = (left + x) + "px";

    return true;
}

/**
 * kaMap.removeObject( obj )
 *
 * removes an object previously added with one of the addObjectXxx calls
 *
 * obj - object, an object that has been previously added, or null to remove
 *       all objects
 *
 * returns true if the object was removed, false otherwise (i.e. if it was
 * never added).
 */
kaMap.prototype.removeObject = function( obj )
{
    for (var i=0; i<this.aObjects.length; i++)
    {
        if (this.aObjects[i] == obj || obj == null)
        {
            if (!obj)
                obj = this.aObjects[i];
            if (obj.canvas)
            {
                obj.canvas.removeChild( obj );
                obj.canvas = null;
		obj = null;
            }
            this.aObjects.splice(i,1);
            return true;
        }
    }
    return false;
}

/**
 * kaMap.centerObject( obj )
 *
 * slides the map to place the object at the center of the map
 *
 * obj - object, an object previously added to the map
 *
 * returns true
 */
kaMap.prototype.centerObject = function(obj)
{

    var vpX = -safeParseInt(this.theInsideLayer.style.left) + this.viewportWidth/2;
    var vpY = -safeParseInt(this.theInsideLayer.style.top) + this.viewportHeight/2;

    var xOffset = (obj.xOffset)?obj.xOffset:0;
    var yOffset = (obj.yOffset)?obj.yOffset:0;

    var dx = safeParseInt(obj.style.left) - xOffset- vpX;
    var dy = safeParseInt(obj.style.top) - yOffset - vpY;

    this.slideBy(-dx, -dy);
    return true;
}

/**
 * kaMap.geoToPix( gX, gY )
 *
 * convert geographic coordinates into pixel coordinates.  Note this does not
 * adjust for the current origin offset that is used to adjust the actual
 * pixel location of the tiles and other images
 *
 * gX - float, the x coordinate in geographic units of the active projection
 * gY - float, the y coordinate in geographic units of the active projection
 *
 * returns an array of pixel coordinates with element 0 being the x and element
 * 1 being the y coordinate.
 */
kaMap.prototype.geoToPix = function( gX, gY )
{

    var pX = gX / this.cellSize;
    var pY = -1 * gY / this.cellSize;
    return [Math.floor(pX), Math.floor(pY)];
}

/**
 * kaMap.pixToGeo( pX, pY [, bAdjust] )
 *
 * convert pixel coordinates into geographic coordinates.  This can optionally
 * adjust for the pixel offset by passing true as the third argument
 *
 * pX - int, the x coordinate in pixel units
 * pY - int, the y coordinate in pixel units
 *
 * returns an array of geographic coordinates with element 0 being the x
 * and element 1 being the y coordinate.
 */
kaMap.prototype.pixToGeo = function( pX, pY )
{

    var bAdjust = (arguments.length == 3 && arguments[2]) ? true : false;

    if (bAdjust)
    {
        pX = pX + this.xOrigin;
        pY = pY + this.yOrigin;
    }
    var gX = -1 * pX * this.cellSize;
    var gY = pY * this.cellSize;
    return [gX, gY];
}

/**
 * kaMap.initialize( [szMap] )
 *
 * main initialization of kaMap.  This must be called after page load and
 * should only be called once (i.e. on page load).  It does not perform
 * intialization synchronously.  This means that the function will return
 * before initialization is complete.  To determine when initialization is
 * complete, the calling application must register for the KAMAP_INITIALIZED
 * event.
 *
 * szMap - string, optional, the name of a map to initialize by default.  If
 *         not set, use the default configuration map file.
 *
 * returns true
 */
kaMap.prototype.initialize = function()
{
	if (this.initializationState == 2)
    {
        this.triggerEvent( KAMAP_ERROR, 'ERROR: ka-Map! is already initialized!' );
        return false;
    }
    else if (this.intializationState == 1)
    {
        this.triggerEvent( KAMAP_WARNING, 'WARNING: ka-Map! is currently initializing ... wait for the KAMAP_INITIALIZED event to be triggered.' );
        return false;
    }
    
    this.initializationState = 1;

	// CUSTOM: just call the init code if it was already retrieved
	// this is so that we don't have to do an async call to initalize
	if (arguments.length == 0 && this.initializationCode != null)
	{
		this.initializeCallback(this.initializationCode);
		return true;
	}

    /* call initialization script on the server */
    var szURL = this.server+this.init;
    
    var sep = (this.init.indexOf("?") == -1) ? "?" : "&";
    
    if (arguments.length > 0 && arguments[0] != '')
    {
        szURL = szURL + sep + "map="+ arguments[0];
        sep = "&";
    }
    if (arguments.length > 1 && arguments[1] != '')
    {
        szURL = szURL + sep + "extents="+ arguments[1];
        sep = "&";
    }
    if (arguments.length > 2 && arguments[2] != '')
    {
        szURL = szURL + sep + "centerPoint="+ arguments[2];
        sep = "&";
    }

	// CUSTOM: use bypass to get around security issue in FF
	// DEPRECATED: no need for initialization call
    //if (this.shouldBypassSameSourcePolicy == true)
	//{
		//bypassCall(this.server, this.init, this.id, 'initializeCallback');
	//}
	//else
	//{
		call(szURL, this, this.initializeCallback);
	//}

    return true;
}

/**
 * hidden function on callback from init.php
 */
kaMap.prototype.initializeCallback = function( szInit )
{
    // szInit contains /**/ if it worked, or some php error otherwise
    if (szInit.substr(0, 1) != "/")
    {
        this.triggerEvent( KAMAP_ERROR, 'ERROR: ka-Map! initialization '+
                          'failed on the server.  Message returned was:\n' +
                          szInit);
        return false;
    }
    
    eval(szInit);

    //this.xOrigin = this.nCurrentLeft;
    //this.yOrigin = this.nCurrentTop;

    this.triggerEvent( KAMAP_INITIALIZED );
    
    this.initializationState = 2;
}

/**
 * kaMap.setBackgroundColor( color )
 *
 * call this to set a background color for the inside layer.  This color
 * shows through any transparent areas of the map.  This is primarily
 * intended to be used by the initializeMap callback function to set the
 * background to the background color in the map file.
 *
 * color: string, a valid HTML color string
 *
 * returns true;
 */
kaMap.prototype.setBackgroundColor = function( color )
{

    this.domObj.style.backgroundColor = color;
    return true;
}

/**
 * hidden method of kaMap to initialize all the various layers needed by
 * kaMap to draw and move the map image.
 */
kaMap.prototype.createLayers = function()
{

    this.theInsideLayer = document.createElement('div');
    this.theInsideLayer.id = 'theInsideLayer';
    this.theInsideLayer.style.position = 'absolute';
    this.theInsideLayer.style.left = '0px';
    this.theInsideLayer.style.top = '0px';
    this.theInsideLayer.style.zIndex = '1';
    this.theInsideLayer.kaMap = this;
    if (this.currentTool)
        this.theInsideLayer.style.cursor = this.currentTool.cursor;
    this.domObj.appendChild(this.theInsideLayer);

    this.domObj.kaMap = this;
    this.theInsideLayer.onmousedown = kaMap_onmousedown;
    this.theInsideLayer.onmouseup = kaMap_onmouseup;
    this.theInsideLayer.onmousemove = kaMap_onmousemove;
    this.theInsideLayer.ontouchstart = kaMap_onmousedown;
    this.theInsideLayer.ontouchend = kaMap_onmouseup;
    this.theInsideLayer.ontouchmove = kaMap_onmousemove;
    this.theInsideLayer.onmouseover = kaMap_onmouseover;
    this.domObj.onmouseout = kaMap_onmouseout;
    this.theInsideLayer.onkeypress = kaMap_onkeypress;
    this.theInsideLayer.ondblclick = kaMap_ondblclick;
    this.theInsideLayer.onclick = kaMap_onclick;
    this.theInsideLayer.oncontextmenu = kaMap_oncontextmenu;
    this.theInsideLayer.onmousewheel = kaMap_onmousewheel;
    if (window.addEventListener && navigator.product && navigator.product == "Gecko")
    {
        this.domObj.addEventListener( "DOMMouseScroll", kaMap_onmousewheel, false );
    }
    
    //this is to prevent problems in IE
    this.theInsideLayer.ondragstart = new Function([], 'var e=e?e:event;e.cancelBubble=true;e.returnValue=false;return false;');
}

/**
 * internal function
 * update the layer URLs based on their current positions
 */

kaMap.prototype.initializeLayers = function(nFactor)
{

    var deltaMouseX = this.nCurrentLeft + safeParseInt(this.theInsideLayer.style.left) - this.xOrigin;
    var deltaMouseY = this.nCurrentTop + safeParseInt(this.theInsideLayer.style.top) - this.yOrigin;

    var vpTop = this.nCurrentTop - deltaMouseY;
    var vpLeft = this.nCurrentLeft - deltaMouseX;

    var vpCenterX = vpLeft + this.viewportWidth/2;
    var vpCenterY = vpTop + this.viewportHeight/2;

    var currentTileX = Math.floor(vpCenterX/this.tileWidth)*this.tileWidth;
    var currentTileY = Math.floor(vpCenterY/this.tileHeight)*this.tileHeight;

    var tileDeltaX = currentTileX - this.nCurrentLeft;
    var tileDeltaY = currentTileY - this.nCurrentTop;

    var newVpCenterX = vpCenterX * nFactor;
    var newVpCenterY = vpCenterY * nFactor;

    var newTileX = Math.floor(newVpCenterX/this.tileWidth) * this.tileWidth;
    var newTileY = Math.floor(newVpCenterY/this.tileHeight) * this.tileHeight;

    var newCurrentLeft = newTileX - tileDeltaX;
    var newCurrentTop = newTileY - tileDeltaY;

    this.nCurrentLeft = newCurrentLeft;
    this.nCurrentTop = newCurrentTop;

    var newTilLeft = -newVpCenterX + this.viewportWidth/2;
    var newTilTop = -newVpCenterY + this.viewportHeight/2;

    var xOldOrigin = this.xOrigin;
    var yOldOrigin = this.yOrigin;

    this.xOrigin = this.nCurrentLeft;
    this.yOrigin = this.nCurrentTop;

    this.theInsideLayer.style.left = (newTilLeft + this.xOrigin) + "px";
    this.theInsideLayer.style.top = (newTilTop + this.yOrigin) + "px";

    var layers = this.aMaps[this.currentMap].getLayers();
    for( var k=0; k<layers.length; k++)
    {
	init_layer(this, layers[k]);
    }

    this.checkWrap();
    this.updateObjects();

}

function rangeK(len) {
 var i;
 var r = [];
 for(i=0; i<len; i++) r.push(i);
 return r;
}

function init_layer(map, layer) {
  switch(LAYER_ALGO) {
    case 'CENTER':
	center_load_layer(map, layer);
	break;
    case 'RANDOM':
	random_load_layer(map, layer);
	break;
    default:
	old_load_layer(map,layer);
	break;
  }
}

function old_load_layer(map, layer) {
 var d = layer.domObj;
 var i; var j;
 for(var j=0; j<map.nHigh; j++)
 {
  for( var i=0; i<map.nWide; i++)
  {
   var img = d.childNodes[(j*map.nWide)+i];
   if (map.animatedZoom) {
	img.style.width = map.tileWidth + "px";
	img.style.height = map.tileHeight + "px";
   }
   img.style.top = (map.nCurrentTop + j*map.tileHeight - map.yOrigin) + "px";
   img.style.left = (map.nCurrentLeft + i*map.tileWidth - map.xOrigin) + "px";
   layer.setTile(img);
  }
 }
}

function random_load_layer(map, layer) {
 	var d = layer.domObj;
        var __j = PWebUtil.shuffleArray(rangeK(map.nHigh));
        var j = __j.pop();
        while (j != null) {
                var __i = PWebUtil.shuffleArray(rangeK(map.nWide));
                var i = __i.pop();
                while (i != null) {
                        var img = d.childNodes[(j*map.nWide)+i];
			if (map.animatedZoom) {
				img.style.width = map.tileWidth + "px";
				img.style.height = map.tileHeight + "px";
			}
                        img.style.top = (map.nCurrentTop + j*map.tileHeight - map.yOrigin) + "px";
                        img.style.left = (map.nCurrentLeft + i*map.tileWidth - map.xOrigin) + "px";
                        layer.setTile(img);
                        i = __i.pop();
                }
                j = __j.pop();
        }
}


function center_load_layer(map, layer) {
        var cY = Math.floor(map.nHigh/2);
        var cX = Math.floor(map.nWide/2);
        var nbProcessed = center_load_helper(map, layer, cX-1, cY, 0, 1);
}

var directions = {1:{'x':1,'y':0},2:{'x':0,'y':-1},3:{'x':-1,'y':0},0:{'x':0,'y':1}};

function center_load_helper(map, layer, x, y, direction, offset) {
        if (x < 0) return 0;
        if (x > map.nHigh) return 0;
        if (y < 0) return 0;
        if (y > map.nHigh) return 0;
        var d = layer.domObj;
        var nbProcessed = 0;
        for(var i=0; i<2; i++) {
                direction = (direction+1) % 4;
                for(var j=0; j<offset; j++) {
                        var img = d.childNodes[(y*map.nWide)+x];
                        if (img) {
				if (map.animatedZoom) {
					img.style.width = map.tileWidth + "px";
					img.style.height = map.tileHeight + "px";
				}
                                img.style.top = (map.nCurrentTop + y*map.tileHeight - map.yOrigin) + "px";
                                img.style.left = (map.nCurrentLeft + x*map.tileWidth - map.xOrigin) + "px";
                        }
                        layer.setTile(img);
                        x += directions[direction].x;
                        y += directions[direction].y;
                        nbProcessed++;
                }
        }
        nbProcessed += center_load_helper(map, layer, x, y, direction, offset + 1);
        return nbProcessed;
}


// end of layer load order code


/***************************************
 * internal function adedd by cappu
 * use to paint a layer calculating tile
 * position for current exten and scale
 * and calling the layer.seTile
 ***************************************/
kaMap.prototype.paintLayer = function(l)
 {
         var d = l.domObj;
         for(var j=0; j<this.nHigh; j++)
         {
             for( var i=0; i<this.nWide; i++)
             {
                 var img = d.childNodes[(j*this.nWide)+i];
                // img.src = this.aPixel.src;
                 img.style.top = (this.nCurrentTop + j*this.tileHeight - this.yOrigin) + "px";
                 img.style.left = (this.nCurrentLeft + i*this.tileWidth - this.xOrigin) + "px";
                 l.setTile(img);
             }
         }
 this.checkWrap();
}


/* kaMap.updateObjects
 * call this after any major change to the state of kaMap including after
 * a zoomTo, zoomToExtents, etc.
 */
kaMap.prototype.updateObjects = function()
{

    for (var i=0; i<this.aObjects.length;i++ )
    {
        var obj = this.aObjects[i];
        var xOffset = (obj.xOffset) ? obj.xOffset : 0;
        var yOffset = (obj.yOffset) ? obj.yOffset : 0;
        var aPix = this.geoToPix( obj.lon, obj.lat );
        var top = (aPix[1] - this.yOrigin + yOffset);
        var left = (aPix[0] - this.xOrigin + xOffset);
        obj.style.top = top + "px";
        obj.style.left = left + "px";
    }
}

/**
 * kaMap.resize()
 *
 * called when the viewport layer changes size.  It is the responsibility
 * of the user of this API to track changes in viewport size and call this
 * function to update the map
 */

kaMap.prototype.resize = function( )
{

    if (this.initializationState != 2)
    {
        return false;
    }
    var newViewportWidth = this.getObjectWidth(this.domObj);
    var newViewportHeight = this.getObjectHeight(this.domObj);

    if (this.viewportWidth == null)
    {
        this.theInsideLayer.style.top = (-1*this.nCurrentTop + this.yOrigin) + "px";
        this.theInsideLayer.style.left = (-1*this.nCurrentLeft + this.xOrigin) + "px";
        this.viewportWidth = newViewportWidth;
        this.viewportHeight = newViewportHeight;
    }
    var newWide = Math.ceil((newViewportWidth / this.tileWidth) + 2*this.nBuffer);
    var newHigh = Math.ceil((newViewportHeight / this.tileHeight) + 2*this.nBuffer);

    //this.theInsideLayer.style.top = (safeParseInt(this.theInsideLayer.style.top) + (newViewportHeight - this.viewportHeight)/2)+"px";
    //this.theInsideLayer.style.left = (safeParseInt(this.theInsideLayer.style.left) + (newViewportWidth - this.viewportWidth)/2)+"px";

    this.viewportWidth = newViewportWidth;
    this.viewportHeight = newViewportHeight;

    if (this.nHigh == 0 && this.nWide == 0) this.nWide = newWide;

    while (this.nHigh < newHigh)
        this.appendRow();
    while (this.nHigh > newHigh && newHigh > 3)
        this.removeRow();
    while (this.nWide < newWide)
        this.appendColumn();
    while (this.nWide > newWide && newWide > 3)
        this.removeColumn();
    //create image don't call layer.set tile so i need to do that! 
	var map = this.getCurrentMap();
    var layers =map.getLayers();
    for(var i=0;i<layers.length;i++) layers[i].setTileLayer();

    this.triggerEvent( KAMAP_EXTENTS_CHANGED, this.getGeoExtents() );
    /*
    var layer = this.aMaps[this.currentMap].aLayers[0].domObj;
    var img = layer.childNodes[0].style;
    this.nCurrentTop = safeParseInt(img.top) + this.yOrigin;
    this.nCurrentLeft = safeParseInt(img.left) + this.xOrigin;
    */
    //this.checkWrap();
    this.triggerEvent( KAMAP_EXTENTS_CHANGED, this.getGeoExtents() );
}

/**
 * internal function to create images for map tiles
 *
 * top - integer, the top of this image in pixels
 * left - integer, the left of this image in pixels
 * obj - object, the layer in which this image will reside
 */
kaMap.prototype.createImage = function( top, left, obj )
{

    var img = document.createElement('img');
    //img.src=this.aPixel.src; p9 hack
    img.width=this.tileWidth;
    img.height=this.tileHeight;
    //first for firefox, rest for IE :(
    img.setAttribute('style', 'position:absolute; top:'+top+'px; left:'+left+'px;' );
    img.style.position = 'absolute';
    img.style.top = (top - this.yOrigin)+'px';
    img.style.left = (left - this.xOrigin)+'px';
    img.style.width = this.tileWidth + "px";
    img.style.height = this.tileHeight + "px";
    img.style.MozUserSelect = 'none';    
    img.style.visibility = 'hidden';
    img.galleryimg = "no"; //turn off image toolbar in IE
    img.onerror = kaMap_imgOnError;
    img.onload = kaMap_imgOnLoad;
    img.errorCount = 0;
    img.id = "i" + this.gImageID;
    img.layer = obj;
    img.kaMap = this;
    this.gImageID = this.gImageID + 1;
    //only set the source of the image if it is actually visible
    //commented by kappu to prevent double loading  
    //     if (obj.visible)
    //         obj.setTile(img);
    return img;
}

kaMap.prototype.resetTile = function( id, bForce )
{

    var img = this.DHTMLapi.getRawObject(id);
    if (img.layer)
        img.layer.setTile(this, bForce);
}

kaMap.prototype.reloadImage = function(id)
{
}

kaMap.prototype.resetImage = function(id)
{
}

/**
 * internal function to handle images that fail to load
 */
kaMap_imgOnError = function(e)
{

    if (this.layer)
        this.layer.setTile(this, true);
}

/**
 * internal function to track images as they finish loading.
 */
kaMap_imgOnLoad = function(e)
{

    this.style.visibility = 'visible';
}

/**
 * internal function to append a row of images to each of the layers
 *
 * this function is used when the viewport is resized
 * modified by cappu can take a single layer as input
 */
kaMap.prototype.appendRow = function(layer)
{

    if (this.nWide == 0)
        return;

    if(arguments.length==1) var layers = Array(layer);
      else var layers = this.aMaps[this.currentMap].getLayers();
    for( var i=0; i<layers.length; i++)
    {
        var obj = layers[i].domObj;
        for (var j=0; j<this.nWide; j++)
        {
            var top = this.nCurrentTop + (this.nHigh * this.tileHeight);
            var left = this.nCurrentLeft + (j * this.tileWidth);
            var img = this.createImage( top, left, layers[i] );
            //hack around IE problem with clipping layers when a filter is
            //active
            if (this.isIE4)
                img.style.filter = "Alpha(opacity="+layers[i].opacity+")";

            obj.appendChild( img );
        }
    }
    this.nHigh = this.nHigh + 1;
}

/**
 * internal function to append a column of images to each of the layers
 *
 * this function is used when the viewport is resized
 * modified by cappu can take a single layer as input
 */
kaMap.prototype.appendColumn = function(layer)
{

    if (this.nHigh == 0)
        return;

    if(arguments.length==1) var layers = Array(layer);
      else var layers = this.aMaps[this.currentMap].getLayers();
    for( var i=0; i<layers.length; i++)
    {
        var obj = layers[i].domObj;
        for(var j=this.nHigh-1; j>=0; j--)
        {
            var top = this.nCurrentTop + (j * this.tileHeight);
            var left = this.nCurrentLeft + (this.nWide * this.tileWidth);
            var img = this.createImage( top, left, layers[i] );
            //hack around IE problem with clipping layers when a filter is
            //active
            if (this.isIE4)
                img.style.filter = "Alpha(opacity="+layers[i].opacity+")";
            if (j < this.nHigh-1)
                obj.insertBefore(img, obj.childNodes[((j+1)*this.nWide)]);
            else
                obj.appendChild(img);

        }
    }
    this.nWide = this.nWide + 1;
}

/**
 * internal function to remove a column of images to each of the layers
 *
 * this function is used when the viewport is resized
 * modified by cappu can take a single layer as input 
 */
kaMap.prototype.removeColumn = function(layer)
{

    if (this.nWide < 3)
        return;

    if(arguments.length==1) var layers = Array(layer);
      else var layers = this.aMaps[this.currentMap].getLayers();
    for( var i=0; i<layers.length; i++)
    {
        var d = layers[i].domObj;
        for(var j=this.nHigh - 1; j >= 0; j--)
        {
            var img = d.childNodes[((j+1)*this.nWide)-1];
            d.removeChild( img );
            //attempt to prevent memory leaks
            img.onload = null;
            img.onerror = null;
        }
    }
    this.nWide = this.nWide - 1;
}

/**
 * internal function to remove a row of images to each of the layers
 *
 * this function is used when the viewport is resized
 * modified by cappu can take a single layer as input
 */
kaMap.prototype.removeRow = function(layer)
{

    if (this.nHigh < 3)
        return;

    if(arguments.length==1) var layers = Array(layer);
      else var layers = this.aMaps[this.currentMap].getLayers();
    for( var i=0; i<layers.length; i++)
    {
        var d = layers[i].domObj;
        for(var j=this.nWide - 1; j >= 0; j--)
        {
            var img = d.childNodes[((this.nHigh-1)*this.nWide)+j];
            d.removeChild( img );
            //attempt to prevent memory leaks
            img.onload = null;
            img.onerror = null;
        }
    }
    this.nHigh = this.nHigh - 1;
}

kaMap.prototype.hideLayers = function()
{
	if (!this.hideLayersOnMove) return;
	
    if (this.layersHidden) return;
    var layers = this.aMaps[this.currentMap].getLayers();
    for( var i=0; i<layers.length; i++)
    {
        layers[i]._visible = layers[i].visible;
        if (layers[i].name != '__base__')
        {
            layers[i].setVisibility( false );
        }
    }
    for( var i = 0; i < this.aCanvases.length; i++)
    {
        this.aCanvases[i].style.visibility = 'hidden';
        this.aCanvases[i].style.display = 'none';
    }
    this.layersHidden = true;
}

kaMap.prototype.showLayers = function()
{
	if (!this.hideLayersOnMove) return;
	
    if (!this.layersHidden) return;
    var layers = this.aMaps[this.currentMap].getLayers();
    for( var i=0; i<layers.length; i++)
    {
        layers[i].setVisibility( layers[i]._visible );
    }
    for( var i = 0; i < this.aCanvases.length; i++)
    {
        this.aCanvases[i].style.visibility = 'visible';
        this.aCanvases[i].style.display = 'block';
    }
    this.layersHidden = false;
}

//
// move the map by a certain amount
//
kaMap.prototype.moveBy = function( x, y )
{
    this.triggerEvent(KAMAP_MOVE);
    var til = this.theInsideLayer;
    til.style.top = (safeParseInt(til.style.top)+y) + 'px';
    til.style.left = (safeParseInt(til.style.left)+x )+ 'px';
    this.checkWrap();
}

//
// slide the map by a certain amount.  This function might not
// slide the exact amount requested by the x and y arguments.  Some rounding
// takes place which may make it off by several pixels.
//
// CUSTOM: Changed method to allow different type of panning algo's (e.g. easing)
kaMap.prototype.slideBy = function(x,y, f)
{
	this.triggerEvent(KAMAP_MOVE_START);
	if (this.slideid!=null) goQueueManager.dequeue( this.slideid );
	this.as = [];

	if (f == null) {
		f = YAHOO_PP.util.Easing.easeBoth;
	}
	
	var steps = 10;
	var dx = dy = 0;
	var px = py = 0;
	var cx = cy = 0;
	var i=0;
	var deltas = this.as;
	while (i<steps) {
		px = cx;
		py = cy;
		cx = f.apply(null, [i,0, x, steps]);
		cy = f.apply(null, [i,0, y, steps]);
		dx = Math.round(cx - px);
		dy = Math.round(cy - py);
		deltas[i] = new Array(dx, dy);
		i++;
	}
	
	// Uncomment this to show real pan (as opposed to requested pan)
	//
	//var sumx = sumy =0;
	//for (var i=0; i<deltas.length; i++) {
	//	sumx+=deltas[i][0];
	//	sumy+=deltas[i][1];
	//}
	//alert(x + " " + y + "\n" + sumx + " " + sumy);

	this.hideLayers();
	this.slideid=goQueueManager.enqueue(this.timePerStep,this,this.slide,[0]);
}

//
// handle individual movement within a slide
//
kaMap.prototype.slide = function(pos)
{

    if (pos>=this.as.length){this.as=slideid=null;this.showLayers();this.triggerEvent( KAMAP_EXTENTS_CHANGED, this.getGeoExtents() );return;}

    this.moveBy( this.as[pos][0], this.as[pos][1] );

    pos ++;
    this.slideid=goQueueManager.enqueue(this.timePerStep,this,this.slide,[ pos]);
}

/**
 * internal function to handle various events that are passed to the
 * current tool
 */
kaMap_onkeypress = function( e )
{

    if (this.kaMap.currentTool)
        this.kaMap.currentTool.onkeypress( e );
}

kaMap_onmousemove = function( e )
{
    e = (e)?e:((event)?event:null);
    if (e.button==2)
    {
        this.kaMap.triggerEvent( KAMAP_CONTEXT_MENU );
    }
    if (this.kaMap.currentTool)
        this.kaMap.currentTool.onmousemove( e );
}

kaMap_onmousedown = function( e )
{

    if (this.kaMap.currentTool)
        this.kaMap.currentTool.onmousedown( e );
}

kaMap_onmouseup = function( e )
{

    if (this.kaMap.currentTool)
        this.kaMap.currentTool.onmouseup( e );
}

kaMap_onmouseover = function( e )
{

    if (this.kaMap.currentTool)
        this.kaMap.currentTool.onmouseover( e );
}

kaMap_onmouseout = function( e )
{

     if (this.kaMap.currentTool)
        this.kaMap.currentTool.onmouseout( e );
}

kaMap_oncontextmenu = function( e )
{
    e = (e)?e:((event)?event:null);
    if (e.preventDefault) e.preventDefault();
    return false;
}

kaMap_onclick = function( e )
{

    if (this.kaMap.currentTool)
        this.kaMap.currentTool.onclick( e );
}

kaMap_ondblclick = function( e )
{

    if (this.kaMap.currentTool)
        this.kaMap.currentTool.ondblclick( e );
}

kaMap_onmousewheel = function( e )
{
    if (this.kaMap.currentTool)
        this.kaMap.currentTool.onmousewheel( e );
}

kaMap.prototype.cancelEvent = function(e)
{

    e = (e)?e:((event)?event:null);
    e.returnValue = false;
    if (e.preventDefault) e.preventDefault();
    return false;
}

kaMap.prototype.registerTool = function( toolObj )
{

    this.aTools.push( toolObj );
}

kaMap.prototype.activateTool = function( toolObj )
{

    if (this.currentTool)
    {
        this.currentTool.deactivate();
    }
    this.currentTool = toolObj;
    if (this.theInsideLayer)
        this.theInsideLayer.style.cursor = this.currentTool.cursor;
}

kaMap.prototype.deactivateTool = function( toolObj )
{

    if (this.currentTool == toolObj)
        this.currentTool = null;
    if (this.theInsideLayer)
        this.theInsideLayer.style.cursor = 'auto';
}

/**
 * internal function to check if images need to be wrapped
 */
kaMap.prototype.checkWrap = function()
{

    this.xOffset = safeParseInt(this.theInsideLayer.style.left) + this.nCurrentLeft - this.xOrigin;
    this.yOffset = safeParseInt(this.theInsideLayer.style.top) + this.nCurrentTop - this.yOrigin;

    while (this.xOffset > 0)
    {
        this.wrapR2L();
    }
    while (this.xOffset < -(this.nBuffer*this.tileWidth))
    {
        this.wrapL2R();
    }
    while (this.yOffset > -(this.nBuffer*this.tileHeight))
    {
        this.wrapB2T();
    }
    while (this.yOffset < -(2*this.nBuffer*this.tileHeight))
    {
        this.wrapT2B();
    }

    var layer = this.aMaps[this.currentMap].aLayers[0].domObj;
    var img = layer.childNodes[0].style;
    this.nCurrentTop = safeParseInt(img.top) + this.yOrigin;
    this.nCurrentLeft = safeParseInt(img.left) + this.xOrigin;
}

/**
 * internal function to reuse extra images
 * take last image from each row and put it at the beginning
 */
kaMap.prototype.wrapR2L = function()
{

    this.xOffset = this.xOffset - (this.nBuffer * this.tileWidth);

    var layers = this.aMaps[this.currentMap].getLayers();
    for( var k=0; k<layers.length; k++)
    {
        var d = layers[k].domObj;
        var refLeft = safeParseInt(d.childNodes[0].style.left);
        for (var j=0; j<this.nHigh; j++)
        {
            var imgLast = d.childNodes[((j+1)*this.nWide)-1];
            var imgNext = d.childNodes[j*this.nWide];

            imgLast.style.left = (refLeft - this.tileWidth) + 'px';
            //imgLast.src = this.aPixel.src; p9 hack
            d.removeChild(imgLast);
            d.insertBefore(imgLast, imgNext);
            if (layers[k].visible)
                layers[k].setTile(imgLast);
        }
    }
}

/**
 * internal function to reuse extra image
 * take first image from each row and put it at the end
 */
kaMap.prototype.wrapL2R = function()
{

    this.xOffset = this.xOffset + (this.nBuffer*this.tileWidth);
    var layers = this.aMaps[this.currentMap].getLayers();
    for( var k=0; k<layers.length; k++)
    {
        var d = layers[k].domObj;
        var refLeft = safeParseInt(d.childNodes[this.nWide-1].style.left);
        for (var j=0; j<this.nHigh; j++)
        {
            var imgFirst = d.childNodes[j*this.nWide];
            var imgNext;
            /* need to use insertBefore to get a node at the end of a 'row'
             * but this doesn't work for the very last row :(*/
            if (j < this.nHigh-1)
                imgNext = d.childNodes[((j+1)*this.nWide)];
            else
                imgNext = null;

            imgFirst.style.left = (refLeft + this.tileWidth) + 'px';
            //imgFirst.src = this.aPixel.src; p9 hack

            d.removeChild(imgFirst);
            if (imgNext)
                d.insertBefore(imgFirst, imgNext);
            else
                d.appendChild(imgFirst);
            if (layers[k].visible)
                layers[k].setTile(imgFirst);
        }
    }
}

/**
 * internal function to reuse extra images
 * take top image from each column and put it at the bottom
 */
kaMap.prototype.wrapT2B = function()
{

    this.yOffset = this.yOffset + (this.nBuffer*this.tileHeight);
    var layers = this.aMaps[this.currentMap].getLayers();
    for( var k=0; k<layers.length; k++)
    {
        var d = layers[k].domObj;
        var refTop = safeParseInt(d.childNodes[(this.nHigh*this.nWide)-1].style.top);
        for (var i=0; i<this.nWide; i++)
        {
            var imgBottom = d.childNodes[0];

            imgBottom.style.top = (refTop + this.tileHeight) + 'px';
            //imgBottom.src = this.aPixel.src; p9 hack

            d.removeChild(imgBottom);
            d.appendChild(imgBottom);
            if (layers[k].visible)
                layers[k].setTile(imgBottom);

        }
    }
}

/**
 * internal function to reuse extra images
 * take bottom image from each column and put it at the top
 */
kaMap.prototype.wrapB2T = function()
{

    this.yOffset = this.yOffset - (this.nBuffer*this.tileHeight);
    var layers = this.aMaps[this.currentMap].getLayers();
    for( var k=0; k<layers.length; k++)
    {
        var d = layers[k].domObj;
        var refTop = safeParseInt(d.childNodes[0].style.top);
        for (var i=0; i<this.nWide; i++)
        {
            var imgTop = d.childNodes[(this.nHigh*this.nWide)-1];

            imgTop.style.top = (refTop - this.tileHeight) + 'px';
            //imgTop.src = this.aPixel.src; p9 hack

            d.removeChild(imgTop);
            d.insertBefore(imgTop, d.childNodes[0]);
            if (layers[k].visible)
                layers[k].setTile(imgTop);

        }
    }
}

/**
 * kaMap.addMap( oMap )
 *
 * add a new instance of _map to kaMap.  _map is an internal class that
 * represents a map file from the configuration file.  This function is
 * intended for internal use by the init.php script.
 *
 * oMap - object, an instance of _map
 */
kaMap.prototype.addMap = function( oMap )
{

    oMap.kaMap = this;
    this.aMaps[oMap.name] = oMap;
}

/**
 * kaMap.getMaps()
 *
 * return an array of all the _map objects that kaMap knows about.  These can
 * be used to generate controls to switch between maps and to get information
 * about the layers (groups) and scales available in a given map.
 */
kaMap.prototype.getMaps = function()
{

    return this.aMaps;
}

/**
 * kaMap.getCurrentMap()
 *
 * returns the currently selected _map object.  This can be used to get
 * information about the layers (groups) and scales available in the current
 * map.
 */
kaMap.prototype.getCurrentMap = function()
{

    return this.aMaps[this.currentMap];
}

/**
 * kaMap.selectMap( name )
 *
 * select one of the maps that kaMap knows about and re-initialize kaMap with
 * this new map.  This function returns true if name is valid and false if the
 * map is invalid.  Note that a return of true does not imply that the map is
 * fully active.  You must register for the KAMAP_MAP_INITIALIZED event since
 * the map initialization happens asynchronously.
 *
 * name - string, the name of the map to select
 */
kaMap.prototype.selectMap = function( name )
{
    if (!this.aMaps[name])
    {
        return false;
    }
    else
    {
        this.currentMap = name;

        var oMap = this.getCurrentMap();
        this.setBackgroundColor(oMap.backgroundColor);

        //modified by cappu
        this.setMapLayers();
        if (oMap.aZoomTo.length != 0)
        {
		    //logger.debug('_map.aZoomTo = ' + oMap.aZoomTo);
            this.zoomTo(oMap.aZoomTo[0], oMap.aZoomTo[1], oMap.aZoomTo[2]);
            oMap.aZoomTo.length = 0;
        }
        else
        {
			// HACK: don't do an initial zoomTo since that will redundantly request tiles.
		    //logger.debug('going to default extent?');
            //this.zoomToExtents( oMap.currentExtents[0], oMap.currentExtents[1],
            //                   oMap.currentExtents[2], oMap.currentExtents[3] );
        }
        this.triggerEvent( KAMAP_MAP_INITIALIZED, this.currentMap );
        return true;
    }
}
/*
 * internal function added by cappu
 * check wich layers are visible and checked visible
 * in legend for current scale and map in InsideLayer
 * If needed create append or remove mapLayer!
 */
kaMap.prototype.setMapLayers = function( )
{
  var oMap = this.getCurrentMap();

//remove layers not to be drown at the selected scale this should be change to not remove the visible 
   for(var i = this.theInsideLayer.childNodes.length - 1; i>=0; i-- )
        {
            if (this.theInsideLayer.childNodes[i].className == 'mapLayer')
            {
                this.theInsideLayer.childNodes[i].appended=false;
                this.theInsideLayer.removeChild(this.theInsideLayer.childNodes[i]);
            }
        }
   //now check layer and create or append
      layers=oMap.getLayers(); 
      for( var i=0; i<layers.length; i++)
        {
            if(!layers[i].domObj)
            {
            var d = this.createMapLayer( layers[i].name );
            this.theInsideLayer.appendChild( d );
            d.appended=true;
            layers[i].domObj = d;
            layers[i].setOpacity( layers[i].opacity );
            layers[i].setZIndex( layers[i].zIndex );
            layers[i].setVisibility( layers[i].visible );
            this.nWide = 0;
            this.nHigh = 0;
            this.drawGroup(layers[i]);
            }else if(!layers[i].domObj.appended)
            {
              this.theInsideLayer.appendChild( layers[i].domObj );
              layers[i].domObj.appended=true;
            }

        }
  return true;
}
/*
 * internal funciton added by cappu
 * this function force a layer create image 
 */
kaMap.prototype.drawGroup = function(group)
{

    var newViewportWidth = this.getObjectWidth(this.domObj);
    var newViewportHeight = this.getObjectHeight(this.domObj);

    if (this.viewportWidth == null)
    {
        this.theInsideLayer.style.top = (-1*this.nCurrentTop + this.yOrigin) + "px";
        this.theInsideLayer.style.left = (-1*this.nCurrentLeft + this.xOrigin) + "px";
        this.viewportWidth = newViewportWidth;
        this.viewportHeight = newViewportHeight;
    }
    var newWide = Math.ceil((newViewportWidth / this.tileWidth) + 2*this.nBuffer);
    var newHigh = Math.ceil((newViewportHeight / this.tileHeight) + 2*this.nBuffer);

    this.viewportWidth = newViewportWidth;
    this.viewportHeight = newViewportHeight;

    if (this.nHigh == 0 && this.nWide == 0) this.nWide = newWide;

    while (this.nHigh < newHigh)
        this.appendRow(group);
    while (this.nHigh > newHigh)
        this.removeRow(group);
    while (this.nWide < newWide)
        this.appendColumn(group);
    while (this.nWide > newWide)
        this.removeColumn(group);
      return true;
}


kaMap.prototype.createMapLayer = function( id )
{

    var d = document.createElement( 'div' );
    d.id = id;
    d.className = 'mapLayer';
    d.style.position = 'absolute';
    d.style.visibility = 'visible';
    d.style.left = '0px';
    d.style.top = '0px';
    d.style.width= '3000px';
    d.style.height = '3000px';
    d.appended= false;//added by cappu 
    return d;
}
//modified by cappu
kaMap.prototype.addMapLayer = function( l )
{

    var map = this.getCurrentMap();
    map.addLayer ( l );
    this.setMapLayers();
    this.paintLayer(l);
    this.triggerEvent( KAMAP_LAYERS_CHANGED, this.currentMap );

}
//added by cappu
kaMap.prototype.removeMapLayer = function( id )
{

    var map = this.getCurrentMap();
    var layer = map.getLayer(id);
    if (!layer) return false;
    if(map.removeLayer ( map.getLayer(id) )) {
    this.setMapLayers();
    this.triggerEvent( KAMAP_LAYERS_CHANGED, this.currentMap );
    }
}

kaMap.prototype.getCenter = function()
{

    var deltaMouseX = this.nCurrentLeft - this.xOrigin + safeParseInt(this.theInsideLayer.style.left);
    var deltaMouseY = this.nCurrentTop - this.yOrigin +  safeParseInt(this.theInsideLayer.style.top);

    var vpTop = this.nCurrentTop - deltaMouseY;
    var vpLeft = this.nCurrentLeft - deltaMouseX;

    var vpCenterX = vpLeft + this.viewportWidth/2;
    var vpCenterY = vpTop + this.viewportHeight/2;

    return new Array( vpCenterX, vpCenterY );
}

/**
 * kaMap.getGeoExtents()
 *
 * returns an array of geographic extents for the current view in the form
 * (minx, miny, maxx, maxy)
 */
kaMap.prototype.getGeoExtents = function()
{

    var minx = -1*(safeParseInt(this.theInsideLayer.style.left) - this.xOrigin) * this.cellSize;
    var maxx = minx + this.viewportWidth * this.cellSize;
    var maxy= (safeParseInt(this.theInsideLayer.style.top) - this.yOrigin) * this.cellSize;
    var miny= maxy - this.viewportHeight * this.cellSize;
    return [minx,miny,maxx,maxy];

}

// continuous zoom set up
kaMap.prototype.zoomSlide = function(zoomfactor) {
	var slideWait = 80; // milliseconds between each step
	var slidePower = 0.2 // power used to calculate width of slide steps

	if (this.animatedZoomingIntervalID) {
		window.clearInterval(this.animatedZoomingIntervalID);
		this.animatedZoomingIntervalID = null;
		this.initializeLayers(zoomfactor);
	}
	var newscale = this.getCurrentScale() * zoomfactor;
	var context = {
		'map': this,
		'slideZoom': newscale,
		'totalSteps': this.slideSteps,
		'step': 1,
		'power': slidePower
	};
	var move = function() {
		var delta = this.slideZoom - this.map.getCurrentScale();
		var dZoom = Math.pow(((1/this.totalSteps)*this.step),this.power) * delta;
		var factor = zoomfactor*dZoom/delta;
		if (zoomfactor < 1 && this.step < this.map.slideSteps)
			factor = 1 - factor; 
		this.map.zoomByFactor(factor, false, this.step);
		this.step++;
		if (this.step > this.totalSteps) {
			window.clearInterval(this.map.animatedZoomingIntervalID);
			this.map.animatedZoomingIntervalID = null;
		}
	};

	this.animatedZoomingIntervalID = window.setInterval(move.KamapBindAsEventListener(context), slideWait);
}

kaMap.prototype.zoomIn = function() {
    this.zoomByFactor(this.aMaps[this.currentMap].zoomIn());
}

kaMap.prototype.zoomOut = function() {
    this.zoomByFactor(this.aMaps[this.currentMap].zoomOut());
}

kaMap.prototype.zoomToScale = function( scale ) {
    this.zoomByFactor(this.aMaps[this.currentMap].zoomToScale(scale));
}

kaMap.prototype.zoomByFactorAnimate = function (nZoomFactor) {
    var zoomTileWidth = this.tileWidth*nZoomFactor;
    var zoomTileHeight = this.tileHeight*nZoomFactor;

    var deltaMouseX = this.nCurrentLeft + safeParseInt(this.theInsideLayer.style.left) - this.xOrigin;
    var deltaMouseY = this.nCurrentTop + safeParseInt(this.theInsideLayer.style.top) - this.yOrigin;

    var vpTop = this.nCurrentTop - deltaMouseY;
    var vpLeft = this.nCurrentLeft - deltaMouseX;

    var vpCenterX = vpLeft + this.viewportWidth/2;
    var vpCenterY = vpTop + this.viewportHeight/2;

    var currentTileX = Math.floor(vpCenterX/this.tileWidth)*this.tileWidth;
    var currentTileY = Math.floor(vpCenterY/this.tileHeight)*this.tileHeight;

    var tileDeltaCenterX = ((currentTileX - vpCenterX) * nZoomFactor) - (currentTileX - vpCenterX);
    var tileDeltaCenterY = ((currentTileY - vpCenterY) * nZoomFactor) - (currentTileY - vpCenterY);
    var tileDeltaTileX = ((currentTileX - this.nCurrentLeft) * nZoomFactor) - (currentTileX - this.nCurrentLeft);
    var tileDeltaTileY = ((currentTileY - this.nCurrentTop) * nZoomFactor) - (currentTileY - this.nCurrentTop);
    var tileDeltaX = parseInt(tileDeltaTileX - tileDeltaCenterX);
    var tileDeltaY = parseInt(tileDeltaTileY - tileDeltaCenterY);

	var layers = this.getCurrentMap().getLayers();
	for( var k=0; k<layers.length; k++) {
		var d = layers[k].domObj;
 		var i; var j;
		for(var j=0; j<this.nHigh; j++) {
			for( var i=0; i<this.nWide; i++) {
				var img = d.childNodes[(j*this.nWide)+i];
				img.style.width = zoomTileWidth+2 + "px";
				img.style.height = zoomTileHeight+2 + "px";
  				img.style.top = (this.nCurrentTop + j*zoomTileHeight - this.yOrigin - tileDeltaY) + "px";
				img.style.left = (this.nCurrentLeft + i*zoomTileWidth - this.xOrigin - tileDeltaX) + "px";
  			}
		}
	}
}

kaMap.prototype.zoomByFactor = function( nZoomFactor, animated, step ) {
    if (nZoomFactor == 1) {
        this.triggerEvent( KAMAP_NOTICE, "NOTICE: changing to current scale aborted");
        return;
    }
	
    // set up continous zoom
    if (animated == null)
    	animated = this.animatedZoom;
    this.triggerEvent(KAMAP_SCALE_CHANGE_START, nZoomFactor * this.getCurrentScale());
    		
    if (animated && nZoomFactor <= 2 && nZoomFactor >= 0.5) {
        this.zoomSlide(nZoomFactor);
    } else {
	if (step != null && step <= this.slideSteps) {
		// run animation
		this.zoomByFactorAnimate(nZoomFactor);
	}
	if ((step == this.slideSteps) || ((step == null)&&(!animated)) || nZoomFactor > 2 || nZoomFactor < 0.5) {
		this.cellSize = this.cellSize/nZoomFactor;
		this.setMapLayers();
		this.initializeLayers(nZoomFactor);

		this.triggerEvent( KAMAP_SCALE_CHANGED, this.getCurrentScale() );
		this.triggerEvent(KAMAP_MOVE);
		this.triggerEvent( KAMAP_EXTENTS_CHANGED, this.getGeoExtents() );

		// HACK FOR REDRAWING WIDGET
		if (this.getCurrentMap().aLayers[0].legend != null && this.widgetIndicator)
		   this.widgetIndicator.buildWidget();
	}
   }
}

kaMap.prototype.getCurrentScale = function()
{

    return this.aMaps[this.currentMap].aScales[this.aMaps[this.currentMap].currentScale];
}

kaMap.prototype.setLayerQueryable = function( name, bQueryable )
{
    this.aMaps[this.currentMap].setLayerQueryable( name, bQueryable );
}

kaMap.prototype.setLayerVisibility = function( name, bVisible )
{

if(!this.loadUnchecked && bVisible){
layer=this.aMaps[this.currentMap].getLayer(name);
layer.visible=true;
this.setMapLayers();
this.aMaps[this.currentMap].setLayerVisibility( name, bVisible );
this.paintLayer(layer);
}else this.aMaps[this.currentMap].setLayerVisibility( name, bVisible );

}

kaMap.prototype.setLayerOpacity = function( name, opacity )
{

    this.aMaps[this.currentMap].setLayerOpacity( name, opacity );
}

kaMap.prototype.registerEventID = function( eventID )
{

    return this.eventManager.registerEventID(eventID);
}

kaMap.prototype.registerForEvent = function( eventID, obj, func )
{

    return this.eventManager.registerForEvent(eventID, obj, func);
}

kaMap.prototype.deregisterForEvent = function( eventID, obj, func )
{

    return this.eventManager.deregisterForEvent(eventID, obj, func);
}

kaMap.prototype.triggerEvent = function( eventID /*pass additional arguments*/ )
{

    return this.eventManager.triggerEvent.apply( this.eventManager, arguments );
}


/**
 * special helper function to parse an integer value safely in case
 * it is represented in IEEE format (scientific notation).
 */
function safeParseInt( val )
{

    return Math.round(parseFloat(val));
}

/******************************************************************************
 * _map
 *
 * internal class used to store map objects coming from the init script
 *
 * szName - string, the layer name (or group name, in this case ;))
 *
 * szTitle - string, the human-readable title of the map
 *
 * nCurrentScale - integer, the current scale as an index into aszScales;
 *
 * aszScales - array, an array of scale values for zooming.  The first scale is
 *             assumed to be the default scale of the map
 *
 * aszLayers - array, an array of layer names and statuses.  The array is indexed by
 *             the layer name and the value is true or false for the status.
 *
 *****************************************************************************/
function _map(szName,groupName,szTitle,nCurrentScale, units, aszScales )
{

    this.name = szName;
    this.groupName = groupName;
    this.title = szTitle;
    this.aScales = aszScales;
    this.currentScale = parseFloat(nCurrentScale);
    this.units = units;
    this.resolution = 72; //used in scale calculations
    this.aLayers = [];
    this.defaultExtents = [];
    this.currentExtents = [];
    this.maxExtents = [];
    this.backgroundColor = '#ffffff';
    this.version = "0"; //to be used for versioning the map file ...
    
    this.aZoomTo = [];

    this.kaMap = null;
}

_map.prototype.addLayer = function( layer )
{
    layer._map = this;
    layer.zIndex = this.aLayers.length;
    this.aLayers.push( layer );
}
//added by cappu
_map.prototype.removeLayer = function( l )
{
  var alayer=Array();
  for(i=0,a=0;i<this.aLayers.length;i++)
    if(this.aLayers[i]!=l){
      alayer[a]=this.aLayers[i];
      a++;
    }
  this.aLayers=alayer;
  return true;
}
//modified by cappu return only layer querable and visible for current scale
_map.prototype.getQueryableLayers = function()
{
    var r = [];
        var l = this.getLayers(); 
    for( var i=0; i<l.length; i++)
    {
        if (l[i].isQueryable())
            r.push(l[i]);
    }
    return r;
}
//modified by cappu, return only layer visible and checked for current scale !!
_map.prototype.getLayers = function()
{
    var r = [];
    for( var i=0; i<this.aLayers.length; i++)
    {
      if (this.aLayers[i].isVisible() && (this.aLayers[i].visible || this.kaMap.loadUnchecked) )
          r.push(this.aLayers[i]);
    }
    return r;
}
//added by cappu replace old getQueryableLayers
_map.prototype.getAllQueryableLayers = function()
{
    var r = [];
    for( var i=0; i<this.aLayers.length; i++)
    {
        if (this.aLayers[i].isQueryable())
            r.push(this.aLayers[i]);
    }
    return r;
}
//added by cappu replace old getLayers
_map.prototype.getAllLayers = function()
{

    return this.aLayers;
}
_map.prototype.getLayer = function( name )
{

    for (var i=0; i<this.aLayers.length; i++)
    {
        if (this.aLayers[i].name == name)
        {
            return this.aLayers[i];
        }
    }
}

_map.prototype.getScales = function()
{

    return this.aScales;
}


_map.prototype.zoomIn = function()
{

    var nZoomFactor = 1;
    if (this.currentScale < this.aScales.length - 1)
    {
        nZoomFactor = this.aScales[this.currentScale]/this.aScales[this.currentScale+1];
        this.currentScale = this.currentScale + 1;
    }
    return nZoomFactor;
}

_map.prototype.zoomOut = function()
{

    var nZoomFactor = 1;
    if (this.currentScale > 0)
    {
        nZoomFactor = this.aScales[this.currentScale]/this.aScales[this.currentScale-1];
        this.currentScale = this.currentScale - 1;
    }
    return nZoomFactor;
}

_map.prototype.zoomToScale = function( scale )
{
    var nZoomFactor = 1;
    for (var i=0; i<this.aScales.length; i++)
    {
        if (this.aScales[i] == scale)
        {
            nZoomFactor = this.aScales[this.currentScale]/scale;
            this.currentScale = parseInt(i);
        }
    }
    return nZoomFactor;
}

_map.prototype.setLayerQueryable = function( name, bQueryable )
{
    var layer = this.getLayer( name );
    layer.setQueryable( bQueryable );
}

_map.prototype.setLayerVisibility = function( name, bVisible )
{

    var layer = this.getLayer( name );
    layer.setVisibility( bVisible );
}

_map.prototype.setLayerOpacity = function( name, opacity )
{

    var layer = this.getLayer( name );
    layer.setOpacity( opacity );
}

_map.prototype.setDefaultExtents = function( minx, miny, maxx, maxy )
{

    this.defaultExtents = [minx, miny, maxx, maxy];
    if (this.currentExtents.length == 0)
        this.setCurrentExtents( minx, miny, maxx, maxy );
}

_map.prototype.setCurrentExtents = function( minx, miny, maxx, maxy )
{

    this.currentExtents = [minx, miny, maxx, maxy];
}

_map.prototype.setMaxExtents = function( minx, miny, maxx, maxy )
{

    this.maxExtents = [minx, miny, maxx, maxy];
}

_map.prototype.setBackgroundColor = function( szBgColor )
{

    this.backgroundColor = szBgColor;
}

/******************************************************************************
 * _layer
 *
 * internal class used to store map layers within a map.  Map layers track
 * visibility of the layer in the user interface.
 *
 * szName - string, the name of the layer
 * bVisible - boolean, the current state of the layer (true is visible)
 * opacity - integer, between 0 (transparent) and 100 (opaque), controls opacity
 *           of the layer as a whole
 * imageformat - string, the format to request the tiles in for this layer.  Can
 *               be used to optimize file sizes for different layer types 
 *               by using GIF for images with fewer colours and JPEG or PNG24
 *               for high-colour layers (such as raster imagery).
 *
 * bQueryable - boolean, is the layer queryable?  This is different from the
 *              layer being included in queries.  bQueryable marks a layer as
 *              being capable of being queried.  The layer also has to have
 *              it's query state turned on using setQueryable
 * scales     - array to containing the layer visibility for each scale! added by cappu
 *****************************************************************************/
function _layer( szName, bVisible, opacity, imageformat, bQueryable , scales, mergedLayers, tileservers)
{
    this.name = szName;
    this.visible = bVisible;
    this.opacity = opacity;
    this.domObj = null;
    this._map = null;
    this.imageformat = imageformat;
    this.queryable = bQueryable;
    this.queryState = bQueryable;

    this.mergedLayers = [];
    if (mergedLayers)
    	this.mergedLayers = mergedLayers;
    this.tileServers = new kaServers();
    this.tileServers.setServers(tileservers);
    this.legend = null;

     //added by cappu
    if(scales)this.scales = scales;
    else this.scales=Array(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1);//very rude to change cappu
    this.toLoad=0;
}

_layer.prototype.addMergedLayer = function(pLayer) { this.mergedLayers.push(pLayer); }

_layer.prototype.clearMergedLayers = function() { this.mergedLayers = []; }

_layer.prototype.isQueryable = function()
{
    return this.queryState;
}

_layer.prototype.setQueryable = function( bQueryable )
{
	if (this.queryable)
		this.queryState = bQueryable;
}
//added by  cappu check layer visibility at current scale
_layer.prototype.isVisible= function()
{
      return (this.scales[this._map.currentScale]==1)? true:false;
}
/**
 * layer.setOpacity( amount )
 *
 * set a layer to be semi transparent.  Amount is a number between
 * 0 and 100 where 0 is fully transparent and 100 is fully opaque
 */
_layer.prototype.setOpacity = function( amount )
{
	this.opacity = amount;
	if (this.domObj)
	{
		this.domObj.style.opacity = amount/100;
		this.domObj.style.mozOpacity = amount/100;
		//Nasty IE effect (or bug?) when you apply a filter
		//to a layer, it clips the layer and we rely on the
		//contents being visible outside the layer bounds
		//for 'railroading' the tiles
// 		if (this.isIE4) //commented by Lorenzo 
// 		{
			for(var i=0;i<this.domObj.childNodes.length;i++)
			{
				this.domObj.childNodes[i].style.filter = "Alpha(opacity="+amount+")";
			}
// 		}
	}
}

_layer.prototype.setTile = function(img)
{
	if (this._map.kaMap.delayLoad)
		return;

	var szForce = '';
	var szLayers = '';
	if (arguments[1])
		szForce = '&force=true';
	var szGroup = "&g="+img.layer.domObj.id;
	var szScale = '&s='+this._map.aScales[this._map.currentScale];
	
	// dynamic imageformat
	var szImageformat = '';
	var image_format = '';
	if (img.layer.imageformat && img.layer.imageformat != '')
	{
		image_format = img.layer.imageformat;
	}
	
	var l = safeParseInt(img.style.left) + this._map.kaMap.xOrigin;
	var t = safeParseInt(img.style.top) + this._map.kaMap.yOrigin;

	// CUSTOM: this customization (maprev) assumes only 1 revision sequence for all maps
	var src = this.buildTileURL(t, l, 
			this._map.name,
			this._map.aScales[this._map.currentScale],
			(arguments[1] ? true : undefined),
			this._map.groupName,
			img.layer.domObj.id,
			image_format);

	if (img.src != src)
	{
		img.style.visibility = 'hidden';
		img.src = src;

		if ((image_format.toLowerCase() == "png24") && this._map && this._map.getAllLayers().length > 1)
			fixPNG(img);
	}
}

_layer.prototype.setVisibility = function( bVisible )
{

	this.visible = bVisible;
	if (this.domObj)
	{
		this.domObj.style.visibility = bVisible?'visible':'hidden';
		//horrid hack - this is needed in case any element contained
		//within the div has its visibility set ... it overrides the
		//style of the container!!!
		this.domObj.style.display = bVisible?'block':'none';
	}
	for( var i=0; i<this.domObj.childNodes.length; i++)
	{
		this.setTile(this.domObj.childNodes[i]);
	}
}

_layer.prototype.setZIndex = function( zIndex )
{
	this.zIndex = zIndex;
	if (this.domObj)
	{
		this.domObj.style.zIndex = zIndex;
	}
}
//Set all layers tile added by cappu
_layer.prototype.setTileLayer = function()
{
    if (this._map.kaMap.delayLoad)
	return;

    var szLayers = '';
        this.loaded=0;

    // dynamic imageformat
    var szImageformat = '';
    var image_format = '';
    if (this.imageformat && this.imageformat != '')
    {
        image_format = this.imageformat;
    }
	for(i=0;i<this.domObj.childNodes.length;i++){

        img=this.domObj.childNodes[i];
		var l = safeParseInt(img.style.left) + this._map.kaMap.xOrigin;
		var t = safeParseInt(img.style.top) + this._map.kaMap.yOrigin;

		var src = this.buildTileURL(t, l,
			this._map.name,
			this._map.aScales[this._map.currentScale],
			(arguments[1] ? true : undefined),
			this._map.groupName,
			img.layer.domObj.id,
			image_format);

	if (img.src != src)
	{
		img.style.visibility = 'hidden';
		img.src = src;

		if ((image_format.toLowerCase() == "png24") && this._map && this._map.getAllLayers().length > 1)
			fixPNG(img);
	}
  }
}

_layer.prototype.buildLayerList = function(scale) {
  	var layers = "";
	if (this.mergedLayers.length > 0) {
		for (var i=0; i < this.mergedLayers.length; i++) {
			if (this.mergedLayers[i].minScale <= scale && this.mergedLayers[i].maxScale >= scale) {
				var name = this.mergedLayers[i].name;
				// swap for thin lines or labels if thematic is on
				if (this.legend) {
					if (name == "pointline") layers += "t_pointline";
					else if (name == "pp2_line") layers += "pp2_tline";
					else if (name == "pp2_labels") layers += "pp2_tlabels";
					else if (name == "pp2tg_pointline") layers += "pp2tg_tpointline";
					else if (name == "pp2tg_line") layers += "pp2tg_tline";
					else if (name == "pp2tg_streetlabels") layers += "pp2tg_tstreetlabels";
					else layers += name;
				} else 
					layers += name;
		
				if (i == 0 && this.legend != null && this.legend.getBreaks() != "") {
               	    			var legendString = "p_" + this.legend.indicator.periodids[this.legend.indicator.curPerIndex] + ".id_" + this.legend.indicator.id + ".colors_" + this.legend.getColors().join(":") + ".breaksdata_" + this.legend.getEncodedBreaks() + ".boundary_definition_" + this.legend.getBoundaryDefinitionID(this.legend.getBoundaryType().id);
					var nd = 0;
					if (this.legend.indicator.nodata)
						nd++;
					if (this.legend.indicator.breakid == P_BREAKTYPE_EXACT_VALUE_ID || this.legend.indicator.breakid == P_BREAKTYPE_EXACT_VALUE_CUSTOM_ID)
						nd += this.legend.getNumberOfBreaks();
					if (nd > 0)
						legendString += ":nd_" + nd;
					layers += "," + legendString;
				}
				if (this.mergedLayers[i].opacity < 1 && !this.mergedLayers[i].client)
					layers += ":o_" + this.mergedLayers[i].opacity;

				layers += ",";
			}
		}
		layers = layers.substring(0,layers.length-1);
	}
	layers = layers.replace(/&/g, '%26');
	layers = layers.replace(/#/g, '%23');
	return layers;
}

_layer.prototype.buildTileURL = function(t, l, mapName, scale, force, group, layer, imageFormat)
{
	//logger.debug("[buildTileURL] " + t + " " + l + " " + scale);
	var kamap = this._map.kaMap;
	var server = this.tileServers.isEmpty() == true ? kamap.server : this.tileServers.next( (t+l)/kamap.tileWidth );

	if (kamap.isDirectTileAccess == true) {
		var layers = this.buildLayerList(scale);
		var src = "";
		if (scale && layers != "") {
			var metaTop = Math.floor(t / 1000) * 1000;
			var metaLeft = Math.floor(l / 1000) * 1000;
			src = server 
				+ '/' + mapName
				+ '/' + scale
				+ '/' + layer
				+ '/' + layers
				+ '/meta_t' + metaTop
				+ '/t' + metaTop + 'l' + metaLeft
				+ '/t' + t + 'l' + l
				+ '.' + 'png'
				+ '?maprev='+this._map.revision
				+ '&key='+kamap.apiKey;
		}
		// if directory name is too long, go straight to tile_r
		if (layers.length > 255 || layers.match(".*pins_.*:data_.*")) {
			var url = server.split('/');
			src = url[0] + "//" + url[2] + "/" + kamap.directTilePath + '?s='+scale+'&t='+t+'&l='+l+'&layers='+layers+'&key='+kamap.apiKey;;
		}

		//document.title = src;
		return src;
	}
}


/******************************************************************************
 * Event Manager class
 *
 * an internal class for managing generic events.  kaMap! uses the event
 * manager internally and exposes certain events to the application.
 *
 * the kaMap class provides wrapper functions that hide this implementation
 * useage:
 *
 * myKaMap.registerForEvent( gnSomeEventID, myObject, myFunction );
 * myKaMap.registerForEvent( 'SOME_EVENT', myObject, myFunction );
 *
 * myKaMap.deregisterForEvent( gnSomeEventID, myObject, myFunction );
 * myKaMap.deregisterForEvent( 'SOME_EVENT', myObject, myFunction );
 *
 * myObject is normally null but can be a javascript object to have myFunction
 * executed within the context of an object (becomes 'this' in the function).
 *
 *****************************************************************************/
function _eventManager( )
{
    this.events = [];
    this.lastEventID = 0;
}

_eventManager.prototype.registerEventID = function( eventID )
{

    var ev = new String(eventID);
    if (!this.events[eventID])
    {
        this.events[eventID] = [];
    }
}

_eventManager.prototype.registerForEvent = function(eventID, obj, func)
{

    var ev = new String(eventID);
    this.events[eventID].push( [obj, func] );
}

_eventManager.prototype.deregisterForEvent = function( eventID, obj, func )
{

    var ev = new String(eventID);
    var bResult = false;
    if (!this.events[eventID]) return false;

    for (var i=0;i<this.events[eventID].length;i++)
    {
        if (this.events[eventID][i][0] == obj &&
            this.events[eventID][i][1] == func)
        {
            this.events[eventID].splice(i,1);
            bResult = true;
        }
    }
    return bResult;
}

_eventManager.prototype.triggerEvent = function( eventID )
{

   var ev = new String(eventID);
   if (!this.events[eventID]) return false;

    var args = new Array();
    for(i=1; i<arguments.length; i++)
    {
        args[args.length] = arguments[i];
    }

    for (var i=0; i<this.events[eventID].length; i++)
    {
        this.events[eventID][i][1].apply( this.events[eventID][i][0],
                                          args );
    }
    return true;
}

/******************************************************************************
 * Queue Manager class
 *
 * an internal class for managing delayed execution of code.  This uses the
 * window.setTimeout interface but adds support for execution of functions
 * on objects
 *
 * The problem with setTimeout is that you need a reference to a global object
 * to do something useful in an object-oriented environment, and we don't
 * really have that here.  So the Queue Manager handles a stack of pending
 * delayed execution code and evaluates it when it comes due.  It can be
 * used exactly like window.setTimeout in that it returns an id that can
 * subsequently be used to clear the delayed code.
 *
 * To add something to the queue, call
 * var id = goQueueManager.enqueue( timeout, obj, func, args );
 *
 * timeout - time to delay (milliseconds)
 * obj - the object to execute the function within.  Can be null for global
 *       scope
 * func - the function to execute.  Note this is the function, not a string
 *        containing the function.
 * args - an array of values to be passed to the function.
 *
 * To remove a function from the queue, call goQueueManager.dequeue( id );
 *****************************************************************************/
var goQueueManager = new _queueManager();

function _queueManager()
{
    this.queue = new Array();
}

_queueManager.prototype.enqueue = function( timeout, obj, func, args )
{

    var pos = this.queue.length;
    for (var i=0; i< this.queue.length; i++)
    {
        if (this.queue[i] == null)
        {
            pos = i;
            break;
        }
    }
    var id = window.setTimeout( "_queueManager_execute("+pos+")", timeout );
    this.queue[pos] = new Array( id, obj, func, args );
    return pos;
}

_queueManager.prototype.dequeue = function( pos )
{

    if (this.queue[pos] != null)
    {
        window.clearTimeout( this.queue[pos][0] );
        this.queue[pos] = null;
    }
}

function _queueManager_execute( pos )
{

    if (goQueueManager.queue[pos] != null)
    {
        var obj = goQueueManager.queue[pos][1];
        var func = goQueueManager.queue[pos][2];
        if (goQueueManager.queue[pos][3] != null)
            func.apply( obj, goQueueManager.queue[pos][3] );
        else
            func.apply( obj );
        goQueueManager.queue[pos] = null;
    }
}

/*
 * kaTool API
 *
 * an API for building tools that work with kaMap
 *
 * To create a new tool, you need to have included this file first.  Next
 * create a function to instantiate your new tool.  All object construction
 * functions must include a parameter that references the kaMap object on which
 * they operate
 *
 * The object construction function must call the kaTool constructor using the
 * following syntax:
 *
 * kaTool.apply( this, [oKaMap] );
 *
 * where oKaMap is the name of the parameter to the constructor function.
 *
 * You should then set the tool's name (this.name) and overload any functions
 * for mouse handling etc
 */

//globally 
var kaCurrentTool = null;

function kaTool( oKaMap )
{
    this.kaMap = oKaMap;
    this.kaMap.registerTool( this );
    this.name = 'kaTool';
}

kaTool.prototype.activate = function()
{
    this.kaMap.activateTool( this );
    document.kaCurrentTool = this;
}

kaTool.prototype.deactivate = function()
{
    this.kaMap.deactivateTool( this );
    document.kaCurrentTool = null;
}

kaTool.prototype.onmousemove = function(e)
{
    return false;
}

kaTool.prototype.onmousedown = function(e)
{
    return false;
}

kaTool.prototype.onmouseup = function(e)
{
    return false;
}

kaTool.prototype.onclick = function(e)
{
    return false;
}

kaTool.prototype.ondblclick = function(e)
{
    return false;
}

kaTool.prototype.onmousewheel = function(e)
{
    e = (e)?e:((event)?event:null);
    var wheelDelta = e.wheelDelta ? e.wheelDelta : e.detail*-1;
    if (wheelDelta > 0)
        this.kaMap.zoomIn();
    else
        this.kaMap.zoomOut();
    return false;
}

/**
 * kaTool.adjustPixPosition( x, y )
 *
 * adjust a page-relative pixel position into a kaMap relative
 * pixel position
 *
 * x - int, the x page coord
 * y - int, the y page coord
 *
 * returns an array with the adjusted pixel positions
 */
kaTool.prototype.adjustPixPosition = function( x, y )
{
    var obj = this.kaMap.domObj;
    var offsetLeft = 0;
    var offsetTop = 0;
    while (obj)
    {
        offsetLeft += parseInt(obj.offsetLeft);
        offsetTop += parseInt(obj.offsetTop);
        obj = obj.offsetParent;
    }
    
    var pX = parseInt(this.kaMap.theInsideLayer.style.left) + 
             offsetLeft - this.kaMap.xOrigin - x;
    var pY = parseInt(this.kaMap.theInsideLayer.style.top) + 
             offsetTop - this.kaMap.yOrigin - y;
             
    return [pX,pY];
}

// get window position coords
kaTool.prototype.getMousePosition = function (e) {
    e = (e)?e:((event)?event:null);
    var posX = 0, posY = 0;

    if (e.pageX && e.pageY) {
        posX = e.pageX;
        posY = e.pageY;
    } else {
        var iebody=(document.compatMode && document.compatMode != "BackCompat")? document.documentElement : document.body
        var scrollX = iebody.scrollLeft?iebody.scrollLeft:(window.pageXOffset?window.pageXOffset:0);
        var scrollY = iebody.scrollTop?iebody.scrollTop:(window.pageYOffset?window.pageYOffset:0);

        posX = e.clientX + scrollX;
        posY = e.clientY + scrollY;
    }
    return [posX,posY];
}

/*
 * key press events are directed to the HTMLDocument rather than the
 * div on which we really wanted them to happen.  So we set the document
 * keypress handler to this function and redirect it to the kaMap core
 * keypress handler, which will eventually reach the onkeypress handler
 * of our current tool ... which by default is the keyboard navigation.
 *
 * To get the keyboard events in the first place, add the following when you
 * want the keypress events to be captured
 *
 * if (isIE4) document.onkeydown = kaTool_redirect_onkeypress;
 * document.onkeypress = kaTool_redirect_onkeypress;
 */
function kaTool_redirect_onkeypress(e)
{
    if (document.kaCurrentTool)
        document.kaCurrentTool.onkeypress(e);
}

kaTool.prototype.onkeypress = function(e)
{
    e = (e)?e:((event)?event:null);
    if(e)
    {
        var charCode=(e.charCode)?e.charCode:e.keyCode;
        var b=true;
        var nStep = 16;
        switch(charCode)
        {
          case 38://up
            this.kaMap.moveBy(0,nStep);
            this.kaMap.triggerEvent( KAMAP_EXTENTS_CHANGED, this.kaMap.getGeoExtents() );
            break;
          case 40:
            this.kaMap.moveBy(0,-nStep);
            this.kaMap.triggerEvent( KAMAP_EXTENTS_CHANGED, this.kaMap.getGeoExtents() );
            break;
          case 37:
            this.kaMap.moveBy(nStep,0);
            this.kaMap.triggerEvent( KAMAP_EXTENTS_CHANGED, this.kaMap.getGeoExtents() );
            break;
          case 39:
            this.kaMap.moveBy(-nStep,0);
            this.kaMap.triggerEvent( KAMAP_EXTENTS_CHANGED, this.kaMap.getGeoExtents() );
            break;
          case 33:
            this.kaMap.slideBy(0, this.kaMap.viewportHeight/2);
            break;
          case 34:
            this.kaMap.slideBy(0,-this.kaMap.viewportHeight/2);
            break;
          case 36:
            this.kaMap.slideBy(this.kaMap.viewportWidth/2,0);
            break;
          case 35:
            this.kaMap.slideBy(-this.kaMap.viewportWidth/2,0);
            break;
          case 43:
            this.kaMap.zoomIn();
            break;
         case 45:
            this.kaMap.zoomOut();
            break;
          default:
            b=false;
        }
        if (b)
        {
            return this.cancelEvent(e);
        }
        return true;
    }
}

kaTool.prototype.onmouseover = function(e)
{
    return false;
}
kaTool.prototype.onmouseout = function(e)
{
    if (this.kaMap.isIE4) document.onkeydown = null;
    document.onkeypress = null;
    return false;
}

kaTool.prototype.cancelEvent = function(e)
{
    e = (e)?e:((event)?event:null);
    e.cancelBubble = true;
    e.returnValue = false;
    if (e.stopPropogation) e.stopPropogation();
    if (e.preventDefault) e.preventDefault();
    return false;
}

function kaNavigator( oKaMap )
{
    kaTool.apply( this, [oKaMap] );
    this.name = 'kaNavigator';
    this.cursor = 'move';

    this.activeImage = this.kaMap.server + 'va-images/button_pan_3.png';
    this.disabledImage = this.kaMap.server + 'va-images/button_pan_2.png';
    
    this.lastx = null;
    this.lasty = null;
    this.bMouseDown = false;
    this.bMouseDrag = false;
    this.allowClick = true;
    
    for (var p in kaTool.prototype)
    {
        if (!kaNavigator.prototype[p])
            kaNavigator.prototype[p]= kaTool.prototype[p];
    }
}

kaNavigator.prototype.onmouseout = function(e)
{
    e = (e)?e:((event)?event:null);
    if (!e.target) e.target = e.srcElement;
    if (e.target.id == this.kaMap.domObj.id)
    {
        this.bMouseDown = false;
        return kaTool.prototype.onmouseout.apply(this, [e]);
    }
}

kaNavigator.prototype.onmousemove = function(e)
{
    e = (e)?e:((event)?event:null);
    
    if (!this.bMouseDown)
    {
        return false;
    }
    else
    {
	if (!this.bMouseDrag) {
		this.kaMap.triggerEvent(KAMAP_DRAG_START);
		this.kaMap.triggerEvent(KAMAP_MOVE_START);
		this.bMouseDrag = true;
	}
    	this.kaMap.triggerEvent(KAMAP_MOVE);
    	this.kaMap.triggerEvent(KAMAP_DRAG);
    }
    
    if (!this.kaMap.layersHidden)
        this.kaMap.hideLayers();

    var newTop = safeParseInt(this.kaMap.theInsideLayer.style.top);
    var newLeft = safeParseInt(this.kaMap.theInsideLayer.style.left);

    newTop = newTop - this.lasty + (e.clientY || e.pageY);
    newLeft = newLeft - this.lastx + (e.clientX || e.pageX);

    this.kaMap.theInsideLayer.style.top=newTop + 'px';
    this.kaMap.theInsideLayer.style.left=newLeft + 'px';

    this.kaMap.checkWrap.apply(this.kaMap, []);

    this.lastx = (e.clientX || e.pageX);
    this.lasty = (e.clientY || e.pageY);
    return false;
}

kaNavigator.prototype.onmousedown = function(e)
{
    e = (e)?e:((event)?event:null);
    if (e.button==2)
    {
        return this.cancelEvent(e);
    }
    else
    {
        if (this.kaMap.isIE4) document.onkeydown = kaTool_redirect_onkeypress;
        document.onkeypress = kaTool_redirect_onkeypress;
        
        this.bMouseDown=true;
    	this.allowClick = true;
        this.lastx = (e.clientX || e.pageX);
        this.lasty = (e.clientY || e.pageY);
        
        e.cancelBubble = true;
        e.returnValue = false;
        if (e.stopPropogation) e.stopPropogation();
        if (e.preventDefault) e.preventDefault();
        return false;
    }
}

kaNavigator.prototype.onmouseup = function(e)
{
    e = (e)?e:((event)?event:null);
    this.bMouseDown=false;

    if (this.bMouseDrag) {
    	this.kaMap.triggerEvent(KAMAP_EXTENTS_CHANGED, this.kaMap.getGeoExtents());
    	this.kaMap.triggerEvent(KAMAP_DRAG_END);
	this.bMouseDrag=false;
	this.allowClick=false;
    }

    /* unnecessary according to Steve Lime */
    //this.lastx=null;
    //this.lasty=null;
    this.kaMap.showLayers();
    return false;
}

kaNavigator.prototype.onclick = function(e)
{
    e = (e)?e:((event)?event:null);
    return false;
}

kaNavigator.prototype.ondblclick = function(e)
{
    var pos = this.getMousePosition(e);
    var aPixPos = this.adjustPixPosition( pos[0], pos[1]);

    var vpX = this.kaMap.viewportWidth/2;
    var vpY = this.kaMap.viewportHeight/2;
    
    var dx = parseInt(this.kaMap.theInsideLayer.style.left) - this.kaMap.xOrigin - vpX - aPixPos[0];
    var dy = parseInt(this.kaMap.theInsideLayer.style.top) - this.kaMap.yOrigin - vpY - aPixPos[1];
    
    this.kaMap.slideBy(-dx, -dy);
}



/* This notice must be untouched at all times.

wz_dragdrop.js    v. 4.62
The latest version is available at
http://www.walterzorn.com
or http://www.devira.com
or http://www.walterzorn.de

Copyright (c) 2002-2003 Walter Zorn. All rights reserved.
Created 26. 8. 2002 by Walter Zorn (Web: http://www.walterzorn.com )
Last modified: 30. 5. 2005

This DHTML & Drag&Drop Library adds Drag&Drop functionality
to the following types of html-elements:
- images, even if not positioned via layers,
  nor via stylesheets or any other kind of "hard-coding"
- relatively and absolutely positioned layers (DIV elements).
Moreover, it provides extended DHTML abilities.

LICENSE: LGPL

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License (LGPL) as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

For more details on the GNU Lesser General Public License,
see http://www.gnu.org/copyleft/lesser.html
*/


// PATH TO THE TRANSPARENT 1*1 PX IMAGE (required by NS 4 as spacer)
var spacer = 'transparentpixel.gif';




//window.onerror = new Function('return true;');


// Optional commands passed to SET_DHTML() on the html-page (g: may be applied globally, i: individually)
var CLONE            = 'C10nE';   // i  img      clone image
var COPY             = 'C0pY';    // i  img      create copies
var DETACH_CHILDREN  = 'd37aCH';  // i  lyr      detach images
var HORIZONTAL       = 'H0r1Z';   // i  img,lyr  horizontally draggable only
var MAXHEIGHT        = 'm7x8I';   // i  img,lyr  maximum height limit, "
var MAXOFFBOTTOM     = 'm7xd0wN'; // i  img,lyr  downward offset limit
var MAXOFFLEFT       = 'm7x23Ft'; // i  img,lyr  leftward offset limit
var MAXOFFRIGHT      = 'm7x0Ff8'; // i  img,lyr  rightward offset limit
var MAXOFFTOP        = 'm7xu9';   // i  img,lyr  upward offset limit
var MAXWIDTH         = 'm7xW1';   // i  img,lyr  maximum width limit, use with resizable or scalable
var MINWIDTH         = 'm1nw1';   // i  img,lyr  minimum width limit, "
var MINHEIGHT        = 'm1n8I';   // i  img,lyr  minimum height limit, "
var NO_ALT           = 'no81T';   // gi img      disable alt and title attributes
var NO_DRAG          = 'N0d4Ag';  // i  img,lyr  disable draggability
var RESET_Z          = 'r35E7z';  // gi img,lyr  reset z-index when dropped
var RESIZABLE        = 'r5IZbl';  // gi img,lyr  resizable if <ctrl> or <shift> pressed
var SCALABLE         = 'SCLbl';   // gi img,lyr  scalable           "
var SCROLL           = 'sC8lL';   // gi img,lyr  enable auto scroll functionality
var TRANSPARENT      = 'dIApHAn'; // gi img,lyr  translucent while dragged
var VERTICAL         = 'V3Rt1C';  // i  img,lyr  vertically draggable only

var dd_cursors = new Array(
	'c:default',
	'c:crosshair',
	'c:e-resize',
	'c:hand',
	'c:help',
	'c:move',
	'c:n-resize',
	'c:ne-resize',
	'c:nw-resize',
	'c:s-resize',
	'c:se-resize',
	'c:sw-resize',
	'c:text',
	'c:w-resize',
	'c:wait'
);
var dd_i = dd_cursors.length; while(dd_i--)
	eval('var CURSOR_' + (dd_cursors[dd_i].substring(2).toUpperCase().replace('-', '_')) + ' = "' + dd_cursors[dd_i] + '";');



function WZDD()
{
	this.elements = new Array(0);
	this.obj = null;
	this.n = navigator.userAgent.toLowerCase();
	this.db = (document.compatMode && document.compatMode.toLowerCase() != "backcompat")?
		document.documentElement
		: (document.body || null);
	this.op = !!(window.opera && document.getElementById);
	this.op6 = !!(this.op && !(this.db && this.db.innerHTML));
	if (this.op && !this.op6) document.onmousedown = new Function('e',
		'if (((e = e || window.event).target || e.srcElement).tagName == "IMAGE") return false;');
	this.ie = !!(this.n.indexOf("msie") >= 0 && document.all && this.db && !this.op);
	this.iemac = !!(this.ie && this.n.indexOf("mac") >= 0);
	this.ie4 = !!(this.ie && !document.getElementById);
	this.n4 = !!(document.layers && typeof document.classes != "undefined");
	this.n6 = !!(typeof window.getComputedStyle != "undefined" && typeof document.createRange != "undefined");
	this.w3c = !!(!this.op && !this.ie && !this.n6 && document.getElementById);
	this.ce = !!(document.captureEvents && document.releaseEvents);
	this.px = (this.n4 || this.op6)? '' : 'px';
	this.tiv = this.w3c? 40 : 10;
}
var dd = new WZDD();

dd.Int = function(d_x, d_y)
{
	return isNaN(d_y = parseInt(d_x))? 0 : d_y;
};

dd.getWndW = function()
{
	return dd.Int(
		(dd.db && !dd.op && !dd.w3c && dd.db.clientWidth)? dd.db.clientWidth
		: (window.innerWidth || 0)
	);
};

dd.getWndH = function()
{
	return dd.Int(
		(dd.db && !dd.op && !dd.w3c && dd.db.clientHeight)? dd.db.clientHeight
		: (window.innerHeight || 0)
	);
};

dd.getScrollX = function()
{
	return dd.Int(window.pageXOffset || (dd.db? dd.db.scrollLeft : 0));
};

dd.getScrollY = function()
{
	return dd.Int(window.pageYOffset || (dd.db? dd.db.scrollTop : 0));
};

dd.getPageXY = function(d_o)
{
	if (dd.n4 && d_o)
	{
		dd.x = d_o.pageX || 0;
		dd.y = d_o.pageY || 0;
	}
	else
	{
		dd.x = dd.y = 0; //global helper vars
		while (d_o)
		{
			dd.x += dd.Int(d_o.offsetLeft);
			dd.y += dd.Int(d_o.offsetTop);
			d_o = d_o.offsetParent || null;
		}
	}
};

dd.getCssXY = function(d_o)
{
	if (d_o.div)
	{
		if (dd.n4)
		{
			d_o.cssx = d_o.div.x;
			d_o.cssy = d_o.div.y;
		}
		else if (dd.ie4)
		{
			d_o.cssx = d_o.css.pixelLeft;
			d_o.cssy = d_o.css.pixelTop;
		}
		else
		{
			d_o.css.left = d_o.css.top = 0 + dd.px;
			dd.getPageXY(d_o.div);
			d_o.cssx = d_o.x - dd.x;
			d_o.cssy = d_o.y - dd.y;
			d_o.css.left = d_o.cssx + dd.px;
			d_o.css.top = d_o.cssy + dd.px;
		}
	}
	else
	{
		d_o.cssx = 0;
		d_o.cssy = 0;
	}
};

dd.getImgW = function(d_o)
{
	return d_o? dd.Int(d_o.width) : 0;
};

dd.getImgH = function(d_o)
{
	return d_o? dd.Int(d_o.height) : 0;
};

dd.getDivW = function(d_o)
{
	return dd.Int(
		dd.n4? (d_o.div? d_o.div.clip.width : 0)
		: d_o.div? (d_o.div.offsetWidth || d_o.css.pixelWidth || d_o.css.width || 0)
		: 0
	);
};

dd.getDivH = function(d_o)
{
	return dd.Int(
		dd.n4? (d_o.div? d_o.div.clip.height : 0)
		: d_o.div? (d_o.div.offsetHeight || d_o.css.pixelHeight || d_o.css.height || 0)
		: 0
	);
};

dd.getWH = function(d_o)
{
	d_o.w = dd.getDivW(d_o);
	d_o.h = dd.getDivH(d_o);
	if (d_o.css)
	{
		d_o.css.width = d_o.w + dd.px;
		d_o.css.height = d_o.h + dd.px;
		d_o.dw = dd.getDivW(d_o)-d_o.w;
		d_o.dh = dd.getDivH(d_o)-d_o.h;
		d_o.css.width = (d_o.w-d_o.dw) + dd.px;
		d_o.css.height = (d_o.h-d_o.dh) + dd.px;
	}
	else d_o.dw = d_o.dh = 0;
};

dd.getCssProp = function(d_o, d_pn6, d_pstyle, d_pn4)
{
	if (d_o && dd.n6) return ''+window.getComputedStyle(d_o, null).getPropertyValue(d_pn6);
	if (d_o && d_o.currentStyle) return ''+eval('d_o.currentStyle.'+d_pstyle);
	if (d_o && d_o.style) return ''+eval('d_o.style.'+d_pstyle);
	if (d_o && dd.n4) return ''+eval('d_o.'+d_pn4);
	return '';
};

dd.getDiv = function(d_x, d_d)
{
	d_d = d_d || document;
	if (dd.n4)
	{
		if (d_d.layers[d_x]) return d_d.layers[d_x];
		for (var d_i = d_d.layers.length; d_i--;)
		{
			var d_y = dd.getDiv(d_x, d_d.layers[d_i].document);
			if (d_y) return d_y;
		}
	}
	if (dd.ie) return d_d.all[d_x] || null;
	if (d_d.getElementById) return d_d.getElementById(d_x) || null;
	return null;
};

dd.getImg = function(d_o, d_nm, d_xy, d_w)
{
	d_w = d_w || window;
	var d_img;
	if (document.images && (d_img = d_w.document.images[d_nm]) && d_img.name == d_nm)
	{
		if (d_xy)
		{
			if (dd.n4)
			{
				dd.getPageXY(d_w);
				d_o.defx = d_img.x + dd.x;
				d_o.defy = d_img.y + dd.y;
			}
			else
			{
				dd.getPageXY(d_img);
				d_o.defx = dd.x;
				d_o.defy = dd.y;
			}
		}
		return d_img;
	}
	if (dd.n4) for (var d_i = d_w.document.layers.length; d_i--;)
	{
		var d_y = dd.getImg(d_o, d_nm, d_xy, d_w.document.layers[d_i]);
		if (d_y) return d_y;
	}
	return null;
};

dd.getParent = function(d_o, d_p)
{
	if (dd.n4)
	{
		for (d_p, d_i = dd.elements.length; d_i--;)
		{
			if (!((d_p = dd.elements[d_i]).is_image) && d_p.div && (d_p.div.document.layers[d_o.name] || d_o.oimg && d_p.div.document.images[d_o.oimg.name]))
				d_p.addChild(d_o, d_p.detach, 1);
		}
	}
	else
	{
		d_p = d_o.is_image? dd.getImg(d_o, d_o.oimg.name) : (d_o.div || null);
		while (d_p && !!(d_p = d_p.offsetParent || d_p.parentNode || null))
		{
			if (d_p.ddObj)
			{
				d_p.ddObj.addChild(d_o, d_p.ddObj.detach, 1);
				break;
			}
		}
	}
};

dd.getCmd = function(d_o, d_cmd, d_cmdStr)
{
	var d_i = d_o.id.indexOf(d_cmd), d_j,
	d_y = (d_i >= 0)*1;
	if (d_y)
	{
		d_j = d_i+d_cmd.length;
		if (d_cmdStr) d_o.cmd += d_o.id.substring(d_i, d_j);
		d_o.id = d_o.id.substring(0, d_i) + d_o.id.substring(d_j);
	}
	return d_y;
};

dd.getCmdVal = function(d_o, d_cmd, d_cmdStr, int0)
{
	var d_i = d_o.id.indexOf(d_cmd), d_j,
	d_y = (d_o.id.indexOf(d_cmd) >= 0)? dd.Int(d_o.id.substring(d_o.id.indexOf(d_cmd)+d_cmd.length)) : int0? -1 : 0;
	if (!int0 && d_y || int0 && d_y >= 0)
	{
		d_j = d_i+d_cmd.length+(""+d_y).length;
		if (d_cmdStr) d_o.cmd += d_o.id.substring(d_i, d_j);
		d_o.id = d_o.id.substring(0, d_i) + d_o.id.substring(d_j);
	}
	return d_y;
};

dd.addElt = function(d_o, d_p)
{
	dd.elements[d_o.name] = dd.elements[d_o.index = dd.elements.length] = d_o;
	if (d_p) d_p.copies[d_o.name] = d_p.copies[d_p.copies.length] = d_o;
};

dd.mkWzDom = function()
{
	var d_o, d_i = dd.elements.length; while(d_i--) dd.getParent(dd.elements[d_i]);
	d_i = dd.elements.length; while(d_i--)
	{
		d_o = dd.elements[d_i];
		if (d_o.children && !d_o.parent)
		{
			var d_j = d_o.children.length; while(d_j--)
				d_o.children[d_j].setZ(d_o.z+d_o.children[d_j].z, 1);
		}
	}
};

dd.addProps = function(d_o)
{
	var d_i, d_c;
	if (d_o.is_image)
	{
		d_o.div = dd.getDiv(d_o.id);
		if (d_o.div && typeof d_o.div.style != "undefined") d_o.css = d_o.div.style;
		d_o.nimg = (dd.n4 && d_o.div)? d_o.div.document.images[0] : (document.images[d_o.id+'NImG'] || null);
		if (d_o.nimg && !d_o.noalt && !dd.noalt)
		{
			d_o.nimg.alt = d_o.oimg.alt || '';
			if (d_o.oimg.title) d_o.nimg.title = d_o.oimg.title;
		}
		d_o.bgColor = '';
	}
	else
	{
		d_o.bgColor = dd.getCssProp(d_o.div, 'background-color','backgroundColor','bgColor').toLowerCase();
		if (dd.n6 && d_o.div)
		{
			if ((d_c = d_o.bgColor).indexOf('rgb') >= 0)
			{
				d_c = d_c.substring(4, d_c.length-1).split(',');
				d_o.bgColor = '#';
				for (d_i = 0; d_i < d_c.length; d_i++) d_o.bgColor += parseInt(d_c[d_i]).toString(0x10);
			}
			else d_o.bgColor = d_c;
		}
	}
	if (dd.scalable) d_o.scalable = d_o.resizable^1;
	else if (dd.resizable) d_o.resizable = d_o.scalable^1;
	d_o.setZ(d_o.defz);
	d_o.cursor = d_o.cursor || dd.cursor || 'auto';
	d_o._setCrs(d_o.nodrag? 'auto' : d_o.cursor);
	d_o.diaphan = d_o.diaphan || dd.diaphan || 0;
	d_o.opacity = 1.0;
	//if (dd.ie && !dd.iemac && d_o.div)
	//	d_o.div.style.filter = "Alpha(opacity=100)";
	d_o.visible = true;
};

dd.initz = function()
{
	if (!(dd && (dd.n4 || dd.n6 || dd.ie || dd.op || dd.w3c))) return;
	if (dd.op6) WINSZ(2);
	else if (dd.n6 || dd.ie || dd.op && !dd.op6 || dd.w3c) dd.recalc(1);
	var d_drag = (document.onmousemove == DRAG),
	d_resize = (document.onmousemove == RESIZE);
	if (dd.loadFunc) dd.loadFunc();
	if (d_drag && document.onmousemove != DRAG) dd.setEvtHdl(1, DRAG);
	else if (d_resize && document.onmousemove != RESIZE) dd.setEvtHdl(1, RESIZE);
	if ((d_drag || d_resize) && document.onmouseup != DROP) dd.setEvtHdl(2, DROP);
	dd.setEvtHdl(0, PICK);
};

dd.finlz = function()
{
	if (dd.ie && dd.elements)
	{
		var d_i = dd.elements.length; while (d_i--)
			dd.elements[d_i].del();
	}
};

dd.setEvtHdl = function(d_typ, d_func)
{
	if (!d_typ)
	{
		if (document.onmousedown != d_func) dd.downFunc = document.onmousedown || null;
		document.onmousedown = d_func;
	}
	else if (d_typ&1)
	{
		if (document.onmousemove != d_func) dd.moveFunc = document.onmousemove || null;
		document.onmousemove = d_func;
	}
	else
	{
		if (document.onmouseup != d_func) dd.upFunc = document.onmouseup || null;
		document.onmouseup = d_func;
	}
	if (dd.ce)
	{
		var d_e = (!d_typ)? Event.MOUSEDOWN : (d_typ&1)? Event.MOUSEMOVE : Event.MOUSEUP;
		d_func? document.captureEvents(d_e) : document.releaseEvents(d_e);
	}
};

dd.evt = function(d_e)
{
	this.but = (this.e = d_e || window.event).which || this.e.button || 0;
	this.button = (this.e.type == 'mousedown')? this.but
		: (dd.e && dd.e.button)? dd.e.button
		: 0;
	this.src = this.e.target || this.e.srcElement || null;
	this.src.tag = ("" + (this.src.tagName || this.src)).toLowerCase();
	this.x = dd.Int(this.e.pageX || this.e.clientX || 0);
	this.y = dd.Int(this.e.pageY || this.e.clientY || 0);
	if (dd.ie)
	{
		this.x += dd.getScrollX() - (dd.ie && !dd.iemac)*1;
		this.y += dd.getScrollY() - (dd.ie && !dd.iemac)*1;
	}
	this.modifKey = this.e.modifiers? this.e.modifiers&Event.SHIFT_MASK : (this.e.shiftKey || false);
};

dd.recalc = function(d_x)
{
	var d_o, d_i = dd.elements.length; while(d_i--)
	{
		if (!(d_o = dd.elements[d_i]).is_image && d_o.div)
		{
			dd.getWH(d_o);
			if (d_o.div.pos_rel)
			{
				dd.getPageXY(d_o.div);
				var d_dx = dd.x - d_o.x, d_dy = dd.y - d_o.y;
				d_o.defx += d_dx;
				d_o.x += d_dx;
				d_o.defy += d_dy;
				d_o.y += d_dy;
				var d_p, d_j = d_o.children.length; while(d_j--)
				{
					if (!(d_p = d_o.children[d_j]).detached && (d_o != d_p.defparent || !(d_p.is_image && dd.getImg(d_p, d_p.oimg.name, 1))))
					{
						d_p.defx += d_dx;
						d_p.defy += d_dy;
						d_p.moveBy(d_dx, d_dy);
					}
				}
			}
		}
		else if (d_o.is_image && !dd.op6 && !dd.n4)
		{
			if (dd.n6 && d_x && !d_o.defw) d_o.resizeTo(d_o.defw = dd.getImgW(d_o.oimg), d_o.defh = dd.getImgH(d_o.oimg));
			var d_defx = d_o.defx, d_defy = d_o.defy;
			if (!(d_o.parent && d_o.parent != d_o.defparent) && (d_x || !d_o.detached || d_o.horizontal || d_o.vertical) && dd.getImg(d_o, d_o.oimg.name, 1))
				d_o.moveBy(d_o.defx-d_defx, d_o.defy-d_defy);
		}
	}
};



function WINSZ(d_x)
{
	if (d_x)
	{
		if (dd.n4 || dd.op6 && d_x&2)
		{
			dd.iW = innerWidth;
			dd.iH = innerHeight;
			if (dd.op6) setTimeout("WINSZ()", 0x1ff);
		}
		window.onresize = new Function('WINSZ();');
	}
	else if ((dd.n4 || dd.op6) && (innerWidth != dd.iW || innerHeight != dd.iH)) location.reload();
	else if (dd.op6) setTimeout("WINSZ()", 0x1ff);
	else if (!dd.n4) setTimeout('dd.recalc()', 0xa);
}
WINSZ(1);



function DDObj(d_o, d_i)
{
	this.id = d_o;
	this.cmd = '';
	this.cpy_n = dd.getCmdVal(this, COPY);
	this.maxoffb = dd.getCmdVal(this, MAXOFFBOTTOM, 0, 1);
	this.maxoffl = dd.getCmdVal(this, MAXOFFLEFT, 0, 1);
	this.maxoffr = dd.getCmdVal(this, MAXOFFRIGHT, 0, 1);
	this.maxofft = dd.getCmdVal(this, MAXOFFTOP, 0, 1);
	var d_j = dd_cursors.length; while(d_j--)
		if (dd.getCmd(this, dd_cursors[d_j], 1)) this.cursor = dd_cursors[d_j].substring(2);
	this.clone = dd.getCmd(this, CLONE, 1);
	this.detach = dd.getCmd(this, DETACH_CHILDREN);
	this.scalable = dd.getCmd(this, SCALABLE, 1);
	this.horizontal = dd.getCmd(this, HORIZONTAL);
	this.noalt = dd.getCmd(this, NO_ALT, 1);
	this.nodrag = dd.getCmd(this, NO_DRAG);
	this.scroll = dd.getCmd(this, SCROLL, 1);
	this.resizable = dd.getCmd(this, RESIZABLE, 1);
	this.re_z = dd.getCmd(this, RESET_Z, 1);
	this.diaphan = dd.getCmd(this, TRANSPARENT, 1);
	this.vertical = dd.getCmd(this, VERTICAL);
	this.maxw = dd.getCmdVal(this, MAXWIDTH, 1, 1);
	this.minw = Math.abs(dd.getCmdVal(this, MINWIDTH, 1, 1));
	this.maxh = dd.getCmdVal(this, MAXHEIGHT, 1, 1);
	this.minh = Math.abs(dd.getCmdVal(this, MINHEIGHT, 1, 1));

	this.name = this.id + (d_i || '');
	this.oimg = dd.getImg(this, this.id, 1);
	this.is_image = !!this.oimg;
	this.copies = new Array();
	this.children = new Array();
	this.parent = this.original = null;
	if (this.oimg)
	{
		this.id = this.name + 'div';
		this.w = dd.getImgW(this.oimg);
		this.h = dd.getImgH(this.oimg);
		this.dw = this.dh = 0;
		this.defz = dd.Int(dd.getCssProp(this.oimg, 'z-index','zIndex','zIndex')) || 1;
		this.defsrc = this.src = this.oimg.src;
		this.htm = '<img name="' + this.id + 'NImG"'+
			' src="' + this.oimg.src + '" '+
			'width="' + this.w + '" height="' + this.h + '">';
		this.t_htm = '<div id="' + this.id +
			'" style="position:absolute;'+
			'left:' + (this.cssx = this.x = this.defx) + 'px;'+
			'top:' + (this.cssy = this.y = this.defy) + 'px;'+
			'width:' + this.w + 'px;'+
			'height:' + this.h + 'px;">'+
			this.htm + '<\/div>';
	}
	else
	{
		if (!!(this.div = dd.getDiv(this.id)) && typeof this.div.style != "undefined") this.css = this.div.style;
		dd.getWH(this);
		if (this.div)
		{
			this.div.ddObj = this;
			this.div.pos_rel = ("" + (this.div.parentNode? this.div.parentNode.tagName : this.div.parentElement? this.div.parentElement.tagName : '').toLowerCase().indexOf('body') < 0);
		}
		dd.getPageXY(this.div);
		this.defx = this.x = dd.x;
		this.defy = this.y = dd.y;
		dd.getCssXY(this);
		this.defz = dd.Int(dd.getCssProp(this.div, 'z-index','zIndex','zIndex'));
	}
	this.defw = this.w || 0;
	this.defh = this.h || 0;
}

DDObj.prototype.moveBy = function(d_x, d_y, d_kds, d_o)
{
	if (!this.div) return;
	this.x += (d_x = dd.Int(d_x));
	this.y += (d_y = dd.Int(d_y));
	if (!d_kds || this.is_image || this.parent != this.defparent)
	{
		(d_o = this.css || this.div).left = (this.cssx += d_x) + dd.px;
		d_o.top = (this.cssy += d_y) + dd.px;
	}
	var d_i = this.children.length; while (d_i--)
	{
		if (!(d_o = this.children[d_i]).detached) d_o.moveBy(d_x, d_y, 1);
		d_o.defx += d_x;
		d_o.defy += d_y;
	}
};

DDObj.prototype.moveTo = function(d_x, d_y)
{
	this.moveBy(dd.Int(d_x)-this.x, dd.Int(d_y)-this.y);
};

DDObj.prototype.hide = function(d_m, d_o, d_p)
{
	if (this.div && this.visible)
	{
		d_p = this.css || this.div;
		if (d_m && !dd.n4)
		{
			this.display = dd.getCssProp(this.div, "display", "display", "display");
			if (this.oimg)
			{
				this.oimg.display = dd.getCssProp(this.oimg, "display", "display", "display");
				this.oimg.style.display = "none";
			}
			d_p.display = "none";
			dd.recalc();
		}
		else d_p.visibility = "hidden";
	}
	this.visible = false;
	var d_i = this.children.length; while (d_i--)
		if (!(d_o = this.children[d_i]).detached) d_o.hide(d_m);
};

DDObj.prototype.show = function(d_o, d_p)
{
	if (this.div)
	{
		d_p = this.css || this.div;
		if (d_p.display && d_p.display == "none")
		{
			d_p.display = this.display || "block";
			if (this.oimg) this.oimg.style.display = this.oimg.display || "inline";
			dd.recalc();
		}
		else d_p.visibility = "visible";
	}
	this.visible = true;
	var d_i = this.children.length; while (d_i--)
		if (!(d_o = this.children[d_i]).detached) d_o.show();
};

DDObj.prototype.resizeTo = function(d_w, d_h, d_o)
{
	if (!this.div) return;
	d_w = (this.w = dd.Int(d_w))-this.dw;
	d_h = (this.h = dd.Int(d_h))-this.dh;
	if (dd.n4)
	{
		this.div.resizeTo(d_w, d_h);
		if (this.is_image)
		{
			this.write('<img src="' + this.src + '" width="' + d_w + '" height="' + d_h + '">');
			(this.nimg = this.div.document.images[0]).src = this.src;
		}
	}
	else if (typeof this.css.pixelWidth != "undefined")
	{
		this.css.pixelWidth = d_w;
		this.css.pixelHeight = d_h;
		if (this.is_image)
		{
			(d_o = this.nimg.style).pixelWidth = d_w;
			d_o.pixelHeight = d_h;
		}
	}
	else
	{
		this.css.width = d_w + dd.px;
		this.css.height = d_h + dd.px;
		if (this.is_image)
		{
			(d_o = this.nimg).width = d_w;
			d_o.height = d_h;
			if (!d_o.complete) d_o.src = this.src;
		}
	}
};

DDObj.prototype.resizeBy = function(d_dw, d_dh)
{
	this.resizeTo(this.w+dd.Int(d_dw), this.h+dd.Int(d_dh));
};

DDObj.prototype.swapImage = function(d_x, d_cp)
{
	if (!this.nimg) return;
	this.nimg.src = d_x;
	this.src = this.nimg.src;
	if (d_cp)
	{
		var d_i = this.copies.length; while (d_i--)
			this.copies[d_i].src = this.copies[d_i].nimg.src = this.nimg.src;
	}
};

DDObj.prototype.setBgColor = function(d_x)
{
	if (dd.n4 && this.div) this.div.bgColor = d_x;
	else if (this.css) this.css.background = d_x;
	this.bgColor = d_x;
};

DDObj.prototype.write = function(d_x, d_o)
{
	this.text = d_x;
	if (!this.div) return;
	if (dd.n4)
	{
		(d_o = this.div.document).open();
		d_o.write(d_x);
		d_o.close();
		dd.getWH(this);
	}
	else if (!dd.op6)
	{
		this.css.height = 'auto';
		this.div.innerHTML = d_x;
		if (!dd.ie4) dd.recalc();
		if (dd.ie4 || dd.n6) setTimeout('dd.recalc();', 0); // n6.0: recalc twice
	}
};

DDObj.prototype.copy = function(d_n, d_p)
{
	if (!this.oimg) return;
	d_n = d_n || 1;
	while (d_n--)
	{
		var d_l = this.copies.length,
		d_o = new DDObj(this.name+this.cmd, d_l+1);
		if (dd.n4)
		{
			d_o.id = (d_p = new Layer(d_o.w)).name;
			d_p.clip.height = d_o.h;
			d_p.visibility = 'show';
			(d_p = d_p.document).open();
			d_p.write(d_o.htm);
			d_p.close();
		}
		else if (dd.db.insertAdjacentHTML) dd.db.insertAdjacentHTML("AfterBegin", d_o.t_htm);
		else if (document.createElement && dd.db && dd.db.appendChild)
		{
			dd.db.appendChild(d_p = document.createElement('div'));
			d_p.innerHTML = d_o.htm;
			d_p.id = d_o.id;
			d_p.style.position = 'absolute';
			d_p.style.width = d_o.w + 'px';
			d_p.style.height = d_o.h + 'px';
		}
		else if (dd.db && dd.db.innerHTML) dd.db.innerHTML += d_o.t_htm;
		d_o.defz = this.defz+1+d_l;
		dd.addProps(d_o);
		d_o.original = this;
		dd.addElt(d_o, this);
		if (this.parent)
		{
			this.parent.addChild(d_o, this.detached);
			d_o.defparent = this.defparent;
		}
		d_o.moveTo(d_o.defx = this.defx, d_o.defy = this.defy);
		if (dd.n4) d_o.defsrc = d_o.src = this.defsrc;
		d_o.swapImage(this.src);
	}
};

DDObj.prototype.addChild = function(d_kd, detach, defp)
{
	if (typeof d_kd != "object") d_kd = dd.elements[d_kd];
	if (d_kd.parent && d_kd.parent == this || d_kd == this || !d_kd.is_image && d_kd.defparent && !defp) return;

	this.children[this.children.length] = this.children[d_kd.name] = d_kd;
	d_kd.detached = detach || 0;
	if (defp) d_kd.defparent = this;
	else if (this == d_kd.defparent && d_kd.is_image) dd.getImg(this, d_kd.oimg.name, 1);
	if (!d_kd.defparent || this != d_kd.defparent)
	{
		d_kd.defx = d_kd.x;
		d_kd.defy = d_kd.y;
	}
	if (!detach)
	{
		d_kd.defz = d_kd.defz+this.defz-(d_kd.parent? d_kd.parent.defz : 0)+(!d_kd.is_image*1);
		d_kd.setZ(d_kd.z+this.z-(d_kd.parent? d_kd.parent.z : 0)+(!d_kd.is_image*1), 1);
	}
	if (d_kd.parent) d_kd.parent._removeChild(d_kd, 1);
	d_kd.parent = this;
};

DDObj.prototype._removeChild = function(d_kd, d_newp)
{
	if (typeof d_kd != "object") d_kd = this.children[d_kd];
	var d_oc = this.children, d_nc = new Array();
	for (var d_i = 0; d_i < d_oc.length; d_i++)
		if (d_oc[d_i] != d_kd) d_nc[d_nc.length] = d_oc[d_i];
	this.children = d_nc;
	d_kd.parent = null;
	if (!d_newp)
	{
		d_kd.detached = d_kd.defp = 0;
		if (d_kd.is_image) dd.getImg(d_kd, d_kd.oimg.name, 1);
	}
};

DDObj.prototype.attachChild = function(d_kd)
{
	(d_kd = (typeof d_kd != "object")? this.children[d_kd]: d_kd).detached = 0;
	d_kd.setZ(d_kd.defz + this.z-this.defz, 1);
};

DDObj.prototype.detachChild = function(d_kd)
{
	(d_kd = (typeof d_kd != "object")? this.children[d_kd]: d_kd).detached = 1;
};

DDObj.prototype.setZ = function(d_x, d_kds, d_o)
{
	if (d_kds)
	{
		var d_dz = d_x-this.z,
		d_i = this.children.length; while (d_i--)
			if (!(d_o = this.children[d_i]).detached) d_o.setZ(d_o.z+d_dz, 1);
	}
	dd.z = Math.max(dd.z, this.z = this.div? ((this.css || this.div).zIndex = d_x) : 0);
};

DDObj.prototype.maximizeZ = function()
{
	this.setZ(dd.z+1, 1);
};

DDObj.prototype._resetZ = function(d_o)
{
	if (this.re_z || dd.re_z)
	{
		this.setZ(this.defz);
		var d_i = this.children.length; while (d_i--)
			if (!(d_o = this.children[d_i]).detached) d_o.setZ(d_o.defz);
	}
};

DDObj.prototype.setOpacity = function(d_x)
{
	this.opacity = d_x;
	this._setOpaRel(1.0, 1);
};

DDObj.prototype._setOpaRel = function(d_x, d_kd, d_y, d_o)
{
	if (this.diaphan || d_kd)
	{
		d_y = this.opacity*d_x;
		if (dd.n6) this.css.MozOpacity = d_y;
		else if (dd.ie && !dd.iemac && typeof this.div.filters != "undefined")
			this.div.filters[0].opacity = parseInt(100*d_y);
		else if (this.css) this.css.opacity = d_y;
		var d_i = this.children.length; while (d_i--)
			if (!(d_o = this.children[d_i]).detached) d_o._setOpaRel(d_x, 1);
	}
};

DDObj.prototype.setCursor = function(d_x)
{
	this._setCrs(this.cursor = (d_x.indexOf('c:')+1)? d_x.substring(2) : d_x);
};

DDObj.prototype._setCrs = function(d_x)
{
	if (this.css) this.css.cursor = ((!dd.ie || dd.iemac) && d_x == 'hand')? 'pointer' : d_x;
};

DDObj.prototype.setDraggable = function(d_x)
{
	this.nodrag = !d_x*1;
	this._setCrs(d_x? this.cursor : 'auto');
};

DDObj.prototype.setResizable = function(d_x)
{
	this.resizable = d_x*1;
	if (d_x) this.scalable = 0;
};

DDObj.prototype.setScalable = function(d_x)
{
	this.scalable = d_x*1;
	if (d_x) this.resizable = 0;
};

DDObj.prototype.del = function(d_os, d_o)
{
	var d_i;
	if (this.parent && this.parent._removeChild) this.parent._removeChild(this);
	if (this.original)
	{
		this.hide();
		if (this.original.copies)
		{
			d_os = new Array();
			for (d_i = 0; d_i < this.original.copies.length; d_i++)
				if ((d_o = this.original.copies[d_i]) != this) d_os[d_o.name] = d_os[d_os.length] = d_o;
			this.original.copies = d_os;
		}
	}
	else if (this.is_image)
	{
		this.hide();
		if (this.oimg)
		{
		  if (dd.n4) this.oimg.src = this.defsrc;
		  else this.oimg.style.visibility = 'visible';
		}
	}
	else if (this.moveTo)
	{
		if (this.css) this.css.cursor = 'default';
		this.moveTo(this.defx, this.defy);
		this.resizeTo(this.defw, this.defh);
	}
	d_os = new Array();
	for (d_i = 0; d_i < dd.elements.length; d_i++)
	{
		if ((d_o = dd.elements[d_i]) != this) d_os[d_o.name] = d_os[d_o.index = d_os.length] = d_o;
		else d_o._free();
	}
	dd.elements = d_os;
	if (!dd.op6 && !dd.n4) dd.recalc();
};

DDObj.prototype._free = function()
{
	for (var d_i in this)
		this[d_i] = null;
	dd.elements[this.name] = null;
};



dd.n4RectVis = function(vis)
{
	for (var d_i = 4; d_i--;)
	{
		dd.rectI[d_i].visibility = dd.rectA[d_i].visibility = vis? 'show' : 'hide';
		if (vis) dd.rectI[d_i].zIndex = dd.rectA[d_i].zIndex = dd.z+2;
	}
};

dd.n4RectPos = function(d_o, d_x, d_y, d_w, d_h)
{
	d_o.x = d_x;
	d_o.y = d_y;
	d_o.clip.width = d_w;
	d_o.clip.height = d_h;
};

// NN4: draw img resize rectangle
dd.n4Rect = function(d_w, d_h)
{
	var d_i;
	if (!dd.rectI)
	{
		dd.rectI = new Array();
		dd.rectA = new Array();
	}
	if (!dd.rectI[0])
	{
		for (d_i = 4; d_i--;)
		{
			(dd.rectI[d_i] = new Layer(1)).bgColor = '#000000';
			(dd.rectA[d_i] = new Layer(1)).bgColor = '#ffffff';
		}
	}
	if (!dd.rectI[0].visibility || dd.rectI[0].visibility == 'hide') dd.n4RectVis(1);
	dd.obj.w = d_w;
	dd.obj.h = d_h;
	for (d_i = 4; d_i--;)
	{
		dd.n4RectPos(dd.rectI[d_i], dd.obj.x + (!(d_i-1)? (dd.obj.w-1) : 0), dd.obj.y + (!(d_i-2)? (dd.obj.h-1) : 0), d_i&1 || dd.obj.w, !(d_i&1) || dd.obj.h);
		dd.n4RectPos(dd.rectA[d_i], !(d_i-1)? dd.rectI[1].x+1 : (dd.obj.x-1), !(d_i-2)? dd.rectI[2].y+1 : (dd.obj.y-1), d_i&1 || dd.obj.w+2, !(d_i&1) || dd.obj.h+2);
	}
};

dd.reszTo = function(d_w, d_h)
{
	if (dd.n4 && dd.obj.is_image) dd.n4Rect(d_w, d_h);
	else dd.obj.resizeTo(d_w, d_h);
};

dd.embedVis = function(d_vis)
{
	var d_o = new Array('iframe', 'applet', 'embed', 'object');
	var d_i = d_o.length; while (d_i--)
	{
		var d_p = dd.ie? document.all.tags(d_o[d_i]) : document.getElementsByTagName? document.getElementsByTagName(d_o[d_i]) : null;
		if (d_p)
		{
			var d_j = d_p.length; while (d_j--)
			{
				var d_q = d_p[d_j];
				while (d_q.offsetParent || d_q.parentNode)
				{
					if ((d_q = d_q.parentNode || d_q.offsetParent || null) == dd.obj.div)
					{
						d_p[d_j].style.visibility = d_vis;
						break;
					}
				}
			}
		}
	}
};

dd.maxOffX = function(d_x, d_y)
{
	return (
		(dd.obj.maxoffl+1 && (d_y = dd.obj.defx-dd.obj.maxoffl)-d_x > 0
		|| dd.obj.maxoffr+1 && (d_y = dd.obj.defx+dd.obj.maxoffr)-d_x < 0)? d_y
		: d_x
	);
};

dd.maxOffY = function(d_x, d_y)
{
	return (
		(dd.obj.maxofft+1 && (d_y = dd.obj.defy-dd.obj.maxofft)-d_x > 0
		|| dd.obj.maxoffb+1 && (d_y = dd.obj.defy+dd.obj.maxoffb)-d_x < 0)? d_y
		: d_x
	);
};

dd.inWndW = function(d_x, d_y)
{
	var d_wx = dd.getScrollX(),
	d_ww = dd.getWndW();
	return (
		((d_y = d_wx+2)-d_x > 0) || ((d_y = d_wx+d_ww+dd.obj.w-2)-d_x < 0)? d_y
		: d_x
	);
};

dd.inWndH = function(d_x, d_y)
{
	var d_wy = dd.getScrollY(),
	d_wh = dd.getWndH();
	return (
		((d_y = d_wy+2)-d_x > 0) || ((d_y = d_wy+d_wh+dd.obj.h-2)-d_x < 0)? d_y
		: d_x
	);
};

// These two funcs limit the size of element when mouseresized.
// Implemented 22.5.2003 by Gregor L?tolf <gregor@milou.ch>, modified by Walter Zorn
dd.limW = function(d_w)
{
	return (
		(dd.obj.minw-d_w > 0)? dd.obj.minw
		: (dd.obj.maxw > 0 && dd.obj.maxw-d_w < 0)? dd.obj.maxw
		: d_w
	);
};

dd.limH = function(d_h)
{
	return (
		(dd.obj.minh-d_h > 0)? dd.obj.minh
		: (dd.obj.maxh > 0 && dd.obj.maxh-d_h < 0)? dd.obj.maxh
		: d_h
	);
};


// Optional autoscroll-page functionality. Courtesy Cedric Savarese.
// Implemented by Walter Zorn
function DDScroll()
{
	if (!dd.obj || !dd.obj.scroll && !dd.scroll || dd.op || dd.ie4 || dd.whratio)
	{
		dd.scrx = dd.scry = 0;
		return;
	}
	var d_bnd = 0x1c,
	d_wx = dd.getScrollX(), d_wy = dd.getScrollY();
	if (dd.msmoved)
	{
		var d_ww = dd.getWndW(), d_wh = dd.getWndH(), d_y;
		dd.scrx = ((d_y = dd.e.x-d_ww-d_wx+d_bnd) > 0)? (d_y>>=2)*d_y
			: ((d_y = d_wx+d_bnd-dd.e.x) > 0)? -(d_y>>=2)*d_y
			: 0;
		dd.scry = ((d_y = dd.e.y-d_wh-d_wy+d_bnd) > 0)? (d_y>>=2)*d_y
			: ((d_y = d_wy+d_bnd-dd.e.y) > 0)? -(d_y>>=2)*d_y
			: 0;
	}
	if (dd.scrx || dd.scry)
	{
		window.scrollTo(
			d_wx + (dd.scrx = dd.obj.is_resized? dd.limW(dd.obj.w+dd.scrx)-dd.obj.w : dd.obj.vertical? 0 : (dd.maxOffX(dd.obj.x+dd.scrx)-dd.obj.x)),
			d_wy + (dd.scry = dd.obj.is_resized? dd.limH(dd.obj.h+dd.scry)-dd.obj.h : dd.obj.horizontal? 0 : (dd.maxOffY(dd.obj.y+dd.scry)-dd.obj.y))
		);
		dd.obj.is_dragged? dd.obj.moveTo(dd.obj.x+dd.getScrollX()-d_wx, dd.obj.y+dd.getScrollY()-d_wy)
			: dd.reszTo(dd.obj.w+dd.getScrollX()-d_wx, dd.obj.h+dd.getScrollY()-d_wy);
	}
	dd.msmoved = 0;
	window.setTimeout('DDScroll()', 0x33);
}



function PICK(d_ev)
{
	dd.e = new dd.evt(d_ev);
	if (dd.e.x >= dd.getWndW()+dd.getScrollX() || dd.e.y >= dd.getWndH()+dd.getScrollY()) return true; // on scrollbar
	var d_o, d_cmp = -1, d_i = dd.elements.length; while (d_i--)
	{
		d_o = dd.elements[d_i];
		if (dd.n4 && dd.e.but > 1 && dd.e.src == d_o.oimg && !d_o.clone) return false;
		if (d_o.visible && dd.e.but <= 1 && dd.e.x >= d_o.x && dd.e.x <= d_o.x+d_o.w && dd.e.y >= d_o.y && dd.e.y <= d_o.y+d_o.h)
		{
			if (d_o.z > d_cmp && dd.e.src.tag.indexOf('input') < 0 && dd.e.src.tag.indexOf('textarea') < 0 && dd.e.src.tag.indexOf('select') < 0 && dd.e.src.tag.indexOf('option') < 0)
			{
				d_cmp = d_o.z;
				dd.obj = d_o;
			}
		}
	}
	if (dd.obj)
	{
		if (dd.obj.nodrag) dd.obj = null;
		else
		{
			dd.e.e.cancelBubble = true;
			var d_rsz = dd.e.modifKey && (dd.obj.resizable || dd.obj.scalable);
			if (dd.op && !dd.op6)
			{
				(d_o = document.getElementById('OpBlUr')).style.pixelLeft = dd.e.x;
				d_o.style.pixelTop = dd.e.y;
				(d_o = d_o.children[0].children[0]).focus();
				d_o.blur();
			}
			else if (dd.ie && !dd.ie4)
			{
				if (document.selection && document.selection.empty) document.selection.empty();
				dd.db.onselectstart = function()
				{
					event.returnValue = false;
				};
			}
			if (d_rsz)
			{
				dd.obj._setCrs('se-resize');
				dd.obj.is_resized = 1;
				dd.whratio = dd.obj.scalable? dd.obj.defw/dd.obj.defh : 0;
				if (dd.ie)
				{
					if (dd.ie4)
					{
						window.dd_x = dd.getScrollX();
						window.dd_y = dd.getScrollY();
					}
					setTimeout(
						'if (dd.obj && document.selection && document.selection.empty)'+
						'{'+
							'document.selection.empty();'+
							'if (dd.ie4) window.scrollTo(window.dd_x, window.dd_y);'+
						'}'
					,0);
				}
				dd.setEvtHdl(1, RESIZE);
				dd.reszTo(dd.obj.w, dd.obj.h);
			}
			else
			{
				dd.obj.is_dragged = 1;
				dd.setEvtHdl(1, DRAG);
			}
			dd.setEvtHdl(2, DROP);
			dd.embedVis('hidden');
			dd.obj._setOpaRel(0.7);
			dd.obj.maximizeZ();
			dd.ofx = dd.obj.x+dd.obj.w-dd.e.x;
			dd.ofy = dd.obj.y+dd.obj.h-dd.e.y;
			if (window.my_PickFunc) my_PickFunc();
			DDScroll();
			return !(
				dd.obj.is_resized
				|| dd.n4 && dd.obj.is_image
				|| dd.n6 || dd.w3c
			);
		}
	}
	if (dd.downFunc) return dd.downFunc(d_ev);
	return true;
}

function DRAG(d_ev)
{
	if (!dd.obj || !dd.obj.visible) return true;
	if (dd.ie4 || dd.w3c || dd.n6 || dd.obj.children.length > 0xf)
	{
		if (dd.wait) return false;
		dd.wait = 1;
		setTimeout('dd.wait = 0;', dd.tiv);
	}
	dd.e = new dd.evt(d_ev);
	if (dd.ie && !dd.e.but)
	{
		DROP(d_ev);
		return true;
	}
	dd.msmoved = 1;
	dd.obj.moveTo(
		dd.obj.vertical? dd.obj.x : dd.maxOffX(dd.inWndW(dd.ofx+dd.e.x)-dd.obj.w),
		dd.obj.horizontal? dd.obj.y : dd.maxOffY(dd.inWndH(dd.ofy+dd.e.y)-dd.obj.h)
	);

	if (window.my_DragFunc) my_DragFunc();
	return false;
}

function RESIZE(d_ev)
{
	if (!dd.obj || !dd.obj.visible) return true;
	if (dd.wait) return false;
	dd.wait = 1;
	setTimeout('dd.wait = 0;', dd.tiv);
	dd.e = new dd.evt(d_ev);
	if (dd.ie && !dd.e.but)
	{
		DROP(d_ev);
		return true;
	}
	dd.msmoved = 1;
	var d_w = dd.limW(dd.inWndW(dd.ofx+dd.e.x)-dd.obj.x), d_h;
	if (!dd.whratio) d_h = dd.limH(dd.inWndH(dd.ofy+dd.e.y)-dd.obj.y);
	else
	{
		d_h = dd.limH(dd.inWndH(Math.round(d_w/dd.whratio)+dd.obj.y)-dd.obj.y);
		d_w = Math.round(d_h*dd.whratio);
	}
	dd.reszTo(d_w, d_h);
	if (window.my_ResizeFunc) my_ResizeFunc();
	return false;
}

function DROP(d_ev)
{
	if (dd.obj)
	{
		if (dd.obj.is_dragged)
		{
			if (!dd.obj.is_image) dd.getWH(dd.obj);
		}
		else if (dd.n4)
		{
			if (dd.obj.is_image)
			{
				dd.n4RectVis(0);
				dd.obj.resizeTo(dd.obj.w, dd.obj.h);
			}
		}
		if (!dd.n4 && !dd.op6 || !dd.obj.is_image) dd.recalc();
		dd.setEvtHdl(1, dd.moveFunc);
		dd.setEvtHdl(2, dd.upFunc);
		if (dd.db) dd.db.onselectstart = null;
		dd.obj._setOpaRel(1.0);
		dd.obj._setCrs(dd.obj.cursor);
		dd.embedVis('visible');
		dd.obj._resetZ();
		if (window.my_DropFunc)
		{
			dd.e = new dd.evt(d_ev);
			my_DropFunc();
		}
		dd.msmoved = dd.obj.is_dragged = dd.obj.is_resized = dd.whratio = 0;
		dd.obj = null;
	}
	dd.setEvtHdl(0, PICK);
}



function SET_DHTML()
{
	var d_a = arguments, d_ai, d_htm = '', d_o, d_i = d_a.length; while (d_i--)
	{
		if (dd.op6)
		{
			var d_t0 = (new Date()).getTime();
			while ((new Date()).getTime()-d_t0 < 0x99);
		}
		if (!(d_ai = d_a[d_i]).indexOf('c:')) dd.cursor = d_ai.substring(2);
		else if (d_ai == NO_ALT) dd.noalt = 1;
		else if (d_ai == SCROLL) dd.scroll = 1;
		else if (d_ai == RESET_Z) dd.re_z = 1;
		else if (d_ai == RESIZABLE) dd.resizable = 1;
		else if (d_ai == SCALABLE) dd.scalable = 1;
		else if (d_ai == TRANSPARENT) dd.diaphan = 1;
		else
		{
			d_o = new DDObj(d_ai);
			dd.addElt(d_o);
			d_htm += d_o.t_htm || '';
			if (d_o.oimg && d_o.cpy_n)
			{
				var d_j = 0; while (d_j < d_o.cpy_n)
				{
					var d_p = new DDObj(d_o.name+d_o.cmd, ++d_j);
					dd.addElt(d_p, d_o);
					d_p.defz = d_o.defz+d_j;
					d_p.original = d_o;
					d_htm += d_p.t_htm;
				}
			}
		}
	}
	if (dd.n4 || dd.n6 || dd.ie || dd.op || dd.w3c) document.write(
		(dd.n4? '<div style="position:absolute;"><\/div>\n'
		: (dd.op && !dd.op6)? '<div id="OpBlUr" style="position:absolute;visibility:hidden;width:0px;height:0px;"><form><input type="text" style="width:0px;height:0px;"><\/form><\/div>'
		: '') + d_htm
	);
	dd.z = 0x33;
	d_i = dd.elements.length; while (d_i--)
	{
		dd.addProps(d_o = dd.elements[d_i]);
		if (d_o.is_image && !d_o.original && !d_o.clone)
			dd.n4? d_o.oimg.src = spacer : d_o.oimg.style.visibility = 'hidden';
	}
	dd.mkWzDom();
	if (window.onload) dd.loadFunc = window.onload;
	document.onmousedown = document.onmousedown||null;
	document.onmousemove = document.onmousemove||null;
	document.onmouseup = document.onmouseup||null;
	window.onload = dd.initz;
	window.onunload = dd.finlz;
	dd.setEvtHdl(0, PICK);
}

function ADD_DHTML(d_o) // layers only!
{
	d_o = new DDObj(d_o);
	dd.addElt(d_o);
	dd.addProps(d_o);
	dd.mkWzDom();
}




////////////////////////////////////////////////////////////
// If not needed, all code below this line may be removed


// For backward compatibility
dd.d = document;            // < v. 2.72
var RESET_ZINDEX = RESET_Z; // < 3.44
var KEYDOWN_RESIZE = RESIZABLE; // < 4.43
var CURSOR_POINTER = CURSOR_HAND; // < 4.44
var NO_SCROLL = '';         // < v. 4.49




////////////////////////////////////////////////////////////
// FUNCTIONS FOR EXTENDED SCRIPTING
// Use these for your own extensions,
// or to call functions defined elsewhere



/* my_PickFunc IS AUTOMATICALLY CALLED WHEN AN ITEM STARTS TO BE DRAGGED.
The following objects/properties are accessible from here:

- dd.e: current mouse event
- dd.e.property: access to a property of the current mouse event.
  Mostly requested properties:
  - dd.e.x: document-related x co-ordinate
  - dd.e.y: document-related y co-ord
  - dd.e.src: target of mouse event (not identical with the drag drop object itself).
  - dd.e.button: currently pressed mouse button. Left button: dd.e.button <= 1

- dd.obj: reference to currently dragged item.
- dd.obj.property: access to any property of that item.
- dd.obj.method(): for example dd.obj.resizeTo() or dd.obj.swapImage() .
  Mostly requested properties:
	- dd.obj.name: image name or layer ID passed to SET_DHTML();
	- dd.obj.x and dd.obj.y: co-ordinates;
	- dd.obj.w and dd.obj.h: size;
	- dd.obj.is_dragged: 1 while item is dragged, else 0;
	- dd.obj.is_resized: 1 while item is resized, i.e. if <ctrl> or <shift> is pressed, else 0

For more properties and details, visit the API documentation
at http://www.walterzorn.com/dragdrop/api_e.htm (english) or
http://www.walterzorn.de/dragdrop/api.htm (german)    */
//function my_PickFunc()
//{
//}




/* my_DragFunc IS CALLED WHILE AN ITEM IS DRAGGED
See the description of my_PickFunc above for what's accessible from here. */
//function my_DragFunc()
//{
	//window.status = 'dd.elements.' + dd.obj.name + '.x  = ' + dd.obj.x + '     dd.elements.' + dd.obj.name + '.y = ' + dd.obj.y;
//}




/* my_ResizeFunc IS CALLED WHILE AN ITEM IS RESIZED
See the description of my_PickFunc above for what's accessible from here. */
//function my_ResizeFunc()
//{
	//window.status = 'dd.elements.' + dd.obj.name + '.w  = ' + dd.obj.w + '     dd.elements.' + dd.obj.name + '.h = ' + dd.obj.h;
//}




/* THIS ONE IS CALLED ONCE AN ITEM IS DROPPED
See the description of my_PickFunc for what's accessible from here.
Here may be investigated, for example, what's the name (dd.obj.name)
of the dropped item, and where (dd.obj.x, dd.obj.y) it has been dropped... */
//function my_DropFunc()
//{
//}

function my_PickFunc()
{
    if (dd.obj.my_PickFunc)
    {
        dd.obj.my_PickFunc();
    }
}

function my_DragFunc()
{
    if (dd.obj.my_DragFunc)
    {
        dd.obj.my_DragFunc();
    }
}

function my_ResizeFunc()
{
    if (dd.obj.my_ResizeFunc)
    {
        dd.obj.my_ResizeFunc();
    }
}

function my_DropFunc()
{
    if (dd.obj.my_DropFunc)
    {
        dd.obj.my_DropFunc();
    }
}

/* This notice must be untouched at all times.

wz_jsgraphics.js    v. 2.31
The latest version is available at
http://www.walterzorn.com
or http://www.devira.com
or http://www.walterzorn.de

Copyright (c) 2002-2004 Walter Zorn. All rights reserved.
Created 3. 11. 2002 by Walter Zorn (Web: http://www.walterzorn.com )
Last modified: 28. 3. 2005

Performance optimizations for Internet Explorer
by Thomas Frank and John Holdsworth.
fillPolygon method implemented by Matthieu Haller.

High Performance JavaScript Graphics Library.
Provides methods
- to draw lines, rectangles, ellipses, polygons
  with specifiable line thickness,
- to fill rectangles and ellipses
- to draw text.
NOTE: Operations, functions and branching have rather been optimized
to efficiency and speed than to shortness of source code.

LICENSE: LGPL

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License (LGPL) as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA,
or see http://www.gnu.org/copyleft/lesser.html
*/


var jg_ihtm, jg_ie, jg_fast, jg_dom, jg_moz,
jg_n4 = (document.layers && typeof document.classes != "undefined");


function chkDHTM(x, i)
{
	x = document.body || null;
	jg_ie = x && typeof x.insertAdjacentHTML != "undefined";
	jg_dom = (x && !jg_ie &&
		typeof x.appendChild != "undefined" &&
		typeof document.createRange != "undefined" &&
		typeof (i = document.createRange()).setStartBefore != "undefined" &&
		typeof i.createContextualFragment != "undefined");
	jg_ihtm = !jg_ie && !jg_dom && x && typeof x.innerHTML != "undefined";
	jg_fast = jg_ie && document.all && !window.opera;
	jg_moz = jg_dom && typeof x.style.MozOpacity != "undefined";
}


function pntDoc()
{
	this.wnd.document.write(jg_fast? this.htmRpc() : this.htm);
	this.htm = '';
}


function pntCnvDom()
{
	var x = document.createRange();
	x.setStartBefore(this.cnv);
	x = x.createContextualFragment(jg_fast? this.htmRpc() : this.htm);
	this.cnv.appendChild(x);
	this.htm = '';
}


function pntCnvIe()
{
	this.cnv.insertAdjacentHTML("BeforeEnd", jg_fast? this.htmRpc() : this.htm);
	this.htm = '';
}


function pntCnvIhtm()
{
	this.cnv.innerHTML += this.htm;
	this.htm = '';
}


function pntCnv()
{
	this.htm = '';
}


function mkDiv(x, y, w, h)
{
	this.htm += '<div style="position:absolute;'+
		'left:' + x + 'px;'+
		'top:' + y + 'px;'+
		'width:' + w + 'px;'+
		'height:' + h + 'px;'+
		'clip:rect(0,'+w+'px,'+h+'px,0);'+
		'background-color:' + this.color +
		(!jg_moz? ';overflow:hidden' : '')+
		';"><\/div>';
}


function mkDivIe(x, y, w, h)
{
	this.htm += '%%'+this.color+';'+x+';'+y+';'+w+';'+h+';';
}


function mkDivPrt(x, y, w, h)
{
	this.htm += '<div style="position:absolute;'+
		'border-left:' + w + 'px solid ' + this.color + ';'+
		'left:' + x + 'px;'+
		'top:' + y + 'px;'+
		'width:0px;'+
		'height:' + h + 'px;'+
		'clip:rect(0,'+w+'px,'+h+'px,0);'+
		'background-color:' + this.color +
		(!jg_moz? ';overflow:hidden' : '')+
		';"><\/div>';
}


function mkLyr(x, y, w, h)
{
	this.htm += '<layer '+
		'left="' + x + '" '+
		'top="' + y + '" '+
		'width="' + w + '" '+
		'height="' + h + '" '+
		'bgcolor="' + this.color + '"><\/layer>\n';
}


var regex =  /%%([^;]+);([^;]+);([^;]+);([^;]+);([^;]+);/g;
function htmRpc()
{
	return this.htm.replace(
		regex,
		'<div style="overflow:hidden;position:absolute;background-color:'+
		'$1;left:$2;top:$3;width:$4;height:$5"></div>\n');
}


function htmPrtRpc()
{
	return this.htm.replace(
		regex,
		'<div style="overflow:hidden;position:absolute;background-color:'+
		'$1;left:$2;top:$3;width:$4;height:$5;border-left:$4px solid $1"></div>\n');
}


function mkLin(x1, y1, x2, y2)
{
	if (x1 > x2)
	{
		var _x2 = x2;
		var _y2 = y2;
		x2 = x1;
		y2 = y1;
		x1 = _x2;
		y1 = _y2;
	}
	var dx = x2-x1, dy = Math.abs(y2-y1),
	x = x1, y = y1,
	yIncr = (y1 > y2)? -1 : 1;

	if (dx >= dy)
	{
		var pr = dy<<1,
		pru = pr - (dx<<1),
		p = pr-dx,
		ox = x;
		while ((dx--) > 0)
		{
			++x;
			if (p > 0)
			{
				this.mkDiv(ox, y, x-ox, 1);
				y += yIncr;
				p += pru;
				ox = x;
			}
			else p += pr;
		}
		this.mkDiv(ox, y, x2-ox+1, 1);
	}

	else
	{
		var pr = dx<<1,
		pru = pr - (dy<<1),
		p = pr-dy,
		oy = y;
		if (y2 <= y1)
		{
			while ((dy--) > 0)
			{
				if (p > 0)
				{
					this.mkDiv(x++, y, 1, oy-y+1);
					y += yIncr;
					p += pru;
					oy = y;
				}
				else
				{
					y += yIncr;
					p += pr;
				}
			}
			this.mkDiv(x2, y2, 1, oy-y2+1);
		}
		else
		{
			while ((dy--) > 0)
			{
				y += yIncr;
				if (p > 0)
				{
					this.mkDiv(x++, oy, 1, y-oy);
					p += pru;
					oy = y;
				}
				else p += pr;
			}
			this.mkDiv(x2, oy, 1, y2-oy+1);
		}
	}
}


function mkLin2D(x1, y1, x2, y2)
{
	if (x1 > x2)
	{
		var _x2 = x2;
		var _y2 = y2;
		x2 = x1;
		y2 = y1;
		x1 = _x2;
		y1 = _y2;
	}
	var dx = x2-x1, dy = Math.abs(y2-y1),
	x = x1, y = y1,
	yIncr = (y1 > y2)? -1 : 1;

	var s = this.stroke;
	if (dx >= dy)
	{
		if (s-3 > 0)
		{
			var _s = (s*dx*Math.sqrt(1+dy*dy/(dx*dx))-dx-(s>>1)*dy) / dx;
			_s = (!(s-4)? Math.ceil(_s) : Math.round(_s)) + 1;
		}
		else var _s = s;
		var ad = Math.ceil(s/2);

		var pr = dy<<1,
		pru = pr - (dx<<1),
		p = pr-dx,
		ox = x;
		while ((dx--) > 0)
		{
			++x;
			if (p > 0)
			{
				this.mkDiv(ox, y, x-ox+ad, _s);
				y += yIncr;
				p += pru;
				ox = x;
			}
			else p += pr;
		}
		this.mkDiv(ox, y, x2-ox+ad+1, _s);
	}

	else
	{
		if (s-3 > 0)
		{
			var _s = (s*dy*Math.sqrt(1+dx*dx/(dy*dy))-(s>>1)*dx-dy) / dy;
			_s = (!(s-4)? Math.ceil(_s) : Math.round(_s)) + 1;
		}
		else var _s = s;
		var ad = Math.round(s/2);

		var pr = dx<<1,
		pru = pr - (dy<<1),
		p = pr-dy,
		oy = y;
		if (y2 <= y1)
		{
			++ad;
			while ((dy--) > 0)
			{
				if (p > 0)
				{
					this.mkDiv(x++, y, _s, oy-y+ad);
					y += yIncr;
					p += pru;
					oy = y;
				}
				else
				{
					y += yIncr;
					p += pr;
				}
			}
			this.mkDiv(x2, y2, _s, oy-y2+ad);
		}
		else
		{
			while ((dy--) > 0)
			{
				y += yIncr;
				if (p > 0)
				{
					this.mkDiv(x++, oy, _s, y-oy+ad);
					p += pru;
					oy = y;
				}
				else p += pr;
			}
			this.mkDiv(x2, oy, _s, y2-oy+ad+1);
		}
	}
}


function mkLinDott(x1, y1, x2, y2)
{
	if (x1 > x2)
	{
		var _x2 = x2;
		var _y2 = y2;
		x2 = x1;
		y2 = y1;
		x1 = _x2;
		y1 = _y2;
	}
	var dx = x2-x1, dy = Math.abs(y2-y1),
	x = x1, y = y1,
	yIncr = (y1 > y2)? -1 : 1,
	drw = true;
	if (dx >= dy)
	{
		var pr = dy<<1,
		pru = pr - (dx<<1),
		p = pr-dx;
		while ((dx--) > 0)
		{
			if (drw) this.mkDiv(x, y, 1, 1);
			drw = !drw;
			if (p > 0)
			{
				y += yIncr;
				p += pru;
			}
			else p += pr;
			++x;
		}
		if (drw) this.mkDiv(x, y, 1, 1);
	}

	else
	{
		var pr = dx<<1,
		pru = pr - (dy<<1),
		p = pr-dy;
		while ((dy--) > 0)
		{
			if (drw) this.mkDiv(x, y, 1, 1);
			drw = !drw;
			y += yIncr;
			if (p > 0)
			{
				++x;
				p += pru;
			}
			else p += pr;
		}
		if (drw) this.mkDiv(x, y, 1, 1);
	}
}


function mkOv(left, top, width, height)
{
	var a = width>>1, b = height>>1,
	wod = width&1, hod = (height&1)+1,
	cx = left+a, cy = top+b,
	x = 0, y = b,
	ox = 0, oy = b,
	aa = (a*a)<<1, bb = (b*b)<<1,
	st = (aa>>1)*(1-(b<<1)) + bb,
	tt = (bb>>1) - aa*((b<<1)-1),
	w, h;
	while (y > 0)
	{
		if (st < 0)
		{
			st += bb*((x<<1)+3);
			tt += (bb<<1)*(++x);
		}
		else if (tt < 0)
		{
			st += bb*((x<<1)+3) - (aa<<1)*(y-1);
			tt += (bb<<1)*(++x) - aa*(((y--)<<1)-3);
			w = x-ox;
			h = oy-y;
			if (w&2 && h&2)
			{
				this.mkOvQds(cx, cy, -x+2, ox+wod, -oy, oy-1+hod, 1, 1);
				this.mkOvQds(cx, cy, -x+1, x-1+wod, -y-1, y+hod, 1, 1);
			}
			else this.mkOvQds(cx, cy, -x+1, ox+wod, -oy, oy-h+hod, w, h);
			ox = x;
			oy = y;
		}
		else
		{
			tt -= aa*((y<<1)-3);
			st -= (aa<<1)*(--y);
		}
	}
	this.mkDiv(cx-a, cy-oy, a-ox+1, (oy<<1)+hod);
	this.mkDiv(cx+ox+wod, cy-oy, a-ox+1, (oy<<1)+hod);
}


function mkOv2D(left, top, width, height)
{
	var s = this.stroke;
	width += s-1;
	height += s-1;
	var a = width>>1, b = height>>1,
	wod = width&1, hod = (height&1)+1,
	cx = left+a, cy = top+b,
	x = 0, y = b,
	aa = (a*a)<<1, bb = (b*b)<<1,
	st = (aa>>1)*(1-(b<<1)) + bb,
	tt = (bb>>1) - aa*((b<<1)-1);

	if (s-4 < 0 && (!(s-2) || width-51 > 0 && height-51 > 0))
	{
		var ox = 0, oy = b,
		w, h,
		pxl, pxr, pxt, pxb, pxw;
		while (y > 0)
		{
			if (st < 0)
			{
				st += bb*((x<<1)+3);
				tt += (bb<<1)*(++x);
			}
			else if (tt < 0)
			{
				st += bb*((x<<1)+3) - (aa<<1)*(y-1);
				tt += (bb<<1)*(++x) - aa*(((y--)<<1)-3);
				w = x-ox;
				h = oy-y;

				if (w-1)
				{
					pxw = w+1+(s&1);
					h = s;
				}
				else if (h-1)
				{
					pxw = s;
					h += 1+(s&1);
				}
				else pxw = h = s;
				this.mkOvQds(cx, cy, -x+1, ox-pxw+w+wod, -oy, -h+oy+hod, pxw, h);
				ox = x;
				oy = y;
			}
			else
			{
				tt -= aa*((y<<1)-3);
				st -= (aa<<1)*(--y);
			}
		}
		this.mkDiv(cx-a, cy-oy, s, (oy<<1)+hod);
		this.mkDiv(cx+a+wod-s+1, cy-oy, s, (oy<<1)+hod);
	}

	else
	{
		var _a = (width-((s-1)<<1))>>1,
		_b = (height-((s-1)<<1))>>1,
		_x = 0, _y = _b,
		_aa = (_a*_a)<<1, _bb = (_b*_b)<<1,
		_st = (_aa>>1)*(1-(_b<<1)) + _bb,
		_tt = (_bb>>1) - _aa*((_b<<1)-1),

		pxl = new Array(),
		pxt = new Array(),
		_pxb = new Array();
		pxl[0] = 0;
		pxt[0] = b;
		_pxb[0] = _b-1;
		while (y > 0)
		{
			if (st < 0)
			{
				st += bb*((x<<1)+3);
				tt += (bb<<1)*(++x);
				pxl[pxl.length] = x;
				pxt[pxt.length] = y;
			}
			else if (tt < 0)
			{
				st += bb*((x<<1)+3) - (aa<<1)*(y-1);
				tt += (bb<<1)*(++x) - aa*(((y--)<<1)-3);
				pxl[pxl.length] = x;
				pxt[pxt.length] = y;
			}
			else
			{
				tt -= aa*((y<<1)-3);
				st -= (aa<<1)*(--y);
			}

			if (_y > 0)
			{
				if (_st < 0)
				{
					_st += _bb*((_x<<1)+3);
					_tt += (_bb<<1)*(++_x);
					_pxb[_pxb.length] = _y-1;
				}
				else if (_tt < 0)
				{
					_st += _bb*((_x<<1)+3) - (_aa<<1)*(_y-1);
					_tt += (_bb<<1)*(++_x) - _aa*(((_y--)<<1)-3);
					_pxb[_pxb.length] = _y-1;
				}
				else
				{
					_tt -= _aa*((_y<<1)-3);
					_st -= (_aa<<1)*(--_y);
					_pxb[_pxb.length-1]--;
				}
			}
		}

		var ox = 0, oy = b,
		_oy = _pxb[0],
		l = pxl.length,
		w, h;
		for (var i = 0; i < l; i++)
		{
			if (typeof _pxb[i] != "undefined")
			{
				if (_pxb[i] < _oy || pxt[i] < oy)
				{
					x = pxl[i];
					this.mkOvQds(cx, cy, -x+1, ox+wod, -oy, _oy+hod, x-ox, oy-_oy);
					ox = x;
					oy = pxt[i];
					_oy = _pxb[i];
				}
			}
			else
			{
				x = pxl[i];
				this.mkDiv(cx-x+1, cy-oy, 1, (oy<<1)+hod);
				this.mkDiv(cx+ox+wod, cy-oy, 1, (oy<<1)+hod);
				ox = x;
				oy = pxt[i];
			}
		}
		this.mkDiv(cx-a, cy-oy, 1, (oy<<1)+hod);
		this.mkDiv(cx+ox+wod, cy-oy, 1, (oy<<1)+hod);
	}
}


function mkOvDott(left, top, width, height)
{
	var a = width>>1, b = height>>1,
	wod = width&1, hod = height&1,
	cx = left+a, cy = top+b,
	x = 0, y = b,
	aa2 = (a*a)<<1, aa4 = aa2<<1, bb = (b*b)<<1,
	st = (aa2>>1)*(1-(b<<1)) + bb,
	tt = (bb>>1) - aa2*((b<<1)-1),
	drw = true;
	while (y > 0)
	{
		if (st < 0)
		{
			st += bb*((x<<1)+3);
			tt += (bb<<1)*(++x);
		}
		else if (tt < 0)
		{
			st += bb*((x<<1)+3) - aa4*(y-1);
			tt += (bb<<1)*(++x) - aa2*(((y--)<<1)-3);
		}
		else
		{
			tt -= aa2*((y<<1)-3);
			st -= aa4*(--y);
		}
		if (drw) this.mkOvQds(cx, cy, -x, x+wod, -y, y+hod, 1, 1);
		drw = !drw;
	}
}


function mkRect(x, y, w, h)
{
	var s = this.stroke;
	this.mkDiv(x, y, w, s);
	this.mkDiv(x+w, y, s, h);
	this.mkDiv(x, y+h, w+s, s);
	this.mkDiv(x, y+s, s, h-s);
}


function mkRectDott(x, y, w, h)
{
	this.drawLine(x, y, x+w, y);
	this.drawLine(x+w, y, x+w, y+h);
	this.drawLine(x, y+h, x+w, y+h);
	this.drawLine(x, y, x, y+h);
}


function jsgFont()
{
	this.PLAIN = 'font-weight:normal;';
	this.BOLD = 'font-weight:bold;';
	this.ITALIC = 'font-style:italic;';
	this.ITALIC_BOLD = this.ITALIC + this.BOLD;
	this.BOLD_ITALIC = this.ITALIC_BOLD;
}
var Font = new jsgFont();


function jsgStroke()
{
	this.DOTTED = -1;
}
var Stroke = new jsgStroke();


function jsGraphics(id, wnd)
{
	this.setColor = new Function('arg', 'this.color = arg.toLowerCase();');

	this.setStroke = function(x)
	{
		this.stroke = x;
		if (!(x+1))
		{
			this.drawLine = mkLinDott;
			this.mkOv = mkOvDott;
			this.drawRect = mkRectDott;
		}
		else if (x-1 > 0)
		{
			this.drawLine = mkLin2D;
			this.mkOv = mkOv2D;
			this.drawRect = mkRect;
		}
		else
		{
			this.drawLine = mkLin;
			this.mkOv = mkOv;
			this.drawRect = mkRect;
		}
	};


	this.setPrintable = function(arg)
	{
		this.printable = arg;
		if (jg_fast)
		{
			this.mkDiv = mkDivIe;
			this.htmRpc = arg? htmPrtRpc : htmRpc;
		}
		else this.mkDiv = jg_n4? mkLyr : arg? mkDivPrt : mkDiv;
	};


	this.setFont = function(fam, sz, sty)
	{
		this.ftFam = fam;
		this.ftSz = sz;
		this.ftSty = sty || Font.PLAIN;
	};


	this.drawPolyline = this.drawPolyLine = function(x, y, s)
	{
		for (var i=0 ; i<x.length-1 ; i++ )
			this.drawLine(x[i], y[i], x[i+1], y[i+1]);
	};


	this.fillRect = function(x, y, w, h)
	{
		this.mkDiv(x, y, w, h);
	};


	this.drawPolygon = function(x, y)
	{
		this.drawPolyline(x, y);
		this.drawLine(x[x.length-1], y[x.length-1], x[0], y[0]);
	};


	this.drawEllipse = this.drawOval = function(x, y, w, h)
	{
		this.mkOv(x, y, w, h);
	};


	this.fillEllipse = this.fillOval = function(left, top, w, h)
	{
		var a = (w -= 1)>>1, b = (h -= 1)>>1,
		wod = (w&1)+1, hod = (h&1)+1,
		cx = left+a, cy = top+b,
		x = 0, y = b,
		ox = 0, oy = b,
		aa2 = (a*a)<<1, aa4 = aa2<<1, bb = (b*b)<<1,
		st = (aa2>>1)*(1-(b<<1)) + bb,
		tt = (bb>>1) - aa2*((b<<1)-1),
		pxl, dw, dh;
		if (w+1) while (y > 0)
		{
			if (st < 0)
			{
				st += bb*((x<<1)+3);
				tt += (bb<<1)*(++x);
			}
			else if (tt < 0)
			{
				st += bb*((x<<1)+3) - aa4*(y-1);
				pxl = cx-x;
				dw = (x<<1)+wod;
				tt += (bb<<1)*(++x) - aa2*(((y--)<<1)-3);
				dh = oy-y;
				this.mkDiv(pxl, cy-oy, dw, dh);
				this.mkDiv(pxl, cy+oy-dh+hod, dw, dh);
				ox = x;
				oy = y;
			}
			else
			{
				tt -= aa2*((y<<1)-3);
				st -= aa4*(--y);
			}
		}
		this.mkDiv(cx-a, cy-oy, w+1, (oy<<1)+hod);
	};


/* fillPolygon method, implemented by Matthieu Haller.
This javascript function is an adaptation of the gdImageFilledPolygon for Walter Zorn lib.
C source of GD 1.8.4 found at http://www.boutell.com/gd/

THANKS to Kirsten Schulz for the polygon fixes!

The intersection finding technique of this code could be improved
by remembering the previous intertersection, and by using the slope.
That could help to adjust intersections to produce a nice
interior_extrema. */
	this.fillPolygon = function(array_x, array_y)
	{
		var i;
		var y;
		var miny, maxy;
		var x1, y1;
		var x2, y2;
		var ind1, ind2;
		var ints;

		var n = array_x.length;

		if (!n) return;


		miny = array_y[0];
		maxy = array_y[0];
		for (i = 1; i < n; i++)
		{
			if (array_y[i] < miny)
				miny = array_y[i];

			if (array_y[i] > maxy)
				maxy = array_y[i];
		}
		for (y = miny; y <= maxy; y++)
		{
			var polyInts = new Array();
			ints = 0;
			for (i = 0; i < n; i++)
			{
				if (!i)
				{
					ind1 = n-1;
					ind2 = 0;
				}
				else
				{
					ind1 = i-1;
					ind2 = i;
				}
				y1 = array_y[ind1];
				y2 = array_y[ind2];
				if (y1 < y2)
				{
					x1 = array_x[ind1];
					x2 = array_x[ind2];
				}
				else if (y1 > y2)
				{
					y2 = array_y[ind1];
					y1 = array_y[ind2];
					x2 = array_x[ind1];
					x1 = array_x[ind2];
				}
				else continue;

				 // modified 11. 2. 2004 Walter Zorn
				if ((y >= y1) && (y < y2))
					polyInts[ints++] = Math.round((y-y1) * (x2-x1) / (y2-y1) + x1);

				else if ((y == maxy) && (y > y1) && (y <= y2))
					polyInts[ints++] = Math.round((y-y1) * (x2-x1) / (y2-y1) + x1);
			}
			polyInts.sort(integer_compare);
			for (i = 0; i < ints; i+=2)
				this.mkDiv(polyInts[i], y, polyInts[i+1]-polyInts[i]+1, 1);
		}
	};


	this.drawString = function(txt, x, y)
	{
		this.htm += '<div style="position:absolute;white-space:nowrap;'+
			'left:' + x + 'px;'+
			'top:' + y + 'px;'+
			'font-family:' +  this.ftFam + ';'+
			'font-size:' + this.ftSz + ';'+
			'color:' + this.color + ';' + this.ftSty + '">'+
			txt +
			'<\/div>';
	};


/* drawStringRect() added by Rick Blommers.
Allows to specify the size of the text rectangle and to align the
text both horizontally (e.g. right) and vertically within that rectangle */
	this.drawStringRect = function(txt, x, y, width, halign)
	{
		this.htm += '<div style="position:absolute;overflow:hidden;'+
			'left:' + x + 'px;'+
			'top:' + y + 'px;'+
			'width:'+width +'px;'+
			'text-align:'+halign+';'+
			'font-family:' +  this.ftFam + ';'+
			'font-size:' + this.ftSz + ';'+
			'color:' + this.color + ';' + this.ftSty + '">'+
			txt +
			'<\/div>';
	};


	this.drawImage = function(imgSrc, x, y, w, h)
	{
		this.htm += '<div style="position:absolute;'+
			'left:' + x + 'px;'+
			'top:' + y + 'px;'+
			'width:' +  w + ';'+
			'height:' + h + ';">'+
			'<img src="' + imgSrc + '" width="' + w + '" height="' + h + '">'+
			'<\/div>';
	};


	this.clear = function()
	{
		this.htm = "";
		if (this.cnv) this.cnv.innerHTML = this.defhtm;
	};


	this.mkOvQds = function(cx, cy, xl, xr, yt, yb, w, h)
	{
		this.mkDiv(xr+cx, yt+cy, w, h);
		this.mkDiv(xr+cx, yb+cy, w, h);
		this.mkDiv(xl+cx, yb+cy, w, h);
		this.mkDiv(xl+cx, yt+cy, w, h);
	};

	this.setStroke(1);
	this.setFont('verdana,geneva,helvetica,sans-serif', String.fromCharCode(0x31, 0x32, 0x70, 0x78), Font.PLAIN);
	this.color = '#000000';
	this.htm = '';
	this.wnd = wnd || window;

	if (!(jg_ie || jg_dom || jg_ihtm)) chkDHTM();
	if (typeof id != 'string' || !id) this.paint = pntDoc;
	else
	{
		this.cnv = document.all? (this.wnd.document.all[id] || null)
			: document.getElementById? (this.wnd.document.getElementById(id) || null)
			: null;
		this.defhtm = (this.cnv && this.cnv.innerHTML)? this.cnv.innerHTML : '';
		this.paint = jg_dom? pntCnvDom : jg_ie? pntCnvIe : jg_ihtm? pntCnvIhtm : pntCnv;
	}

	this.setPrintable(false);
}



function integer_compare(x,y)
{
	return (x < y) ? -1 : ((x > y)*1);
}

/******************************************************************************
 * kaZoomer
 *
 * class to handle the zoom overlay
 *
 * oKaMap - the ka-Map instance to draw the zoomer on
 *
 *****************************************************************************/
function kaZoomer()
{
	this.nZoomImageHeight = 8;
	this.opacity = 100;
	this.left = 7;
	this.top = 3;
	this.right = null;
	this.bottom = null;
	this.zoomControlObj = null;
	this.draw = kaZoomer_draw;
	this.update = kaZoomer_update;
	this.listeners = [];
}

kaZoomer.prototype.attach = function(oKaMap)
{
    this.kaMap = oKaMap;
    //get the viewport
    this.domObj = oKaMap.domObj;    
   
   	// don't draw until initialized
   	if (this.kaMap.initializationState < 2) {
		this.kaMap.registerForEvent( KAMAP_MAP_INITIALIZED, this, this.draw );
	} else {
		this.draw();
	}
}

kaZoomer.prototype.remove = function()
{
	if (this.zoomControlObj && this.zoomControlObj != null)
	{
		for (var i=0; i<this.listeners.length; i++)
			PEvent.removeListener(this.listeners[i]);
		this.listeners = [];
		while (this.zoomControlObj.hasChildNodes())
			this.zoomControlObj.removeChild(this.zoomControlObj.firstChild);
		if (this.kaMap && this.kaMap != null) 
			this.kaMap.domObj.removeChild(this.zoomControlObj);
	}
}

function kaZoomer_setPosition( left, top, right, bottom )
{
    this.left = left;
    this.top = top;
    this.right = right;
    this.bottom = bottom;
    
    if (this.zoomControlObj != null)
    {
        if (this.left != null)
        {
            oZoomControl.style.left = this.left + 'px';
        }
        else if (this.right != null)
        {
            oZoomControl.style.right = this.right + 'px';
        }
        if (this.top != null)
        {
            oZoomControl.style.top = this.top + 'px';
        }
        else if (this.bottom != null)
        {
            oZoomControl.style.bottom = this.bottom + 'px';
        }
    }
}

//handle a map zoom change from another tool
function kaZoomer_update()
{
    
    var nThumbHeight = dd.elements.zoomTrack.div.elementHeight;
    var nTrackTop = dd.elements.zoomTrack.y;
    
    var oKaMap = dd.elements.zoomTrack.div.kaZoomer.kaMap;
    var oMap = oKaMap.getCurrentMap();
    var nCurrentScale = parseInt(oMap.currentScale) + 1; //array is zero based
    var nScales = oMap.getScales().length;
    var nTrackHeight = this.nZoomImageHeight * nScales;
    var nPos = (nScales-nCurrentScale)*nThumbHeight;
    dd.elements.zoomThumb.moveTo(dd.elements.zoomThumb.x,nTrackTop + nPos);
}

//set up the slider UI.
function kaZoomer_draw()
{
    //get scale info for the current map.
    var oMap = this.kaMap.getCurrentMap();
    var nScales = oMap.getScales().length;
    var nCurrentScale = oMap.currentScale;
    var nTrackHeight = this.nZoomImageHeight * nScales;
    var nTrackMaxPosition = this.nZoomImageHeight * (nScales - 1);
    var nInitialPosition = dd.Int(this.nZoomImageHeight * 
                                  (nScales - nCurrentScale - 1));
    //widget images
    var szThumbImg = this.kaMap.server + 'images/control_slider.png';
    var szThumbImgOver = this.kaMap.server + 'images/control_slider_over.png';
    
    //container div
    this.zoomControlObj = document.createElement('div');
    this.zoomControlObj.id = 'zoomControl';
    this.zoomControlObj.style.position = 'absolute';
    if (this.left != null) 
    	this.zoomControlObj.style.left = this.left + 'px';
    else if (this.right != null)
        this.zoomControlObj.style.right = this.right + 'px';
    if (this.top != null)
        this.zoomControlObj.style.top = this.top + 'px';
    else if (this.bottom != null)
        this.zoomControlObj.style.bottom = this.bottom + 'px';
    
    this.zoomControlObj.style.width = 29 + "px";
	// make sure this height accounts for spacing between buttons
    this.zoomControlObj.style.height = (nTrackHeight + 2 * this.nZoomImageHeight + 30) + "px"; 
    this.zoomControlObj.style.zIndex = 300;
    this.zoomControlObj.kaZoomer = this;
    this.zoomControlObj.style.MozUserSelect = 'none';
    this.kaMap.domObj.appendChild(this.zoomControlObj);
    
    //draw the widget
    var oZoomTrack = document.createElement( 'div' );
    oZoomTrack.id = 'zoomTrack';
    oZoomTrack.kaZoomer = this;
    oZoomTrack.style.position = 'absolute';
    oZoomTrack.style.left = '0px';
    oZoomTrack.style.top = '28px';
    oZoomTrack.style.height = parseInt(nTrackHeight) + 'px';
    oZoomTrack.style.width = '29px';
    addPNGBackground(oZoomTrack,this.kaMap.server + "images/control_zoombar.png");
    oZoomTrack.style.backgroundRepeat = "no-repeat";
    oZoomTrack.elementHeight = this.nZoomImageHeight;
    this.listeners.push(PEvent.addListener(oZoomTrack, 'click', kaZoomer_zoomTo));
    this.zoomControlObj.appendChild(oZoomTrack);
   
	var oZoomThumb = document.createElement('div');
	oZoomThumb.id = 'zoomThumb';
	oZoomThumb.title = 'Drag to Zoom';
	oZoomThumb.style.position = 'absolute';
	oZoomThumb.style.width = "29px";
	oZoomThumb.style.height = "7px";
	this.listeners.push(PEvent.addListener(oZoomThumb, 'mouseover', function() { addPNGBackground(this,szThumbImgOver); }));
	this.listeners.push(PEvent.addListener(oZoomThumb, 'mouseout', function() { addPNGBackground(this,szThumbImg); })); 
	addPNGBackground(oZoomThumb,szThumbImg);
	this.zoomControlObj.appendChild(oZoomThumb);

	//add +/- labels
	var zoomKamap = this.kaMap;
	var oZoomIn = document.createElement('img');
	var oZoomInImg = this.kaMap.server+"images/control_zoomin.png";
	var oZoomInImgOver = this.kaMap.server+"images/control_zoomin_over.png";
	oZoomIn.title = 'Zoom In';
	oZoomIn.id = 'zoomIn';
	oZoomIn.style.position = 'absolute';
	oZoomIn.style.top = '0px';
	oZoomIn.style.left = '2px';
	oZoomIn.style.width = '25px';
	oZoomIn.style.height = '25px';
	oZoomIn.style.cursor = 'pointer';
	oZoomIn.src = oZoomInImg;
	oZoomIn.kaZoomer = this;
	this.listeners.push(PEvent.addListener(oZoomIn, 'mouseover', function() { this.src = oZoomInImgOver; }));
	this.listeners.push(PEvent.addListener(oZoomIn, 'mouseout', function() { this.src = oZoomInImg; }));
	this.listeners.push(PEvent.addListener(oZoomIn, 'click', function() { kaZoomer_zoomIn(zoomKamap); }));
	this.zoomControlObj.appendChild(oZoomIn);

	var oZoomOut = document.createElement('img');
	var oZoomOutImg = this.kaMap.server+"images/control_zoomout.png";
	var oZoomOutImgOver = this.kaMap.server+"images/control_zoomout_over.png";
	oZoomOut.id = 'zoomOut';
	oZoomOut.title = 'Zoom Out';
	oZoomOut.style.position = 'absolute';
	oZoomOut.style.top = 30 + nTrackHeight + 'px';
	oZoomOut.style.left = '2px';
	oZoomOut.style.width = '25px';
	oZoomOut.style.height = '25px';
	oZoomOut.style.cursor = 'pointer';
	oZoomOut.src = oZoomOutImg;
	oZoomOut.kaZoomer = this;
	this.listeners.push(PEvent.addListener(oZoomOut, 'mouseover', function() { this.src = oZoomOutImgOver; }));
	this.listeners.push(PEvent.addListener(oZoomOut, 'mouseout', function() { this.src = oZoomOutImg; }));
	this.listeners.push(PEvent.addListener(oZoomOut, 'click', function() { kaZoomer_zoomOut(zoomKamap) }));
	this.zoomControlObj.appendChild(oZoomOut);

    //set up drag and drop
    ADD_DHTML('zoomThumb'+MAXOFFTOP+0+MAXOFFBOTTOM+nTrackMaxPosition+VERTICAL);
    //document.title = ('zoomThumb'+MAXOFFTOP+0+MAXOFFBOTTOM+nTrackMaxPosition+VERTICAL);
    ADD_DHTML('zoomTrack'+NO_DRAG);
    //document.title = ('zoomTrack'+NO_DRAG);

    dd.elements.zoomThumb.moveTo(dd.elements.zoomTrack.x, dd.elements.zoomTrack.y + nInitialPosition);
    dd.elements.zoomThumb.css.cursor = 'pointer';
    dd.elements.zoomThumb.setZ(dd.elements.zoomTrack.z+1);

    dd.elements.zoomTrack.addChild('zoomThumb');
    dd.elements.zoomTrack.css.cursor = 'pointer';

    dd.elements.zoomThumb.defx = dd.elements.zoomTrack.x;
    dd.elements.zoomThumb.defy = dd.elements.zoomTrack.y;
    
    dd.elements.zoomThumb.my_DropFunc = kaZoomer_DropFunc;
    
    this.kaMap.registerForEvent( KAMAP_SCALE_CHANGED, this, this.update );
}

//wz_dragdrop.js overriden function for responding to a release of the slider
function kaZoomer_DropFunc()
{
    //move thumb to closest scale marker
    var nTrackTop = dd.elements.zoomTrack.y;
    
    var nThumbTop = dd.elements.zoomThumb.y - nTrackTop;
    var nThumbHeight = dd.elements.zoomTrack.div.elementHeight;
    
    var nNearestIndex = Math.round(nThumbTop / nThumbHeight);
    dd.elements.zoomThumb.moveTo(dd.elements.zoomThumb.x,nTrackTop +(nNearestIndex*nThumbHeight));
    dd.elements.zoomThumb.css.cursor = 'pointer';
    
    //perform zoom
    var oKaMap = dd.elements.zoomTrack.div.kaZoomer.kaMap;
    var oMap = oKaMap.getCurrentMap();
    var nCurrentScale = oMap.getScales()[oMap.aScales.length - nNearestIndex - 1];
    oKaMap.zoomToScale(nCurrentScale);
}

//zoom to the level clicked in the track
function kaZoomer_zoomTo( e )
{
    e = (e)?e:((event)?event:null);
    var nClickTop = (e.layerY)?e.layerY:e.offsetY;
    //find current track height
    var oKaZoomer = dd.elements.zoomTrack.div.kaZoomer;
    var oKaMap = oKaZoomer.kaMap;
    var oMap = oKaMap.getCurrentMap();
    var nScales = oMap.getScales().length;
    var nTrackHeight = dd.Int(oKaZoomer.nZoomImageHeight) * nScales;
    
    //zoome to closest scale
    var nNearestIndex = Math.floor(nClickTop / nTrackHeight * nScales);
    var nNewScale = oMap.getScales()[oMap.aScales.length - nNearestIndex - 1];
    oKaMap.zoomToScale(nNewScale);
}

function kaZoomer_onmouseover( e )
{
    this.style.opacity = 1;
    this.style.mozOpacity = 1;
    this.style.filter = "Alpha(opacity=100)";
}

function kaZoomer_onmouseout( e )
{
    this.style.opacity = this.kaZoomer.opacity/100;
    this.style.mozOpacity = this.kaZoomer.opacity/100;
    this.style.filter = "Alpha(opacity="+this.kaZoomer.opacity+")";
}

function kaZoomer_zoomIn(kaMap)
{
    kaMap.zoomIn();
}

function kaZoomer_zoomOut(kaMap)
{
    kaMap.zoomOut();
}

function kaZoomer_alert()
{
    alert('here');
}

kaServers = function()
{
	this.current = -1;
	this.servers;
}

kaServers.prototype.setServers = function(servs)
{
	this.servers = servs;
}

kaServers.prototype.nextIndex = function()
{
	this.current++;
	this.current = this.current % this.servers.length;

	return this.current;
}

kaServers.prototype.next = function(key)
{
	if (key) return this.servers[this.hash(key)];
	else return this.servers[this.nextIndex()];
}

// returns the index (in the list of servers) for the given
// key using a hash algorithm based on the key argument.
kaServers.prototype.hash = function(key)
{
	return Math.abs(key % this.servers.length);
}

kaServers.prototype.isEmpty = function()
{
	return this.servers == undefined;
}



/***

MochiKit.Base 1.3.1

See <http://mochikit.com/> for documentation, downloads, license, etc.

(c) 2005 Bob Ippolito.  All rights Reserved.

***/

if (typeof(dojo) != 'undefined') {
    dojo.provide("MochiKit.Base");
}

if (typeof(MochiKit) == 'undefined') {
    MochiKit = {};
}
if (typeof(MochiKit.Base) == 'undefined') {
    MochiKit.Base = {};
}

MochiKit.Base.VERSION = "1.3.1";
MochiKit.Base.NAME = "MochiKit.Base";
MochiKit.Base.update = function (self, obj/*, ... */) {
    if (self === null) {
        self = {};
    }
    for (var i = 1; i < arguments.length; i++) {
        var o = arguments[i];
        if (typeof(o) != 'undefined' && o !== null) {
            for (var k in o) {
                self[k] = o[k];
            }
        }
    }
    return self;
};

MochiKit.Base.update(MochiKit.Base, {
    __repr__: function () {
        return "[" + this.NAME + " " + this.VERSION + "]";
    },

    toString: function () {
        return this.__repr__();
    },

    counter: function (n/* = 1 */) {
        if (arguments.length === 0) {
            n = 1;
        }
        return function () {
            return n++;
        };
    },
        
    clone: function (obj) {
        var me = arguments.callee;
        if (arguments.length == 1) {
            me.prototype = obj;
            return new me();
        }
    },
            
    flattenArguments: function (lst/* ...*/) {
        var res = [];
        var m = MochiKit.Base;
        var args = m.extend(null, arguments);
        while (args.length) {
            var o = args.shift();
            if (o && typeof(o) == "object" && typeof(o.length) == "number") {
                for (var i = o.length - 1; i >= 0; i--) {
                    args.unshift(o[i]);
                }
            } else {
                res.push(o);
            }
        }
        return res;
    },

    extend: function (self, obj, /* optional */skip) {        
        // Extend an array with an array-like object starting
        // from the skip index
        if (!skip) {
            skip = 0;
        }
        if (obj) {
            // allow iterable fall-through, but skip the full isArrayLike
            // check for speed, this is called often.
            var l = obj.length;
            if (typeof(l) != 'number' /* !isArrayLike(obj) */) {
                if (typeof(MochiKit.Iter) != "undefined") {
                    obj = MochiKit.Iter.list(obj);
                    l = obj.length;
                } else {
                    throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
                }
            }
            if (!self) {
                self = [];
            }
            for (var i = skip; i < l; i++) {
                self.push(obj[i]);
            }
        }
        // This mutates, but it's convenient to return because
        // it's often used like a constructor when turning some
        // ghetto array-like to a real array
        return self;
    },


    updatetree: function (self, obj/*, ...*/) {
        if (self === null) {
            self = {};
        }
        for (var i = 1; i < arguments.length; i++) {
            var o = arguments[i];
            if (typeof(o) != 'undefined' && o !== null) {
                for (var k in o) {
                    var v = o[k];
                    if (typeof(self[k]) == 'object' && typeof(v) == 'object') {
                        arguments.callee(self[k], v);
                    } else {
                        self[k] = v;
                    }
                }
            }
        }
        return self;
    },

    setdefault: function (self, obj/*, ...*/) {
        if (self === null) {
            self = {};
        }
        for (var i = 1; i < arguments.length; i++) {
            var o = arguments[i];
            for (var k in o) {
                if (!(k in self)) {
                    self[k] = o[k];
                }
            }
        }
        return self;
    },

    keys: function (obj) {
        var rval = [];
        for (var prop in obj) {
	    if (typeof obj[prop] != 'function')
            	rval.push(prop);
        }
        return rval;
    },
        
    items: function (obj) {
        var rval = [];
        var e;
        for (var prop in obj) {
            var v;
            try {
                v = obj[prop];
            } catch (e) {
                continue;
            }
	    if (typeof v != 'function')
            	rval.push([prop, v]);
        }
        return rval;
    },


    _newNamedError: function (module, name, func) {
        func.prototype = new MochiKit.Base.NamedError(module.NAME + "." + name);
        module[name] = func;
    },


    operator: {
        // unary logic operators
        truth: function (a) { return !!a; }, 
        lognot: function (a) { return !a; },
        identity: function (a) { return a; },

        // bitwise unary operators
        not: function (a) { return ~a; },
        neg: function (a) { return -a; },

        // binary operators
        add: function (a, b) { return a + b; },
        sub: function (a, b) { return a - b; },
        div: function (a, b) { return a / b; },
        mod: function (a, b) { return a % b; },
        mul: function (a, b) { return a * b; },

        // bitwise binary operators
        and: function (a, b) { return a & b; },
        or: function (a, b) { return a | b; },
        xor: function (a, b) { return a ^ b; },
        lshift: function (a, b) { return a << b; },
        rshift: function (a, b) { return a >> b; },
        zrshift: function (a, b) { return a >>> b; },

        // near-worthless built-in comparators
        eq: function (a, b) { return a == b; },
        ne: function (a, b) { return a != b; },
        gt: function (a, b) { return a > b; },
        ge: function (a, b) { return a >= b; },
        lt: function (a, b) { return a < b; },
        le: function (a, b) { return a <= b; },

        // compare comparators
        ceq: function (a, b) { return MochiKit.Base.compare(a, b) === 0; },
        cne: function (a, b) { return MochiKit.Base.compare(a, b) !== 0; },
        cgt: function (a, b) { return MochiKit.Base.compare(a, b) == 1; },
        cge: function (a, b) { return MochiKit.Base.compare(a, b) != -1; },
        clt: function (a, b) { return MochiKit.Base.compare(a, b) == -1; },
        cle: function (a, b) { return MochiKit.Base.compare(a, b) != 1; },

        // binary logical operators
        logand: function (a, b) { return a && b; },
        logor: function (a, b) { return a || b; },
        contains: function (a, b) { return b in a; }
    },

    forwardCall: function (func) {
        return function () {
            return this[func].apply(this, arguments);
        };
    },

    itemgetter: function (func) {
        return function (arg) {
            return arg[func];
        };
    },

    typeMatcher: function (/* typ */) {
        var types = {};
        for (var i = 0; i < arguments.length; i++) {
            var typ = arguments[i];
            types[typ] = typ;
        }
        return function () { 
            for (var i = 0; i < arguments.length; i++) {
                if (!(typeof(arguments[i]) in types)) {
                    return false;
                }
            }
            return true;
        };
    },

    isNull: function (/* ... */) {
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] !== null) {
                return false;
            }
        }
        return true;
    },

    isUndefinedOrNull: function (/* ... */) {
        for (var i = 0; i < arguments.length; i++) {
            var o = arguments[i];
            if (!(typeof(o) == 'undefined' || o === null)) {
                return false;
            }
        }
        return true;
    },

    isEmpty: function (obj) {
        return !MochiKit.Base.isNotEmpty.apply(this, arguments);
    },

    isNotEmpty: function (obj) {
        for (var i = 0; i < arguments.length; i++) {
            var o = arguments[i];
            if (!(o && o.length)) {
                return false;
            }
        }
        return true;
    },

    isArrayLike: function () {
        for (var i = 0; i < arguments.length; i++) {
            var o = arguments[i];
            var typ = typeof(o);
            if (
                (typ != 'object' && !(typ == 'function' && typeof(o.item) == 'function')) ||
                o === null ||
                typeof(o.length) != 'number'
            ) {
                return false;
            }
        }
        return true;
    },

    isDateLike: function () {
        for (var i = 0; i < arguments.length; i++) {
            var o = arguments[i];
            if (typeof(o) != "object" || o === null
                    || typeof(o.getTime) != 'function') {
                return false;
            }
        }
        return true;
    },


    xmap: function (fn/*, obj... */) {
        if (fn === null) {
            return MochiKit.Base.extend(null, arguments, 1);
        }
        var rval = [];
        for (var i = 1; i < arguments.length; i++) {
            rval.push(fn(arguments[i]));
        }
        return rval;
    },

    map: function (fn, lst/*, lst... */) {
        var m = MochiKit.Base;
        var itr = MochiKit.Iter;
        var isArrayLike = m.isArrayLike;
        if (arguments.length <= 2) {
            // allow an iterable to be passed
            if (!isArrayLike(lst)) {
                if (itr) {
                    // fast path for map(null, iterable)
                    lst = itr.list(lst);
                    if (fn === null) {
                        return lst;
                    }
                } else {
                    throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
                }
            }
            // fast path for map(null, lst)
            if (fn === null) {
                return m.extend(null, lst);
            }
            // disabled fast path for map(fn, lst)
            /*
            if (false && typeof(Array.prototype.map) == 'function') {
                // Mozilla fast-path
                return Array.prototype.map.call(lst, fn);
            }
            */
            var rval = [];
            for (var i = 0; i < lst.length; i++) {
                rval.push(fn(lst[i]));
            }
            return rval;
        } else {
            // default for map(null, ...) is zip(...)
            if (fn === null) {
                fn = Array;
            }
            var length = null;
            for (i = 1; i < arguments.length; i++) {
                // allow iterables to be passed
                if (!isArrayLike(arguments[i])) {
                    if (itr) {
                        return itr.list(itr.imap.apply(null, arguments));
                    } else {
                        throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
                    }
                }
                // find the minimum length
                var l = arguments[i].length;
                if (length === null || length > l) {
                    length = l;
                }
            }
            rval = [];
            for (i = 0; i < length; i++) {
                var args = [];
                for (var j = 1; j < arguments.length; j++) {
                    args.push(arguments[j][i]);
                }
                rval.push(fn.apply(this, args));
            }
            return rval;
        }
    },

    xfilter: function (fn/*, obj... */) {
        var rval = [];
        if (fn === null) {
            fn = MochiKit.Base.operator.truth;
        }
        for (var i = 1; i < arguments.length; i++) {
            var o = arguments[i];
            if (fn(o)) {
                rval.push(o);
            }
        }
        return rval;
    },

    filter: function (fn, lst, self) {
        var rval = [];
        // allow an iterable to be passed
        var m = MochiKit.Base;
        if (!m.isArrayLike(lst)) {
            if (MochiKit.Iter) {
                lst = MochiKit.Iter.list(lst);
            } else {
                throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
            }
        }
        if (fn === null) {
            fn = m.operator.truth;
        }
        if (typeof(Array.prototype.filter) == 'function') {
            // Mozilla fast-path
            return Array.prototype.filter.call(lst, fn, self);
        } else if (typeof(self) == 'undefined' || self === null) {
            for (var i = 0; i < lst.length; i++) {
                var o = lst[i];
                if (fn(o)) {
                    rval.push(o);
                }
            }
        } else {
            for (i = 0; i < lst.length; i++) {
                o = lst[i];
                if (fn.call(self, o)) {
                    rval.push(o);
                }
            }
        }
        return rval;
    },


    _wrapDumbFunction: function (func) {
        return function () {
            // fast path!
            switch (arguments.length) {
                case 0: return func();
                case 1: return func(arguments[0]);
                case 2: return func(arguments[0], arguments[1]);
                case 3: return func(arguments[0], arguments[1], arguments[2]);
            }
            var args = [];
            for (var i = 0; i < arguments.length; i++) {
                args.push("arguments[" + i + "]");
            }
            return eval("(func(" + args.join(",") + "))");
        };
    },
            
    method: function (self, func) {
        var m = MochiKit.Base;
        return m.bind.apply(this, m.extend([func, self], arguments, 2));
    },

    bind: function (func, self/* args... */) {
        if (typeof(func) == "string") {
            func = self[func];
        }
        var im_func = func.im_func;
        var im_preargs = func.im_preargs;
        var im_self = func.im_self;
        var m = MochiKit.Base;
        if (typeof(func) == "function" && typeof(func.apply) == "undefined") {
            // this is for cases where JavaScript sucks ass and gives you a
            // really dumb built-in function like alert() that doesn't have
            // an apply
            func = m._wrapDumbFunction(func);
        }
        if (typeof(im_func) != 'function') {
            im_func = func;
        }
        if (typeof(self) != 'undefined') {
            im_self = self;
        }
        if (typeof(im_preargs) == 'undefined') {
            im_preargs = [];
        } else  {
            im_preargs = im_preargs.slice();
        }
        m.extend(im_preargs, arguments, 2);
        var newfunc = function () {
            var args = arguments;
            var me = arguments.callee;
            if (me.im_preargs.length > 0) {
                args = m.concat(me.im_preargs, args);
            }
            var self = me.im_self;
            if (!self) {
                self = this;
            }
            return me.im_func.apply(self, args);
        };
        newfunc.im_self = im_self;
        newfunc.im_func = im_func;
        newfunc.im_preargs = im_preargs;
        return newfunc;
    },

    bindMethods: function (self) {
        var bind = MochiKit.Base.bind;
        for (var k in self) {
            var func = self[k];
            if (typeof(func) == 'function') {
                self[k] = bind(func, self);
            }
        }
    },

    registerComparator: function (name, check, comparator, /* optional */ override) {
        MochiKit.Base.comparatorRegistry.register(name, check, comparator, override);
    },

    _primitives: {'boolean': true, 'string': true, 'number': true},

    compare: function (a, b) {
        if (a == b) {
            return 0;
        }
        var aIsNull = (typeof(a) == 'undefined' || a === null || isNaN(a));
        var bIsNull = (typeof(b) == 'undefined' || b === null || isNaN(b));
        if (aIsNull && bIsNull) {
            return 0;
        } else if (aIsNull) {
            return -1;
        } else if (bIsNull) {
            return -1;
        }
        var m = MochiKit.Base;
        // bool, number, string have meaningful comparisons
        var prim = m._primitives;
        if (!(typeof(a) in prim && typeof(b) in prim)) {
            try {
                return m.comparatorRegistry.match(a, b);
            } catch (e) {
                if (e != m.NotFound) {
                    throw e;
                }
            }
        }
        if (a < b) {
            return -1;
        } else if (a > b) {
            return 1;
        }
        // These types can't be compared
        var repr = m.repr;
        throw new TypeError(repr(a) + " and " + repr(b) + " can not be compared");
    },

    compareDateLike: function (a, b) {
        return MochiKit.Base.compare(a.getTime(), b.getTime());
    },

    compareArrayLike: function (a, b) {
        var compare = MochiKit.Base.compare;
        var count = a.length;
        var rval = 0;
        if (count > b.length) {
            rval = 1;
            count = b.length;
        } else if (count < b.length) {
            rval = -1;
        }
        for (var i = 0; i < count; i++) {
            var cmp = compare(a[i], b[i]);
            if (cmp) {
                return cmp;
            }
        }
        return rval;
    },

    registerRepr: function (name, check, wrap, /* optional */override) {
        MochiKit.Base.reprRegistry.register(name, check, wrap, override);
    },

    repr: function (o) {
        if (typeof(o) == "undefined") {
            return "undefined";
        } else if (o === null) {
            return "null";
        }
        try {
            if (typeof(o.__repr__) == 'function') {
                return o.__repr__();
            } else if (typeof(o.repr) == 'function' && o.repr != arguments.callee) {
                return o.repr();
            }
            return MochiKit.Base.reprRegistry.match(o);
        } catch (e) {
            if (typeof(o.NAME) == 'string' && (
                    o.toString == Function.prototype.toString ||
                    o.toString == Object.prototype.toString
                )) {
                return o.NAME;
            }
        }
        try {
            var ostring = (o + "");
        } catch (e) {
            return "[" + typeof(o) + "]";
        }
        if (typeof(o) == "function") {
            o = ostring.replace(/^\s+/, "");
            var idx = o.indexOf("{");
            if (idx != -1) {
                o = o.substr(0, idx) + "{...}";
            }
        }
        return ostring;
    },

    reprArrayLike: function (o) {
        var m = MochiKit.Base;
        return "[" + m.map(m.repr, o).join(", ") + "]";
    },

    reprString: function (o) { 
        return ('"' + o.replace(/(["\\])/g, '\\$1') + '"'
            ).replace(/[\f]/g, "\\f"
            ).replace(/[\b]/g, "\\b"
            ).replace(/[\n]/g, "\\n"
            ).replace(/[\t]/g, "\\t"
            ).replace(/[\r]/g, "\\r");
    },

    reprNumber: function (o) {
        return o + "";
    },

    registerJSON: function (name, check, wrap, /* optional */override) {
        MochiKit.Base.jsonRegistry.register(name, check, wrap, override);
    },


    evalJSON: function () {
        return eval("(" + arguments[0] + ")");
    },

    serializeJSON: function (o) {
        var objtype = typeof(o);
        if (objtype == "undefined") {
            return "undefined";
        } else if (objtype == "number" || objtype == "boolean") {
            return o + "";
        } else if (o === null) {
            return "null";
        }
        var m = MochiKit.Base;
        var reprString = m.reprString;
        if (objtype == "string") {
            return reprString(o);
        }
        // recurse
        var me = arguments.callee;
        // short-circuit for objects that support "json" serialization
        // if they return "self" then just pass-through...
        var newObj;
        if (typeof(o.__json__) == "function") {
            newObj = o.__json__();
            if (o !== newObj) {
                return me(newObj);
            }
        }
        if (typeof(o.json) == "function") {
            newObj = o.json();
            if (o !== newObj) {
                return me(newObj);
            }
        }
        // array
        if (objtype != "function" && typeof(o.length) == "number") {
            var res = [];
            for (var i = 0; i < o.length; i++) {
                var val = me(o[i]);
                if (typeof(val) != "string") {
                    val = "undefined";
                }
                res.push(val);
            }
            return "[" + res.join(", ") + "]";
        }
        // look in the registry
        try {
            newObj = m.jsonRegistry.match(o);
            return me(newObj);
        } catch (e) {
            if (e != m.NotFound) {
                // something really bad happened
                throw e;
            }
        }
        // it's a function with no adapter, bad
        if (objtype == "function") {
            return null;
        }
        // generic object code path
        res = [];
        for (var k in o) {
            var useKey;
            if (typeof(k) == "number") {
                useKey = '"' + k + '"';
            } else if (typeof(k) == "string") {
                useKey = reprString(k);
            } else {
                // skip non-string or number keys
                continue;
            }
            val = me(o[k]);
            if (typeof(val) != "string") {
                // skip non-serializable values
                continue;
            }
            res.push(useKey + ":" + val);
        }
        return "{" + res.join(", ") + "}";
    },
            

    objEqual: function (a, b) {
        return (MochiKit.Base.compare(a, b) === 0);
    },

    arrayEqual: function (self, arr) {
        if (self.length != arr.length) {
            return false;
        }
        return (MochiKit.Base.compare(self, arr) === 0);
    },

    concat: function (/* lst... */) {
        var rval = [];
        var extend = MochiKit.Base.extend;
        for (var i = 0; i < arguments.length; i++) {
            extend(rval, arguments[i]);
        }
        return rval;
    },

    keyComparator: function (key/* ... */) {
        // fast-path for single key comparisons
        var m = MochiKit.Base;
        var compare = m.compare;
        if (arguments.length == 1) {
            return function (a, b) {
                return compare(a[key], b[key]);
            };
        }
        var compareKeys = m.extend(null, arguments);
        return function (a, b) {
            var rval = 0;
            // keep comparing until something is inequal or we run out of
            // keys to compare
            for (var i = 0; (rval === 0) && (i < compareKeys.length); i++) {
                var key = compareKeys[i];
                rval = compare(a[key], b[key]);
            }
            return rval;
        };
    },

    reverseKeyComparator: function (key) {
        var comparator = MochiKit.Base.keyComparator.apply(this, arguments);
        return function (a, b) {
            return comparator(b, a);
        };
    },

    partial: function (func) {
        var m = MochiKit.Base;
        return m.bind.apply(this, m.extend([func, undefined], arguments, 1));
    },
     
    listMinMax: function (which, lst) {
        if (lst.length === 0) {
            return null;
        }
        var cur = lst[0];
        var compare = MochiKit.Base.compare;
        for (var i = 1; i < lst.length; i++) {
            var o = lst[i];
            if (o != null && !isNaN(o) && compare(o, cur) == which) {
                cur = o;
            }
        }
        return cur;
    },

    objMax: function (/* obj... */) {
        return MochiKit.Base.listMinMax(1, arguments);
    },
            
    objMin: function (/* obj... */) {
        return MochiKit.Base.listMinMax(-1, arguments);
    },

    findIdentical: function (lst, value, start/* = 0 */, /* optional */end) {
        if (typeof(end) == "undefined" || end === null) {
            end = lst.length;
        }
        for (var i = (start || 0); i < end; i++) {
            if (lst[i] === value) {
                return i;
            }
        }
        return -1;
    },

    findValue: function (lst, value, start/* = 0 */, /* optional */end) {
        if (typeof(end) == "undefined" || end === null) {
            end = lst.length;
        }
        var cmp = MochiKit.Base.compare;
        for (var i = (start || 0); i < end; i++) {
            if (cmp(lst[i], value) === 0) {
                return i;
            }
        }
        return -1;
    },
    
    nodeWalk: function (node, visitor) {
        var nodes = [node];
        var extend = MochiKit.Base.extend;
        while (nodes.length) {
            var res = visitor(nodes.shift());
            if (res) {
                extend(nodes, res);
            }
        }
    },

       
    nameFunctions: function (namespace) {
        var base = namespace.NAME;
        if (typeof(base) == 'undefined') {
            base = '';
        } else {
            base = base + '.';
        }
        for (var name in namespace) {
            var o = namespace[name];
            if (typeof(o) == 'function' && typeof(o.NAME) == 'undefined') {
                try {
                    o.NAME = base + name;
                } catch (e) {
                    // pass
                }
            }
        }
    },


    queryString: function (names, values) {
        // check to see if names is a string or a DOM element, and if
        // MochiKit.DOM is available.  If so, drop it like it's a form
        // Ugliest conditional in MochiKit?  Probably!
        if (typeof(MochiKit.DOM) != "undefined" && arguments.length == 1
            && (typeof(names) == "string" || (
                typeof(names.nodeType) != "undefined" && names.nodeType > 0
            ))
        ) {
            var kv = MochiKit.DOM.formContents(names);
            names = kv[0];
            values = kv[1];
        } else if (arguments.length == 1) {
            var o = names;
            names = [];
            values = [];
            for (var k in o) {
                var v = o[k];
                if (typeof(v) != "function") {
                    names.push(k);
                    values.push(v);
                }
            }
        }
        var rval = [];
        var len = Math.min(names.length, values.length);
        var urlEncode = MochiKit.Base.urlEncode;
        for (var i = 0; i < len; i++) {
            v = values[i];
            if (typeof(v) != 'undefined' && v !== null) {
                rval.push(urlEncode(names[i]) + "=" + urlEncode(v));
            }
        }
        return rval.join("&");
    },


    parseQueryString: function (encodedString, useArrays) {
        var pairs = encodedString.replace(/\+/g, "%20").split("&");
        var o = {};
        var decode;
        if (typeof(decodeURIComponent) != "undefined") {
            decode = decodeURIComponent;
        } else {
            decode = unescape;
        }
        if (useArrays) {
            for (var i = 0; i < pairs.length; i++) {
                var pair = pairs[i].split("=");
                var name = decode(pair[0]);
                var arr = o[name];
                if (!(arr instanceof Array)) {
                    arr = [];
                    o[name] = arr;
                }
                arr.push(decode(pair[1]));
            }
        } else {
            for (i = 0; i < pairs.length; i++) {
                pair = pairs[i].split("=");
                o[decode(pair[0])] = decode(pair[1]);
            }
        }
        return o;
    }
});
    
MochiKit.Base.AdapterRegistry = function () {
    this.pairs = [];
};

MochiKit.Base.AdapterRegistry.prototype = {
    register: function (name, check, wrap, /* optional */ override) {
        if (override) {
            this.pairs.unshift([name, check, wrap]);
        } else {
            this.pairs.push([name, check, wrap]);
        }
    },

    match: function (/* ... */) {
        for (var i = 0; i < this.pairs.length; i++) {
            var pair = this.pairs[i];
            if (pair[1].apply(this, arguments)) {
                return pair[2].apply(this, arguments);
            }
        }
        throw MochiKit.Base.NotFound;
    },

    unregister: function (name) {
        for (var i = 0; i < this.pairs.length; i++) {
            var pair = this.pairs[i];
            if (pair[0] == name) {
                this.pairs.splice(i, 1);
                return true;
            }
        }
        return false;
    }
};


MochiKit.Base.EXPORT = [
    "counter",
    "clone",
    "extend",
    "update",
    "updatetree",
    "setdefault",
    "keys",
    "items",
    "NamedError",
    "operator",
    "forwardCall",
    "itemgetter",
    "typeMatcher",
    "isCallable",
    "isUndefined",
    "isUndefinedOrNull",
    "isNull",
    "isEmpty",
    "isNotEmpty",
    "isArrayLike",
    "isDateLike",
    "xmap",
    "map",
    "xfilter",
    "filter",
    "bind",
    "bindMethods",
    "NotFound",
    "AdapterRegistry",
    "registerComparator",
    "compare",
    "registerRepr",
    "repr",
    "objEqual",
    "arrayEqual",
    "concat",
    "keyComparator",
    "reverseKeyComparator",
    "partial",
    "merge",
    "listMinMax",
    "listMax",
    "listMin",
    "objMax",
    "objMin",
    "nodeWalk",
    "zip",
    "urlEncode",
    "queryString",
    "serializeJSON",
    "registerJSON",
    "evalJSON",
    "parseQueryString",
    "findValue",
    "findIdentical",
    "flattenArguments",
    "method"
];

MochiKit.Base.EXPORT_OK = [
    "nameFunctions",
    "comparatorRegistry",
    "reprRegistry",
    "jsonRegistry",
    "compareDateLike",
    "compareArrayLike",
    "reprArrayLike",
    "reprString",
    "reprNumber"
];

MochiKit.Base._exportSymbols = function (globals, module) {
    if (typeof(MochiKit.__export__) == "undefined") {
        MochiKit.__export__ = (MochiKit.__compat__  ||
            (typeof(JSAN) == 'undefined' && typeof(dojo) == 'undefined')
        );
    }
    if (!MochiKit.__export__) {
        return;
    }
    var all = module.EXPORT_TAGS[":all"];
    for (var i = 0; i < all.length; i++) {
        globals[all[i]] = module[all[i]];
    }
};

MochiKit.Base.__new__ = function () {
    // A singleton raised when no suitable adapter is found
    var m = this;

    // Backwards compat
    m.forward = m.forwardCall;
    m.find = m.findValue;

    if (typeof(encodeURIComponent) != "undefined") {
        m.urlEncode = function (unencoded) {
            return encodeURIComponent(unencoded).replace(/\'/g, '%27');
        };
    } else {
        m.urlEncode = function (unencoded) {
            return escape(unencoded
                ).replace(/\+/g, '%2B'
                ).replace(/\"/g,'%22'
                ).rval.replace(/\'/g, '%27');
        };
    }

    m.NamedError = function (name) {
        this.message = name;
        this.name = name;
    };
    m.NamedError.prototype = new Error();
    m.update(m.NamedError.prototype, {
        repr: function () {
            if (this.message && this.message != this.name) {
                return this.name + "(" + m.repr(this.message) + ")";
            } else {
                return this.name + "()";
            }
        },
        toString: m.forwardCall("repr")
    });

    m.NotFound = new m.NamedError("MochiKit.Base.NotFound");


    m.listMax = m.partial(m.listMinMax, 1);
    m.listMin = m.partial(m.listMinMax, -1);

    m.isCallable = m.typeMatcher('function');
    m.isUndefined = m.typeMatcher('undefined');

    m.merge = m.partial(m.update, null);
    m.zip = m.partial(m.map, null);

    m.comparatorRegistry = new m.AdapterRegistry();
    m.registerComparator("dateLike", m.isDateLike, m.compareDateLike);
    m.registerComparator("arrayLike", m.isArrayLike, m.compareArrayLike);

    m.reprRegistry = new m.AdapterRegistry();
    m.registerRepr("arrayLike", m.isArrayLike, m.reprArrayLike);
    m.registerRepr("string", m.typeMatcher("string"), m.reprString);
    m.registerRepr("numbers", m.typeMatcher("number", "boolean"), m.reprNumber);

    m.jsonRegistry = new m.AdapterRegistry();

    var all = m.concat(m.EXPORT, m.EXPORT_OK);
    m.EXPORT_TAGS = {
        ":common": m.concat(m.EXPORT_OK),
        ":all": all
    };

    m.nameFunctions(this);

};

MochiKit.Base.__new__();

//
// XXX: Internet Explorer blows
//
if (!MochiKit.__compat__) {
    compare = MochiKit.Base.compare;
}

MochiKit.Base._exportSymbols(this, MochiKit.Base);

/***

MochiKit.Iter 1.3.1

See <http://mochikit.com/> for documentation, downloads, license, etc.

(c) 2005 Bob Ippolito.  All rights Reserved.

***/
if (typeof(dojo) != 'undefined') {
    dojo.provide('MochiKit.Iter');
    dojo.require('MochiKit.Base');
}

if (typeof(JSAN) != 'undefined') {
    JSAN.use("MochiKit.Base", []);
}   

try {
    if (typeof(MochiKit.Base) == 'undefined') {
        throw "";
    }
} catch (e) {
    throw "MochiKit.Iter depends on MochiKit.Base!";
}  
            
if (typeof(MochiKit.Iter) == 'undefined') {
    MochiKit.Iter = {};
}           
        
MochiKit.Iter.NAME = "MochiKit.Iter";
MochiKit.Iter.VERSION = "1.3.1";
MochiKit.Base.update(MochiKit.Iter, {
    __repr__: function () {
        return "[" + this.NAME + " " + this.VERSION + "]";
    },
    toString: function () {
        return this.__repr__();
    },

    registerIteratorFactory: function (name, check, iterfactory, /* optional */ override) {
        MochiKit.Iter.iteratorRegistry.register(name, check, iterfactory, override);
    },

    iter: function (iterable, /* optional */ sentinel) {
        var self = MochiKit.Iter;
        if (arguments.length == 2) {
            return self.takewhile(
                function (a) { return a != sentinel; },
                iterable
            );
        }
        if (typeof(iterable.next) == 'function') {
            return iterable;
        } else if (typeof(iterable.iter) == 'function') {
            return iterable.iter();
        }
        try {
            return self.iteratorRegistry.match(iterable);
        } catch (e) {
            var m = MochiKit.Base;
            if (e == m.NotFound) {
                e = new TypeError(typeof(iterable) + ": " + m.repr(iterable) + " is not iterable");
            }
            throw e;
        }
    },

    count: function (n) {
        if (!n) {
            n = 0;
        }
        var m = MochiKit.Base;
        return {
            repr: function () { return "count(" + n + ")"; },
            toString: m.forwardCall("repr"),
            next: m.counter(n)
        };
    },

    cycle: function (p) {
        var self = MochiKit.Iter;
        var m = MochiKit.Base;
        var lst = [];
        var iterator = self.iter(p);
        return {
            repr: function () { return "cycle(...)"; },
            toString: m.forwardCall("repr"),
            next: function () {
                try {
                    var rval = iterator.next();
                    lst.push(rval);
                    return rval;
                } catch (e) {
                    if (e != self.StopIteration) {
                        throw e;
                    }
                    if (lst.length === 0) {
                        this.next = function () {
                            throw self.StopIteration;
                        };
                    } else {
                        var i = -1;
                        this.next = function () {
                            i = (i + 1) % lst.length;
                            return lst[i];
                        };
                    }
                    return this.next();
                }
            }
        };
    },

    repeat: function (elem, /* optional */n) {
        var m = MochiKit.Base;
        if (typeof(n) == 'undefined') {
            return {
                repr: function () {
                    return "repeat(" + m.repr(elem) + ")";
                },
                toString: m.forwardCall("repr"),
                next: function () {
                    return elem;
                }
            };
        }
        return {
            repr: function () {
                return "repeat(" + m.repr(elem) + ", " + n + ")";
            },
            toString: m.forwardCall("repr"),
            next: function () {
                if (n <= 0) {
                    throw MochiKit.Iter.StopIteration;
                }
                n -= 1;
                return elem;
            }
        };
    },
            
    next: function (iterator) {
        return iterator.next();
    },

    izip: function (p, q/*, ...*/) {
        var m = MochiKit.Base;
        var next = MochiKit.Iter.next;
        var iterables = m.map(iter, arguments);
        return {
            repr: function () { return "izip(...)"; },
            toString: m.forwardCall("repr"),
            next: function () { return m.map(next, iterables); }
        };
    },

    ifilter: function (pred, seq) {
        var m = MochiKit.Base;
        seq = MochiKit.Iter.iter(seq);
        if (pred === null) {
            pred = m.operator.truth;
        }
        return {
            repr: function () { return "ifilter(...)"; },
            toString: m.forwardCall("repr"),
            next: function () {
                while (true) {
                    var rval = seq.next();
                    if (pred(rval)) {
                        return rval;
                    }
                }
                // mozilla warnings aren't too bright
                return undefined;
            }
        };
    },

    ifilterfalse: function (pred, seq) {
        var m = MochiKit.Base;
        seq = MochiKit.Iter.iter(seq);
        if (pred === null) {
            pred = m.operator.truth;
        }
        return {
            repr: function () { return "ifilterfalse(...)"; },
            toString: m.forwardCall("repr"),
            next: function () {
                while (true) {
                    var rval = seq.next();
                    if (!pred(rval)) {
                        return rval;
                    }
                }
                // mozilla warnings aren't too bright
                return undefined;
            }
        };
    },
     
    islice: function (seq/*, [start,] stop[, step] */) {
        var self = MochiKit.Iter;
        var m = MochiKit.Base;
        seq = self.iter(seq);
        var start = 0;
        var stop = 0;
        var step = 1;
        var i = -1;
        if (arguments.length == 2) {
            stop = arguments[1];
        } else if (arguments.length == 3) {
            start = arguments[1];
            stop = arguments[2];
        } else {
            start = arguments[1];
            stop = arguments[2];
            step = arguments[3];
        }
        return {
            repr: function () {
                return "islice(" + ["...", start, stop, step].join(", ") + ")";
            },
            toString: m.forwardCall("repr"),
            next: function () {
                var rval;
                while (i < start) {
                    rval = seq.next();
                    i++;
                }
                if (start >= stop) {
                    throw self.StopIteration;
                }
                start += step;
                return rval;
            }
        };
    },

    imap: function (fun, p, q/*, ...*/) {
        var m = MochiKit.Base;
        var self = MochiKit.Iter;
        var iterables = m.map(self.iter, m.extend(null, arguments, 1));
        var map = m.map;
        var next = self.next;
        return {
            repr: function () { return "imap(...)"; },
            toString: m.forwardCall("repr"),
            next: function () {
                return fun.apply(this, map(next, iterables));
            }
        };
    },
        
    applymap: function (fun, seq, self) {
        seq = MochiKit.Iter.iter(seq);
        var m = MochiKit.Base;
        return {
            repr: function () { return "applymap(...)"; },
            toString: m.forwardCall("repr"),
            next: function () {
                return fun.apply(self, seq.next());
            }
        };
    },

    chain: function (p, q/*, ...*/) {
        // dumb fast path
        var self = MochiKit.Iter;
        var m = MochiKit.Base;
        if (arguments.length == 1) {
            return self.iter(arguments[0]);
        }
        var argiter = m.map(self.iter, arguments);
        return {
            repr: function () { return "chain(...)"; },
            toString: m.forwardCall("repr"),
            next: function () {
                while (argiter.length > 1) {
                    try {
                        return argiter[0].next();
                    } catch (e) {
                        if (e != self.StopIteration) {
                            throw e;
                        }
                        argiter.shift();
                    }
                }
                if (argiter.length == 1) {
                    // optimize last element
                    var arg = argiter.shift();
                    this.next = m.bind("next", arg);
                    return this.next();
                }
                throw self.StopIteration;
            }
        };
    },

    takewhile: function (pred, seq) {
        var self = MochiKit.Iter;
        seq = self.iter(seq);
        return {
            repr: function () { return "takewhile(...)"; },
            toString: MochiKit.Base.forwardCall("repr"),
            next: function () {
                var rval = seq.next();
                if (!pred(rval)) {
                    this.next = function () {
                        throw self.StopIteration;
                    };
                    this.next();
                }
                return rval;
            }
        };
    },

    dropwhile: function (pred, seq) {
        seq = MochiKit.Iter.iter(seq);
        var m = MochiKit.Base;
        var bind = m.bind;
        return {
            "repr": function () { return "dropwhile(...)"; },
            "toString": m.forwardCall("repr"),
            "next": function () {
                while (true) {
                    var rval = seq.next();
                    if (!pred(rval)) {
                        break;
                    }
                }
                this.next = bind("next", seq);
                return rval;
            }
        };
    },

    _tee: function (ident, sync, iterable) {
        sync.pos[ident] = -1;
        var m = MochiKit.Base;
        var listMin = m.listMin;
        return {
            repr: function () { return "tee(" + ident + ", ...)"; },
            toString: m.forwardCall("repr"),
            next: function () {
                var rval;
                var i = sync.pos[ident];

                if (i == sync.max) {
                    rval = iterable.next();
                    sync.deque.push(rval);
                    sync.max += 1;
                    sync.pos[ident] += 1;
                } else {
                    rval = sync.deque[i - sync.min];
                    sync.pos[ident] += 1;
                    if (i == sync.min && listMin(sync.pos) != sync.min) {
                        sync.min += 1;
                        sync.deque.shift();
                    }
                }
                return rval;
            }
        };
    },

    tee: function (iterable, n/* = 2 */) {
        var rval = [];
        var sync = {
            "pos": [],
            "deque": [],
            "max": -1,
            "min": -1
        };
        if (arguments.length == 1) {
            n = 2;
        }
        var self = MochiKit.Iter;
        iterable = self.iter(iterable);
        var _tee = self._tee;
        for (var i = 0; i < n; i++) {
            rval.push(_tee(i, sync, iterable));
        }
        return rval;
    },

    list: function (iterable) {
        // Fast-path for Array and Array-like
        var m = MochiKit.Base;
        if (typeof(iterable.slice) == 'function') {
            return iterable.slice();
        } else if (m.isArrayLike(iterable)) {
            return m.concat(iterable);
        }

        var self = MochiKit.Iter;
        iterable = self.iter(iterable);
        var rval = [];
        try {
            while (true) {
                rval.push(iterable.next());
            }
        } catch (e) {
            if (e != self.StopIteration) {
                throw e;
            }
            return rval;
        }
        // mozilla warnings aren't too bright
        return undefined;
    },

        
    reduce: function (fn, iterable, /* optional */initial) {
        var i = 0;
        var x = initial;
        var self = MochiKit.Iter;
        iterable = self.iter(iterable);
        if (arguments.length < 3) {
            try {
                x = iterable.next();
            } catch (e) {
                if (e == self.StopIteration) {
                    e = new TypeError("reduce() of empty sequence with no initial value");
                }
                throw e;
            }
            i++;
        }
        try {
            while (true) {
                x = fn(x, iterable.next());
            }
        } catch (e) {
            if (e != self.StopIteration) {
                throw e;
            }
        }
        return x;
    },

    range: function (/* [start,] stop[, step] */) {
        var start = 0;
        var stop = 0;
        var step = 1;
        if (arguments.length == 1) {
            stop = arguments[0];
        } else if (arguments.length == 2) {
            start = arguments[0];
            stop = arguments[1];
        } else if (arguments.length == 3) {
            start = arguments[0];
            stop = arguments[1];
            step = arguments[2];
        } else {
            throw new TypeError("range() takes 1, 2, or 3 arguments!");
        }
        if (step === 0) {
            throw new TypeError("range() step must not be 0");
        }
        return {
            next: function () {
                if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
                    throw MochiKit.Iter.StopIteration;
                }
                var rval = start;
                start += step;
                return rval;
            },
            repr: function () {
                return "range(" + [start, stop, step].join(", ") + ")";
            },
            toString: MochiKit.Base.forwardCall("repr")
        };
    },
            
    sum: function (iterable, start/* = 0 */) {
        var x = start || 0;
        var self = MochiKit.Iter;
        iterable = self.iter(iterable);
        try {
            while (true) {
                x += iterable.next();
            }
        } catch (e) {
            if (e != self.StopIteration) {
                throw e;
            }
        }
        return x;
    },
            
    exhaust: function (iterable) {
        var self = MochiKit.Iter;
        iterable = self.iter(iterable);
        try {
            while (true) {
                iterable.next();
            }
        } catch (e) {
            if (e != self.StopIteration) {
                throw e;
            }
        }
    },

    forEach: function (iterable, func, /* optional */self) {
        var m = MochiKit.Base;
        if (arguments.length > 2) {
            func = m.bind(func, self);
        }
        // fast path for array
        if (m.isArrayLike(iterable)) {
            try {
                for (var i = 0; i < iterable.length; i++) {
                    func(iterable[i]);
                }
            } catch (e) {
                if (e != MochiKit.Iter.StopIteration) {
                    throw e;
                }
            }
        } else {
            self = MochiKit.Iter;
            self.exhaust(self.imap(func, iterable));
        }
    },

    every: function (iterable, func) {
        var self = MochiKit.Iter;
        try {
            self.ifilterfalse(func, iterable).next();
            return false;
        } catch (e) {
            if (e != self.StopIteration) {
                throw e;
            }
            return true;
        }
    },

    sorted: function (iterable, /* optional */cmp) {
        var rval = MochiKit.Iter.list(iterable);
        if (arguments.length == 1) {
            cmp = MochiKit.Base.compare;
        }
        rval.sort(cmp);
        return rval;
    },

    reversed: function (iterable) {
        var rval = MochiKit.Iter.list(iterable);
        rval.reverse();
        return rval;
    },

    some: function (iterable, func) {
        var self = MochiKit.Iter;
        try {
            self.ifilter(func, iterable).next();
            return true;
        } catch (e) {
            if (e != self.StopIteration) {
                throw e;
            }
            return false;
        }
    },

    iextend: function (lst, iterable) {
        if (MochiKit.Base.isArrayLike(iterable)) {
            // fast-path for array-like
            for (var i = 0; i < iterable.length; i++) {
                lst.push(iterable[i]);
            }
        } else {
            var self = MochiKit.Iter;
            iterable = self.iter(iterable);
            try {
                while (true) {
                    lst.push(iterable.next());
                }
            } catch (e) {
                if (e != self.StopIteration) {
                    throw e;
                }
            }
        }
        return lst;
    },

    groupby: function(iterable, /* optional */ keyfunc) {
        var m = MochiKit.Base;
        var self = MochiKit.Iter;
        if (arguments.length < 2) {
            keyfunc = m.operator.identity;
        }
        iterable = self.iter(iterable);

        // shared
        var pk = undefined;
        var k = undefined;
        var v;

        function fetch() {
            v = iterable.next();
            k = keyfunc(v);
        };

        function eat() {
            var ret = v;
            v = undefined;
            return ret;
        };

        var first = true;
        return {
            repr: function () { return "groupby(...)"; },
            next: function() {
                // iterator-next

                // iterate until meet next group
                while (k == pk) {
                    fetch();
                    if (first) {
                        first = false;
                        break;
                    }
                }
                pk = k;
                return [k, {
                    next: function() {
                        // subiterator-next
                        if (v == undefined) { // Is there something to eat?
                            fetch();
                        }
                        if (k != pk) {
                            throw self.StopIteration;
                        }
                        return eat();
                    }
                }];
            }
        };
    },

    groupby_as_array: function (iterable, /* optional */ keyfunc) {
        var m = MochiKit.Base;
        var self = MochiKit.Iter;
        if (arguments.length < 2) {
            keyfunc = m.operator.identity;
        }

        iterable = self.iter(iterable);
        var result = [];
        var first = true;
        var prev_key;
        while (true) {
            try {
                var value = iterable.next();
                var key = keyfunc(value);
            } catch (e) {
                if (e == self.StopIteration) {
                    break;
                }
                throw e;
            }
            if (first || key != prev_key) {
                var values = [];
                result.push([key, values]);
            }
            values.push(value);
            first = false;
            prev_key = key;
        }
        return result;
    },

    arrayLikeIter: function (iterable) {
        var i = 0;
        return {
            repr: function () { return "arrayLikeIter(...)"; },
            toString: MochiKit.Base.forwardCall("repr"),
            next: function () {
                if (i >= iterable.length) {
                    throw MochiKit.Iter.StopIteration;
                }
                return iterable[i++];
            }
        };
    },

    hasIterateNext: function (iterable) {
        return (iterable && typeof(iterable.iterateNext) == "function");
    },

    iterateNextIter: function (iterable) {
        return {
            repr: function () { return "iterateNextIter(...)"; },
            toString: MochiKit.Base.forwardCall("repr"),
            next: function () {
                var rval = iterable.iterateNext();
                if (rval === null || rval === undefined) {
                    throw MochiKit.Iter.StopIteration;
                }
                return rval;
            }
        };
    }
});


MochiKit.Iter.EXPORT_OK = [
    "iteratorRegistry",
    "arrayLikeIter",
    "hasIterateNext",
    "iterateNextIter",
];

MochiKit.Iter.EXPORT = [
    "StopIteration",
    "registerIteratorFactory",
    "iter",
    "count",
    "cycle",
    "repeat",
    "next",
    "izip",
    "ifilter",
    "ifilterfalse",
    "islice",
    "imap",
    "applymap",
    "chain",
    "takewhile",
    "dropwhile",
    "tee",
    "list",
    "reduce",
    "range",
    "sum",
    "exhaust",
    "forEach",
    "every",
    "sorted",
    "reversed",
    "some",
    "iextend",
    "groupby",
    "groupby_as_array"
];

MochiKit.Iter.__new__ = function () {
    var m = MochiKit.Base;
    this.StopIteration = new m.NamedError("StopIteration");
    this.iteratorRegistry = new m.AdapterRegistry();
    // Register the iterator factory for arrays
    this.registerIteratorFactory(
        "arrayLike",
        m.isArrayLike,
        this.arrayLikeIter
    );

    this.registerIteratorFactory(
        "iterateNext",
        this.hasIterateNext,
        this.iterateNextIter
    );

    this.EXPORT_TAGS = {
        ":common": this.EXPORT,
        ":all": m.concat(this.EXPORT, this.EXPORT_OK)
    };

    m.nameFunctions(this);
        
};

MochiKit.Iter.__new__();

//
// XXX: Internet Explorer blows
//
if (!MochiKit.__compat__) {
    reduce = MochiKit.Iter.reduce;
}

MochiKit.Base._exportSymbols(this, MochiKit.Iter);

/***

MochiKit.Color 1.3.1

See <http://mochikit.com/> for documentation, downloads, license, etc.

(c) 2005 Bob Ippolito and others.  All rights Reserved.

***/

if (typeof(dojo) != 'undefined') {
    dojo.provide('MochiKit.Color');
    dojo.require('MochiKit.Base');
}

if (typeof(JSAN) != 'undefined') {
    JSAN.use("MochiKit.Base", []);
}

try {
    if (typeof(MochiKit.Base) == 'undefined') {
        throw "";
    }
} catch (e) {
    throw "MochiKit.Color depends on MochiKit.Base";
}

if (typeof(MochiKit.Color) == "undefined") {
    MochiKit.Color = {};
}

MochiKit.Color.NAME = "MochiKit.Color";
MochiKit.Color.VERSION = "1.3.1";

MochiKit.Color.__repr__ = function () {
    return "[" + this.NAME + " " + this.VERSION + "]";
};

MochiKit.Color.toString = function () {
    return this.__repr__();
};


MochiKit.Color.Color = function (red, green, blue, alpha) {
    if (typeof(alpha) == 'undefined' || alpha === null) {
        alpha = 1.0;
    }
    this.rgb = {
        r: red,
        g: green,
        b: blue,
        a: alpha
    };
};


// Prototype methods
MochiKit.Color.Color.prototype = {

    __class__: MochiKit.Color.Color,

    colorWithAlpha: function (alpha) {
        var rgb = this.rgb;
        var m = MochiKit.Color;
        return m.Color.fromRGB(rgb.r, rgb.g, rgb.b, alpha);
    },

    colorWithHue: function (hue) {
        // get an HSL model, and set the new hue...
        var hsl = this.asHSL();
        hsl.h = hue;
        var m = MochiKit.Color;
        // convert back to RGB...
        return m.Color.fromHSL(hsl);
    },

    colorWithSaturation: function (saturation) {
        // get an HSL model, and set the new hue...
        var hsl = this.asHSL();
        hsl.s = saturation;
        var m = MochiKit.Color;
        // convert back to RGB...
        return m.Color.fromHSL(hsl);
    },

    colorWithLightness: function (lightness) {
        // get an HSL model, and set the new hue...
        var hsl = this.asHSL();
        hsl.l = lightness;
        var m = MochiKit.Color;
        // convert back to RGB...
        return m.Color.fromHSL(hsl);
    },

    darkerColorWithLevel: function (level) {
        var hsl  = this.asHSL();
        hsl.l = Math.max(hsl.l - level, 0);
        var m = MochiKit.Color;
        return m.Color.fromHSL(hsl);
    },

    lighterColorWithLevel: function (level) {
        var hsl  = this.asHSL();
        hsl.l = Math.min(hsl.l + level, 1);
        var m = MochiKit.Color;
        return m.Color.fromHSL(hsl);
    },

    blendedColor: function (other, /* optional */ fraction) {
        if (typeof(fraction) == 'undefined' || fraction === null) {
            fraction = 0.5;
        }
        var sf = 1.0 - fraction;
        var s = this.rgb;
        var d = other.rgb;
        var df = fraction;
        return MochiKit.Color.Color.fromRGB(
            (s.r * sf) + (d.r * df),
            (s.g * sf) + (d.g * df),
            (s.b * sf) + (d.b * df),
            (s.a * sf) + (d.a * df)
        );
    },

    compareRGB: function (other) {
        var a = this.asRGB();
        var b = other.asRGB();
        return MochiKit.Base.compare(
            [a.r, a.g, a.b, a.a],
            [b.r, b.g, b.b, b.a]
        );
    },
        
    isLight: function () {
        return this.asHSL().b > 0.5;
    },

    isDark: function () {
        return (!this.isLight());
    },

    toHSLString: function () {
        var c = this.asHSL();
        var ccc = MochiKit.Color.clampColorComponent;
        var rval = this._hslString;
        if (!rval) {
            var mid = (
                ccc(c.h, 360).toFixed(0)
                + "," + ccc(c.s, 100).toPrecision(4) + "%" 
                + "," + ccc(c.l, 100).toPrecision(4) + "%"
            );
            var a = c.a;
            if (a >= 1) {
                a = 1;
                rval = "hsl(" + mid + ")";
            } else {
                if (a <= 0) {
                    a = 0;
                }
                rval = "hsla(" + mid + "," + a + ")";
            }
            this._hslString = rval;
        }
        return rval;
    },

    toRGBString: function () {
        var c = this.rgb;
        var ccc = MochiKit.Color.clampColorComponent;
        var rval = this._rgbString;
        if (!rval) {
            var mid = (
                ccc(c.r, 255).toFixed(0)
                + "," + ccc(c.g, 255).toFixed(0)
                + "," + ccc(c.b, 255).toFixed(0)
            );
            if (c.a != 1) {
                rval = "rgba(" + mid + "," + c.a + ")";
            } else {
                rval = "rgb(" + mid + ")";
            }
            this._rgbString = rval;
        }
        return rval;
    },

    asRGB: function () {
        return MochiKit.Base.clone(this.rgb);
    },

    toHexString: function () {
        var m = MochiKit.Color;
        var c = this.rgb;
        var ccc = MochiKit.Color.clampColorComponent;
        var rval = this._hexString;
        if (!rval) {
            rval = ("#" + 
                m.toColorPart(ccc(c.r, 255)) +
                m.toColorPart(ccc(c.g, 255)) +
                m.toColorPart(ccc(c.b, 255))
            );
            this._hexString = rval;
        }
        return rval;
    },

    asHSV: function () {
        var hsv = this.hsv;
        var c = this.rgb;
        if (typeof(hsv) == 'undefined' || hsv === null) {
            hsv = MochiKit.Color.rgbToHSV(this.rgb);
            this.hsv = hsv;
        }
        return MochiKit.Base.clone(hsv);
    },

    asHSL: function () {
        var hsl = this.hsl;
        var c = this.rgb;
        if (typeof(hsl) == 'undefined' || hsl === null) {
            hsl = MochiKit.Color.rgbToHSL(this.rgb);
            this.hsl = hsl;
        }
        return MochiKit.Base.clone(hsl);
    },

    toString: function () {
        return this.toRGBString();
    },

    repr: function () {
        var c = this.rgb;
        var col = [c.r, c.g, c.b, c.a];
        return this.__class__.NAME + "(" + col.join(", ") + ")";
    }

};

// Constructor methods
MochiKit.Base.update(MochiKit.Color.Color, {
    fromRGB: function (red, green, blue, alpha) {
        // designated initializer
        var Color = MochiKit.Color.Color;
        if (arguments.length == 1) {
            var rgb = red;
            red = rgb.r;
            green = rgb.g;
            blue = rgb.b;
            if (typeof(rgb.a) == 'undefined') {
                alpha = undefined;
            } else {
                alpha = rgb.a;
            }
        }
        return new Color(red, green, blue, alpha);
    },

    fromHSL: function (hue, saturation, lightness, alpha) {
        var m = MochiKit.Color;
        return m.Color.fromRGB(m.hslToRGB.apply(m, arguments));
    },

    fromHSV: function (hue, saturation, value, alpha) {
        var m = MochiKit.Color;
        return m.Color.fromRGB(m.hsvToRGB.apply(m, arguments));
    },

    fromName: function (name) {
        var Color = MochiKit.Color.Color;
        // Opera 9 seems to "quote" named colors(?!)
        if (name.charAt(0) == '"') {
            name = name.substr(1, name.length - 2);
        }
        var htmlColor = Color._namedColors[name.toLowerCase()];
        if (typeof(htmlColor) == 'string') {
            return Color.fromHexString(htmlColor);
        } else if (name == "transparent") {
            return Color.transparentColor();
        }
        return null;
    },

    fromString: function (colorString) {
        var self = MochiKit.Color.Color;
        var three = colorString.substr(0, 3);
        if (three == "rgb") {
            return self.fromRGBString(colorString);
        } else if (three == "hsl") {
            return self.fromHSLString(colorString);
        } else if (colorString.charAt(0) == "#") {
            return self.fromHexString(colorString);
        }
        return self.fromName(colorString);
    },


    fromHexString: function (hexCode) {
        if (hexCode.charAt(0) == '#') {
            hexCode = hexCode.substring(1);
        }
        var components = [];
        var i, hex;
        if (hexCode.length == 3) {
            for (i = 0; i < 3; i++) {
                hex = hexCode.substr(i, 1);
                components.push(parseInt(hex + hex, 16) / 255.0);
            }
        } else {
            for (i = 0; i < 6; i += 2) {
                hex = hexCode.substr(i, 2);
                components.push(parseInt(hex, 16) / 255.0);
            }
        }
        var Color = MochiKit.Color.Color;
        return Color.fromRGB.apply(Color, components);
    },
        

    _fromColorString: function (pre, method, scales, colorCode) {
        // parses either HSL or RGB
        if (colorCode.indexOf(pre) === 0) {
            colorCode = colorCode.substring(colorCode.indexOf("(", 3) + 1, colorCode.length - 1);
        } 
        var colorChunks = colorCode.split(/\s*,\s*/);
        var colorFloats = [];
        for (var i = 0; i < colorChunks.length; i++) {
            var c = colorChunks[i];
            var val;
            var three = c.substring(c.length - 3);
            if (c.charAt(c.length - 1) == '%') {
                val = 0.01 * parseFloat(c.substring(0, c.length - 1));
            } else if (three == "deg") {
                val = parseFloat(c) / 360.0;
            } else if (three == "rad") {
                val = parseFloat(c) / (Math.PI * 2);
            } else {
                val = scales[i] * parseFloat(c);
            }
            colorFloats.push(val);
        }
        return this[method].apply(this, colorFloats);
    },
    
    fromComputedStyle: function (elem, style, mozillaEquivalentCSS) {
        var d = MochiKit.DOM;
        var cls = MochiKit.Color.Color;
        for (elem = d.getElement(elem); elem; elem = elem.parentNode) {
            var actualColor = d.computedStyle.apply(d, arguments);
            if (!actualColor) {
                continue;
            }
            var color = cls.fromString(actualColor);
            if (!color) {
                break;
            }
            if (color.asRGB().a > 0) {
                return color;
            }
        }
        return null;
    },

    fromBackground: function (elem) {
        var cls = MochiKit.Color.Color;
        return cls.fromComputedStyle(
            elem, "backgroundColor", "background-color") || cls.whiteColor();
    },

    fromText: function (elem) {
        var cls = MochiKit.Color.Color;
        return cls.fromComputedStyle(
            elem, "color", "color") || cls.blackColor();
    },

    namedColors: function () {
        return MochiKit.Base.clone(MochiKit.Color.Color._namedColors);
    }
});

// Module level functions
MochiKit.Base.update(MochiKit.Color, {
    clampColorComponent: function (v, scale) {
        v *= scale;
        if (v < 0) {
            return 0;
        } else if (v > scale) {
            return scale;
        } else {
            return v;
        }
    },

    _hslValue: function (n1, n2, hue) {
        if (hue > 6.0) {
            hue -= 6.0;
        } else if (hue < 0.0) {
            hue += 6.0;
        }
        var val;
        if (hue < 1.0) {
            val = n1 + (n2 - n1) * hue;
        } else if (hue < 3.0) {
            val = n2;
        } else if (hue < 4.0) {
            val = n1 + (n2 - n1) * (4.0 - hue);
        } else {
            val = n1;
        }
        return val;
    },
        
    hsvToRGB: function (hue, saturation, value, alpha) {
        if (arguments.length == 1) {
            var hsv = hue;
            hue = hsv.h;
            saturation = hsv.s;
            value = hsv.v;
            alpha = hsv.a;
        }
        var red;
        var green;
        var blue;
        if (saturation === 0) {
            red = 0;
            green = 0;
            blue = 0;
        } else {
            var i = Math.floor(hue * 6);
            var f = (hue * 6) - i;
            var p = value * (1 - saturation);
            var q = value * (1 - (saturation * f));
            var t = value * (1 - (saturation * (1 - f)));
            switch (i) {
                case 1: red = q; green = value; blue = p; break;
                case 2: red = p; green = value; blue = t; break;
                case 3: red = p; green = q; blue = value; break;
                case 4: red = t; green = p; blue = value; break;
                case 5: red = value; green = p; blue = q; break;
                case 6: // fall through
                case 0: red = value; green = t; blue = p; break;
            }
        }
        return {
            r: red,
            g: green,
            b: blue,
            a: alpha
        };
    },

    hslToRGB: function (hue, saturation, lightness, alpha) {
        if (arguments.length == 1) {
            var hsl = hue;
            hue = hsl.h;
            saturation = hsl.s;
            lightness = hsl.l;
            alpha = hsl.a;
        }
        var red;
        var green;
        var blue;
        if (saturation === 0) {
            red = lightness;
            green = lightness;
            blue = lightness;
        } else {
            var m2;
            if (lightness <= 0.5) {
                m2 = lightness * (1.0 + saturation);
            } else {
                m2 = lightness + saturation - (lightness * saturation);
            }
            var m1 = (2.0 * lightness) - m2;
            var f = MochiKit.Color._hslValue;
            var h6 = hue * 6.0;
            red = f(m1, m2, h6 + 2);
            green = f(m1, m2, h6);
            blue = f(m1, m2, h6 - 2);
        }
        return {
            r: red,
            g: green,
            b: blue,
            a: alpha
        };
    },

    rgbToHSV: function (red, green, blue, alpha) {
        if (arguments.length == 1) {
            var rgb = red;
            red = rgb.r;
            green = rgb.g;
            blue = rgb.b;
            alpha = rgb.a;
        }
        var max = Math.max(Math.max(red, green), blue);
        var min = Math.min(Math.min(red, green), blue);
        var hue;
        var saturation;
        var value = max;
        if (min == max) {
            hue = 0;
            saturation = 0;
        } else {
            var delta = (max - min);
            saturation = delta / max;

            if (red == max) {
                hue = (green - blue) / delta;
            } else if (green == max) {
                hue = 2 + ((blue - red) / delta);
            } else {
                hue = 4 + ((red - green) / delta);
            }
            hue /= 6;
            if (hue < 0) {
                hue += 1;
            }
            if (hue > 1) {
                hue -= 1;
            }
        }
        return {
            h: hue,
            s: saturation,
            v: value,
            a: alpha
        };
    },
            
    rgbToHSL: function (red, green, blue, alpha) {
        if (arguments.length == 1) {
            var rgb = red;
            red = rgb.r;
            green = rgb.g;
            blue = rgb.b;
            alpha = rgb.a;
        }
        var max = Math.max(red, Math.max(green, blue));
        var min = Math.min(red, Math.min(green, blue));
        var hue;
        var saturation;
        var lightness = (max + min) / 2.0;
        var delta = max - min;
        if (delta === 0) {
            hue = 0;
            saturation = 0;
        } else {
            if (lightness <= 0.5) {
                saturation = delta / (max + min);
            } else {
                saturation = delta / (2 - max - min);
            }
            if (red == max) {
                hue = (green - blue) / delta;
            } else if (green == max) {
                hue = 2 + ((blue - red) / delta);
            } else {
                hue = 4 + ((red - green) / delta);
            }
            hue /= 6;
            if (hue < 0) {
                hue += 1;
            }
            if (hue > 1) {
                hue -= 1;
            }
            
        }
        return {
            h: hue,
            s: saturation,
            l: lightness,
            a: alpha
        };
    },

    toColorPart: function (num) {
        num = Math.round(num);
        var digits = num.toString(16);
        if (num < 16) {
            return '0' + digits;
        }
        return digits;
    },

    __new__: function () {
        var m = MochiKit.Base;
        this.Color.fromRGBString = m.bind(
            this.Color._fromColorString, this.Color, "rgb", "fromRGB",
            [1.0/255.0, 1.0/255.0, 1.0/255.0, 1]
        );
        this.Color.fromHSLString = m.bind(
            this.Color._fromColorString, this.Color, "hsl", "fromHSL",
            [1.0/360.0, 0.01, 0.01, 1]
        );
        
        var third = 1.0 / 3.0;
        var colors = {
            // NSColor colors plus transparent
            black: [0, 0, 0],
            blue: [0, 0, 1],
            brown: [0.6, 0.4, 0.2],
            cyan: [0, 1, 1],
            darkGray: [third, third, third],
            gray: [0.5, 0.5, 0.5],
            green: [0, 1, 0],
            lightGray: [2 * third, 2 * third, 2 * third],
            magenta: [1, 0, 1],
            orange: [1, 0.5, 0],
            purple: [0.5, 0, 0.5],
            red: [1, 0, 0],
            transparent: [0, 0, 0, 0],
            white: [1, 1, 1],
            yellow: [1, 1, 0]
        };

        var makeColor = function (name, r, g, b, a) {
            var rval = this.fromRGB(r, g, b, a);
            this[name] = function () { return rval; };
            return rval;
        };

        for (var k in colors) {
            var name = k + "Color";
            var bindArgs = m.concat(
                [makeColor, this.Color, name],
                colors[k]
            );
            this.Color[name] = m.bind.apply(null, bindArgs);
        }

        var isColor = function () {
            for (var i = 0; i < arguments.length; i++) {
                if (!(arguments[i] instanceof Color)) {
                    return false;
                }
            }
            return true;
        };

        var compareColor = function (a, b) {
            return a.compareRGB(b);
        };

        m.nameFunctions(this);

        m.registerComparator(this.Color.NAME, isColor, compareColor);
            
        this.EXPORT_TAGS = {
            ":common": this.EXPORT,
            ":all": m.concat(this.EXPORT, this.EXPORT_OK)
        };

    }
});

MochiKit.Color.EXPORT = [
    "Color"
];

MochiKit.Color.EXPORT_OK = [
    "clampColorComponent",
    "rgbToHSL",
    "hslToRGB",
    "rgbToHSV",
    "hsvToRGB",
    "toColorPart"
];

MochiKit.Color.__new__();

MochiKit.Base._exportSymbols(this, MochiKit.Color);

// Full table of css3 X11 colors <http://www.w3.org/TR/css3-color/#X11COLORS>

MochiKit.Color.Color._namedColors = {
    aliceblue: "#f0f8ff",
    antiquewhite: "#faebd7",
    aqua: "#00ffff",
    aquamarine: "#7fffd4",
    azure: "#f0ffff",
    beige: "#f5f5dc",
    bisque: "#ffe4c4",
    black: "#000000",
    blanchedalmond: "#ffebcd",
    blue: "#0000ff",
    blueviolet: "#8a2be2",
    brown: "#a52a2a",
    burlywood: "#deb887",
    cadetblue: "#5f9ea0",
    chartreuse: "#7fff00",
    chocolate: "#d2691e",
    coral: "#ff7f50",
    cornflowerblue: "#6495ed",
    cornsilk: "#fff8dc",
    crimson: "#dc143c",
    cyan: "#00ffff",
    darkblue: "#00008b",
    darkcyan: "#008b8b",
    darkgoldenrod: "#b8860b",
    darkgray: "#a9a9a9",
    darkgreen: "#006400",
    darkgrey: "#a9a9a9",
    darkkhaki: "#bdb76b",
    darkmagenta: "#8b008b",
    darkolivegreen: "#556b2f",
    darkorange: "#ff8c00",
    darkorchid: "#9932cc",
    darkred: "#8b0000",
    darksalmon: "#e9967a",
    darkseagreen: "#8fbc8f",
    darkslateblue: "#483d8b",
    darkslategray: "#2f4f4f",
    darkslategrey: "#2f4f4f",
    darkturquoise: "#00ced1",
    darkviolet: "#9400d3",
    deeppink: "#ff1493",
    deepskyblue: "#00bfff",
    dimgray: "#696969",
    dimgrey: "#696969",
    dodgerblue: "#1e90ff",
    firebrick: "#b22222",
    floralwhite: "#fffaf0",
    forestgreen: "#228b22",
    fuchsia: "#ff00ff",
    gainsboro: "#dcdcdc",
    ghostwhite: "#f8f8ff",
    gold: "#ffd700",
    goldenrod: "#daa520",
    gray: "#808080",
    green: "#008000",
    greenyellow: "#adff2f",
    grey: "#808080",
    honeydew: "#f0fff0",
    hotpink: "#ff69b4",
    indianred: "#cd5c5c",
    indigo: "#4b0082",
    ivory: "#fffff0",
    khaki: "#f0e68c",
    lavender: "#e6e6fa",
    lavenderblush: "#fff0f5",
    lawngreen: "#7cfc00",
    lemonchiffon: "#fffacd",
    lightblue: "#add8e6",
    lightcoral: "#f08080",
    lightcyan: "#e0ffff",
    lightgoldenrodyellow: "#fafad2",
    lightgray: "#d3d3d3",
    lightgreen: "#90ee90",
    lightgrey: "#d3d3d3",
    lightpink: "#ffb6c1",
    lightsalmon: "#ffa07a",
    lightseagreen: "#20b2aa",
    lightskyblue: "#87cefa",
    lightslategray: "#778899",
    lightslategrey: "#778899",
    lightsteelblue: "#b0c4de",
    lightyellow: "#ffffe0",
    lime: "#00ff00",
    limegreen: "#32cd32",
    linen: "#faf0e6",
    magenta: "#ff00ff",
    maroon: "#800000",
    mediumaquamarine: "#66cdaa",
    mediumblue: "#0000cd",
    mediumorchid: "#ba55d3",
    mediumpurple: "#9370db",
    mediumseagreen: "#3cb371",
    mediumslateblue: "#7b68ee",
    mediumspringgreen: "#00fa9a",
    mediumturquoise: "#48d1cc",
    mediumvioletred: "#c71585",
    midnightblue: "#191970",
    mintcream: "#f5fffa",
    mistyrose: "#ffe4e1",
    moccasin: "#ffe4b5",
    navajowhite: "#ffdead",
    navy: "#000080",
    oldlace: "#fdf5e6",
    olive: "#808000",
    olivedrab: "#6b8e23",
    orange: "#ffa500",
    orangered: "#ff4500",
    orchid: "#da70d6",
    palegoldenrod: "#eee8aa",
    palegreen: "#98fb98",
    paleturquoise: "#afeeee",
    palevioletred: "#db7093",
    papayawhip: "#ffefd5",
    peachpuff: "#ffdab9",
    peru: "#cd853f",
    pink: "#ffc0cb",
    plum: "#dda0dd",
    powderblue: "#b0e0e6",
    purple: "#800080",
    red: "#ff0000",
    rosybrown: "#bc8f8f",
    royalblue: "#4169e1",
    saddlebrown: "#8b4513",
    salmon: "#fa8072",
    sandybrown: "#f4a460",
    seagreen: "#2e8b57",
    seashell: "#fff5ee",
    sienna: "#a0522d",
    silver: "#c0c0c0",
    skyblue: "#87ceeb",
    slateblue: "#6a5acd",
    slategray: "#708090",
    slategrey: "#708090",
    snow: "#fffafa",
    springgreen: "#00ff7f",
    steelblue: "#4682b4",
    tan: "#d2b48c",
    teal: "#008080",
    thistle: "#d8bfd8",
    tomato: "#ff6347",
    turquoise: "#40e0d0",
    violet: "#ee82ee",
    wheat: "#f5deb3",
    white: "#ffffff",
    whitesmoke: "#f5f5f5",
    yellow: "#ffff00",
    yellowgreen: "#9acd32"
};

/***

MochiKit.DOM 1.3.1

See <http://mochikit.com/> for documentation, downloads, license, etc.

(c) 2005 Bob Ippolito.  All rights Reserved.

***/

if (typeof(dojo) != 'undefined') {
    dojo.provide("MochiKit.DOM");
    dojo.require("MochiKit.Iter");
}
if (typeof(JSAN) != 'undefined') {
    JSAN.use("MochiKit.Iter", []);
}

try {
    if (typeof(MochiKit.Iter) == 'undefined') {
        throw "";
    }
} catch (e) {
    throw "MochiKit.DOM depends on MochiKit.Iter!";
}

if (typeof(MochiKit.DOM) == 'undefined') {
    MochiKit.DOM = {};
}

MochiKit.DOM.NAME = "MochiKit.DOM";
MochiKit.DOM.VERSION = "1.3.1";
MochiKit.DOM.__repr__ = function () {
    return "[" + this.NAME + " " + this.VERSION + "]";
};
MochiKit.DOM.toString = function () {
    return this.__repr__();
};

MochiKit.DOM.EXPORT = [
    "formContents",
    "currentWindow",
    "currentDocument",
    "withWindow",
    "withDocument",
    "registerDOMConverter",
    "coerceToDOM",
    "createDOM",
    "createDOMFunc",
    "getNodeAttribute",
    "setNodeAttribute",
    "updateNodeAttributes",
    "appendChildNodes",
    "replaceChildNodes",
    "removeElement",
    "swapDOM",
    "BUTTON",
    "TT",
    "PRE",
    "H1",
    "H2",
    "H3",
    "BR",
    "CANVAS",
    "HR",
    "LABEL",
    "TEXTAREA",
    "FORM",
    "STRONG",
    "SELECT",
    "OPTION",
    "OPTGROUP",
    "LEGEND",
    "FIELDSET",
    "P",
    "UL",
    "OL",
    "LI",
    "TD",
    "TR",
    "THEAD",
    "TBODY",
    "TFOOT",
    "TABLE",
    "TH",
    "INPUT",
    "SPAN",
    "A",
    "DIV",
    "IMG",
    "getElement",
    "computedStyle",
    "getElementsByTagAndClassName",
    "addToCallStack",
    "addLoadEvent",
    "focusOnLoad",
    "setElementClass",
    "toggleElementClass",
    "addElementClass",
    "removeElementClass",
    "swapElementClass",
    "hasElementClass",
    "escapeHTML",
    "toHTML",
    "emitHTML",
    "setDisplayForElement",
    "hideElement",
    "showElement",
    "scrapeText",
    "elementDimensions",
    "elementPosition",
    "setElementDimensions",
    "setElementPosition",
    "getViewportDimensions",
    "setOpacity"
];

MochiKit.DOM.EXPORT_OK = [
    "domConverters"
];

MochiKit.DOM.Dimensions = function (w, h) {
    this.w = w;
    this.h = h;
};

MochiKit.DOM.Dimensions.prototype.repr = function () {
    var repr = MochiKit.Base.repr;
    return "{w: "  + repr(this.w) + ", h: " + repr(this.h) + "}";
};

MochiKit.DOM.Coordinates = function (x, y) {
    this.x = x;
    this.y = y;
};

MochiKit.DOM.Coordinates.prototype.repr = function () {
    var repr = MochiKit.Base.repr;
    return "{x: "  + repr(this.x) + ", y: " + repr(this.y) + "}";
};

MochiKit.DOM.Coordinates.prototype.toString = function () {
    return this.repr();
};

MochiKit.Base.update(MochiKit.DOM, {

    setOpacity: function(elem, o) {
        elem = MochiKit.DOM.getElement(elem);
        MochiKit.DOM.updateNodeAttributes(elem, {'style': {
                'opacity': o, 
                '-moz-opacity': o,
                '-khtml-opacity': o,
                'filter':' alpha(opacity=' + (o * 100) + ')'
            }});
    },
    
    getViewportDimensions: function() {
        var d = new MochiKit.DOM.Dimensions();
        
        var w = MochiKit.DOM._window;
        var b = MochiKit.DOM._document.body;
        
        if (w.innerWidth) {
            d.w = w.innerWidth;
            d.h = w.innerHeight;
        } else if (b.parentElement.clientWidth) {
            d.w = b.parentElement.clientWidth;
            d.h = b.parentElement.clientHeight;
        } else if (b && b.clientWidth) {
            d.w = b.clientWidth;
            d.h = b.clientHeight;
        }
        return d;
    },

    elementDimensions: function (elem) {
        var self = MochiKit.DOM;
        if (typeof(elem.w) == 'number' || typeof(elem.h) == 'number') {
            return new self.Dimensions(elem.w || 0, elem.h || 0);
        }
        elem = self.getElement(elem);
        if (!elem) {
            return undefined;
        }
        if (self.computedStyle(elem, 'display') != 'none') {
            return new self.Dimensions(elem.offsetWidth || 0, 
                elem.offsetHeight || 0);
        }
        var s = elem.style;
        var originalVisibility = s.visibility;
        var originalPosition = s.position;
        s.visibility = 'hidden';
        s.position = 'absolute';
        s.display = '';
        var originalWidth = elem.offsetWidth;
        var originalHeight = elem.offsetHeight;
        s.display = 'none';
        s.position = originalPosition;
        s.visibility = originalVisibility;
        return new self.Dimensions(originalWidth, originalHeight);
    },

    /* 

        elementPosition is adapted from YAHOO.util.Dom.getXY, version 0.9.0.
        Copyright: Copyright (c) 2006, Yahoo! Inc. All rights reserved.
        License: BSD, http://developer.yahoo.net/yui/license.txt

    */
    elementPosition: function (elem, /* optional */relativeTo) {
        var self = MochiKit.DOM;        
        elem = self.getElement(elem);
        
        if (!elem) { 
            return undefined;
        }

        var c = new self.Coordinates(0, 0);
        
        if (elem.x && elem.y) {
            /* it's just a MochiKit.DOM.Coordinates object */
            c.x += elem.x || 0;
            c.y += elem.y || 0;
            return c;
        } else if (elem.parentNode === null || self.computedStyle(elem, 'display') == 'none') {
            return undefined;
        }
        
        var box = null;
        var parent = null;
        
        var d = MochiKit.DOM._document;
        var de = d.documentElement;
        var b = d.body;            
    
        if (elem.getBoundingClientRect) { // IE shortcut
            
            /*
            
                The IE shortcut is off by two:
                http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/getboundingclientrect.asp
                
            */
            box = elem.getBoundingClientRect();
                        
            c.x += box.left + 
                (de.scrollLeft || b.scrollLeft) - 
                (de.clientLeft || b.clientLeft);
            
            c.y += box.top + 
                (de.scrollTop || b.scrollTop) - 
                (de.clientTop || b.clientTop);
            
        } else if (d.getBoxObjectFor) { // Gecko shortcut
            box = d.getBoxObjectFor(elem);
            c.x += box.x;
            c.y += box.y;
        } else if (elem.offsetParent) {
            c.x += elem.offsetLeft;
            c.y += elem.offsetTop;
            parent = elem.offsetParent;
            
            if (parent != elem) {
                while (parent) {
                    c.x += parent.offsetLeft;
                    c.y += parent.offsetTop;
                    parent = parent.offsetParent;
                }
            }

            /*
                
                Opera < 9 and old Safari (absolute) incorrectly account for 
                body offsetTop and offsetLeft.
                
            */            
            var ua = navigator.userAgent.toLowerCase();
            if ((typeof(opera) != "undefined" && 
                parseFloat(opera.version()) < 9) || 
                (ua.indexOf('safari') != -1 && 
                self.computedStyle(elem, 'position') == 'absolute')) {
                                
                c.x -= b.offsetLeft;
                c.y -= b.offsetTop;
                
            }
        }
        
        if (typeof(relativeTo) != 'undefined') {
            relativeTo = arguments.callee(relativeTo);
            if (relativeTo) {
                c.x -= (relativeTo.x || 0);
                c.y -= (relativeTo.y || 0);
            }
        }
        
        if (elem.parentNode) {
            parent = elem.parentNode;
        } else {
            parent = null;
        }
        
        while (parent && parent.tagName != 'BODY' && 
            parent.tagName != 'HTML') {
            c.x -= parent.scrollLeft;
            c.y -= parent.scrollTop;        
            if (parent.parentNode) {
                parent = parent.parentNode;
            } else {
                parent = null;
            }
        }
        
        return c;
    },
    
    setElementDimensions: function (elem, newSize/* optional */, units) {
        elem = MochiKit.DOM.getElement(elem);
        if (typeof(units) == 'undefined') {
            units = 'px';
        }
        MochiKit.DOM.updateNodeAttributes(elem, {'style': {
            'width': newSize.w + units, 
            'height': newSize.h + units
        }});
    },
    
    setElementPosition: function (elem, newPos/* optional */, units) {
        elem = MochiKit.DOM.getElement(elem);
        if (typeof(units) == 'undefined') {
            units = 'px';
        }
        MochiKit.DOM.updateNodeAttributes(elem, {'style': {
            'left': newPos.x + units,
            'top': newPos.y + units
        }});
    },
    
    currentWindow: function () {
        return MochiKit.DOM._window;
    },

    currentDocument: function () {
        return MochiKit.DOM._document;
    },

    withWindow: function (win, func) {
        var self = MochiKit.DOM;
        var oldDoc = self._document;
        var oldWin = self._win;
        var rval;
        try {
            self._window = win;
            self._document = win.document;
            rval = func();
        } catch (e) {
            self._window = oldWin;
            self._document = oldDoc;
            throw e;
        }
        self._window = oldWin;
        self._document = oldDoc;
        return rval;
    },

    formContents: function (elem/* = document */) {
        var names = [];
        var values = [];
        var m = MochiKit.Base;
        var self = MochiKit.DOM;
        if (typeof(elem) == "undefined" || elem === null) {
            elem = self._document;
        } else {
            elem = self.getElement(elem);
        }
        m.nodeWalk(elem, function (elem) {
            var name = elem.name;
            if (m.isNotEmpty(name)) {
                var tagName = elem.nodeName;
                if (tagName == "INPUT"
                    && (elem.type == "radio" || elem.type == "checkbox")
                    && !elem.checked
                ) {
                    return null;
                }
                if (tagName == "SELECT") {
                    if (elem.selectedIndex >= 0) {
                        var opt = elem.options[elem.selectedIndex];
                        names.push(name);
                        values.push((opt.value) ? opt.value : opt.text);
                        return null;
                    }
                    // no form elements?
                    names.push(name);
                    values.push("");
                    return null;
                }
                if (tagName == "FORM" || tagName == "P" || tagName == "SPAN"
                    || tagName == "DIV"
                ) {
                    return elem.childNodes;
                }
                names.push(name);
                values.push(elem.value || '');
                return null;
            }
            return elem.childNodes;
        });
        return [names, values];
    },

    withDocument: function (doc, func) {
        var self = MochiKit.DOM;
        var oldDoc = self._document;
        var rval;
        try {
            self._document = doc;
            rval = func();
        } catch (e) {
            self._document = oldDoc;
            throw e;
        }
        self._document = oldDoc;
        return rval;
    },

    registerDOMConverter: function (name, check, wrap, /* optional */override) {
        MochiKit.DOM.domConverters.register(name, check, wrap, override);
    },

    coerceToDOM: function (node, ctx) {
        var im = MochiKit.Iter;
        var self = MochiKit.DOM;
        var iter = im.iter;
        var repeat = im.repeat;
        var imap = im.imap;
        var domConverters = self.domConverters;
        var coerceToDOM = self.coerceToDOM;
        var NotFound = MochiKit.Base.NotFound;
        while (true) {
            if (typeof(node) == 'undefined' || node === null) {
                return null;
            }
            if (typeof(node.nodeType) != 'undefined' && node.nodeType > 0) {
                return node;
            }
            if (typeof(node) == 'number' || typeof(node) == 'boolean') {
                node = node.toString();
                // FALL THROUGH
            }
            if (typeof(node) == 'string') {
                return self._document.createTextNode(node);
            }
            if (typeof(node.toDOM) == 'function') {
                node = node.toDOM(ctx);
                continue;
            }
            if (typeof(node) == 'function') {
                node = node(ctx);
                continue;
            }

            // iterable
            var iterNodes = null;
            try {
                iterNodes = iter(node);
            } catch (e) {
                // pass
            }
            if (iterNodes) {
                return imap(
                    coerceToDOM,
                    iterNodes,
                    repeat(ctx)
                );
            }

            // adapter
            try {
                node = domConverters.match(node, ctx);
                continue;
            } catch (e) {
                if (e != NotFound) {
                    throw e;
                }
            }

            // fallback
            return self._document.createTextNode(node.toString());
        }
        // mozilla warnings aren't too bright
        return undefined;
    },
        
    setNodeAttribute: function (node, attr, value) {
        var o = {};
        o[attr] = value;
        try {
            return MochiKit.DOM.updateNodeAttributes(node, o);
        } catch (e) {
            // pass
        }
        return null;
    },

    getNodeAttribute: function (node, attr) {
        var self = MochiKit.DOM;
        var rename = self.attributeArray.renames[attr];
        node = self.getElement(node);
        try {
            if (rename) {
                return node[rename];
            }
            return node.getAttribute(attr);
        } catch (e) {
            // pass
        }
        return null;
    },

    updateNodeAttributes: function (node, attrs) {
        var elem = node;
        var self = MochiKit.DOM;
        if (typeof(node) == 'string') {
            elem = self.getElement(node);
        }
        if (attrs) {
            var updatetree = MochiKit.Base.updatetree;
            if (self.attributeArray.compliant) {
                // not IE, good.
                for (var k in attrs) {
                    var v = attrs[k];
                    if (typeof(v) == 'object' && typeof(elem[k]) == 'object') {
                        updatetree(elem[k], v);
                    } else if (k.substring(0, 2) == "on") {
                        if (typeof(v) == "string") {
                            v = new Function(v);
                        }
                        elem[k] = v;
                    } else {
                        elem.setAttribute(k, v);
                    }
                }
            } else {
                // IE is insane in the membrane
                var renames = self.attributeArray.renames;
                for (k in attrs) {
                    v = attrs[k];
                    var renamed = renames[k];
                    if (k == "style" && typeof(v) == "string") {
                        elem.style.cssText = v;
                    } else if (typeof(renamed) == "string") {
                        elem[renamed] = v;
                    } else if (typeof(elem[k]) == 'object'
                            && typeof(v) == 'object') {
                        updatetree(elem[k], v);
                    } else if (k.substring(0, 2) == "on") {
                        if (typeof(v) == "string") {
                            v = new Function(v);
                        }
                        elem[k] = v;
                    } else {
                        elem.setAttribute(k, v);
                    }
                }
            }
        }
        return elem;
    },

    appendChildNodes: function (node/*, nodes...*/) {
        var elem = node;
        var self = MochiKit.DOM;
        if (typeof(node) == 'string') {
            elem = self.getElement(node);
        }
        var nodeStack = [
            self.coerceToDOM(
                MochiKit.Base.extend(null, arguments, 1),
                elem
            )
        ];
        var concat = MochiKit.Base.concat;
        while (nodeStack.length) {
            var n = nodeStack.shift();
            if (typeof(n) == 'undefined' || n === null) {
                // pass
            } else if (typeof(n.nodeType) == 'number') {
                elem.appendChild(n);
            } else {
                nodeStack = concat(n, nodeStack);
            }
        }
        return elem;
    },

    replaceChildNodes: function (node/*, nodes...*/) {
        var elem = node;
        var self = MochiKit.DOM;
        if (typeof(node) == 'string') {
            elem = self.getElement(node);
            arguments[0] = elem;
        }
        var child;
        while ((child = elem.firstChild)) {
            elem.removeChild(child);
        }
        if (arguments.length < 2) {
            return elem;
        } else {
            return self.appendChildNodes.apply(this, arguments);
        }
    },

    createDOM: function (name, attrs/*, nodes... */) {
        /*

            Create a DOM fragment in a really convenient manner, much like
            Nevow's <http://nevow.com> stan.

        */

        var elem;
        var self = MochiKit.DOM;
        var m = MochiKit.Base;
        if (typeof(attrs) == "string" || typeof(attrs) == "number") {
            var args = m.extend([name, null], arguments, 1);
            return arguments.callee.apply(this, args);
        }
        if (typeof(name) == 'string') {
            // Internet Explorer is dumb
            if (attrs && "name" in attrs && !self.attributeArray.compliant) {
                // http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/name_2.asp
                name = ('<' + name + ' name="' + self.escapeHTML(attrs.name)
                    + '">');
            }
            elem = self._document.createElement(name);
        } else {
            elem = name;
        }
        if (attrs) {
            self.updateNodeAttributes(elem, attrs);
        }
        if (arguments.length <= 2) {
            return elem;
        } else {
            var args = m.extend([elem], arguments, 2);
            return self.appendChildNodes.apply(this, args);
        }
    },

    createDOMFunc: function (/* tag, attrs, *nodes */) {
        var m = MochiKit.Base;
        return m.partial.apply(
            this,
            m.extend([MochiKit.DOM.createDOM], arguments)
        );
    },

    swapDOM: function (dest, src) {
        var self = MochiKit.DOM;
        dest = self.getElement(dest);
        var parent = dest.parentNode;
        if (src) {
            src = self.getElement(src);
            parent.replaceChild(src, dest);
        } else {
            parent.removeChild(dest);
        }
        return src;
    },

    getElement: function (id) {
        var self = MochiKit.DOM;
        if (arguments.length == 1) {
            return ((typeof(id) == "string") ?
                self._document.getElementById(id) : id);
        } else {
            return MochiKit.Base.map(self.getElement, arguments);
        }
    },

    computedStyle: function (htmlElement, cssProperty, mozillaEquivalentCSS) {
        if (arguments.length == 2) {
            mozillaEquivalentCSS = cssProperty;
        }   
        var self = MochiKit.DOM;
        var el = self.getElement(htmlElement);
        var document = self._document;
        if (!el || el == document) {
            return undefined;
        }
        if (el.currentStyle) {
            return el.currentStyle[cssProperty];
        }
        if (typeof(document.defaultView) == 'undefined') {
            return undefined;
        }
        if (document.defaultView === null) {
            return undefined;
        }
        var style = document.defaultView.getComputedStyle(el, null);
        if (typeof(style) == "undefined" || style === null) {
            return undefined;
        }
        return style.getPropertyValue(mozillaEquivalentCSS);
    },

    getElementsByTagAndClassName: function (tagName, className,
            /* optional */parent) {
        var self = MochiKit.DOM;
        if (typeof(tagName) == 'undefined' || tagName === null) {
            tagName = '*';
        }
        if (typeof(parent) == 'undefined' || parent === null) {
            parent = self._document;
        }
        parent = self.getElement(parent);
        var children = (parent.getElementsByTagName(tagName)
            || self._document.all);
        if (typeof(className) == 'undefined' || className === null) {
            return MochiKit.Base.extend(null, children);
        }

        var elements = [];
        for (var i = 0; i < children.length; i++) {
            var child = children[i];
            var classNames = child.className.split(' ');
            for (var j = 0; j < classNames.length; j++) {
                if (classNames[j] == className) {
                    elements.push(child);
                    break;
                }
            }
        }

        return elements;
    },

    _newCallStack: function (path, once) {
        var rval = function () {
            var callStack = arguments.callee.callStack;
            for (var i = 0; i < callStack.length; i++) {
                if (callStack[i].apply(this, arguments) === false) {
                    break;
                }
            }
            if (once) {
                try {
                    this[path] = null;
                } catch (e) {
                    // pass
                }
            }
        };
        rval.callStack = [];
        return rval;
    },

    addToCallStack: function (target, path, func, once) {
        var self = MochiKit.DOM;
        var existing = target[path];
        var regfunc = existing;
        if (!(typeof(existing) == 'function'
                && typeof(existing.callStack) == "object"
                && existing.callStack !== null)) {
            regfunc = self._newCallStack(path, once);
            if (typeof(existing) == 'function') {
                regfunc.callStack.push(existing);
            }
            target[path] = regfunc;
        }
        regfunc.callStack.push(func);
    },

    addLoadEvent: function (func) {
        var self = MochiKit.DOM;
        self.addToCallStack(self._window, "onload", func, true);
        
    },

    focusOnLoad: function (element) {
        var self = MochiKit.DOM;
        self.addLoadEvent(function () {
            element = self.getElement(element);
            if (element) {
                element.focus();
            }
        });
    },
            
    setElementClass: function (element, className) {
        var self = MochiKit.DOM;
        var obj = self.getElement(element);
        if (self.attributeArray.compliant) {
            obj.setAttribute("class", className);
        } else {
            obj.setAttribute("className", className);
        }
    },
            
    toggleElementClass: function (className/*, element... */) {
        var self = MochiKit.DOM;
        for (var i = 1; i < arguments.length; i++) {
            var obj = self.getElement(arguments[i]);
            if (!self.addElementClass(obj, className)) {
                self.removeElementClass(obj, className);
            }
        }
    },

    addElementClass: function (element, className) {
        var self = MochiKit.DOM;
        var obj = self.getElement(element);
        var cls = obj.className;
        // trivial case, no className yet
        if (cls.length === 0) {
            self.setElementClass(obj, className);
            return true;
        }
        // the other trivial case, already set as the only class
        if (cls == className) {
            return false;
        }
        var classes = obj.className.split(" ");
        for (var i = 0; i < classes.length; i++) {
            // already present
            if (classes[i] == className) {
                return false;
            }
        }
        // append class
        self.setElementClass(obj, cls + " " + className);
        return true;
    },

    removeElementClass: function (element, className) {
        var self = MochiKit.DOM;
        var obj = self.getElement(element);
        var cls = obj.className;
        // trivial case, no className yet
        if (cls.length === 0) {
            return false;
        }
        // other trivial case, set only to className
        if (cls == className) {
            self.setElementClass(obj, "");
            return true;
        }
        var classes = obj.className.split(" ");
        for (var i = 0; i < classes.length; i++) {
            // already present
            if (classes[i] == className) {
                // only check sane case where the class is used once
                classes.splice(i, 1);
                self.setElementClass(obj, classes.join(" "));
                return true;
            }
        }
        // not found
        return false;
    },

    swapElementClass: function (element, fromClass, toClass) {
        var obj = MochiKit.DOM.getElement(element);
        var res = MochiKit.DOM.removeElementClass(obj, fromClass);
        if (res) {
            MochiKit.DOM.addElementClass(obj, toClass);
        }
        return res;
    },

    hasElementClass: function (element, className/*...*/) {
        var obj = MochiKit.DOM.getElement(element);
        var classes = obj.className.split(" ");
        for (var i = 1; i < arguments.length; i++) {
            var good = false;
            for (var j = 0; j < classes.length; j++) {
                if (classes[j] == arguments[i]) {
                    good = true;
                    break;
                }
            }
            if (!good) {
                return false;
            }
        }
        return true;
    },

    escapeHTML: function (s) {
        return s.replace(/&/g, "&amp;"
            ).replace(/"/g, "&quot;"
            ).replace(/</g, "&lt;"
            ).replace(/>/g, "&gt;");
    },

    toHTML: function (dom) {
        return MochiKit.DOM.emitHTML(dom).join("");
    },

    emitHTML: function (dom, /* optional */lst) {
        if (typeof(lst) == 'undefined' || lst === null) {
            lst = [];
        }
        // queue is the call stack, we're doing this non-recursively
        var queue = [dom];
        var self = MochiKit.DOM;
        var escapeHTML = self.escapeHTML;
        var attributeArray = self.attributeArray;
        while (queue.length) {
            dom = queue.pop();
            if (typeof(dom) == 'string') {
                lst.push(dom);
            } else if (dom.nodeType == 1) {
                // we're not using higher order stuff here
                // because safari has heisenbugs.. argh.
                //
                // I think it might have something to do with
                // garbage collection and function calls.
                lst.push('<' + dom.nodeName.toLowerCase());
                var attributes = [];
                var domAttr = attributeArray(dom);
                for (var i = 0; i < domAttr.length; i++) {
                    var a = domAttr[i];
                    attributes.push([
                        " ",
                        a.name,
                        '="',
                        escapeHTML(a.value),
                        '"'
                    ]);
                }
                attributes.sort();
                for (i = 0; i < attributes.length; i++) {
                    var attrs = attributes[i];
                    for (var j = 0; j < attrs.length; j++) {
                        lst.push(attrs[j]);
                    }
                }
                if (dom.hasChildNodes()) {
                    lst.push(">");
                    // queue is the FILO call stack, so we put the close tag
                    // on first
                    queue.push("</" + dom.nodeName.toLowerCase() + ">");
                    var cnodes = dom.childNodes;
                    for (i = cnodes.length - 1; i >= 0; i--) {
                        queue.push(cnodes[i]);
                    }
                } else {
                    lst.push('/>');
                }
            } else if (dom.nodeType == 3) {
                lst.push(escapeHTML(dom.nodeValue));
            }
        }
        return lst;
    },

    setDisplayForElement: function (display, element/*, ...*/) {
        var m = MochiKit.Base;
        var elements = m.extend(null, arguments, 1);
        MochiKit.Iter.forEach(
            m.filter(null, m.map(MochiKit.DOM.getElement, elements)),
            function (element) {
                element.style.display = display;
            }
        );
    },

    scrapeText: function (node, /* optional */asArray) {
        var rval = [];
        (function (node) {
            var cn = node.childNodes;
            if (cn) {
                for (var i = 0; i < cn.length; i++) {
                    arguments.callee.call(this, cn[i]);
                }
            }
            var nodeValue = node.nodeValue;
            if (typeof(nodeValue) == 'string') {
                rval.push(nodeValue);
            }
        })(MochiKit.DOM.getElement(node));
        if (asArray) {
            return rval;
        } else {
            return rval.join("");
        }
    },


    __new__: function (win) {

        var m = MochiKit.Base;
        this._document = document;
        this._window = win;

        this.domConverters = new m.AdapterRegistry(); 
        
        var __tmpElement = this._document.createElement("span");
        var attributeArray;
        if (__tmpElement && __tmpElement.attributes &&
                __tmpElement.attributes.length > 0) {
            // for braindead browsers (IE) that insert extra junk
            var filter = m.filter;
            attributeArray = function (node) {
                return filter(attributeArray.ignoreAttrFilter, node.attributes);
            };
            attributeArray.ignoreAttr = {};
            MochiKit.Iter.forEach(__tmpElement.attributes, function (a) {
                attributeArray.ignoreAttr[a.name] = a.value;
            });
            attributeArray.ignoreAttrFilter = function (a) {
                return (attributeArray.ignoreAttr[a.name] != a.value);
            };
            attributeArray.compliant = false;
            attributeArray.renames = {
                "class": "className",
                "checked": "defaultChecked",
                "usemap": "useMap",
                "for": "htmlFor"
            };
        } else {
            attributeArray = function (node) {
                /***
                    
                    Return an array of attributes for a given node,
                    filtering out attributes that don't belong for
                    that are inserted by "Certain Browsers".

                ***/
                return node.attributes;
            };
            attributeArray.compliant = true;
            attributeArray.renames = {};
        }
        this.attributeArray = attributeArray;


        // shorthand for createDOM syntax
        var createDOMFunc = this.createDOMFunc;
        this.UL = createDOMFunc("ul");
        this.OL = createDOMFunc("ol");
        this.LI = createDOMFunc("li");
        this.TD = createDOMFunc("td");
        this.TR = createDOMFunc("tr");
        this.TBODY = createDOMFunc("tbody");
        this.THEAD = createDOMFunc("thead");
        this.TFOOT = createDOMFunc("tfoot");
        this.TABLE = createDOMFunc("table");
        this.TH = createDOMFunc("th");
        this.INPUT = createDOMFunc("input");
        this.SPAN = createDOMFunc("span");
        this.A = createDOMFunc("a");
        this.DIV = createDOMFunc("div");
        this.IMG = createDOMFunc("img");
        this.BUTTON = createDOMFunc("button");
        this.TT = createDOMFunc("tt");
        this.PRE = createDOMFunc("pre");
        this.H1 = createDOMFunc("h1");
        this.H2 = createDOMFunc("h2");
        this.H3 = createDOMFunc("h3");
        this.BR = createDOMFunc("br");
        this.HR = createDOMFunc("hr");
        this.LABEL = createDOMFunc("label");
        this.TEXTAREA = createDOMFunc("textarea");
        this.FORM = createDOMFunc("form");
        this.P = createDOMFunc("p");
        this.SELECT = createDOMFunc("select");
        this.OPTION = createDOMFunc("option");
        this.OPTGROUP = createDOMFunc("optgroup");
        this.LEGEND = createDOMFunc("legend");
        this.FIELDSET = createDOMFunc("fieldset");
        this.STRONG = createDOMFunc("strong");
        this.CANVAS = createDOMFunc("canvas");

        this.hideElement = m.partial(this.setDisplayForElement, "none");
        this.showElement = m.partial(this.setDisplayForElement, "block");
        this.removeElement = this.swapDOM;

        this.EXPORT_TAGS = {
            ":common": this.EXPORT,
            ":all": m.concat(this.EXPORT, this.EXPORT_OK)
        };

        m.nameFunctions(this);

    }
});

MochiKit.DOM.__new__(((typeof(window) == "undefined") ? this : window));

//
// XXX: Internet Explorer blows
//
if (!MochiKit.__compat__) {
    withWindow = MochiKit.DOM.withWindow;
    withDocument = MochiKit.DOM.withDocument;
}

MochiKit.Base._exportSymbols(this, MochiKit.DOM);

/***

MochiKit.Format 1.3.1

See <http://mochikit.com/> for documentation, downloads, license, etc.

(c) 2005 Bob Ippolito.  All rights Reserved.

***/

if (typeof(dojo) != 'undefined') {
    dojo.provide('MochiKit.Format');
}

if (typeof(MochiKit) == 'undefined') {
    MochiKit = {};
}

if (typeof(MochiKit.Format) == 'undefined') {
    MochiKit.Format = {};
}

MochiKit.Format.NAME = "MochiKit.Format";
MochiKit.Format.VERSION = "1.3.1";
MochiKit.Format.__repr__ = function () {
    return "[" + this.NAME + " " + this.VERSION + "]";
};
MochiKit.Format.toString = function () {
    return this.__repr__();
};

MochiKit.Format._numberFormatter = function (placeholder, header, footer, locale, isPercent, precision, leadingZeros, separatorAt, trailingZeros) {
    return function (num) {
        num = parseFloat(num);
        if (typeof(num) == "undefined" || num === null || isNaN(num)) {
            return placeholder;
        }
        var curheader = header;
        var curfooter = footer;
        if (num < 0) {
            num = -num;
        } else {
            curheader = curheader.replace(/-/, "");
        }
        var me = arguments.callee;
        var fmt = MochiKit.Format.formatLocale(locale);
        if (isPercent) {
            num = num * 100.0;
            curfooter = fmt.percent + curfooter;
        }
        num = MochiKit.Format.roundToFixed(num, precision);
        var parts = num.split(/\./);
        var whole = parts[0];
        var frac = (parts.length == 1) ? "" : parts[1];
        var res = "";
        while (whole.length < leadingZeros) {
            whole = "0" + whole;
        }
        if (separatorAt) {
            while (whole.length > separatorAt) {
                var i = whole.length - separatorAt;
                //res = res + fmt.separator + whole.substring(i, whole.length);
                res = fmt.separator + whole.substring(i, whole.length) + res;
                whole = whole.substring(0, i);
            }
        }
        res = whole + res;
        if (precision > 0) {
            while (frac.length < trailingZeros) {
                frac = frac + "0";
            }
            res = res + fmt.decimal + frac;
        }
        return curheader + res + curfooter;
    };
};

MochiKit.Format.numberFormatter = function (pattern, placeholder/* = "" */, locale/* = "default" */) {
    // http://java.sun.com/docs/books/tutorial/i18n/format/numberpattern.html
    // | 0 | leading or trailing zeros
    // | # | just the number
    // | , | separator
    // | . | decimal separator
    // | % | Multiply by 100 and format as percent
    if (typeof(placeholder) == "undefined") {
        placeholder = "";
    }
    var match = pattern.match(/((?:[0#]+,)?[0#]+)(?:\.([0#]+))?(%)?/);
    if (!match) {
        throw TypeError("Invalid pattern");
    }
    var header = pattern.substr(0, match.index);
    var footer = pattern.substr(match.index + match[0].length);
    if (header.search(/-/) == -1) {
        header = header + "-";
    }
    var whole = match[1];
    var frac = (typeof(match[2]) == "string" && match[2] != "") ? match[2] : "";
    var isPercent = (typeof(match[3]) == "string" && match[3] != "");
    var tmp = whole.split(/,/);
    var separatorAt;
    if (typeof(locale) == "undefined") {
        locale = "default";
    }
    if (tmp.length == 1) {
        separatorAt = null;
    } else {
        separatorAt = tmp[1].length;
    }
    var leadingZeros = whole.length - whole.replace(/0/g, "").length;
    var trailingZeros = frac.length - frac.replace(/0/g, "").length;
    var precision = frac.length;
    var rval = MochiKit.Format._numberFormatter(
        placeholder, header, footer, locale, isPercent, precision,
        leadingZeros, separatorAt, trailingZeros
    );
    var m = MochiKit.Base;
    if (m) {
        var fn = arguments.callee;
        var args = m.concat(arguments);
        rval.repr = function () {
            return [
                self.NAME,
                "(",
                map(m.repr, args).join(", "),
                ")"
            ].join("");
        };
    }
    return rval;
};

MochiKit.Format.formatLocale = function (locale) {
    if (typeof(locale) == "undefined" || locale === null) {
        locale = "default";
    }
    if (typeof(locale) == "string") {
        var rval = MochiKit.Format.LOCALE[locale];
        if (typeof(rval) == "string") {
            rval = arguments.callee(rval);
            MochiKit.Format.LOCALE[locale] = rval;
        }
        return rval;
    } else {
        return locale;
    }
};

MochiKit.Format.twoDigitAverage = function (numerator, denominator) {
    if (denominator) {
        var res = numerator / denominator;
        if (!isNaN(res)) {
            return MochiKit.Format.twoDigitFloat(numerator / denominator);
        }
    }
    return "0";
};

MochiKit.Format.twoDigitFloat = function (someFloat) {
    var sign = (someFloat < 0 ? '-' : '');
    var s = Math.floor(Math.abs(someFloat) * 100).toString();
    if (s == '0') {
        return s;
    }
    if (s.length < 3) {
        while (s.charAt(s.length - 1) == '0') {
            s = s.substring(0, s.length - 1);
        }
        return sign + '0.' + s;
    }
    var head = sign + s.substring(0, s.length - 2);
    var tail = s.substring(s.length - 2, s.length);
    if (tail == '00') {
        return head;
    } else if (tail.charAt(1) == '0') {
        return head + '.' + tail.charAt(0);
    } else {
        return head + '.' + tail;
    }
};

MochiKit.Format.lstrip = function (str, /* optional */chars) {
    str = str + "";
    if (typeof(str) != "string") {
        return null;
    }
    if (!chars) {
        return str.replace(/^\s+/, "");
    } else {
        return str.replace(new RegExp("^[" + chars + "]+"), "");
    }
};

MochiKit.Format.rstrip = function (str, /* optional */chars) {
    str = str + "";
    if (typeof(str) != "string") {
        return null;
    }
    if (!chars) {
        return str.replace(/\s+$/, "");
    } else {
        return str.replace(new RegExp("[" + chars + "]+$"), "");
    }
};

MochiKit.Format.strip = function (str, /* optional */chars) {
    var self = MochiKit.Format;
    return self.rstrip(self.lstrip(str, chars), chars);
};

MochiKit.Format.truncToFixed = function (aNumber, precision) {
    aNumber = Math.floor(aNumber * Math.pow(10, precision));
    var res = (aNumber * Math.pow(10, -precision)).toFixed(precision);
    if (res.charAt(0) == ".") {
        res = "0" + res;
    }
    return res;
};

MochiKit.Format.roundToFixed = function (aNumber, precision) {
    return MochiKit.Format.truncToFixed(
        aNumber + 0.5 * Math.pow(10, -precision),
        precision
    );
};

MochiKit.Format.percentFormat = function (someFloat) {
    return MochiKit.Format.twoDigitFloat(100 * someFloat) + '%';
};

MochiKit.Format.EXPORT = [
    "truncToFixed",
    "roundToFixed",
    "numberFormatter",
    "formatLocale",
    "twoDigitAverage",
    "twoDigitFloat",
    "percentFormat",
    "lstrip",
    "rstrip",
    "strip"
];

MochiKit.Format.LOCALE = {
    en_US: {separator: ",", decimal: ".", percent: "%"},
    de_DE: {separator: ".", decimal: ",", percent: "%"},
    fr_FR: {separator: " ", decimal: ",", percent: "%"},
    "default": "en_US"
};

MochiKit.Format.EXPORT_OK = [];
MochiKit.Format.EXPORT_TAGS = {
    ':all': MochiKit.Format.EXPORT,
    ':common': MochiKit.Format.EXPORT
};

MochiKit.Format.__new__ = function () {
    // MochiKit.Base.nameFunctions(this);
    var base = this.NAME + ".";
    var k, v, o;
    for (k in this.LOCALE) {
        o = this.LOCALE[k];
        if (typeof(o) == "object") {
            o.repr = function () { return this.NAME; };
            o.NAME = base + "LOCALE." + k;
        }
    }
    for (k in this) {
        o = this[k];
        if (typeof(o) == 'function' && typeof(o.NAME) == 'undefined') {
            try {
                o.NAME = base + k;
            } catch (e) {
                // pass
            }
        }
    }
};

MochiKit.Format.__new__();

if (typeof(MochiKit.Base) != "undefined") {
    MochiKit.Base._exportSymbols(this, MochiKit.Format);
} else {
    (function (globals, module) {
        if ((typeof(JSAN) == 'undefined' && typeof(dojo) == 'undefined')
            || (typeof(MochiKit.__compat__) == 'boolean' && MochiKit.__compat__)) {
            var all = module.EXPORT_TAGS[":all"];
            for (var i = 0; i < all.length; i++) {
                globals[all[i]] = module[all[i]]; 
            }
        }   
    })(this, MochiKit.Format);  
}

/***

MochiKit.MochiKit 1.3.1

See <http://mochikit.com/> for documentation, downloads, license, etc.

(c) 2005 Bob Ippolito.  All rights Reserved.

***/

if (typeof(MochiKit) == 'undefined') {
    MochiKit = {};
}

if (typeof(MochiKit.MochiKit) == 'undefined') {
    MochiKit.MochiKit = {};
}

MochiKit.MochiKit.NAME = "MochiKit.MochiKit";
MochiKit.MochiKit.VERSION = "1.3.1";
MochiKit.MochiKit.__repr__ = function () {
    return "[" + this.NAME + " " + this.VERSION + "]";
};

MochiKit.MochiKit.toString = function () {
    return this.__repr__();
};

MochiKit.MochiKit.SUBMODULES = [
    "Base",
    "Iter",
    "Logging",
    "DateTime",
    "Format",
    "Async",
    "DOM",
    "LoggingPane",
    "Color",
    "Signal",
    "Visual"
];

if (typeof(JSAN) != 'undefined' || typeof(dojo) != 'undefined') {
    if (typeof(dojo) != 'undefined') {
        dojo.provide('MochiKit.MochiKit');
        dojo.require("MochiKit.*");
    }
    if (typeof(JSAN) != 'undefined') {
        // hopefully this makes it easier for static analysis?
        JSAN.use("MochiKit.Base", []);
        JSAN.use("MochiKit.Iter", []);
        JSAN.use("MochiKit.Logging", []);
        JSAN.use("MochiKit.DateTime", []);
        JSAN.use("MochiKit.Format", []);
        JSAN.use("MochiKit.Async", []);
        JSAN.use("MochiKit.DOM", []);
        JSAN.use("MochiKit.LoggingPane", []);
        JSAN.use("MochiKit.Color", []);
        JSAN.use("MochiKit.Signal", []);
        JSAN.use("MochiKit.Visual", []);
    }
    (function () {
        var extend = MochiKit.Base.extend;
        var self = MochiKit.MochiKit;
        var modules = self.SUBMODULES;
        var EXPORT = [];
        var EXPORT_OK = [];
        var EXPORT_TAGS = {};
        var i, k, m, all;
        for (i = 0; i < modules.length; i++) {
            m = MochiKit[modules[i]];
            extend(EXPORT, m.EXPORT);
            extend(EXPORT_OK, m.EXPORT_OK);
            for (k in m.EXPORT_TAGS) {
                EXPORT_TAGS[k] = extend(EXPORT_TAGS[k], m.EXPORT_TAGS[k]);
            }
            all = m.EXPORT_TAGS[":all"];
            if (!all) {
                all = extend(null, m.EXPORT, m.EXPORT_OK);
            }
            var j;
            for (j = 0; j < all.length; j++) {
                k = all[j];
                self[k] = m[k];
            }
        }
        self.EXPORT = EXPORT;
        self.EXPORT_OK = EXPORT_OK;
        self.EXPORT_TAGS = EXPORT_TAGS;
    }());
    
} else {
    if (typeof(MochiKit.__compat__) == 'undefined') {
        MochiKit.__compat__ = true;
    }
    (function () {
        var scripts = document.getElementsByTagName("script");
        var kXULNSURI = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
        var base = null;
        var baseElem = null;
        var allScripts = {};
        var i;
        for (i = 0; i < scripts.length; i++) {
            var src = scripts[i].getAttribute("src");
            if (!src) {
                continue;
            }
            allScripts[src] = true;
            if (src.match(/MochiKit.js$/)) {
                base = src.substring(0, src.lastIndexOf('MochiKit.js'));
                baseElem = scripts[i];
            }
        }
        if (base === null) {
            return;
        }
        var modules = MochiKit.MochiKit.SUBMODULES;
        for (var i = 0; i < modules.length; i++) {
            if (MochiKit[modules[i]]) {
                continue;
            }
            var uri = base + modules[i] + '.js';
            if (uri in allScripts) {
                continue;
            }
            if (document.documentElement &&
                document.documentElement.namespaceURI == kXULNSURI) {
                // XUL
                var s = document.createElementNS(kXULNSURI, 'script');
                s.setAttribute("id", "MochiKit_" + base + modules[i]);
                s.setAttribute("src", uri);
                s.setAttribute("type", "application/x-javascript");
                baseElem.parentNode.appendChild(s);
            } else {
                // HTML
                /*
                    DOM can not be used here because Safari does
                    deferred loading of scripts unless they are
                    in the document or inserted with document.write

                    This is not XHTML compliant.  If you want XHTML
                    compliance then you must use the packed version of MochiKit
                    or include each script individually (basically unroll
                    these document.write calls into your XHTML source)

                */
                document.write('<script src="' + uri +
                    '" type="text/javascript"></script>');
            }
        };
    })();
}

/*
    PlotKit
    =======
    PlotKit is a collection of Javascript classes that allows
    you to quickly visualise data using different types of charts.

    For license/info/documentation: http://www.liquidx.net/plotkit/

    Copyright
    ---------
    Copyright 2005,2006 (c) Alastair Tse <alastair^liquidx.net>
    For use under the BSD license. <http://www.liquidx.net/plotkit>
*/

// --------------------------------------------------------------------
// Check required components
// --------------------------------------------------------------------

try {    
    if (typeof(MochiKit.Base) == 'undefined'   ||
        typeof(MochiKit.DOM) == 'undefined'    ||
        typeof(MochiKit.Color) == 'undefined'  ||
        typeof(MochiKit.Format) == 'undefined')
    {
        throw "";    
    }
} 
catch (e) {    
    throw "PlotKit depends on MochiKit.{Base,Color,DOM,Format}"
}

// -------------------------------------------------------------------
// Inject Common Shortcuts we use into MochiKit.Color.Color
// -------------------------------------------------------------------

MochiKit.Base.update(MochiKit.Color.Color.prototype, {
    asFillColor: function() {
        return this.lighterColorWithLevel(0.3);
    },
        
    asStrokeColor: function() {
        return this.darkerColorWithLevel(0.1);
    },

    asPointColor: function() {
        return this.lighterColorWithLevel(0.1);
    }
});


// -------------------------------------------------------------------
// Define our own PlotKit namespace
// -------------------------------------------------------------------

if (typeof(PlotKit) == 'undefined') {
    PlotKit = {};
}

PlotKit.NAME = "PlotKit";
PlotKit.VERSION = "0.8";
PlotKit.__repr__ = function() {
    return "[" + this.NAME + " " + this.VERSION + "]";
};

PlotKit.toString = function() {
    return this.__repr__();
}

// -------------------------------------------------------------------
//  Encapsulate all our utility function into it's own namespace.
// -------------------------------------------------------------------

if (typeof(PlotKit.Base) == 'undefined') {
    PlotKit.Base = {};
}

PlotKit.Base.NAME = 'PlotKit.Base';
PlotKit.Base.VERSION = PlotKit.VERSION;

PlotKit.Base.__repr__ = function() {
    return "[" + this.NAME + " " + this.VERSION + "]";
};

PlotKit.Base.toString = function() {
    return this.__repr__();
}


// Detect whether we are using prototype.js
PlotKit.Base.usingPrototype =  function() {
    try {
        return (typeof(Object.extend) == 'function');
    }
    catch (e) {
        return false;
    }
}


MochiKit.Base.update(PlotKit.Base, {
    roundInterval: function(range, intervals, precision) {
        // We want to make the interval look regular,
        var trunc = MochiKit.Format.roundToFixed;
        var sep = range/intervals;
        return parseFloat(trunc(sep, precision));
    },

    collapse: function(lst) {
        var m = MochiKit.Base;
        var biggerList = new Array();
        for (var i = 0; i < lst.length; i++) {
            biggerList = m.concat(biggerList, lst[i]);
        }
        if (PlotKit.Base.usingPrototype()) {
            delete biggerList.extend;
            delete biggerList.from;
            delete biggerList.inspect;
        }
        
        return biggerList;
    },
    
    uniq: function(sortedList) {
        // get unique elements in list, exactly the same as unix shell's uniq.
        var m = MochiKit.Base;
        
        if (!m.isArrayLike(sortedList) || (sortedList.length < 1))
            return new Array();

        var uniq = new Array();
        var lastElem = sortedList[0];    
        uniq.push(sortedList[0]);
        for (var i = 1; i < sortedList.length; i++) {
            if (sortedList[i] != null && m.compare(sortedList[i], lastElem) != 0) {
                lastElem = sortedList[i];
                uniq.push(sortedList[i]);            
            }
        }
        return uniq;
    },
    
    colorScheme: function() {
        var mb = MochiKit.Base;
        var mc = MochiKit.Color
        var scheme = ["red", "orange", "yellow", "green", "cyan", "blue", "purple", "magenta"];
        
        var makeColor = function(name) {
            return mc.Color[name + "Color"]()
        };
        
        return mb.map(makeColor, scheme);
    },

    baseDarkPrimaryColors: function () {
        var hexColor = MochiKit.Color.Color.fromHexString;
        return [hexColor("#ad3f40"),
                hexColor("#ddac2c"),
                hexColor("#dfdd0c"),
                hexColor("#5276c4"),
                hexColor("#739c5a")];
    },

    basePrimaryColors: function () {
        var hexColor = MochiKit.Color.Color.fromHexString;
        return [hexColor("#d24c4d"),
                hexColor("#f2b32f"),
                hexColor("#ece90e"),
                hexColor("#5d83da"),
                hexColor("#78a15d")];
    },
    
    baseBlueColors: function () {
         var hexColor = MochiKit.Color.Color.fromHexString;
         return [hexColor("#4b6b94"), hexColor("#5d81b4"), hexColor("#acbad2")];
    },

    palette: function(baseColor, fromLevel, toLevel, increment) {
        var isNil = MochiKit.Base.isUndefinedOrNull;
        var fractions = new Array();
        if (isNil(increment))
            increment = 0.1;
        if (isNil(toLevel))
            toLevel = 0.4;
        if (isNil(fromLevel))
            fromLevel = -0.2;

        var level = fromLevel;
        while (level <= toLevel) {
            fractions.push(level);
            level += increment;
        }
            
        var makeColor = function(color, fraction) {
            return color.lighterColorWithLevel(fraction);
        };
        return MochiKit.Base.map(partial(makeColor, baseColor), fractions);
    },
    
    excanvasSupported: function() {
         if (/MSIE/.test(navigator.userAgent) && !window.opera) {
             return true;
         }
         return false;
    },

    // The following functions are from quirksmode.org
    // http://www.quirksmode.org/js/findpos.html

    findPosX: function(obj) {
        var curleft = 0;
        if (obj.offsetParent) {
            while (obj.offsetParent) {
                    curleft += obj.offsetLeft
                        obj = obj.offsetParent;
            }
        }
        else if (obj.x)
            curleft += obj.x;
        return curleft;
    },
                       
   findPosY: function(obj) {
       var curtop = 0;
       if (obj.offsetParent) {
           while (obj.offsetParent) {
               curtop += obj.offsetTop
               obj = obj.offsetParent;
           }
       }
       else if (obj.y)
           curtop += obj.y;
       return curtop;
   },
   
   isFuncLike: function(obj) {
       return (typeof(obj) == 'function');
   }
});    

//
// Prototype.js aware (crippled) versions of map and items.
//

PlotKit.Base.map = function(fn, lst) {
    if (PlotKit.Base.usingPrototype()) {
        var rval = [];
        for (var x in lst) {
            if (typeof(lst[x]) == 'function') continue;
            rval.push(fn(lst[x]));
        }
        return rval;
    }
    else {
        return MochiKit.Base.map(fn, lst);
    }
};

PlotKit.Base.items = function(lst) {
    if (PlotKit.Base.usingPrototype()) {
        var rval = [];
         for (var x in lst) {
             if (typeof(lst[x]) == 'function') continue;
             rval.push([x, lst[x]]);
         }
         return rval;
    }
    else {
        return MochiKit.Base.items(lst);
    }
};

PlotKit.Base.keys = function(lst) {
    if (PlotKit.Base.usingPrototype()) {
        var rval = [];
         for (var x in lst) {
             if (typeof(lst[x]) == 'function') continue;
             rval.push(x);
         }
         return rval;
    }
    else {
        return MochiKit.Base.keys(lst);
    }
};

// 
// colour schemes
//

PlotKit.Base.baseColors = function () {
   var hexColor = MochiKit.Color.Color.fromHexString;
   return [hexColor("#476fb2"),
           hexColor("#be2c2b"),
           hexColor("#85b730"),
           hexColor("#734a99"),
           hexColor("#26a1c5"),
           hexColor("#fb8707"),
           hexColor("#000000")];
};

PlotKit.Base.officeBaseStyle = {
    "axisLineWidth": 2.0,
    "axisLabelColor": Color.grayColor(),
    "axisLineColor": Color.grayColor(),
    "backgroundLineColor": Color.whiteColor(),
    "padding": {top: 5, bottom: 10, left: 30, right: 30}
};    

MochiKit.Base.update(PlotKit.Base,{
    officeBlue: function() {
        var r = {
        "colorScheme": PlotKit.Base.palette(PlotKit.Base.baseColors()[0]),
        "backgroundColor": PlotKit.Base.baseColors()[0].lighterColorWithLevel(0.45)
        };
        MochiKit.Base.update(r, PlotKit.Base.officeBaseStyle);
        return r;
    },
    officeRed: function() {
        var r = {
        "colorScheme": PlotKit.Base.palette(PlotKit.Base.baseColors()[1]),
        "backgroundColor": PlotKit.Base.baseColors()[1].lighterColorWithLevel(0.5)
        };
        MochiKit.Base.update(r, PlotKit.Base.officeBaseStyle);
        return r;
    },
    officeGreen: function() {
        var r = {
        "colorScheme": PlotKit.Base.palette(PlotKit.Base.baseColors()[2]),
        "backgroundColor": PlotKit.Base.baseColors()[2].lighterColorWithLevel(0.5)
        };
        MochiKit.Base.update(r, PlotKit.Base.officeBaseStyle);
        return r;
    },
    officePurple: function() {
        var r = {
        "colorScheme": PlotKit.Base.palette(PlotKit.Base.baseColors()[3]),
        "backgroundColor": PlotKit.Base.baseColors()[3].lighterColorWithLevel(0.5)
        };
        MochiKit.Base.update(r, PlotKit.Base.officeBaseStyle);
        return r;
    },
    
    officeCyan: function() {
        var r = {
            "colorScheme": PlotKit.Base.palette(PlotKit.Base.baseColors()[4]),
            "backgroundColor": PlotKit.Base.baseColors()[4].lighterColorWithLevel(0.5)
            };
        MochiKit.Base.update(r, PlotKit.Base.officeBaseStyle);
        return r;
    },
    
    officeOrange: function() {
        var r = {
            "colorScheme": PlotKit.Base.palette(PlotKit.Base.baseColors()[5]),
            "backgroundColor": PlotKit.Base.baseColors()[5].lighterColorWithLevel(0.4)
            };
        MochiKit.Base.update(r, PlotKit.Base.officeBaseStyle);
        return r;
    },
    
    officeBlack: function() {
        var r = {
        "colorScheme": PlotKit.Base.palette(PlotKit.Base.baseColors()[6], 0.0, 0.6),
        "backgroundColor": PlotKit.Base.baseColors()[6].lighterColorWithLevel(0.9)
        };
        MochiKit.Base.update(r, PlotKit.Base.officeBaseStyle);
        return r;
    }
});


PlotKit.Base.EXPORT = [
   "baseColors",
   "collapse",
   "colorScheme",
   "findPosX",
   "findPosY",
   "officeBaseStyle",
   "officeBlue",
   "officeRed",
   "officeGreen",
   "officePurple",
   "officeCyan",
   "officeOrange",
   "officeBlack",
   "roundInterval",
   "uniq",
   "isFuncLike",
   "excanvasSupported"
];

PlotKit.Base.EXPORT_OK = [];

PlotKit.Base.__new__ = function() {
    var m = MochiKit.Base;
    
    m.nameFunctions(this);
    
    this.EXPORT_TAGS = {
        ":common": this.EXPORT,
        ":all": m.concat(this.EXPORT, this.EXPORT_OK)
    };
};

PlotKit.Base.__new__();
MochiKit.Base._exportSymbols(this, PlotKit.Base);


/* 
    PlotKit Layout
    ==============
    
    Handles laying out data on to a virtual canvas square canvas between 0.0 
    and 1.0. If you want to add new chart/plot types such as point plots,
    you need to add them here.
    
    Copyright
    ---------
    Copyright 2005,2006 (c) Alastair Tse <alastair^liquidx.net>
    For use under the BSD license. <http://www.liquidx.net/plotkit>
    
*/

try {    
    if (typeof(PlotKit.Base) == 'undefined')
    {
        throw ""
    }
} 
catch (e) {    
    throw "PlotKit.Layout depends on MochiKit.{Base,Color,DOM,Format} and PlotKit.Base"
}

// --------------------------------------------------------------------
// Start of Layout definition
// --------------------------------------------------------------------

if (typeof(PlotKit.Layout) == 'undefined') {
    PlotKit.Layout = {};
}

PlotKit.Layout.NAME = "PlotKit.Layout";
PlotKit.Layout.VERSION = PlotKit.VERSION;

PlotKit.Layout.__repr__ = function() {
    return "[" + this.NAME + " " + this.VERSION + "]";
};

PlotKit.Layout.toString = function() {
    return this.__repr__();
}

PlotKit.Layout.valid_styles = ["bar", "line", "pie", "point"];

// --------------------------------------------------------------------
// Start of Layout definition
// --------------------------------------------------------------------

PlotKit.Layout = function(style, options) {
  
    this.options = {
        "barWidthFillFraction": 0.75,
        "barOrientation": "vertical",
        "xOriginIsZero": false,
        "yOriginIsZero": false,
        "xAxis": null, // [xmin, xmax]
        "yAxis": null, // [ymin, ymax]
        "xTicks": null, // [{label: "somelabel", v: value}, ..] (label opt.)
        "yTicks": null, // [{label: "somelabel", v: value}, ..] (label opt.)
        "xNumberOfTicks": 10,
        "yNumberOfTicks": 5,
        "xTickPrecision": 1,
        "yTickPrecision": 1,
        "pieRadius": 0.4
    };

    // valid external options : TODO: input verification
    this.style = style; 
    MochiKit.Base.update(this.options, options ? options : {});

    // externally visible states
    // overriden if xAxis and yAxis are set in options
    if (!MochiKit.Base.isUndefinedOrNull(this.options.xAxis)) {
        this.minxval = this.options.xAxis[0];
        this.maxxval = this.options.xAxis[1];
        this.xscale = this.maxxval - this.minxval; 
    }
    else {
        this.minxval = 0;
        this.maxxval = null;
        this.xscale = null; // val -> pos factor (eg, xval * xscale = xpos)
    }

    if (!MochiKit.Base.isUndefinedOrNull(this.options.yAxis)) {
        this.minyval = this.options.yAxis[0];
        this.maxyval = this.options.yAxis[1];
        this.yscale = this.maxyval - this.minyval;
    }
    else {
        this.minyval = 0;
        this.maxyval = null;
        this.yscale = null;
    }

    this.bars = new Array();   // array of bars to plot for bar charts
    this.points = new Array(); // array of points to plot for line plots
    this.slices = new Array(); // array of slices to draw for pie charts

    this.xticks = new Array();
    this.yticks = new Array();

    // internal states
    this.datasets = new Array();
    this.minxdelta = 0;
    this.xrange = 1;
    this.yrange = 1;

    this.hitTestCache = {x2maxy: null};
    
};

// --------------------------------------------------------------------
// Dataset Manipulation
// --------------------------------------------------------------------


PlotKit.Layout.prototype.addDataset = function(setname, set_xy) {
    this.datasets[setname] = set_xy;
};

PlotKit.Layout.prototype.removeDataset = function(setname, set_xy) {
    delete this.datasets[setname];
};

PlotKit.Layout.prototype.addDatasetFromTable = function(name, tableElement, xcol, ycol,  lcol) {
	var isNil = MochiKit.Base.isUndefinedOrNull;
	var scrapeText = MochiKit.DOM.scrapeText;
	var strip = MochiKit.Format.strip;
	
	if (isNil(xcol))
		xcol = 0;
	if (isNil(ycol))
		ycol = 1;
	if (isNil(lcol))
	    lcol = -1;
        
    var rows = tableElement.tBodies[0].rows;
    var data = new Array();
    var labels = new Array();
    
    if (!isNil(rows)) {
        for (var i = 0; i < rows.length; i++) {
            data.push([parseFloat(strip(scrapeText(rows[i].cells[xcol]))),
                       parseFloat(strip(scrapeText(rows[i].cells[ycol])))]);
            if (lcol >= 0){
               labels.push({v: parseFloat(strip(scrapeText(rows[i].cells[xcol]))),
                            label:  strip(scrapeText(rows[i].cells[lcol]))});
            }
        }
        this.addDataset(name, data);
        if (lcol >= 0) {
            this.options.xTicks = labels;
        }
        return true;
    }
    return false;
};

// --------------------------------------------------------------------
// Evaluates the layout for the current data and style.
// --------------------------------------------------------------------

PlotKit.Layout.prototype.evaluate = function() {
    this._evaluateLimits();
    this._evaluateScales();
    if (this.style == "bar") {
        if (this.options.barOrientation == "horizontal") {
            this._evaluateHorizBarCharts();
        }
        else {
            this._evaluateBarCharts();
        }
        this._evaluateBarTicks();
    }
    else if (this.style == "line") {
        this._evaluateLineCharts();
        this._evaluateLineTicks();
    }
    else if (this.style == "pie") {
        this._evaluatePieCharts();
        this._evaluatePieTicks();
    }
};



// Given the fractional x, y positions, report the corresponding
// x, y values.
PlotKit.Layout.prototype.hitTest = function(x, y) {
    // TODO: make this more efficient with better datastructures
    //       for this.bars, this.points and this.slices

    var f = MochiKit.Format.twoDigitFloat;

    if ((this.style == "bar") && this.bars && (this.bars.length > 0)) {
        for (var i = 0; i < this.bars.length; i++) {
            var bar = this.bars[i];
            if ((x >= bar.x) && (x <= bar.x + bar.w) 
                && (y >= bar.y) && (y - bar.y <= bar.h))
                return bar;
        }
    }

    else if (this.style == "line") {
        if (this.hitTestCache.x2maxy == null) {
            this._regenerateHitTestCache();
        }

        // 1. find the xvalues that equal or closest to the give x
        var xval = x / this.xscale;
        var xvalues = this.hitTestCache.xvalues;
        var xbefore = null;
        var xafter = null;

        for (var i = 1; i < xvalues.length; i++) {
            if (xvalues[i] > xval) {
                xbefore = xvalues[i-1];
                xafter = xvalues[i];
                break;
            }
        }

        if ((xbefore != null)) {
            var ybefore = this.hitTestCache.x2maxy[xbefore];
            var yafter = this.hitTestCache.x2maxy[xafter];
            var yval = (1.0 - y)/this.yscale;

            // interpolate whether we will fall inside or outside
            var gradient = (yafter - ybefore) / (xafter - xbefore);
            var projmaxy = ybefore + gradient * (xval - xbefore);
            if (projmaxy >= yval) {
                // inside the highest curve (roughly)
                var obj = {xval: xval, yval: yval,
                           xafter: xafter, yafter: yafter,
                           xbefore: xbefore, ybefore: ybefore,
                           yprojected: projmaxy
                };
                return obj;
            }
        }
    }

    else if (this.style == "pie") {
        var dist = Math.sqrt((y-0.5)*(y-0.5) + (x-0.5)*(x-0.5));
        if (dist > this.options.pieRadius)
            return null;

        // TODO: actually doesn't work if we don't know how the Canvas
        //       lays it out, need to fix!
        var angle = Math.atan2(y - 0.5, x - 0.5) - Math.PI/2;
        for (var i = 0; i < this.slices.length; i++) {
            var slice = this.slices[i];
            if (slice.startAngle < angle && slice.endAngle >= angle)
                return slice;
        }
    }

    return null;
};

// Reports valid position rectangle for X value (only valid for bar charts)
PlotKit.Layout.prototype.rectForX = function(x) {
    return null;
};

// Reports valid angles through which X value encloses (only valid for pie charts)
PlotKit.Layout.prototype.angleRangeForX = function(x) {
    return null;
};

// --------------------------------------------------------------------
// START Internal Functions
// --------------------------------------------------------------------

PlotKit.Layout.prototype._evaluateLimits = function() {
    // take all values from all datasets and find max and min
    var map = PlotKit.Base.map;
    var items = PlotKit.Base.items;
    var itemgetter = MochiKit.Base.itemgetter;
    var collapse = PlotKit.Base.collapse;
    var listMin = MochiKit.Base.listMin;
    var listMax = MochiKit.Base.listMax;
    var isNil = MochiKit.Base.isUndefinedOrNull;


    var all = collapse(map(itemgetter(1), items(this.datasets)));
    if (isNil(this.options.xAxis)) {
        if (this.options.xOriginIsZero)
            this.minxval = 0;
        else
            this.minxval = listMin(map(parseFloat, map(itemgetter(0), all)));

        this.maxxval = listMax(map(parseFloat, map(itemgetter(0), all)));
    }
    else {
        this.minxval = this.options.xAxis[0];
        this.maxxval = this.options.xAxis[1];
        this.xscale = this.maxval - this.minxval;
    }
    
    if (isNil(this.options.yAxis)) {
        if (this.options.yOriginIsZero)
            this.minyval = 0;
        else{
            this.minyval = listMin(map(parseFloat, map(itemgetter(1), all)));
            if(this.minyval>0 || isNaN(this.minyval) || this.minyval == null) 
            	this.minyval = 0;
        }

        this.maxyval = listMax(map(parseFloat, map(itemgetter(1), all)));
        if(this.maxyval<0)
        	this.maxyval = 0;
        else if(isNaN(this.maxyval) || this.maxyval == null || this.maxyval == 0)
        	this.maxyval = 1;
        else
        	this.maxyval += (this.maxyval - this.minyval) * .05;
        
       if(this.minyval < 0)
    	   this.minyval -= (this.maxyval - this.minyval) * .05;

    }
    else {
        this.minyval = this.options.yAxis[0];
        this.maxyval = this.options.yAxis[1];
        this.yscale = this.maxyval - this.minyval;
    }
};

PlotKit.Layout.prototype._evaluateScales = function() {
    var isNil = MochiKit.Base.isUndefinedOrNull;

    this.xrange = this.maxxval - this.minxval;
    if (this.xrange == 0)
        this.xscale = 1.0;
    else
        this.xscale = 1/this.xrange;

    this.yrange = this.maxyval - this.minyval;
    if (this.yrange == 0)
        this.yscale = 1.0;
    else
        this.yscale = 1/this.yrange;
};

PlotKit.Layout.prototype._uniqueXValues = function() {
    var collapse = PlotKit.Base.collapse;
    var map = PlotKit.Base.map;
    var uniq = PlotKit.Base.uniq;
    var getter = MochiKit.Base.itemgetter;
    var items = PlotKit.Base.items;
    
    var xvalues = map(parseFloat, map(getter(0), collapse(map(getter(1), items(this.datasets)))));
    xvalues.sort(MochiKit.Base.compare);
    return uniq(xvalues);
};

// Create the bars
PlotKit.Layout.prototype._evaluateBarCharts = function() {
    var items = PlotKit.Base.items;

    var setCount = items(this.datasets).length;

    // work out how far separated values are
    var xdelta = 10000000;
    var xvalues = this._uniqueXValues();
    for (var i = 1; i < xvalues.length; i++) {
        xdelta = Math.min(Math.abs(xvalues[i] - xvalues[i-1]), xdelta);
    }

    var barWidth = 0;
    var barWidthForSet = 0;
    var barMargin = 0;
    if (xvalues.length == 1) {
        // note we have to do something smarter if we only plot one value
        xdelta = 1.0;
        this.xscale = 1.0;
        this.minxval = xvalues[0];
        barWidth = 1.0 * this.options.barWidthFillFraction;
        barWidthForSet = barWidth/setCount;
        barMargin = (1.0 - this.options.barWidthFillFraction)/2;
    }
    else {
        // readjust xscale to fix with bar charts
        if (this.xrange == 1) {
            this.xscale = 0.5;
        }
        else if (this.xrange == 2) {
            this.xscale = 1/3.0;
        }
        else {
            this.xscale = (1.0 - xdelta/this.xrange)/this.xrange;
        }
        barWidth = xdelta * this.xscale * this.options.barWidthFillFraction;
        barWidthForSet = barWidth / setCount;
        barMargin = xdelta * this.xscale * (1.0 - this.options.barWidthFillFraction)/2;
    }
    
    this.minxdelta = xdelta; // need this for tick positions

    // add all the rects
    this.bars = new Array();
    var i = 0;
    for (var setName in this.datasets) {
        var dataset = this.datasets[setName];
        if (PlotKit.Base.isFuncLike(dataset)) continue;
        for (var j = 0; j < dataset.length; j++) {
            var item = dataset[j];

            var rect = {
                xval: parseFloat(item[0]),
                yval: parseFloat(item[1]),
                name: setName,
                w: barWidthForSet,
            	x: ((parseFloat(item[0]) - this.minxval) * this.xscale) + (i * barWidthForSet) + barMargin
            };

            if(parseFloat(item[1])>=0){
                rect.y = 1.0 - ((parseFloat(item[1]) - this.minyval) * this.yscale);  // top
                rect.h = ((parseFloat(item[1])) * this.yscale);
            }else{ // negative
                rect.y = this.maxyval * this.yscale;  // top 
                rect.h = (-parseFloat(item[1]) * this.yscale);
            }
            
            if ((rect.x >= 0.0) && (rect.x <= 1.0) && 
                (rect.y >= 0.0) && (rect.y <= 1.0)) {
                this.bars.push(rect);
            }
        }
        i++;
    }
};

// Create the horizontal bars
PlotKit.Layout.prototype._evaluateHorizBarCharts = function() {
    var items = PlotKit.Base.items;

    var setCount = items(this.datasets).length;

    // work out how far separated values are
    var xdelta = 10000000;
    var xvalues = this._uniqueXValues();
    for (var i = 1; i < xvalues.length; i++) {
        xdelta = Math.min(Math.abs(xvalues[i] - xvalues[i-1]), xdelta);
    }

    var barWidth = 0;
    var barWidthForSet = 0;
    var barMargin = 0;
    
    // work out how far each far each bar is separated
    if (xvalues.length == 1) {
        // do something smarter if we only plot one value
        xdelta = 1.0;
        this.xscale = 1.0;
        this.minxval = xvalues[0];
        barWidth = 1.0 * this.options.barWidthFillFraction;
        barWidthForSet = barWidth/setCount;
        barMargin = (1.0 - this.options.barWidthFillFraction)/2;
    }
    else {
        // readjust yscale to fix with bar charts
        this.xscale = (1.0 - xdelta/this.xrange)/this.xrange;
        barWidth = xdelta * this.xscale * this.options.barWidthFillFraction;
        barWidthForSet = barWidth / setCount;
        barMargin = xdelta * this.xscale * (1.0 - this.options.barWidthFillFraction)/2;
    }

    this.minxdelta = xdelta; // need this for tick positions

    // add all the rects
    this.bars = new Array();
    var i = 0;
    for (var setName in this.datasets) {
        var dataset = this.datasets[setName];
        if (PlotKit.Base.isFuncLike(dataset)) continue;
        for (var j = 0; j < dataset.length; j++) {
            var item = dataset[j];
            var rect = {
                y: ((parseFloat(item[0]) - this.minxval) * this.xscale) + (i * barWidthForSet) + barMargin,
                x: 0.0,
                h: barWidthForSet,
                w: ((parseFloat(item[1]) - this.minyval) * this.yscale),
                xval: parseFloat(item[0]),
                yval: parseFloat(item[1]),
                name: setName
            };

            // limit the x, y values so they do not overdraw
            if (rect.y <= 0.0) {
                rect.y = 0.0;
            }
            if (rect.y >= 1.0) {
                rect.y = 1.0;
            }
            if ((rect.x >= 0.0) && (rect.x <= 1.0)) {
                this.bars.push(rect);
            }
        }
        i++;
    }
};


// Create the line charts
PlotKit.Layout.prototype._evaluateLineCharts = function() {
    var items = PlotKit.Base.items;

    var setCount = items(this.datasets).length;

    // add all the rects
    this.points = new Array();
    var i = 0;
    for (var setName in this.datasets) {
        var dataset = this.datasets[setName];
        if (PlotKit.Base.isFuncLike(dataset)) continue;
        dataset.sort(function(a, b) { return compare(parseFloat(a[0]), parseFloat(b[0])); });
        for (var j = 0; j < dataset.length; j++) {
            var item = dataset[j];

            // KLUGE: for now the value can't be null because it causes the  layout to break when the first place added has a null value.
            // Setting the value to a 0.00000 string on the charts page before passing it along allows it to check for that value before plotting points
	    // So basically "0.00000" replaces null, this way 0 can still be used for calculating the y axis.
            // TODO: make calculation of the line chart layout not break when the first place added has a null value.
            if (item[1] == "0.00000")
            	item[1] = null;

            var point = {
                x: ((parseFloat(item[0]) - this.minxval) * this.xscale),
                y: 1.0 - ((parseFloat(item[1]) - this.minyval) * this.yscale),
                xval: parseFloat(item[0]),
                yval: parseFloat(item[1]),
                name: setName
            };

            // limit the x, y values so they do not overdraw
            if (point.y <= 0.0) {
                point.y = 0.0;
            }
            if (point.y >= 1.0) {
                point.y = 1.0;
            }
            if ((point.x >= 0.0) && (point.x <= 1.0)) {
                this.points.push(point);
            }
        }
        i++;
    }
};

// Create the pie charts
PlotKit.Layout.prototype._evaluatePieCharts = function() {
    var items = PlotKit.Base.items;
    var sum = MochiKit.Iter.sum;
    var getter = MochiKit.Base.itemgetter;

    var setCount = items(this.datasets).length;

    // we plot the y values of the first dataset
    var dataset = items(this.datasets)[0][1];
    var total = sum(PlotKit.Base.map(getter(1), dataset));

    this.slices = new Array();
    var currentAngle = 0.0;
    for (var i = 0; i < dataset.length; i++) {
        var fraction = dataset[i][1] / total;
		var startAngle = currentAngle * Math.PI * 2;
		var endAngle = (currentAngle + fraction) * Math.PI * 2;
			
        var slice = {fraction: fraction,
                     xval: dataset[i][0],
                     yval: dataset[i][1],
                     startAngle: startAngle,
                     endAngle: endAngle
        };
        if (dataset[i][1] != 0) {
            this.slices.push(slice);
        }
        currentAngle += fraction;
    }
};

PlotKit.Layout.prototype._evaluateLineTicksForXAxis = function() {
    var isNil = MochiKit.Base.isUndefinedOrNull;
    
    if (this.options.xTicks) {
        // we use use specified ticks with optional labels

        this.xticks = new Array();
        var makeTicks = function(tick) {
            var label = tick.label;
            if (isNil(label))
                label = tick.v.toString();
            var pos = this.xscale * (tick.v - this.minxval);
            if ((pos >= 0.0) && (pos <= 1.0)) {
                this.xticks.push([pos, label]);
            }
        };
        MochiKit.Iter.forEach(this.options.xTicks, bind(makeTicks, this));
    }
    else if (this.options.xNumberOfTicks) {
        // we use defined number of ticks as hint to auto generate
        var xvalues = this._uniqueXValues();
        var roughSeparation = this.xrange / this.options.xNumberOfTicks;
        var tickCount = 0;

        this.xticks = new Array();
        for (var i = 0; i <= xvalues.length; i++) {
            if ((xvalues[i] - this.minxval) >= (tickCount * roughSeparation)) {
                var pos = this.xscale * (xvalues[i] - this.minxval);
                if ((pos > 1.0) || (pos < 0.0))
                    continue;
                this.xticks.push([pos, xvalues[i]]);
                tickCount++;
            }
            if (tickCount > this.options.xNumberOfTicks)
                break;
        }
    }
};

PlotKit.Layout.prototype._evaluateLineTicksForYAxis = function() {
    var isNil = MochiKit.Base.isUndefinedOrNull;

    if (this.options.yTicks) {
        this.yticks = new Array();
        var makeTicks = function(tick) {
            var label = tick.label;
            if (isNil(label))
                label = tick.v.toString();
            var pos = 1.0 - (this.yscale * (tick.v - this.minyval));
            if ((pos >= 0.0) && (pos <= 1.0)) {
                this.yticks.push([pos, label]);
            }
        };
        MochiKit.Iter.forEach(this.options.yTicks, bind(makeTicks, this));
    }
    else if (this.options.yNumberOfTicks) {
        // We use the optionally defined number of ticks as a guide        
        this.yticks = new Array();

        // if we get this separation right, we'll have good looking graphs
        var roundInt = PlotKit.Base.roundInterval;
        var prec = this.options.yTickPrecision;
        var roughSeparation = roundInt(this.yrange, this.options.yNumberOfTicks, prec);
        var roughOffset = 0;
        for (var i = 0; i <= this.options.yNumberOfTicks; i++){
            var yval = this.minyval + (i * roughSeparation);
            if(yval == 0){
            	break;
            }else if((yval>0 && yval - (roughSeparation/2) <= 0) || (yval<0 && yval + (roughSeparation/2) >= 0)){
            	roughOffset = yval;
            	break;
            }
        }
        // round off each value of the y-axis to the precision
        // eg. 1.3333 at precision 1 -> 1.3
        for (var i = 0; i <= this.options.yNumberOfTicks; i++) {
            var yval = this.minyval + (i * roughSeparation) - roughOffset;
            var pos = 1.0 - ((yval - this.minyval) * this.yscale);
            if ((pos > 1.0) || (pos < 0.0))
                continue;
            this.yticks.push([pos, MochiKit.Format.roundToFixed(yval, prec)]);
        }
    }
};

PlotKit.Layout.prototype._evaluateLineTicks = function() {
    this._evaluateLineTicksForXAxis();
    this._evaluateLineTicksForYAxis();
};

PlotKit.Layout.prototype._evaluateBarTicks = function() {
    this._evaluateLineTicks();
    var centerInBar = function(tick) {
        return [tick[0] + (this.minxdelta * this.xscale)/2, tick[1]];
    };
    this.xticks = MochiKit.Base.map(bind(centerInBar, this), this.xticks);
    
    if (this.options.barOrientation == "horizontal") {
        // swap scales
        var tempticks = this.xticks;
        this.xticks = this.yticks;
        this.yticks = tempticks;

        // we need to invert the "yaxis" (which is now the xaxis when drawn)
        var invert = function(tick) {
            return [1.0 - tick[0], tick[1]];
        }
        this.xticks = MochiKit.Base.map(invert, this.xticks);
    }
};

PlotKit.Layout.prototype._evaluatePieTicks = function() {
    var isNil = MochiKit.Base.isUndefinedOrNull;
	var formatter = MochiKit.Format.numberFormatter("#%");

    this.xticks = new Array();
	if (this.options.xTicks) {
		// make a lookup dict for x->slice values
		var lookup = new Array();
		for (var i = 0; i < this.slices.length; i++) {
			lookup[this.slices[i].xval] = this.slices[i];
		}
		
		for (var i =0; i < this.options.xTicks.length; i++) {
			var tick = this.options.xTicks[i];
			var slice = lookup[tick.v]; 
            var label = tick.label;
			if (slice) {
                if (isNil(label))
                    label = tick.v.toString();
				label += " (" + formatter(slice.fraction) + ")";
				this.xticks.push([tick.v, label]);
			}
		}
	}
	else {
		// we make our own labels from all the slices
		for (var i =0; i < this.slices.length; i++) {
			var slice = this.slices[i];
			var label = slice.xval + " (" + formatter(slice.fraction) + ")";
			this.xticks.push([slice.xval, label]);
		}
	}
};

PlotKit.Layout.prototype._regenerateHitTestCache = function() {
    this.hitTestCache.xvalues = this._uniqueXValues();
    this.hitTestCache.xlookup = new Array();
    this.hitTestCache.x2maxy = new Array();

    var listMax = MochiKit.Base.listMax;
    var itemgetter = MochiKit.Base.itemgetter;
    var map = MochiKit.Base.map;

    // generate a lookup table for x values to y values
    var setNames = keys(this.datasets);
    for (var i = 0; i < setNames.length; i++) {
        var dataset = this.datasets[setNames[i]];
        for (var j = 0; j < dataset.length; j++) {
            var xval = dataset[j][0];
            var yval = dataset[j][1];
            if (this.hitTestCache.xlookup[xval])
                this.hitTestCache.xlookup[xval].push([yval, setNames[i]]);
            else 
                this.hitTestCache.xlookup[xval] = [[yval, setNames[i]]];
        }
    }

    for (var x in this.hitTestCache.xlookup) {
        var yvals = this.hitTestCache.xlookup[x];
        this.hitTestCache.x2maxy[x] = listMax(map(itemgetter(0), yvals));
    }


};

// --------------------------------------------------------------------
// END Internal Functions
// --------------------------------------------------------------------


// Namespace Iniitialisation

PlotKit.LayoutModule = {};
PlotKit.LayoutModule.Layout = PlotKit.Layout;

PlotKit.LayoutModule.EXPORT = [
    "Layout"
];

PlotKit.LayoutModule.EXPORT_OK = [];

PlotKit.LayoutModule.__new__ = function() {
    var m = MochiKit.Base;
    
    m.nameFunctions(this);
    
    this.EXPORT_TAGS = {
        ":common": this.EXPORT,
        ":all": m.concat(this.EXPORT, this.EXPORT_OK)
    };
};

PlotKit.LayoutModule.__new__();
MochiKit.Base._exportSymbols(this, PlotKit.LayoutModule);



//
// This code is released to the public domain by Jim Studt, 2007.
// He may keep some sort of up to date copy at http://www.federated.com/~jim/canvastext/
//
var CanvasTextFunctions = { };

CanvasTextFunctions.letters = {
    ' ': { width: 16, points: [] },
    '!': { width: 10, points: [[5,21],[5,7],[-1,-1],[5,2],[4,1],[5,0],[6,1],[5,2]] },
    '"': { width: 16, points: [[4,21],[4,14],[-1,-1],[12,21],[12,14]] },
    '#': { width: 21, points: [[11,25],[4,-7],[-1,-1],[17,25],[10,-7],[-1,-1],[4,12],[18,12],[-1,-1],[3,6],[17,6]] },
    '$': { width: 20, points: [[8,25],[8,-4],[-1,-1],[12,25],[12,-4],[-1,-1],[17,18],[15,20],[12,21],[8,21],[5,20],[3,18],[3,16],[4,14],[5,13],[7,12],[13,10],[15,9],[16,8],[17,6],[17,3],[15,1],[12,0],[8,0],[5,1],[3,3]] },
    '%': { width: 24, points: [[21,21],[3,0],[-1,-1],[8,21],[10,19],[10,17],[9,15],[7,14],[5,14],[3,16],[3,18],[4,20],[6,21],[8,21],[10,20],[13,19],[16,19],[19,20],[21,21],[-1,-1],[17,7],[15,6],[14,4],[14,2],[16,0],[18,0],[20,1],[21,3],[21,5],[19,7],[17,7]] },
    '&': { width: 26, points: [[23,12],[23,13],[22,14],[21,14],[20,13],[19,11],[17,6],[15,3],[13,1],[11,0],[7,0],[5,1],[4,2],[3,4],[3,6],[4,8],[5,9],[12,13],[13,14],[14,16],[14,18],[13,20],[11,21],[9,20],[8,18],[8,16],[9,13],[11,10],[16,3],[18,1],[20,0],[22,0],[23,1],[23,2]] },
    '\'': { width: 10, points: [[5,19],[4,20],[5,21],[6,20],[6,18],[5,16],[4,15]] },
    '(': { width: 14, points: [[11,25],[9,23],[7,20],[5,16],[4,11],[4,7],[5,2],[7,-2],[9,-5],[11,-7]] },
    ')': { width: 14, points: [[3,25],[5,23],[7,20],[9,16],[10,11],[10,7],[9,2],[7,-2],[5,-5],[3,-7]] },
    '*': { width: 16, points: [[8,21],[8,9],[-1,-1],[3,18],[13,12],[-1,-1],[13,18],[3,12]] },
    '+': { width: 26, points: [[13,18],[13,0],[-1,-1],[4,9],[22,9]] },
    ',': { width: 10, points: [[6,1],[5,0],[4,1],[5,2],[6,1],[6,-1],[5,-3],[4,-4]] },
    '-': { width: 26, points: [[4,9],[22,9]] },
    '.': { width: 10, points: [[5,2],[4,1],[5,0],[6,1],[5,2]] },
    '/': { width: 22, points: [[20,25],[2,-7]] },
    '0': { width: 20, points: [[9,21],[6,20],[4,17],[3,12],[3,9],[4,4],[6,1],[9,0],[11,0],[14,1],[16,4],[17,9],[17,12],[16,17],[14,20],[11,21],[9,21]] },
    '1': { width: 20, points: [[6,17],[8,18],[11,21],[11,0]] },
    '2': { width: 20, points: [[4,16],[4,17],[5,19],[6,20],[8,21],[12,21],[14,20],[15,19],[16,17],[16,15],[15,13],[13,10],[3,0],[17,0]] },
    '3': { width: 20, points: [[5,21],[16,21],[10,13],[13,13],[15,12],[16,11],[17,8],[17,6],[16,3],[14,1],[11,0],[8,0],[5,1],[4,2],[3,4]] },
    '4': { width: 20, points: [[13,21],[3,7],[18,7],[-1,-1],[13,21],[13,0]] },
    '5': { width: 20, points: [[15,21],[5,21],[4,12],[5,13],[8,14],[11,14],[14,13],[16,11],[17,8],[17,6],[16,3],[14,1],[11,0],[8,0],[5,1],[4,2],[3,4]] },
    '6': { width: 20, points: [[16,18],[15,20],[12,21],[10,21],[7,20],[5,17],[4,12],[4,7],[5,3],[7,1],[10,0],[11,0],[14,1],[16,3],[17,6],[17,7],[16,10],[14,12],[11,13],[10,13],[7,12],[5,10],[4,7]] },
    '7': { width: 20, points: [[17,21],[7,0],[-1,-1],[3,21],[17,21]] },
    '8': { width: 20, points: [[8,21],[5,20],[4,18],[4,16],[5,14],[7,13],[11,12],[14,11],[16,9],[17,7],[17,4],[16,2],[15,1],[12,0],[8,0],[5,1],[4,2],[3,4],[3,7],[4,9],[6,11],[9,12],[13,13],[15,14],[16,16],[16,18],[15,20],[12,21],[8,21]] },
    '9': { width: 20, points: [[16,14],[15,11],[13,9],[10,8],[9,8],[6,9],[4,11],[3,14],[3,15],[4,18],[6,20],[9,21],[10,21],[13,20],[15,18],[16,14],[16,9],[15,4],[13,1],[10,0],[8,0],[5,1],[4,3]] },
    ':': { width: 10, points: [[5,14],[4,13],[5,12],[6,13],[5,14],[-1,-1],[5,2],[4,1],[5,0],[6,1],[5,2]] },
    ';': { width: 10, points: [[5,14],[4,13],[5,12],[6,13],[5,14],[-1,-1],[6,1],[5,0],[4,1],[5,2],[6,1],[6,-1],[5,-3],[4,-4]] },
    '<': { width: 24, points: [[20,18],[4,9],[20,0]] },
    '=': { width: 26, points: [[4,12],[22,12],[-1,-1],[4,6],[22,6]] },
    '>': { width: 24, points: [[4,18],[20,9],[4,0]] },
    '?': { width: 18, points: [[3,16],[3,17],[4,19],[5,20],[7,21],[11,21],[13,20],[14,19],[15,17],[15,15],[14,13],[13,12],[9,10],[9,7],[-1,-1],[9,2],[8,1],[9,0],[10,1],[9,2]] },
    '@': { width: 27, points: [[18,13],[17,15],[15,16],[12,16],[10,15],[9,14],[8,11],[8,8],[9,6],[11,5],[14,5],[16,6],[17,8],[-1,-1],[12,16],[10,14],[9,11],[9,8],[10,6],[11,5],[-1,-1],[18,16],[17,8],[17,6],[19,5],[21,5],[23,7],[24,10],[24,12],[23,15],[22,17],[20,19],[18,20],[15,21],[12,21],[9,20],[7,19],[5,17],[4,15],[3,12],[3,9],[4,6],[5,4],[7,2],[9,1],[12,0],[15,0],[18,1],[20,2],[21,3],[-1,-1],[19,16],[18,8],[18,6],[19,5]] },
    'A': { width: 18, points: [[9,21],[1,0],[-1,-1],[9,21],[17,0],[-1,-1],[4,7],[14,7]] },
    'B': { width: 21, points: [[4,21],[4,0],[-1,-1],[4,21],[13,21],[16,20],[17,19],[18,17],[18,15],[17,13],[16,12],[13,11],[-1,-1],[4,11],[13,11],[16,10],[17,9],[18,7],[18,4],[17,2],[16,1],[13,0],[4,0]] },
    'C': { width: 21, points: [[18,16],[17,18],[15,20],[13,21],[9,21],[7,20],[5,18],[4,16],[3,13],[3,8],[4,5],[5,3],[7,1],[9,0],[13,0],[15,1],[17,3],[18,5]] },
    'D': { width: 21, points: [[4,21],[4,0],[-1,-1],[4,21],[11,21],[14,20],[16,18],[17,16],[18,13],[18,8],[17,5],[16,3],[14,1],[11,0],[4,0]] },
    'E': { width: 19, points: [[4,21],[4,0],[-1,-1],[4,21],[17,21],[-1,-1],[4,11],[12,11],[-1,-1],[4,0],[17,0]] },
    'F': { width: 18, points: [[4,21],[4,0],[-1,-1],[4,21],[17,21],[-1,-1],[4,11],[12,11]] },
    'G': { width: 21, points: [[18,16],[17,18],[15,20],[13,21],[9,21],[7,20],[5,18],[4,16],[3,13],[3,8],[4,5],[5,3],[7,1],[9,0],[13,0],[15,1],[17,3],[18,5],[18,8],[-1,-1],[13,8],[18,8]] },
    'H': { width: 22, points: [[4,21],[4,0],[-1,-1],[18,21],[18,0],[-1,-1],[4,11],[18,11]] },
    'I': { width: 8, points: [[4,21],[4,0]] },
    'J': { width: 16, points: [[12,21],[12,5],[11,2],[10,1],[8,0],[6,0],[4,1],[3,2],[2,5],[2,7]] },
    'K': { width: 21, points: [[4,21],[4,0],[-1,-1],[18,21],[4,7],[-1,-1],[9,12],[18,0]] },
    'L': { width: 17, points: [[4,21],[4,0],[-1,-1],[4,0],[16,0]] },
    'M': { width: 24, points: [[4,21],[4,0],[-1,-1],[4,21],[12,0],[-1,-1],[20,21],[12,0],[-1,-1],[20,21],[20,0]] },
    'N': { width: 22, points: [[4,21],[4,0],[-1,-1],[4,21],[18,0],[-1,-1],[18,21],[18,0]] },
    'O': { width: 22, points: [[9,21],[7,20],[5,18],[4,16],[3,13],[3,8],[4,5],[5,3],[7,1],[9,0],[13,0],[15,1],[17,3],[18,5],[19,8],[19,13],[18,16],[17,18],[15,20],[13,21],[9,21]] },
    'P': { width: 21, points: [[4,21],[4,0],[-1,-1],[4,21],[13,21],[16,20],[17,19],[18,17],[18,14],[17,12],[16,11],[13,10],[4,10]] },
    'Q': { width: 22, points: [[9,21],[7,20],[5,18],[4,16],[3,13],[3,8],[4,5],[5,3],[7,1],[9,0],[13,0],[15,1],[17,3],[18,5],[19,8],[19,13],[18,16],[17,18],[15,20],[13,21],[9,21],[-1,-1],[12,4],[18,-2]] },
    'R': { width: 21, points: [[4,21],[4,0],[-1,-1],[4,21],[13,21],[16,20],[17,19],[18,17],[18,15],[17,13],[16,12],[13,11],[4,11],[-1,-1],[11,11],[18,0]] },
    'S': { width: 20, points: [[17,18],[15,20],[12,21],[8,21],[5,20],[3,18],[3,16],[4,14],[5,13],[7,12],[13,10],[15,9],[16,8],[17,6],[17,3],[15,1],[12,0],[8,0],[5,1],[3,3]] },
    'T': { width: 16, points: [[8,21],[8,0],[-1,-1],[1,21],[15,21]] },
    'U': { width: 22, points: [[4,21],[4,6],[5,3],[7,1],[10,0],[12,0],[15,1],[17,3],[18,6],[18,21]] },
    'V': { width: 18, points: [[1,21],[9,0],[-1,-1],[17,21],[9,0]] },
    'W': { width: 24, points: [[2,21],[7,0],[-1,-1],[12,21],[7,0],[-1,-1],[12,21],[17,0],[-1,-1],[22,21],[17,0]] },
    'X': { width: 20, points: [[3,21],[17,0],[-1,-1],[17,21],[3,0]] },
    'Y': { width: 18, points: [[1,21],[9,11],[9,0],[-1,-1],[17,21],[9,11]] },
    'Z': { width: 20, points: [[17,21],[3,0],[-1,-1],[3,21],[17,21],[-1,-1],[3,0],[17,0]] },
    '[': { width: 14, points: [[4,25],[4,-7],[-1,-1],[5,25],[5,-7],[-1,-1],[4,25],[11,25],[-1,-1],[4,-7],[11,-7]] },
    '\\': { width: 14, points: [[0,21],[14,-3]] },
    ']': { width: 14, points: [[9,25],[9,-7],[-1,-1],[10,25],[10,-7],[-1,-1],[3,25],[10,25],[-1,-1],[3,-7],[10,-7]] },
    '^': { width: 16, points: [[6,15],[8,18],[10,15],[-1,-1],[3,12],[8,17],[13,12],[-1,-1],[8,17],[8,0]] },
    '_': { width: 16, points: [[0,-2],[16,-2]] },
    '`': { width: 10, points: [[6,21],[5,20],[4,18],[4,16],[5,15],[6,16],[5,17]] },
    'a': { width: 19, points: [[15,14],[15,0],[-1,-1],[15,11],[13,13],[11,14],[8,14],[6,13],[4,11],[3,8],[3,6],[4,3],[6,1],[8,0],[11,0],[13,1],[15,3]] },
    'b': { width: 19, points: [[4,21],[4,0],[-1,-1],[4,11],[6,13],[8,14],[11,14],[13,13],[15,11],[16,8],[16,6],[15,3],[13,1],[11,0],[8,0],[6,1],[4,3]] },
    'c': { width: 18, points: [[15,11],[13,13],[11,14],[8,14],[6,13],[4,11],[3,8],[3,6],[4,3],[6,1],[8,0],[11,0],[13,1],[15,3]] },
    'd': { width: 19, points: [[15,21],[15,0],[-1,-1],[15,11],[13,13],[11,14],[8,14],[6,13],[4,11],[3,8],[3,6],[4,3],[6,1],[8,0],[11,0],[13,1],[15,3]] },
    'e': { width: 18, points: [[3,8],[15,8],[15,10],[14,12],[13,13],[11,14],[8,14],[6,13],[4,11],[3,8],[3,6],[4,3],[6,1],[8,0],[11,0],[13,1],[15,3]] },
    'f': { width: 12, points: [[10,21],[8,21],[6,20],[5,17],[5,0],[-1,-1],[2,14],[9,14]] },
    'g': { width: 19, points: [[15,14],[15,-2],[14,-5],[13,-6],[11,-7],[8,-7],[6,-6],[-1,-1],[15,11],[13,13],[11,14],[8,14],[6,13],[4,11],[3,8],[3,6],[4,3],[6,1],[8,0],[11,0],[13,1],[15,3]] },
    'h': { width: 19, points: [[4,21],[4,0],[-1,-1],[4,10],[7,13],[9,14],[12,14],[14,13],[15,10],[15,0]] },
    'i': { width: 8, points: [[3,21],[4,20],[5,21],[4,22],[3,21],[-1,-1],[4,14],[4,0]] },
    'j': { width: 10, points: [[5,21],[6,20],[7,21],[6,22],[5,21],[-1,-1],[6,14],[6,-3],[5,-6],[3,-7],[1,-7]] },
    'k': { width: 17, points: [[4,21],[4,0],[-1,-1],[14,14],[4,4],[-1,-1],[8,8],[15,0]] },
    'l': { width: 8, points: [[4,21],[4,0]] },
    'm': { width: 30, points: [[4,14],[4,0],[-1,-1],[4,10],[7,13],[9,14],[12,14],[14,13],[15,10],[15,0],[-1,-1],[15,10],[18,13],[20,14],[23,14],[25,13],[26,10],[26,0]] },
    'n': { width: 19, points: [[4,14],[4,0],[-1,-1],[4,10],[7,13],[9,14],[12,14],[14,13],[15,10],[15,0]] },
    'o': { width: 19, points: [[8,14],[6,13],[4,11],[3,8],[3,6],[4,3],[6,1],[8,0],[11,0],[13,1],[15,3],[16,6],[16,8],[15,11],[13,13],[11,14],[8,14]] },
    'p': { width: 19, points: [[4,14],[4,-7],[-1,-1],[4,11],[6,13],[8,14],[11,14],[13,13],[15,11],[16,8],[16,6],[15,3],[13,1],[11,0],[8,0],[6,1],[4,3]] },
    'q': { width: 19, points: [[15,14],[15,-7],[-1,-1],[15,11],[13,13],[11,14],[8,14],[6,13],[4,11],[3,8],[3,6],[4,3],[6,1],[8,0],[11,0],[13,1],[15,3]] },
    'r': { width: 13, points: [[4,14],[4,0],[-1,-1],[4,8],[5,11],[7,13],[9,14],[12,14]] },
    's': { width: 17, points: [[14,11],[13,13],[10,14],[7,14],[4,13],[3,11],[4,9],[6,8],[11,7],[13,6],[14,4],[14,3],[13,1],[10,0],[7,0],[4,1],[3,3]] },
    't': { width: 12, points: [[5,21],[5,4],[6,1],[8,0],[10,0],[-1,-1],[2,14],[9,14]] },
    'u': { width: 19, points: [[4,14],[4,4],[5,1],[7,0],[10,0],[12,1],[15,4],[-1,-1],[15,14],[15,0]] },
    'v': { width: 16, points: [[2,14],[8,0],[-1,-1],[14,14],[8,0]] },
    'w': { width: 22, points: [[3,14],[7,0],[-1,-1],[11,14],[7,0],[-1,-1],[11,14],[15,0],[-1,-1],[19,14],[15,0]] },
    'x': { width: 17, points: [[3,14],[14,0],[-1,-1],[14,14],[3,0]] },
    'y': { width: 16, points: [[2,14],[8,0],[-1,-1],[14,14],[8,0],[6,-4],[4,-6],[2,-7],[1,-7]] },
    'z': { width: 17, points: [[14,14],[3,0],[-1,-1],[3,14],[14,14],[-1,-1],[3,0],[14,0]] },
    '{': { width: 14, points: [[9,25],[7,24],[6,23],[5,21],[5,19],[6,17],[7,16],[8,14],[8,12],[6,10],[-1,-1],[7,24],[6,22],[6,20],[7,18],[8,17],[9,15],[9,13],[8,11],[4,9],[8,7],[9,5],[9,3],[8,1],[7,0],[6,-2],[6,-4],[7,-6],[-1,-1],[6,8],[8,6],[8,4],[7,2],[6,1],[5,-1],[5,-3],[6,-5],[7,-6],[9,-7]] },
    '|': { width: 8, points: [[4,25],[4,-7]] },
    '}': { width: 14, points: [[5,25],[7,24],[8,23],[9,21],[9,19],[8,17],[7,16],[6,14],[6,12],[8,10],[-1,-1],[7,24],[8,22],[8,20],[7,18],[6,17],[5,15],[5,13],[6,11],[10,9],[6,7],[5,5],[5,3],[6,1],[7,0],[8,-2],[8,-4],[7,-6],[-1,-1],[8,8],[6,6],[6,4],[7,2],[8,1],[9,-1],[9,-3],[8,-5],[7,-6],[5,-7]] },
    '~': { width: 24, points: [[3,6],[3,8],[4,11],[6,12],[8,12],[10,11],[14,8],[16,7],[18,7],[20,8],[21,10],[-1,-1],[3,8],[4,10],[6,11],[8,11],[10,10],[14,7],[16,6],[18,6],[20,7],[21,10],[21,12]] }
};

CanvasTextFunctions.letter = function (ch)
{
    return CanvasTextFunctions.letters[ch];
}

CanvasTextFunctions.ascent = function( font, size)
{
    return size;
}

CanvasTextFunctions.descent = function( font, size)
{
    return 7.0*size/25.0;
}

CanvasTextFunctions.measure = function( font, size, str)
{
    var total = 0;
    var len = str.length;

    for ( i = 0; i < len; i++) {
	var c = CanvasTextFunctions.letter( str.charAt(i));
	if ( c) total += c.width * size / 25.0;
    }
    return total;
}

CanvasTextFunctions.draw = function(ctx,font,size,x,y,str)
{
    var total = 0;
    var len = str.length;
    var mag = size / 25.0;

    ctx.save();
    ctx.lineCap = "round";
    ctx.lineWidth = 2.0 * mag;

    for ( i = 0; i < len; i++) {
	var c = CanvasTextFunctions.letter( str.charAt(i));
	if ( !c) continue;

	ctx.beginPath();

	var penUp = 1;
	var needStroke = 0;
	for ( j = 0; j < c.points.length; j++) {
	    var a = c.points[j];
	    if ( a[0] == -1 && a[1] == -1) {
		penUp = 1;
		continue;
	    }
	    if ( penUp) {
		ctx.moveTo( x + a[0]*mag, y - a[1]*mag);
		penUp = false;
	    } else {
		ctx.lineTo( x + a[0]*mag, y - a[1]*mag);
	    }
	}
	ctx.stroke();
	x += c.width*mag;
    }
    ctx.restore();
    return total;
}

CanvasTextFunctions.enable = function( ctx)
{
    ctx.drawText = function(font,size,x,y,text) { return CanvasTextFunctions.draw( ctx, font,size,x,y,text); };
    ctx.measureText = function(font,size,text) { return CanvasTextFunctions.measure( font,size,text); };
    ctx.fontAscent = function(font,size) { return CanvasTextFunctions.ascent(font,size); }
    ctx.fontDescent = function(font,size) { return CanvasTextFunctions.descent(font,size); }

    ctx.drawTextRight = function(font,size,x,y,text) { 
	var w = CanvasTextFunctions.measure(font,size,text);
	return CanvasTextFunctions.draw( ctx, font,size,x-w,y,text); 
    };
    ctx.drawTextCenter = function(font,size,x,y,text) { 
	var w = CanvasTextFunctions.measure(font,size,text);
	return CanvasTextFunctions.draw( ctx, font,size,x-w/2,y,text); 
    };
}


/* 
    PlotKit Canvas
    ==============
    
    Provides HTML Canvas Renderer. This is supported under:
    
    - Safari 2.0
    - Mozilla Firefox 1.5
    - Opera 9.0 preview 2
    - IE 6 (via VML Emulation)
    
    It uses DIVs for labels.
    
    Copyright
    ---------
    Copyright 2005,2006 (c) Alastair Tse <alastair^liquidx.net>
    For use under the BSD license. <http://www.liquidx.net/plotkit>
    
*/
// --------------------------------------------------------------------
// Check required components
// --------------------------------------------------------------------

try {    
    if ((typeof(PlotKit.Base) == 'undefined') ||
        (typeof(PlotKit.Layout) == 'undefined'))
    {
        throw "";    
    }
} 
catch (e) {    
    throw "PlotKit.Layout depends on MochiKit.{Base,Color,DOM,Format} and PlotKit.{Base,Layout}"
}


// ------------------------------------------------------------------------
//  Defines the renderer class
// ------------------------------------------------------------------------

if (typeof(PlotKit.CanvasRenderer) == 'undefined') {
    PlotKit.CanvasRenderer = {};
}

PlotKit.CanvasRenderer.NAME = "PlotKit.CanvasRenderer";
PlotKit.CanvasRenderer.VERSION = PlotKit.VERSION;

PlotKit.CanvasRenderer.__repr__ = function() {
    return "[" + this.NAME + " " + this.VERSION + "]";
};

PlotKit.CanvasRenderer.toString = function() {
    return this.__repr__();
}

PlotKit.CanvasRenderer = function(element, layout, options) {
    if (arguments.length  > 0)
        this.__init__(element, layout, options);
};

PlotKit.CanvasRenderer.prototype.__init__ = function(element, layout, options) {
    var isNil = MochiKit.Base.isUndefinedOrNull;
    var Color = MochiKit.Color.Color;
    
    // default options
    this.options = {
        "drawBackground": true,
        "backgroundColor": Color.whiteColor(),
        "padding": {left: 30, right: 30, top: 5, bottom: 10},
        "colorScheme": PlotKit.Base.palette(PlotKit.Base.baseColors()[0]),
        "strokeColor": Color.whiteColor(),
        "strokeColorTransform": "asStrokeColor",
        "strokeWidth": 0.5,
        "shouldFill": true,
        "shouldStroke": true,
        "drawXAxis": true,
        "drawYAxis": true,
        "axisLineColor": Color.blackColor(),
        "axisLineWidth": 0.5,
        "axisTickSize": 3,
        "axisLabelColor": Color.blackColor(),
        "axisLabelFont": "Arial",
        "axisLabelFontSize": 9,
		"axisLabelWidth": 65,
		"pieRadius": 0.4,
        "enableEvents": true
    };
    MochiKit.Base.update(this.options, options ? options : {});

    this.layout = layout;
    this.element = MochiKit.DOM.getElement(element);
    this.container = this.element.parentNode;

    // Stuff relating to Canvas on IE support    
    this.isIE = PlotKit.Base.excanvasSupported();

    if (this.isIE && !isNil(G_vmlCanvasManager)) {
        this.IEDelay = 0.5;
        this.maxTries = 5;
        this.renderDelay = null;
        this.clearDelay = null;
        this.element = G_vmlCanvasManager.initElement(this.element);
    }

    this.height = this.element.height;
    this.width = this.element.width;

    // --- check whether everything is ok before we return

    if (isNil(this.element))
        throw "CanvasRenderer() - passed canvas is not found";

    if (!this.isIE && !(PlotKit.CanvasRenderer.isSupported(this.element)))
        throw "CanvasRenderer() - Canvas is not supported.";

    if (isNil(this.container) || (this.container.nodeName.toLowerCase() != "div"))
        throw "CanvasRenderer() - <canvas> needs to be enclosed in <div>";

    // internal state
    this.xlabels = new Array();
    this.ylabels = new Array();
    this.isFirstRender = true;

    this.area = {
        x: this.options.padding.left,
        y: this.options.padding.top,
        w: this.width - this.options.padding.left - this.options.padding.right,
        h: this.height - this.options.padding.top - this.options.padding.bottom
    };

    MochiKit.DOM.updateNodeAttributes(this.container, 
    {"style":{ "position": "relative", "width": this.width + "px"}});

    // load event system if we have Signals
    /* Disabled until we have a proper implementation
    try {
        this.event_isinside = null;
        if (MochiKit.Signal && this.options.enableEvents) {
            this._initialiseEvents();
        }
    }
    catch (e) {
        // still experimental
    }
    */
};

PlotKit.CanvasRenderer.prototype.render = function() {
    if (this.isIE) {
        // VML takes a while to start up, so we just poll every this.IEDelay
        try {
            if (this.renderDelay) {
                this.renderDelay.cancel();
                this.renderDelay = null;
            }
            var context = this.element.getContext("2d");
        }
        catch (e) {
            this.isFirstRender = false;
            if (this.maxTries-- > 0) {
                this.renderDelay = MochiKit.Async.wait(this.IEDelay);
                this.renderDelay.addCallback(bind(this.render, this));
            }
            return;
        }
    }

    if (this.options.drawBackground)
        this._renderBackground();

    if (this.layout.style == "bar") {
        this._renderBarChart();
		this._renderBarAxis(); 
	}
    else if (this.layout.style == "pie") {
        this._renderPieChart();
		this._renderPieAxis();
	}
    else if (this.layout.style == "line") {
        this._renderLineChart();
		this._renderLineAxis();
	}
};

PlotKit.CanvasRenderer.prototype._renderBarChartWrap = function(data, plotFunc) {
    var context = this.element.getContext("2d");
    var colorCount = this.options.colorScheme.length;
    var colorScheme = this.options.colorScheme;
    var setNames = MochiKit.Base.keys(this.layout.datasets);
    var setCount = setNames.length;

    for (var i = 0; i < setCount; i++) {
        var setName = setNames[i];
        var color = colorScheme[i%colorCount];
        context.save();
        context.fillStyle = color.toRGBString();
        if (this.options.strokeColor)
            context.strokeStyle = this.options.strokeColor.toRGBString();
        else if (this.options.strokeColorTransform) 
            context.strokeStyle = color[this.options.strokeColorTransform]().toRGBString();
        
        context.lineWidth = this.options.strokeWidth;
        var forEachFunc = function(obj) {
            if (obj.name == setName)
                plotFunc(context, obj);
        };                

        MochiKit.Iter.forEach(data, bind(forEachFunc, this));
        context.restore();
    }
};

PlotKit.CanvasRenderer.prototype._renderBarChart = function() {
    var bind = MochiKit.Base.bind;

    var drawRect = function(context, bar) {
        var x = this.area.w * bar.x + this.area.x;
        var y = this.area.h * bar.y + this.area.y;
        var w = this.area.w * bar.w;
        var h = this.area.h * bar.h;       
        if ((w < 1) || (h < 1))
            return;
        if (this.options.shouldFill)
            context.fillRect(x, y, w, h);
        if (this.options.shouldStroke)
            context.strokeRect(x, y, w, h);                
    };
    this._renderBarChartWrap(this.layout.bars, bind(drawRect, this));
};

PlotKit.CanvasRenderer.prototype._renderLineChart = function() {
    var context = this.element.getContext("2d");
    var colorCount = this.options.colorScheme.length;
    var colorScheme = this.options.colorScheme;
    var setNames = MochiKit.Base.keys(this.layout.datasets);
    var setCount = setNames.length;
    var bind = MochiKit.Base.bind;
    var partial = MochiKit.Base.partial;

    for (var i = 0; i < setCount; i++) {
        var setName = setNames[i];
        var color = colorScheme[i%colorCount];
        var strokeX = this.options.strokeColorTransform;

        // setup graphics context
        context.save();
        context.fillStyle = color.toRGBString();
        if (this.options.strokeColor)
            context.strokeStyle = this.options.strokeColor.toRGBString();
        else if (this.options.strokeColorTransform) 
            context.strokeStyle = color[strokeX]().toRGBString();
        
        context.lineWidth = this.options.strokeWidth;
        
        // create paths
        var makePath = function(ctx) {
            ctx.beginPath();
            ctx.moveTo(this.area.x, this.area.y + this.area.h);
            var addPoint = function(ctx_, point) {
                if (point.name == setName)
                    ctx_.lineTo(this.area.w * point.x + this.area.x,
                                this.area.h * point.y + this.area.y);
            };
            MochiKit.Iter.forEach(this.layout.points, partial(addPoint, ctx), this);
            ctx.lineTo(this.area.w + this.area.x,
                           this.area.h + this.area.y);
            ctx.lineTo(this.area.x, this.area.y + this.area.h);
            ctx.closePath();
        };

        if (this.options.shouldFill) {
            bind(makePath, this)(context);
            context.fill();
        }
        if (this.options.shouldStroke) {
            bind(makePath, this)(context);
            context.stroke();
        }

        context.restore();
    }
};

PlotKit.CanvasRenderer.prototype._renderPieChart = function() {
    var context = this.element.getContext("2d");
    var colorCount = this.options.colorScheme.length;
    var slices = this.layout.slices;

    var centerx = this.area.x + this.area.w * 0.5;
    var centery = this.area.y + this.area.h * 0.5;
    var radius = Math.min(this.area.w * this.options.pieRadius, 
                          this.area.h * this.options.pieRadius);

    if (this.isIE) {
        centerx = parseInt(centerx);
        centery = parseInt(centery);
        radius = parseInt(radius);
    }


	// NOTE NOTE!! Canvas Tag draws the circle clockwise from the y = 0, x = 1
	// so we have to subtract 90 degrees to make it start at y = 1, x = 0

    for (var i = 0; i < slices.length; i++) {
        var color = this.options.colorScheme[i%colorCount];
        context.save();
        context.fillStyle = color.toRGBString();

        var makePath = function() {
            context.beginPath();
            context.moveTo(centerx, centery);
            context.arc(centerx, centery, radius, 
                        slices[i].startAngle - Math.PI/2,
                        slices[i].endAngle - Math.PI/2,
                        false);
            context.lineTo(centerx, centery);
            context.closePath();
        };

        if (Math.abs(slices[i].startAngle - slices[i].endAngle) > 0.001) {
            if (this.options.shouldFill) {
                makePath();
                context.fill();
            }
            
            if (this.options.shouldStroke) {
                makePath();
                context.lineWidth = this.options.strokeWidth;
                if (this.options.strokeColor)
                    context.strokeStyle = this.options.strokeColor.toRGBString();
                else if (this.options.strokeColorTransform)
                    context.strokeStyle = color[this.options.strokeColorTransform]().toRGBString();
                context.stroke();
            }
        }
        context.restore();
    }
};

PlotKit.CanvasRenderer.prototype._renderBarAxis = function() {
	this._renderAxis();
}

PlotKit.CanvasRenderer.prototype._renderLineAxis = function() {
	this._renderAxis();
};


PlotKit.CanvasRenderer.prototype._renderAxis = function() {
    if (!this.options.drawXAxis && !this.options.drawYAxis)
        return;

    var context = this.element.getContext("2d");

    var labelStyle = {"style":
         {"position": "absolute",
          "fontSize": this.options.axisLabelFontSize + "px",
          "zIndex": 10,
          "color": this.options.axisLabelColor.toRGBString(),
          "width": this.options.axisLabelWidth + "px",
          "overflow": "hidden"
         }
    };

    // axis lines
    context.save();
    context.strokeStyle = this.options.axisLineColor.toRGBString();
    context.lineWidth = this.options.axisLineWidth;


    if (this.options.drawYAxis) {
        if (this.layout.yticks) {
            var drawTick = function(tick) {
                if (typeof(tick) == "function") return;
                var x = this.area.x;
                var y = this.area.y + tick[0] * this.area.h;
                context.beginPath();
                context.moveTo(x, y);
                context.lineTo(x - this.options.axisTickSize, y);
                context.closePath();
                context.stroke();

                var label = DIV(labelStyle, tick[1]);
                label.style.top = (y - this.options.axisLabelFontSize) + "px";
                label.style.left = (x - this.options.padding.left - this.options.axisTickSize) + "px";
                label.style.textAlign = "right";
                label.style.width = (this.options.padding.left - this.options.axisTickSize * 2) + "px";
                MochiKit.DOM.appendChildNodes(this.container, label);
                this.ylabels.push(label);
            };
            
            MochiKit.Iter.forEach(this.layout.yticks, bind(drawTick, this));
        }

        context.beginPath();
        context.moveTo(this.area.x, this.area.y);
        context.lineTo(this.area.x, this.area.y + this.area.h);
        context.closePath();
        context.stroke();
    }

    if (this.options.drawXAxis) {
        if (this.layout.xticks) {
            var drawTick = function(tick) {
                if (typeof(dataset) == "function") return;
                
                var x = this.area.x + tick[0] * this.area.w;
                var y = this.area.y + this.area.h;
                context.beginPath();
                context.moveTo(x, y);
                context.lineTo(x, y + this.options.axisTickSize);
                context.closePath();
                context.stroke();

                var label = DIV(labelStyle, tick[1]);
                label.style.top = (y + this.options.axisTickSize) + "px";
                label.style.left = (x - this.options.axisLabelWidth/2) + "px";
                label.style.textAlign = "center";
                label.style.width = this.options.axisLabelWidth + "px";
                MochiKit.DOM.appendChildNodes(this.container, label);
                this.xlabels.push(label);
            };
            
            MochiKit.Iter.forEach(this.layout.xticks, bind(drawTick, this));
        }

       	var yoffset = this.area.y + (this.layout.maxyval * this.layout.yscale * this.area.h);
        context.beginPath();
        context.moveTo(this.area.x, yoffset);
        context.lineTo(this.area.x + this.area.w, yoffset);
        context.closePath();
        context.stroke();
        context.beginPath();
        context.moveTo(this.area.x + this.area.w, this.area.y);
        context.lineTo(this.area.x + this.area.w, this.area.y + this.area.h);
        context.closePath();
        context.stroke();

    }

    context.restore();

};

PlotKit.CanvasRenderer.prototype._renderPieAxis = function() {
    if (!this.options.drawXAxis)
        return;

	if (this.layout.xticks) {
		// make a lookup dict for x->slice values
		var lookup = new Array();
		for (var i = 0; i < this.layout.slices.length; i++) {
			lookup[this.layout.slices[i].xval] = this.layout.slices[i];
		}
		
		var centerx = this.area.x + this.area.w * 0.5;
	    var centery = this.area.y + this.area.h * 0.5;
	    var radius = Math.min(this.area.w * this.options.pieRadius,
	                          this.area.h * this.options.pieRadius);
		var labelWidth = this.options.axisLabelWidth;
		
		for (var i = 0; i < this.layout.xticks.length; i++) {
			var slice = lookup[this.layout.xticks[i][0]];
			if (MochiKit.Base.isUndefinedOrNull(slice))
				continue;
				
				
			var angle = (slice.startAngle + slice.endAngle)/2;
			// normalize the angle
			var normalisedAngle = angle;
			if (normalisedAngle > Math.PI * 2)
				normalisedAngle = normalisedAngle - Math.PI * 2;
			else if (normalisedAngle < 0)
				normalisedAngle = normalisedAngle + Math.PI * 2;
				
			var labelx = centerx + Math.sin(normalisedAngle) * (radius + 10);
	        var labely = centery - Math.cos(normalisedAngle) * (radius + 10);

			var attrib = {"position": "absolute",
	                      "zIndex": 11,
	                      "width": labelWidth + "px",
	                      "fontSize": this.options.axisLabelFontSize + "px",
	                      "overflow": "hidden",
						  "color": this.options.axisLabelColor.toHexString()
						};

			if (normalisedAngle <= Math.PI * 0.5) {
	            // text on top and align left
	            attrib["textAlign"] = "left";
	            attrib["verticalAlign"] = "top";
	            attrib["left"] = labelx + "px";
	            attrib["top"] = (labely - this.options.axisLabelFontSize) + "px";
	        }
	        else if ((normalisedAngle > Math.PI * 0.5) && (normalisedAngle <= Math.PI)) {
	            // text on bottom and align left
	            attrib["textAlign"] = "left";
	            attrib["verticalAlign"] = "bottom";     
	            attrib["left"] = labelx + "px";
	            attrib["top"] = labely + "px";

	        }
	        else if ((normalisedAngle > Math.PI) && (normalisedAngle <= Math.PI*1.5)) {
	            // text on bottom and align right
	            attrib["textAlign"] = "right";
	            attrib["verticalAlign"] = "bottom"; 
	            attrib["left"] = (labelx  - labelWidth) + "px";
	            attrib["top"] = labely + "px";
	        }
	        else {
	            // text on top and align right
	            attrib["textAlign"] = "right";
	            attrib["verticalAlign"] = "bottom";  
	            attrib["left"] = (labelx  - labelWidth) + "px";
	            attrib["top"] = (labely - this.options.axisLabelFontSize) + "px";
	        }
	
			var label = DIV({'style': attrib}, this.layout.xticks[i][1]);
			this.xlabels.push(label);
			MochiKit.DOM.appendChildNodes(this.container, label);
	  }
		
	}
};

PlotKit.CanvasRenderer.prototype._renderBackground = function() {
    var context = this.element.getContext("2d");
    context.save();
    context.fillStyle = this.options.backgroundColor.toRGBString();
    context.fillRect(0, 0, this.width, this.height);
    context.restore();
};

PlotKit.CanvasRenderer.prototype.clear = function() {
    if (this.isIE) {
        // VML takes a while to start up, so we just poll every this.IEDelay
        try {
            if (this.clearDelay) {
                this.clearDelay.cancel();
                this.clearDelay = null;
            }
            var context = this.element.getContext("2d");
        }
        catch (e) {
            this.isFirstRender = false;
            this.clearDelay = MochiKit.Async.wait(this.IEDelay);
            this.clearDelay.addCallback(bind(this.clear, this));
            return;
        }
    }

    var context = this.element.getContext("2d");
    context.clearRect(0, 0, this.width, this.height);

    MochiKit.Iter.forEach(this.xlabels, MochiKit.DOM.removeElement);
    MochiKit.Iter.forEach(this.ylabels, MochiKit.DOM.removeElement);
    this.xlabels = new Array();
    this.ylabels = new Array();
};

// ----------------------------------------------------------------
//  Everything below here is experimental and undocumented.
// ----------------------------------------------------------------

PlotKit.CanvasRenderer.prototype._initialiseEvents = function() {
    var connect = MochiKit.Signal.connect;
    var bind = MochiKit.Base.bind;
    //MochiKit.Signal.registerSignals(this, ['onmouseover', 'onclick', 'onmouseout', 'onmousemove']);
    //connect(this.element, 'onmouseover', bind(this.onmouseover, this));
    //connect(this.element, 'onmouseout', bind(this.onmouseout, this));
    //connect(this.element, 'onmousemove', bind(this.onmousemove, this));
    connect(this.element, 'onclick', bind(this.onclick, this));
};

PlotKit.CanvasRenderer.prototype._resolveObject = function(e) {
    // does not work in firefox
	//var x = (e.event().offsetX - this.area.x) / this.area.w;
	//var y = (e.event().offsetY - this.area.y) / this.area.h;

    var x = (e.mouse().page.x - PlotKit.Base.findPosX(this.element) - this.area.x) / this.area.w;
    var y = (e.mouse().page.y - PlotKit.Base.findPosY(this.element) - this.area.y) / this.area.h;
	
    //log(x, y);

    var isHit = this.layout.hitTest(x, y);
    if (isHit)
        return isHit;
    return null;
};

PlotKit.CanvasRenderer.prototype._createEventObject = function(layoutObj, e) {
    if (layoutObj == null) {
        return null;
    }

    e.chart = layoutObj
    return e;
};


PlotKit.CanvasRenderer.prototype.onclick = function(e) {
    var layoutObject = this._resolveObject(e);
    var eventObject = this._createEventObject(layoutObject, e);
    if (eventObject != null)
        MochiKit.Signal.signal(this, "onclick", eventObject);
};

PlotKit.CanvasRenderer.prototype.onmouseover = function(e) {
    var layoutObject = this._resolveObject(e);
    var eventObject = this._createEventObject(layoutObject, e);
    if (eventObject != null) 
        signal(this, "onmouseover", eventObject);
};

PlotKit.CanvasRenderer.prototype.onmouseout = function(e) {
    var layoutObject = this._resolveObject(e);
    var eventObject = this._createEventObject(layoutObject, e);
    if (eventObject == null)
        signal(this, "onmouseout", e);
    else 
        signal(this, "onmouseout", eventObject);

};

PlotKit.CanvasRenderer.prototype.onmousemove = function(e) {
    var layoutObject = this._resolveObject(e);
    var eventObject = this._createEventObject(layoutObject, e);

    if ((layoutObject == null) && (this.event_isinside == null)) {
        // TODO: should we emit an event anyway?
        return;
    }

    if ((layoutObject != null) && (this.event_isinside == null))
        signal(this, "onmouseover", eventObject);

    if ((layoutObject == null) && (this.event_isinside != null))
        signal(this, "onmouseout", eventObject);

    if ((layoutObject != null) && (this.event_isinside != null))
        signal(this, "onmousemove", eventObject);

    this.event_isinside = layoutObject;
    //log("move", x, y);    
};

PlotKit.CanvasRenderer.isSupported = function(canvasName) {
    var canvas = null;
    try {
        if (MochiKit.Base.isUndefinedOrNull(canvasName)) 
            canvas = MochiKit.DOM.CANVAS({});
        else
            canvas = MochiKit.DOM.getElement(canvasName);
        var context = canvas.getContext("2d");
    }
    catch (e) {
        var ie = navigator.appVersion.match(/MSIE (\d\.\d)/);
        var opera = (navigator.userAgent.toLowerCase().indexOf("opera") != -1);
        if ((!ie) || (ie[1] < 6) || (opera))
            return false;
        return true;
    }
    return true;
};

// Namespace Iniitialisation

PlotKit.Canvas = {}
PlotKit.Canvas.CanvasRenderer = PlotKit.CanvasRenderer;

PlotKit.Canvas.EXPORT = [
    "CanvasRenderer"
];

PlotKit.Canvas.EXPORT_OK = [
    "CanvasRenderer"
];

PlotKit.Canvas.__new__ = function() {
    var m = MochiKit.Base;
    
    m.nameFunctions(this);
    
    this.EXPORT_TAGS = {
        ":common": this.EXPORT,
        ":all": m.concat(this.EXPORT, this.EXPORT_OK)
    };
};

PlotKit.Canvas.__new__();
MochiKit.Base._exportSymbols(this, PlotKit.Canvas);


/*
    PlotKit Sweet Canvas Renderer
    =============================
    Canvas Renderer for PlotKit which looks pretty!

    Copyright
    ---------
    Copyright 2005,2006 (c) Alastair Tse <alastair^liquidx.net>
    For use under the BSD license. <http://www.liquidx.net/plotkit>
*/

// -------------------------------------------------------------------------
// Check required components
// -------------------------------------------------------------------------

try {    
    if (typeof(PlotKit.CanvasRenderer) == 'undefined')
    {
        throw "";    
    }
} 
catch (e) {    
    throw "SweetCanvas depends on MochiKit.{Base,Color,DOM,Format} and PlotKit.{Layout, Canvas}"
}


if (typeof(PlotKit.SweetCanvasRenderer) == 'undefined') {
    PlotKit.SweetCanvasRenderer = {};
}

PlotKit.SweetCanvasRenderer = function(element, layout, options) {
    if (arguments.length > 0) {
        this.__init__(element, layout, options);
    }
};

PlotKit.SweetCanvasRenderer.NAME = "PlotKit.SweetCanvasRenderer";
PlotKit.SweetCanvasRenderer.VERSION = PlotKit.VERSION;

PlotKit.SweetCanvasRenderer.__repr__ = function() {
    return "[" + this.NAME + " " + this.VERSION + "]";
};

PlotKit.SweetCanvasRenderer.toString = function() {
    return this.__repr__();
};

// ---------------------------------------------------------------------
// Subclassing Magic
// ---------------------------------------------------------------------

PlotKit.SweetCanvasRenderer.prototype = new PlotKit.CanvasRenderer();
PlotKit.SweetCanvasRenderer.prototype.constructor = PlotKit.SweetCanvasRenderer;
PlotKit.SweetCanvasRenderer.__super__ = PlotKit.CanvasRenderer.prototype;

// ---------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------

PlotKit.SweetCanvasRenderer.prototype.__init__ = function(el, layout, opts) { 
    var moreOpts = PlotKit.Base.officeBlue();
    MochiKit.Base.update(moreOpts, opts);
    PlotKit.SweetCanvasRenderer.__super__.__init__.call(this, el, layout, moreOpts);
};

// ---------------------------------------------------------------------
// Extended Plotting Functions
// ---------------------------------------------------------------------

PlotKit.SweetCanvasRenderer.prototype._renderBarChart = function() {
    var bind = MochiKit.Base.bind;
    var shadowColor = Color.blackColor().colorWithAlpha(0.1).toRGBString();

    var prepareFakeShadow = function(context, x, y, w, h) {
        context.fillStyle = shadowColor;
        context.fillRect(x-2, y-2, w+4, h+2); 
        context.fillStyle = shadowColor;
        context.fillRect(x-1, y-1, w+2, h+1); 
    };

    var colorCount = this.options.colorScheme.length;
    var colorScheme =  this.options.colorScheme;
    var setNames = PlotKit.Base.keys(this.layout.datasets);
    var setCount = setNames.length;

    var chooseColor = function(name) {
        for (var i = 0; i < setCount; i++) {
            if (name == setNames[i])
                return colorScheme[i%colorCount];
        }
        return colorScheme[0];
    };

    var drawRect = function(context, bar) {
        var x = this.area.w * bar.x + this.area.x;
        var y = this.area.h * bar.y + this.area.y;
        var w = this.area.w * bar.w;
        var h = this.area.h * bar.h;
        h = h || 0;

        if ((w < 1) || (h < 1))
            return;        

        context.save();

        context.shadowBlur = 5.0;
        context.shadowColor = Color.fromHexString("#888888").toRGBString();

        if (this.isIE) {
            context.save();
            context.fillStyle = "#cccccc";
            context.fillRect(x-2, y-2, w+4, h+2); 
            context.restore();
        }
        else {
            prepareFakeShadow(context, x, y, w, h);
        }

        if (this.options.shouldFill) {
            context.fillStyle = chooseColor(bar.name).toRGBString();
            context.fillRect(x, y, w, h);
        }

	if (this.options.displayValue) {
		CanvasTextFunctions.enable(context);
		var textFont = "sans";
		var textSize = 7;
		var textColor = "#333";
		var textValue = PWebUtil.formatNumber(bar.yval.toString());
		var textX = x + w*0.5 - context.measureText(textFont,textSize,textValue)*0.5
		var textY = y - 3;
		context.strokeStyle = Color.fromHexString(textColor).toRGBString();
		context.drawText(textFont,textSize,textX,textY,textValue);
	}

        context.shadowBlur = 0;
        context.strokeStyle = Color.whiteColor().toRGBString();
        context.lineWidth = 2.0;
        
        if (this.options.shouldStroke) {
            context.strokeRect(x, y, w, h);                
        }

        context.restore();

    };
    this._renderBarChartWrap(this.layout.bars, bind(drawRect, this));
};

PlotKit.SweetCanvasRenderer.prototype._renderLineChart = function() {
    var context = this.element.getContext("2d");
    var colorCount = this.options.colorScheme.length;
    var colorScheme = this.options.colorScheme;
    var setNames = PlotKit.Base.keys(this.layout.datasets);
    var setCount = setNames.length;
    var bind = MochiKit.Base.bind;


    for (var i = 0; i < setCount; i++) {
        var setName = setNames[i];
        var color = colorScheme[i%colorCount];
        var strokeX = this.options.strokeColorTransform;

        // setup graphics context
        context.save();
        
        // create paths
        var makePath = function(ctx) {
        	this.ctx_points = new Array();
        	ctx.beginPath();
            var addPoint = function(ctx_, point) {
	            if (point.name == setName && !isNaN(point.y) && !isNaN(point.x)){
	            	this.ctx_points.push(new Array(this.area.w * point.x + this.area.x, this.area.h * point.y + this.area.y));
	            	if(this.ctx_points.length == 1)
	            		ctx_.moveTo(this.area.w * point.x + this.area.x, this.area.h * point.y + this.area.y);
	            	else
	            		ctx_.lineTo(this.area.w * point.x + this.area.x, this.area.h * point.y + this.area.y);
	            }
            };
            MochiKit.Iter.forEach(this.layout.points, partial(addPoint, ctx), this);
            for(var j=this.ctx_points.length-2;j>=0;j--)
            	ctx.lineTo(this.ctx_points[j][0],this.ctx_points[j][1]);
            ctx.closePath();
        };

        // faux shadow for firefox
        if (this.options.shouldFill) {
            context.save();
            if (this.isIE) {
                context.fillStyle = "#cccccc";
            }
            else {
                context.fillStyle = Color.blackColor().colorWithAlpha(0.2).toRGBString();
            }
            context.translate(-1, -2);
            bind(makePath, this)(context);
            if (this.options.shouldFill) {
                context.fill();
            }
            context.restore();
        }

        context.shadowBlur = 5.0;
        context.shadowColor = Color.fromHexString("#888888").toRGBString();
        context.fillStyle = color.toRGBString();
        context.lineWidth = 2.0;
        context.strokeStyle = color.toRGBString();

        if (this.options.shouldFill) {
            bind(makePath, this)(context);
            context.fill();
        }
        if (this.options.shouldStroke) {
            bind(makePath, this)(context);
            context.stroke();
        }
        context.restore();
    }
};

PlotKit.SweetCanvasRenderer.prototype._renderPieChart = function() {
    var context = this.element.getContext("2d");

    var colorCount = this.options.colorScheme.length;
    var slices = this.layout.slices;

    var centerx = this.area.x + this.area.w * 0.5;
    var centery = this.area.y + this.area.h * 0.5;
    var radius = Math.min(this.area.w * this.options.pieRadius, 
                          this.area.h * this.options.pieRadius);

    if (this.isIE) {
        centerx = parseInt(centerx);
        centery = parseInt(centery);
        radius = parseInt(radius);
    }

	// NOTE NOTE!! Canvas Tag draws the circle clockwise from the y = 0, x = 1
	// so we have to subtract 90 degrees to make it start at y = 1, x = 0

    if (!this.isIE) {
        context.save();
        var shadowColor = Color.blackColor().colorWithAlpha(0.2);
        context.fillStyle = shadowColor.toRGBString();
        context.shadowBlur = 5.0;
        context.shadowColor = Color.fromHexString("#888888").toRGBString();
        context.translate(1, 1);
        context.beginPath();
        context.moveTo(centerx, centery);
        context.arc(centerx, centery, radius + 2, 0, Math.PI*2, false);
        context.closePath();
        context.fill();
        context.restore();
    }

    context.save();
    context.strokeStyle = Color.whiteColor().toRGBString();
    context.lineWidth = 2.0;    
    for (var i = 0; i < slices.length; i++) {
        var color = this.options.colorScheme[i%colorCount];
        context.fillStyle = color.toRGBString();

        var makePath = function() {
            context.beginPath();
            context.moveTo(centerx, centery);
            context.arc(centerx, centery, radius, 
                        slices[i].startAngle - Math.PI/2,
                        slices[i].endAngle - Math.PI/2,
                        false);
            context.lineTo(centerx, centery);
            context.closePath();
        };

        if (Math.abs(slices[i].startAngle - slices[i].endAngle) > 0.0001) {
            if (this.options.shouldFill) {
                makePath();
                context.fill();
            }
            if (this.options.shouldStroke) {
                makePath();
                context.stroke();
            }
        }
    }
    context.restore();
};

PlotKit.SweetCanvasRenderer.prototype._renderBackground = function() {
    var context = this.element.getContext("2d");
   
    if (this.layout.style == "bar" || this.layout.style == "line") {
        context.save();
        context.fillStyle = this.options.backgroundColor.toRGBString();
        context.fillRect(this.area.x, this.area.y, this.area.w, this.area.h);
        context.strokeStyle = this.options.backgroundLineColor.toRGBString();
        context.lineWidth = 1.0;
        
        var ticks = this.layout.yticks;
        var horiz = false;
        if (this.layout.style == "bar" && 
            this.layout.options.barOrientation == "horizontal") {
                ticks = this.layout.xticks;
                horiz = true;
        }
        
        for (var i = 0; i < ticks.length; i++) {
            var x1 = 0;
            var y1 = 0;
            var x2 = 0;
            var y2 = 0;
            
            if (horiz) {
                x1 = ticks[i][0] * this.area.w + this.area.x;
                y1 = this.area.y;
                x2 = x1;
                y2 = y1 + this.area.h;
            }
            else {
                x1 = this.area.x;
                y1 = ticks[i][0] * this.area.h + this.area.y;
                x2 = x1 + this.area.w;
                y2 = y1;
            }
            
            context.beginPath();
            context.moveTo(x1, y1);
            context.lineTo(x2, y2);
            context.closePath();
            context.stroke();
        }
        context.restore();
    }
    else {
        PlotKit.SweetCanvasRenderer.__super__._renderBackground.call(this);
    }
};

// Namespace Iniitialisation

PlotKit.SweetCanvas = {}
PlotKit.SweetCanvas.SweetCanvasRenderer = PlotKit.SweetCanvasRenderer;

PlotKit.SweetCanvas.EXPORT = [
    "SweetCanvasRenderer"
];

PlotKit.SweetCanvas.EXPORT_OK = [
    "SweetCanvasRenderer"
];

PlotKit.SweetCanvas.__new__ = function() {
    var m = MochiKit.Base;
    
    m.nameFunctions(this);
    
    this.EXPORT_TAGS = {
        ":common": this.EXPORT,
        ":all": m.concat(this.EXPORT, this.EXPORT_OK)
    };
};

PlotKit.SweetCanvas.__new__();
MochiKit.Base._exportSymbols(this, PlotKit.SweetCanvas);





/* Copyright (c) 2006 Yahoo! Inc. All rights reserved. */

/**
 * @class The Yahoo global namespace
 */
var YAHOO_PP = function() {

    return {

        /**
         * Yahoo presentation platform utils namespace
         */
        util: {},

        /**
         * Yahoo presentation platform widgets namespace
         */
        widget: {},

        /**
         * Yahoo presentation platform examples namespace
         */
        example: {},

        /**
         * Returns the namespace specified and creates it if it doesn't exist
         *
         * YAHOO_PP.namespace("property.package");
         * YAHOO_PP.namespace("YAHOO_PP.property.package");
         *
         * Either of the above would create YAHOO_PP.property, then
         * YAHOO_PP.property.package
         *
         * @param  {String} sNameSpace String representation of the desired 
         *                             namespace
         * @return {Object}            A reference to the namespace object
         */
        namespace: function( sNameSpace ) {

            if (!sNameSpace || !sNameSpace.length) {
                return null;
            }

            var levels = sNameSpace.split(".");

            var currentNS = YAHOO_PP;

            // YAHOO_PP is implied, so it is ignored if it is included
            for (var i=(levels[0] == "YAHOO_PP") ? 1 : 0; i<levels.length; ++i) {
                currentNS[levels[i]] = currentNS[levels[i]] || {};
                currentNS = currentNS[levels[i]];
            }

            return currentNS;

        }
    };

} ();


/* Copyright (c) 2006 Yahoo! Inc. All rights reserved. */YAHOO_PP.util.CustomEvent=function(_1,_2){this.type=_1;this.scope=_2||window;this.subscribers=[];if(YAHOO_PP.util["Event"]){YAHOO_PP.util.Event.regCE(this);}};YAHOO_PP.util.CustomEvent.prototype={subscribe:function(fn,_4,_5){this.subscribers.push(new YAHOO_PP.util.Subscriber(fn,_4,_5));},unsubscribe:function(fn,_6){var _7=false;for(var i=0;i<this.subscribers.length;++i){var s=this.subscribers[i];if(s&&s.contains(fn,_6)){this._delete(i);_7=true;}}return _7;},fire:function(){for(var i=0;i<this.subscribers.length;++i){var s=this.subscribers[i];if(s){var _10=(s.override)?s.obj:this.scope;s.fn.call(_10,this.type,arguments,s.obj);}}},unsubscribeAll:function(){for(var i=0;i<this.subscribers.length;++i){this._delete(i);}},_delete:function(_11){var s=this.subscribers[_11];if(s){delete s.fn;delete s.obj;}delete this.subscribers[_11];}};YAHOO_PP.util.Subscriber=function(fn,obj,_13){this.fn=fn;this.obj=obj||null;this.override=(_13);};YAHOO_PP.util.Subscriber.prototype.contains=function(fn,obj){return (this.fn==fn&&this.obj==obj);};if(!YAHOO_PP.util.Event){YAHOO_PP.util.Event=function(){var _14=false;var _15=[];var _16=[];var _17=[];var _18=[];var _19=[];var _20=[];return {EL:0,TYPE:1,FN:2,WFN:3,SCOPE:3,ADJ_SCOPE:4,isSafari:(navigator.userAgent.match(/safari/gi)),isIE:(!this.isSafari&&navigator.userAgent.match(/msie/gi)),addListener:function(el,_22,fn,_23,_24){if(this._isValidCollection(el)){var ok=true;for(var i=0;i<el.length;++i){ok=(this.on(el[i],_22,fn,_23,_24)&&ok);}return ok;}else{if(typeof el=="string"){if(_14){el=this.getEl(el);}else{_16[_16.length]=[el,_22,fn,_23,_24];return true;}}}if(!el){return false;}if("unload"==_22&&_23!==this){_17[_17.length]=[el,_22,fn,_23,_24];return true;}var _26=(_24)?_23:el;var _27=function(e){return fn.call(_26,YAHOO_PP.util.Event.getEvent(e),_23);};var li=[el,_22,fn,_27,_26];var _30=_15.length;_15[_30]=li;if(this.useLegacyEvent(el,_22)){var _31=this.getLegacyIndex(el,_22);if(_31==-1){_31=_19.length;_19[_31]=[el,_22,el["on"+_22]];_20[_31]=[];el["on"+_22]=function(e){YAHOO_PP.util.Event.fireLegacyEvent(YAHOO_PP.util.Event.getEvent(e),_31);};}_20[_31].push(_30);}else{if(el.addEventListener){el.addEventListener(_22,_27,false);}else{if(el.attachEvent){el.attachEvent("on"+_22,_27);}}}return true;},fireLegacyEvent:function(e,_32){var ok=true;var le=_20[_32];for(i=0;i<le.length;++i){var _34=le[i];if(_34){var li=_15[_34];var _35=li[this.ADJ_SCOPE];var ret=li[this.WFN].call(_35,e);ok=(ok&&ret);}}return ok;},getLegacyIndex:function(el,_37){for(var i=0;i<_19.length;++i){var le=_19[i];if(le&&le[0]==el&&le[1]==_37){return i;}}return -1;},useLegacyEvent:function(el,_38){return ((!el.addEventListener&&!el.attachEvent)||(_38=="click"&&this.isSafari));},removeListener:function(el,_39,fn){if(typeof el=="string"){el=this.getEl(el);}else{if(this._isValidCollection(el)){var ok=true;for(var i=0;i<el.length;++i){ok=(this.removeListener(el[i],_39,fn)&&ok);}return ok;}}var _40=null;var _41=this._getCacheIndex(el,_39,fn);if(_41>=0){_40=_15[_41];}if(!el||!_40){return false;}if(el.removeEventListener){el.removeEventListener(_39,_40[this.WFN],false);}else{if(el.detachEvent){el.detachEvent("on"+_39,_40[this.WFN]);}}delete _15[_41][this.WFN];delete _15[_41][this.FN];delete _15[_41];return true;},getTarget:function(ev,_43){var t=ev.target||ev.srcElement;if(_43&&t&&"#text"==t.nodeName){return t.parentNode;}else{return t;}},getPageX:function(ev){var x=ev.pageX;if(!x&&0!==x){x=ev.clientX||0;if(this.isIE){x+=this._getScrollLeft();}}return x;},getPageY:function(ev){var y=ev.pageY;if(!y&&0!==y){y=ev.clientY||0;if(this.isIE){y+=this._getScrollTop();}}return y;},getRelatedTarget:function(ev){var t=ev.relatedTarget;if(!t){if(ev.type=="mouseout"){t=ev.toElement;}else{if(ev.type=="mouseover"){t=ev.fromElement;}}}return t;},getTime:function(ev){if(!ev.time){var t=new Date().getTime();try{ev.time=t;}catch(e){return t;}}return ev.time;},stopEvent:function(ev){this.stopPropagation(ev);this.preventDefault(ev);},stopPropagation:function(ev){if(ev.stopPropagation){ev.stopPropagation();}else{ev.cancelBubble=true;}},preventDefault:function(ev){if(ev.preventDefault){ev.preventDefault();}else{ev.returnValue=false;}},getEvent:function(e){var ev=e||window.event;if(!ev){var c=this.getEvent.caller;while(c){ev=c.arguments[0];if(ev&&Event==ev.constructor){break;}c=c.caller;}}return ev;},getCharCode:function(ev){return ev.charCode||(ev.type=="keypress")?ev.keyCode:0;},_getCacheIndex:function(el,_48,fn){for(var i=0;i<_15.length;++i){var li=_15[i];if(li&&li[this.FN]==fn&&li[this.EL]==el&&li[this.TYPE]==_48){return i;}}return -1;},_isValidCollection:function(o){return (o&&o.length&&typeof o!="string"&&!o.tagName&&!o.alert&&typeof o[0]!="undefined");},elCache:{},getEl:function(id){return document.getElementById(id);},clearCache:function(){for(i in this.elCache){delete this.elCache[i];}},regCE:function(ce){_18.push(ce);},_load:function(e){_14=true;},_tryPreloadAttach:function(){var _52=!_14;for(var i=0;i<_16.length;++i){var d=_16[i];if(d){var el=this.getEl(d[this.EL]);if(el){this.on(el,d[this.TYPE],d[this.FN],d[this.SCOPE],d[this.ADJ_SCOPE]);delete _16[i];}}}if(_52){setTimeout("YAHOO_PP.util.Event._tryPreloadAttach()",50);}},_unload:function(e,me){for(var i=0;i<_17.length;++i){var l=_17[i];if(l){var _56=(l[this.ADJ_SCOPE])?l[this.SCOPE]:window;l[this.FN].call(_56,this.getEvent(e),l[this.SCOPE]);}}if(_15&&_15.length>0){for(i=0;i<_15.length;++i){l=_15[i];if(l){this.removeListener(l[this.EL],l[this.TYPE],l[this.FN]);}}this.clearCache();}for(i=0;i<_18.length;++i){_18[i].unsubscribeAll();delete _18[i];}for(i=0;i<_19.length;++i){delete _19[i][0];delete _19[i];}},_getScrollLeft:function(){return this._getScroll()[1];},_getScrollTop:function(){return this._getScroll()[0];},_getScroll:function(){var dd=document.documentElement;db=document.body;if(dd&&dd.scrollTop){return [dd.scrollTop,dd.scrollLeft];}else{if(db){return [db.scrollTop,db.scrollLeft];}else{return [0,0];}}}};}();YAHOO_PP.util.Event.on=YAHOO_PP.util.Event.addListener;if(document&&document.body){YAHOO_PP.util.Event._load();}else{YAHOO_PP.util.Event.on(window,"load",YAHOO_PP.util.Event._load,YAHOO_PP.util.Event,true);}YAHOO_PP.util.Event.on(window,"unload",YAHOO_PP.util.Event._unload,YAHOO_PP.util.Event,true);YAHOO_PP.util.Event._tryPreloadAttach();}
/* Copyright (c) 2006 Yahoo! Inc. All rights reserved. */
YAHOO_PP.util.Dom=new function(){this.get=function(el){if(typeof el=='string'){el=document.getElementById(el);}
return el;};this.getStyle=function(el,property){var value=null;var dv=document.defaultView;el=this.get(el);if(property=='opacity'&&el.filters){value=1;try{value=el.filters.item('DXImageTransform.Microsoft.Alpha').opacity/100;}catch(e){try{value=el.filters.item('alpha').opacity/100;}catch(e){}}}
else if(el.style[property]){value=el.style[property];}
else if(el.currentStyle&&el.currentStyle[property]){value=el.currentStyle[property];}
else if(dv&&dv.getComputedStyle)
{var converted='';for(i=0,len=property.length;i<len;++i){if(property.charAt(i)==property.charAt(i).toUpperCase()){converted=converted+'-'+property.charAt(i).toLowerCase();}else{converted=converted+property.charAt(i);}}
if(dv.getComputedStyle(el,'').getPropertyValue(converted)){value=dv.getComputedStyle(el,'').getPropertyValue(converted);}}
return value;};this.setStyle=function(el,property,val){el=this.get(el);switch(property){case'opacity':if(el.filters){el.style.filter='alpha(opacity='+val*100+')';if(!el.currentStyle.hasLayout){el.style.zoom=1;}}else{el.style.opacity=val;el.style['-moz-opacity']=val;el.style['-khtml-opacity']=val;}
break;default:el.style[property]=val;}};this.getXY=function(el){el=this.get(el);if(el.parentNode===null||this.getStyle(el,'display')=='none'){return false;}
var parent=null;var pos=[];var box;if(el.getBoundingClientRect){box=el.getBoundingClientRect();var scrollTop=document.documentElement.scrollTop||document.body.scrollTop;var scrollLeft=document.documentElement.scrollLeft||document.body.scrollLeft;return[box.left+scrollLeft,box.top+scrollTop];}
else if(document.getBoxObjectFor){box=document.getBoxObjectFor(el);pos=[box.x,box.y];}
else{pos=[el.offsetLeft,el.offsetTop];parent=el.offsetParent;if(parent!=el){while(parent){pos[0]+=parent.offsetLeft;pos[1]+=parent.offsetTop;parent=parent.offsetParent;}}
var ua=navigator.userAgent.toLowerCase();if(ua.indexOf('opera')!=-1||(ua.indexOf('safari')!=-1&&this.getStyle(el,'position')=='absolute')){pos[1]-=document.body.offsetTop;}}
if(el.parentNode){parent=el.parentNode;}
else{parent=null;}
while(parent&&parent.tagName!='BODY'&&parent.tagName!='HTML'){pos[0]-=parent.scrollLeft;pos[1]-=parent.scrollTop;if(parent.parentNode){parent=parent.parentNode;}
else{parent=null;}}
return pos;};this.getX=function(el){return this.getXY(el)[0];};this.getY=function(el){return this.getXY(el)[1];};this.setXY=function(el,pos,noRetry){el=this.get(el);var pageXY=YAHOO_PP.util.Dom.getXY(el);if(pageXY===false){return false;}
var delta=[parseInt(YAHOO_PP.util.Dom.getStyle(el,'left'),10),parseInt(YAHOO_PP.util.Dom.getStyle(el,'top'),10)];if(isNaN(delta[0])){delta[0]=0;}
if(isNaN(delta[1])){delta[1]=0;}
if(pos[0]!==null){el.style.left=pos[0]-pageXY[0]+delta[0]+'px';}
if(pos[1]!==null){el.style.top=pos[1]-pageXY[1]+delta[1]+'px';}
var newXY=this.getXY(el);if(!noRetry&&(newXY[0]!=pos[0]||newXY[1]!=pos[1])){this.setXY(el,pos,true);}
return true;};this.setX=function(el,x){return this.setXY(el,[x,null]);};this.setY=function(el,y){return this.setXY(el,[null,y]);};this.getRegion=function(el){el=this.get(el);return new YAHOO_PP.util.Region.getRegion(el);};this.getClientWidth=function(){return(document.documentElement.offsetWidth||document.body.offsetWidth);};this.getClientHeight=function(){return(self.innerHeight||document.documentElement.clientHeight||document.body.clientHeight);};};YAHOO_PP.util.Region=function(t,r,b,l){this.top=t;this.right=r;this.bottom=b;this.left=l;};YAHOO_PP.util.Region.prototype.contains=function(region){return(region.left>=this.left&&region.right<=this.right&&region.top>=this.top&&region.bottom<=this.bottom);};YAHOO_PP.util.Region.prototype.getArea=function(){return((this.bottom-this.top)*(this.right-this.left));};YAHOO_PP.util.Region.prototype.intersect=function(region){var t=Math.max(this.top,region.top);var r=Math.min(this.right,region.right);var b=Math.min(this.bottom,region.bottom);var l=Math.max(this.left,region.left);if(b>=t&&r>=l){return new YAHOO_PP.util.Region(t,r,b,l);}else{return null;}};YAHOO_PP.util.Region.prototype.union=function(region){var t=Math.min(this.top,region.top);var r=Math.max(this.right,region.right);var b=Math.max(this.bottom,region.bottom);var l=Math.min(this.left,region.left);return new YAHOO_PP.util.Region(t,r,b,l);};YAHOO_PP.util.Region.prototype.toString=function(){return("Region {"+"  t: "+this.top+", r: "+this.right+", b: "+this.bottom+", l: "+this.left+"}");}
YAHOO_PP.util.Region.getRegion=function(el){var p=YAHOO_PP.util.Dom.getXY(el);var t=p[1];var r=p[0]+el.offsetWidth;var b=p[1]+el.offsetHeight;var l=p[0];return new YAHOO_PP.util.Region(t,r,b,l);};YAHOO_PP.util.Point=function(x,y){this.x=x;this.y=y;this.top=y;this.right=x;this.bottom=y;this.left=x;};YAHOO_PP.util.Point.prototype=new YAHOO_PP.util.Region();
/* Copyright (c) 2006 Yahoo! Inc. All rights reserved. */YAHOO_PP.util.DragDrop=function(id,_2){if(id){this.init(id,_2);}};YAHOO_PP.util.DragDrop.prototype={id:null,dragElId:null,handleElId:null,invalidHandleTypes:null,startPageX:0,startPageY:0,groups:null,locked:false,lock:function(){this.locked=true;},unlock:function(){this.locked=false;},isTarget:true,padding:null,_domRef:null,__ygDragDrop:true,constrainX:false,constrainY:false,minX:0,maxX:0,minY:0,maxY:0,maintainOffset:false,xTicks:null,yTicks:null,primaryButtonOnly:true,b4StartDrag:function(x,y){},startDrag:function(x,y){},b4Drag:function(e){},onDrag:function(e){},onDragEnter:function(e,id){},b4DragOver:function(e){},onDragOver:function(e,id){},b4DragOut:function(e){},onDragOut:function(e,id){},b4DragDrop:function(e){},onDragDrop:function(e,id){},b4EndDrag:function(e){},endDrag:function(e){},b4MouseDown:function(e){},onMouseDown:function(e){},onMouseUp:function(e){},getEl:function(){if(!this._domRef){this._domRef=this.DDM.getElement(this.id);}return this._domRef;},getDragEl:function(){return this.DDM.getElement(this.dragElId);},init:function(id,_6){this.initTarget(id,_6);YAHOO_PP.util.Event.addListener(id,"mousedown",this.handleMouseDown,this,true);},initTarget:function(id,_7){this.DDM=YAHOO_PP.util.DDM;this.padding=[0,0,0,0];this.groups={};this.id=id;this.setDragElId(id);this.invalidHandleTypes={a:"a"};this.handleElId=id;if(document&&document.body){this.setInitPosition();}this.addToGroup((_7)?_7:"default");},setPadding:function(_8,_9,_10,_11){if(!_9&&0!==_9){this.padding=[_8,_8,_8,_8];}else{if(!_10&&0!==_10){this.padding=[_8,_9,_8,_9];}else{this.padding=[_8,_9,_10,_11];}}},setInitPosition:function(_12,_13){var el=this.getEl();if(!this.DDM.verifyEl(el)){return;}var dx=_12||0;var dy=_13||0;var p=YAHOO_PP.util.Dom.getXY(el);this.initPageX=p[0]-dx;this.initPageY=p[1]-dy;this.lastPageX=p[0];this.lastPageY=p[1];this.setStartPosition(p);},setStartPosition:function(pos){var p=pos||YAHOO_PP.util.Dom.getXY(this.getEl());this.startPageX=p[0];this.startPageY=p[1];},addToGroup:function(_19){this.groups[_19]=true;this.DDM.regDragDrop(this,_19);},setDragElId:function(id){this.dragElId=id;},setHandleElId:function(id){this.handleElId=id;this.DDM.regHandle(this.id,id);},setOuterHandleElId:function(id){YAHOO_PP.util.Event.addListener(id,"mousedown",this.handleMouseDown,this,true);this.setHandleElId(id);},unreg:function(){YAHOO_PP.util.Event.removeListener(this.id,"mousedown",this.handleMouseDown);this._domRef=null;this.DDM._remove(this);},isLocked:function(){return (this.DDM.isLocked()||this.locked);},handleMouseDown:function(e,oDD){var EU=YAHOO_PP.util.Event;var _22=e.which||e.button;if(this.primaryButtonOnly&&_22>1){return;}if(this.isLocked()){return;}this.DDM.refreshCache(this.groups);var pt=new YAHOO_PP.util.Point(EU.getPageX(e),EU.getPageY(e));if(this.DDM.isOverTarget(pt,this)){var _24=EU.getTarget(e);if(this.isValidHandleChild(_24)&&(this.id==this.handleElId||this.DDM.handleWasClicked(_24,this.id))){this.setStartPosition();this.b4MouseDown(e);this.onMouseDown(e);this.DDM.handleMouseDown(e,this);this.DDM.stopEvent(e);}}},addInvalidHandleType:function(_25){var _26=_25.toUpperCase();this.invalidHandleTypes[_26]=_26;},removeInvalidHandleType:function(_27){var _28=_27.toUpperCase();this.invalidHandleTypes[_28]=null;},isValidHandleChild:function(_29){var _30=_29.nodeName;if(_30=="#text"){_30=_29.parentNode.nodeName;}return (!this.invalidHandleTypes[_30]);},setXTicks:function(_31,_32){this.xTicks=[];this.xTickSize=_32;var _33={};for(var i=this.initPageX;i>=this.minX;i=i-_32){if(!_33[i]){this.xTicks[this.xTicks.length]=i;_33[i]=true;}}for(i=this.initPageX;i<=this.maxX;i=i+_32){if(!_33[i]){this.xTicks[this.xTicks.length]=i;_33[i]=true;}}this.xTicks.sort(this.DDM.numericSort);},setYTicks:function(_35,_36){this.yTicks=[];this.yTickSize=_36;var _37={};for(var i=this.initPageY;i>=this.minY;i=i-_36){if(!_37[i]){this.yTicks[this.yTicks.length]=i;_37[i]=true;}}for(i=this.initPageY;i<=this.maxY;i=i+_36){if(!_37[i]){this.yTicks[this.yTicks.length]=i;_37[i]=true;}}this.yTicks.sort(this.DDM.numericSort);},setXConstraint:function(_38,_39,_40){this.leftConstraint=_38;this.rightConstraint=_39;this.minX=this.initPageX-_38;this.maxX=this.initPageX+_39;if(_40){this.setXTicks(this.initPageX,_40);}this.constrainX=true;},setYConstraint:function(iUp,_42,_43){this.topConstraint=iUp;this.bottomConstraint=_42;this.minY=this.initPageY-iUp;this.maxY=this.initPageY+_42;if(_43){this.setYTicks(this.initPageY,_43);}this.constrainY=true;},resetConstraints:function(){var dx=(this.maintainOffset)?this.lastPageX-this.initPageX:0;var dy=(this.maintainOffset)?this.lastPageY-this.initPageY:0;this.setInitPosition(dx,dy);if(this.constrainX){this.setXConstraint(this.leftConstraint,this.rightConstraint,this.xTickSize);}if(this.constrainY){this.setYConstraint(this.topConstraint,this.bottomConstraint,this.yTickSize);}},getTick:function(val,_45){if(!_45){return val;}else{if(_45[0]>=val){return _45[0];}else{for(var i=0;i<_45.length;++i){var _46=i+1;if(_45[_46]&&_45[_46]>=val){var _47=val-_45[i];var _48=_45[_46]-val;return (_48>_47)?_45[i]:_45[_46];}}return _45[_45.length-1];}}},toString:function(val,_49){return ("YAHOO_PP.util.DragDrop {"+this.id+"}");}};if(!YAHOO_PP.util.DragDropMgr){YAHOO_PP.util.DragDropMgr=new function(){var _50=YAHOO_PP.util;this.ids={};this.handleIds={};this.dragCurrent=null;this.dragOvers={};this.deltaX=0;this.deltaY=0;this.preventDefault=true;this.stopPropagation=true;this.initalized=false;this.locked=false;this.init=function(){};this.POINT=0;this.INTERSECT=1;this.mode=this.POINT;this._execOnAll=function(_51,_52){for(var i in this.ids){for(var j in this.ids[i]){var oDD=this.ids[i][j];if(!this.isTypeOfDD(oDD)){continue;}oDD[_51].apply(oDD,_52);}}};this._onLoad=function(){this._execOnAll("setInitPosition",[]);var EU=_50.Event;EU.addListener(document,"mouseup",this.handleMouseUp,this,true);EU.addListener(document,"mousemove",this.handleMouseMove,this,true);EU.addListener(window,"unload",this._onUnload,this,true);EU.addListener(window,"resize",this._onResize,this,true);this.initalized=true;};this._onResize=function(e){this._execOnAll("resetConstraints",[]);};this.lock=function(){this.locked=true;};this.unlock=function(){this.locked=false;};this.isLocked=function(){return this.locked;};this.locationCache={};this.useCache=true;this.clickPixelThresh=3;this.clickTimeThresh=1000;this.dragThreshMet=false;this.clickTimeout=null;this.startX=0;this.startY=0;this.regDragDrop=function(oDD,_54){if(!this.initialized){this.init();}if(!this.ids[_54]){this.ids[_54]={};}this.ids[_54][oDD.id]=oDD;};this._remove=function(oDD){for(var g in oDD.groups){if(g&&this.ids[g][oDD.id]){delete this.ids[g][oDD.id];}}delete this.handleIds[oDD.id];};this.regHandle=function(_56,_57){if(!this.handleIds[_56]){this.handleIds[_56]={};}this.handleIds[_56][_57]=_57;};this.isDragDrop=function(id){return (this.getDDById(id))?true:false;};this.getRelated=function(_58,_59){var _60=[];for(var i in _58.groups){for(j in this.ids[i]){var dd=this.ids[i][j];if(!this.isTypeOfDD(dd)){continue;}if(!_59||dd.isTarget){_60[_60.length]=dd;}}}return _60;};this.isLegalTarget=function(oDD,_62){var _63=this.getRelated(oDD);for(var i=0;i<_63.length;++i){if(_63[i].id==_62.id){return true;}}return false;};this.isTypeOfDD=function(oDD){return (oDD&&oDD.__ygDragDrop);};this.isHandle=function(_64,_65){return (this.handleIds[_64]&&this.handleIds[_64][_65]);};this.getDDById=function(id){for(var i in this.ids){if(this.ids[i][id]){return this.ids[i][id];}}return null;};this.handleMouseDown=function(e,oDD){this.dragCurrent=oDD;var el=oDD.getEl();this.startX=_50.Event.getPageX(e);this.startY=_50.Event.getPageY(e);this.deltaX=this.startX-el.offsetLeft;this.deltaY=this.startY-el.offsetTop;this.dragThreshMet=false;this.clickTimeout=setTimeout("var DDM=YAHOO_PP.util.DDM;DDM.startDrag(DDM.startX, DDM.startY)",this.clickTimeThresh);};this.startDrag=function(x,y){clearTimeout(this.clickTimeout);if(this.dragCurrent){this.dragCurrent.b4StartDrag(x,y);this.dragCurrent.startDrag(x,y);}this.dragThreshMet=true;};this.handleMouseUp=function(e){if(!this.dragCurrent){return;}clearTimeout(this.clickTimeout);if(this.dragThreshMet){this.fireEvents(e,true);}else{}this.stopDrag(e);this.stopEvent(e);};this.stopEvent=function(e){if(this.stopPropagation){_50.Event.stopPropagation(e);}if(this.preventDefault){_50.Event.preventDefault(e);}};this.stopDrag=function(e){if(this.dragCurrent){if(this.dragThreshMet){this.dragCurrent.b4EndDrag(e);this.dragCurrent.endDrag(e);}this.dragCurrent.onMouseUp(e);}this.dragCurrent=null;this.dragOvers={};};this.handleMouseMove=function(e){if(!this.dragCurrent){return;}if(_50.Event.isIE&&!e.button){this.stopEvent(e);return this.handleMouseUp(e);}if(!this.dragThreshMet){var _66=Math.abs(this.startX-_50.Event.getPageX(e));var _67=Math.abs(this.startY-_50.Event.getPageY(e));if(_66>this.clickPixelThresh||_67>this.clickPixelThresh){this.startDrag(this.startX,this.startY);}}if(this.dragThreshMet){this.dragCurrent.b4Drag(e);this.dragCurrent.onDrag(e);this.fireEvents(e,false);}this.stopEvent(e);};this.fireEvents=function(e,_68){var dc=this.dragCurrent;if(!dc||dc.isLocked()){return;}var x=_50.Event.getPageX(e);var y=_50.Event.getPageY(e);var pt=new YAHOO_PP.util.Point(x,y);var _70=[];var _71=[];var _72=[];var _73=[];var _74=[];for(var i in this.dragOvers){var ddo=this.dragOvers[i];if(!this.isTypeOfDD(ddo)){continue;}if(!this.isOverTarget(pt,ddo,this.mode)){_71.push(ddo);}_70[i]=true;delete this.dragOvers[i];}for(var _76 in dc.groups){if("string"!=typeof _76){continue;}for(i in this.ids[_76]){var oDD=this.ids[_76][i];if(!this.isTypeOfDD(oDD)){continue;}if(oDD.isTarget&&!oDD.isLocked()&&oDD!=dc){if(this.isOverTarget(pt,oDD,this.mode)){if(_68){_73.push(oDD);}else{if(!_70[oDD.id]){_74.push(oDD);}else{_72.push(oDD);}this.dragOvers[oDD.id]=oDD;}}}}}if(this.mode){if(_71.length>0){dc.b4DragOut(e,_71);dc.onDragOut(e,_71);}if(_74.length>0){dc.onDragEnter(e,_74);}if(_72.length>0){dc.b4DragOver(e,_72);dc.onDragOver(e,_72);}if(_73.length>0){dc.b4DragDrop(e,_73);dc.onDragDrop(e,_73);}}else{for(i=0;i<_71.length;++i){dc.b4DragOut(e,_71[i].id);dc.onDragOut(e,_71[i].id);}for(i=0;i<_74.length;++i){dc.onDragEnter(e,_74[i].id);}for(i=0;i<_72.length;++i){dc.b4DragOver(e,_72[i].id);dc.onDragOver(e,_72[i].id);}for(i=0;i<_73.length;++i){dc.b4DragDrop(e,_73[i].id);dc.onDragDrop(e,_73[i].id);}}};this.getBestMatch=function(dds){var _78=null;if(dds.length==1){_78=dds[0];}else{for(var i=0;i<dds.length;++i){var dd=dds[i];if(dd.cursorIsOver){_78=dd;break;}else{if(!_78||_78.overlap.getArea()<dd.overlap.getArea()){_78=dd;}}}}return _78;};this.refreshCache=function(_79){for(sGroup in _79){if("string"!=typeof sGroup){continue;}for(i in this.ids[sGroup]){var oDD=this.ids[sGroup][i];if(this.isTypeOfDD(oDD)){var loc=this.getLocation(oDD);if(loc){this.locationCache[oDD.id]=loc;}else{delete this.locationCache[oDD.id];oDD.unreg();}}}}};this.verifyEl=function(el){try{if(el){var _81=el.offsetParent;if(_81){return true;}}}catch(e){}return false;};this.getLocation=function(oDD){if(!this.isTypeOfDD(oDD)){return null;}var el=oDD.getEl();if(!this.verifyEl(el)){return null;}var _82=YAHOO_PP.util.Dom.getXY(el);x1=_82[0];x2=x1+el.offsetWidth;y1=_82[1];y2=y1+el.offsetHeight;var t=y1-oDD.padding[0];var r=x2+oDD.padding[1];var b=y2+oDD.padding[2];var l=x1-oDD.padding[3];return new YAHOO_PP.util.Region(t,r,b,l);};this.isOverTarget=function(pt,_87,_88){var loc=this.locationCache[_87.id];if(!loc||!this.useCache){loc=this.getLocation(_87);this.locationCache[_87.id]=loc;}_87.cursorIsOver=loc.contains(pt);_87.overlap=null;if(_88){var _89=YAHOO_PP.util.Region.getRegion(this.dragCurrent.getDragEl());var _90=_89.intersect(loc);if(_90){_87.overlap=_90;return true;}else{return false;}}else{return _87.cursorIsOver;}};this._onUnload=function(e,me){this.unregAll();};this.unregAll=function(){if(this.dragCurrent){this.stopDrag();this.dragCurrent=null;}this._execOnAll("unreg",[]);for(i in this.elementCache){delete this.elementCache[i];}this.elementCache={};this.ids={};};this.elementCache={};this.getElWrapper=function(id){var _92=this.elementCache[id];if(!_92||!_92.el){_92=this.elementCache[id]=new this.ElementWrapper(document.getElementById(id));}return _92;};this.getElement=function(id){return document.getElementById(id);};this.getCss=function(id){var css=null;var el=document.getElementById(id);if(el){css=el.style;}return css;};this.ElementWrapper=function(el){this.el=el||null;this.id=this.el&&el.id;this.css=this.el&&el.style;};this.getPosX=function(el){return YAHOO_PP.util.Dom.getX(el);};this.getPosY=function(el){return YAHOO_PP.util.Dom.getY(el);};this.swapNode=function(n1,n2){if(n1.swapNode){n1.swapNode(n2);}else{var p=n2.parentNode;var s=n2.nextSibling;n1.parentNode.replaceChild(n2,n1);p.insertBefore(n1,s);}};this.getScroll=function(){var t,l;if(document.documentElement&&document.documentElement.scrollTop){t=document.documentElement.scrollTop;l=document.documentElement.scrollLeft;}else{if(document.body){t=document.body.scrollTop;l=document.body.scrollLeft;}}return {top:t,left:l};};this.getStyle=function(el,_97){if(el.style.styleProp){return el.style.styleProp;}else{if(el.currentStyle){return el.currentStyle[_97];}else{if(document.defaultView){return document.defaultView.getComputedStyle(el,null).getPropertyValue(_97);}}}};this.getScrollTop=function(){return this.getScroll().top;};this.getScrollLeft=function(){return this.getScroll().left;};this.moveToEl=function(_98,_99){var _100=YAHOO_PP.util.Dom.getXY(_99);YAHOO_PP.util.Dom.setXY(_98,_100);};this.getClientHeight=function(){return (window.innerHeight)?window.innerHeight:(document.documentElement&&document.documentElement.clientHeight)?document.documentElement.clientHeight:document.body.offsetHeight;};this.getClientWidth=function(){return (window.innerWidth)?window.innerWidth:(document.documentElement&&document.documentElement.clientWidth)?document.documentElement.clientWidth:document.body.offsetWidth;};this.numericSort=function(a,b){return (a-b);};this._timeoutCount=0;this._addListeners=function(){if(_50.Event&&document&&document.body){this._onLoad();}else{if(this._timeoutCount>500){}else{setTimeout("YAHOO_PP.util.DDM._addListeners()",10);this._timeoutCount+=1;}}};this.handleWasClicked=function(node,id){if(this.isHandle(id,node.id)){return true;}else{var p=node.parentNode;while(p){if(this.isHandle(id,p.id)){return true;}else{p=p.parentNode;}}}return false;};};YAHOO_PP.util.DDM=YAHOO_PP.util.DragDropMgr;YAHOO_PP.util.DDM._addListeners();}YAHOO_PP.util.DD=function(id,_103){if(id){this.init(id,_103);}};YAHOO_PP.util.DD.prototype=new YAHOO_PP.util.DragDrop();YAHOO_PP.util.DD.prototype.scroll=true;YAHOO_PP.util.DD.prototype.autoOffset=function(_104,_105){var el=this.getEl();var _106=YAHOO_PP.util.Dom.getXY(el);var x=_104-_106[0];var y=_105-_106[1];this.setDelta(x,y);};YAHOO_PP.util.DD.prototype.setDelta=function(_107,_108){this.deltaX=_107;this.deltaY=_108;};YAHOO_PP.util.DD.prototype.setDragElPos=function(_109,_110){var el=this.getDragEl();this.alignElWithMouse(el,_109,_110);};YAHOO_PP.util.DD.prototype.alignElWithMouse=function(el,_111,_112){var _113=this.getTargetCoord(_111,_112);var _114=[_113.x,_113.y];YAHOO_PP.util.Dom.setXY(el,_114);this.cachePosition(_113.x,_113.y);this.autoScroll(_113.x,_113.y,el.offsetHeight,el.offsetWidth);};YAHOO_PP.util.DD.prototype.cachePosition=function(_115,_116){if(_115){this.lastPageX=_115;this.lastPageY=_116;}else{var _117=YAHOO_PP.util.Dom.getXY(this.getEl());this.lastPageX=_117[0];this.lastPageY=_117[1];}};YAHOO_PP.util.DD.prototype.autoScroll=function(x,y,h,w){if(this.scroll){var _120=this.DDM.getClientHeight();var _121=this.DDM.getClientWidth();var st=this.DDM.getScrollTop();var sl=this.DDM.getScrollLeft();var bot=h+y;var _125=w+x;var _126=(_120+st-y-this.deltaY);var _127=(_121+sl-x-this.deltaX);var _128=40;var _129=(document.all)?80:30;if(bot>_120&&_126<_128){window.scrollTo(sl,st+_129);}if(y<st&&st>0&&y-st<_128){window.scrollTo(sl,st-_129);}if(_125>_121&&_127<_128){window.scrollTo(sl+_129,st);}if(x<sl&&sl>0&&x-sl<_128){window.scrollTo(sl-_129,st);}}};YAHOO_PP.util.DD.prototype.getTargetCoord=function(_130,_131){var x=_130-this.deltaX;var y=_131-this.deltaY;if(this.constrainX){if(x<this.minX){x=this.minX;}if(x>this.maxX){x=this.maxX;}}if(this.constrainY){if(y<this.minY){y=this.minY;}if(y>this.maxY){y=this.maxY;}}x=this.getTick(x,this.xTicks);y=this.getTick(y,this.yTicks);return {x:x,y:y};};YAHOO_PP.util.DD.prototype.b4MouseDown=function(e){this.autoOffset(YAHOO_PP.util.Event.getPageX(e),YAHOO_PP.util.Event.getPageY(e));};YAHOO_PP.util.DD.prototype.b4Drag=function(e){this.setDragElPos(YAHOO_PP.util.Event.getPageX(e),YAHOO_PP.util.Event.getPageY(e));};YAHOO_PP.util.DDProxy=function(id,_132){if(id){this.forceCssPosition=false;this.init(id,_132);this.initFrame();}};YAHOO_PP.util.DDProxy.prototype=new YAHOO_PP.util.DD();YAHOO_PP.util.DDProxy.frameDiv=null;YAHOO_PP.util.DDProxy.dragElId="ygddfdiv";YAHOO_PP.util.DDProxy.prototype.borderWidth=2;YAHOO_PP.util.DDProxy.prototype.resizeFrame=true;YAHOO_PP.util.DDProxy.prototype.centerFrame=false;YAHOO_PP.util.DDProxy.createFrame=function(){var THIS=YAHOO_PP.util.DDProxy;if(!document||!document.body){setTimeout(THIS.createFrame,50);return;}if(!THIS.frameDiv){THIS.frameDiv=document.createElement("div");THIS.frameDiv.id=THIS.dragElId;var s=THIS.frameDiv.style;s.position="absolute";s.visibility="hidden";s.cursor="move";s.border="2px solid #aaa";s.zIndex=999;document.body.appendChild(THIS.frameDiv);}};YAHOO_PP.util.DDProxy.prototype.initFrame=function(){YAHOO_PP.util.DDProxy.createFrame();this.setDragElId(YAHOO_PP.util.DDProxy.dragElId);this.useAbsMath=true;};YAHOO_PP.util.DDProxy.prototype.showFrame=function(_134,_135){var el=this.getEl();var s=this.getDragEl().style;if(this.resizeFrame){s.width=(parseInt(el.offsetWidth)-(2*this.borderWidth))+"px";s.height=(parseInt(el.offsetHeight)-(2*this.borderWidth))+"px";}if(this.centerFrame){this.setDelta(Math.round(parseInt(s.width)/2),Math.round(parseInt(s.width)/2));}this.setDragElPos(_134,_135);s.visibility="";};YAHOO_PP.util.DDProxy.prototype.b4MouseDown=function(e){var x=YAHOO_PP.util.Event.getPageX(e);var y=YAHOO_PP.util.Event.getPageY(e);this.autoOffset(x,y);this.setDragElPos(x,y);};YAHOO_PP.util.DDProxy.prototype.b4StartDrag=function(x,y){this.showFrame(x,y);};YAHOO_PP.util.DDProxy.prototype.b4EndDrag=function(e){var s=this.getDragEl().style;s.visibility="hidden";};YAHOO_PP.util.DDProxy.prototype.endDrag=function(e){var lel=this.getEl();var del=this.getDragEl();del.style.visibility="";lel.style.visibility="hidden";YAHOO_PP.util.DDM.moveToEl(lel,del);del.style.visibility="hidden";lel.style.visibility="";};YAHOO_PP.util.DDTarget=function(id,_138){if(id){this.initTarget(id,_138);}};YAHOO_PP.util.DDTarget.prototype=new YAHOO_PP.util.DragDrop();
/*
Copyright (c) 2007, Yahoo! Inc. All rights reserved.
Code licensed under the BSD License:
http://developer.yahoo.net/yui/license.txt
version: 2.2.0
*/
YAHOO_PP.util.Easing = {
    easeNone: function (t, b, c, d) {
    	return c*t/d + b;
    },
    easeIn: function (t, b, c, d) {
    	return c*(t/=d)*t + b;
    },
    easeOut: function (t, b, c, d) {
    	return -c *(t/=d)*(t-2) + b;
    },
    easeBoth: function (t, b, c, d) {
    	if ((t/=d/2) < 1) {
            return c/2*t*t + b;
        }
        
    	return -c/2 * ((--t)*(t-2) - 1) + b;
    },
    easeInStrong: function (t, b, c, d) {
    	return c*(t/=d)*t*t*t + b;
    },
    easeOutStrong: function (t, b, c, d) {
    	return -c * ((t=t/d-1)*t*t*t - 1) + b;
    },
    easeBothStrong: function (t, b, c, d) {
    	if ((t/=d/2) < 1) {
            return c/2*t*t*t*t + b;
        }
        
    	return -c/2 * ((t-=2)*t*t*t - 2) + b;
    },
    elasticIn: function (t, b, c, d, a, p) {
    	if (t == 0) {
            return b;
        }
        if ( (t /= d) == 1 ) {
            return b+c;
        }
        if (!p) {
            p=d*.3;
        }
        
    	if (!a || a < Math.abs(c)) {
            a = c; 
            var s = p/4;
        }
    	else {
            var s = p/(2*Math.PI) * Math.asin (c/a);
        }
        
    	return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
    },
    elasticOut: function (t, b, c, d, a, p) {
    	if (t == 0) {
            return b;
        }
        if ( (t /= d) == 1 ) {
            return b+c;
        }
        if (!p) {
            p=d*.3;
        }
        
    	if (!a || a < Math.abs(c)) {
            a = c;
            var s = p / 4;
        }
    	else {
            var s = p/(2*Math.PI) * Math.asin (c/a);
        }
        
    	return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
    },
    elasticBoth: function (t, b, c, d, a, p) {
    	if (t == 0) {
            return b;
        }
        
        if ( (t /= d/2) == 2 ) {
            return b+c;
        }
        
        if (!p) {
            p = d*(.3*1.5);
        }
        
    	if ( !a || a < Math.abs(c) ) {
            a = c; 
            var s = p/4;
        }
    	else {
            var s = p/(2*Math.PI) * Math.asin (c/a);
        }
        
    	if (t < 1) {
            return -.5*(a*Math.pow(2,10*(t-=1)) * 
                    Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
        }
    	return a*Math.pow(2,-10*(t-=1)) * 
                Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
    },
    backIn: function (t, b, c, d, s) {
    	if (typeof s == 'undefined') {
            s = 1.70158;
        }
    	return c*(t/=d)*t*((s+1)*t - s) + b;
    },
    backOut: function (t, b, c, d, s) {
    	if (typeof s == 'undefined') {
            s = 1.70158;
        }
    	return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
    },
    backBoth: function (t, b, c, d, s) {
    	if (typeof s == 'undefined') {
            s = 1.70158; 
        }
        
    	if ((t /= d/2 ) < 1) {
            return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
        }
    	return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
    },
    bounceIn: function (t, b, c, d) {
    	return c - YAHOO_PP.util.Easing.bounceOut(d-t, 0, c, d) + b;
    },
    bounceOut: function (t, b, c, d) {
    	if ((t/=d) < (1/2.75)) {
    		return c*(7.5625*t*t) + b;
    	} else if (t < (2/2.75)) {
    		return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
    	} else if (t < (2.5/2.75)) {
    		return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
    	}
        return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
    },
    bounceBoth: function (t, b, c, d) {
    	if (t < d/2) {
            return YAHOO_PP.util.Easing.bounceIn(t*2, 0, c, d) * .5 + b;
        }
    	return YAHOO_PP.util.Easing.bounceOut(t*2-d, 0, c, d) * .5 + c*.5 + b;
    }
};




/**************************************************************
 *
 * Pushpin Javascript API Code
 * http://www.pushpin.com/api/docs
 * Copyright (c) 2006-2009 Placebase, Inc. All Rights Reserved.
 * http://www.placebase.com
 *
 **************************************************************/

// Default dimensions for the content of the infowindow
var DEFAULT_INFODIV_WIDTH = 180;
var DEFAULT_INFODIV_HEIGHT = 40;

/**
 * Information windows that appear as cartoon-like bubbles on the map
 * With specified html content 
 * @constructor
 */
PInfoWindow = function() {
	this.visible = true;
	this.isOpen = false;
	this.point = null;
	this.tabs = [];
	this.selectedTab = 0; 	// move this PInfoWindowOptions later
	this.tabDivs = [];
	this.tabOverlap = 20; 	// number of pixels to overlap tabs
	this.nwDiff = 0; 	// difference between nw corner for tabs vs no tabs
	this.tabsWidth = 0;	// width of tabs
	this.tabsAdjust = 0;	// auto adjust if more than 2 tabs
	this.tabRows = []       // number of tab rows
	this.maxRowLength = 5;	// how many tabs will appear in each row
	this.listeners = [];
}
/**
 * Selects the given index of the tab array. 0 is the index of the first tab.
 * @param {Number} index The index of the tab array.
 */
PInfoWindow.prototype.selectTab = function(index) {
	if (index < this.tabs.length)
		this.selectedTab = index;
	this.updateTabs();
	this.updateInfoDiv();
}

/**
 * Hides the info window.
 */
PInfoWindow.prototype.hide = function() {
	this.visible = false;
	this.bubbleDiv.style.visibility = "hidden";
	this.shadowDiv.style.visibility = "hidden";
}

/**
 * Shows the info window.
 */
PInfoWindow.prototype.show = function() {
	this.visible = true;
	this.bubbleDiv.style.visibility = "visible";
	this.shadowDiv.style.visibility = "visible";
}

/**
 * @return True if the info window is hidden, else returns false.
 * @type Boolean
 */
PInfoWindow.prototype.isHidden = function() {
	return !this.visible;
}

/**
 * @return The point where the info window is anchored.
 * @type PLatLng
 */
PInfoWindow.prototype.getPoint = function() {
	return this.point;
}

/** 
 * @return The index of the currently selected info window tab.
 * @type Number
 */
PInfoWindow.prototype.getSelectedTab = function() {
	return this.selectedTab;
}

/**
 * @return The array of {@link PInfoWindowTab}
 * @type Array
 */
PInfoWindow.prototype.getTabs = function() {
	return this.tabs;
}

//
// Functions not exposed to the API
//

/**
 * Initializes the build of the infowindow.
 */
PInfoWindow.prototype.initialize = function() {
	this.createBubble();
	this.createShadow();
	this.createClose();
}

/**
 * Determines how many tabs need to be created.
 */
PInfoWindow.prototype.updateTabs = function() {
	for (var i=0; i<this.tabDivs.length; i++)
		this.updateTab(i);
}

/**
 * Adds the image to tabs and sets the layer position based on which is the selected one.
 * param {Number} i The tab that gets created
 */
PInfoWindow.prototype.updateTab = function(i) {
	var labelDiv = this.tabDivs[i].firstChild.nextSibling;
	var label = this.tabs[i].label;

	var tStyle = "style='position:relative; left:16px; width:70px; height:21px; font-weight:bold; top:-2px; //left:0px/*IE HACK*/'";
	if (i == this.selectedTab) {
		addPNGBackground(this.tabDivs[i].firstChild,this.map.kamap.server + "images/tab_front.png");
		labelDiv.innerHTML = "<table " + tStyle + " class='tab selected'><tr><td><b>" + label + "</b></td></tr></table>";
		this.tabDivs[i].style.zIndex = this.tabs.length + 1;
	} else {
		addPNGBackground(this.tabDivs[i].firstChild,this.map.kamap.server + "images/tab_back.png");
		labelDiv.innerHTML = "<table " + tStyle + " class='tab'><tr><td><a href='#' onclick='return false;'>" + label + "</a></td></tr></table>";
		this.tabDivs[i].style.zIndex = this.tabs.length - i;
	}
}

/**
 * Creates the div layout for each tab with the event to select it.
 */
PInfoWindow.prototype.createTabs = function() {
	for (var i=0; i<this.tabs.length; i++) {
		var tabDivMain = document.createElement('div');
		tabDivMain.style.position = "absolute";
		tabDivMain.style.top = "0px";
		tabDivMain.style.height = "49px";
		tabDivMain.style.width = "103px";
		tabDivMain.style.left = "0px";

		var tabDiv = document.createElement('div');
		var tabLabel = document.createElement('div');
		tabDiv.style.position = "absolute";
		tabDiv.style.width = "103px";
		tabDiv.style.height = "49px";
		tabDiv.style.left = "0px";
		tabDiv.style.top = "0px";
		tabDiv.style.textAlign = "center";

		tabLabel.style.position = "absolute";
		tabLabel.style.top = "0px";
		tabLabel.style.left = "0px";
		tabLabel.style.textAlign = "center";
		tabLabel.style.width = "103px";
		tabLabel.style.cursor = "pointer";
		tabLabel.style.paddingTop = "4px";

		tabDivMain.appendChild(tabDiv);
		tabDivMain.appendChild(tabLabel);
		this.tabDivs.push(tabDivMain);

		this.updateTab(i);
		this.tabsWidth += parseInt(tabDiv.style.width);
		if (i < this.tabs.length-1)
			this.tabsWidth -= this.tabOverlap;

		tabLabel.infowin = this;
		tabLabel.index = i;
		this.listeners.push(PEvent.addListener(tabLabel, 'click', function() { this.infowin.selectTab(this.index); }));
	}
	this.tabsWidth -= this.nwDiff;
}
/**
 * Sets variables with the image and div elements used to create the bubble part of the infowindow.
 * Assigns the source and position properties for the images.
 */ 
PInfoWindow.prototype.createBubble = function() {
	this.bubbleCanvas = this.map.getMarkerCanvas();
	this.bubbleDiv = document.createElement('div');
	this.bubbleDiv.className = 'InfoBubbleContainer';
	this.bubbleDiv.style.width = '100%';
	this.bubbleDiv.style.height = '100%';
	this.bubbleDiv.style.zIndex = Z_BUBBLE;
	this.bubbleDiv.style.cursor = 'default';
	
	// hack to stop events from going to map
	var f = function(e) {
		if (!e) var e = window.event;
		e.cancelBubble = true;
		if (e.stopPropagation) e.stopPropagation();
	};
	this.listeners.push(PEvent.addListener(this.bubbleDiv, 'mousedown', f));
	this.listeners.push(PEvent.addListener(this.bubbleDiv, 'click', f));

	// create images
	if (this.tabs.length > 1) {
		this.nw = this.createImage('tab_nw.png', 11, 49);
		this.nwDiff = 14;
		this.createTabs();
	} else 
		this.nw = this.createImage('bubble_nw.png', 25, 25);
	
	this.n  = this.createImage('bubble_n.png', 1, 25);
	this.ne = this.createImage('bubble_ne.png', 25, 25);
	this.w  = this.createImage('bubble_w.png', 25, 1);
	this.c  = this.createImage('bubble_center.png', 1, 1);
	this.e  = this.createImage('bubble_e.png', 25, 1);
	this.sw = this.createImage('bubble_sw.png', 25, 96);
	this.s1 = this.createImage('bubble_s.png', 1, 96);
	this.pointer = this.createImage('bubble_pointer.png', 98, 96);
	this.s2 = this.createImage('bubble_s.png', 1, 96);
	this.se = this.createImage('bubble_se.png', 25, 96);
}

/**
 * Sets variables with the image and div elements used to create the shadow part of the infowindow.
 * Assigns the source and position properties for the images.
 */
PInfoWindow.prototype.createShadow = function() {
	this.shadowCanvas = this.map.getShadowCanvas();
	this.shadowDiv = document.createElement('div');

	// create shadow images
	this.s_nw = this.createImage('bubble_shadow_nw.png', 70, 30);
	this.s_n  = this.createImage('bubble_shadow_n.png', 1, 30);
	this.s_ne = this.createImage('bubble_shadow_ne.png', 70, 30);
	this.s_c  = this.createImage('bubble_shadow_center.png', 1, 1);
	this.s_sw = this.createImage('bubble_shadow_sw.png', 70, 60);
	this.s_s1 = this.createImage('bubble_shadow_s.png', 1, 60);
	this.s_pointer = this.createImage('bubble_shadow_pointer.png', 140, 60);
	this.s_s2 = this.createImage('bubble_shadow_s.png', 1, 60);
	this.s_se = this.createImage('bubble_shadow_se.png', 70, 60);

	// special case divs to allow for background image
	this.s_w_img  = this.createImage('bubble_shadow_w.png', 360, 280);
	this.s_e_img  = this.createImage('bubble_shadow_e.png', 360, 280);
	this.s_w = this.createDivImage(this.s_w_img);
	this.s_e = this.createDivImage(this.s_e_img);
}

/**
 * Creates the close button on the infowindow.
 */
PInfoWindow.prototype.createClose = function() {	
	this.closeImage = this.createImage('button_close.gif', 14, 13);
	this.closeImage.style.cursor = 'pointer';
	this.closeImage.style.zIndex = this.tabs.length + 3;
	var infoWin = this;
	this.listeners.push(PEvent.addListener(this.closeImage, 'mouseup', function() { infoWin.close() }));
}

/**
 * Sets the width and height to use for the infowindow divs based on its content.
 * @param {Number} w Width of content div in the infowindow
 * @param {Number} h Height of content div in the infowindow
 */
PInfoWindow.prototype.encloseSize = function(w, h) {
	var nWidth = this.tabsWidth;
	if (nWidth > w) {
		this.tabsAdjust = nWidth - w;
		nWidth = w;
	}

	this.n.style.width = w - nWidth + "px";
	this.c.style.width = w + this.nwDiff + this.tabsAdjust + "px";
	var s1w = Math.ceil((w - parseInt(this.pointer.style.width))*0.5);
	var s2w = Math.floor((w - parseInt(this.pointer.style.width))*0.5) + this.tabsAdjust;
	this.s1.style.width = s1w + "px";
	this.s2.style.width = s2w + "px";

	// height
	this.w.style.height = h + "px";
	this.c.style.height = h + "px";
	this.e.style.height = h + "px";
}

/**
 * Sets the width and height to use for the infowindow shadow divs based on the content in the infowindow.
 * @param {Number} w Width of content div in the infowindow
 * @param {Number} h Height of content div in the infowindow
 */ 
PInfoWindow.prototype.encloseShadowSize = function(w, h) {
	// skew adjustment
	var skew = 10;
	
	// shadow width
	this.s_n.style.width = w + this.tabsAdjust + "px";
	var s_s1w = Math.floor((w - parseInt(this.s_pointer.style.width) + 30)*0.5) - skew;
	var s_s2w = Math.ceil((w - parseInt(this.s_pointer.style.width) + 30)*0.5 + this.tabsAdjust) + skew;
	this.s_s1.style.width = s_s1w + "px";
	this.s_s2.style.width = s_s2w + "px";
	this.s_w.style.width = (parseInt(this.s_nw.style.width) + h) + "px";
	this.s_e.style.width = (parseInt(this.s_ne.style.width) + h + this.tabsAdjust) + "px";
	this.s_c.style.width = (w - (parseInt(this.s_w.style.width) - parseInt(this.s_nw.style.width)) + 30) + "px";
	
	// shadow height
	this.s_w.style.height = h + "px";
	this.s_c.style.height = h + "px";
	this.s_e.style.height = h + "px";
}

/**
 * Calculates and declares the positioning for all the image divs used to create the infowindow and shadow
 */
PInfoWindow.prototype.positionInternals = function() {
	// padding inside bubble to adjust for position of infoDiv
	var bubblePaddingWidth = 15;
	var bubblePaddingHeight = 5;

	// set positions 
	this.nw.style.left = 0;
	this.nw.style.top  = 0;
	this.n.style.top   = 0;
	this.ne.style.top  = 0;
	
	var nLeft = parseInt(this.nw.style.width);
	if (this.tabDivs.length > 1) {
		for (var i=0; i<this.tabDivs.length; i++) {
			this.tabDivs[i].style.left = nLeft + "px";
			this.tabDivs[i].style.top = 0;
			nLeft += parseInt(this.tabDivs[i].style.width);
			if (i < this.tabDivs.length-1)
				nLeft -= this.tabOverlap;
		}
		this.n.style.top = parseInt(this.tabDivs[0].style.height) - parseInt(this.ne.style.height) + "px";
		this.ne.style.top = this.n.style.top;
	}
	this.n.style.left  = nLeft + "px";
	
	var neLeft = (parseInt(this.n.style.left) + parseInt(this.n.style.width));
	this.ne.style.left = neLeft + "px";
	
	this.w.style.left  = 0;
	this.w.style.top   = this.nw.style.height;
	this.c.style.left  = this.nw.style.width;
	this.c.style.top   = this.nw.style.height;
	this.e.style.left  = this.ne.style.left;
	this.e.style.top   = parseInt(this.ne.style.top) + parseInt(this.ne.style.height) + "px";
	this.sw.style.left = 0;
	this.sw.style.top  = (parseInt(this.w.style.top) + parseInt(this.w.style.height)) + "px";
	this.s1.style.left = this.sw.style.width;
	this.s1.style.top  = this.sw.style.top;
	this.pointer.style.left = (parseInt(this.s1.style.left) + parseInt(this.s1.style.width)) + "px";
	this.pointer.style.top  = this.sw.style.top;
	this.s2.style.left = (parseInt(this.pointer.style.left) + parseInt(this.pointer.style.width)) + "px";
	this.s2.style.top  = this.sw.style.top;
	this.se.style.left = (parseInt(this.s2.style.left) + parseInt(this.s2.style.width)) + "px";
	this.se.style.top  = this.sw.style.top;
	this.infoDiv.style.left = (parseInt(this.c.style.left) - (parseInt(this.nw.style.width) - bubblePaddingWidth)) + "px";
	this.infoDiv.style.top = parseInt(this.c.style.top) - bubblePaddingHeight + "px";

	// set shadow positions
	this.s_nw.style.left = 0;
	this.s_nw.style.top  = 0;
	this.s_n.style.left  = this.s_nw.style.width;
	this.s_n.style.top   = 0;
	this.s_ne.style.left = (parseInt(this.s_n.style.left) + parseInt(this.s_n.style.width)) + "px";
	this.s_ne.style.top  = 0;
	this.s_w.style.left  = (0 - parseInt(this.s_w.style.width) + parseInt(this.s_nw.style.width) + 10) + "px";
	this.s_w.style.top   = this.s_nw.style.height;
	this.s_c.style.left  = (parseInt(this.s_w.style.left) + parseInt(this.s_w.style.width)) + "px";
	this.s_c.style.top   = this.s_nw.style.height;
	this.s_e.style.left  = (parseInt(this.s_c.style.left) + parseInt(this.s_c.style.width)) + "px";
	this.s_e.style.top   = this.s_ne.style.height;
	this.s_sw.style.left = (parseInt(this.s_w.style.left) - 40) + "px";
	this.s_sw.style.top  = (parseInt(this.s_w.style.top) + parseInt(this.s_w.style.height)) + "px";
	this.s_s1.style.left = (parseInt(this.s_sw.style.left) + parseInt(this.s_sw.style.width)) + "px";
	this.s_s1.style.top  = this.s_sw.style.top;
	this.s_pointer.style.left = (parseInt(this.s_s1.style.left) + parseInt(this.s_s1.style.width)) + "px";
	this.s_pointer.style.top  = this.s_sw.style.top;
	this.s_s2.style.left = (parseInt(this.s_pointer.style.left) + parseInt(this.s_pointer.style.width)) + "px";
	this.s_s2.style.top  = this.s_sw.style.top;
	this.s_se.style.left = (parseInt(this.s_s2.style.left) + parseInt(this.s_s2.style.width)) + "px";
	this.s_se.style.top  = this.s_sw.style.top;

	// adjust shadow image in div
	this.s_w_img.style.left = (0 - (parseInt(this.s_w_img.style.width) - parseInt(this.s_w.style.width))) + "px";
	this.s_e_img.style.left = (parseInt(this.s_e.style.width) - (parseInt(this.s_e_img.style.width))) + "px";

	// close image position
	var closeImageOffset = 2;
	this.closeImage.style.left = (parseInt(this.ne.style.left) + closeImageOffset) + "px";
	this.closeImage.style.top = (parseInt(this.ne.style.top) + parseInt(this.ne.style.height) - parseInt(this.closeImage.style.height) - closeImageOffset) + "px";
}

/**
 * Adds the content to the center section of the infodiv.
 * Updates the content of the infowindow when different tabs are selected.
 */
PInfoWindow.prototype.updateInfoDiv = function() {
	var content = this.tabs[this.selectedTab].content;
	if (content.data || content.innerHTML) {
		while (this.infoDiv.hasChildNodes())
			this.infoDiv.removeChild(this.infoDiv.firstChild);
		this.infoDiv.appendChild(content);
	}
	else
		this.infoDiv.innerHTML = content;
}

/**
 * Creates infowindow center section 
 */
PInfoWindow.prototype.createInfoDiv = function() {
	this.infoDiv = document.createElement('div');
	this.infoDiv.style.position = "absolute";
	this.infoDiv.style.background = "#FFFFFF";
	this.infoDiv.style.border = "none";
	this.infoDiv.style.zIndex = this.tabs.length + 2;
	this.updateInfoDiv();
}

/**
 * Adds all the infowindow divs with images together to create the whole image.
 * Adds the completed infowindow to the map.
 */
PInfoWindow.prototype.create = function() {
	this.createInfoDiv();
	// layout images and info 
	this.bubbleDiv.appendChild(this.nw);
	
	for(var i=0; i<this.tabDivs.length; i++) {
		this.bubbleDiv.appendChild(this.tabDivs[i]);
	}
	
	this.bubbleDiv.appendChild(this.n);
	this.bubbleDiv.appendChild(this.ne);
	this.bubbleDiv.appendChild(this.w);
	this.bubbleDiv.appendChild(this.c);
	this.bubbleDiv.appendChild(this.e);
	this.bubbleDiv.appendChild(this.sw);
	this.bubbleDiv.appendChild(this.s1);
	this.bubbleDiv.appendChild(this.pointer);
	this.bubbleDiv.appendChild(this.s2);
	this.bubbleDiv.appendChild(this.se);
	this.bubbleDiv.appendChild(this.infoDiv);
	this.bubbleDiv.appendChild(this.closeImage);

	// layout shadow images and info
	this.shadowDiv.appendChild(this.s_nw);
	this.shadowDiv.appendChild(this.s_n);
	this.shadowDiv.appendChild(this.s_ne);
	this.shadowDiv.appendChild(this.s_w);
	this.shadowDiv.appendChild(this.s_c);
	this.shadowDiv.appendChild(this.s_e);
	this.shadowDiv.appendChild(this.s_sw);
	this.shadowDiv.appendChild(this.s_s1);
	this.shadowDiv.appendChild(this.s_pointer);
	this.shadowDiv.appendChild(this.s_s2);
	this.shadowDiv.appendChild(this.s_se);

	// render on map first to get width and height
	this.addBubbleToMap();
	var infoWidth = this.infoDiv.offsetWidth;
	var infoHeight = this.infoDiv.offsetHeight;
	if (infoWidth < DEFAULT_INFODIV_WIDTH)
		infoWidth = DEFAULT_INFODIV_WIDTH;
	if (infoHeight < DEFAULT_INFODIV_HEIGHT)
		infoHeight = DEFAULT_INFODIV_HEIGHT;

	this.encloseSize(infoWidth, infoHeight);
	var shadowWidth = Math.ceil(infoWidth * 0.75);
	var shadowHeight = Math.ceil(infoHeight * 0.5);
	this.encloseShadowSize(shadowWidth, shadowHeight);
	this.positionInternals();
	this.adjustBubble();
	this.addBubbleToMap();
	this.resize(); // to shrink 100% enclosing div to absolute size
	this.slideMap();
	this.isOpen = true;
	this.map.eventManager.triggerEvent('infowindowopen');
}

/**
 * Shrink 100% enclosing div to absolute size
 */
PInfoWindow.prototype.resize = function() {
	this.bubbleDiv.style.width = this.getWidth() + "px";	
	this.bubbleDiv.style.height = this.getHeight() + "px";
}

/**
 * Closes the infowindow
 */
PInfoWindow.prototype.close = function() {
	this.clearListeners();
	this.removeDiv(this.bubbleDiv);
	this.map.kamap.removeObject(this.bubbleDiv);
	this.removeDiv(this.shadowDiv);
	this.map.kamap.removeObject(this.shadowDiv);
	this.isOpen = false;
	this.visible = false;
	this.map.eventManager.triggerEvent('infowindowclose');
}

/**
 * Removes all the {@link PEvent} listeners added to PInfowWindow
 */
PInfoWindow.prototype.clearListeners = function() {
	for (var i=0; i<this.listeners.length; i++)
		PEvent.removeListener(this.listeners[i]);
	this.listeners = [];
}

/**
 * Removes all the images and divs from the infowindow
 * @param {Element} o The main bubble and shadow div
 */
PInfoWindow.prototype.removeDiv = function(o) {
	while (o.childNodes.length)
		o.removeChild(o.firstChild);
}

/**
 * Adds the infowindow to the map
 */
PInfoWindow.prototype.addBubbleToMap = function() {
	// passed in x, y are our coordinates in projected space(mercator)
	this.map.kamap.addObjectGeo(this.bubbleCanvas, this.whereGeo.x, this.whereGeo.y, this.bubbleDiv);
	this.map.kamap.addObjectGeo(this.shadowCanvas, this.whereGeo.x, this.whereGeo.y, this.shadowDiv);
}

/**
 * Adjusts the infowindow to display above marker
 */
PInfoWindow.prototype.adjustBubble = function() {
	// if there's a marker offset the shadow
	var offsetX = 0;
	var offsetY = 0;
	var shadowOffsetX = 0;
	var shadowOffsetY = 0;
	if (this.marker) {
		offsetX = this.marker.icon.infoWindowAnchor.x - this.marker.icon.iconAnchor.x;
		offsetY = this.marker.icon.infoWindowAnchor.y - this.marker.icon.iconAnchor.y;
		shadowOffsetX = this.marker.icon.shadowAnchor.x - this.marker.icon.infoWindowAnchor.x;
		if (this.marker.icon.shadowSize)
			shadowOffsetX += this.marker.icon.shadowSize.width*0.5;
		shadowOffsetY = this.marker.icon.infoWindowAnchor.y - this.marker.icon.shadowAnchor.y;
		if (this.marker.icon.shadowSize)
			shadowOffsetY += this.marker.icon.shadowSize.height*0.5;
	}
	this.bubbleDiv.xOffset = -parseInt(this.pointer.style.left) + offsetX;
	this.bubbleDiv.yOffset = -this.getHeight() + offsetY;
	this.shadowDiv.xOffset = -parseInt(this.s_pointer.style.left) + shadowOffsetX;
	this.shadowDiv.yOffset = -(parseInt(this.s_c.style.height) + parseInt(this.s_pointer.style.height) + parseInt(this.s_n.style.height)) + shadowOffsetY;
}

/**
 * Adjusts map position to show the infowindow location and fits infowindow in map viewport
 */
PInfoWindow.prototype.slideMap = function() {
	// check for control to offset
	var controlMarginLeft = 0;
	var controlMarginTop = 0;
	for (var i=0; i<this.map.controls.length; i++) {
		if (this.map.controls[i].marginLeft)
			controlMarginLeft = this.map.controls[i].marginLeft;
		if (this.map.controls[i].marginTop)
			controlMarginTop = this.map.controls[i].marginTop;
	}

	var paddingTop = 7 + controlMarginTop;
	var paddingLeft = 7 + controlMarginLeft;
	var paddingBottom = 25;
	var paddingRight = 7;
	
	// get extent of current map in pixels
	var mapExtents = this.map.kamap.getGeoExtents();
	var mapMin = this.map.kamap.geoToPix(mapExtents[0],mapExtents[1]);
	var mapMax = this.map.kamap.geoToPix(mapExtents[2],mapExtents[3]);
	var mapMinX = mapMin[0] + paddingLeft;
	var mapMinY = mapMin[1] - paddingBottom;
	var mapMaxX = mapMax[0] - paddingRight;
	var mapMaxY = mapMax[1] + paddingTop;
	
	// get extent of bubble in pixels
	var point = this.map.kamap.geoToPix(this.whereGeo.x, this.whereGeo.y);
	var pointMinX = point[0] + this.bubbleDiv.xOffset;
	var pointMinY = point[1];
	var pointMaxX = point[0] + (this.map.kamap.getObjectWidth(this.bubbleDiv) + this.bubbleDiv.xOffset + this.nwDiff);
	var pointMaxY = point[1] + this.bubbleDiv.yOffset;

	// check if bubble falls outside of map
	var moveX = 0;
	var moveY = 0;
	if (pointMaxX > mapMaxX)
		moveX += mapMaxX - pointMaxX;
	else if (pointMinX < mapMinX)
		moveX -= pointMinX - mapMinX;
	if (pointMinY > mapMinY)
		moveY += mapMinY - pointMinY;
	else if (pointMaxY < mapMaxY)
		moveY -= pointMaxY - mapMaxY;
	
	if (moveX != 0 || moveY != 0)
		this.map.kamap.slideBy(moveX,moveY);
}

/**
 * @return The height of the infowindow
 * @type Number
 */
PInfoWindow.prototype.getHeight = function() {
	return parseInt(this.nw.style.height) + parseInt(this.w.style.height) + parseInt(this.pointer.style.height);
}

/**
 * @return The width of the infowindow
 * @type Number
 */
PInfoWindow.prototype.getWidth = function() {
	return parseInt(this.nw.style.width) + parseInt(this.n.style.width) + parseInt(this.ne.style.width) + this.tabsWidth;
}

/**
 * Assigns the css and src to each image element used to create the infowindow
 * @param {String} src The source of the image
 * @param {Number} w The width of the image
 * @param {Number} h The height of the image
 * @param {Number} left The left position for the image
 * @param {Number} top The top position for the image
 * @param {String} display The display property for how the image element is displayed
 * @return {Element} The image element
 */ 
PInfoWindow.prototype.createImage = function(src, w, h, left, top, display) {
	var ret = document.createElement('img');
	ret.style.display = display == null ? "inline" : display;
	ret.style.position = "absolute";
	ret.style.border = "none";
	ret.style.margin = "0";
	ret.style.padding = "0";
	ret.style.MozUserSelect = 'none';
	if (left!=null && left!='') ret.style.left = left + "px";
	if (top!=null && top!='') ret.style.top = top + "px";
	if (w!=null && w!='') ret.style.width = w + "px";
	if (w!=null && h!='') ret.style.height = h + "px";
	var server = this.map.kamap.server;
	ret.src = this.map.kamap.server + "images/" + src;
	if (src.match('png')) fixPNG(ret);
	return ret;
}

/**
 * Creates the infowindow elements that require a div wrapper
 * @param {Element} i The image element
 * @return {Element} The div element that wraps the image
 */
PInfoWindow.prototype.createDivImage = function(i) {
	var ret = document.createElement('div');
	ret.style.position = "absolute";
	ret.style.overflow = "hidden";
	ret.appendChild(i);
	return ret;
}

/**
 * This sets the label and content for tabs used with {@link PInfoWindow}
 * This is passed as an array of tabs to the marker or map using {@link PMarker#openInfoWindowTabs} and {@link PMap#openInfoWindowTabs}
 * @param {String} label This sets the label displayed on the tab
 * @param {String} content This sets the content displayed in the infowindow when this tab is selected
 * @constructor
 */
PInfoWindowTab = function(label, content) {
	this.label = label;
	this.content = content;
}



/**************************************************************
 *
 * Pushpin Javascript API Code
 * http://www.pushpin.com/api/docs
 * Copyright (c) 2006-2009 Placebase, Inc. All Rights Reserved.
 * http://www.placebase.com
 *
 **************************************************************/

var widgetEnum = 1;
var P_WIDGET_LAYER_ID = widgetEnum++;
var P_WIDGET_INDICATOR_ID = widgetEnum++;
var P_WIDGET_OVERLAY_ID = widgetEnum++;

var widgetZIndex = 999;

function PWidgetDrag(id, sGroup) {
	this.id = id;
	if (id) {
		this.init(id, sGroup);
	}
}

PWidgetDrag.prototype = new YAHOO_PP.util.DD();

PWidgetDrag.prototype.startDrag = function(x, y) {
	var style = this.getEl().style;

	// increment zIndex so widget is ends up on top
	widgetZIndex++;
	style.zIndex = widgetZIndex;
	style.position = "absolute";
}

// **********************
// *** Class: PWidget ***
// **********************
PWidget = function(map, div, widgetid) {
	var pWidget = this;
	if (map)
		this.map = map;
	else {
		this.map = new Object();
		this.map.kamap = new Object();
		this.map.kamap.server = PEnvironment.kamapUrl;
	}
	this.id = widgetid;

	// background for widget (default styles)
	this.background = div;
	this.background.style.borderRight = '1px solid #666'
	this.background.style.borderBottom = '1px solid #666'
	this.background.style.backgroundColor = '#fff';

	// widget box (default styles)
	this.box = document.createElement("div");
	this.box.style.border = "1px solid #C7BEA5";
	this.box.style.padding = "2px";

	// widget heading (default styles)
	this.heading = document.createElement("div");
	this.heading.id = div.id + "_heading";
	this.heading.style.border = "1px solid #E2DFD3";
	this.heading.style.backgroundColor = "#E2DFD3";
	this.heading.style.padding = "0px 1px 0px 5px";
	this.heading.style.height = "15px";
	PEvent.addListener(this.heading, 'click', function() { widgetZIndex++; pWidget.background.style.zIndex = widgetZIndex; });
	PEvent.addListener(this.heading, 'dblclick', function() { pWidget.toggleMinMaximize(); });

	// widget heading width
	var widgetWidth = parseInt(this.background.style.width);
	var totalPadding = parseInt(this.box.style.paddingLeft) + parseInt(this.box.style.paddingRight) +
						parseInt(this.heading.style.paddingLeft) + parseInt(this.heading.style.paddingRight) +
						parseInt(this.box.style.borderLeftWidth) + parseInt(this.box.style.borderRightWidth) +
						parseInt(this.heading.style.borderRightWidth) + parseInt(this.background.style.borderRightWidth);
	this.heading.style.width = (widgetWidth - totalPadding) + "px";

	// widget heading text
	this.title = document.createElement("div");
	this.title.style.styleFloat = "left";
	this.title.style.cssFloat = "left";
	this.title.style.color = "#666";
	this.title.style.fontFamily = "arial";
	this.title.style.fontSize = "11px";
	this.title.style.fontWeight = "bold";
	this.title.innerHTML = "";

	// widget controls
	this.controls = document.createElement("div");
	this.controls.style.width = "28px";
	this.controls.style.height = "13px";
	this.controls.style.styleFloat = "right";
	this.controls.style.cssFloat = "right";

	// minimize maximize button
	this.button_maximize = document.createElement("img");
	PEvent.addListener(this.button_maximize, 'click', function() { pWidget.toggleMinMaximize() });
	this.button_maximize.style.cursor = "pointer";
	this.button_maximize.style.width = "13px";
	this.button_maximize.style.height = "13px";
	this.button_maximize.border = 0;
	this.button_maximize.hspace = 1;
	this.button_maximize.vspace = 1;
	this.button_maximize.src = this.map.kamap.server + "images/button_minimize_widget.gif";
	this.button_maximize.title = "Minimize";

	// close button
	this.button_close = document.createElement("img");
	PEvent.addListener(this.button_close, 'click', function() { pWidget.close() });
	this.button_close.style.cursor = "pointer";
	this.button_close.style.width = "13px";
	this.button_close.style.height = "13px";
	this.button_close.border = 0;
	this.button_close.vspace = 1;
	this.button_close.src = this.map.kamap.server + "images/button_close_widget.gif";
	this.button_close.title = "Close";

	this.controls.appendChild(this.button_maximize);
	this.controls.appendChild(this.button_close);

	this.heading.appendChild(this.title);
	this.heading.appendChild(this.controls);

	// widget body (default styles)
	this.body = document.createElement("div");
	this.body.style.padding = "3px";
	this.body.style.fontFamily = "arial";
	this.body.style.fontWeight = "normal";
	this.body.style.fontSize = "11px";
	this.body.style.color = "#666";

	// default widget state
	this.disableDragging();
	this.box.appendChild(this.heading);
	this.background.appendChild(this.box);
	this.maximize();

	this.listeners = [];

	if (widgetid) {
		if (widgetid == P_WIDGET_LAYER_ID) {
			this.map.widgetLayer = this;
			var mapref = this.map;
			PEvent.addListener(this.map, "zoomend", function() { mapref.refreshWidget(mapref.widgetLayer); });
		}
		else if (this.id == P_WIDGET_OVERLAY_ID)
			this.map.widgetOverlay = this;
		else if (this.id == P_WIDGET_INDICATOR_ID) {
			this.map.widgetIndicator = this; 
			this.map.kamap.widgetIndicator = this;
		}
		this.buildWidget();
	}
}

// ***********************************************************************
// ******************** Version 0.9 Functions ****************************
// ***********************************************************************

PWidget.prototype.setTitle = function(html) {
	this.setLabel(html);
}

PWidget.prototype.getTitle = function() {
	return this.title.innerHTML;
}

PWidget.prototype.setBody = function(html) {
	this.setContentHtml(html);
}

PWidget.prototype.getBody = function() {
	return this.body.innerHTML;
}

// ********************* End Version 0.9 Functions ***********************

PWidget.prototype.setLabel = function(html) {
	this.title.innerHTML = html;
}

PWidget.prototype.setContent = function(dom) {
	this.body.appendChild(dom);
}

PWidget.prototype.setContentHtml = function(html) {
	this.body.innerHTML = html;
}

PWidget.prototype.maximize = function() {
	if (!this.isMaximized()) {
		this.box.appendChild(this.body);
		
		// ie fix -- otherwise loses all the checked marks
		if (this.layersDiv || this.overlaysDiv)
			this.buildWidget();
		
		this.button_maximize.src = this.map.kamap.server + "images/button_minimize_widget.gif";
		this.button_maximize.title = "Minimize";
		this.isMax = true;
	}
}

PWidget.prototype.minimize = function() {
	if (this.isMaximized()) {
		this.box.removeChild(this.body);
		this.button_maximize.src = this.map.kamap.server + "images/button_maximize_widget.gif";
		this.button_maximize.title = "Maximize";
		this.isMax = false;
	}
}

PWidget.prototype.isMaximized = function() {
	if (this.isMax)
		return this.isMax;
	else
		return false;
}

PWidget.prototype.enableDragging = function() {
	// yahoo api draggable widget
	var div_id = this.background.id;
	this.heading.style.cursor = "move";
	//this.drag = new YAHOO_PP.util.DD(div_id);
	this.drag = new PWidgetDrag(div_id);
	this.drag.setHandleElId(div_id + "_heading");
}

PWidget.prototype.disableDragging = function() {
	if (this.drag)
		this.drag.unreg();
	this.drag = null;
	this.heading.style.cursor = "default";
}

PWidget.prototype.draggingEnabled = function() {
	if (this.drag == null)
		return false;
	else
		return true;
}

PWidget.prototype.close = function() {
	this.clearListeners();
	this.background.parentNode.removeChild(this.background);
}

//
// Internal functions not in API
//

PWidget.prototype.clearListeners = function() {
	for (var i=0; i<this.listeners.length; i++)
		PEvent.removeListener(this.listeners[i]);
	this.listeners = [];
}

PWidget.prototype.buildWidget = function() {
	this.clearListeners();
	if (this.id == P_WIDGET_LAYER_ID) {
		if (this.title && this.title.innerHTML == "")
			this.setLabel("Display " + this.map.getCurrentMapType().getName() + " Layers");
		
		if (!this.layersDiv) {
			this.layersDiv = document.createElement("div");
			this.body.appendChild(this.layersDiv);
		}
		else {
                	this.layersDiv.innerHTML = "";
		}

		var layers = this.map.getCurrentMapType().getMapLayers();
		for (var i=1; i<layers.length; i++) {
			if (layers[i].title != "donotshowinwidget") {
				var checkDiv = document.createElement("div");
				checkDiv.style.styleFloat = "left";
				checkDiv.style.cssFloat = "left";
			
				var check = document.createElement("input");
				check.type = "checkbox";
				check.value = i;
				checkDiv.appendChild(check);
				this.layersDiv.appendChild(checkDiv);
				
				if (layers[i].isOn())
					check.checked = "true";
				this.listeners.push(PEvent.addListener(check, 'click', function() { if (layers[this.value].isOn()) layers[this.value].off(); else layers[this.value].on(); }));
				if (layers[i].minScale > this.map.getScale() || layers[i].maxScale < this.map.getScale())
					check.disabled = true;
			
				var textDiv = document.createElement("div");
				textDiv.style.styleFloat = "left";
				textDiv.style.cssFloat = "left";
				textDiv.style.paddingTop = "3px";
				textDiv.style.paddingLeft = "2px";
				textDiv.innerHTML = layers[i].title;
				if (check.disabled)
					textDiv.style.color = "#ccc";
				this.layersDiv.appendChild(textDiv);
			
				var br = document.createElement("br");
				br.clear = "both";
				this.layersDiv.appendChild(br);
			}
		}
	}
	else if (this.id == P_WIDGET_OVERLAY_ID) {
		if (!this.expandDiv)
			this.expandDiv = [];
		if (this.title && this.title.innerHTML == "")
			this.setLabel("Display Overlays");
		
		if (!this.overlaysDiv) {
			this.overlaysDiv = document.createElement("div");
			this.overlaysDiv.style.padding = "1px";
			this.body.appendChild(this.overlaysDiv);
		}
		else {
                	this.overlaysDiv.innerHTML = "";
		}

		var overlays = this.map.getOverlaySets();
		for (var i=0; i<overlays.length; i++) {
			var overlayi = overlays[i];
			var checkDiv = document.createElement("div");
			checkDiv.style.styleFloat = "left";
			checkDiv.style.cssFloat = "left";
			
			var check = document.createElement("input");
			check.type = "checkbox";
			check.value = i;
			checkDiv.appendChild(check);
			this.overlaysDiv.appendChild(checkDiv);
			
			if (overlayi.isOn())
				check.checked = "true";
			this.listeners.push(PEvent.addListener(check, 'click', function() { if (overlays[this.value].isOn()) overlays[this.value].off(); else overlays[this.value].on(); }));
	
			// add icon for the set
			var imgWidth = 10;
			var iconDiv = null;
			if ((overlayi.markers && overlayi.markers[0]) || overlayi.icon) {
				var overlay = null;
				if (overlayi.markers && overlayi.markers[0])
					overlay = overlayi.markers[0];
				if (overlay instanceof PMarker || overlayi.icon) {
					iconDiv = document.createElement("img");
					var icon;
					if (overlayi.icon)
						icon = new PIcon(overlayi.icon);
					else
						icon = new PIcon(overlay.icon);
					iconDiv.src = icon.image;
					var height = icon.iconSize.height;
					var width = icon.iconSize.width;
					if (width > imgWidth) {
						height = (imgWidth / width) * height;
						width = imgWidth;
					}
					iconDiv.style.height = height + "px";
					iconDiv.style.width = width + "px";
					fixPNG(iconDiv);
				}
				else if (overlay instanceof PPolyline || overlay instanceof PPolygon) {
					iconDiv = document.createElement("div");
					iconDiv.style.styleFloat = "left";
					iconDiv.style.cssFloat = "left";
					iconDiv.style.height = overlay.weight + "px";
					iconDiv.style.width = imgWidth + "px";
					iconDiv.style.marginTop = (15 - overlay.weight) + "px";
					iconDiv.style.marginRight = "3px";
					iconDiv.style.backgroundColor = overlay.color;
					iconDiv.style.fontSize = "1px";
					_BrowserIdent_setOpacity(iconDiv, overlay.opacity);
				}
			}

			var textDiv = document.createElement("div");
			var textNode = document.createTextNode(" " + overlayi.name + " [" + overlayi.getOverlayCount() + "] ");
			textDiv.style.styleFloat = "left";
			textDiv.style.cssFloat = "left";
			textDiv.style.paddingTop = "3px";
			textDiv.style.paddingLeft = "2px";
			
			if (iconDiv)
				textDiv.appendChild(iconDiv);
			textDiv.appendChild(textNode);
			//textDiv.innerHTML = "&nbsp;" + overlayi.name + " [" + overlayi.getOverlayCount() + "]&nbsp;&nbsp;";
	
			this.overlaysDiv.appendChild(textDiv);
			
			// Check if there are display filters
			if (overlayi.displayfiltergroups) {
				var menuTimer = [];
				var menuTimerNameDiv = [];
				var menuTimerValueDiv = [];
				var menuWait = 300;
				
				function findPos(obj) {
					var curleft = curtop = 0;
					if (obj.offsetParent) {
						curleft = obj.offsetLeft
						curtop = obj.offsetTop
						while (obj = obj.offsetParent) {
							curleft += obj.offsetLeft
							curtop += obj.offsetTop
						}
					}
					return [curleft,curtop];
				};

				function removeNode(div, id) {
					for (var i=0; i<div.childNodes.length; i++) {
						if (div.childNodes[i].id == id)
							div.removeChild(div.childNodes[i]);
					}

				};

				// menu elements
				var filterArrow = document.createElement("img");
				var nameDiv = document.createElement("div");
				
				// arrow to open menu
				filterArrow.style.width = "13px";
				filterArrow.style.height = "13px";
				filterArrow.style.cursor = "pointer";
				filterArrow.style.paddingRight = "3px";
				filterArrow.align = "top";
				filterArrow.textDiv = textDiv;
				filterArrow.nameDiv = nameDiv;
				filterArrow.mouseoverimg = this.map.kamap.server + "images/button_arrow_down_widget.gif";
				filterArrow.mouseoutimg = this.map.kamap.server + "images/button_arrow_widget.gif";
				filterArrow.src = filterArrow.mouseoutimg;
				filterArrow.timerIndex = i;
				filterArrow.valueDivId = "filterValueDiv";
				this.listeners.push(PEvent.addListener(filterArrow, 'mouseover', function() { 
					this.src = this.mouseoverimg;
					clearTimeout(menuTimer[this.timerIndex]);
					clearTimeout(menuTimerNameDiv[this.timerIndex]);
					clearTimeout(menuTimerValueDiv[this.timerIndex]);
					this.textDiv.appendChild(this.nameDiv);
					removeNode(this.textDiv, this.valueDivId);
				}));
				this.listeners.push(PEvent.addListener(filterArrow, 'mouseout', function() {
					var self = this;
					menuTimer[self.timerIndex] = setTimeout(function() {
						self.src = self.mouseoutimg; 
						self.textDiv.removeChild(self.nameDiv);
					}, menuWait);
				}));
				while (textDiv.hasChildNodes())
					textDiv.removeChild(textDiv.firstChild);
				textDiv.appendChild(filterArrow);
				if (iconDiv)
					textDiv.appendChild(iconDiv);
				textDiv.appendChild(textNode);
	
				// attribute name menu
				nameDiv.style.zIndex = 10;
				nameDiv.style.position = "absolute";
				nameDiv.style.borderTop = this.box.style.borderTop;
				nameDiv.style.borderRight = this.background.style.borderRight;
				nameDiv.style.borderBottom = this.background.style.borderBottom;
				nameDiv.style.width = "150px";
				nameDiv.style.backgroundColor = this.background.style.backgroundColor;
				nameDiv.filterArrow = filterArrow;
				this.listeners.push(PEvent.addListener(nameDiv, 'mouseover', function() { 
					clearTimeout(menuTimer[this.filterArrow.timerIndex]);
					clearTimeout(menuTimerNameDiv[this.filterArrow.timerIndex]); 
					clearTimeout(menuTimerValueDiv[this.filterArrow.timerIndex]); 
				}));
				this.listeners.push(PEvent.addListener(nameDiv, 'mouseout', function() {
					var filterArrow = this.filterArrow;
					menuTimerNameDiv[filterArrow.timerIndex] = setTimeout(function() {
						filterArrow.src = filterArrow.mouseoutimg;
						filterArrow.textDiv.removeChild(filterArrow.nameDiv);
						removeNode(filterArrow.textDiv, filterArrow.valueDivId);
					}, menuWait);
				}));
				var nameDivPos = findPos(filterArrow);
				var widgetPos = findPos(this.background);
				nameDiv.style.left = nameDivPos[0] - widgetPos[0] + parseInt(filterArrow.style.width) + 2 + "px";
				nameDiv.style.top = nameDivPos[1] - widgetPos[1] + "px";
				
				for (var j in overlayi.displayfiltergroups) {
					var filters = overlayi.displayfiltergroups[j];
					if (filters.length > 0) {
						var newDivOuter = document.createElement("div");
						newDivOuter.style.padding = "1px";
						newDivOuter.style.borderLeft = this.box.style.borderLeft;
						newDivOuter.style.borderRight = this.box.style.borderRight;
						newDivOuter.style.borderBottom = this.box.style.borderBottom;

						var valueDiv = document.createElement("div");
						valueDiv.id = filterArrow.valueDivId;
						valueDiv.style.zIndex = nameDiv.style.zIndex;
						valueDiv.style.position = nameDiv.style.position;
						valueDiv.style.borderTop = nameDiv.style.borderTop;
						valueDiv.style.borderRight = nameDiv.style.borderRight;
						valueDiv.style.borderBottom = nameDiv.style.borderBottom;
						valueDiv.style.width = nameDiv.style.width;
						valueDiv.style.backgroundColor = nameDiv.style.backgroundColor;
						valueDiv.style.left = parseInt(nameDiv.style.left) + parseInt(nameDiv.style.width) - 1 + "px";
						valueDiv.style.top = nameDiv.style.top;
						valueDiv.filterArrow = filterArrow;
						this.listeners.push(PEvent.addListener(valueDiv, 'mouseover', function() { 
							clearTimeout(menuTimerValueDiv[this.filterArrow.timerIndex]); 
							clearTimeout(menuTimerNameDiv[this.filterArrow.timerIndex]);
						}));
						this.listeners.push(PEvent.addListener(valueDiv, 'mouseout', function() { 
							var self = this;
							var filterArrow = this.filterArrow;
							menuTimerValueDiv[filterArrow.timerIndex] = setTimeout(function() {
								filterArrow.src = filterArrow.mouseoutimg;
								filterArrow.textDiv.removeChild(filterArrow.nameDiv);
								filterArrow.textDiv.removeChild(self);
							}, menuWait);
						}));

						// attribute names
						var newDiv = document.createElement("div");
						newDiv.innerHTML = j;
						newDiv.style.width = "136px";
						newDiv.style.padding = "0px 5px 0px 5px";
						newDiv.style.cursor = "pointer";
						newDiv.style.fontSize = "10px";
						newDiv.valueDiv = valueDiv;
						newDiv.textDiv = textDiv;
						newDiv.filterArrow = filterArrow;
						newDiv.mouseovercolor = this.heading.style.backgroundColor;
						newDiv.mouseoutcolor = this.background.style.backgroundColor;
						this.listeners.push(PEvent.addListener(newDiv, 'mouseover', function() { 
							this.style.backgroundColor = this.mouseovercolor; 
							removeNode(this.textDiv, this.filterArrow.valueDivId);
							this.textDiv.appendChild(this.valueDiv);
						}));
						this.listeners.push(PEvent.addListener(newDiv, 'mouseout', function() { this.style.backgroundColor = this.mouseoutcolor; }));
						newDivOuter.appendChild(newDiv);
						nameDiv.appendChild(newDivOuter);
						
						for (var k=0; k<filters.length; k++) {
							var existfilters = overlayi.filtergroups[j];
							var found = false;
							
							// attribute filter values
							var newChild = document.createElement("div");
							var newChildOuter = document.createElement("div");
							newChildOuter.style.padding = newDivOuter.style.padding;
							newChildOuter.style.borderLeft = newDivOuter.style.borderLeft;
							newChildOuter.style.borderRight = newDivOuter.style.borderRight;
							newChildOuter.style.borderBottom = newDivOuter.style.borderBottom;
							newChild.style.width = newDiv.style.width;
							newChild.style.padding = newDiv.style.padding;
							newChild.style.fontSize = "10px";
							newChild.innerHTML = filters[k].displayValues();
							if (existfilters) {
								for (var l=0; l<existfilters.length; l++) {
									if (filters[k] == existfilters[l]) {
										found = true;
										break;
									}
								}
							}
							if (found)
								newChild.style.backgroundColor = this.heading.style.backgroundColor;
							else {
								newChild.mouseovercolor = this.heading.style.backgroundColor;
								newChild.mouseoutcolor = this.background.style.backgroundColor;
								newChild.overlay = overlayi;
								newChild.filter = filters[k];
								newChild.style.cursor = "pointer";
								newChild.filterArrow = filterArrow;
								newChild.timerIndex = k;
								this.listeners.push(PEvent.addListener(newChild, 'mouseover', function() { this.style.backgroundColor = this.mouseovercolor; }));
								this.listeners.push(PEvent.addListener(newChild, 'mouseout', function() { this.style.backgroundColor = this.mouseoutcolor; }));
								this.listeners.push(PEvent.addListener(newChild, 'click', function() { this.overlay.addFilter(this.filter); }));
							}
							newChildOuter.appendChild(newChild);
							valueDiv.appendChild(newChildOuter);
						}
					}
				}
			}
			
			// Check if there are any active filters
			if (overlayi.getFilters().length > 0) {
				var activeDiv = document.createElement("div");
				activeDiv.style.paddingLeft = "15px";
				
				//if (!this.expandDiv[i]) {
					// expand button
					var expandImg = document.createElement("img");
					expandImg.style.width = "9px";
					expandImg.style.height = "9px";
					expandImg.hspace = 3;

					this.expandDiv[i] = document.createElement("div");
					this.expandDiv[i].expand = true;
					this.expandDiv[i].plusImg = this.map.kamap.server + "images/expand.png";
					this.expandDiv[i].minusImg = this.map.kamap.server + "images/collapse.png";
					expandImg.src = this.expandDiv[i].minusImg;
					this.expandDiv[i].appendChild(expandImg);
					this.expandDiv[i].innerHTML += "<b><u>Active Filters</u></b><br>";
					this.expandDiv[i].style.cursor = "pointer";
					this.listeners.push(PEvent.addListener(this.expandDiv[i], 'click', function () { 
						if (this.expand) {
							this.childNodes[0].src = this.plusImg;
							this.expand = false;
							this.parentNode.removeChild(this.activeDiv);
						} 
						else { 
							this.childNodes[0].src = this.minusImg;
							this.expand = true;
							this.parentNode.appendChild(this.activeDiv);
						}
					}));
				//}
				this.expandDiv[i].activeDiv = activeDiv;
				textDiv.appendChild(this.expandDiv[i]);
				if (this.expandDiv[i].expand)
					textDiv.appendChild(activeDiv);
				for (var j in overlayi.filtergroups) {
					var filters = overlayi.filtergroups[j];
					if (filters.length > 0) {
						var newDiv = document.createElement("div");
						var newChild = document.createElement("div");
						newDiv.innerHTML = j + ": <span style='font-size: 9px; color: #aaa'>(click to remove)</span>";
						newChild.style.paddingLeft = "15px";
						newChild.style.fontSize = "10px";
						newDiv.appendChild(newChild);
						activeDiv.appendChild(newDiv);
						for (var k=0; k<filters.length; k++) {
							var newA = document.createElement("a");
							newA.href = "#";
							newA.title = "Remove";
							newA.style.paddingRight = "2px";
							newA.filter = filters[k];
							newA.overlay = overlayi;
							newA.innerHTML = newA.filter.displayValues();
							this.listeners.push(PEvent.addListener(newA, 'click', function() { this.overlay.removeFilter(this.filter); }));
							newChild.appendChild(newA);
							newChild.appendChild(document.createElement("br"));
						}
					}
				}
			}
			var br = document.createElement("br");
			br.clear = "both";
			this.overlaysDiv.appendChild(br);
		}
	}
	else if (this.id == P_WIDGET_INDICATOR_ID) {
		if (this.title && this.title.innerHTML == "")
			this.setLabel("Choose an Indicator");
		
		if(!this.indSelect) {
			this.indSelect = document.createElement('select');
			this.indSelect.style.width = "100%";
			this.indSelect.style.fontSize = "10px";
			this.body.appendChild(this.indSelect);
		}
		else {
			this.indSelect.innerHTML = "";
		}

		var widgetMap = this.map;
		var widget = this;
		var indList = this.map.getIndicatorList();

		this.listeners.push(PEvent.addListener(this.indSelect, 'change', function() { 
			if (this.value == -1) widgetMap.removeIndicator(); 
			else widgetMap.setIndicator(indList[this.value]);
		}));

		var indOption = document.createElement('option');
		indOption.text = "None";
		indOption.value = -1;
		try {
			this.indSelect.add(indOption,null);
		}
		catch(ex) {
			this.indSelect.add(indOption);
		}
		
		if (this.map.getLegend() != null && this.map.getIndicatorList()) {
			var inds = this.map.getIndicatorList();
			var selectedIndex = 0;
			for (var i=0; i<inds.length; i++) {
				var indOption = document.createElement('option');
				indOption.text = inds[i].displayName;
				indOption.value = i;
				if (this.map.getIndicator() != null && this.map.getIndicator().id == inds[i].id)
					selectedIndex = i+1;
				try {
					this.indSelect.add(indOption,null);
				}
				catch(ex) {
					this.indSelect.add(indOption);
				}
			}
			this.indSelect.selectedIndex = selectedIndex;
		}

		var legend = "";
		if (this.map.getLegend() != null && this.map.getIndicator() != null && this.map.getLegend().getBoundaryType()) {
			var leg = this.map.getLegend();
			var incrementValue = PWebUtil.getBreakIncrement(leg.getBreaks());
			var breaks = leg.getFormattedBreaks(incrementValue);
			var incrementBreaks = leg.getIncrementedBreaks(incrementValue);
			var colors = leg.getColors();
			legend = "<div style='padding-bottom: 5px'></div><table width=98% cellpadding=0 cellspacing=0 border=0 style='border-left: #ccc 1px solid; border-top: #ccc 1px solid; border-right: #ccc 1px solid'>";
			var numbreaks = leg.getNumberOfBreaks();

			// check for no data value
			if (leg.getIndicator().nodata)
				numbreaks += 1;
			
			for (var i=0; i<numbreaks; i++) {
				var breaksString;
	
				// check for no data value
				if (leg.getIndicator().nodata && i == 0)
					breaksString = "<span style='color:#ccc;font-style:italic'>Data Not Available</span>";
				// check for exact value break types or same value range
				else if (leg.getIndicator().breakid == P_BREAKTYPE_EXACT_VALUE_ID || leg.getIndicator().breakid == P_BREAKTYPE_EXACT_VALUE_CUSTOM_ID || breaks[i] == breaks[i+1])
					breaksString = breaks[i];
				else {
					var startBreak = "";
					if (i == 0 || (i == 1 && leg.getIndicator().nodata))
						startBreak = breaks[i];
					else
						startBreak = incrementBreaks[i];
					if (startBreak == breaks[i+1])
						breaksString = startBreak;
					else
						breaksString = startBreak + "&nbsp;&nbsp;&ndash;&nbsp;&nbsp;" + breaks[i+1];
				}

				legend += "<tr><td style='border-right: #ccc 1px solid; border-bottom: #ccc 1px solid; width: 30px; background-color: #" + colors[i] + "'>&nbsp;</td><td style='border-bottom: #ccc 1px solid'>&nbsp;&nbsp;" + breaksString + "</td></tr>";
			}

			legend += "</table><div style='padding-bottom: 3px'></div>";
			legend += "Shaded by " + leg.getBoundaryType().name;
			legend += "<br>";
			if (leg.getIndicator().source != '')
				legend += "<i>Source: " + leg.getIndicator().source + "</i>";
		} else if (this.map.getIndicator() != null)
			legend += "<i>Data not available at this zoom level.</i><br>";

		if (!this.indLegend) {
			this.indLegend = document.createElement('div');
			this.body.appendChild(this.indLegend);
		}
		this.indLegend.innerHTML = legend;
	}
}

PWidget.prototype.toggleMinMaximize = function() {
	if (this.isMaximized()) {
		this.minimize();
	}
	else {
		this.maximize();
	}
}

// **************************************
// *** Class: PPlaceContainmentWidget ***
// **************************************
PPlaceContainmentWidget = function(map, node, placeorder, separator) {
	this.map = map;
	this.background = node;
	if (placeorder)
		this.placeorder = placeorder;
	else
		this.placeorder = [PPlaceType.STATE, PPlaceType.COUNTY, PPlaceType.ZIP];
	if (separator)
		this.separator = separator;
	else
		this.separator = ">";

	this.eventTypes = new Object();
	this.eventTypes.click = 'click';

	this.eventManager = new _eventManager();
	for (var ev in this.eventTypes)
		this.eventManager.registerEventID(ev);
	
	this.listeners = [];
}

PPlaceContainmentWidget.prototype.refresh = function(places) {
	this.clearListeners();
	var placeString = "";
	this.places = places;
	while (this.background.hasChildNodes())
		this.background.removeChild(this.background.firstChild);
	for (var i=0; i<this.placeorder.length; i++) {
		for (var j=0; j<places.length; j++) {
			if (this.placeorder[i].id == places[j].typeid) {
				// add separator
				var separator = document.createElement("div");
				separator.style.styleFloat = "left";
				separator.style.cssFloat = "left";
				separator.style.paddingLeft = "5px";
				separator.style.paddingRight = "5px";
				separator.innerHTML = this.separator;
				this.background.appendChild(separator);
				
				// add place
				var placeDiv = document.createElement("div");
				placeDiv.style.styleFloat = "left";
				placeDiv.style.cssFloat = "left";
				
				var placeLink = document.createElement("a");
				placeLink.href = "#";
				placeLink.innerHTML = places[j].label;
				if (this.placeorder[i] == PPlaceType.COUNTY)
					placeLink.innerHTML += " County";
				
				placeDiv.place = places[j];
				placeDiv.map = this.map;
				placeDiv.outerDiv = this.background;
				placeDiv.widget = this;
				placeDiv.highlight = this.highlight;
				this.listeners.push(PEvent.addListener(placeDiv, 'click', function() { 
					this.map.setCenterBounds(this.place.bounds);
					this.widget.eventManager.triggerEvent('click', this.place);
				}));
				
				placeDiv.appendChild(placeLink);
				this.background.appendChild(placeDiv);
			}
		}
	}
	if (this.background.firstChild)
		this.background.removeChild(this.background.firstChild);
}

PPlaceContainmentWidget.prototype.addListener = function(eventId, func) {
	this.eventManager.registerForEvent(eventId, [], func);
}

PPlaceContainmentWidget.prototype.removeListener = function(event) {
	this.eventManager.deregisterForEvent(event.id, event.obj, event.func)
}

PPlaceContainmentWidget.prototype.clearListeners = function() {
	for (var i=0; i<this.listeners.length; i++)
		PEvent.removeListener(this.listeners[i]);
	this.listeners = [];
}



/**************************************************************
 *
 * Pushpin Javascript API Code
 * http://www.pushpin.com/api/docs
 * Copyright (c) 2006-2009 Placebase, Inc. All Rights Reserved.
 * http://www.placebase.com
 *
 **************************************************************/

PMarkerManager=function(map, icon) {
	this.map = map;
	this.markers = [];
	this.clusters = [];
	this.timeout = null;
	this.currentZoomLevel = map.getZoom();
	this.maxVisibleMarkers = 150;
	this.gridSize = 5;
	this.minMarkersPerCluster = 5;
	if (icon)
		this.icon = icon;
	else
		this.icon= PIcon.CLUSTER;
	PEvent.addListener(map,'zoomend',PMarkerManager.makeCaller(PMarkerManager.display,this));
	PEvent.addListener(map,'moveend',PMarkerManager.makeCaller(PMarkerManager.display,this));
	PEvent.addListener(map,'infowindowclose',PMarkerManager.makeCaller(PMarkerManager.popDown,this));
}

PMarkerManager.prototype.getIcon = function(icon) { return this.icon; }

PMarkerManager.prototype.setMaxVisibleMarkers = function(n) {	this.maxVisibleMarkers = n; }
	
PMarkerManager.prototype.setMinMarkersPerCluster = function(n) { this.minMarkersPerCluster=n; }
	
PMarkerManager.prototype.addMarker = function(marker) {
	marker.onMap=false;
	this.markers.push(marker);
	this.displayLater();
}

PMarkerManager.prototype.addMarkers = function(markers) {
	for(var i=0; i<markers.length; ++i)
		this.addMarker(markers[i]);
}

PMarkerManager.prototype.removeMarker=function(marker)
{
	for(var i=0; i<this.markers.length; ++i)
		if(this.markers[i]==marker) {
			if(marker.onMap)
				this.map.removeOverlay(marker);
			for(var j=0; j<this.clusters.length; ++j) {
				var cluster=this.clusters[j];
				if(cluster!=null) {
					for(var k=0; k<cluster.markers.length; ++k)
						if(cluster.markers[k]==marker) {
							cluster.markers[k]=null;
							--cluster.markerCount;
							break;
						}
						if(cluster.markerCount==0) {
							this.clearCluster(cluster);
							this.clusters[j]=null;
						}
						else if(cluster==this.poppedUpCluster)
							PMarkerManager.rePop(this);
				}
			}
			this.markers[i]=null;
			break;
		}
	this.displayLater();
}

PMarkerManager.prototype.clearMarkers = function() {
	for (var i=0; i<this.markers.length; i++) {
		if(this.markers[i] && this.markers[i].onMap)
				this.map.removeOverlay(this.markers[i]);
	}
	for (var i=0; i<this.clusters.length; i++) {
		if (this.clusters[i])
				this.clearCluster(this.clusters[i]);
	}
	this.markers = [];
	this.clusters = [];
	this.timeout = null;
}

PMarkerManager.prototype.displayLater=function() {
	if(this.timeout!=null)
		clearTimeout(this.timeout);
	this.timeout=setTimeout(PMarkerManager.makeCaller(PMarkerManager.display,this),50);
}

PMarkerManager.display=function(clusterer) {
	var i,j,marker,cluster;
	clearTimeout(clusterer.timeout);
	var newZoomLevel=clusterer.map.getZoom();
	if(newZoomLevel!=clusterer.currentZoomLevel) {
		for(i=0; i<clusterer.clusters.length; ++i)
			if(clusterer.clusters[i]!=null) {
				clusterer.clearCluster(clusterer.clusters[i]);
				clusterer.clusters[i]=null;
			}
		clusterer.clusters.length=0;
		clusterer.currentZoomLevel=newZoomLevel;
	}
	var bounds=clusterer.map.getBounds();
	var sw=bounds.getSouthWest();
	var ne=bounds.getNorthEast();
	var dx=ne.lng()-sw.lng();
	var dy=ne.lat()-sw.lat();
	dx*=0.10;
	dy*=0.10;
	bounds=new PLatLngBounds(new PLatLng(sw.lat()-dy,sw.lng()-dx),new PLatLng(ne.lat()+dy,ne.lng()+dx));
	var visibleMarkers=[];
	var nonvisibleMarkers=[];
	for(i=0; i<clusterer.markers.length; ++i) {
		marker=clusterer.markers[i];
		if(marker!=null)
			if(bounds.contains(marker.getPoint()))
				visibleMarkers.push(marker);
			else
				nonvisibleMarkers.push(marker);
	}
	for(i=0; i<nonvisibleMarkers.length; ++i) {
		marker=nonvisibleMarkers[i];
		if(marker.onMap) {
			clusterer.map.removeOverlay(marker);
			marker.onMap=false;
		}
	}
	for(i=0; i<clusterer.clusters.length; ++i) {
		cluster=clusterer.clusters[i];
		if(cluster!=null&&!bounds.contains(cluster.marker.getPoint())&&cluster.onMap) {
			clusterer.map.removeOverlay(cluster.marker);
			cluster.onMap=false;
		}
	}
	if(visibleMarkers.length>clusterer.maxVisibleMarkers) {
		var latRange=bounds.getNorthEast().lat()-bounds.getSouthWest().lat();
		var latInc=latRange/clusterer.gridSize;
		var lngInc=latInc/Math.cos((bounds.getNorthEast().lat()+bounds.getSouthWest().lat())/2.0*Math.PI/180.0);
		for(var lat=bounds.getSouthWest().lat();
		lat<=bounds.getNorthEast().lat();
		lat+=latInc)
		for(var lng=bounds.getSouthWest().lng(); lng<=bounds.getNorthEast().lng(); lng+=lngInc)	{
			cluster=new Object();
			cluster.clusterer=clusterer;
			cluster.bounds=new PLatLngBounds(new PLatLng(lat,lng),new PLatLng(lat+latInc,lng+lngInc));
			cluster.markers=[];
			cluster.markerCount=0;
			cluster.onMap=false;
			cluster.marker=null;
			clusterer.clusters.push(cluster);
		}
		for(i=0; i<visibleMarkers.length; ++i) {
			marker=visibleMarkers[i];
			if(marker!=null&&!marker.inCluster) {
				for(j=0; j<clusterer.clusters.length; ++j) {
					cluster=clusterer.clusters[j];
					if(cluster!=null&&cluster.bounds.contains(marker.getPoint())) {
						cluster.markers.push(marker);
						++cluster.markerCount;
						marker.inCluster=true;
					}
				}
			}
		}
		for(i=0; i<clusterer.clusters.length; ++i)
			if(clusterer.clusters[i]!=null&&clusterer.clusters[i].markerCount<clusterer.minMarkersPerCluster) {
				clusterer.clearCluster(clusterer.clusters[i]);
				clusterer.clusters[i]=null;
			}
		for(i=clusterer.clusters.length-1; i>=0; --i)
			if(clusterer.clusters[i]!=null)
				break;
			else
				--clusterer.clusters.length;
		for(i=0; i<clusterer.clusters.length; ++i) {
			cluster=clusterer.clusters[i];
			if(cluster!=null) {
				for(j=0; j<cluster.markers.length; ++j) {
					marker=cluster.markers[j];
					if(marker!=null&&marker.onMap) {
						clusterer.map.removeOverlay(marker);
						marker.onMap=false;
					}
				}
			}
		}
		for(i=0; i<clusterer.clusters.length; ++i) {
			cluster=clusterer.clusters[i];
			if(cluster!=null&&cluster.marker==null) {
				var xTotal=0.0,yTotal=0.0;
				for(j=0; j<cluster.markers.length; ++j) {
					marker=cluster.markers[j];
					if(marker!=null) {
						xTotal+=(+marker.getPoint().lng());
						yTotal+=(+marker.getPoint().lat());
					}
				}
				var location=new PLatLng(yTotal/cluster.markerCount,xTotal/cluster.markerCount);
				marker=new PMarker(location,clusterer.icon);
				cluster.marker=marker;
				PEvent.addListener(marker, 'click', PMarkerManager.makeCaller(PMarkerManager.popUp,cluster));
			}
		}
	}
	for(i=0; i<visibleMarkers.length; ++i) {
		marker=visibleMarkers[i];
		if(marker!=null&&!marker.onMap&&!marker.inCluster) {
			clusterer.map.addOverlay(marker);
			if(marker.addedToMap!=null)
				marker.addedToMap();
			marker.onMap=true;
		}
	}
	for(i=0; i<clusterer.clusters.length; ++i) {
		cluster=clusterer.clusters[i];
		if(cluster!=null&&!cluster.onMap&&bounds.contains(cluster.marker.getPoint())) {
			clusterer.map.addOverlay(cluster.marker);
			cluster.onMap=true;
		}
	}
	PMarkerManager.rePop(clusterer);
}

PMarkerManager.popUp=function(cluster) {
	var clusterer=cluster.clusterer;
	var html = "This cluster represents <b>" + cluster.markerCount + "</b> individual pins.<br>Zoom in closer to see them.";
	cluster.marker.openInfoWindowHtml(html);
	clusterer.poppedUpCluster=cluster;
}

PMarkerManager.rePop=function(clusterer) {
	if(clusterer.poppedUpCluster!=null)
		PMarkerManager.popUp(clusterer.poppedUpCluster);
}

PMarkerManager.popDown=function(clusterer) {
	clusterer.poppedUpCluster=null;
}

PMarkerManager.prototype.clearCluster=function(cluster) {
	var i,marker;
	for(i=0; i<cluster.markers.length; ++i)
		if(cluster.markers[i]!=null) {
			cluster.markers[i].inCluster=false;
			cluster.markers[i]=null;
		}
	cluster.markers.length=0;
	cluster.markerCount=0;
	if(cluster==this.poppedUpCluster)
		this.map.closeInfoWindow();
	if(cluster.onMap) {
		this.map.removeOverlay(cluster.marker);
		cluster.onMap=false;
	}
}

PMarkerManager.makeCaller=function(func,arg) {
	return function() {
		func(arg);
	};
}

/**************************************************************
 *
 * Pushpin Javascript API Code
 * http://www.pushpin.com/api/docs
 * Copyright (c) 2006-2009 Placebase, Inc. All Rights Reserved.
 * http://www.placebase.com
 *
 **************************************************************/

/**
 * This class represents a place (boundary), e.g. 90013, los angeles, etc.
 * @param {Number} id Optional. The unique id of a place
 * @constructor
 */
PPlace = function(id) {
	if (id) this.id = id; else this.id = null;
	this.identifier = null;
	this.label = null;
	this.typeid = null;
	this.bounds = null;
	this.centroid = null;
	this.vertices = null;
	this.area = null;
	this.pop = null;
	this.state = null;
        this.country = null;
}

/**
 * @return The unique id of this place
 * @type   Number
 */
PPlace.prototype.getID = function() { 
	return this.id; 
}

/**
 * @return The identifier for this place, usually the FIPS code
 * @type   String
 */
PPlace.prototype.getIdentifier = function() { 
	return this.identifier; 
}

/**
 * @return The label/name of this place
 * @type   String
 */
PPlace.prototype.getLabel = function() { 
	return this.label; 
}

/**
 * @see PPlace#getTypeById
 */
PPlace.prototype.getType = function() { 
	return this.getTypeById(this.typeid); 
}

/**
 * @return The extent of this place
 * @type   PLatLngBounds
 */
PPlace.prototype.getBounds = function() { 
	return this.bounds; 
}

/**
 * @return The centroid of this place
 * @type   PLatLng
 */
PPlace.prototype.getCentroid = function() { 
	return this.centroid; 
}

/**
 * @return The vertices of this place as an array of {@link PLatLng}
 * @type   Array
 */
PPlace.prototype.getVertices = function() { 
	return this.vertices; 
}

/**
 * @return The area of this place in meters
 * @type   Number
 */
PPlace.prototype.getArea = function() {	
	return this.area; 
}

/**
 * @return The population of this place if exists
 * @type   Number
 */
PPlace.prototype.getPopulation = function() { 
	return this.pop; 
}

/**
 * @return The abbreviated state that this place is in
 * @type   String
 */
PPlace.prototype.getState = function() { 
	return this.state; 
}

/**
 * @return The string to display with this place, with the state for certain place types
 * @type   String
 */
PPlace.prototype.getDisplayState = function() {
	var state = "";
	if (this.getState() && this.getType() != PPlaceType.CBSA && this.getType() != PPlaceType.STATE && this.getType() != PPlaceType.CDBG)
		state = ", " + this.getState();
	return state;
}

/**
 * @return The country that this place is in
 * @type   String
 */
PPlace.prototype.getCountry = function() {
	return this.country;
}

/**
 * Searches for places within this place
 * @see PClientGeocoder#getPlacesWithin
 */
PPlace.prototype.getPlacesWithin = function(placetype, callback, overlap, maxResults, order) {
	new PClientGeocoder().getPlacesWithin(this, placetype, callback, overlap, maxResults, order);
}

/**
 * Searches for places containing this place
 * @see PClientGeocoder#getPlacesContaining
 */
PPlace.prototype.getPlacesContaining = function(placetype, callback, overlap, maxResults, order) {
	new PClientGeocoder().getPlacesContaining(this, placetype, callback, overlap, maxResults, order);
}

/**
 * Searches for server side points within this place
 * @see PClientGeocoder#getMarkersWithin
 */
PPlace.prototype.getMarkersWithin = function(overlayset, callback) {
        new PClientGeocoder().getMarkersWithin(this, overlayset, callback);
}

/**
 * @see PClientGeocoder#getPlaceContainmentByPlace
 */
PPlace.prototype.getContainment = function(callback) {
	new PClientGeocoder().getPlaceContainmentByPlace(this, callback);
}

/**
 * @return The place type for this place
 * @type   PPlaceType
 */
PPlace.prototype.getTypeById = function() {
	for (var i=0; i<P_PLACETYPES.length; i++) {
		if (this.typeid == P_PLACETYPES[i].id)
			return P_PLACETYPES[i];
	}
	return null;
}

/**
 * This class represents the a place type, e.g. state, county etc.
 * @param {Number} id       The unique id for this place type
 * @param {String} name     The name of this place type
 * @param {String} path     The path for the placetype. Not currently used.
 * @param {Array} maplayers Optional. The array of map layers that represent this place.
 */
PPlaceType = function(id,name,path,maplayers) {
	this.id = id;
	this.name = name;
	this.path = path;
	this.minScale = 0;
	this.maxScale = 1000000000;
	this.maplayers = null;
	if (maplayers)
		this.maplayers = maplayers;
}

/**
 * @return The name of this place type
 * @type   String
 */
PPlaceType.prototype.getName = function() { 
	return this.name; 
}

/**
 * @return The array of {@link PMapLayer} associated to this place
 * @type   Array
 */
PPlaceType.prototype.getMapLayers = function() { 
	if (this.maplayers)
		return this.maplayers
	else
		return null;
}

/**
 * This class represents a configuration for zooms to place types
 * @constructor
 */
PPlaceTypeConfig = function() { 
	this.zooms = []; 
}

/**
 * Assigns a place type to an absolute zoom
 * @param {Number} zoom     The absolute zoom level to set
 * @param {PPlaceType} type The place type to assign the zoom to
 */
PPlaceTypeConfig.prototype.setTypeByAbsoluteZoom = function(zoom, type) { 
	this.zooms[zoom] = type; 
}

/**
 * Gets a place type by absolute zoom
 * @param {Number} zoom The absolute zoom level to look up
 * @return              The place type or false if not found
 * @type                PPlaceType
 */
PPlaceTypeConfig.prototype.getTypeByAbsoluteZoom = function(zoom) { 
	if (this.zooms[zoom])
		return this.zooms[zoom]; 
	else {
		for (var i=zoom; i >= 0; i--) {
			if (this.zooms[i])
				return this.zooms[i];
		}
		return false;
	}
}

/**
 * This class represents the order for returning {@link PPlace} arrays.
 * This is used as global variables, e.g. PPlaceOrder.AREA.
 * @constructor
 */
PPlaceOrder = function() {}

/**************************************************************
 *
 * Pushpin Javascript API Code
 * http://www.pushpin.com/api/docs
 * Copyright (c) 2006-2009 Placebase, Inc. All Rights Reserved.
 * http://www.placebase.com
 * 
 ***************************************************************/

/**
 * This class represents a collection of overlays, can be client or server side
 * @param markers         Either an array of {@link PMarker} or an id for a server pinset
 * @param mgr             Optional. Either a {@link PMarkerManager} or an icon to use for server pins
 * @param {Number} zoom   Optional. The zoom level to switch server to client pins. Defaults to zoom level 12
 *                        Only used when declaring a server pinset.
 * @param {Number} pinmax Optional. The threshold for maximum number of pins to display on the client side. Defaults to 50.
 *                        Only used when declaring a server pinset.
 * @constructor
 */
POverlaySet = function(markers,mgr,zoom,pinmax) {
	this.name = "Overlay Set";

	if (markers instanceof Array) {
		this.markers = markers;
		if (mgr)
			this.markermgr = mgr;
	} else {
		this.markers = [];
		this.id = markers;
		this.serverOn = false;
		this.serverPinCount = 0;
		if (zoom || zoom == 0)
			this.zoom = zoom;
		else
			this.zoom = 12;
		if (pinmax || pinmax == 0)
			this.pinmax = pinmax;
		else
			this.pinmax = 50;
		if (mgr)
			this.icon = mgr;
		else
			this.icon = PIcon.POINT;
	}
	
	this.filtered = this.markers.slice();
	this.refreshed = [];
	this.filtergroups = new Object();
	this.display = true;
	this.oldQuery = '';

	// for filtering by icons
	this.filtersbyicons = [];
	this.filtericons = [];
	this.reloadfiltericons = true;
}

/**
 * Sets the label for this overlay set
 * @param {String} label The label for this set
 */
POverlaySet.prototype.setLabel = function(label) { 
	this.name = label;
	if (this.map)
		this.map.refreshWidget(this.map.widgetOverlay);
}

/**
 * @return The label for this set
 * @type   String
 */
POverlaySet.prototype.getLabel = function() { 
	return this.name; 
}

/**
 * Adds a client overlay to the set
 * @param marker The overlay to add to the set, e.g. {@link PMarker}
 */
POverlaySet.prototype.addOverlay = function(marker) {
	this.markers.push(marker);
	if (this.overlayInFilters(marker)) {
		this.filtered.push(marker);
		if (this.map && this.isOn())
			this.addMarker(marker);
		if (this.map)
			this.map.refreshWidget(this.map.widgetOverlay);
	}
}

/**
 * Removes an overlay from the set
 * @param marker The overlay to remove from the set
 */
POverlaySet.prototype.removeOverlay = function(marker) {
	for(var i=0; i<this.markers.length; i++) {
		if (this.markers[i] == marker) {
			this.markers.splice(i,1);
			break;
		}
	}
	if (this.overlayInFilters(marker)) {
		if (this.filtered != this.markers) {
			for(var i=0; i<this.filtered.length; i++) {
				if (this.filtered[i] == marker) {
					this.filtered.splice(i,1);
					break;
				}
			}
		}
		if (this.map && this.isOn())
			this.removeMarker(marker);
		if (this.map)
			this.map.refreshWidget(this.map.widgetOverlay);
	}
}

/**
 * @return The array of overlays in this set
 * @type   Array
 */
POverlaySet.prototype.getOverlays = function() { 
	return this.filtered; 
}

/**
 * @return The number of overlays in this set, if server pins, returns the number in the current extent
 * @type   Number
 */
POverlaySet.prototype.getOverlayCount = function() {
	if (this.serverOn)
		return this.serverPinCount;
	else
		return this.filtered.length;
}

/**
 * Turns this set on
 */
POverlaySet.prototype.on = function() {
	if (!this.display) {
		this.display = true;
		if (this.map) {
			for (var i = 0; i < this.filtered.length; i++)
				this.addMarker(this.filtered[i]);
			this.refreshed = this.filtered;
			this.map.refreshWidget(this.map.widgetOverlay);
		}
		if (this.id)
			this.renderClient();
	}
}

/**
 * Turns this set off
 */
POverlaySet.prototype.off = function() {
	if (this.display) {
		this.display = false;
		if (this.map) {
			this.clearMarkers();
			this.map.refreshWidget(this.map.widgetOverlay);
		}
		if (this.map && this.serverOn)
			this.removeServer();
	}
}

/**
 * @return True if this set is on
 * @type   Boolean
 */
POverlaySet.prototype.isOn = function() { 
	return this.display; 
}

/**
 * Applies the filter to this set
 * @param {PAttributeFilter} filter The filter to apply
 */
POverlaySet.prototype.addFilter = function(filter) {
	this.addFilterToGroup(filter);
	this.executeFilters();
	this.refresh();
}

/**
 * Removes the filter from this set
 * @param {PAttributeFilter} filter The filter to remove
 */
POverlaySet.prototype.removeFilter = function(filter) {
	this.removeFilterFromGroup(filter);
	this.executeFilters();
	this.refresh();
}

/**
 * Clears all filters from this set
 */
POverlaySet.prototype.clearFilters = function() {
	this.filtergroups = new Object();
	this.filtered = this.markers.slice();
	this.executeFilters();
	this.refresh();
}

/**
 * Applies an array of filters to this set
 * @param {Array} filters The array of {@link PAttributeFilter} to apply
 */
POverlaySet.prototype.setFilters = function(filters) {
	this.filtergroups = new Object();
	for (var i = 0; i < filters.length; i++)
		this.addFilterToGroup(filters[i]);
	this.executeFilters();
	this.refresh();
}

/**
 * @return The array of {@link PAttributeFilter} applied to this set
 * @type   Array
 */
POverlaySet.prototype.getFilters = function() {
	var retFilters = [];
	for (var i in this.filtergroups) {
		var filters = this.filtergroups[i];
		for (var j=0; j<filters.length; j++)
			retFilters.push(filters[j]);
		
	}
	return retFilters;
}

/**
 * Sets the display filters for this overlay set. These show up in the overlay widget.
 * @param {Array} filters The array of {@link PAttributeFilter} to display
 */
POverlaySet.prototype.setDisplayFilters = function(filters) {
	this.displayfiltergroups = new Object();
	for (var i = 0; i < filters.length; i++) {
		var filter = filters[i];
		if (!this.displayfiltergroups[filter.name])
			this.displayfiltergroups[filter.name] = [];
		this.displayfiltergroups[filter.name].push(filter);
	}
}

/**
 * Filters this set by associating each filter with an icon
 * @param {Array} filters The array of {@link PAttributeFilter} to filter
 * @param {Array} icons   The corresponding array of {@link PIcon} to use for each filter
 */
POverlaySet.prototype.setFiltersByIcons = function(filters, icons) {
	this.filtersbyicons = filters.slice();
	this.filtericons = icons.slice();
	
	// clear other filters for now, which will refresh
	this.clearFilters();
}

/**
 * Clears the filtering by icons
 */
POverlaySet.prototype.clearFiltersByIcons = function() {
	if (this.filtersbyicons.length > 0) {
		this.filtersbyicons = [];
		this.filtericons = [];
		this.reloadfiltericons = true;
		this.oldQuery = null;
		this.clearFilters();
	}
}

/**
 * Adds a filter (grouped by filter name)
 * @param {PAttributeFilter} filter The filter to add
 */
POverlaySet.prototype.addFilterToGroup = function(filter) {
	// clear icon filters for now
	this.clearFiltersByIcons();
	
	if (!this.filtergroups[filter.name])
		this.filtergroups[filter.name] = [];
	this.filtergroups[filter.name].push(filter);
}

/**
 * Removes a filter from a group
 * @param {PAttributeFilter} filter The filter to remove
 */
POverlaySet.prototype.removeFilterFromGroup = function(filter) {
	if (this.filtergroups[filter.name]) {
		var filters = this.filtergroups[filter.name];
		for (var i=0; i<filters.length; i++) {
			if (filter == filters[i]) {
				this.filtergroups[filter.name].splice(i,1);
				break;
			}
		}
	}
}

/**
 * Executes the filters on this set
 */
POverlaySet.prototype.executeFilters = function() {
	if (this.id) {
		this.setMarkersById();
	} else {
		this.filtered = [];
		for (var i=0; i<this.markers.length; i++) {
			if (this.overlayInFilters(this.markers[i]))
				this.filtered.push(this.markers[i]);
		}
	}
}

/**
 * For client overlay set.
 * This checks to see if an overlay falls within any of the filters
 * @param overlay The overlay to check
 * @return        True if the overlay falls within a filter
 * @type          Boolean
 */
POverlaySet.prototype.overlayInFilters = function(overlay) {
	var andCheck = true;
	// loop through filters with different attributes and treat as AND query
	for (var i in this.filtergroups) {
		var filters = this.filtergroups[i];
		// loop through filters with same attributes and treat as OR query
		var orCheck = true;
		for (var j=0; j<filters.length; j++) {
			var attrib = overlay.getAttribute(filters[j].name);
			if (attrib) {
				if (this.attributeInFilter(attrib,filters[j])) {
					orCheck = true;
					break;
				} else
					orCheck = false;
			}
		}
		if (orCheck)
			andCheck = true;
		else {
			andCheck = false;
			break;
		}
	}
	return andCheck;
}

/**
 * Checks if the attribute falls within the filter
 * @param {PAttribute} attrib       The attribute to check
 * @param {PAttributeFilter} filter The filter to apply on the attribute
 * @return                          True if the attribute falls within the filter
 * @type                            Boolean
 */
POverlaySet.prototype.attributeInFilter = function(attrib, filter) {
	var values = filter.values;
	if (filter.type == PAttributeFilter.EQUAL) {
		for (var k = 0; k < values.length; k++) {
			if (attrib.value == values[k])
				return true;
		}
	}
	else if (filter.type == PAttributeFilter.RANGE) {
		if (attrib.type == PAttribute.STRI