function AJAXQueueSystem() {
    /// <summary>Something in here</summary>
    /// <field name="Transactions" type="AJAXTransactionCollection">Transactions for this queue system</field>
    /// <field name="Channels" type="Collection">Communication channels for this queue system</field>
    /// <field name="Events" type="Events">Events</field>    

    Object.Inherits(this, WebControl);

    this.Transactions = new AJAXTransactionCollection(this);

    this.Channels = new Collection();
    this.Channels.Parent = this;
    this.Channels.DefaultCollectionObject = __AJAXQS_TransactionChannel;
    this.Channels.Add = function (uCount) { if (ISNAN(uCount)) uCount = 1; for (var i = 0; i < uCount; i++) { this.Items.splice(this.Items.length, 0, new __AJAXQS_TransactionChannel(this.Parent)); } }

    this.Channels.Add(); // Add a default single channel


    /* Properties */
    var oJSCtl = this;

    this.SetStatus = function (msg) { AJAXQS_SetStatus(this, msg); }


    /* Bound Events */
    this.Events.Add("TRANSACTION_READY", __AJAXQS_TransactionReady);
    this.Events.Add("TRANSFERCOMPLETE", __AJAXQS_TransactionComplete)
    this.Events.Add("TRANSFERFAILED", __AJAXQS_TransactionFailed);
    this.Events.Add("TRANSFERCANCELLED", __AJAXQS_TransactionCancelled);

    this.__ScreenBlocker = null;
    this.__StatusDialog = null;
    this.__ScreenDialogImgRef = null;
    this.__ScreenDialogTextRef = null;
}

Cast.As.AJAXQueueSystem = function (val) {
    /// <summary>Returns a casted AJAXQueueSystem</summary>
    /// <param name="val" type="AJAXQueueSystem">Value to cast</param>
    /// <returns type="AJAXQueueSystem" />
    return val;
}


AJAXQueueSystem.prototype.toString = function () { return "[AJAX Queue System]" }

AJAXQueueSystem.prototype.Status = "IDLE";
AJAXQueueSystem.prototype.StatusObject = window;
AJAXQueueSystem.prototype.RemainingObject = window;
AJAXQueueSystem.prototype.QueueNumber = 0;
AJAXQueueSystem.prototype.DefaultTimeout = 120;
AJAXQueueSystem.prototype.DefaultChannel = null;
AJAXQueueSystem.prototype.AutoParseParams = true;
AJAXQueueSystem.prototype.DefaultStatusImage = "Controls/AJAX/loading-circle-brown.gif";
AJAXQueueSystem.prototype.DefaultStatusMessage = '';
AJAXQueueSystem.prototype.DisplayRemainingInStatus = true;
AJAXQueueSystem.prototype.AllowErrorThrow = false;


AJAXQueueSystem.prototype.__class = true;
AJAXQueueSystem.prototype.__Dispose = __AJAXQS_Dispose;

function __AJAXQS_Dispose() {
    for (var i = 0; i < this.Transactions.Items.length; i++) {
        this.Transactions.Items[i].__Dispose();
    }

    this.AJAXRequest.__Dispose();

    this.Channels.Parent = null;
    for (var i = 0; i < this.Channels.Items.length; i++)
        this.Channel.Items.splice(this.Channel.Items.length, 1);

    this.Transactions.Parent = null;
    this.Transactions = null
    this.AJAXRequest = null;
    this.StatusObject = null;
    this.__ScreenBlocker = null;
    this.__StatusDialog = null;
    this.__ScreenDialogImgRef = null;
    this.__ScreenDialogTextRef = null;
}


AJAXTransactionCollection.prototype.Cancel = __ATC_Cancel;
AJAXTransactionCollection.prototype.Add = __ATC_Add;
AJAXTransactionCollection.prototype.Remaining = __ATC_Remaining;
AJAXTransactionCollection.prototype.Current = null;

function AJAXTransactionCollection(pParent) {
    /// <summary>Transaction collection</summary>
    /// <field name="Parent" type="AJAXQueueSystem">QueueSystem this collection is bound to</field>
    /// <field name="DefaultCollectionObject" type="AJAXTransaction" />
    /// <field name="Current" type="Array">Current transactions(s)</field>

    Object.Inherits(this, Collection);                          // Inherit Instantiated Collection properties

    delete this.Add;                                    // Remove inherited 'Add' function

    this.Parent = pParent;
    this.DefaultCollectionObject = AJAXTransaction;

    this.__Total = 0;

    this.Current = null;
}



function __ATC_Remaining() {
    /// <summary>Returns the count of the remmaining transactions queued</summary>
    /// <returns type="Number" />
    return (this.Current == null) ? 0 : (this.Items.length + (this.__Total - this.Current.TransactionID)) - 1;
}

