// SpryHTMLPanel.js - version 0.4 - Spry Pre-Release 1.6.1
//
// Copyright (c) 2006. Adobe Systems Incorporated.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name of Adobe Systems Incorporated nor the names of its
//     contributors may be used to endorse or promote products derived from this
//     software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

var Spry; if (!Spry) Spry = {}; if (!Spry.Widget) Spry.Widget = {};

Spry.Widget.HTMLPanel = function(ele, opts)
{
  Spry.Widget.HTMLPanel.Notifier.call(this);

  this.element = Spry.Widget.HTMLPanel.$(ele);

  // evalScripts controls whether or not we execute any script that is within
  // an HTML fragment we load into the panel's container. The default value for
  // this comes from our global flag, but users can override this setting for
  // a specific HTMLPanel instance with an evalScripts constructor option.

  this.evalScripts = Spry.Widget.HTMLPanel.evalScripts;

  // These class names are used to identify content *inside* the panel's container
  // when the panel is first created. If the HTMLPanel finds any elements
  // with these class names, it will remove the elements from the document
  // and tuck away their content. The HTMLPanel will then inject this content
  // back into the its container at the appropriate time.
  //
  // This gives the designer an option for specifying content they want shown
  // when the HTMLPanel is loading content or has encountered an error.

  this.loadingContentClass = "HTMLPanelLoadingContent";
  this.errorContentClass = "HTMLPanelErrorContent";

  this.loadingStateContent = "";
  this.errorStateContent = "";

  // These class names are placed on the panel's container whenever the HTMLPanel
  // loads content, or has encountered an error. This is an alternative to specifying
  // content to use during loading and error states. Instead, the designer would simply
  // define CSS rules that use these class names to alter the appearance of the panel's
  // container.

  this.loadingStateClass = "HTMLPanelLoading";
  this.errorStateClass = "HTMLPanelError";

  // The current request that is pending completion.

  this.pendingRequest = null;

  Spry.Widget.HTMLPanel.setOptions(this, opts);

  // Find any content within the panel's container that is supposed to be
  // used for the loading and error states.

  var elements = this.element.getElementsByTagName("*");
  var numElements = elements.length;

  var errorEle = null;
  var loadingEle = null;

  var d = document.createElement("div");

  for (var i = 0; i < numElements && (!loadingEle || !errorEle); i++)
  {
    var e = elements[i];
    if (Spry.Widget.HTMLPanel.hasClassName(e, this.loadingContentClass))
      loadingEle = e;
    if (Spry.Widget.HTMLPanel.hasClassName(e, this.errorContentClass))
      errorEle = e;
  }

  if (loadingEle)
    this.loadingStateContent = Spry.Widget.HTMLPanel.removeAndExtractContent(loadingEle, this.loadingContentClass);
  if (errorEle)
    this.errorStateContent = Spry.Widget.HTMLPanel.removeAndExtractContent(errorEle, this.errorContentClass);
};

// Global switch that decides whether or not HTMLPanels execute
// script embedded within HTML fragments, after the fragment is inserted
// into the DOM. If false, no HTMLPanel will execute any script embedded
// within an HTML fragment.

Spry.Widget.HTMLPanel.evalScripts = false;

Spry.Widget.HTMLPanel.Notifier = function()
{
  this.observers = [];
  this.suppressNotifications = 0;
};

Spry.Widget.HTMLPanel.Notifier.prototype.addObserver = function(observer)
{
  if (!observer)
    return;

  // Make sure the observer isn't already on the list.

  var len = this.observers.length;
  for (var i = 0; i < len; i++)
  {
    if (this.observers[i] == observer)
      return;
  }
  this.observers[len] = observer;
};

Spry.Widget.HTMLPanel.Notifier.prototype.removeObserver = function(observer)
{
  if (!observer)
    return;

  for (var i = 0; i < this.observers.length; i++)
  {
    if (this.observers[i] == observer)
    {
      this.observers.splice(i, 1);
      break;
    }
  }
};

Spry.Widget.HTMLPanel.Notifier.prototype.notifyObservers = function(methodName, data)
{
  if (!methodName)
    return;

  if (!this.suppressNotifications)
  {
    var len = this.observers.length;
    for (var i = 0; i < len; i++)
    {
      var obs = this.observers[i];
      if (obs)
      {
        if (typeof obs == "function")
          obs(methodName, this, data);
        else if (obs[methodName])
          obs[methodName](this, data);
      }
    }
  }
};

Spry.Widget.HTMLPanel.Notifier.prototype.enableNotifications = function()
{
  if (--this.suppressNotifications < 0)
  {
    this.suppressNotifications = 0;
    Spry.Debug.reportError("Unbalanced enableNotifications() call!\n");
  }
};

Spry.Widget.HTMLPanel.Notifier.prototype.disableNotifications = function()
{
  ++this.suppressNotifications;
};

