btg.js

LINUX下

	}
}

/* Called when the upload iframe has been loaded, either on first page load
 * or after an upload is complete. 
 */
function uploadDone()
{
	var file = document.getElementById('upload_input');
	var content = document.getElementById('upload_iframe').contentDocument;

	/* We only care about the contents if its a XMLDocument, not on default empty page load */
	if(content == null)
		return;
		
	/* This breaks on safari.... However, safari is fuckedup anyways since it doesnt run onLoad on the iframe
	when its reloaded... Opera does not know about XMLDocument either though... */
	if(!(content instanceof XMLDocument))
		return;

	/* Fetch the response object from the DOM */
	var response = content.getElementsByTagName('response')[0];
	if(!response)
	{
		alert("Invalid response from server, missing response. Upload failed.");
		return;
	}

	/* Check if any errors occured */
	var error = response.getElementsByTagName('error');
	if(error.length > 0)
	{
		var errStr = ""
		for(var i=0; i < error.length; i++)
			errStr+=error[i].childNodes[0].nodeValue+"\n";

		setStatus(errStr);
		file.value = '';
		return;
	}

	/* No errors occured, torrents should be uploaded and running. Erase file field and update the context list */
	file.value = '';
	refreshContextList();
}

/**
 * This function is called every second, is used for misc stuff like refresh, age counter etc.
 */
function timer()
{
	if(doAutoRefresh && isStatusIdle)
	{
		contextsAge++;

		var diff = refreshTimeout - contextsAge;

		if(isBlurred)
			document.getElementById('statusMessage').innerHTML = 'Window not on focus, wont update...';
		else if(diff <= 0)
		{
			refreshContextList();
		}
		else if(diff > 0)
			document.getElementById('statusMessage').innerHTML = 'Update in ' + (refreshTimeout - contextsAge)  + ' seconds.';
	}
	else
	{
		contextsAge = 0; 
	}

	clearTimeout(timerHandle);
	timerHandle = setTimeout(timer, 1000);
}

/**************************************************
 * Callback functions for the remote calls.
 **************************************************/

function cb_globallimit(response)
{
	setStatus("Global limits set.");
	setUIState(3);
}

function cb_globallimit_err(error, errStr)
{
	setStatus("Unable to set global limits.");
	setUIState(3);
}

function cb_globallimitstatus(response)
{
	var r_ull  = parseInt(getFirstChildValue(response, 'uploadLimit'));
	if (r_ull != noLimit)
	{
		ri_ull = parseInt(r_ull / bytesPerKiB);
	}
	else
	{
		ri_ull = noLimit;
	}

	var r_dll  = parseInt(getFirstChildValue(response, 'downloadLimit'));
	if (r_dll != noLimit)
	{
		ri_dll = parseInt(r_dll / bytesPerKiB);
	}
	else
	{
		ri_dll = noLimit;
	}

	var r_mull = parseInt(getFirstChildValue(response, 'maxuploads'));
	var r_mc   = parseInt(getFirstChildValue(response, 'maxconnections'));

	// Update the limit table.
	var eUl = document.getElementById('gupload');
	var eDl = document.getElementById('gdownload');
	var eMu = document.getElementById('gmaxuploads');
	var eMc = document.getElementById('gmaxconn');

	eUl.value = ri_ull;
	eDl.value = ri_dll;
	eMu.value = r_mull;
	eMc.value = r_mc;
}

function cb_globallimitstatus_err(error, errStr)
{
	setStatus("Unable to get global limit status...");
}

/**
 * Callback for btg_auth.
 * Called when a user has been authed successfully.
 */
function cb_auth(response)
{
	setStatus("");
	setUIState(2);
	sessionList();
}

/**
 * Error Callback for btg_auth.
 * Called when the auth failed.
 */
function cb_auth_err(error, errStr)
{
	setError(error, 'Failed to login: ' + errStr);
	document.frm_auth.username.focus();
}