function __ATC_Add(fBuilder, fHandler, bBlocking, sStatusMessage, oParams, bAsync, fFailHandler, fCancelHandler) {
    /// <summary>Adds a new transaction. Specifying paramaters will make the transaction auto-start [Ready()]</summary>
    /// <param name="fBuilder"          type="Function" mayBeNull="true">Function that will be called to build the transaction</param>
    /// <param name="fHandler"          type="Function" mayBeNull="true">Function that will be called to handle the transaction return</param>
    /// <param name="bBlocking"         type="Boolean" mayBeNull="true">Specifying true makes the user unable to interact with the page</param>
    /// <param name="sStatusMessage"    type="String" mayBeNull="true">Message to show when blocking</param>
    /// <param name="oParams"           type="Object" mayBeNull="true">List of parameters to attach to the transaction</param>
    /// <param name="bAsync"            type="Boolean" mayBeNull="true">Set to false if you want to run a synchronouse operation, default is Async</param>
    /// <param name="fFailHandler"      type="Function" mayBeNull="true">Function that will be called when the transaction fails</param>
    /// <param name="fCancelHandler"    type="Function" mayBeNull="true">Function that will be called when the transaction is cancelled</param>
    /// <returns type="AJAXTransaction" />
    var o = new AJAXTransaction(this.Parent.QueueNumber++, this.Parent);
    this.__Total++;

    if (fBuilder != undefined && fHandler != undefined) {
        o.RequestBuilder = fBuilder;
        o.ResponseHandler = fHandler;


        if (oParams != undefined && oParams != null) {
            if (typeof (oParams) != 'object') {
                var e = new Error();
                e.message = 'Parameters should be passed in using the following syntax.\n "Transactions.Add([Function_Builder], [Function_Handler], {"VariableParam" : VariableParamValue, "StringParam" : "String value"}, [Function_FailHandler], [Function_CancelHandler]);"';
                e.description = e.message;
                throw e;
            }

            for (var n in oParams) {
                if (!oParams.hasOwnProperty(n)) continue;
                o.Params.Add(n, oParams[n]);
            }
        }

        if (bBlocking == true || bBlocking == false) o.Blocking = bBlocking;
        if (sStatusMessage != undefined && sStatusMessage != null) {
            o.StatusMessage = sStatusMessage;
        }

        if (fFailHandler != undefined) o.FailHandler = fFailHandler;
        if (fCancelHandler != undefined) o.CancelHandler = fCancelHandler;

        if (bAsync == true || bAsync == false) {
            o.Async = bAsync;
        }

        o.Ready();
    }

    return o;
}

function __ATC_Cancel() {
    /// <summary>Cancels all currently running and queued transations.</summary>
    var Channels = this.Parent.Channels.Items;

    for (var c = 0; c < Channels.length; c++) {
        var Channel = Channels[c];

        if (Channel.AJAXRequest.Status == "PROCESSING")
            Channel.AJAXRequest.Cancel();

        for (var i = 0; i < Channel.Queue.length; i++) {
            if (Channel.Queue[i].Status == "PROCESSING" || Channel.Queue[i].Status == "WAITING") {
                Channel.Queue[i].Status = "CANCELLED";
                Channel.Queue[i].Events.RaiseEvent("CANCELLED");
            }
        }

        if (Channel.__TimeoutHandle != null) {
            clearTimeout(Channel.__TimeoutHandle);
            Channel.__TimeoutHandle = null;
        }
    }
}



AJAXTransaction.prototype.toString = function () { return "[AJAX Transaction]" }
AJAXTransaction.prototype.Events = null;
AJAXTransaction.prototype.Channel = null;
AJAXTransaction.prototype.QueueChannel = null;
AJAXTransaction.prototype.Status = "INITIALISING";
AJAXTransaction.prototype.TransactionID = -1;
AJAXTransaction.prototype.Parent = null;
AJAXTransaction.prototype.StatusMessage = "";
AJAXTransaction.prototype.CompletedStatusMessage = "";
AJAXTransaction.prototype.Timeout = -1;
AJAXTransaction.prototype.Async = null;
AJAXTransaction.prototype.Blocking = false;
AJAXTransaction.prototype.CallBackOnly = false;
AJAXTransaction.prototype.StatusDialogImage = '';
AJAXTransaction.prototype.RequestBuilder = null;
AJAXTransaction.prototype.ResponseHandler = null;
AJAXTransaction.prototype.FailHandler = null;
AJAXTransaction.prototype.CancelHandler = null;
AJAXTransaction.prototype.Params = null;
AJAXTransaction.prototype.TransactionReady = null;
AJAXTransaction.prototype.EncodeResponse = false;

