//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Request Headers Helpers
//
function CreateBasicRequestHeaders() {
  var reqHeaders  = new Array();
//  var reqHeaders  = [];

  reqHeaders["Content-Type"] = "application/x-www-form-urlencoded";
  reqHeaders["Content-length"] = 0;
  reqHeaders["Connection"] = "close";

//  reqHeaders.Content-Type = "application/x-www-form-urlencoded";
//  reqHeaders.Content-length = 0;
//  reqHeaders.Connection = "close";

  return reqHeaders;
}

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// XMLHTTPRequest
//
var xmlhttp = xmlhttpCreate();                                              // autocreate xmlhttp object when lib is included

function xmlhttpCreate()
{
  var xhro = false;                                                         // NULL?

  /*@cc_on @*/
  /*@if (@_jscript_version >= 5)
  try {
    xhro = new ActiveXObject("Msxml2.xhro");
  } catch (e) {
    try {
      xhro = new ActiveXObject("Microsoft.xhro");
    } catch (E) {
      xhro = false;
    }
  }
  @end @*/
  if (!xhro && typeof XMLHttpRequest != 'undefined') {
    try {
      xhro = new XMLHttpRequest();
    } catch (e) {
      xhro = false;
    }
  }
  if (!xhro && window.createRequest) {
    try {
      xhro = window.createRequest();
    } catch (e) {
      xhro = false;
    }
  }
  return xhro;
}

//
// Basic Get ------------------------------------------------------------------------------------------------------------------------------------------------------------------
//
var MSG_ERROR_XMLHTTP            = '<strong><em> Error:  xmlhttp = null</em></strong>';
var MSG_ERROR_XMLHTTP_READYSTATE = '<strong><em> Error:  xmlhttp.readyState Waiting...</em></strong>';

var MSG_LOAD_DEF                 = '<strong><em> Loading ... </em></strong>';
var MSG_DATARECEIVED             = '<strong><em> data received on xmlhttp object... </em></strong>';

//
// Helper, GetForID
//
function xmlhttpcallback_GetForID(eid, data)
{
  if (eid != '') { elemSetInnerHTML(eid, data); }
}

function xmlhttp_GetForID(eid, url, async)                                                         // Allowing async param for now... syncGetForID, asyncGetForID?
{
  elemSetInnerHTML(eid, MSG_LOAD_DEF);
  if (xmlhttp != null) {
    xmlhttp.open("GET", url, async);                                                               // GET or POST?
    result = true;                                                                                 // best we can do, success so far, no need to think we won't go all the way
    xmlhttp.onreadystatechange = function() {                                                      // inline callback definition, return can't be inside
      if (xmlhttp.readyState==4) {
        elemAppendInnerHTML(eid, MSG_DATARECEIVED);                                                // Append status message
        var FinalResponseText = xmlhttp.responseText;                                              // Preset our ResponseTest var to current return
        if(!xmlhttp.getResponseHeader("Date")) {                                                   // Caching, force re-get if date string empty, indicating cached return
          elemAppendInnerHTML(eid, '... Date was null, resubmitting');                             //   Append status message
          var newrequest = xmlhttpCreate();                                                        //   Create new xmlhttp object
          var ifModifiedSince = xmlhttp.getResponseHeader("Last-Modified");                        //   Grab Last-Modified date
          ifModifiedSince = (ifModifiedSince) ? ifModifiedSince : new Date(0);                     //   Either from response header or our very old base date (January 1, 1970)
          newrequest.open("GET", url, false);                                                      //   Send new request in sync mode, we are inside async callback
          newrequest.setRequestHeader("If-Modified-Since", ifModifiedSince);                       //   Update headers
          newrequest.send("");                                                                     //
          if(newrequest.status != 304) {                                                           //
            FinalResponseText = newrequest.responseText;                                           //  use new request
          }                                                                                        //
        }                                                                                          //
        xmlhttpcallback_GetForID(eid, FinalResponseText);                                          // Set the HTML element with our final responseText
      } else {
        elemSetInnerHTML(eid, MSG_ERROR_XMLHTTP_READYSTATE);
        result = false;
      }
    }
    xmlhttp.send(null)
  } else {
    elemSetInnerHTML(eid, MSG_ERROR_XMLHTTP);
    result = false;
  }
  return result;
}