/**
 * Callback and error callback for btg_deauth.
 * Called when a user has been logged out, both success and failure...
 */
function cb_deauth(response)
{
	setStatus("Logged out.");
	setUIState(1);
}

/**
 * Callback for btg_sessionList.
 * Called when a successfull list of sessions was retrieved. Display these in the listbox.
 */
function cb_sessionList(response)
{
	var sessions = response.getElementsByTagName('sessions')[0].getElementsByTagName('session');
	var list = document.getElementById('sessionlist');
	while(list.hasChildNodes())
		list.removeChild(list.childNodes[0]);
	for(var i=0; i < sessions.length; i++)
	{
		var session = sessions[i].childNodes[0].nodeValue;
		list.options[i] = new Option(session, session);
	}
	setStatus("");
}

/**
 * Error Callback for btg_sessionList.
 * Called when we failed to get a list of sessions, for example, when 
 * there are no sessions (?) or when daemon is down.
 */
function cb_sessionList_err(error, errStr)
{
	var list = document.getElementById('sessionlist');
	while(list.hasChildNodes())
		list.removeChild(list.childNodes[0]);
	setError(error, 'Could not list sessions: ' + errStr);
}

/**
 * Callback for btg_sessionAttach.
 * Called when a session was successfully attached.
 */
function cb_sessionAttach(response)
{
	setUIState(3);
	refreshContextList();
}

/**
 * Error Callback for btg_sessionAttach.
 * Called when we failed to attach to a session.
 */
function cb_sessionAttach_err(error, errStr)
{
	setError(error, 'Failed to attach to session: ' + errStr);
}

/**
 * Callback for btg_sessionSetup.
 * Called when a new session was successfully created.
 */
function cb_sessionSetup(response)
{
	setUIState(3);
	refreshContextList();
}

/**
 * Error Callback for btg_sessionSetup.
 * Called when we failed to create a session.
 */
function cb_sessionSetup_err(error, errStr)
{
	setError(error, 'Failed to create new session: ' + errStr);
}

/**
 * Callback for btg_sessionDetach.
 * Called when a session was successfully detached.
 */
function cb_sessionDetach(response)
{
	setUIState(2);
	clearContextList();
	sessionList();
}

/**
 * Error Callback for btg_sessionDetach.
 * Called when we failed to detach to a session.
 */
function cb_sessionDetach_err(error, errStr)
{
	setError(error, 'Failed to detach from session: ' + errStr);
}

/**
 * Callback for btg_sessionQuit.
 * Called when a session was successfully terminated.
 */
function cb_sessionQuit(response)
{
	setUIState(2);
	clearContextList();
	sessionList();
}

/**
 * Error Callback for btg_sessionQuit.
 * Called when we failed to terminate a session.
 */
function cb_sessionQuit_err(error, errStr)
{
	setError(error, 'Failed to terminate session: ' + errStr);
}

function cb_cleanAll(response)
{
	setStatus("Session cleaned...");
	refreshContextList();
}

function cb_cleanAll_err(error, errorStr)
{
	setError(error, 'Unable to clean session.');
}

/**
 * Callback for btg_contextStatus.
 * Called when a successfull status query was executed.
 */
function cb_contextStatus(response)
{
	setStatus("Parsing context response...");

	/* Fetch all contexts, create new Status objects for them (status.js) and let 
	 * updateContextTable do the work.
	 */
	var contexts = response.getElementsByTagName('contexts')[0];
	if(contexts == null)
	{
		setStatus("Server didnt provide any contexts!");
		return;
	}

	var newContextList = new Array();
	var strContexts = "";
	for(var i=0; i < contexts.getElementsByTagName('context').length; i++)
	{
		var s = new Status(contexts.getElementsByTagName('context')[i]);
		newContextList.push(s);
		if(strContexts == "")
			strContexts += s.contextID;
		else
			strContexts += ","+s.contextID;
	}

	updateContextTable(newContextList)
	contextsAge = 0;

	// Refresh limits
	if(strContexts != "")
		contextLimitStatus(strContexts);

	/* Updates done */
	setStatus("");
}