function AJAXTransaction(ID, oJSParent) {
    /// <summary>The Transaction object is used by the QueueSystem to interact with the server</summary>
    /// <param name="ID" type="Number">Unique ID of the transaction</param>
    /// <param name="oJSParent" type="AJAXQueueSystem" >Bound QueueSystem</param>
    /// <field name="Events" type="Events">Events for the transaction</field>
    /// <field name="Channel" type="__AJAXQS_TransactionChannel">Channel the transaction is bound to (if any)</field>
    /// <field name="QueueChannel" type="Number">Channel index the transaction is bound to (if any)</field>
    /// <field name="Status" type="String">Current status</field>
    /// <field name="TransactionID" type="Number">Same as ID</field>
    /// <field name="Parent" type="AJAXQueueSystem">Bound QueueSystem</field>
    /// <field name="StatusMessage" type="String">Message to show while blocking</field>
    /// <field name="CompletedStatusMessage" type="String">Message to show on window status bar when completed</field>
    /// <field name="Timeout" type="Number">Amount of time to wait before timing out.  Best not touched.</field>
    /// <field name="Async" type="Boolean">Whether to run in synchronous mode or not</field>
    /// <field name="Blocking" type="Boolean">Whether to block (show the status as a blocking status dialog)</field>
    /// <field name="CallBackOnly" type="Boolean">If set to True, the transaction will not try to run the handler.  This can be used to determine when a set of transactions running synchronously have been completed</field>
    /// <field name="StatusDialogImage" type="String">Image to show on the status dialog</field>
    /// <field name="RequestBuilder" type="Function">Function to be called when the transaction is being built</field>
    /// <field name="ResponseHandler" type="Function">Called when the transaction has completed</field>
    /// <field name="FailHandler" type="Function">Called when the transaction has failed</field>
    /// <field name="CancelHandler" type="Function">Called when the transaction is cancelled</field>
    /// <field name="Params" type="ICTWebParameterCollection">Collection of custom parameters to pass through.  All items are garbage collected to stop cyclic references</field>
    /// <field name="TransactionReady" type="Boolean">Used for determining whether the transation is ready.  Do NOT manually change this field.  To set a transaction as ready, use the Ready() function</field>
    /// <field name="EncodeResponse" type="Boolean">Used for determining whether the transation response should be hex encoded.  Use this if you are sending XML fragments.  It does cause a large decoding overhead however</field>

    this.Events = new Events();                 // Custom Events Object

    this.Channel = null; 					/* Transaction Request Sub-Channel to use */
    this.QueueChannel = null;
    this.Status = "INITIALISING"; 			/* Represents the current status of the transaction */
    this.TransactionID = ID; 				/* Transaction Unique Identifier */
    this.Parent = oJSParent; 				/* Bound Queue System Object */
    this.StatusMessage = oJSParent.DefaultStatusMessage; /* Message Displayed on the windows status screen while processing */
    this.CompletedStatusMessage = ""; 		/* Message Displayed after the transaction has completed */
    this.Timeout = oJSParent.DefaultTimeout; /* Default Timeout */
    this.EncodeResponse = false;
    this.Async = null;                 // Whether or not to run the transaction in async mode

    this.Blocking = false;
    this.CallBackOnly = false; 			/* If set to TRUE, the transaction will not try to run the handler */
    this.StatusDialogImage = oJSParent.DefaultStatusImage;
    this.RequestBuilder = null; 				/* Pointer to the function that will build the request, function interface must support: function([AJAXQueueSystem] oJSCtl, [AJAXTransaction] oTransaction)		*/
    this.ResponseHandler = null; 			/* Pointer to the function that will handle the response, function interface must support: function([AJAXTransaction] oTransaction, [AJAXRequest] oAJAXRequest) */
    /*		NOTE- [AJAXQueueSystem] AJAXRequest.Parent will be referend to the bound Ajax queue system */
    this.FailHandler = null;
    this.CancelHandler = null;

    this.Params = new Collection();
    this.Params.DefaultCollectionObject = CTWebParameter;
    /* Add() Overload */
    this.Params.Add = function (Name, Value) {
        var o = new CTWebParameter();
        o.Name = this.Add.arguments[0];
        o.Value = this.Add.arguments[1];

        this.Items.splice(this.Items.length, 0, o);
        return o;
    }

    /* Triggers AJAX Queue System to send this transaction - If its already processing, this transaction will be added to the queue*/
    this.TransactionReady = false;
}

Cast.As.AJAXTransaction = function (val) {
    /// <summary>Returns a casted AJAXTransaction</summary>
    /// <param name="val" type="AJAXTransaction">Value to cast</param>
    /// <returns type="AJAXTransaction" />
    return val;
}

AJAXTransaction.prototype.Ready = __AJAXQSTRANSACTION_Ready;
AJAXTransaction.prototype.__Dispose = __AJAXQSTRANSACTION_Dispose;
AJAXTransaction.prototype.Cancel = __AJAXQSTRANSACTION_Cancel;