Spry.Widget.HTMLPanel.prototype = new Spry.Widget.HTMLPanel.Notifier();
Spry.Widget.HTMLPanel.prototype.constructor = Spry.Widget.HTMLPanel;

Spry.Widget.HTMLPanel.$ = function(ele)
{
  if (ele && typeof ele == "string")
    return document.getElementById(ele);
  return ele;
};

Spry.Widget.HTMLPanel.setOptions = function(dstObj, srcObj, ignoreUndefinedProps)
{
  if (srcObj)
  {
    for (var optionName in srcObj)
    {
      if (ignoreUndefinedProps && srcObj[optionName] == undefined)
        continue;
      dstObj[optionName] = srcObj[optionName];
    }
  }
};

Spry.Widget.HTMLPanel.addClassName = function(ele, className)
{
  ele = Spry.Widget.HTMLPanel.$(ele);
  if (!ele || !className || (ele.className && ele.className.search(new RegExp("\\b" + className + "\\b")) != -1))
    return;
  ele.className += (ele.className ? " " : "") + className;
};

Spry.Widget.HTMLPanel.removeClassName = function(ele, className)
{
  ele = Spry.Widget.HTMLPanel.$(ele);
  if (Spry.Widget.HTMLPanel.hasClassName(ele, className))
    ele.className = ele.className.replace(new RegExp("\\s*\\b" + className + "\\b", "g"), "");
};

Spry.Widget.HTMLPanel.hasClassName = function(ele, className)
{
  ele = Spry.Widget.HTMLPanel.$(ele);
  if (!ele || !className || !ele.className || ele.className.search(new RegExp("\\b" + className + "\\b")) == -1)
    return false;
  return true;
};

Spry.Widget.HTMLPanel.removeAndExtractContent = function(ele, className)
{
  var d = document.createElement("div");
  if (ele)
  {
    d.appendChild(ele);
    if (className)
      Spry.Widget.HTMLPanel.removeClassName(ele, className);
  }
  return d.innerHTML;
};

Spry.Widget.HTMLPanel.findNodeById = function(id, node)
{
  if (node && node.nodeType == 1 /* NODE.ELEMENT_NODE */)
  {
    if (node.id == id)
      return node;
    var child = node.firstChild;
    while (child)
    {
      var result = Spry.Widget.HTMLPanel.findNodeById(id, child);
      if (result)
        return result;
      child = child.nextSibling;
    }
  }
  return null;
};

Spry.Widget.HTMLPanel.disableSrcReferences = function (source)
{
  if (source)
    source = source.replace(/<(img|script|link|frame|iframe|input)([^>]+)>/gi, function(a,b,c) {
        // b=tag name, c=tag attributes
        return '<' + b + c.replace(/\b(src|href)\s*=/gi, function(a, b) {
          // b=attribute name
          return 'spry_'+ b + '=';
        }) + '>';
      });
  return source;
};

Spry.Widget.HTMLPanel.enableSrcReferences = function (source)
{
  source = source.replace(/<(img|script|link|frame|iframe|input)([^>]+)>/gi, function(a,b,c) {
      // b=tag name, c=tag attributes
      return '<' + b + c.replace(/\bspry_(src|href)\s*=/gi, function(a, b) {
        // b=attribute name
        return b + '=';
      }) + '>';
    });
  return source;
};

Spry.Widget.HTMLPanel.getFragByID = function(id, contentStr)
{
  var frag = Spry.Widget.HTMLPanel.disableSrcReferences(contentStr);
  var div = document.createElement("div");
  div.innerHTML = frag;

  frag = "";
  var node = Spry.Widget.HTMLPanel.findNodeById(id, div);
  if (node)
    frag = node.innerHTML;

  return Spry.Widget.HTMLPanel.enableSrcReferences(frag);
};

Spry.Widget.HTMLPanel.prototype.setContent = function(contentStr, id)
{
  var data = { content: contentStr, id: id };
  this.notifyObservers("onPreUpdate", data);

  // Observers are allowed to modify the data. Make sure
  // the fragment and id we use are from the data that was
  // past to our observers.

  contentStr = data.content;
  id = data.id;

  // If we have a valid id, extract the markup underneath
  // the element with that id from our html fragment.

  if (typeof id != "undefined")
    contentStr = Spry.Widget.HTMLPanel.getFragByID(id, contentStr);

  // Slam the html fragment into the DOM.

  Spry.Widget.HTMLPanel.setInnerHTML(this.element, contentStr, !this.evalScripts);

  this.removeStateClasses();

  this.notifyObservers("onPostUpdate", data);
};