/**
 * Error Callback for btg_contextStatus.
 * Called when an error occured when context status was requested.
 */
function cb_contextStatus_err(error, errStr)
{
	setError(error, 'Failed to list contexts: '+errStr);
	canGetContexts = 0;
}

/**
 * Callback for btg_contextLimitStatus.
 * Called when a successfull limit status query was executed.
 */
function cb_contextLimitStatus(response)
{
	var limits = response.getElementsByTagName('limits')[0];

	for(var i=0; i < limits.getElementsByTagName('limit').length; i++)
	{
		var l = new Limit(limits.getElementsByTagName('limit')[i]);
		var e = document.getElementById('txtUploadLimit_'+l.contextID);
		if(l.uploadLimit == noLimit)
			e.value = "";
		else
			e.value = l.uploadLimit/bytesPerKiB;
		e = document.getElementById('txtDownloadLimit_'+l.contextID);
		if(l.downloadLimit == noLimit)
			e.value = "";
		else
			e.value = l.downloadLimit/bytesPerKiB;
		e = document.getElementById('txtSeedLimit_'+l.contextID);
		if(l.seedLimit == noLimit)
			e.value = "";
		else
			e.value = l.seedLimit;
		e = document.getElementById('txtSeedTimeout_'+l.contextID);
		if(l.seedTimeout == noLimit)
			e.value = "";
		else
			e.value = l.seedTimeout/60;
	}
}

/**
 * Error Callback for btg_contextLimitStatus.
 * Called when an error occured when context status was requested.
 */
function cb_contextLimitStatus_err(error, errStr)
{
	setError(error, 'Failed to get limit status: '+errStr);
}

/**
 * Callback for btg_contextLimit.
 * Called when a successfull limit save was executed.
 */
function cb_contextLimit(response)
{
	setStatus("");
}

/**
 * Error Callback for btg_contextStatus.
 * Called when an error occured when context status was requested.
 */
function cb_contextLimit_err(error, errStr)
{
	setError(error, 'Failed to set limit: '+errStr);
}

/**
 * Callback for btg_contextStart.
 * Called when a torrent was successfully started.
 */
function cb_contextStart(response)
{
	refreshContextList();
}

/**
 * Error Callback for btg_contextStart.
 * Called when a start operation fails.
 */
function cb_contextStart_err(error, errStr)
{
	setError(error, "Failed to start torrent: "+ errStr);
}

/**
 * Callback for btg_contextStop.
 * Called when a torrent was successfully stopped.
 */
function cb_contextStop(response)
{
	refreshContextList();
}

/**
 * Error Callback for btg_contextStop.
 * Called when a stop operation fails.
 */
function cb_contextStop_err(error, errStr)
{
	setError(error, "Failed to stop torrent: "+ errStr);
}

/**
 * Callback for btg_contextPeers.
 * Called when a list of peers is sent.
 */
function cb_contextPeers(response)
{
	var peers = new Array();
	for(var i=0; i < contexts.getElementsByTagName('peers').length; i++)
	{
		var p = new Peer(contexts.getElementsByTagName('peer')[i]);
		peers.push(p);
	}
	if(peers.length == 0)
		setStatus("No peer information available.");
	else
		alert(peers);
}

/**
 * Error Callback for btg_contextPeers.
 * Called when a peer list request fails.
 */
function cb_contextPeers_err(error, errStr)
{
	setError(error, "Failed to get peers list: "+ errStr);
}

/**
 * Callback for btg_contextAbort.
 * Called when a torrent was successfully deleted.
 */
function cb_contextAbort(response)
{
	refreshContextList();
}

/**
 * Error Callback for btg_contextAbort.
 * Called when a abort operation fails.
 */
function cb_contextAbort_err(error, errStr)
{
	setError(error, "Failed to delete torrent: "+ errStr);
}