function __AJAXQSTRANSACTION_Cancel(bDontCallChannel) {
    if (this.Status != "CANCELLED") {
        if (bDontCallChannel == true) {
            // Do nothing
        } else if (this.QueueChannel.Status == "PROCESSING") {
            this.QueueChannel.Cancel();
        }
    }

    this.Status = "CANCELLED";
    this.Events.RaiseEvent("CANCELLED", null);
}

function __AJAXQSTRANSACTION_Dispose() {
    this.Parent = null;
    this.RequestBuilder = null;
    this.ResponseHandler = null;
    this.Params = null;
}


function __AJAXQSTRANSACTION_Ready() {
    if (typeof (this.RequestBuilder) != "function") {
        var e = new Error();
        e.description = "No valid request builder has been specified for this transaction";
        throw e;
    }

    if (this.CallBackOnly != true && typeof (this.ResponseHandler) != "function") {
        var e = new Error();
        e.description = "No valid response handler has been specified for this transaction";
        throw e;
    }

    this.TransactionReady = true;
    this.Status = "WAITING";
    this.Events.RaiseEvent("READY");
    this.Parent.Events.RaiseEvent("TRANSACTION_READY", this)
}


__AJAXQS_TransactionChannel.prototype.toString = function () { return "[Transaction Channel]" }
function __AJAXQS_TransactionChannel(oJSParent) {
    this.Parent = oJSParent;
    this.Queue = new Array();

    var self = this;
    this.__TimoutCallBack = function () { __AJAXQS_Timeout(oJSParent, self); }
    this.__TimeoutHandle = null;

    this.Private = false; 		// If set to true this channel will only allow transactions if explicitly set on the transaction itself

    this.Status = "IDLE";

    this.CurrentTransaction = null;

    this.AJAXRequest = new AJAXRequestControl();
    this.AJAXRequest.Parent = this;
    this.AJAXRequest.Events = oJSParent.Events;

    this.ChannelNumber = function () { for (var c = 0; c < this.Parent.Channels.Items.length; c++) { if (this.Parent.Channels.Items[c] == this) return c } return -1; }
}
__AJAXQS_TransactionChannel.prototype.Cancel = __AJAXQS_TransactionChannel_Cancel;

function __AJAXQS_TransactionChannel_Cancel() {
    this.AJAXRequest.Cancel();

    if (this.Status != "IDLE") {
        this.Status = "IDLE";

        if (this.CurrentTransaction.Status == "PROCESSING")
            this.CurrentTransaction.Cancel(true);
    }

    //__AJAXQS_CheckTransactions(this.Parent, this);
}


function __AJAXQS_Timeout(oJSCtl, oChannel) {
    ///<summary>
    ///	<input name="oJSCtl"	type="object/AJAXQueueSystem"	required="yes"	default=""	description="Reference to the QueueSystem firing this event">
    ///	<description>
    ///		This function is fired when an AJAX Transaction has timed out.  This function works as an Event Delegate for internal use only.  It is used
    ///		used to abort and clean up the internal AJAXXfer control.  The user is also alerted to the timeout.
    ///	</description>
    ///</summary>


    oChannel.__TimeoutHandle = null;

    if (oChannel.CurrentTransaction != null) {
        oChannel.CurrentTransaction.Status = "FAILED";
    }

    try {
        oChannel.AJAXRequest.Cancel();
    } catch (err) {
        // Failed to abort ?
    }

    oChannel.Status = "IDLE";

    Msgbox("Your transaction has timed out.  You may no longer be connected to the internet, or the server has stopped responding.", vbCritical + vbOKOnly, "Timeout Experienced");

    __AJAXQS_CheckTransactions(oJSCtl, oChannel);
}


function __AJAXQS_TransactionReady(oAJAXTransaction) {
    ///<summary>
    ///	<input name="oAJAXTransaction"	type="object/AJAXTransaction"	required="yes"	default=""	description="Transaction Object">
    ///	<description>
    ///		This function is fired whenever an ajax transactions .Ready() is called.  It is used to jump-start the queueing system
    ///		if it has shut down because of inactivity.
    ///	</description>
    ///</summary>

    var iChannel = 0;
    var Channels = oAJAXTransaction.Parent.Channels;

    // Assign the Transaction to a data sub-channel
    if (oAJAXTransaction.Channel == null || isNaN(oAJAXTransaction.Channel)) {
        // Check to see if a default channel exists
        if (oAJAXTransaction.Parent.DefaultChannel != null) {
            // Assign to default channel
            iChannel = oAJAXTransaction.Parent.DefaultChannel;
        } else {
            // Assign to lowest transaction count	
            var iMin = 999;

            for (var c = 0; c < Channels.Items.length; c++) {
                if (Channels.Items[c].Private) continue;

                if (Channels.Items[c].Queue.length < iMin) {
                    iChannel = c;
                    iMin = Channels.Items[c].Queue.length;
                }
            }
        }

    } else {
        if (oAJAXTransaction.Channel > Channels.Items.length) {
            var err = new Error();
            err.description = "Invalid channel index passed to transaction.  The channel requested does not exist/is out of bounds."
            err.message = err.description;
            throw err;
        }
    }

    var oChannel = Channels.Items[iChannel];

    oAJAXTransaction.QueueChannel = oChannel;

    oChannel.Queue.splice(oChannel.Queue.length, 0, oAJAXTransaction);

    __AJAXQS_CheckTransactions(oAJAXTransaction.Parent, oChannel);
}


