/* -------- OPENSTREETMAP SCRIPTS BEGIN -------- */
/**
 * Namespace: Util.OSM
 */
OpenLayers.Util.OSM = {};

/**
 * Constant: MISSING_TILE_URL
 * {String} URL of image to display for missing tiles
 */
OpenLayers.Util.OSM.MISSING_TILE_URL = "http://openstreetmap.org/openlayers/img/404.png";

/**
 * Property: originalOnImageLoadError
 * {Function} Original onImageLoadError function.
 */
OpenLayers.Util.OSM.originalOnImageLoadError = OpenLayers.Util.onImageLoadError;

/**
 * Function: onImageLoadError
 */
OpenLayers.Util.onImageLoadError = function() 
{
  if (this.src.match(/^http:\/\/[abc]\.[a-z]+\.openstreetmap\.org\//)) {
      this.src = OpenLayers.Util.OSM.MISSING_TILE_URL;
  } else if (this.src.match(/^http:\/\/[def]\.tah\.openstreetmap\.org\//)) {
      // do nothing - this layer is transparent
  } else {
      OpenLayers.Util.OSM.originalOnImageLoadError;
  }
};

/**
 * Class: OpenLayers.Layer.OSM.Mapnik
 *
 * Inherits from:
 *  - <OpenLayers.Layer.OSM>
 */
OpenLayers.Layer.OSM.Mapnik = OpenLayers.Class(OpenLayers.Layer.OSM, 
{
  /**
   * Constructor: OpenLayers.Layer.OSM.Mapnik
   *
   * Parameters:
   * name - {String}
   * options - {Object} Hashtable of extra options to tag onto the layer
   */
  initialize: function(name, options) {
      var url = [
          "http://a.tile.openstreetmap.org/${z}/${x}/${y}.png",
          "http://b.tile.openstreetmap.org/${z}/${x}/${y}.png",
          "http://c.tile.openstreetmap.org/${z}/${x}/${y}.png"
      ];
      options = OpenLayers.Util.extend({numZoomLevels: 19}, options);
      var newArguments = [name, url, options];
      OpenLayers.Layer.OSM.prototype.initialize.apply(this, newArguments);
  },

  CLASS_NAME: "OpenLayers.Layer.OSM.Mapnik"
});

/**
 * Class: OpenLayers.Layer.OSM.Osmarender
 *
 * Inherits from:
 *  - <OpenLayers.Layer.OSM>
 */
OpenLayers.Layer.OSM.Osmarender = OpenLayers.Class(OpenLayers.Layer.OSM, 
{
  /**
   * Constructor: OpenLayers.Layer.OSM.Osmarender
   *
   * Parameters:
   * name - {String}
   * options - {Object} Hashtable of extra options to tag onto the layer
   */
  initialize: function(name, options) {
      var url = [
          "http://a.tah.openstreetmap.org/Tiles/tile/${z}/${x}/${y}.png",
          "http://b.tah.openstreetmap.org/Tiles/tile/${z}/${x}/${y}.png",
          "http://c.tah.openstreetmap.org/Tiles/tile/${z}/${x}/${y}.png"
      ];
      options = OpenLayers.Util.extend({numZoomLevels: 18}, options);
      var newArguments = [name, url, options];
      OpenLayers.Layer.OSM.prototype.initialize.apply(this, newArguments);
  },

  CLASS_NAME: "OpenLayers.Layer.OSM.Osmarender"
});

/**
 * Class: OpenLayers.Layer.OSM.CycleMap
 *
 * Inherits from:
 *  - <OpenLayers.Layer.OSM>
 */
OpenLayers.Layer.OSM.CycleMap = OpenLayers.Class(OpenLayers.Layer.OSM, 
{
  /**
   * Constructor: OpenLayers.Layer.OSM.CycleMap
   *
   * Parameters:
   * name - {String}
   * options - {Object} Hashtable of extra options to tag onto the layer
   */
  initialize: function(name, options) {
      var url = [
          "http://a.andy.sandbox.cloudmade.com/tiles/cycle/${z}/${x}/${y}.png",
          "http://b.andy.sandbox.cloudmade.com/tiles/cycle/${z}/${x}/${y}.png",
          "http://c.andy.sandbox.cloudmade.com/tiles/cycle/${z}/${x}/${y}.png"
      ];
      options = OpenLayers.Util.extend({numZoomLevels: 19}, options);
      var newArguments = [name, url, options];
      OpenLayers.Layer.OSM.prototype.initialize.apply(this, newArguments);
  },

  CLASS_NAME: "OpenLayers.Layer.OSM.CycleMap"
});

/**
 * Class: OpenLayers.Layer.OSM.Maplint
 *
 * Inherits from:
 *  - <OpenLayers.Layer.OSM>
 */
OpenLayers.Layer.OSM.Maplint = OpenLayers.Class(OpenLayers.Layer.OSM, 
{
  /**
   * Constructor: OpenLayers.Layer.OSM.Maplint
   *
   * Parameters:
   * name - {String}
   * options - {Object} Hashtable of extra options to tag onto the layer
   */
  initialize: function(name, options) {
      var url = [
          "http://d.tah.openstreetmap.org/Tiles/maplint/${z}/${x}/${y}.png",
          "http://e.tah.openstreetmap.org/Tiles/maplint/${z}/${x}/${y}.png",
          "http://f.tah.openstreetmap.org/Tiles/maplint/${z}/${x}/${y}.png"
      ];
      options = OpenLayers.Util.extend({numZoomLevels: 18, isBaseLayer: false, visibility: false}, options);
      var newArguments = [name, url, options];
      OpenLayers.Layer.OSM.prototype.initialize.apply(this, newArguments);
  },

  CLASS_NAME: "OpenLayers.Layer.OSM.Maplint"
});
/* -------- OPENSTREETMAP SCRIPTS END -------- */



/* -------- FESTMAP SCRIPTS BEGIN -------- */

Festmap = {};
Festmap.Util = {};
Festmap.Constants = {
  markerWidth:21,
  markerHeight:28,
  offsetH:11,
  offsetW:0,
  maxResolution: 156543.0339,
  minZoomLevel:10,
  maxZoomLevel:19, // used as numZoomLevels too
  defaultZoomLevel:12
}

OpenLayers.Util.alphaHack = function() {return false;} // disable IE6 transparency hack


Festmap.PanZoomBar = OpenLayers.Class(OpenLayers.Control.PanZoomBar, {
  buttonDown : function(evt) {
    if (!OpenLayers.Event.isLeftClick(evt)) {
      return;
    }
    var zoom = 0;
    switch (this.action) {
    case "panup":
      this.map.pan(0, -this.getSlideFactor("h"));
      break;
    case "pandown":
      this.map.pan(0, this.getSlideFactor("h"));
      break;
    case "panleft":
      this.map.pan(-this.getSlideFactor("w"), 0);
      break;
    case "panright":
      this.map.pan(this.getSlideFactor("w"), 0);
      break;
    case "zoomin":
      this.map.zoomIn();
      break;
    case "zoomout":
      zoom = this.map.getZoom() - 1;
      if (zoom >= Festmap.Constants.minZoomLevel) {
        this.map.zoomOut();
      }
      break;
    case "zoomworld":
      this.map.zoomToMaxExtent();
      break;
    }
    OpenLayers.Event.stop(evt);
  },

  /**
   * draws custom zoom controls
   */
  draw : function(px) {

    OpenLayers.Control.prototype.draw.apply(this, arguments);
    px = this.position.clone();
    this.buttons = [];
    var sz = new OpenLayers.Size(18, 18);
    var centered = new OpenLayers.Pixel(px.x + sz.w / 2, px.y);
    var wposition = sz.w;
    if (this.zoomWorldIcon) {
      centered = new OpenLayers.Pixel(px.x + sz.w, px.y);
    }
    this._addButton("panup", "north-mini.png", centered, sz);
    px.y = centered.y + sz.h;

    this._addButton("panleft", "west-mini.png", px, sz);
      if (this.zoomWorldIcon) {
      this._addButton("zoomworld", "zoom-world-mini.png", px.add(sz.w, 0), sz);
      wposition *= 2;
    }
    this._addButton("panright", "east-mini.png", px.add(wposition, 0), sz);
    this._addButton("pandown", "south-mini.png", centered.add(0, sz.h*2), sz);

    this._addButton("zoomin", "zoom-plus-mini.png", centered.add(0, sz.h*3 + 5), sz);

    centered = this._addZoomBar(centered.add(0, sz.h*4 + 5));
  //  var delta = -this.zoomStopHeight * (Festmap.Constants.maxZoomLevel - Festmap.Constants.minZoomLevel);
    this._addButton("zoomout", "zoom-minus-mini.png", centered, sz);
    return this.div;
  },

  _addZoomBar : function(centered) {
    var imgLocation = OpenLayers.Util.getImagesLocation();
    var id = this.id + "_" + this.map.id;
    var zoomsToEnd = (Festmap.Constants.maxZoomLevel) - 1
        - this.map.getZoom();
    var slider = OpenLayers.Util.createAlphaImageDiv(id, centered.add(
        -1, zoomsToEnd * this.zoomStopHeight), new OpenLayers.Size(20,
        9), imgLocation + "slider.png", "absolute");
    this.slider = slider;
    this.sliderEvents = new OpenLayers.Events(this, slider, null, true,
        {
          includeXY : true
        });
    this.sliderEvents.on( {
      "mousedown" : this.zoomBarDown,
      "mousemove" : this.zoomBarDrag,
      "mouseup" : this.zoomBarUp,
      "dblclick" : this.doubleClick,
      "click" : this.doubleClick
    });
    var sz = new OpenLayers.Size();
    sz.h = this.zoomStopHeight * (Festmap.Constants.maxZoomLevel - Festmap.Constants.minZoomLevel);

    sz.w = this.zoomStopWidth;
    var div = null;
    if (OpenLayers.Util.alphaHack()) {
      var id = this.id + "_" + this.map.id;
      div = OpenLayers.Util.createAlphaImageDiv(id, centered,
          new OpenLayers.Size(sz.w, this.zoomStopHeight), imgLocation
              + "zoombar.png", "absolute", null, "crop");
      div.style.height = sz.h + "px";
    } else {
      div = OpenLayers.Util.createDiv(
          'OpenLayers_Control_PanZoomBar_Zoombar' + this.map.id,
          centered, sz, imgLocation + "zoombar.png");
    }
    this.zoombarDiv = div;
    this.divEvents = new OpenLayers.Events(this, div, null, true, {
      includeXY : true
    });
    this.divEvents.on( {
      "mousedown" : this.divClick,
      "mousemove" : this.passEventToSlider,
      "dblclick" : this.doubleClick,
      "click" : this.doubleClick
    });
    this.div.appendChild(div);
    this.startTop = parseInt(div.style.top);
    this.div.appendChild(slider);
    this.map.events.register("zoomend", this, this.moveZoomBar);
    centered = centered.add(0, this.zoomStopHeight
        * (Festmap.Constants.maxZoomLevel - Festmap.Constants.minZoomLevel));
    return centered;
  },
  
  CLASS_NAME : "Festmap.PanZoomBar"
 });

Festmap.PermalinkHash = OpenLayers.Class(OpenLayers.Control.Permalink, {
  
  draw: function() {
    OpenLayers.Control.Permalink.prototype.draw.apply(this, arguments);
    $(this.element).hide();

    var $map = $(this.map.div);
    $map.bind("mousedown", _enableHash);
    function _enableHash()
    {
      Festmap.PermalinkHash.hashEnabled = true;
      $map.unbind("mousedown", _enableHash);
    }
  },
  updateLink: function(ev) {
    if (!Festmap.PermalinkHash.hashEnabled || (ev && ev.type != 'moveend'))
      return;
    var params = this.createParams();
    // update zoom, lon, lat if changed
    if (parseFloat(params.lon) && parseFloat(params.lat) && parseFloat(params.zoom))
    {
      Festmap.Util.updateLocationHash({lon: params.lon, lat: params.lat, zoom: params.zoom});
    }
  },
  CLASS_NAME : "Festmap.PermalinkHash"
});
Festmap.PermalinkHash.hashEnabled = false;

Festmap.Util.updateLocationHash = function (pars)
{
  // preserve hash old parameters
  var oldPars = Festmap.Util.getHashParameters();
  // update zoom, lon, lat if changed
  for (var parName in pars)
  {
    oldPars[parName] = pars[parName];
  }
  var hash = OpenLayers.Util.getParameterString(oldPars);
  if (hash && document.location.hash != '#' + hash)
    document.location.hash = hash;
}
Festmap.Util.getHashParameters = function()
{
  return OpenLayers.Util.getParameters('?' + document.location.hash.substring(1));
}

Festmap.Navigation = OpenLayers.Class(OpenLayers.Control.Navigation, {
   wheelDown : function(evt) {
     var zoom = this.map.getZoom() - 1;
     if (zoom >= Festmap.Constants.minZoomLevel) {
       this.wheelChange(evt, -1);
     }
   },
   draw : function() {
    if (this.handleRightClicks) {
      this.map.viewPortDiv.oncontextmenu = function() {
        return false;
      };
    }
    var clickCallbacks = {
      'dblclick' : this.defaultDblClick,
      'dblrightclick' : this.defaultDblRightClick,
      "click" : this.festMouseDown
    };
    var clickOptions = {
      'double' : true,
      'stopDouble' : true
    };
    this.handlers.click = new OpenLayers.Handler.Click(this, clickCallbacks,
        clickOptions);
    this.dragPan = new OpenLayers.Control.DragPan(OpenLayers.Util.extend( {
      map : this.map
    }, this.dragPanOptions));
    this.zoomBox = new OpenLayers.Control.ZoomBox( {
      map : this.map,
      keyMask : this.zoomBoxKeyMask
    });
    this.dragPan.draw();
    this.zoomBox.draw();
    this.handlers.wheel = new OpenLayers.Handler.MouseWheel(this, {
      "up" : this.wheelUp,
      "down" : this.wheelDown
    });
    this.activate();
    this.disableZoomWheel();
    var _this = this;

    $(this.map.div).bind('mousedown',function() {
      _this.festMouseDown();
    });
    $(this.map.div).bind('mouseleave',function() {
      _this.festMouseLeave();
    });
    this.mouseIsOut = true;
  },
  festMouseDown: function() {
    if(!this.zoomWheelEnabled) {
      this.enableZoomWheel();
    }
  },
  festMouseLeave: function() {
    if(this.zoomWheelEnabled) {
      this.disableZoomWheel();
    }
  },
  CLASS_NAME : "Festmap.Navigation"
 });


Festmap.Map = OpenLayers.Class(OpenLayers.Map, {

  initialize: function(div, options) {

    var controls = [
       new OpenLayers.Control.ArgParser(),
       new OpenLayers.Control.Attribution(),
       new OpenLayers.Control.ScaleLine({bottomOutUnits: 'km', bottomInUnits: "m"}),
       new Festmap.Navigation(div),
       new Festmap.PanZoomBar()
     ];
    if (options.permalinkHash)
      controls.push(new Festmap.PermalinkHash())
   
    options = OpenLayers.Util.extend(options, {
      projection: new OpenLayers.Projection("EPSG:900913"),
      displayProjection: new OpenLayers.Projection("EPSG:4326"),
      units: "m",
      maxExtent: new OpenLayers.Bounds(-20037508.34, -20037508.34, 20037508.34, 20037508.34),
      maxResolution: 156543.0339,
      numZoomLevels: Festmap.Constants.maxZoomLevel,
      controls: controls
    });
    
    var newArguments = [div, options];
    OpenLayers.Map.prototype.initialize.apply(this, newArguments);
    this.mapOptions = options;
  },
  jumpTo: function (lonLat, zoom) {
      this.setCenter(OpenLayers.Layer.SphericalMercator.forwardMercator(lonLat.lon, lonLat.lat), zoom);
      return false;
  },
  zoomTo : function(zoom) {
    if (this.isValidZoomLevel(zoom)) {
      if (zoom < this.minZoomLevel) {
        zoom = this.minZoomLevel;
      }
      this.setCenter(null, zoom);
    }
  },

  createVectorLayer: function() {
    var layer;
    var layerName = 'vector';

    layer = new OpenLayers.Layer.Vector(layerName);
    global_map.addLayers([layer]);
    global_layers[layerName] = layer;
    layer.setVisibility(true);
    layer.setZIndex(300);
    return layer;
  },
  
  getVectorLayer: function() {
    var layer;
    var layerName = 'vector';
    if(typeof global_layers[layerName] != 'undefined') {
      layer = global_layers[layerName];
    }
    if(!layer) {
      layer = this.createVectorLayer();
    }
    return layer;
  },

  getStreetFeatures: function(streetId) {
    var features = [];
    var layer = this.getVectorLayer();

    for (var i in layer.features) {
      var feature = layer.features[i];
      if (feature.streetId == streetId) {
        features.push(feature);
      }
    }
    return features;
  },

  addStreetFeatures: function(streetId, strPoints)
  {

    var polyline_style = {
      strokeColor: "#2260C2",
      strokeOpacity: 0.4,
      strokeWidth: 6
    };

    var layer = this.getVectorLayer();

    var features = [];
    
    var margin = null;
    var lines = strPoints.split(';');
    for (var line_index = 0; line_index < lines.length; line_index++)
    {
      if (!lines[line_index])
        continue;
      var coords = lines[line_index].split(')');
      var points = [];
      for (var i = 0; i < coords.length; i++)
      {
        coords[i] = coords[i].replace(/,?\(/, '');
        coords[i] = coords[i].replace(/[ ]+/, '');
        var coord = coords[i].split(",");

        if (!parseFloat(coord[0]) || !parseFloat(coord[1])) {
          continue;
        }
        var lonLat = new OpenLayers.LonLat(parseFloat(coord[0]), parseFloat(coord[1]));
        if (!margin) margin = lonLat;
        var _lonLat = OpenLayers.Layer.SphericalMercator.forwardMercator(lonLat.lon, lonLat.lat);
        points.push(new OpenLayers.Geometry.Point(_lonLat.lon, _lonLat.lat));
      }
      var feature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LineString(points), null, polyline_style);
      feature.streetId = streetId;
      layer.addFeatures([feature]);
      features.push(feature);
    }

    return features;
  },

  centerToStreetFeatures:  function(streetId) {
    this.zoomTo(16);
    var features = this.getStreetFeatures(streetId);
    if (features.length == 0) return;
    var visible = false;
    for (var i in features) {
      var feature = features[i];
      if (feature.onScreen()) {
        visible = true;
        break;
      }
    }
    if (!visible) {
      feature = features[0];
      var bounds = feature.geometry.bounds;
      global_map.zoomToExtent(bounds);
    }
  },
  centerToMarker:  function(markerId, zoom) {

    if (typeof zoom == 'number')
      this.zoomTo(zoom);

    var marker = document.getElementById(markerId);
    if (marker != null && !marker.onScreen()) {
      this.setCenter(marker.lonlat);
    }
  },

  CLASS_NAME : "Festmap.Map"
});

Festmap.Util.createDiv = function(html, theme) {
  
};


/**
 *  Wrapper class for OpenLayers.Marker.
 *  Allows access to marker's instance with document.getElementById.
 *
 */

Festmap.Marker = function(lonlat, html, theme, colorScheme, id, options) {
  // private
  var _this;
  var $_this;
  var _state = 'collapsed';
  var _mouseOver = false;
  var _animationTime = 100;
  var _popup;
  var $_popup;
  var _layer;
  var $_layer;
  var _lonlat = lonlat;
  var _options = {
    animation: true,
    expandable: true,
    sticky: false // marker remains opened (but not expanded) on mouse out
  }

  // background elements. We store them since IE6 can't hadle width/height:auto
  var _tl,_t,_tr, _l,_r,_bl,_b,_br,_c;
  var _content, $_content, _visibleContent;

  // public
  Festmap.Marker.prototype = {
    collapse : function(force) {
      _collapse(force);
    },
    expand: function() {
      _expandRight();
    },
    CLASSNAME: 'Festmap.Marker'
  }

  return _createMarker(html, theme, colorScheme, id, options);


  function _createMarker(html, theme, colorScheme, id, options) {
    _this = document.createElement("div");// creating an empty div is faster than OpenLayers.Util.createDiv()

    if (typeof id != "string" || id == "")
      id = "marker-" + id + "-" + Math.floor(Math.random() * 1000000);
    _this.id = id;
    $_this = $(_this);

    // copy all public methods and propreties
    _extendOpenlayersMarker();
    $.extend(_this, Festmap.Marker.prototype);
    _drawMarker(html, theme, colorScheme);

    if(options) {
      if (options.expandable === false)
        _options.expandable = false;
      if (options.sticky === true)
        _options.sticky = true;
      if (options.animation === false)
        _options.animation = false;
    }
    if (browser.isIE6down)
      _options.animation = false;// no animation for IE6
    
    return _this;
  }

  function _extendOpenlayersMarker() {
    $.extend(_this, OpenLayers.Marker.prototype); // extend first as Openalayers.Marker
    _this.lonlat = _lonlat;
    var icon = new Festmap.Icon();
    icon.imageDiv = _this;
    _this.icon = icon;
    this.events = new OpenLayers.Events(_this, _this.icon.imageDiv, null);
  }

  function _drawMarker(html, themeId, colorScheme) {
    
    if (!themeId) themeId = '1';
    if (!colorScheme) colorScheme = 'colored';
    var markers_folder = '/images/markers/';
    
    var bg_popup = 'url(' + markers_folder + 'marker-' + themeId + '.png)';
    var bg_center = 'url(' + markers_folder + 'marker-' + themeId + '-center.png)';
    var bg_hor = 'url(' + markers_folder + 'marker-' + themeId + '-hor.png)';
    var bg_vert = 'url(' + markers_folder + 'marker-' + themeId + '-vert.png)';

    if (browser.isIE6down) {
      var bg_popup = 'url(' + markers_folder + 'ie/' + 'marker-' + themeId + '.gif)';
      var bg_hor = 'url(' + markers_folder + 'ie/' + 'marker-' + themeId + '-hor.gif)';
      var bg_vert = 'url(' + markers_folder + 'ie/' + 'marker-' + themeId + '-vert.gif)';
    }

    _visibleContent = document.createElement("div");
    _visibleContent.className = "visible-content";

    _content = document.createElement("div");
    _content.className = "content";
    _content.innerHTML = html;
    $_content = $(_content);
    _visibleContent.appendChild(_content);

    var closeDiv = document.createElement("div");
    closeDiv.className = 'close ';
    closeDiv.style.backgroundImage = bg_popup;
    _visibleContent.appendChild(closeDiv);
    

    _popup = document.createElement('div');
    _popup.className = 'marker ' + colorScheme;
    _this.appendChild(_popup);

    _tl = document.createElement('div');
    _tl.className = "tl";
    _popup.appendChild(_tl);
    _tl.style.backgroundImage = bg_popup;

    _t = document.createElement('div');
    _t.className = "t";
    _popup.appendChild(_t);
    _t.style.backgroundImage = bg_vert;

    _tr = document.createElement('div');
    _tr.className = "tr";
    _popup.appendChild(_tr);
    _tr.style.backgroundImage = bg_popup;

    _l = document.createElement('div');
    _l.className = "l";
    _popup.appendChild(_l);
    _l.style.backgroundImage = bg_hor;

    _r = document.createElement('div');
    _r.className = "r";
    _popup.appendChild(_r);
    _r.style.backgroundImage = bg_hor;

    _bl = document.createElement('div');
    _bl.className = "bl";
    _popup.appendChild(_bl);
    _bl.style.backgroundImage = bg_popup;

    _b = document.createElement('div');
    _b.className = "b";
    _popup.appendChild(_b);
    _b.style.backgroundImage = bg_vert;

    _br = document.createElement('div');
    _br.className = "br";
    _popup.appendChild(_br);
    _br.style.backgroundImage = bg_popup;

    _c = document.createElement('div');
    _c.className = "c";
    _popup.appendChild(_c);
    _c.style.backgroundImage = bg_center;
    _c.appendChild(_visibleContent);

    $_popup = $(_popup);

    _visibleContent.onmouseover =  _bufferMouseOver;
    _visibleContent.onclick =  _bufferMouseOver;
    _visibleContent.onmouseout =  _bufferMouseOut;
    if (browser.isIE6down) {
      _tl.onmouseover =  _bufferMouseOver;
      _tl.onclick =  _bufferMouseOver;
    }

    closeDiv.onclick = _collapse;
    
    _state = 'collapsed';
    _mouseOver = false;
  }

  function _bufferMouseOver() {
    _mouseOver = true;

    var timeout = 100;
    if(_state == 'collapsed') {
      setTimeout(function() {
        _executeEvent();
      },
      timeout);
    }
  }

  function _bufferMouseOut() {
    _mouseOver = false;
    if (_options.sticky === true) {
      return;
    }
    var timeout = 100;
    if(_state == 'expanded_right') {
      setTimeout(function() {
        _executeEvent();
      },
      timeout);
    }
  }

  function _executeEvent() {
    switch (_state) {
      case 'animating':
        break;
      case 'expanded_up':
        break;
      case 'expanded_right':
        if (_mouseOver === false) {
          _collapse();
        }
        break;
      case 'collapsed':
        if(_mouseOver === true) {
          _expandRight();
        }
        break;
    }
  }

  function _expandRight() {
    _registerAsExpanded();
    if (typeof _layer == 'undefined') {
      _layer = _this.parentNode;
      $_layer = $(_layer);
    }
    
    _mouseOver = true;
    if(_state != 'collapsed' || _state=='animating') {
      return;
    }
    
    _collapseOthers();
    _state = 'animating';
    $_popup.addClass('animating');
    var width = $_content.width();
    if (_options.animation) {
      $_popup.animate({'width':width + 40}, _animationTime, _finishExpandRight);
    }
    else {
      _popup.style.width = (width + 40) + "px";
      setTimeout(_finishExpandRight, _animationTime);
    }
    _updateIE6sDimensions();
  }

  function _finishExpandRight() {
    $_popup.removeClass('animating').addClass('expanded-right');
    setTimeout(function() {
      _state = 'expanded_right';
      $_content.bind('click', _expandUp)
    },
    100);
    $_layer.addClass('selected');
  }

  function _expandUp() {
    if (_options.expandable === false) {
      return;
    }
    if(_state != 'expanded_right' || _state=='animating') {
      return;
    }
    _state = 'animating';
    $_popup.removeClass('expanded-right').addClass('animating');
    var height = $_content.height();


    if (_options.animation) {
      $_popup.animate({height:height + Festmap.Constants.markerHeight}, _animationTime, _finishExpandUp);
    }
    else {
      _popup.style.height = (height + Festmap.Constants.markerHeight) + "px";
      setTimeout(_finishExpandUp, _animationTime);
    }
    _updateIE6sDimensions();
  }

  function _finishExpandUp() {
    $_popup.removeClass('animating').addClass('expanded-up');
    setTimeout(function() {
      _state = 'expanded_up';
      _updateIE6sDimensions();
      $_content.unbind('click');
    },
    1000);
  }

  function _collapse(force) {
    switch(_state) {
      case 'animating':
        if(!force) return;
        break;
      case 'collapsed':
        return;
      case 'expanded_up':
      case 'expanded_right':
        break;
    }
    _state = 'animating';

    if (_options.animation && !(force === true)) {
      $_popup.removeClass('expanded-up').removeClass('expanded-right').addClass('animating');
      $_popup.animate({height:Festmap.Constants.markerHeight}, _animationTime, function() {
        $_popup.animate({width:Festmap.Constants.markerWidth}, _animationTime, _finishCollapse)
      });
    }
    else {
      $_popup.removeClass('expanded-up').removeClass('expanded-right').addClass('animating');
      _popup.style.height = Festmap.Constants.markerHeight + "px";
      setTimeout(
        function() {
          _popup.style.width = Festmap.Constants.markerWidth + "px";
          setTimeout(_finishCollapse, _animationTime);
        },
        _animationTime);
      
    }
  }

  function _collapseOthers() {
    if (_options.sticky === true) return;
    if (typeof global_map._expanded_markers != 'object')
      return;
    for (var i in global_map._expanded_markers) {
      var el = global_map._expanded_markers[i];
      if(typeof el == 'object' && _this.id != el.id) {
        el.collapse(true);
      }
    }
  }

  function _finishCollapse() {
    _mouseOver = false;
    _state = 'collapsed';
    $_layer.removeClass('selected');
    $_popup.removeClass('animating').removeClass('expanded-up').removeClass('expanded-right');
    _updateIE6sDimensions();
    _registerAsCollapsed();
  }

  /**
   * Updates (only in IE6) width and height to elements with width or height set
   * to "auto".
   */
  function _updateIE6sDimensions() {
    // they should call this browser.isRetarded instead of isIE6down
    if (browser.isIE6down) {
      _updateIE6sDimension(_t, "t");
      _updateIE6sDimension(_l, "l");
      _updateIE6sDimension(_c, "c");
      _updateIE6sDimension(_r, "r");
      _updateIE6sDimension(_b, "b");
      _updateIE6sDimension(_visibleContent, "visible-content");
    }
  }

  /**
   * Updates element's width and height for a given classname.
   * Note that you'll have to update this function each time you change marker's
   * stylesheets. E.g.:
   *  for
   *    .c {
   *       top:14px;
   *       right:8px;
   *       bottom:14px;
   *       left:3px;
   *    }
   *  you will have:
   *    el.style.height = (el.parentNode.scrollHeight - 28) + "px";
   *    el.style.width = (el.parentNode.scrollWidth - 11) + "px";
   */
  function _updateIE6sDimension(el, classname) {
    var width = null
    var height = null;
    switch (classname) {
      case "t":
        width = el.parentNode.scrollWidth - 21;
        break;
      case "l":
        height = el.parentNode.scrollHeight - 28;
        break;
      case "c":
        height = el.parentNode.scrollHeight - 28;
        width = el.parentNode.scrollWidth - 11;
        break;
      case "r":
        height = el.parentNode.scrollHeight - 28;
        break;
      case "b":
        width = el.parentNode.scrollWidth - 22;
        break;
      case "visible-content" :
        width = el.parentNode.scrollWidth + 2;
        height = el.parentNode.scrollHeight + 18;
        break;
    }
    if (height !== null) {
      height = (height > 0) ? height : "0";
      el.style.height = height + "px";
    }
    if (width !== null) {
      width = (width > 0) ? width : "0";
      el.style.width = width + "px";
    }
    
  }

  function _registerAsCollapsed() {
    if (typeof global_map._expanded_markers != 'object'
        || typeof global_map._expanded_markers.length == 'undefined')
      global_map._expanded_markers = new Array();
    
      global_map._expanded_markers[_this.id + ""] = undefined;
  }

  function _registerAsExpanded() {
    if (typeof global_map._expanded_markers != 'object'
        || typeof global_map._expanded_markers.length == 'undefined')
      global_map._expanded_markers = new Array();
    
    // cache marker's state
    global_map._expanded_markers[_this.id + ""] = _this;
  }
};


Festmap.Icon =
  OpenLayers.Class(OpenLayers.Icon, {
  initialize : function() {
    this.url = '';
    this.size = new OpenLayers.Size(Festmap.Constants.markerWidth, Festmap.Constants.markerHeight);
    this.offset = new OpenLayers.Pixel(0, -(this.size.h + Festmap.Constants.offsetH));

    this.calculateOffset = function(size) {
      return new OpenLayers.Pixel(0, -(size.h + Festmap.Constants.offsetH));
    };
  }

});


Festmap.Mapnik = OpenLayers.Class(OpenLayers.Layer.OSM, {

    initialize: function(name, options) {
        var url = [
            "http://a.tile.openstreetmap.org/${z}/${x}/${y}.png",
            "http://b.tile.openstreetmap.org/${z}/${x}/${y}.png",
            "http://c.tile.openstreetmap.org/${z}/${x}/${y}.png"
        ];
        options = OpenLayers.Util.extend({ 
          numZoomLevels: Festmap.Constants.maxZoomLevel,
          maxResolution: Festmap.Constants.maxResolution,
          minZoomLevel: Festmap.Constants.minZoomLevel,
          maxZoomLevel: Festmap.Constants.maxZoomLevel,
          units: "m",
          projection: new OpenLayers.Projection("EPSG:900913"),
          displayProjection: new OpenLayers.Projection("EPSG:4326")
        }, options);
        var newArguments = [name, url, options];
        OpenLayers.Layer.OSM.prototype.initialize.apply(this, newArguments);
    },
    name : "Festmap",

    CLASS_NAME: "Festmap.Mapnik"
});
/* -------- FESTMAP SCRIPTS END -------- */



/* -------- MAP SCRIPTS BEGIN -------- */
function setMapviewType(elem, map, updateHash) 
{
  if (elem.className.indexOf('selected') >= 0)
    return;
  if (typeof global_baseLayers != 'object')
    return;

  if (!map)
    map = window.global_map;
  if (!map)
    return;

  var $elem = $(elem);
  var $container = $(elem.parentNode.parentNode);
  $container.find('.selected').removeClass('selected');
  $container.find('.map-view').each(function(i, el){
    if (el == elem) {
      var center = map.getCenter();
      var zoom = map.getZoom();
      if (i < global_baseLayers.length)
        global_baseLayers[i].setVisibility(true);
      map.setCenter(center, zoom, false, true);
      if (i < global_baseLayers.length)
        map.setBaseLayer(global_baseLayers[i]);
      $elem.addClass('selected');
    }
    else {
      if (i < global_baseLayers.length)
        global_baseLayers[i].setVisibility(false);
    }
  });
  // update hash if permalinkHash is enabled
  if (updateHash === true && map.mapOptions.permalinkHash === true)
  {
    var source = 'osm'
    if ($('#map-view-satellite').hasClass('selected'))
      source = 'sat';
    Festmap.Util.updateLocationHash({source: source});
  }
  return;
}

/**
 * Adds a marker to a layer when it is swhown for the first time (when
 * "visibilitychanged" is triggered).
 */
function addCachedMarker(layerName, lonLat, popup, options) {

  if (typeof(global_layers[layerName]) == 'undefined') {
    addLayer(layerName);
  }
  var layer = global_layers[layerName];
  layer.events.register(
      'visibilitychanged',
      this,
      _addMarker
    );
  function _addMarker() {
    // add markers when layer is first shown and unregister future calls
    if (layer.getVisibility() == true) {
      addMarker(layerName, lonLat, popup, options);
      layer.events.unregister('visibilitychanged', this, _addMarker);
    }
  }
}

/**
 * Adds a marker to a layer when it is swhown for the first time (when
 * "visibilitychanged" is triggered).
 */
function addDelayedMarker(layerName, lonLat, popup, options)
{
  if (typeof window.delayedMarkers == 'undefined')
    window.delayedMarkers = new Array();
  
  var _addMarker = function() {
      addMarker(layerName, lonLat, popup, options);
  }
  window.executionQueue.add(_addMarker);
}


ExecutionQueue = window.ExecutionQueue = function(delay)
{
  var queue = new Array();
  var _running = false;
  var _delay;

  ExecutionQueue.fn = ExecutionQueue.prototype =
  {
    init: function(delay) {
      _delay = delay;
      var _this = {};
      $.extend(_this, ExecutionQueue.fn);
      return _this;
    },
    add: function (fn) {
      queue.push(fn);
      if (!_running) _runNext();
    },
    setInterval: function(delay) {
      _delay = delay;
    },
    start: function() {
    },
    CLASSNAME: 'ExecutionQueue'
  }
  return new ExecutionQueue.fn.init(delay);

  function _runNext()
  {
    var fn = queue.shift();
    if (typeof fn != 'function') {
      _running = false;
      return;
    }
    _running = true;
    fn();
    setTimeout(_runNext, _delay);
  }
}

window.addMarkerQueue = new ExecutionQueue(25);
if (browser.isIE6down)
  window.addMarkerQueue.setInterval(200);
else if(browser.isIE7down)
  window.addMarkerQueue.setInterval(50);





function addMarker(layerName, lonLat, popup, options) {
  if (mapIsNull()) return;
  
  var popupContentHTML = '<h4 class="marker-title">'
      + popup.title+'</h4>'
      + ((typeof popup.thumbSrc == 'string')?('<a href="'+popup.link+'"><img src="'+popup.thumbSrc+'"></a>'):"")
      + (popup.link != '' ? '<a href="'+popup.link + '">' + popup.linkText + '</a>' : '');
  var _lonLat = OpenLayers.Layer.SphericalMercator.forwardMercator(lonLat.lon, lonLat.lat);

  var marker = new Festmap.Marker(_lonLat, popupContentHTML, popup.theme, popup.colorScheme, popup.id, options);

  if (typeof(global_layers[layerName]) == 'undefined') {
    addLayer(layerName);
  }
  var layer = global_layers[layerName];
  layer.addMarker(marker);
}

function mapIsNull() {
  return window.global_map === null ? true : false;
}

var markersShown = 0;

function toggleLayer(layerName) {
  if (mapIsNull()) return;
  var layer = global_layers[layerName];
  if (layer) {
    layer.setVisibility(!layer.visibility);
  }
}

function showLayer(layerName) {
  if (mapIsNull()) return;
  var layer = global_layers[layerName];
  if (layer && !layer.getVisibility()) {
    layer.setVisibility(true);
  }
}

function hideLayer(layerName) {
  if (mapIsNull()) return;
  var layer = global_layers[layerName];
  if (layer) {
    layer.setVisibility(false);
  }
}

function layerRemoveMarkers(layerName) {
  if (mapIsNull()) return;
  var layer = global_layers[layerName];
  if (layer != null) {
    for(var i=0; i<layer.markers.length; i++) {
      var marker = layer.markers[i];
      $(marker.icon.imageDiv).remove();
    }
    layer.markers = new Array();
  }
}

function layerExpandMarker(layerName, markerId, centerMap) {
  if (mapIsNull()) return;

  var marker = document.getElementById(markerId);
  if (marker != null)
  {
    if (centerMap !== false)
      global_map.centerToMarker(markerId);
    marker.expand();
  }
}

function layerCollapseMarker(layerName, markerId) {
  if (mapIsNull()) return;
  var layer = global_layers[layerName];

  var marker = document.getElementById(markerId);
  if (marker != null) {
    global_map.centerToMarker(markerId);
    marker.collapse();
  }
}

function layerCollapseAllMarkers(layerName) {
  if (mapIsNull()) return;
  var layer = global_layers[layerName];
  if (layer != null) {
    for(var i=0; i<layer.markers.length; i++) {
      var marker = layer.markers[i];
      marker.icon.imageDiv.collapse();
    }
  }
}

function layerExpandAllMarkers(layerName) {
  if (mapIsNull()) return;
  var layer = global_layers[layerName];
  if (layer != null) {
    for(var i=0; i<layer.markers.length; i++) {
      var marker = layer.markers[i];
      marker.icon.imageDiv.expand();
    }
  }
}


function createMap(elId, permalinkHash)
{
  var lonLat = new OpenLayers.LonLat(28.834139, 47.026039);
  if (typeof global_baseLayers != 'object')
    global_baseLayers = new Array();
  var defaultZoom = Festmap.Constants.defaultZoomLevel;
  var options = {};
  if (permalinkHash === true)
    options.permalinkHash = true;
  
  var map = new Festmap.Map(elId, options);
  var mapnikLayer = new Festmap.Mapnik("Mapnik", {
    isBaseLayer: true
  });

  global_baseLayers.push(mapnikLayer);
  map.addLayer(mapnikLayer);

  if (typeof G_SATELLITE_MAP != 'undefined') {
    var gmapLayer = new OpenLayers.Layer.Google("GMaps", {
      'sphericalMercator': true,
      type: G_SATELLITE_MAP
    });
    global_baseLayers.push(gmapLayer);
    map.addLayer(gmapLayer);
  }
  map.setBaseLayer(mapnikLayer);

  if (permalinkHash === true)
  {
    var pars = Festmap.Util.getHashParameters()
    if (pars.lon && pars.lat && pars.zoom)
    {
      lonLat = {
        lon: parseFloat(pars.lon),
        lat: parseFloat(pars.lat)
      }
      defaultZoom = parseInt(pars.zoom);
      // prevent map from zooming to marker/street when displaying address given
      // in hash. Hash lonlat has a bigger priority.
      if (pars.address)
        window.dontZoomOnFirstSearch = true;
    }
    
    var source = pars.source;
    // change map source to either osm or satellite
    if (source == 'osm' && $('#map-view-map')[0])
      setMapviewType($('#map-view-map')[0], map, true);
    else if (source == 'sat' && $('#map-view-satellite')[0])
      setMapviewType($('#map-view-satellite')[0], map, true);
  }
  
  map.jumpTo(lonLat, defaultZoom);
  return map;
}

function addLayer(layerName, visible) {
  if (mapIsNull()) return;
  if(typeof global_layers[layerName] != 'undefined') return;
  var layer = new OpenLayers.Layer.Markers(layerName, {projection: new OpenLayers.Projection("EPSG:4326"), visibility: true});
  global_map.addLayers([layer]);
  global_layers[layerName] = layer;

  layer.events.register(
    'visibilitychanged',
    this,
    function(ev) {
      var $cbx = $("#cbx-" + layerName);
      if (ev.object.getVisibility())
        $cbx.attr('checked', "checked");
      else
        $cbx.removeAttr('checked');
    }
  );


  layer.setVisibility(visible);
  if (layer.visibility) {
    $('#cbx-' + layerName).attr("checked", "checked");
  }
  else {
    $('#cbx-' + layerName).attr("checked", null);
  }
}

function centerMap(lon, lat, zoom)
{
  if (mapIsNull()) return;
  var lonLat = new OpenLayers.LonLat(lon, lat);
  if(!zoom) zoom = 14;
  global_map.jumpTo(lonLat, zoom);
}

function zoomToExtent(min_lon, min_lat, max_lon, max_lat, zoom_dif)
{
  if (mapIsNull()) return;
  if (window.dontZoomOnFirstSearch === true)
  {
    window.dontZoomOnFirstSearch = false;
    return;
  }
  var bounds = new OpenLayers.Bounds();
  bounds.extend(new OpenLayers.LonLat(min_lon, min_lat));
  bounds.extend(new OpenLayers.LonLat(max_lon, max_lat));
  bounds.transform(
      new OpenLayers.Projection("EPSG:4326"),     // coordinates are in lon/lat
      global_map.getProjectionObject()
    );
  global_map.zoomToExtent(bounds);
  if (!zoom_dif){zoom_dif=0;}
  var zoom = global_map.getZoomForExtent(bounds) + zoom_dif;
  if (zoom > 17) global_map.zoomTo(17)
  else {global_map.zoomTo(zoom);}
}

function toggleMapSize() {
  if (mapIsNull()) return;
  var $map = $("#map-holder");
  var $toggle_map_size = $("#toggle-map-size");
  if ($toggle_map_size.hasClass("open")) {
    $("#toggle-map-size").removeClass("open").addClass("close");
    $map.height(450);
    $('#map-holder').find('.map-shadow').find('.shadow-left').css({height: "450px"});
    global_map.updateSize();
  }
  else {
    $("#toggle-map-size").removeClass("close").addClass("open");
    $map.height(200);
    $('#map-holder').find('.map-shadow').find('.shadow-left').css({height: "200px"});
    global_map.updateSize();
  }
}

function navigateMap(el)
{
  var regions = new Array();
  regions['botanica'] = {'lon':'28.857485386223', 'lat':'46.9862982565'};
  regions['telecentru'] = {'lon':'28.818303676911', 'lat':'47.0000560643'};
  regions['centru'] = {'lon':'28.833796116222', 'lat':'47.023699506951'};
  regions['riscani'] = {'lon':'28.863193126827', 'lat':'47.04967181221'};
  regions['ciocana'] = {'lon':'28.890229793602', 'lat':'47.048151259974'};
  regions['buiucani'] = {'lon':'28.785173031191', 'lat':'47.035166317296'};

  if (typeof regions[el.value] != 'undefined') {
    centerMap(regions[el.value].lon, regions[el.value].lat, 14);
  }
}

function selectPoi(el, poiId, address, centerMap)
{
  /*
  // 24.05.2011 - url hash disabled for pois. They used to overwrite the street search
  // results in the url
  if (address && Festmap.PermalinkHash && Festmap.PermalinkHash.hashEnabled)
    Festmap.Util.updateLocationHash({address: address});
  */
  $('#search-results-content').find('.selected').removeClass('selected');
  clearPolylines();
  $(el).parent().addClass('selected');
  layerCollapseAllMarkers('search');

  if (centerMap !== false)
  {
    // dont zoom to marker since we already zoomed to lonlat coordinates taken from hash
    if (window.dontZoomOnFirstSearch === true)
    {
      window.dontZoomOnFirstSearch = false;
      layerExpandMarker('search', poiId, false);
    }
    else
      layerExpandMarker('search', poiId, true);
  }
}

function toggleSearchResults() {
  var $btn = $('#toggle-results-container');
  if ($btn.hasClass('collapsed')) {
    showSearchResults();
  }
  else {
    hideSearchResults();
  }
}

function hideSearchResults() {
  var $container = $("#search-results-container");
  var $btn = $('#toggle-results-container');
  var $map = $('#map-holder');
  $container.removeClass('expanded').addClass('collapsed');
  $btn.addClass('collapsed');
  $map.addClass('expanded-hor').removeClass('collapsed-hor');
  global_map.updateSize();
  $('#search-results-content').hide();
}

function showSearchResults() {
  var $container = $("#search-results-container");
  var $btn = $('#toggle-results-container');
  var $map = $('#map-holder');
  $container.removeClass('collapsed').addClass('expanded');
  $btn.removeClass('collapsed');
  $map.removeClass('expanded-hor').addClass('collapsed-hor');
  global_map.updateSize();
  $('#search-results-content').show();
}

function selectPolyline(el, streetId, address, centerMap)
{
  /*
  // 24.05.2011 - url hash disabled for street. They used to overwrite the street search
  // results in the url
  if (address && Festmap.PermalinkHash && Festmap.PermalinkHash.hashEnabled)
    Festmap.Util.updateLocationHash({address: address});
  */
  if (mapIsNull()) return;
  var strPoints = global_streets[streetId];
  if (!strPoints) return;

  $('#search-results-content').find('.selected').removeClass('selected');
  $(el).parent().addClass('selected');
  clearPolylines();
  global_map.addStreetFeatures(streetId, strPoints);

  if (centerMap !== false)
  {
    // dont zoom to street since we already zoomed to lonlat coordinates taken from hash
    if (window.dontZoomOnFirstSearch === true)
      window.dontZoomOnFirstSearch = false;
    else
     global_map.centerToStreetFeatures(streetId);
  }
  
}

function clearPolylines(){
  var layerName = 'vector';
  var layer;

  if(typeof global_layers[layerName] != 'undefined') {
    layer = global_layers[layerName];
    layer.destroyFeatures();
  }
}

function showPlaceOnMap(typeId, id) {
  var markerId = "marker-" + id;
  var marker = document.getElementById(markerId);
//  if (marker == null) {
    showLayer('layer_' + typeId);
//  }
  scrollToMap();
  delayedExpandMarker(markerId);
}

function delayedExpandMarker(markerId, recursion)
{
  if (typeof recursion != 'number')
    recursion = 0;
  else
    recursion++;
  var marker = document.getElementById(markerId);
  if (marker) {
    global_map.centerToMarker(markerId, 16);
    marker.expand();
  }
  else if (recursion < 100)
    setTimeout(function() {delayedExpandMarker(markerId, recursion);}, 200);
    
}

function scrollToMap() {
  var map = document.getElementById("map-holder");
  var selectedPosX = 0;
  var selectedPosY = 0;

  while(map != null){
    selectedPosX += map.offsetLeft;
    selectedPosY += map.offsetTop;
    map = map.offsetParent;
  }

 window.scrollTo(selectedPosX, selectedPosY);
}


function closeMapFullscreen()
{
  if ($('#map-bar-container').hasClass('fullscreen'))
  {
    $(document.body).removeClass('fullscreen');
    $('#big-map-inner').append($('#map-bar-container'));
    $('#map-bar-container').removeClass('fullscreen');
    global_map.updateSize();
  }
}
function openMapFullscreen()
{
  if (!$('#map-bar-container').hasClass('fullscreen'))
  {
    $(document.body).addClass('fullscreen');
    $('#map-bar-container').addClass('fullscreen');
    $(document.body).append($('#map-bar-container'));
    global_map.updateSize();
  }
}




MapLegend = window.MapLegend = function() {

  var _this, $_this, $_btnLeft, $_btnDown, $_layerList;
  MapLegend.fn = MapLegend.prototype = {

    init: function()
    {
      _this = document.getElementById("map-layer-list-container");
      $_this = $(_this);
      
      $_btnLeft = $("#btn-layer-list-left").find(".bg-arrow");
      $_btnDown = $("#btn-layer-list-down").find(".bg-arrow");
      $_layerList = $("#map-layer-list");
      _bindEvents();
      
      $_btnLeft.css({height: "auto"});
      $_btnDown.css({width: "auto"});
      if ($_layerList[0].clientHeight == $_layerList[0].scrollHeight)
        $_this.removeClass("collapsed-vert");

      _redrawButtons();

      // copy all public methods and propreties
      $.extend(_this, MapLegend.fn);
      return _this;
    },

    CLASSNAME: 'MapLegend'
  }

  return new MapLegend.fn.init();

  function _bindEvents()
  {
    _this.onmousedown = _preventMapScroll;
    _this.ondblclick = _preventMapScroll;
    $_this.bind("scroll", _preventMapScroll);
    $_btnLeft.bind("click", _toggleCollapseHor);
    $_btnDown.bind("click", _toggleCollapseVert);
    $_this.bind("mouseenter", function(){
      $(window.global_map.div).trigger("mouseleave");
    });
//    _registerLayers();
  }

  function _preventMapScroll(ev)
  {
    if (ev && typeof ev.stopPropagation == 'function')
      ev.stopPropagation();
    else if (window.event)
      window.event.cancelBubble = true;
  }

  function _toggleCollapseVert()
  {
    $_layerList[0].style.height = null;
    _resetButtonDimensions();
    $_this.toggleClass('collapsed-vert');
    _redrawButtons();
  }
  function _toggleCollapseHor()
  {
    // if expanded both vert and hor collapse in both directions
    if (!$_this.hasClass('collapsed-hor') && !$_this.hasClass('collapsed-vert'))
      _toggleCollapseVert();
    
    var oldHeight = $_layerList.height();
    _resetButtonDimensions();
    $_this.toggleClass('collapsed-hor');
    $_layerList.height(oldHeight);
    _redrawButtons();
  }

  function _resetButtonDimensions()
  {
    $_btnLeft.css({height: "auto"});
    $_btnDown.css({width: "auto"});
  }
  function _redrawButtons()
  {
    if ($_layerList[0].clientHeight < $_layerList[0].scrollHeight || $_layerList.height() > 100)
    {
      $_btnDown.show();
      $_btnDown.width(parseInt($_this.width()) - 4);
    }
    else
    {
      $_btnDown.hide();
    }
    var newHeight = parseInt($_this.height() - 4);
    if (newHeight < 16)
      newHeight = 16;
    $_btnLeft.height(newHeight);
    
  }
}
/* -------- MAP SCRIPTS END -------- */