//
// Core, Basic Get
//
function xmlhttp_Get(url, pCallback)
{
  if (xmlhttp) {
    xmlhttp.open("GET", url, true);
    xmlhttp.onreadystatechange = function() {
      //if (xmlhttp.readyState==4) {
      if (xmlhttp.readyState == 4 && xmlhttp.status == 200) {
        if (pCallback) pCallback(xmlhttp.responseText);
      } else {
        if (pCallback) pCallback(MSG_ERROR_XMLHTTP_READYSTATE);
      }
    }
    xmlhttp.send(null)
  } else {
    if (pCallback) pCallback(MSG_ERROR_XMLHTTP);
  }

/*
    xmlhttp.open("GET", url, true);
    xmlhttp.onreadystatechange = function() {
      if (xmlhttp.readyState==4) {
        if (pCallback != null) { pCallback(xmlhttp.responseText); }
      }
    }
    xmlhttp.send(null)
*/
}




//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Generalized ASync XMLHTTPRequest
//
// example:  asyncRequest('GET', 'foo.php', function(o) { console.log(o.responseText); }, postdata);
//
var asyncRequest = function() {
                     function handleReadyState(o, pCallback) {
                       if (o && o.readyState == 4 && o.status == 200) {
                         if (pCallback) pCallback(o);
                       } else {
                         if (pCallback) pCallback(MSG_ERROR_XMLHTTP_READYSTATE);
                       }
                     }

                     var getXHR = function() {
                                    var xmlhttp;
                                    try {
                                      xmlhttp = new XMLHttpRequest;          // return getXHR();
                                      getXHR = function() {
                                        return new XMLHttpRequest;
                                      };
                                    }
                                    catch(e) {
                                      var msxml = ['MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP', 'Microsoft.XMLHTTP'];
                                      for (var i = 0, len = msxml.length; i < len; ++i) {
                                        try {
                                          xmlhttp = new ActiveXObject(msxml[i]);
                                          getXHR = function() {
                                            return new ActiveXObject(msxml[i]);
                                          };
                                          break;
                                        }
                                        catch(e) {}
                                      }
                                    }
                                    return xmlhttp;
                                  };
                     return function(method, url, callback, postData, reqHeaders) {
                              var xmlhttp = getXHR();
                              xmlhttp.onreadystatechange = function () { handleReadyState(xmlhttp, callback); };
                              xmlhttp.open(method, url, true);
                              //if (isArray(reqHeaders) && (reqHeaders.length > 0)) {
                              //if (reqHeaders) {
                              if (isArray(reqHeaders)) {
                                for (var i in reqHeaders) {
                                  xmlhttp.setRequestHeader(i, reqHeaders[i]);
                                  //alert(i + ' = ' + reqHeaders[i]);
                                }
                              }
                              //alert(postData);
                              xmlhttp.send(postData || null);
                              return xmlhttp;
                            };
                   }();



/*

function getResource(uri, data_callback, error_callback, timeout) {
    var tryAgain = function () {
      getResource(uri, data_callback, error_callback, timeout);
    }
    var r = new XMLHttpRequest();
    var timer = setTimeout(
        function() {
            r.abort();
            r.onreadystatechange = null;
            setTimeout(tryAgain, timeout);
        },
        timeout);
    r.open("GET", uri, true);
    r.onreadystatechange = function() {
        if (r.readyState != 4) {
            // Ignore non-loaded readyStates
            // ...will timeout if do not get to "Loaded"
            return;
        }
        clearTimeout(timer);  // readyState==4, no more timer
        if (r.status==200) {  // "OK status"
              data_callback(r.responseText);
        }
        else if (r.status==304) {
            // "Not Modified": No change to display
        }
        else if (r.status >= 400 && r.status < 500) {
            // Client error, probably bad URI
            error_callback(r)
        }
        else if (r.status >= 500 && r.status < 600) {
            // Server error, try again after delay
            setTimeout(tryAgain, timeout);
        }
        else {
            error_callback(r);
        }
    }
    r.send(null);
    return r;
}




*/

//
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//

function X2()
{


}


function X3(url, w, h)
{



}