function __AJAXQS_CheckTransactions(oJSCtl, uChannel) {
    ///<summary>
    ///	<input name="oJSCtl"	type="object/AJAXQueueSystem"	required="yes"	default=""	description="Queue System object">
    ///	<input name="uChannel"	type="object/numeric"			required="yes"	default=""	description="Index of, or Actual Data SubChannel to check">
    ///	<description>
    ///		This function is used to check the current status of the QueueSystem.  If it is idle, it scans its list for the 
    ///		next transaction inline to be fired.  If none are found, it performs a cleanup and shuts the system down to save
    ///		resources.
    ///
    ///		uChannel *MUST* be passed in.  This makes the Check Transactions fire on a particular data channel.
    ///	</description>
    ///</summary>

    if (typeof (uChannel) == 'object') {
        // nothing, we already have the channel
    } else {
        // retrieve the channel from the QueueSystem.
        uChannel = oJSCtl.Channels.Items[uChannel];
    }

    var oChannel = uChannel; 		// In context data channel

    if (oChannel.Status != "IDLE") return;

    if (oJSCtl.__ScreenBlocker != null) {
        var bHide = true;

        for (var c = 0; c < oJSCtl.Channels.Items.length; c++)
            if (oJSCtl.Channels.Items[c].CurrentTransaction != null && oJSCtl.Channels.Items[c].Status == "PROCESSING") {
                bHide = false;
                break;
            }

        if (bHide) {
            oJSCtl.__ScreenBlocker.style.visibility = "hidden";
            oJSCtl.__StatusDialog.style.visibility = "hidden";
        }
    }

    var oAJAXTransaction = null;
    oChannel.CurrentTransaction = null;

    for (var i = 0; i < oChannel.Queue.length; i++) {
        if (oChannel.Queue[i].Status != "WAITING") continue;

        oAJAXTransaction = oChannel.Queue[i];
        break;
    }


    if (oAJAXTransaction == null) {
        oChannel.Status = "IDLE";
        // Nothings being done, Clean Up time!

        var bFinished = false;
        var oQueue = oChannel.Queue;

        while (!bFinished) {
            var iFound = -1;

            for (var i = 0; i < oQueue.length; i++) {
                var sStatus = oQueue[i].Status;

                if (sStatus != "WAITING" && sStatus != "PROCESSING") {
                    iFound = i;
                    try {
                        oQueue[i].__Dispose();
                        oQueue.splice(i, 1);
                    } catch (err) {
                    }
                    break;
                }
            }

            if (iFound == -1) bFinished = true;
        }

        oChannel.CurrentTransaction = null;

        __AJAXQS_CheckChannels(oJSCtl);

        oJSCtl.Events.RaiseEvent("STATUS_CHANGE_IDLE", oChannel);
        return;
    }

    oChannel.CurrentTransaction = oAJAXTransaction;

    oChannel.Status = "PROCESSING";
    oJSCtl.SetStatus(oAJAXTransaction.StatusMessage);
    oJSCtl.Events.RaiseEvent("STATUS_CHANGE_PROCESSING", oJSCtl);

    oChannel.AJAXRequest.Clear(); 							/* Clear old Request */
    oChannel.AJAXRequest.Async.Clear();

    if (!oJSCtl.AllowErrorThrow) {
        try {
            __AJAXQS_BuildAndSendRequest(oChannel, oAJAXTransaction, oJSCtl);
        }
        catch (err) {
            oChannel.Status = "IDLE";
            oAJAXTransaction.Status = "FAILED";

            /*
            if (oJSCtl.AllowErrorThrow) 
            {
            err.message = err.description;
            throw err;
            } 
            else 
            {
            */
            var sFunctionCode = oAJAXTransaction.RequestBuilder.toString();
            sFunctionCode = sFunctionCode.substr(sFunctionCode.indexOf(" "), sFunctionCode.indexOf("(") - sFunctionCode.indexOf(" "));

            alert("An error occurred on a transaction builder [" + sFunctionCode + "], the system returned the following error: \n\n" + err.description + "\n\nPlease contact VitalSoftware Technical Support for more information");
            //   }
        }
        finally {
            __AJAXQS_CheckTransactions(oChannel, oAJAXTransaction, oJSCtl);
        }
    }
    else {
        __AJAXQS_BuildAndSendRequest(oChannel, oAJAXTransaction, oJSCtl);
        __AJAXQS_CheckTransactions(oChannel, oAJAXTransaction, oJSCtl);
    }

}