Spry.Widget.HTMLPanel.prototype.loadContent = function(url, opts)
{
  if (!this.element)
    return;

  this.cancelLoad();

  if (!opts)
    opts = new Object;

  opts.url  = opts.url ? opts.url : url;
  opts.method = opts.method ? opts.method : "GET";
  opts.async  = opts.async ? opts.async : true;
  opts.id  = opts.id ? opts.id : undefined;

  var self = this;
  opts.errorCallback = function(req) { self.onLoadError(req); };

  this.notifyObservers("onPreLoad", opts);

  if (this.loadingStateContent)
    this.setContent(this.loadingStateContent);

  Spry.Widget.HTMLPanel.addClassName(this.element, this.loadingStateClass);
  this.pendingRequest = Spry.Widget.HTMLPanel.loadURL(opts.method, opts.url, opts.async, function(req){ self.onLoadSuccessful(req); }, opts);
};

Spry.Widget.HTMLPanel.prototype.cancelLoad = function()
{
  try
  {
    if (this.pendingRequest && this.pendingRequest.xhRequest)
    {
      var xhr = this.pendingRequest.xhRequest;
      if (xhr.abort)
        xhr.abort();
      xhr.onreadystatechange = null;
      this.notifyObservers("onLoadCancelled", this.pendingRequest);
    }
  }
  catch(e) {}
  this.pendingRequest = null;
};

Spry.Widget.HTMLPanel.prototype.removeStateClasses = function()
{
  Spry.Widget.HTMLPanel.removeClassName(this.element, this.loadingStateClass);
  Spry.Widget.HTMLPanel.removeClassName(this.element, this.errorStateClass);
};

Spry.Widget.HTMLPanel.prototype.onLoadSuccessful = function(req)
{
  this.notifyObservers("onPostLoad", req);
  this.setContent(req.xhRequest.responseText, req.id);
  this.pendingRequest = null;
};

Spry.Widget.HTMLPanel.prototype.onLoadError = function(req)
{
  this.notifyObservers("onLoadError", req);
  if (this.errorStateContent)
    this.setContent(this.errorStateContent);
  Spry.Widget.HTMLPanel.addClassName(this.element, this.errorStateClass);
  this.pendingRequest = null;
};

Spry.Widget.HTMLPanel.msProgIDs = ["MSXML2.XMLHTTP.6.0", "MSXML2.XMLHTTP.3.0"];

Spry.Widget.HTMLPanel.createXMLHttpRequest = function()
{
  var req = null;
  if (window.ActiveXObject)
  {
    while (!req && Spry.Widget.HTMLPanel.msProgIDs.length)
    {
      try { req = new ActiveXObject(Spry.Widget.HTMLPanel.msProgIDs[0]); } catch (e) { req = null; }
      if (!req)
        Spry.Widget.HTMLPanel.msProgIDs.splice(0, 1);
    }
  }
  if (!req && window.XMLHttpRequest) { try { req = new XMLHttpRequest(); } catch (e) { req = null; } }
  return req;
};

Spry.Widget.HTMLPanel.loadURL = function(method, url, async, callback, opts)
{
  var req = new Object;
  req.method = method;
  req.url = url;
  req.async = async;
  req.successCallback = callback;

  Spry.Widget.HTMLPanel.setOptions(req, opts);

  try
  {
    req.xhRequest = Spry.Widget.HTMLPanel.createXMLHttpRequest();
    if (!req.xhRequest)
      return null;

    if (req.async)
      req.xhRequest.onreadystatechange = function() { Spry.Widget.HTMLPanel.loadURL.callback(req); };

    req.xhRequest.open(method, req.url, req.async, req.username, req.password);

    if (req.headers)
    {
      for (var name in req.headers)
        req.xhRequest.setRequestHeader(name, req.headers[name]);
    }

    req.xhRequest.send(req.postData);

    if (!req.async)
      Spry.Widget.HTMLPanel.loadURL.callback(req);
  }
  catch(e) { if (req.errorCallback) req.errorCallback(req); req = null; }

  return req;
};

Spry.Widget.HTMLPanel.loadURL.callback = function(req)
{
  if (!req || req.xhRequest.readyState != 4)
    return;
  if (req.successCallback && (req.xhRequest.status == 200 || req.xhRequest.status == 0))
    req.successCallback(req);
  else if (req.errorCallback)
    req.errorCallback(req);
};

Spry.Widget.HTMLPanel.eval = function(str) { return eval(str); };

Spry.Widget.HTMLPanel.setInnerHTML = function(ele, str, preventScripts)
{
  if (!ele)
    return;
  if (!str) str = "";
  ele = Spry.Widget.HTMLPanel.$(ele);
  var scriptExpr = "<script[^>]*>(.|\s|\n|\r)*?</script>";
  ele.innerHTML = str.replace(new RegExp(scriptExpr, "img"), "");

  if (preventScripts)
    return;

  var matches = str.match(new RegExp(scriptExpr, "img"));
  if (matches)
  {
    var numMatches = matches.length;
    for (var i = 0; i < numMatches; i++)
    {
      var s = matches[i].replace(/<script[^>]*>[\s\r\n]*(<\!--)?|(-->)?[\s\r\n]*<\/script>/img, "");
      Spry.Widget.HTMLPanel.eval(s);
    }
  }
};