function __AJAXQS_BuildAndSendRequest(oChannel, oAJAXTransaction, oJSCtl) {
    oAJAXTransaction.Events.RaiseEvent("PREBUILD");
    // Check if the async property has been set
    if (oAJAXTransaction.Async != null && (oAJAXTransaction.Async == true || oAJAXTransaction.Async == false)) oChannel.AJAXRequest.Async.Enabled = oAJAXTransaction.Async;
    if (oChannel.AJAXRequest.Async.Enabled) oChannel.AJAXRequest.Async.Timeout = oAJAXTransaction.Timeout;

    var buildRet = oAJAXTransaction.RequestBuilder(oJSCtl, oAJAXTransaction, oChannel.AJAXRequest); 	/* Build Request	 */
    oAJAXTransaction.Events.RaiseEvent("POSTBUILD", buildRet);


    if (buildRet == false || oAJAXTransaction.CallBackOnly == true) {
        // Cancel Request.
        oChannel.Parent.Events.RaiseEvent("TRANSFERCANCELLED", oChannel.AJAXRequest);
    } else {
        oChannel.AJAXRequest.EncodeResponse = oAJAXTransaction.EncodeResponse;
        oChannel.AJAXRequest.SendRequest(); 					/* Send Request		 */

        oAJAXTransaction.Status = "PROCESSING";

        if (oAJAXTransaction.Timeout > 0) {
            // Set timeout
            oChannel.__TimeoutHandle = setTimeout(oChannel.__TimoutCallBack, (oAJAXTransaction.Timeout * 1000));
        }
    }
}


function __AJAXQS_CheckChannels(oJSCtl) {
    ///<summary>
    ///	<input name="oJSCtl"	type="object/AJAXQueueSystem"	required="yes"	default=""	description="Queue System Object">
    ///	<description>
    ///		Checks to see if all the channels are idle, performs internal clean up if they are
    ///	</description>
    ///</summary>

    var oChannels = oJSCtl.Channels.Items;

    for (var c = 0; c < oChannels.length; c++) {
        if (oChannels[c].Status != "IDLE") {
            return; 		// Not idle, exit early
        }
    }

    // All idle, perform clean up
    var oTrns = oJSCtl.Transactions.Items;
    for (var t = 0; t < oTrns.length; t++)
        oTrns[t].__Dispose();

    // remove all transactions
    oTrns.splice(0, oTrns.length);

    // Raise QS idle event
    oJSCtl.Events.RaiseEvent("QUEUESYSTEM_IDLE", oJSCtl);
}

function AJAXXFER_InstantiateBlocker(oJSCtl) {
    ///<summary>
    ///	<input name="oJSCtl"	type="object/AJAXQueueSystem"	required="yes"	default=""	description="Queue System Object">
    ///	<description>
    ///		Creates a new screen blocker object.
    ///	</description>
    ///</summary>

    /* Blocker Constructor */
    var o = document.createElement("div");
    o.style.top = 0;
    o.style.left = 0;
    o.style.width = "100%";
    o.style.height = "100%";
    o.style.position = "absolute";
    o.style.backgroundColor = "#FFFFFF";
    o.style.display = "block";
    o.style.visibility = "hidden";
    o.style.filter = "progid:DXImageTransform.Microsoft.Alpha(opacity=60)";
    o.style.zIndex = 9999;
    oJSCtl.__ScreenBlocker = document.body.appendChild(o);

    /* Blocker Dialog Constructor */
    o = document.createElement("div");
    o.style.position = "absolute";
    o.style.display = "block";
    o.style.visibility = "hidden";
    o.style.top = 0;
    o.style.left = 0;
    o.style.width = 300;

    o.style.zIndex = 10000;
    oJSCtl.__StatusDialog = document.body.appendChild(o);

    var aOut = new Array(0);
    var idx = 0;


    aOut[idx++] = '	<table style="padding-top:0px; width: 100%; height: 100%; table-layout: fixed; filter:progid:DXImageTransform.Microsoft.Gradient(GradientType=0,StartColorStr=\'#FF3a7085\',EndColorStr=\'#ff0e2d3d\');" cellpadding=4 cellspacing=0>';
    aOut[idx++] = '		<tr>';
    aOut[idx++] = '			<td>';
    aOut[idx++] = '				<div valign=middle style="padding: 0px; width: 100%; height: 100%;">';
    aOut[idx++] = '				</div>';
    aOut[idx++] = '			</td>';
    aOut[idx++] = '		</tr>';
    aOut[idx++] = '	</table>';

    var s = aOut.join("");
    o.innerHTML = s;

    oJSCtl.__ScreenDialogContainer = o.children[0].children[0].children[0].children[0].children[0];

    //oJSCtl.__ScreenDialogImgRef = o.children[0].children[0].children[0].children[0].children[0].children[0].children[0].children[0].children[0].children[0];
    //oJSCtl.__ScreenDialogTextRef = o.children[0].children[0].children[0].children[0].children[0].children[0].children[0].children[0].children[1].children[0];
}


function AJAXQS_SetStatus(oJSCtl, sMessage) {
    ///<summary>
    ///	<input name="oJSCtl"	type="object/AJAXQueueSystem"	required="true"	default=""	description="Queue System object">
    /// <input name="sMessage"	type="String"	required="true"	default=""	description="Sets the current status of a queue system status display object">
    ///
    /// 	<output type="" default="" description="">
    ///
    ///	<description>
    ///	</description>
    ///</summary>

    var oDialog = oJSCtl.__StatusDialog;
    var oBlocker = oJSCtl.__ScreenBlocker

    var bBlocking = false;
    var Channels = oJSCtl.Channels.Items;
    var aMessages = new Array(0);
    var aImages = new Array(0);
    var n = -1;

    for (var c = 0; c < Channels.length; c++) {
        if (Channels[c].CurrentTransaction != null && Channels[c].CurrentTransaction.Blocking) {
            bBlocking = true;
            aMessages[++n] = Channels[c].CurrentTransaction.StatusMessage;
            aImages[n] = Channels[c].CurrentTransaction.StatusDialogImage;
        }
    }

    if (!bBlocking && aMessages.length == 0) {
        return;
    }

    if (bBlocking) {
        if (oDialog == null) {
            AJAXXFER_InstantiateBlocker(oJSCtl);
            oDialog = oJSCtl.__StatusDialog;
            oBlocker = oJSCtl.__ScreenBlocker
        }


        var t = (parseInt(document.body.clientHeight, 10) - 50) / 2;
        var l = (parseInt(document.body.clientWidth, 10) - 300) / 2;

        oBlocker.style.visibility = "visible";

        oDialog.style.left = l;
        oDialog.style.top = t;
        oDialog.style.visibility = "visible";

        var aOut = new Array(0);
        var idx = 0;

        aOut[idx++] = '<table cellpadding=5 cellspacing=0 style="padding-top:0px; width:100%;">';
        for (var i = 0; i < aMessages.length; i++) {
            aImages[i] = (aImages[i] && aImages[i].length == 0) ? '0009-doc_search.gif' : aImages[i];

            if (aMessages[i] == "" || aMessages[i] == null) aMessages[i] = "Loading, please wait...";

            aOut[idx++] = '<tr>';
            /*aOut[idx++] =		'<td style="display: block;">';
            aOut[idx++] =			'<img src="/CTWebImages/' + aImages[i] + '" style="width: 32px; height: 32px;">';
            aOut[idx++] =		'</td>';			*/
            aOut[idx++] = '<td style="color:white; border-bottom: 1px solid white; width: 100%; vertical-align: middle; text-align:center;">';
            aOut[idx++] = '<div style="color:white; font: 8pt Tahoma; font-weight: bold; padding-left: 5px; vertical-align: middle;">' + aMessages[i] + '</div>';
            aOut[idx++] = '</td>';
            aOut[idx++] = '</tr>';
            aOut[idx++] = '<tr>';
            aOut[idx++] = '<td style="text-align:center;"><marquee direction="right" scrolldelay="1"><img src="/CTWebImages/progbar2.gif" /></marquee></td>';
            aOut[idx++] = '</tr>';
            aOut[idx++] = '';
        }
        aOut[idx++] = '</table>';

        var sOut = aOut.join("");
        oJSCtl.__ScreenDialogContainer.innerHTML = sOut;

    } else {

        if (oJSCtl.StatusObject == oJSCtl.RemainingObject) {
            if (sMessage != "") sMessage += " - (" + oJSCtl.Transactions.Remaining() + ") Transactions remaining";
        } else if (oJSCtl.RemainingObject != null) {
            var RemMessage = "(" + oJSCtl.Transactions.Remaining() + ") Transactions remaining";

            if (oJSCtl.RemainingObject != window) {
                oJSCtl.RemainingObject.innerHTML = RemMessage;
            } else {
                window.status = RemMessage;
            }
        }

        if (oJSCtl.StatusObject != null) {
            switch (oJSCtl.StatusObject) {
                case window:
                    window.status = sMessage; 			/* Set status message */
                    break;

                default:
                    if (oJSCtl.StatusObject.tagName) {
                        oJSCtl.StatusObject.innerHTML = sMessage;
                    } else {
                        window.status = "Unsupported Status Object!";
                    }
            }
        }
    }

}


function __AJAXQS_TransactionFailed(oAJAXRequest) {
    ///<summary>
    ///	<input name="oAJAXRequest"	type="object/AJAXRequest"	required="true"	default=""	description="AJAXRequest object">
    ///	<description>
    ///		Event delegated function for when a transaction fails at the lowest level (server) and an error is thrown by the
    ///		by the AJAXRequest object itself.
    ///	</description>
    ///</summary>

    var oJSCtl = oAJAXRequest.Parent.Parent;
    var oChannel = oAJAXRequest.Parent;
    var oCurTransaction = oChannel.CurrentTransaction;
    oCurTransaction.Status = "FAILED";
    oCurTransaction.Events.RaiseEvent("FAILED");

    clearTimeout(oChannel.__TimeoutHandle);
    oChannel.__TimeoutHandle = null;

    oChannel.Status = "IDLE";

    if (oCurTransaction.FailHandler != undefined && oCurTransaction.FailHandler != null) {
        oCurTransaction.FailHandler(oCurTransaction, oAJAXRequest);
    }
    else {
        oAJAXRequest.ReportError();
    }

    __AJAXQS_CheckTransactions(oJSCtl, oChannel);
}

function __AJAXQS_TransactionCancelled(oAJAXRequest) {
    var oJSCtl = oAJAXRequest.Parent.Parent;
    var oChannel = oAJAXRequest.Parent;
    var oCurTransaction = oChannel.CurrentTransaction;

    oCurTransaction.Cancel();
    oJSCtl.SetStatus('Transaction Cancelled');

    /* Clean up memory in the transaction */
    oCurTransaction.__Dispose();
    __AJAXQS_CheckTransactions(oJSCtl, oChannel);
}

function __AJAXQS_TransactionComplete(oAJAXRequest) {
    ///<summary>
    ///	<input name="oAJAXRequest"	type="object/AJAXRequest"	required="true"	default=""	description="AJAXRequest object">
    ///	<description>
    ///		Event delegated function for when a transaction succeeds at the lowest level (server). 
    ///	</description>
    ///</summary>

    var oJSCtl = oAJAXRequest.Parent.Parent;
    var oChannel = oAJAXRequest.Parent;
    var oCurTransaction = oChannel.CurrentTransaction;

    clearTimeout(oChannel.__TimeoutHandle);
    oChannel.__TimeoutHandle = null;

    if (oCurTransaction.Status != "PROCESSING") {
        oJSCtl.Events.RaiseEvent("TRANSACTION_UNHANDLED", oAJAXRequest, oChannel);
        // Transaction has since been removed / cancelled (or something went horribly wrong...)
        oJSCtl.SetStatus("Transaction went unhandled");
    } else {
        oJSCtl.Events.RaiseEvent("TRANSACTION_COMPLETE", oCurTransaction, oChannel);


        if (oJSCtl.AllowErrorThrow == false) {
            try {
                __AJAXQS_ProcessTransactionComplete(oAJAXRequest, oCurTransaction);
            }
            catch (err) {
                var fName = oCurTransaction.ResponseHandler.toString();
                var ErrorDetails = '';

                for (var n in err) {
                    if (typeof (err[n]) == "function") continue;

                    ErrorDetails += n + ': ' + err[n] + '\n'
                }

                var sFunctionCode = oCurTransaction.ResponseHandler.toString();

                sFunctionCode = sFunctionCode.substr(sFunctionCode.indexOf(" "), sFunctionCode.indexOf("(") - sFunctionCode.indexOf(" "));
                alert("An error ocurred trying to run the response handler [" + sFunctionCode + "]:  \n\n" + ErrorDetails);
            }
            finally {
                oCurTransaction.Status = "COMPLETE";
                oCurTransaction.Events.RaiseEvent("COMPLETE", oCurTransaction, oAJAXRequest);
                oJSCtl.SetStatus(oCurTransaction.CompletedStatusMessage);

                /* Clean up memory in the transaction */
                oCurTransaction.__Dispose();
            }
        }
        else {
            __AJAXQS_ProcessTransactionComplete(oAJAXRequest, oCurTransaction);
            oCurTransaction.Status = "COMPLETE";
            oCurTransaction.Events.RaiseEvent("COMPLETE", oCurTransaction, oAJAXRequest);
            oJSCtl.SetStatus(oCurTransaction.CompletedStatusMessage);

            /* Clean up memory in the transaction */
            oCurTransaction.__Dispose();
        }

    }


    oChannel.Status = "IDLE";

    __AJAXQS_CheckTransactions(oJSCtl, oChannel);
}


function __AJAXQS_ProcessTransactionComplete(oAJAXRequest, oCurTransaction) {
    if (typeof (oCurTransaction.ResponseHandler) != "function") {
        throw new Error("No valid response handler has been assigned to this transaction.");
    }

    oCurTransaction.Events.RaiseEvent("PRERESPONSE", oCurTransaction, oAJAXRequest);
    oCurTransaction.ResponseHandler(oCurTransaction, oAJAXRequest);
    oCurTransaction.Events.RaiseEvent("POSTRESPONSE", oCurTransaction, oAJAXRequest);
}