PC Professionell 2005 March/PCpro_2005_03.ISO/files/firefox/fireftp-i18n.xpi/chrome/fireftp.jar/content/fireftp.js

JavaScript | 2005-01-13 | 199.1 KB | 5,935 lines

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is fireftp
 *
 * The Initial Developer of the Original Code is Mime Cuvalo
 * Portions created by the Initial Developer are Copyright (C) 2004
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *    Mime Cuvalo, http://www.chasaidthekitty.com/email.php?name=mime, original author
 *
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU Public License (the "GPL"), in which case the
 * provisions of the GPL are applicable instead of those above.
 * If you wish to allow use of your version of this file only
 * under the terms of the GPL and not to allow others to use your
 * version of this file under the MPL, indicate your decision by
 * deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL.  If you do not delete
 * the provisions above, a recipient may use your version of this
 * file under either the MPL or the GPL.
 *
 */

// yeah, all this code could be a lot more elegant, bite me

// NOTE: i've listed 'messy, messy, messy' in a couple places
// this code is messy but necessary b/c when shortening arrays
// if you are left with only one object, javascript will just
// give you the object and not an object inside of an array.
// thus the code 'stuff = new Array(stuff)' in case of this.
// are there better solutions?

// *************************************************************************************************
// *************************************** global variables ****************************************
// *************************************************************************************************

var welcomeMessage;
var isConnected = false;        // are we connected?
var isReady = false;            // are we busy writing/reading the control socket
var initialPath;                // path we go to first onload
var connectedHost;                // name of the host we connect to plus username
var control_instream;
var control_outstream;
var data_transport;
var data_outstream;
var datahost;
var dataport;                    // calculated from PASV command
var legitClose = true;            // are we the ones initiating the close or is it a network error
var isReconnecting;
var reconnectAttempts;
var data;                        // holds list data
var file_instream;
var data_remember;                // function to evaluate after data socket closes
var data_finished = true;        // is data socket finished?
var moreToRemember = "";        // function to evaluate after changing directories
var eventQueue = new Array;        // commands to be sent
var trashQueue = new Array;        // once commands are read, throw them away here
                                // but we might have to recycle these if there is an error

var remotesize;                    // total size for current remote directory
var remotecache = new Array;    // local cache
var remotedircache = new Array( {path:"/", open:true, empty:false, children:-1} );
var hiddenremotedircache = new Array;
var refreshRemote = false;        // are we refreshing?

var localsize;                    // total size for current local directory
var localAvailableDiskSpace;
var localdircache = new Array;
var hiddenlocaldircache = new Array;
var refreshLocal = false;        // are we refreshing?
var slash;                        // holds '/' or '\\' depending on local system

var localPasteFiles;            // local files to be pasted
var remotePasteFiles;            // remote files to be pasted
var localIsCut;                    // is the local paste a cut or copy (remote has only cut)

var strbundle;                    // i18n

var gLocalPath;
var gLocalTree;
var gLocalDirTree;
var gRemotePath;                // document.getElementById() references
var gRemoteTree;
var gRemoteDirTree;
var gConnectButton;

var networkTimeoutID = 0;        // a counter increasing with each write to the control socket

var prefAsciiFiles = new Array();        // needed to workaround bug #7700

var welcomemode;
var errormode;
var refreshmode;
var passwordmode;
var sessionsmode;
var hiddenmode;
var interfacemode;
var sslmode;                    // preferences (UI overhaul for 0.85)
var network;
var timeoutmode;
var retry;
var attempts;
var port;
var destructmode;
var filemode;
var loadmode;
var logmode;
var pasvmode;
var debugmode;
var proxymode;

var activeCmd;                    // for active mode - way too messy for my tastes
var activeRemember;                // find a better way by 1.0
var activeRemember2;
var activeRemember3;

var emptyFileSoCloseLater;        // uploading empty files was causing problems

// *************************************************************************************************
// ****************************************** startup/close ****************************************
// *************************************************************************************************

function startup()
{
    // set up references
    strbundle = document.getElementById("strings");
    gLocalPath = document.getElementById('localpath');
    gLocalTree = document.getElementById('localtree');
    gLocalDirTree = document.getElementById('localdirtree');
    gRemotePath = document.getElementById('remotepath');
    gRemoteTree = document.getElementById('remotetree');
    gRemoteDirTree = document.getElementById('remotedirtree');
    gConnectButton = document.getElementById('connectbutton');

    gConnectButton.label = strbundle.getString("connectButton");
    gConnectButton.setAttribute('command','cmd_connect');
    gConnectButton.setAttribute('accesskey', strbundle.getString("connectAccess"));

    // load preferences
    readPreferences();

    // for bug #7731 we need to help those who have stuck folder views
    if (gRemoteDirTree.collapsed)
        document.getElementById('remotesplitter').state = "collapsed";
    if (gLocalDirTree.collapsed)
        document.getElementById('localsplitter').state = "collapsed";

    var el = document.getElementById('cmdlog').appendItem("       fireFTP 0.86.2", "       fireFTP 0.86.2");
    el.setAttribute('style', 'color:blue;font-weight:bold');

    // rev the engine
    if (gLocalPath.value != "")
        onLocalPathChange();

    document.getElementById('host').focus();
}
function disconnect()
{
    // haven't connected yet, changed our minds and decided to invade canada instead (just playin' canada...naw, i'm serious)
    if (!isConnected && eventQueue.length && eventQueue[0].cmd == "welcome")
    {
        document.getElementById('statusbytes').label = "";
        document.getElementById('statusmeter').setAttribute("mode", "determined");
        document.getElementById('statusmeter').setAttribute("value", "0%");
        gConnectButton.label = strbundle.getString("connectButton");
        gConnectButton.setAttribute('command','cmd_connect');
        gConnectButton.setAttribute('accesskey', strbundle.getString("connectAccess"));
        eventQueue = new Array;

        // you're young, try everything
        try {
            control_instream.close();
        }catch(ex){ debug(ex,1); }
        try {
            control_outstream.close();
        }catch(ex){ debug(ex,2); }
    }
    else if (isConnected)
    {
        if (eventQueue.length)
            if (!confirm(strbundle.getString("reallyclose")))
                return;
        legitClose = true;    // this close() is ok, don't try to reconnect
        gRemotePath.value = '/';
        remotePathFocus = '/';
        close();
    }
}
function close()
{
    if (isConnected)
    {
        eventQueue.unshift( { cmd: "goodbye", parameter: "", remember: "" } );
        writeControl("QUIT");

        // you're young, try everything
        try {
            control_instream.close();
        }catch(ex){ debug(ex,3); }
        try {
            control_outstream.close();
        }catch(ex){ debug(ex,4); }
        try {
            data_transport.close("Finished");
        }catch(ex){ debug(ex,5); }
        try {
            file_instream.close();
        }catch(ex){ debug(ex,6); }

        data_finished = true;

        // clear out remote window
        data = '';
        remotedircache = new Array;
        hiddenremotedircache = new Array;
        changeRemoteView();
    }
}

// *************************************************************************************************
// ******************************************** preferences ****************************************
// *************************************************************************************************

function readPreferences()
{
    try {
        var prefs = Components.classes["@mozilla.org/preferences-service;1"].
            getService(Components.interfaces.nsIPrefService);
        var prefBranch = prefs.getBranch("fireftp.");
        if (!prefBranch.prefHasUserValue("welcomemode"))
            savePreferences(true);
        if (!prefBranch.prefHasUserValue("filemode"))    // update from version 0.82
        {
            prefBranch.setIntPref("filemode", 0);
            prefBranch.setCharPref("asciifiles", "ai,bas,bat,c,cc,cgi,conf,cpp,css,diz,eps,h,htm,html,hqx,java,map,nfo,pas,php,pl,ps,py,sh,shtml,txt,uue,xml");
            prefBranch.setIntPref("loadmode", 1);
        }
        if (!prefBranch.prefHasUserValue("logmode"))    // update from previous version
            prefBranch.setBoolPref("logmode", false);
        if (!prefBranch.prefHasUserValue("pasvmode"))    // update from previous version
            prefBranch.setBoolPref("pasvmode", true);
        if (!prefBranch.prefHasUserValue("debugmode"))    // update from previous version
            prefBranch.setBoolPref("debugmode", false);
        if (!prefBranch.prefHasUserValue("proxymode"))    // update from previous version
            prefBranch.setBoolPref("proxymode", false);

        welcomemode = prefBranch.getBoolPref("welcomemode");
        errormode = prefBranch.getBoolPref("errormode");
        refreshmode = prefBranch.getBoolPref("refreshmode");
        passwordmode = prefBranch.getBoolPref("passwordmode");
        sessionsmode = prefBranch.getBoolPref("sessionsmode");
        hiddenmode = prefBranch.getBoolPref("hiddenmode");
        interfacemode = prefBranch.getIntPref("interfacemode");
        sslmode = prefBranch.getBoolPref("sslmode");
        pasvmode = prefBranch.getBoolPref("pasvmode");
        network = prefBranch.getIntPref("network");
        timeoutmode = prefBranch.getBoolPref("timeoutmode");
        retry = prefBranch.getIntPref("retry");
        attempts = prefBranch.getIntPref("attempts");
        port = prefBranch.getIntPref("port");
        destructmode = prefBranch.getBoolPref("destructmode");
        filemode = prefBranch.getIntPref("filemode");
        loadmode = prefBranch.getIntPref("loadmode");
        logmode = prefBranch.getBoolPref("logmode");
        debugmode = prefBranch.getBoolPref("debugmode");
        proxymode = prefBranch.getBoolPref("proxymode");
        gLocalPath.value = prefBranch.getCharPref("folder");

        if (interfacemode == 0)
            interfaceChange(false, false);
        else if (interfacemode == 1)
            interfaceChange(false, true);
        else if (interfacemode == 2)
            interfaceChange(true, false);

        if (logmode)
        {
            document.getElementById('cmdlog').collapsed = false;
            document.getElementById('logsplitter').state = '';
            document.getElementById('logbutton').checked = true;
        }
        else
        {
            document.getElementById('cmdlog').collapsed = true;
            document.getElementById('logsplitter').state = 'collapsed';
            document.getElementById('logbutton').checked = false;
        }

        var transferTypes = new Array("Auto", "Binary", "ASCII");
        document.getElementById('statustype').label = transferTypes[filemode];

        var asciiFiles = prefBranch.getCharPref("asciifiles");
        asciiFiles = asciiFiles.split(",");
        for (var x = 0; x < asciiFiles.length; ++x)
            prefAsciiFiles.push(asciiFiles[x]);
    } catch (ex) { debug(ex,7); }
}
function savePreferences(firstTime)
{
    try {
        var prefs = Components.classes["@mozilla.org/preferences-service;1"].
            getService(Components.interfaces.nsIPrefService);
        var prefBranch = prefs.getBranch("fireftp.");

        if (firstTime)
        {
            prefBranch.setBoolPref("welcomemode", true);
            prefBranch.setBoolPref("errormode", true);
            prefBranch.setBoolPref("refreshmode", true);
            prefBranch.setBoolPref("passwordmode", true);
            prefBranch.setBoolPref("sessionsmode", true);
            prefBranch.setBoolPref("hiddenmode", false);
            prefBranch.setIntPref("interfacemode", 0);
            prefBranch.setBoolPref("sslmode", false);
            prefBranch.setBoolPref("pasvmode", true);
            prefBranch.setIntPref("network", 30);
            prefBranch.setBoolPref("timeoutmode", true);
            prefBranch.setIntPref("retry", 10);
            prefBranch.setIntPref("attempts", 40);
            prefBranch.setIntPref("port", 21);
            prefBranch.setBoolPref("destructmode", false);
            prefBranch.setIntPref("filemode", 0);
            prefBranch.setCharPref("asciifiles", "ai,bas,bat,c,cc,cgi,conf,cpp,css,diz,eps,h,htm,html,hqx,java,map,nfo,pas,php,pl,ps,py,sh,shtml,txt,uue,xml");
            prefBranch.setIntPref("loadmode", 1);
            prefBranch.setBoolPref("logmode", false);
            prefBranch.setBoolPref("debugmode", false);
            prefBranch.setBoolPref("proxymode", false);

            var file = Components.classes["@mozilla.org/file/directory_service;1"].
                    createInstance(Components.interfaces.nsIProperties).
                    get("Home", Components.interfaces.nsIFile);
            if (file.path.indexOf('/') != -1)
                prefBranch.setCharPref("folder", file.path.substring(0, file.path.indexOf('/') + 1));
            else if (file.path.indexOf('\\') != -1)
                prefBranch.setCharPref("folder", file.path.substring(0, file.path.indexOf('\\') + 1));
        }
        else
        {
            prefBranch.setIntPref("filemode", filemode);
            prefBranch.setCharPref("folder", gLocalPath.value);
            prefBranch.setBoolPref("logmode", logmode);
        }
    } catch (ex) { debug(ex,8); }
}

// *************************************************************************************************
// *************************************** sessions/passwords **************************************
// *************************************************************************************************

function onHostChange()
{
    var host = {value:""};
    var login =  {value:""};
    var password = {value:""};

    // try to auto-fill the username and password based on host
    if (passwordmode)
    {
        try {
            var passManager = Components.classes["@mozilla.org/passwordmanager;1"]
                .getService(Components.interfaces.nsIPasswordManagerInternal);

            if (document.getElementById('host').value.indexOf("ftp.") == 0)
                passManager.findPasswordEntry(document.getElementById('host').value, "", "", host, login, password);
            else
                passManager.findPasswordEntry("ftp." + document.getElementById('host').value, "", "", host, login, password);

            document.getElementById('login').value = login.value;
            document.getElementById('password').value = password.value;
        } catch (ex) { }
    }
}
function saveSession()
{
    connectedHost = document.getElementById('host').value + document.getElementById('login').value;
    var host = {value:""};
    var login =  {value:""};
    var password = {value:""};

    try {
        var formHistory = Components.classes["@mozilla.org/satchel/form-history;1"]
            .getService(Components.interfaces.nsIFormHistory);
        formHistory.addEntry(document.getElementById('host').getAttribute("autocompletesearchparam"), document.getElementById('host').value);

        var passManager = Components.classes["@mozilla.org/passwordmanager;1"]
            .getService(Components.interfaces.nsIPasswordManager);
        var passManagerIn = Components.classes["@mozilla.org/passwordmanager;1"]
            .getService(Components.interfaces.nsIPasswordManagerInternal);

        // remember last account only
        while (1)
        {
            try {
                if (document.getElementById('host').value.indexOf("ftp.") == 0)
                    passManagerIn.findPasswordEntry(document.getElementById('host').value, "", "", host, login, password);
                else
                    passManagerIn.findPasswordEntry("ftp." + document.getElementById('host').value, "", "", host, login, password);
            } catch (ex) { }
            if (login.value)
            {
                passManager.removeUser(host.value, login.value);
                login.value = "";
            }
            else
                break;
        }

        // save username & password
        if (passwordmode)
        {
            if (document.getElementById('host').value.indexOf("ftp.") == 0)
                passManager.addUser(document.getElementById('host').value,
                    document.getElementById('login').value,
                    document.getElementById('password').value);
            else
                passManager.addUser("ftp." + document.getElementById('host').value,
                    document.getElementById('login').value,
                    document.getElementById('password').value);
        }
    } catch (ex) { debug(ex,11); }
}

// *************************************************************************************************
// *************************************** control socket ******************************************
// *************************************************************************************************

function controlSocketConnect(manual)
{
    document.getElementById('host').value.replace(/^ftp:\/*/, '');    // error checking - get rid of 'ftp://'
    var host = document.getElementById("host").value;

    if (host == "about:mozilla")
    {
        var windowHeight = document.getElementById('main-window').boxObject.height;
        var windowWidth = document.getElementById('main-window').boxObject.width;

        window.openDialog("chrome://fireftp/content/welcomeDialog.xul","welcomeDialog",
                "screenY=0,screenX=0,width=" + windowWidth +",height=" + windowHeight +
                ",chrome,modal=no,dialog=yes,resizable=yes", welcomeMessage, true);
        gConnectButton.label = "Flame On!";
        gConnectButton.setAttribute('accesskey', "F");
        return;
    }

    if (!host)
    {
        var windowHeight = document.getElementById('main-window').boxObject.height;
        var windowWidth = document.getElementById('main-window').boxObject.width;

        window.openDialog("chrome://fireftp/content/alertDialog.xul","alertDialog",
                "screenY="+(windowHeight/2 - 100)+",screenX="+(windowWidth/2 - 200)+
                ",width=400,height=200,chrome,modal=yes,dialog=yes,resizable=yes", strbundle.getString("alertFillHost"));
        return;
    }
    if (!port || !parseInt(port))
    {
        var windowHeight = document.getElementById('main-window').boxObject.height;
        var windowWidth = document.getElementById('main-window').boxObject.width;

        window.openDialog("chrome://fireftp/content/alertDialog.xul","alertDialog",
                "screenY="+(windowHeight/2 - 100)+",screenX="+(windowWidth/2 - 200)+
                ",width=400,height=200,chrome,modal=yes,dialog=yes,resizable=yes", strbundle.getString("alertFillPort"));
        return;
    }

    document.getElementById('statusbytes').label = strbundle.getString("connecting");
    document.getElementById('statusmeter').setAttribute("mode", "undetermined");
    gConnectButton.label = strbundle.getString("disconnectButton");
    gConnectButton.setAttribute('command','cmd_disconnect');
    gConnectButton.setAttribute('accesskey', strbundle.getString("disconnectAccess"));

    if (!eventQueue.length || eventQueue[0].cmd != "welcome")
        eventQueue.unshift( { cmd: "welcome", parameter: "", remember: "" } );

    if (manual)
    {
        isReconnecting = false;
        reconnectAttempts = parseInt(attempts);
        if (!reconnectAttempts || reconnectAttempts < 1)
            reconnectAttempts = 1;
    }

    // create a control socket
    try
    {
        var transportService =
          Components.classes["@mozilla.org/network/socket-transport-service;1"]
            .getService(Components.interfaces.nsISocketTransportService);

        var proxyInfo = null;

        if (proxymode)
        {
            var prefs = Components.classes["@mozilla.org/preferences-service;1"].
                getService(Components.interfaces.nsIPrefService);
            var prefBranch = prefs.getBranch("network.proxy.");

            var proxyService = Components.classes["@mozilla.org/network/protocol-proxy-service;1"]
                .getService(Components.interfaces.nsIProtocolProxyService);
            proxyInfo = proxyService.newProxyInfo("socks" + prefBranch.getIntPref("socks_version"),
                    prefBranch.getCharPref("ftp"), prefBranch.getIntPref("ftp_port"));
        }

        var control_transport;
        if (sslmode)
            control_transport = transportService.createTransport(["ssl"],1,host,parseInt(port),proxyInfo);
        else
            control_transport = transportService.createTransport(null,0,host,parseInt(port),proxyInfo);

        control_outstream = control_transport.openOutputStream(0,0,0);
        var control_stream = control_transport.openInputStream(0,0,0);
        control_instream = Components.classes["@mozilla.org/scriptableinputstream;1"]
            .createInstance(Components.interfaces.nsIScriptableInputStream);
        control_instream.init(control_stream);

        // async data listener for the control socket
        var dataListener = {
            data : "",
            onStartRequest: function(request, context){},
            onStopRequest: function(request, context, status){
                if (!isConnected)    // no route to host
                {
                    var el = document.getElementById('cmdlog').appendItem(strbundle.getString("errorConn"), strbundle.getString("errorConn"));
                    el.setAttribute("style", 'color:red;font-weight:bold;');
                    document.getElementById('cmdlog').ensureIndexIsVisible(document.getElementById('cmdlog').getRowCount() - 1);
                }
                isConnected = false;

                document.getElementById('statusbytes').label = "";
                document.getElementById('statusmeter').setAttribute("mode", "determined");
                document.getElementById('statusmeter').setAttribute("value", "0%");
                gConnectButton.label = strbundle.getString("connectButton");
                gConnectButton.setAttribute('command','cmd_connect');
                gConnectButton.setAttribute('accesskey', strbundle.getString("connectAccess"));

                if (!legitClose && timeoutmode)
                {
                    isReconnecting = true;
                    var seconds = parseInt(retry);
                    if (!seconds || seconds < 1)
                        seconds = 1;
                    document.getElementById('statusbytes').label =
                        strbundle.getString("reconnect") + ' ' + seconds + ' ' + strbundle.getString("seconds") +
                        ' ' + reconnectAttempts + ' ' + strbundle.getString("attempts");
                    document.getElementById('statusmeter').setAttribute("mode", "undetermined");
                    setTimeout("tryReconnect()", seconds * 1000);
                }
                else
                    eventQueue = new Array;
            },
            onDataAvailable: function(request, context, inputStream, offset, count){
                this.data = control_instream.read(count);
                readControl(this.data);
            },
        };

        var pump = Components.classes["@mozilla.org/network/input-stream-pump;1"].
            createInstance(Components.interfaces.nsIInputStreamPump);
        pump.init(control_stream, -1, -1, 0, 0, false);
        pump.asyncRead(dataListener,null);

    } catch(ex) {
        error(strbundle.getString("errorConn"));
        debug(ex,12);
        return;
    }
}
function tryReconnect()    // ahhhh! our precious connection has been lost, must...get it...back...our...precious
{
    if (!isReconnecting)
    {
        document.getElementById('statusbytes').label = "";
        document.getElementById('statusmeter').setAttribute("mode", "determined");
        document.getElementById('statusmeter').setAttribute("value", "0%");
        return;
    }

    --reconnectAttempts;
    if (reconnectAttempts < 0)
    {
        document.getElementById('statusbytes').label = "";
        document.getElementById('statusmeter').setAttribute("mode", "determined");
        document.getElementById('statusmeter').setAttribute("value", "0%");
        return;
    }

    controlSocketConnect();
}
// helper function
function addEventQueue(cmd, parameter, remember)
{
    parameter = parameter ? parameter : '';
    remember = remember ? remember : '';
    eventQueue.push( { cmd: cmd, parameter: parameter, remember: remember } );
}

// *************************************************************************************************
// ************************************* control socket write **************************************
// *************************************************************************************************

function writeControl(cmd, parameter)
{
    try
    {
        if (cmd == "aborted" || cmd == "goodbye")
        {
            eventQueue.shift();
            if (eventQueue.length)
            {
                cmd = eventQueue[0].cmd;
                parameter = eventQueue[0].parameter;
            }
            else
                return;
        }

        isReady = false;
        if (cmd != "QUIT")
        {
            document.getElementById('statusbytes').label = strbundle.getString("working");
            document.getElementById('statusmeter').setAttribute("mode", "undetermined");
        }
        else
        {
            document.getElementById('statusbytes').label = "";
            document.getElementById('statusmeter').setAttribute("mode", "determined");
            document.getElementById('statusmeter').setAttribute("value", "0%");
        }
        var filesleft = 0;
        for (var x = 0; x < eventQueue.length; ++x)
            if (eventQueue[x].cmd == "RETR" || eventQueue[x].cmd == "APPE"
                    || eventQueue[x].cmd == "STOR" || eventQueue[x].cmd == "DELE" || eventQueue[x].cmd == "RMD")
            ++filesleft;
        if (filesleft)
            document.getElementById('statusbytes').label +=
                ' - ' + filesleft + ' ' + strbundle.getString("filesleft");
        if (!pasvmode && cmd == "PASV")
        {
            cmd = "PORT";
            activeConnected = false;
            try {
                var DNSService = Components.classes["@mozilla.org/network/dns-service;1"]
                        .getService(Components.interfaces.nsIDNSService);
                var ipAddress = DNSService.resolve(DNSService.myHostName, false).getNextAddrAsString();
                var re = /\x2e/g;
                var serverSocket = Components.classes["@mozilla.org/network/server-socket;1"]
                        .createInstance(Components.interfaces.nsIServerSocket);
                var serverListener = {
                    onSocketAccepted: function(serv, transport){
                        data_transport = transport;
                        if (activeCmd == "LIST")
                            dataSocketConnect(false, '', 0, 0, transport);
                        else if (activeCmd == "RETR")
                            dataSocketConnect(false, activeRemember, activeRemember2, 0, transport);
                        else if (activeCmd == "REST")
                            dataSocketConnect(false, activeRemember, activeRemember2, activeRemember3, transport);
                        else if (activeCmd == "STOR")
                            dataSocketConnect(true, activeRemember, 0, 0, transport);
                        else if (activeCmd == "APPE")
                            dataSocketConnect(true, activeRemember, 0, activeRemember2, transport);
                    },
                    onStopListening: function(serv, status){ }
                };
                serverSocket.init(-1, false, -1);
                serverSocket.asyncListen(serverListener);
                parameter = ipAddress.replace(re, ",") + "," + parseInt(serverSocket.port / 256) + "," + serverSocket.port % 256;
            } catch (ex) {
                error(strbundle.getString("errorDataConn"));
                debug(ex,13);
                return;
            }
        }
        var outputData = cmd + (parameter ? (' ' + parameter) : '') + "\r\n";    // thanks to devin
        control_outstream.write(outputData,outputData.length);

        // alright, here's a little magic do-hickey
        ++networkTimeoutID;
        var seconds = parseInt(network);
        if (!seconds || seconds < 1)
            seconds = 1;
        setTimeout("checkTimeout(" + networkTimeoutID + ",'" + cmd + "')", seconds * 1000);

        outputData = cmd + (parameter ? (' ' + parameter) : '');
        if (cmd != "PASS")
        {
            var el = document.getElementById('cmdlog').appendItem("       " + outputData, "       " + outputData);
            el.setAttribute('style', 'color:blue');
            document.getElementById('cmdlog').ensureIndexIsVisible(document.getElementById('cmdlog').getRowCount() - 1);
        }
        else
        {
            var el = document.getElementById('cmdlog').appendItem("       PASS " + strbundle.getString("passNotShown"), "       PASS " + strbundle.getString("passNotShown"));
            el.setAttribute('style', 'color:blue');
            document.getElementById('cmdlog').ensureIndexIsVisible(document.getElementById('cmdlog').getRowCount() - 1);
        }
    } catch(ex) {
        error(strbundle.getString("errorConn"));
        debug(ex,14);
    }
}

// *************************************************************************************************
// *************************************** control socket read *************************************
// *************************************************************************************************

function readControl(buffer)
{
    var lastLineOfBuffer = buffer.split("\r\n");

    if (buffer != "2")    // these are self-generated fake messages
    {
        for (var x = 0; x < lastLineOfBuffer.length; ++x)
        {
            var message = lastLineOfBuffer[x].charAt(lastLineOfBuffer[x].length - 1) == '\r'
                    ? lastLineOfBuffer[x].substring(0, lastLineOfBuffer[x].length - 1) : lastLineOfBuffer[x];
            var el = document.getElementById('cmdlog').appendItem(message, message);
            document.getElementById('cmdlog').ensureIndexIsVisible(document.getElementById('cmdlog').getRowCount() - 1);
            if (lastLineOfBuffer[x].charAt(0) == '4' || lastLineOfBuffer[x].charAt(0) == '5')
                el.setAttribute('style', 'color:red;font-weight:bold');
            else
                el.setAttribute('style', 'color:green');
        }
    }

    lastLineOfBuffer = lastLineOfBuffer[lastLineOfBuffer.length - 1];
    var returnCode;

    // see if they're still talking, blah blah blah
    if ((lastLineOfBuffer.length > 3 && lastLineOfBuffer.charAt(3) == '-') || lastLineOfBuffer.charAt(0) == ' ')
    {
        if (eventQueue[0].cmd == "USER" || eventQueue[0].cmd == "PASS")
            welcomeMessage += buffer;
        return;
    }
    else
        returnCode = parseInt(lastLineOfBuffer.charAt(0));    // no intelligence here, folks

    var cmd;
    var parameter;
    var remember;

    if (eventQueue.length)
    {
        cmd = eventQueue[0].cmd;
        parameter = eventQueue[0].parameter;
        remember = eventQueue[0].remember;
        if (cmd != "LIST" && cmd != "RETR" && cmd != "STOR" && cmd != "APPE")
        {
            var throwAway = eventQueue.shift();
            if (throwAway.cmd != "USER" && throwAway.cmd != "PASS" && throwAway.cmd != "PWD" &&
                    throwAway.cmd != "welcome" && throwAway.cmd != "goodbye" && throwAway.cmd != "aborted")
                trashQueue.push(throwAway);
            if (trashQueue.length > 4)    // don't remember too much junk
                trashQueue.shift();
        }
        if (eventQueue.cmd)    // messy, messy, messy
            eventQueue = new Array(eventQueue);
    }
    else
        cmd = "default";    // an unexpected reply - perhaps a 421 timeout message

    switch(cmd)
    {
        case "welcome":
            welcomeMessage = buffer;

            if (returnCode != 2)
            {
                displayWelcomeMessage();    // not so welcome
                eventQueue = new Array;
                addEventQueue("welcome");
                gConnectButton.label = strbundle.getString("connectButton");
                gConnectButton.setAttribute('command','cmd_connect');
                gConnectButton.setAttribute('accesskey', strbundle.getString("connectAccess"));
                document.getElementById('login').focus();
                break;
            }

            isConnected = true;
            reconnectAttempts = parseInt(attempts);
            if (!reconnectAttempts || reconnectAttempts < 1)
                reconnectAttempts = 1;

            //favicon - just for kicks
            var host = document.getElementById("host").value;
            if (host.indexOf("ftp.") == 0)
                host = host.substring(4);
            document.getElementById('favicon').src = "http://" + host + "/favicon.ico";

            initialPath = gRemotePath.value;     // save the path (and the seamonkeys)
            // send username
            if (!document.getElementById('login').value) // send anonymous username if field blank
                document.getElementById('login').value = "anonymous";
            eventQueue.unshift( { cmd: "USER", parameter: document.getElementById('login').value, remember: "" } );
            break;
        case "goodbye":        // you say yes, i say no, you stay stop...
            if (returnCode != 2)
                error(buffer, true);
            return;
        case "USER":
            if (returnCode == 2)
            {
                welcomeMessage += buffer;
                displayWelcomeMessage();
                saveSession();

                // list the current directory
                if (!legitClose)
                {
                    recoverFromDisaster();
                    break;
                }
                legitClose = false;
                remotePathFocus = '/';
                gRemotePath.value = initialPath;

                remotedircache = new Array( {path: "/", open: true, empty: false, children: -1} );
                hiddenremotedircache = new Array;

                eventQueue.unshift( { cmd: "PWD", parameter: "", remember: "" } );
            }
            else if (returnCode == 3)
            {
                // send password
                if (!document.getElementById('password').value) // send anonymous password if field blank
                    document.getElementById('password').value = "[e-mail]";
                eventQueue.unshift( { cmd: "PASS", parameter: document.getElementById('password').value, remember: "" } );
            }
            else
            {
                eventQueue = new Array;
                addEventQueue("welcome");
                error(buffer, true);
                gConnectButton.label = strbundle.getString("connectButton");
                gConnectButton.setAttribute('command','cmd_connect');
                gConnectButton.setAttribute('accesskey', strbundle.getString("connectAccess"));
                document.getElementById('login').focus();
                return;
            }
            break;
        case "PASS":
            if (returnCode == 2)
            {
                welcomeMessage += buffer;
                displayWelcomeMessage();
                saveSession();

                // list the current directory
                if (!legitClose)
                {
                    recoverFromDisaster();
                    break;
                }
                legitClose = false;
                remotePathFocus = '/';
                gRemotePath.value = initialPath;

                remotedircache = new Array( {path: "/", open: true, empty: false, children: -1} );
                hiddenremotedircache = new Array;

                eventQueue.unshift( { cmd: "PWD", parameter: "", remember: "" } );
            }
            else
            {
                eventQueue = new Array;
                addEventQueue("welcome");
                error(buffer, true);
                gConnectButton.label = strbundle.getString("connectButton");
                gConnectButton.setAttribute('command','cmd_connect');
                gConnectButton.setAttribute('accesskey', strbundle.getString("connectAccess"));
                document.getElementById('password').focus();
                return;
            }
            break;
        case "PASV":
            if (returnCode != 2)
            {
                error(buffer, true);
                break;
            }

            emptyFileSoCloseLater = false;
            if (pasvmode)
            {
                // whoa, string manipulation ahoy
                buffer = buffer.substring(buffer.indexOf("(") + 1, buffer.indexOf(")"));

                var re = /,/g;
                buffer = buffer.replace(re,".");
                dataport = parseInt(buffer.substring(buffer.lastIndexOf(".") + 1));
                dataport += 256 * parseInt(buffer.substring(buffer.lastIndexOf(".", buffer.lastIndexOf(".") - 1) + 1, buffer.lastIndexOf(".") + 1));
                datahost = buffer.substring(0, buffer.lastIndexOf(".", buffer.lastIndexOf(".") - 1));

                if (eventQueue[0].cmd == "LIST")
                {
                    remember = remember ? remember : false;
                    data_remember = "afterList(\"" + eventQueue[0].remember + "\"," + remember + ")";
                    dataSocketConnect();
                }
                else if (eventQueue[0].cmd == "RETR")
                    dataSocketConnect(false, eventQueue[0].remember, remember);
                else if (eventQueue[0].cmd == "REST")
                    dataSocketConnect(false, eventQueue[1].remember, remember, eventQueue[0].parameter);
                else if (eventQueue[0].cmd == "STOR")
                    dataSocketConnect(true, eventQueue[0].remember, 0, 0);
                else if (eventQueue[0].cmd == "APPE")
                    dataSocketConnect(true, eventQueue[0].remember[0], 0, eventQueue[0].remember[1]);
            }
            else
            {
                activeCmd = eventQueue[0].cmd;
                if (eventQueue[0].cmd == "LIST")
                {
                    remember = remember ? remember : false;
                    data_remember = "afterList(\"" + eventQueue[0].remember + "\"," + remember + ")";
                }
                else if (eventQueue[0].cmd == "RETR")
                {
                    activeRemember = eventQueue[0].remember;
                    activeRemember2 = remember;
                }
                else if (eventQueue[0].cmd == "REST")
                {
                    activeRemember = eventQueue[1].remember;
                    activeRemember2 = remember;
                    activeRemember3 = eventQueue[0].parameter;
                }
                else if (eventQueue[0].cmd == "STOR")
                    activeRemember = eventQueue[0].remember;
                else if (eventQueue[0].cmd == "APPE")
                {
                    activeRemember = eventQueue[0].remember[0];
                    activeRemember2 = eventQueue[0].remember[1];
                }
            }
            break;
        case "TYPE":
            if (returnCode != 2)
                error(buffer, true);
            break;
        case "LIST":
            eventQueue[0].cmd = "LIST2";
            if (returnCode == 2)
            {
                if (data_finished)
                {
                    var throwAway = eventQueue.shift();
                    trashQueue.push(throwAway);
                    if (trashQueue.length > 4)    // don't remember too much junk
                        trashQueue.shift();
                    eval(data_remember);
                    break;
                }
                else
                {
                    setTimeout("readControl(\"2\")", 500);    // give data stream some time to finish up
                    return;
                }
            }
            if (returnCode != 1)
            {
                moreToRemember = "";
                error(buffer, true);
                eventQueue.shift();
                break;
            }
            return;
        case "LIST2":
            if (returnCode != 2)
            {
                error(buffer, true);
                break;
            }

            if (data_finished)
                eval(data_remember);
            else
            {
                eventQueue.unshift( { cmd: "LIST2", parameter: "", remember: "" } );
                setTimeout("readControl(\"2\")", 500);    // give data stream some time to finish up
                return;
            }
            break;
        case "MKD":
            if (returnCode != 2)
            {
                moreToRemember = "";
                error(buffer, true);
                break;
            }
            if (!storeRemoteParent && refreshmode)
                refreshRemoteView();
            break;
        case "RNFR":
            if (returnCode != 3)
            {
                moreToRemember = "";
                eventQueue = new Array;
                error(buffer, true);
            }
            break;
        case "RNTO":
            if (returnCode != 2)
            {
                moreToRemember = "";
                error(buffer, true);
                break;
            }
            if (remember == "pasting")
                break;
            if (remember)
                onRemoteCDUP();
            moreToRemember = "renameRemoteFile2(" + remember + ")";
            if (refreshmode)
                refreshRemoteView();
            break;
        case "DELE":
        case "RMD":
            if (returnCode != 2)
            {
                error(buffer, true);
                break;
            }

            // clear out of cache
            if (cmd == "RMD")
            {
                for (var x = 0; x < remotecache.length; ++x)
                    if (remotecache[x].path == parameter && remotecache[x].host == connectedHost)
                    {
                        remotecache.splice(x, 1);
                        if (remotecache.data)
                            remotecache = new Array(remotecache);// messy, messy, messy
                        break;
                    }
                // remove from nsICache
                if (sessionsmode)
                {
                    try {
                        var cacheService = Components.classes["@mozilla.org/network/cache-service;1"]
                            .getService(Components.interfaces.nsICacheService);
                        var cacheSession = cacheService.createSession("fireftp", 0, true);
                        var cacheDesc = cacheSession.openCacheEntry("ftp://" + connectedHost + parameter,
                            Components.interfaces.nsICache.ACCESS_WRITE, false);
                        cacheDesc.doom();
                        cacheDesc.close();
                    } catch (ex) { debug(ex,15); }
                }
            }

            eval(remember);
            break;
        case "RETR":
            eventQueue[0].cmd = "RETR2";
            if (returnCode == 2)
            {
                if (data_finished)
                {
                    var throwAway = eventQueue.shift();
                    trashQueue.push(throwAway);
                    if (trashQueue.length > 4)    // don't remember too much junk
                        trashQueue.shift();
                    break;
                }
                else
                {
                    setTimeout("readControl(\"2\")", 500);    // give data stream some time to finish up
                    return;
                }
            }
            if (returnCode != 1)
            {
                error(buffer, true);
                eventQueue.shift();
                break;
            }
            return;
        case "RETR2":
            if (returnCode != 2)
            {
                if (buffer.substring(0,3) != "450")    // ignore this error - from the pseudo-ABOR we generate
                    error(buffer, true);
                break;
            }

            if (!data_finished)
            {
                eventQueue.unshift( { cmd: "RETR2", parameter: "", remember: "" } );
                setTimeout("readControl(\"2\")", 500);    // give data stream some time to finish up
                return;
            }
            break;
        case "REST":
            if (returnCode != 3)
            {
                error(buffer, true);    // should still be able to go on without this, just not with resuming
                break;
            }
            break;
        case "SITE CHMOD":
            if (returnCode != 2)
            {
                moreToRemember = "";
                error(buffer, true);
                break;
            }
            moreToRemember = "getRemoteProperties2(\'" + remember + "\')";
            if (refreshmode)
                refreshRemoteView();
            break;
        case "APPE":
            eventQueue[0].cmd = "APPE2";
            if (returnCode == 2)
            {
                if (data_finished)
                {
                    var throwAway = eventQueue.shift();
                    trashQueue.push(throwAway);
                    if (trashQueue.length > 4)    // don't remember too much junk
                        trashQueue.shift();
                    break;
                }
                else
                {
                    setTimeout("readControl(\"2\")", 500);    // give data stream some time to finish up
                    return;
                }
            }
            if (returnCode != 1)
            {
                error(buffer, true);
                eventQueue.shift();
                break;
            }
            return;
        case "APPE2":
            if (returnCode != 2)
            {
                error(buffer, true);
                break;
            }

            if (!data_finished)
            {
                eventQueue.unshift( { cmd: "APPE2", parameter: "", remember: "" } );
                setTimeout("readControl(\"2\")", 500);    // give data stream some time to finish up
                return;
            }
            break;
        case "STOR":
            if (emptyFileSoCloseLater)
            {
                try {
                    data_outstream.close();
                } catch (ex) { debug(ex,42); }
            }
            eventQueue[0].cmd = "STOR2";
            if (returnCode == 2)
            {
                if (data_finished)
                {
                    var throwAway = eventQueue.shift();
                    trashQueue.push(throwAway);
                    if (trashQueue.length > 4)    // don't remember too much junk
                        trashQueue.shift();
                    break;
                }
                else
                {
                    setTimeout("readControl(\"2\")", 500);    // give data stream some time to finish up
                    return;
                }
            }
            if (returnCode != 1)
            {
                error(buffer, true);
                eventQueue.shift();
                break;
            }
            return;
        case "STOR2":
            if (returnCode != 2)
            {
                error(buffer, true);
                break;
            }

            if (!data_finished)
            {
                eventQueue.unshift( { cmd: "STOR2", parameter: "", remember: "" } );
                setTimeout("readControl(\"2\")", 500);    // give data stream some time to finish up
                return;
            }
            break;
        case "SIZE":
            if (returnCode == 2)
            {
                var size = buffer.split(" ");
                size = parseInt(size[1]);
                for (var x = 0; x < eventQueue.length; ++x)
                    if (remember == eventQueue[x].cmd)
                    {
                        if (remember == "STOR")
                        {
                            eventQueue[x].cmd = "APPE";
                            eventQueue[x].remember = new Array(eventQueue[x].remember, size);
                        }
                        if (remember == "APPE")
                            eventQueue[x].remember = new Array(eventQueue[x].remember[0], size);
                        break;
                    }
            }
            break;
        case "aborted":
            break;
        case "CWD":
            if (returnCode != 2)    // it's not a directory
                retr();
            else
            {
                gRemotePath.value = parameter;
                onRemotePathChange();
            }
            break;
        case "PWD":    // gotta check for chrooted directories
            buffer = buffer.substring(buffer.indexOf("\"") + 1, buffer.lastIndexOf("\""));

            if (buffer != '/')    // chrooted
            {
                remotecache.push( { path: '/', host: connectedHost, data: '' });
                gRemotePath.value = buffer;
            }

            onRemotePathChange();
            break;
        default:
            if (returnCode != 2)
                error(buffer, true);
            break;
    }

    isReady = true;
    if (eventQueue.length && eventQueue[0].cmd != "welcome")    // start the next command
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
    else    // or refresh in the appropriate manner
    {
        document.getElementById('statusbytes').label = "";
        document.getElementById('statusmeter').setAttribute("mode", "determined");
        document.getElementById('statusmeter').setAttribute("value", "0%");
        if (retrieveLocalParent == gLocalPath.value)
        {
            retrieveLocalParent = "";
            setTimeout("refreshLocalView()", 1000);    // give it a little time to freshen up
        }
        else if (storeRemoteParent && refreshmode)
        {
            if (storeRemoteParent == gRemotePath.value)
                refreshRemoteView();
            else
            {
                refreshRemote = true;
                list(storeRemoteParent, "refreshRemote = false", true);
                if (isReady)    // get the ball rollin' if it isn't already
                    writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
            }
            storeRemoteParent = "";
        }
        else if (remoteCutParentDir && remotePasteReady && refreshmode)
        {
            var tempPath = gRemotePath.value;
            if (remoteCutParentDir2)
            {
                gRemotePath.value =    remoteCutParentDir.substring(0,
                    remoteCutParentDir.lastIndexOf('/')    ? remoteCutParentDir.lastIndexOf('/') : 1);
                onRemotePathChange();
                moreToRemember = "refreshPasting(\'" + tempPath + "\')";
                refreshRemoteView();
            }
            else
            {
                gRemotePath.value = isRemoteDirCut
                    ? remoteCutParentDir.substring(0, remoteCutParentDir.lastIndexOf('/') ? remoteCutParentDir.lastIndexOf('/') : 1)
                    : remoteCutParentDir;
                remoteCutParentDir = "";
                onRemotePathChange();
                moreToRemember = "moreToRemember='';gRemotePath.value=\'" + tempPath + "\';refreshRemoteView();";
                refreshRemoteView();
            }
            remotePasteReady = false;
        }
    }
}

// *************************************************************************************************
// ******************************************** data socket ****************************************
// *************************************************************************************************

function dataSocketConnect(write, localpath, fileTotalBytes, filePartialBytes, activeTransport)
{
    // create a data socket
    try
    {
        if (pasvmode)
        {
            var transportService =
                    Components.classes["@mozilla.org/network/socket-transport-service;1"]
                    .getService(Components.interfaces.nsISocketTransportService);

            var proxyInfo = null;

            if (proxymode)
            {
                var prefs = Components.classes["@mozilla.org/preferences-service;1"].
                    getService(Components.interfaces.nsIPrefService);
                var prefBranch = prefs.getBranch("network.proxy.");

                var proxyService = Components.classes["@mozilla.org/network/protocol-proxy-service;1"]
                    .getService(Components.interfaces.nsIProtocolProxyService);
                proxyInfo = proxyService.newProxyInfo("socks" + prefBranch.getIntPref("socks_version"),
                        prefBranch.getCharPref("ftp"), prefBranch.getIntPref("ftp_port"));
            }

            if (sslmode)
                data_transport = transportService.createTransport(["ssl"],1,datahost,dataport,proxyInfo);
            else
                data_transport = transportService.createTransport(null,0,datahost,dataport,proxyInfo);
        }
        else
            data_transport = activeTransport;

        if (write)
        {
            data_finished = false;
            data_outstream = data_transport.openOutputStream(0,0,-1);

            // open the file
            var file;
            try {
                file = Components.classes['@mozilla.org/file/local;1']
                    .createInstance(Components.interfaces.nsILocalFile);
                file.initWithPath(localpath);
                file_instream = Components.classes["@mozilla.org/network/file-input-stream;1"]
                    .createInstance();
                file_instream.QueryInterface(Components.interfaces.nsIFileInputStream);
                file_instream.init(file, 0x01, 420, 0);
                file_instream.QueryInterface(Components.interfaces.nsISeekableStream);
                file_instream.seek(0, filePartialBytes);    // append or not to append
            } catch (ex) {
                debug(ex,16);
                error(strbundle.getString("failedUpload") + " '" + localpath + "'.");
                data_outstream.close();
                data_transport.close("Finished");
                file_instream.close();
                data_finished = true;
            }

            // async write, update status bar at the same time
            var outputStreamCallback = {
                sendBytesTotal : file.fileSize,
                sendBytesUploaded : parseInt(filePartialBytes),
                sendTimeStart : new Date(),
                sendOffset : parseInt(filePartialBytes),
                onOutputStreamReady: function(stream){
                    try {
                        var numBytesToWrite = file_instream.available();
                        data_outstream.writeFrom(file_instream, file_instream.available());

                        // NOTE: for the time being, this doesn't work, we ignore it in checkTimeout
                        ++networkTimeoutID;
                        var seconds = parseInt(network);
                        if (!seconds || seconds < 1)
                            seconds = 1;
                        setTimeout("checkTimeout(" + networkTimeoutID + ", '', true)", seconds * 1000);

                        this.sendBytesUploaded += numBytesToWrite - file_instream.available();
                        var timeElapsed = ((new Date()) - this.sendTimeStart) / 1000;
                        timeElapsed = timeElapsed ? timeElapsed : 1; // no dividing by 0
                        var averageRate = ((this.sendBytesUploaded - this.sendOffset) / 1024 / timeElapsed).toFixed(2);
                        averageRate = averageRate ? averageRate : 0.01; // no dividing by 0
                        var timeRemaining = (this.sendBytesTotal - this.sendBytesUploaded) / 1024 * (1 / averageRate);
                        averageRate += " KB/s";

                        var filesleft = 1;
                        for (var x = 0; x < eventQueue.length; ++x)
                            if (eventQueue[x].cmd == "RETR" || eventQueue[x].cmd == "APPE"
                                    || eventQueue[x].cmd == "STOR")
                                ++filesleft;
                        document.getElementById('statusbytes').label =
                                commas(this.sendBytesUploaded) + " / " + commas(this.sendBytesTotal) + ' - ' +
                                filesleft + ' ' + strbundle.getString("filesleft");
                        var hours = parseInt(timeElapsed / 3600);
                        var min = parseInt((timeElapsed - hours * 3600) / 60);
                        var sec = parseInt(timeElapsed - hours * 3600 - min * 60);
                        document.getElementById('statuselapsed').label = zeros(hours)+":"+zeros(min)+":"+zeros(sec);

                        hours = parseInt(timeRemaining / 3600);
                        min = parseInt((timeRemaining - hours * 3600) / 60);
                        sec = parseInt(timeRemaining - hours * 3600 - min * 60);
                        document.getElementById('statusremaining').label = zeros(hours)+":"+zeros(min)+":"+zeros(sec);

                        document.getElementById('statusrate').label = averageRate;
                        var total = this.sendBytesTotal ? this.sendBytesTotal : 1;    // no dividing by 0
                        document.getElementById('statusmeter').setAttribute("mode", "determined");
                        document.getElementById('statusmeter').setAttribute("value", parseInt(this.sendBytesUploaded / total * 100) + "%");
                        document.title = document.getElementById('statusmeter').getAttribute("value") + " - " + averageRate;

                        if (!file_instream.available())    // finished writing
                        {
                            if (file.fileSize)    // empty files are bad
                                data_outstream.close();
                            else
                                emptyFileSoCloseLater = true;
                            file_instream.close();
                            data_finished = true;
                            document.getElementById('statusbytes').label = strbundle.getString("working");
                            var filesleft = 0;
                            for (var x = 0; x < eventQueue.length; ++x)
                                if (eventQueue[x].cmd == "RETR" || eventQueue[x].cmd == "APPE"
                                        || eventQueue[x].cmd == "STOR")
                                    ++filesleft;
                            if (filesleft)
                            {
                                document.getElementById('statusbytes').label +=
                                        ' - ' + filesleft + ' ' + strbundle.getString("filesleft");
                                document.getElementById('statusmeter').setAttribute("mode", "undetermined");
                            }
                            else
                                document.getElementById('statusmeter').setAttribute("mode", "determined");
                            document.getElementById('statuselapsed').label = "";
                            document.getElementById('statusremaining').label = "";
                            document.getElementById('statusrate').label = "";
                            document.getElementById('statusmeter').setAttribute("value", "0%");
                            document.title = "fireFTP";
                        }
                        else
                            data_outstream.asyncWait(outputStreamCallback, 0, 0, null);
                    } catch (ex) { debug(ex,17); /*WOULD_BLOCK*/  } // shouldn't get here
                }
            }
            data_outstream.QueryInterface(Components.interfaces.nsIAsyncOutputStream);
            data_outstream.asyncWait(outputStreamCallback, 0, 0, null);
        }
        else    // read data
        {
            data_finished = false;
            var data_stream = data_transport.openInputStream(0,0,0);
            var data_instream = Components.classes["@mozilla.org/binaryinputstream;1"]
                .createInstance(Components.interfaces.nsIBinaryInputStream);
            data_instream.setInputStream(data_stream);

            fileTotalBytes = fileTotalBytes ? fileTotalBytes : 0;
            filePartialBytes = filePartialBytes ? filePartialBytes : 0;

            // async read, update status bar at the same time
            var dataListener = {
                dummy : "",
                data : "",
                file : "",
                file_outstream : "",
                binary_outstream : "",
                bytesTotal : fileTotalBytes,
                bytesDownloaded : filePartialBytes,
                bytesPartial : filePartialBytes,
                timeStart : 0,
                byteArray : new Array,
                isNotList : eventQueue[0].cmd.indexOf("LIST") == -1,
                onStartRequest: function(request, context){
                    data = "";
                    if (this.isNotList)
                    {
                        this.timeStart = new Date();
                        try {
                            this.file = Components.classes['@mozilla.org/file/local;1'].createInstance(Components.interfaces.nsILocalFile);
                            this.file.initWithPath(localpath);
                            this.file_outstream = Components.classes["@mozilla.org/network/file-output-stream;1"]
                                .createInstance(Components.interfaces.nsIFileOutputStream);
                            if (filePartialBytes)
                                this.file_outstream.init(this.file, 0x04 | 0x10, 420, 0);
                            else
                                this.file_outstream.init(this.file, 0x04 | 0x08 | 0x20, 420, 0);
                            this.binary_outstream = Components.classes["@mozilla.org/binaryoutputstream;1"]
                                .createInstance(Components.interfaces.nsIBinaryOutputStream);
                            this.binary_outstream.setOutputStream(this.file_outstream);
                        } catch (ex) {
                            debug(ex,18);
                            error(strbundle.getString("failedSave") + " '" + localpath + "' " + strbundle.getString("failedSave2"));
                            data_instream.close();
                            data_transport.close("Finished");
                            this.binary_outstream.close();
                            this.file_outstream.close();
                            data_finished = true;
                        }
                    }
                },
                onStopRequest: function(request, context, status){
                    data_instream.close();
                    data_transport.close("Finished");
                    if (this.isNotList)
                    {
                        this.binary_outstream.close();
                        this.file_outstream.close();
                    }
                    var filesleft = 0;
                    for (var x = 0; x < eventQueue.length; ++x)
                        if (eventQueue[x].cmd == "RETR" || eventQueue[x].cmd == "APPE"
                                || eventQueue[x].cmd == "STOR")
                            ++filesleft;

                    if (filesleft)
                    {
                        document.getElementById('statusbytes').label = strbundle.getString("working") + ' - ' +
                            filesleft + ' ' + strbundle.getString("filesleft");
                        document.getElementById('statusmeter').setAttribute("mode", "undetermined");
                    }
                    else
                    {
                        document.getElementById('statusbytes').label = "";
                        document.getElementById('statusmeter').setAttribute("mode", "determined");
                    }
                    document.getElementById('statuselapsed').label = "";
                    document.getElementById('statuselapsed').label = "";
                    document.getElementById('statusremaining').label = "";
                    document.getElementById('statusrate').label = "";
                    document.getElementById('statusmeter').setAttribute("value", "0%");
                    document.title = "fireFTP";
                    data = this.data;
                    data_finished = true;
                },
                onDataAvailable: function(request, context, inputStream, offset, count){
                    if (this.isNotList)
                    {
                        try {
                            this.byteArray = data_instream.readByteArray(count, this.byteArray);
                            this.binary_outstream.writeByteArray(this.byteArray, this.byteArray.length);

                            ++networkTimeoutID;
                            var seconds = parseInt(network);
                            if (!seconds || seconds < 1)
                                seconds = 1;
                            setTimeout("checkTimeout(" + networkTimeoutID + ", '', true)", seconds * 1000);

                            this.bytesDownloaded += this.byteArray.length;
                            var timeElapsed = ((new Date()) - this.timeStart) / 1000;
                            timeElapsed = timeElapsed ? timeElapsed : 1; // no dividing by 0
                            var averageRate = ((this.bytesDownloaded - this.bytesPartial) / 1024 / timeElapsed).toFixed(2);
                            averageRate = averageRate ? averageRate : 0.01; // no dividing by 0
                            var timeRemaining = (this.bytesTotal - this.bytesDownloaded) / 1024 * (1 / averageRate);

                            averageRate += " KB/s";
                            var filesleft = 1;
                            for (var x = 0; x < eventQueue.length; ++x)
                                if (eventQueue[x].cmd == "RETR" || eventQueue[x].cmd == "APPE"
                                        || eventQueue[x].cmd == "STOR")
                                    ++filesleft;
                            document.getElementById('statusbytes').label =
                                    commas(this.bytesDownloaded) + " / " + commas(this.bytesTotal) + ' - ' +
                                    filesleft + ' ' + strbundle.getString("filesleft");
                            var hours = parseInt(timeElapsed / 3600);
                            var min = parseInt((timeElapsed - hours * 3600) / 60);
                            var sec = parseInt(timeElapsed - hours * 3600 - min * 60);
                            document.getElementById('statuselapsed').label = zeros(hours)+":"+zeros(min)+":"+zeros(sec);

                            hours = parseInt(timeRemaining / 3600);
                            min = parseInt((timeRemaining - hours * 3600) / 60);
                            sec = parseInt(timeRemaining - hours * 3600 - min * 60);
                            document.getElementById('statusremaining').label = zeros(hours)+":"+zeros(min)+":"+zeros(sec);

                            document.getElementById('statusrate').label = averageRate;
                            var total = this.bytesTotal ? this.bytesTotal : 1;    // no dividing by 0
                            document.getElementById('statusmeter').setAttribute("mode", "determined");
                            document.getElementById('statusmeter').setAttribute("value", parseInt(this.bytesDownloaded / total * 100) + "%");
                            document.title = document.getElementById('statusmeter').getAttribute("value") + " - " + averageRate;
                        } catch (ex) {
                            debug(ex,19);
                            error(strbundle.getString("failedSave") + " '" + localpath + "' " + strbundle.getString("failedSave2"));
                            data_instream.close();
                            data_transport.close("Finished");
                            this.binary_outstream.close();
                            this.file_outstream.close();
                            data_finished = true;
                        }
                    }
                    else
                        this.data += data_instream.readBytes(data_instream.available());
                },
            };

            var pump = Components.classes["@mozilla.org/network/input-stream-pump;1"].
                createInstance(Components.interfaces.nsIInputStreamPump);
            pump.init(data_stream, -1, -1, 0, 0, false);
            pump.asyncRead(dataListener,null);
        }

    } catch(ex) {
        error(strbundle.getString("errorDataConn"));
        debug(ex,20);
        return;
    }
}

// *************************************************************************************************
// *********************************************** LIST ********************************************
// *************************************************************************************************

// execute a LIST command gracefully, if necessary
var listPath;
function list(path, remember, noRemoteViewUpdate, deletingRecursively)
{
    noRemoteViewUpdate = noRemoteViewUpdate ? noRemoteViewUpdate : false;
    listPath = path;

    if (!refreshRemote)
    {
        if (!noRemoteViewUpdate)
            gRemotePath.value = path;

        // first, see if directory is in local cache
        var index = checkRemoteCache(path);
        if (index != -1)
        {
            data = remotecache[index].data;
            if (!noRemoteViewUpdate)
                changeRemoteView();
            if (remember)
                eval(remember);
            return;
        }

        // next, try nsICache
        if (sessionsmode)
        {
            try {
                var cacheService = Components.classes["@mozilla.org/network/cache-service;1"]
                    .getService(Components.interfaces.nsICacheService);
                var cacheSession = cacheService.createSession("fireftp", 0, true);
                var cacheDesc = cacheSession.openCacheEntry("ftp://" + connectedHost + path,
                    Components.interfaces.nsICache.ACCESS_READ, false);
                if (cacheDesc.dataSize)
                {
                    var cacheIn = cacheDesc.openInputStream(0);
                    var cacheInstream = Components.classes["@mozilla.org/binaryinputstream;1"]
                        .createInstance(Components.interfaces.nsIBinaryInputStream);
                    cacheInstream.setInputStream(cacheIn);
                    data = cacheInstream.readBytes(cacheInstream.available());
                    remotecache.push( { path: path, host: connectedHost, data: data }); // add to local cache
                    cacheInstream.close();
                    if (!noRemoteViewUpdate)
                        changeRemoteView();
                    if (remember)
                        eval(remember);
                    return;
                }
                cacheDesc.close();
            } catch (ex) { }
        }
    }

    // do things backwards if deleting
    if (deletingRecursively)
    {
        eventQueue.unshift( { cmd: "LIST", parameter: hiddenmode ? "-al" : '', remember: remember } );
        eventQueue.unshift( { cmd: "PASV", parameter: "", remember: noRemoteViewUpdate } );
        eventQueue.unshift( { cmd: "CWD", parameter: path, remember: "" } );
        eventQueue.unshift( { cmd: "TYPE", parameter: "A", remember: "" } );
    }
    else
    {
        addEventQueue("TYPE", "A");
        addEventQueue("CWD", path);    // i thought i could do without you, CWD, but bugs #7588 and #7496 say otherwise
        addEventQueue("PASV", "", noRemoteViewUpdate);
        addEventQueue("LIST", hiddenmode ? "-al" : '', remember);
    }
    if (isReady && !noRemoteViewUpdate)    // get the ball rollin' if it isn't already
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
}
function afterList(remember, noRemoteViewUpdate)
{
    data_remember = "";
    if (refreshRemote)    // update cache
    {
        for (var x = 0; x < remotecache.length; ++x)
            if (remotecache[x].path == listPath && remotecache[x].host == connectedHost)
            {
                remotecache[x].data = data;
                break;
            }
    }
    else
        remotecache.push( { path: listPath, host: connectedHost, data: data }); // add to local cache

    // add to nsICache
    if (sessionsmode)
    {
        try {
            var cacheService = Components.classes["@mozilla.org/network/cache-service;1"]
                .getService(Components.interfaces.nsICacheService);
            var cacheSession = cacheService.createSession("fireftp", 0, true);
            var cacheDesc = cacheSession.openCacheEntry("ftp://" + connectedHost + listPath,
                Components.interfaces.nsICache.ACCESS_WRITE, false);
            var cacheOut = cacheDesc.openOutputStream(0);
            cacheOut.write(data, data.length);
            cacheOut.close();
            cacheDesc.close();
        } catch (ex) { debug(ex,22); }
    }

    if (!noRemoteViewUpdate)
        changeRemoteView();
    eval(remember);
}

// *************************************************************************************************
// ********************************************* RETR/REST *****************************************
// *************************************************************************************************

// execute RETR (and REST if necessary)
var retrieveLocalParent;
function retr()
{
    if (!isConnected)
        return;
    var fileList = gRemoteTree.view.selection;
    if (fileList.count == 0)
        return;

    var retrievePrompt = true;
    var retrieveSkipAll = false;
    var resume;
    var localParent = gLocalPath.value;
    retrieveLocalParent = localParent;
    var remoteParent = gRemotePath.value;

    for (var x = 0; x < gRemoteTree.view.rowCount; ++x)
        if (gRemoteTree.view.selection.isSelected(x))
        {
            var remotepath = gRemoteTree.view.getCellText(x, "remotename");
            var isDirectory = gRemoteTree.view.getCellText(x, "remoteattr").charAt(0) == 'd';

            if (remoteParent.charAt(remoteParent.length - 1) != '/')
                remotepath = remoteParent + '/' + remotepath;
            else
                remotepath = remoteParent + remotepath;

            var localpath = remotepath.substring(remoteParent.length + (remoteParent != "/" ? 1 : 0));
            if (slash == "\\")
                localpath = localpath.replace(/\x2f/g, "\\");
            if (localParent.charAt(localParent.length - 1) != slash)
                localpath = localParent + slash + localpath;
            else
                localpath = localParent + localpath;

            var index = checkRemoteCache(remoteParent);
            var files = parseListData(remotecache[index].data);
            var file = getLocalFileSpec(localpath);
            var filesIndex = 0;
            for (var y = 0; y < files.length; ++y)
                if (files[y].name == file.leafName)
                {
                    filesIndex = y;
                    break;
                }

            if (file.exists() && retrieveSkipAll)
                continue;

            // overwrite prompt
            resume = false;
            if (file.exists() && retrievePrompt && !isDirectory)
            {
                var response = new Object();
                response.value = 0;
                var windowHeight = document.getElementById('main-window').boxObject.height;
                var windowWidth = document.getElementById('main-window').boxObject.width;
                var timer = destructmode;

                if (file.fileSize < files[filesIndex].size)
                    resume = true;
                else
                    resume = false;

                window.openDialog("chrome://fireftp/content/confirmFileDialog.xul","confirmFileDialog",
                        "screenY="+(windowHeight/2 - 45)+",screenX="+(windowWidth/2 - 200)+
                        ",width=400,height=90,chrome,modal=yes,dialog=yes,resizable=yes", response, file.leafName, resume, false, timer);
                if (response.value == 1)
                    resume = false;
                else if (response.value == 2)
                {
                    retrievePrompt = false;
                    resume = false;
                }
                else if ((response.value == 3) || (response.value == 0))
                    continue;
                else if (response.value == 4)
                    resume = true;
                else if (response.value == 5)
                {
                    retrieveSkipAll = true;
                    continue;
                }
            }

            if (isDirectory)
            {
                try{
                    file.createDir();
                } catch (ex) {
                    error(strbundle.getString("failedDir") + " '" + remotepath + "' " + strbundle.getString("failedDir2"));
                    debug(ex,23);
                    continue;
                }
                if (!file.exists())
                {
                    error(strbundle.getString("failedDir") + " '" + remotepath + "' " + strbundle.getString("failedDir2"));
                    continue;
                }

                //XXX hack - \\ are erased during eval() so here we convert them to / and change them back later
                list(remotepath, "retrieveRecursive(\'" + remotepath + "\',\'" + localParent.replace(/\x5c/g, "/") + "\',\'"
                        + remoteParent + "\'," + retrievePrompt + "," + retrieveSkipAll + ")", true);
            }
            else
            {
                addEventQueue("TYPE", detectAscii(remotepath));
                addEventQueue("PASV", "", files[filesIndex].size);
                if (resume)
                {
                    addEventQueue("REST", file.fileSize);
                    addEventQueue("RETR", remotepath, localpath);
                }
                else
                    addEventQueue("RETR", remotepath, localpath);
            }
        }
    if (isReady && eventQueue.length)    // get the ball rollin' if it isn't already
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
}
// a RETR command sent from the folder view
function retrDir()
{
    if (!isConnected)
        return;
    if (gRemoteDirTree.view.selection.count == 0)
        return;
    var dir = gRemoteDirTree.view.selection.currentIndex;
    var localParent = gLocalPath.value;
    retrieveLocalParent = localParent;
    var remotepath = remotedircache[dir].path;
    var localpath = remotepath.substring(remotepath.lastIndexOf('/') + 1);

    if (localParent.charAt(localParent.length - 1) != slash)
        localpath = localParent + slash + localpath;
    else
        localpath = localParent + localpath;

    var localdir = getLocalFileSpec(localpath);

    try{
        localdir.createDir();
    } catch (ex) {
        error(strbundle.getString("failedDir") + " '" + remotepath + "' " + strbundle.getString("failedDir2"));
        debug(ex,24);
        return;
    }
    if (!localdir.exists())
    {
        error(strbundle.getString("failedDir") + " '" + remotepath + "' " + strbundle.getString("failedDir2"));
        return;
    }
    //XXX hack - \\ are erased during eval() so here we convert them to / and change them back later
    localpath = localpath.replace(/\x5c/g, "/");
    var retrievePrompt = true;
    var retrieveSkipAll = false;

    list(remotepath, "retrieveRecursive(\'" + remotepath + "\',\'" + localpath + "\',\'" + remotepath
            + "\'," + retrievePrompt + "," + retrieveSkipAll + ")", true);
    if (isReady && eventQueue.length)    // get the ball rollin' if it isn't already
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
}

// *************************************************************************************************
// *************************************** RETR/REST recursive *************************************
// *************************************************************************************************

function retrieveRecursive(parent, localParent, remoteParent, retrievePrompt, retrieveSkipAll)
{
    if (slash == "\\")    //XXX continuation of aforementioned hack, working around eval()
        localParent = localParent.replace(/\x2f/g, "\\");
    var resume;
    var files = parseListData(data);

    for (var x = 0; x < files.length; ++x)
    {
        var remotepath = files[x].name;
        var isDirectory = files[x].isDirectory;

        if (parent.charAt(parent.length - 1) != '/')
            remotepath = parent + '/' + remotepath;
        else
            remotepath = parent + remotepath;

        var localpath = remotepath.substring(remoteParent.length + (remoteParent != "/" ? 1 : 0));
        if (slash == "\\")
            localpath = localpath.replace(/\x2f/g, "\\");
        if (localParent.charAt(localParent.length - 1) != slash)
            localpath = localParent + slash + localpath;
        else
            localpath = localParent + localpath;

        var file = getLocalFileSpec(localpath);
        if (file.exists() && retrieveSkipAll)
            continue;
        resume = false;
        if (file.exists() && retrievePrompt && !isDirectory)
        {
            var response = new Object();
            response.value = 0;
            var windowHeight = document.getElementById('main-window').boxObject.height;
            var windowWidth = document.getElementById('main-window').boxObject.width;
            var timer = destructmode;

            if (file.fileSize < files[x].size)
                resume = true;
            else
                resume = false;

            window.openDialog("chrome://fireftp/content/confirmFileDialog.xul","confirmFileDialog",
                    "screenY="+(windowHeight/2 - 45)+",screenX="+(windowWidth/2 - 200)+
                    ",width=400,height=90,chrome,modal=yes,dialog=yes,resizable=yes", response, file.leafName, resume, false, timer);
            if (response.value == 1)
                resume = false;
            else if (response.value == 2)
            {
                retrievePrompt = false;
                resume = false;
            }
            else if ((response.value == 3) || (response.value == 0))
                continue;
            else if (response.value == 4)
                resume = true;
            else if (response.value == 5)
            {
                retrieveSkipAll = true;
                continue;
            }
        }

        if (isDirectory)
        {
            try{
                file.createDir();
            } catch (ex) {
                error(strbundle.getString("failedDir") + " '" + remotepath + "' " + strbundle.getString("failedDir2"));
                debug(ex,25);
                continue;
            }
            if (!file.exists())
            {
                error(strbundle.getString("failedDir") + " '" + remotepath + "' " + strbundle.getString("failedDir2"));
                continue;
            }

            //XXX hack - \\ are erased during eval() so here we convert them to / and change them back later
            list(remotepath, "retrieveRecursive(\'" + remotepath + "\',\'" + localParent.replace(/\x5c/g, "/") + "\',\'" + remoteParent
                    + "\'," + retrievePrompt + "," + retrieveSkipAll + ")", true);
        }
        else
        {
            addEventQueue("TYPE", detectAscii(remotepath));
            addEventQueue("PASV", "", files[x].size);
            if (resume)
            {
                addEventQueue("REST", file.fileSize);
                addEventQueue("RETR", remotepath, localpath);
            }
            else
                addEventQueue("RETR", remotepath, localpath);
        }
    }
}

// *************************************************************************************************
// ******************************************* STOR/APPE *******************************************
// *************************************************************************************************

// execute a STOR command (or APPE if necessary)
var storeRemoteParent;
function stor()
{
    if (!isConnected)
        return;
    var fileList = gLocalTree.view.selection;
    if (fileList.count == 0)
        return;

    var storePrompt = true;
    var storeSkipAll = false;
    var resume;
    var localParent = gLocalPath.value;
    var remoteParent = gRemotePath.value;
    storeRemoteParent = remoteParent;
    var index = checkRemoteCache(remoteParent);
    var remotefiles = parseListData(remotecache[index].data);

    for (var x = 0; x < gLocalTree.view.rowCount; ++x)
        if (gLocalTree.view.selection.isSelected(x))
        {
            var localpath = gLocalTree.view.getCellText(x, "localname");
            var isDirectory = gLocalTree.view.getCellText(x, "localsize") == "";

            if (localParent.charAt(localParent.length - 1) != slash)
                localpath = localParent + slash + localpath;
            else
                localpath = localParent + localpath;

            var remotepath = localpath.substring(localParent.length + (localParent.charAt(localParent.length - 1) != slash ? 1 : 0));
            remotepath = remotepath.replace(/\x5c/g, "/");
            if (remoteParent.charAt(remoteParent.length - 1) != '/')
                remotepath = remoteParent + '/' + remotepath;
            else
                remotepath = remoteParent + remotepath;

            var localfile = getLocalFileSpec(localpath);
            var exists = false;
            var theremotesize = 0;

            resume = false;
            if (storePrompt)
                for (var y = 0; y < remotefiles.length; ++y)
                    if (remotefiles[y].name == localfile.leafName)
                    {
                        exists = true;
                        if (localfile.fileSize > remotefiles[y].size)
                        {
                            resume = true;
                            theremotesize = remotefiles[y].size;
                        }
                        else
                            resume = false;
                        break;
                    }
            if (exists && storeSkipAll)
                continue;
            if (exists && storePrompt && !isDirectory)
            {
                var response = new Object();
                response.value = 0;
                var windowHeight = document.getElementById('main-window').boxObject.height;
                var windowWidth = document.getElementById('main-window').boxObject.width;
                var timer = destructmode;

                window.openDialog("chrome://fireftp/content/confirmFileDialog.xul","confirmFileDialog",
                        "screenY="+(windowHeight/2 - 45)+",screenX="+(windowWidth/2 - 200)+
                        ",width=400,height=90,chrome,modal=yes,dialog=yes,resizable=yes",
                        response, localfile.leafName, resume, false, timer, true);
                if (response.value == 1)
                    resume = false;
                else if (response.value == 2)
                {
                    storePrompt = false;
                    resume = false;
                }
                else if ((response.value == 3) || (response.value == 0))
                    continue;
                else if (response.value == 4)
                    resume = true;
                else if (response.value == 5)
                {
                    storeSkipAll = true;
                    continue;
                }
            }

            if (isDirectory)
            {
                if (!exists)
                {
                    addEventQueue("MKD", remotepath);
                    storeRecursive(localpath, localParent, remoteParent, true);
                }
                else
                {

                    //XXX hack - \\ are erased during eval() so here we convert them to / and change them back later
                    list(remotepath, "storeRecursive(\'" + localpath.replace(/\x5c/g, "/")
                            + "\',\'" + localParent.replace(/\x5c/g, "/") + "\',\'" + remoteParent
                            + "\',false," + storePrompt + "," + storeSkipAll + ")", true);
                }
            }
            else
            {
                addEventQueue("TYPE", detectAscii(remotepath));
                addEventQueue("PASV");
                if (resume)
                    addEventQueue("APPE", remotepath, new Array(localpath, theremotesize));
                else
                    addEventQueue("STOR", remotepath, localpath);
            }
        }
    if (isReady && eventQueue.length)    // get the ball rollin' if it isn't already
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
}
// a STOR command sent from the folder view
function storDir()
{
    if (!isConnected)
        return;
    if (gLocalDirTree.view.selection.count == 0)
        return;
    var dir = gLocalDirTree.view.selection.currentIndex;
    var remoteParent = gRemotePath.value;
    storeRemoteParent = remoteParent;
    var localpath = localdircache[dir].path;
    var remotepath = localpath.substring(localpath.lastIndexOf(slash) + 1);

    if (remoteParent.charAt(remoteParent.length - 1) != '/')
        remotepath = remoteParent + '/' + remotepath;
    else
        remotepath = remoteParent + remotepath;
    var localdir = getLocalFileSpec(localpath);
    var index = checkRemoteCache(remoteParent);
    var remotefiles = parseListData(remotecache[index].data);
    var storePrompt = true;
    var storeSkipAll = false;

    var exists = false;
    for (var y = 0; y < remotefiles.length; ++y)
        if (remotefiles[y].name == localpath.substring(localpath.indexOf(slash) + 1))
        {
            exists = true;
            break;
        }

    if (!exists)
    {
        addEventQueue("MKD", remotepath);
        storeRecursive(localpath, localpath, remotepath, true);
    }
    else
    {
        //XXX hack - \\ are erased during eval() so here we convert them to / and change them back later
        localpath = localpath.replace(/\x5c/g, "/");

        list(remotepath, "storeRecursive(\'" + localpath + "\',\'" + localpath + "\',\'" + remotepath +
                "\',false," + storePrompt + "," + storeSkipAll + ")", true);
    }

    if (isReady && eventQueue.length)    // get the ball rollin' if it isn't already
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
}

// *************************************************************************************************
// *************************************** STOR/APPE recursively ***********************************
// *************************************************************************************************

function storeRecursive(parent, localParent, remoteParent, newDir, storePrompt, storeSkipAll)
{
    if (slash == "\\")    //XXX continuation of aforementioned hack, working around eval()
    {
        localParent = localParent.replace(/\x2f/g, "\\");
        parent = parent.replace(/\x2f/g, "\\");
    }
    var resume;
    var remotefiles = newDir ? new Array : parseListData(data);
    var localfiles = new Array;

    try {
        var dir = Components.classes['@mozilla.org/file/local;1'].createInstance(Components.interfaces.nsILocalFile);
        dir.initWithPath(parent);
        var entries = dir.directoryEntries;
        while (entries.hasMoreElements())
        {
            var file = entries.getNext().QueryInterface(Components.interfaces.nsIFile);
            if (file.exists() && (!file.isHidden() || hiddenmode))
                localfiles.push(file);
        }
    } catch (ex) {
        debug(ex,26);
        return;    // skip this directory
    }

    for (var x = 0; x < localfiles.length; ++x)
    {
        var localpath = localfiles[x].path;
        var isDirectory = localfiles[x].isDirectory();

        var remotepath = localpath.substring(localParent.length + (localParent.charAt(localParent.length - 1) != slash ? 1 : 0));
        remotepath = remotepath.replace(/\x5c/g, "/");
        if (remoteParent.charAt(remoteParent.length - 1) != '/')
            remotepath = remoteParent + '/' + remotepath;
        else
            remotepath = remoteParent + remotepath;

        var exists = false;
        var theremotesize = 0;
        resume = false;
        if (storePrompt)
            for (var y = 0; y < remotefiles.length; ++y)
                if (remotefiles[y].name == localfiles[x].leafName)
                {
                    exists = true;
                    if (localfile.fileSize > remotefiles[y].size)
                    {
                        resume = true;
                        theremotesize = remotefiles[y].size;
                    }
                    else
                        resume = false;
                    break;
                }

        if (exists && storeSkipAll)
            continue;
        if (exists && storePrompt && !isDirectory)
        {
            var response = new Object();
            response.value = 0;
            var windowHeight = document.getElementById('main-window').boxObject.height;
            var windowWidth = document.getElementById('main-window').boxObject.width;
            var timer = destructmode;

            window.openDialog("chrome://fireftp/content/confirmFileDialog.xul","confirmFileDialog",
                    "screenY="+(windowHeight/2 - 45)+",screenX="+(windowWidth/2 - 200)+
                    ",width=400,height=90,chrome,modal=yes,dialog=yes,resizable=yes",
                    response, localfiles[x].leafName, resume, false, timer, true);
            if (response.value == 1)
                resume = false;
            else if (response.value == 2)
            {
                storePrompt = false;
                resume = false;
            }
            else if ((response.value == 3) || (response.value == 0))
                continue;
            else if (response.value == 4)
                resume = true;
            else if (response.value == 5)
            {
                storeSkipAll = true;
                continue;
            }
        }

        if (isDirectory)
        {
            if (!exists)
            {
                addEventQueue("MKD", remotepath);
                storeRecursive(localpath, localParent, remoteParent, true);
            }
            else
            {

                //XXX hack - \\ are erased during eval() so here we convert them to / and change them back later
                list(remotepath, "storeRecursive(\'" + localpath.replace(/\x5c/g, "/")
                        + "\',\'" + localParent.replace(/\x5c/g, "/") + "\',\'" + remoteParent
                        + "\',false," + storePrompt + "," + storeSkipAll + ")", true);
            }
        }
        else
        {
            addEventQueue("TYPE", detectAscii(remotepath));
            addEventQueue("PASV");
            if (resume)
                addEventQueue("APPE", remotepath, new Array(localpath, theremotesize));
            else
                addEventQueue("STOR", remotepath, localpath);
        }
    }
}

// *************************************************************************************************
// ************************************* remote folder functions ***********************************
// *************************************************************************************************

// helper function
function checkRemoteCache(path)
{
    for (var x = 0; x < remotecache.length; ++x)
        if (remotecache[x].path == path && remotecache[x].host == connectedHost)
            return x;
    return -1;
}
// helper function
function checkIsListing()
{
    for (var x = 0; x < eventQueue.length; ++x)
        if (eventQueue[x].cmd.indexOf("LIST") != -1)
            return true;
    return false;
}

function remoteDirChangeHelper(index, toggle)
{
    if (checkIsListing() || (eventQueue.length && checkRemoteCache(remotedircache[index].path) == -1))
    {
        for (var x = 0; x < remotedircache.length; ++x)
            if (remotedircache[x].path == gRemotePath.value)
            {
                gRemoteDirTree.view.selection.select(x);
                gRemoteDirTree.treeBoxObject.ensureRowIsVisible(x);
                break;
            }
        return;
    }

    var state = remotedircache[index].open;

    var gFormHistory = Components.classes["@mozilla.org/satchel/form-history;1"]
        .getService(Components.interfaces.nsIFormHistory);
    gFormHistory.addEntry(gRemotePath.getAttribute("autocompletesearchparam"), remotedircache[index].path);

    list(remotedircache[index].path, "remoteDirChangeHelper2(" + index + ", " + state + ", " + toggle + ")");
}
function remoteDirChangeHelper2(index, state, toggle)
{
    if (!state && !remotedircache[index].empty)
    {
        remotedircache[index].open = false;
        gRemoteDirTree.view.toggleOpenState(index);
    }
    if (toggle)
        gRemoteDirTree.view.toggleOpenState(index);
    gRemoteDirTree.view.selection.select(index);

    if (remoteLastRowSeen)
    {
        gRemoteDirTree.treeBoxObject.ensureRowIsVisible(index + (remoteLastRowSeen - index - 1));
        remoteLastRowSeen = 0;
    }
    else
        gRemoteDirTree.treeBoxObject.ensureRowIsVisible(index);

    refreshRemote = false;
    if (moreToRemember)
        eval(moreToRemember);
}
// does not execute a CDUP command literally - only locally changes directory
function onRemoteCDUP()
{
    if (!gRemoteDirTree.view || !isConnected)
        return;
    var parentIndex = gRemoteDirTree.view.
        getParentIndex(gRemoteDirTree.view.selection.currentIndex);
    if (parentIndex != -1)
    {
        gRemoteDirTree.view.selection.select(parentIndex);
        remoteDirChangeHelper(parentIndex);
    }
}
var remoteLastRowSeen = 0;
function onRemoteDirClick(event)
{
    if (isConnected && event.button == 0)
    {
        var row = {};
        var col = {};
        var child = {};
        gRemoteDirTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);
        var index = gRemoteDirTree.view.selection.currentIndex;
        remoteLastRowSeen = gRemoteDirTree.treeBoxObject.getLastVisibleRow();    // have you seen this row?

        if (index == row.value && remotedircache[index].path != gRemotePath.value)
            remoteDirChangeHelper(index);
    } else if (event.button == 1 && !document.getElementById('remotePasteContext').disabled)
        remoteDirPaste();
}
var remoteDirKeyDownIndex;    // global variables - yummy, as they say (you know who you are)
var remoteDirKeyDownOpen;
function onRemoteDirKeyDown(event)
{
    if (!isConnected)
        return;
    remoteDirKeyDownIndex = gRemoteDirTree.view.selection.currentIndex;
    remoteDirKeyDownOpen = remotedircache[remoteDirKeyDownIndex].open;
}
function onRemoteDirKeyPress(event)
{
    if (!isConnected)
        return;
    var index = gRemoteDirTree.view.selection.currentIndex;
    switch(event.keyCode)
    {
        case 37:    // left
            if (remoteDirKeyDownIndex != index)
            {
                gRemoteDirTree.view.selection.select(index);
                remoteDirChangeHelper(index);
            }
            break;
        case 38:    // up
            if (!index)
                return;

            if (remotedircache[index - 1].open)
                remoteDirChangeHelper(index - 1);
            else
                remoteDirChangeHelper(index - 1, true);
            gRemoteDirTree.view.selection.select(index);
            break;
        case 40:    // down
            if (index == remotedircache.length - 1)
            {
                gRemoteDirTree.view.selection.select(index - 1);    // this shouldn't work but it does
                return;
            }

            if (remotedircache[index + 1].open)
                remoteDirChangeHelper(index + 1);
            else
                remoteDirChangeHelper(index + 1, true);
            gRemoteDirTree.view.selection.select(index);
            break;
        case 39:    // right
            if (remoteDirKeyDownOpen && !remotedircache[index].empty)
                remoteDirChangeHelper(index + 1);
            break;
        case 8: // backspace
            onRemoteCDUP();
            break;
        case 116: // F5
            event.preventDefault();
            refreshRemoteView();
            break;
        case 113: // F2
            renameRemoteFile(remotedircache[index].path, true);
            break;
        case 46: // delete
            onRemoteDirDeleteContext();
            break;
        case 93: // context menu
            var x = {};
            var y = {};
            var width = {};
            var height = {};
            var childrenBoxX = document.getElementById('remotedirtreechildren').boxObject.x;
            var childrenBoxY = document.getElementById('remotedirtreechildren').boxObject.y;

            gRemoteDirTree.treeBoxObject.getCoordsForCellItem(index, "remotedirname", "text", x, y, width, height);
            document.getElementById('remotedirmenu').showPopup(document.getElementById('remotedirtreechildren'), childrenBoxX + 75, childrenBoxY + y.value + 30, "context");
            break;
        default:
            break;
    }
    if (event.ctrlKey)
    {
        switch(event.charCode)
        {
            case 120:    // ctrl-x
                event.preventDefault();
                remoteDirCut();
                break;
            case 118:    // ctrl-v
                event.preventDefault();
                remoteDirPaste();
                break;
            default:
                break;
        }
    }
}

// *************************************************************************************************
// *************************************** remote context menus ************************************
// *************************************************************************************************

function onRemoteDirRenameContext()
{
    if (!isConnected)
        return;
    if (eventQueue.length)
        return;
    var index = gRemoteDirTree.view.selection.currentIndex;
    renameRemoteFile(remotedircache[index].path, true);
}
function onRemoteRenameContext()
{
    if (!isConnected)
        return;
    if (gRemoteDirTree.view.selection.count == 0)
        return;
    if (eventQueue.length)
        return;
    var fileList = gRemoteTree.view.selection;
    if (fileList.count == 0)
        return;
    var thepath = gRemoteTree.view.getCellText(fileList.currentIndex, "remotename");
    if (gRemotePath.value.charAt(gRemotePath.value.length - 1) != '/')
        thepath = gRemotePath.value + '/' + thepath;
    else
        thepath = gRemotePath.value + thepath;
    renameRemoteFile(thepath, false);
}
function onRemoteDirDeleteContext()
{
    if (!isConnected)
        return;
    if (gRemoteDirTree.view.selection.count == 0)
        return;
    if (eventQueue.length)
        return;
    if (!window.confirm(strbundle.getString("confirmDeleteDir")))
        return;

    var index = gRemoteDirTree.view.selection.currentIndex;
    var whatToDo = refreshmode ? "onRemoteCDUP();refreshRemoteView()" : "";
    eventQueue.unshift( { cmd: "RMD", parameter: remotedircache[index].path, remember: whatToDo } );
    list(remotedircache[index].path, "deleteRecursive(\'" + remotedircache[index].path + "\')", true, true);

    if (isReady)    // get the ball rollin' if it isn't already
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
}
function onRemoteDeleteContext()
{
    if (!isConnected)
        return;
    if (eventQueue.length)
        return;
    var fileList = gRemoteTree.view.selection;
    if (fileList.count == 0)
        return;

    if (!window.confirm(strbundle.getString("confirmDelete") + " " + fileList.count + " " + strbundle.getString("confirmDelete2")))
        return;

    var thecount = 0;
    for (var x = 0; x < gRemoteTree.view.rowCount; ++x)
        if (gRemoteTree.view.selection.isSelected(x))
        {
            var afterLastDelete = (thecount == 0 && refreshmode)
                ? "refreshRemoteView()" : "";
            ++thecount;
            var remotepath = gRemoteTree.view.getCellText(x, "remotename");
            var isDirectory = gRemoteTree.view.getCellText(x, "remoteattr").charAt(0) == 'd';
            if (gRemotePath.value.charAt(gRemotePath.value.length - 1) != '/')
                remotepath = gRemotePath.value + '/' + remotepath;
            else
                remotepath = gRemotePath.value + remotepath;
            if (isDirectory)
            {
                eventQueue.unshift( { cmd: "RMD", parameter: remotepath, remember: afterLastDelete } );
                list(remotepath, "deleteRecursive(\'" + remotepath + "\')", true, true);
            }
            else
                eventQueue.unshift( { cmd: "DELE", parameter: remotepath, remember: afterLastDelete } );
        }
    if (isReady)    // get the ball rollin' if it isn't already
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
}
function deleteRecursive(parent)
{
    var files = parseListData(data);

    for (var x = 0; x < files.length; ++x)
    {
        var remotepath = files[x].name;
        var isDirectory = files[x].isDirectory;

        if (parent.charAt(parent.length - 1) != '/')
            remotepath = parent + '/' + remotepath;
        else
            remotepath = parent + remotepath;
        if (isDirectory)
        {
            eventQueue.unshift( { cmd: "RMD", parameter: remotepath, remember: "" } );
            list(remotepath, "deleteRecursive(\'" + remotepath + "\')", true, true);
        }
        else
            eventQueue.unshift( { cmd: "DELE", parameter: remotepath, remember: "" } );
    }
}

// *************************************************************************************************
// *************************************** remote path changes *************************************
// *************************************************************************************************

var remotePathFocus;
function onRemotePathFocus(event)
{
    remotePathFocus = gRemotePath.value;
}
function onRemotePathBlur(event)
{
    gRemotePath.value = remotePathFocus;
}
function onRemotePathChange()
{
    gRemotePath.value = gRemotePath.value.replace(/\x5c/g, "/");
    if (gRemotePath.value != '/' && gRemotePath.value.charAt(gRemotePath.value.length - 1) == '/')
        gRemotePath.value =    gRemotePath.value.substring(0,gRemotePath.value.length - 1);
    if (gRemotePath.value.charAt(0) != '/')
        gRemotePath.value = '/' + gRemotePath.value;
    var newDir = gRemotePath.value;
    gRemoteDirTree.focus();
    var found = false;
    for (var x = 0; x < remotedircache.length; ++x)
        if (remotedircache[x].path == newDir)
        {
            found = true;
            remotePathFocus = newDir;
            remoteDirChangeHelper(x);
            return;
        }
    if (checkIsListing() || eventQueue.length)
    {
        gRemotePath.value = remotePathFocus;
        return;
    }
    findSubdirectory(newDir, -1);
}
function findSubdirectory(newDir, previousParent)
{
    for (var x = remotedircache.length - 1; x > -1; --x)
        if (newDir.indexOf(remotedircache[x].path) == 0)
        {
            moreToRemember = "findSubdirectory2(\"" + newDir + "\", " + x + ", " + previousParent + ")";
            remoteDirChangeHelper(x);
            return;
        }
}
function findSubdirectory2(newDir, findParent, previousParent)
{
    moreToRemember = "";
    for (var x = 0; x < remotedircache.length; ++x)
        if (remotedircache[x].path == newDir)
        {
            remotePathFocus = newDir;
            remoteDirChangeHelper(x);
            return;
        }
    if (previousParent == findParent)
    {
        // directory not found in conventional sense - don't freak out
        // just create directories above as if it were there and list
        //remotedircache = new Array( {path:newDir, open:true, empty:false, children:-1} );
        remotedircache = new Array( {path:'/', open:true, empty:false, children:-1} );
        hiddenremotedircache = new Array;

        var tempParent = "";
        newDir = newDir.substring(1);
        while (true)
        {
            if (newDir.indexOf('/') != -1)
            {
                tempParent += '/' + newDir.substring(0, newDir.indexOf('/'));
                remotedircache.push( {path:tempParent, open:true, empty:false, children:-1} );
                newDir = newDir.substring(newDir.indexOf('/') + 1);
            }
            else
            {
                tempParent += '/' + newDir;
                remotedircache.push( {path:tempParent, open:true, empty:false, children:-1} );
                break;
            }
        }
        gRemotePath.value = tempParent;
        onRemotePathChange();
        return;

        /*    old way of doing things - freak out - change to previous good directory
        gRemotePath.value = remotePathFocus;
        for (var x = 0; x < remotedircache.length; ++x)
            if (remotedircache[x].path == remotePathFocus)
            {
                remoteDirChangeHelper(x);
                break;
            }
        error(strbundle.getString("dirNotFound"));
        return;*/
    }
    findSubdirectory(newDir, findParent);
}

// *************************************************************************************************
// *************************************** remote mouse events *************************************
// *************************************************************************************************

function onRemoteDblClick(event)
{
    if (!isConnected)
        return;
    if (event.button != 0)
        return;
    var target = event.originalTarget;
    if (target.localName != "treechildren")
        return;

    var fileList = gRemoteTree.view.selection;
    if (fileList.count == 0)
        return;

    if (gRemoteTree.view.getCellText(fileList.currentIndex, "remoteattr").charAt(0) == 'd')
    {
        var thepath = gRemoteTree.view.getCellText(fileList.currentIndex, "remotename");
        if (gRemotePath.value.charAt(gRemotePath.value.length - 1) != '/')
            thepath = gRemotePath.value + '/' + thepath;
        else
            thepath = gRemotePath.value + thepath;
        if (checkIsListing() || (eventQueue.length && checkRemoteCache(thepath) == -1))
            return;
        gRemotePath.value = thepath;
        onRemotePathChange();
    }
    else if (gRemoteTree.view.getCellText(fileList.currentIndex, "remoteattr").charAt(0) == 'l')
    {
        var thepath = gRemoteTree.view.getCellText(fileList.currentIndex, "remotename");
        var index = checkRemoteCache(gRemotePath.value);
        var files = parseListData(remotecache[index].data);

        for (var x = 0; x < files.length; ++x)
            if (files[x].name == thepath)
            {
                var linkedFile = files[x].symlink;
                var parentPath = gRemotePath.value;
                while (linkedFile.indexOf("./") == 0 || linkedFile.indexOf("../") == 0)
                {
                    if (linkedFile.indexOf("./") == 0)
                        linkedFile = linkedFile.substring(2);
                    else
                    {
                        linkedFile = linkedFile.substring(3);
                        parentPath = parentPath.substring(0, parentPath.lastIndexOf('/') ? parentPath.lastIndexOf('/') : 1);
                    }
                }
                if (parentPath.charAt(parentPath.length - 1) != '/')
                    thepath = parentPath + '/' + linkedFile;
                else
                    thepath = parentPath + linkedFile;

                if (checkIsListing() || (eventQueue.length && checkRemoteCache(thepath) == -1))
                    return;
                addEventQueue("CWD", thepath);
                if (isReady)    // get the ball rollin' if it isn't already
                    writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
            }
    }
    else
        retr();
}
function onRemoteClick(event)
{
    if (!isConnected)
        return;
    if (event.button == 1 && !document.getElementById('remotePasteContext').disabled)
        remotePaste();
}
function onRemoteMouseOver(event)
{
    if (gRemoteTree.view.rowCount)
        document.getElementById('statustxt').label =
        strbundle.getString("remoteListing") + " " + gRemoteTree.view.rowCount + " " + strbundle.getString("objects") + " " + commas(remotesize) + " KB";
    else
        document.getElementById('statustxt').label = strbundle.getString("remoteListingNoObjects");
}

// *************************************************************************************************
// *************************************** remote key commands *************************************
// *************************************************************************************************

function onRemoteKeyPress(event)
{
    if (!isConnected)
        return;
    if (event.keyCode == 13)
    {
        var fileList = gRemoteTree.view.selection;
        if (fileList.count == 0)
            return;
        if (fileList.count == 1 && gRemoteTree.view.getCellText(fileList.currentIndex, "remoteattr").charAt(0) == 'd')
        {
            var thepath = gRemoteTree.view.getCellText(fileList.currentIndex, "remotename");
            if (gRemotePath.value.charAt(gRemotePath.value.length - 1) != '/')
                thepath = gRemotePath.value + '/' + thepath;
            else
                thepath = gRemotePath.value + thepath;
            if (checkIsListing() || (eventQueue.length && checkRemoteCache(thepath) == -1))
                return;
            gRemotePath.value = thepath;
            onRemotePathChange();
            gRemoteTree.focus();
        }
        else
            retr();
    }
    else if (event.ctrlKey && (event.which == 65 || event.which == 97)) // ctrl-a: select all
    {
        event.preventDefault();
        gRemoteTree.view.selection.selectAll();        // previous hack had window.blur() after this, now it's ok
    }
    else if (event.ctrlKey && event.which == 32)    // ctrl-space, select or deselect
        gRemoteTree.view.selection.toggleSelect(gRemoteTree.view.selection.currentIndex);
    else if (event.keyCode == 8)    // backspace
        onRemoteCDUP();
    else if (event.keyCode == 116) // F5
    {
        event.preventDefault();
        refreshRemoteView();
    }
    else if (event.keyCode == 113) // F2
        onRemoteRenameContext();
    else if (event.charCode == 109 && event.ctrlKey)    // ctrl-m
    {
        event.preventDefault();
        makeRemoteDirectory();
    }
    else if (event.keyCode == 46)    // del
        onRemoteDeleteContext();
    else if (event.keyCode == 93) // context menu
    {
        var fileList = gLocalTree.view.selection;
        if (fileList.count == 0)
            return;
        var index = fileList.currentIndex;
        var x = {};
        var y = {};
        var width = {};
        var height = {};
        var childrenBoxX = document.getElementById('remotetreechildren').boxObject.x;
        var childrenBoxY = document.getElementById('remotetreechildren').boxObject.y;

        gRemoteTree.treeBoxObject.getCoordsForCellItem(index, "remotename", "text", x, y, width, height);
        document.getElementById('remotemenu').showPopup(document.getElementById('remotetreechildren'), childrenBoxX + 75, childrenBoxY + y.value + 30, "context");
    }
    else if (event.charCode == 112 && event.ctrlKey)    // ctrl-p
    {
        event.preventDefault();
        getRemoteProperties();
    }
    else if (event.charCode == 120 && event.ctrlKey)    // ctrl-x
    {
        event.preventDefault();
        remoteCut();
    }
    else if (event.charCode == 118 && event.ctrlKey)    // ctrl-v
    {
        event.preventDefault();
        remotePaste();
    }
}

// *************************************************************************************************
// *************************************** highlighting multiple rows ******************************
// *************************************************************************************************

var remoteMouseDownRow;
var remoteMouseDownOnName;
var remoteMouseDownPressed;
var remoteMouseDirection;
var remoteMousePreviousY;

function onRemoteMouseDown(event)
{
    if (event.target.getAttribute('id') != 'remotetreechildren')
        return;
    remoteMouseDownPressed = true;
    var row = {};
    var col = {};
    var child = {};
    var x = {};
    var y = {};
    var width = {};
    var height = {};
    var childrenBoxX = document.getElementById('remotetreechildren').boxObject.x;
    var childrenBoxY = document.getElementById('remotetreechildren').boxObject.y;
    gRemoteTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);
    gRemoteTree.treeBoxObject.getCoordsForCellItem (row.value, "remotename", "text", x, y, width, height);
    if (row.value == -1)
    {
        gRemoteTree.view.selection.clearSelection();
        row.value = gRemoteTree.view.rowCount - 1;
    }
    remoteMouseDownRow = row.value;
    remoteMouseDownOnName = event.pageX - childrenBoxX < x.value + width.value ? true : false;
    if (remoteMouseDownOnName)
        dragSessionEnabled = true;
    else
        dragSessionEnabled = false;
}
function extendRemoteSelectionUpwards()
{
    if (remoteMouseDirection || !remoteMouseDownPressed)
        return;
    if (gRemoteTree.treeBoxObject.getFirstVisibleRow() == 0)
    {
        gRemoteTree.view.selection.rangedSelect(remoteMouseDownRow, gRemoteTree.treeBoxObject.getFirstVisibleRow(), false);
        return;
    }
    gRemoteTree.treeBoxObject.ensureRowIsVisible(gRemoteTree.treeBoxObject.getFirstVisibleRow() - 1);
    gRemoteTree.view.selection.rangedSelect(remoteMouseDownRow, gRemoteTree.treeBoxObject.getFirstVisibleRow(), false);
    if (remoteMouseDownPressed)
        setTimeout("extendRemoteSelectionUpwards()", 100);
}
function extendRemoteSelectionDownwards()
{
    if (!remoteMouseDirection || !remoteMouseDownPressed)
        return;
    if (gRemoteTree.view.rowCount - 1 < gRemoteTree.treeBoxObject.getLastVisibleRow())
    {
        gRemoteTree.view.selection.rangedSelect(remoteMouseDownRow, gRemoteTree.treeBoxObject.getLastVisibleRow(), false);
        return;
    }
    gRemoteTree.treeBoxObject.ensureRowIsVisible(gRemoteTree.treeBoxObject.getLastVisibleRow() + 1);
    gRemoteTree.view.selection.rangedSelect(remoteMouseDownRow, gRemoteTree.treeBoxObject.getLastVisibleRow(), false);
    if (remoteMouseDownPressed)
        setTimeout("extendRemoteSelectionDownwards()", 100);
}
function onRemoteMouseMove(event)    // does pageX or clientX make a difference?
{
    if (remoteMouseDownPressed && !event.ctrlKey && !dragSessionEnabled)
    {
        var row = {};
        var col = {};
        var child = {};
        if (remoteMousePreviousY)
            remoteMouseDirection = event.pageY - remoteMousePreviousY > 0 ? true : false;
        remoteMousePreviousY = event.pageY;
        if (event.pageY < document.getElementById('remotetreechildren').boxObject.y)
        {
            extendRemoteSelectionUpwards();
            return;
        }
        else if (event.pageY > document.getElementById('remotetreechildren').boxObject.y + document.getElementById('remotetreechildren').boxObject.height)
        {
            extendRemoteSelectionDownwards();
            return;
        }
        gRemoteTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);
        if (row.value == -1)
            return;
        gRemoteTree.view.selection.rangedSelect(remoteMouseDownRow, row.value, false);
    }
}
function onRemoteMouseUp(event)
{
    remoteMouseDownPressed = false;
}

// *************************************************************************************************
// *************************************** list data parser ****************************************
// *************************************************************************************************

function parseListData(thedata)
{
    /* Unix style:                     drwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog
     * Alternate Unix style:           drwxr-xr-x 1 user01 ftp 512 Jan 29 1997  prog
     * Alternate Unix style:           drwxr-xr-x 1 1      1   512 Jan 29 23:32 prog
     * A symbolic link in Unix style:  lrwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog -> prog2000
     * MS-DOS style:                   01-29-97 11:32PM <DIR> prog
     * Novell Style:                   drwxr-xr-x 1 user01     512 Jan 29 23:32 prog
     * OS/2 style:                     0           DIR 01-29-97  23:32  PROG
     * OS/2 style:                     2243        RA  04-05-103 00:22  PJL
     * OS/2 style:                     60              11-18-104 06:54  chkdsk.log
     * AIX style:                      -rw-r--r-- 1 sys   sys   30 05 Nov 2003  foo.txt
     *
     * CURRENTLY NOT SUPPORTED: (are these even used anymore?  i can't find any ftp servers using these)
     *  Macintosh style:       drwxr-xr-x folder 0 Jan 29 23:32 prog
     */

    debug(thedata,0);

    var treeitem = thedata.split("\r\n");

    // some ftp servers send 'count <number>' or 'total <number>' first
    if (treeitem.length && (treeitem[0].indexOf("count") == 0 || treeitem[0].indexOf("total") == 0))
        treeitem.shift();

    for (var x = 0; x < treeitem.length; ++x)
    {
        if (!treeitem[x]) // some servers put in blank lines b/w entries, aw, for cryin' out loud
        {
            treeitem.splice(x, 1);
            --x;
            continue;
        }
        var temp = treeitem[x];
        treeitem[x] = treeitem[x].split(" ");
        if (!parseInt(treeitem[x][0].charAt(0)) && treeitem[x][0].charAt(0) != '0') // unix style - so much simpler with you guys
        {
            var months = "Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec";
            var offset = 0;
            if (treeitem[x][4].search(months) != -1)    // added to support novell servers
                offset = 1;
            var name = temp.substring(temp.indexOf(treeitem[x][7 - offset]) + treeitem[x][7 - offset].length + 1, temp.length);
            var symlink = "";
            name = name.substring(name.search(/[^\s]/));
            if (treeitem[x][0].charAt(0) == 'l')
            {
                symlink = name;
                name = name.substring(0, name.indexOf("->") - 1);
                symlink = symlink.substring(symlink.indexOf("->") + 3);
            }
            treeitem[x] = {
                attr: treeitem[x][0],
                hardLink: treeitem[x][1],
                user: treeitem[x][2],
                group: (offset ? "" : treeitem[x][3]),
                size: treeitem[x][4 - offset],
                date: treeitem[x][5 - offset] + ' ' + treeitem[x][6 - offset] + ' ' + treeitem[x][7 - offset],
                name: (name.lastIndexOf('/') == -1 ? name : name.substring(name.lastIndexOf('/') + 1)),
                isDirectory: treeitem[x][0].charAt(0) == 'd',
                isSymlink: treeitem[x][0].charAt(0) == 'l',
                symlink: symlink
            };
        }
        else if (treeitem[x][0].indexOf('-') == -1) // os/2 style
        {
            var offset = 0;
            if (treeitem[x][2].indexOf(':') != -1)    // if "DIR" and "A" are missing
                offset = 1;
            var rawDate = treeitem[x][2 - offset].split("-");
            var rawTime = treeitem[x][3 - offset];
            var timeOrYear = rawTime;
            rawTime = rawTime.split(":");
            for (var y = 0; y < rawDate.length; ++y)
            {
                if (rawDate[y].charAt(0) == '0') // javascript, seriously - can't you parse 09 to 9 and not 0?
                    rawDate[y] = rawDate[y][1];
                rawDate[y] = parseInt(rawDate[y]);
            }
            for (var y = 0; y < rawTime.length; ++y)
            {
                if (rawTime[y].charAt(0) == '0')
                    rawTime[y] = rawTime[y][1];
                rawTime[y] = parseInt(rawTime[y]);
            }
            rawDate[2] = rawDate[2] + 1900;                // ah, that's better
            parsedDate = new Date(rawDate[2], rawDate[0] - 1, rawDate[1], rawTime[0], rawTime[1]);    // month-day-year format
            if (new Date() - parsedDate > 15600000000)    // roughly 6 months
                timeOrYear = rawDate[2];
            var month = parsedDate.toLocaleDateString().split(" ");
            var name = temp.substring(temp.indexOf(treeitem[x][3 - offset]) + treeitem[x][3 - offset].length + 1, temp.length);
            name = name.substring(name.search(/[^\s]/));
            month = month[1].substring(0,3);    // abbr.

            treeitem[x] = {
                attr: treeitem[x][1] == "DIR" ? "d---------" : "----------",
                hardLink: "",
                user: "",
                group: "",
                size: treeitem[x][0],
                date: month + ' ' + rawDate[1] + ' ' + timeOrYear,
                name: (name.lastIndexOf('/') == -1 ? name : name.substring(name.lastIndexOf('/') + 1)),
                isDirectory: treeitem[x][1] == "DIR",
                isSymlink: false,
                symlink: ""
            };
        }
        else                                    // ms-dos style
        {
            var rawDate = treeitem[x][0].split("-");
            var rawTime = treeitem[x][1].substring(0, 5);    // get rid of PM, AM
            var timeOrYear = rawTime;
            rawTime = rawTime.split(":");
            for (var y = 0; y < rawDate.length; ++y)
            {
                if (rawDate[y].charAt(0) == '0') // javascript, seriously - can't you parse 09 to 9 and not 0?
                    rawDate[y] = rawDate[y][1];
                rawDate[y] = parseInt(rawDate[y]);
            }
            for (var y = 0; y < rawTime.length; ++y)
            {
                if (rawTime[y].charAt(0) == '0')
                    rawTime[y] = rawTime[y][1];
                rawTime[y] = parseInt(rawTime[y]);
            }
            if (rawDate[2] < 70)                // assuming you didn't have some files left over from 1904
                rawDate[2] = rawDate[2] + 2000;                // ah, that's better
            parsedDate = new Date(rawDate[2], rawDate[0] - 1, rawDate[1], rawTime[0], rawTime[1]);    // month-day-year format
            if (new Date() - parsedDate > 15600000000)    // roughly 6 months
                timeOrYear = rawDate[2];
            var month = parsedDate.toLocaleDateString().split(" ");
            var name = temp.substring(temp.indexOf(treeitem[x][2]) + treeitem[x][2].length + 1, temp.length);
            name = name.substring(name.search(/[^\s]/));
            month = month[1].substring(0,3);    // abbr.
            treeitem[x] = {
                attr: treeitem[x][2] == "<DIR>" ? "d---------" : "----------",
                hardLink: "",
                user: "",
                group: "",
                size: treeitem[x][2] == "<DIR>" ? 0 : treeitem[x][2],
                date: month + ' ' + rawDate[1] + ' ' + timeOrYear,
                name: (name.lastIndexOf('/') == -1 ? name : name.substring(name.lastIndexOf('/') + 1)),
                isDirectory: treeitem[x][2] == "<DIR>",
                isSymlink: false,
                symlink: ""
            };
        }
    }

    // sort directories to the top
    var directories = new Array;
    var files = new Array;
    for (var x = 0; x < treeitem.length; ++x)
    {
        if (treeitem[x].isDirectory)
            directories.push(treeitem[x]);
        else
            files.push(treeitem[x]);
    }

    // get rid of "." or ".." - this can screw up things (i already got one angry letter) if you recursively delete
    if (directories.length && directories[0].name == ".")
        directories.shift();
    if (directories.length && directories[0].name == "..")
        directories.shift();

    treeitem = directories.concat(files);

    return treeitem;
}

// *************************************************************************************************
// *************************************** remote tree views ***************************************
// *************************************************************************************************

function changeRemoteView(column, direction)
{
    var treeitem = parseListData(data);
    var directories = new Array;

    // get directory size
    remotesize = 0;
    for (var x = 0; x < treeitem.length; ++x)
    {
        var size = parseInt(treeitem[x].size);
        if (size != 0)
            size = parseInt(size / 1024) + 1;
        remotesize += size;
    }

    for (var x = 0; x < treeitem.length; ++x)
        if (treeitem[x].isDirectory)
            directories.push(treeitem[x]);

    // begin column sorting
    if (!column)
    {
        if (document.getElementById('remotename').getAttribute("sortDirection") &&
                document.getElementById('remotename').getAttribute("sortDirection") != "natural")
        {
            column = "remotename";
            direction = document.getElementById('remotename').getAttribute("sortDirection");
        }
        if (document.getElementById('remotesize').getAttribute("sortDirection") &&
                document.getElementById('remotesize').getAttribute("sortDirection") != "natural")
        {
            column = "remotesize";
            direction = document.getElementById('remotesize').getAttribute("sortDirection");
        }
        if (document.getElementById('remotedate').getAttribute("sortDirection") &&
                document.getElementById('remotedate').getAttribute("sortDirection") != "natural")
        {
            column = "remotedate";
            direction = document.getElementById('remotedate').getAttribute("sortDirection");
        }
        if (document.getElementById('remoteattr').getAttribute("sortDirection") &&
                document.getElementById('remoteattr').getAttribute("sortDirection") != "natural")
        {
            column = "remoteattr";
            direction = document.getElementById('remoteattr').getAttribute("sortDirection");
        }
    }

    if (column == "remotename")
        treeitem.sort(compareRemoteName);
    if (column == "remotesize")
        treeitem.sort(compareRemoteSize);
    if (column == "remotedate")
        treeitem.sort(compareRemoteDate);
    if (column == "remoteattr")
        treeitem.sort(compareRemoteAttr);
    if (direction == "ascending")
        treeitem.reverse();
    // end column sorting

    var treeView = {
    rowCount : treeitem.length,
    getCellText : function(row,column){
        if (row == -1)
            return "";
        switch(column)
        {
            case "remotename":
                return treeitem[row].name;
            case "remotesize":
                if (treeitem[row].size == 0)
                    return "0 KB  ";
                return commas(parseInt(treeitem[row].size / 1024) + 1) + " KB  ";
            case "remotedate":
                return treeitem[row].date;
            case "remoteattr":
                return treeitem[row].attr;
            default:
                return " "; // shouldn't get here
        }
    },
    setTree: function(treebox){ this.treebox = treebox; },
    isContainer: function(row){ return false; },
    isSeparator: function(row){ return false; },
    isSorted: function(row){ return false; },
    getLevel: function(row){ return 0; },
    getImageSrc: function(row,col)
    {
        if (row == -1)
            return "";
        if (col == "remotename")
        {
            if (treeitem[row].isDirectory)
                return "res/directory.ico";      // kind of a hack - is there a way to get the folder icon from "moz-icon://"?
            if (treeitem[row].isSymlink)
                return "res/link.ico";
            return "moz-icon://" + treeitem[row].name + "?size=16";
        }
    },
    getRowProperties: function(row,props){},
    getCellProperties: function(row,col,props){},
    getColumnProperties: function(colid,col,props){},
    cycleHeader: function(col, elem){ }
    };

    remoteDirManager(gRemotePath.value, directories);

    var dirTreeView = {
    rowCount : remotedircache.length,
    getCellText : function(row,column){
        if (row < 0 || row >= remotedircache.length)
            return "";
        if (row == 0)
            return "/";
        return remotedircache[row].path.substring(remotedircache[row].path.lastIndexOf('/') + 1);
    },
    getParentIndex: function(row){
        if (row < 0 || row >= remotedircache.length)
            return -1;
        if (remotedircache[row].path == "/")
            return -1;
        var parent = remotedircache[row].path.substring(0, remotedircache[row].path.lastIndexOf('/'));
        if (parent.length == 0)
            return 0;
        for (var x = 0; x < remotedircache.length; ++x)
            if (remotedircache[x].path == parent)
                return x;
    },
    isContainerOpen: function(row){ if (row < 0 || row >= remotedircache.length) return false; return remotedircache[row].open; },
     isContainerEmpty:function(row){ if (row < 0 || row >= remotedircache.length) return true; return remotedircache[row].empty; },
     hasNextSibling: function(row,nextrow) { return remotedircache[row].hasnext; },
    getLevel:function(row) {
         if (row < 0 || row >= remotedircache.length)
             return 0;
         return row ? remotedircache[row].path.match(/\x2f/g).length : 0;
    },
    toggleOpenState:function(row){
        if (this.isContainerOpen(row))
        {
            if (checkIsListing())
                return;
            var count = 1;
            while ((count + row) < remotedircache.length && this.getLevel(count + row) > this.getLevel(row))
                ++count;
            --count;
            var temp = remotedircache.splice(row + 1, count);
            if (temp.path)
                temp = new Array(temp); // messy, messy, messy
            if (remotedircache.path)
                remotedircache = new Array(remotedircache); // messy, messy, messy
            if (hiddenremotedircache.path)
                hiddenremotedircache = new Array(hiddenremotedircache); // messy, messy, messy
            hiddenremotedircache = temp.concat(hiddenremotedircache);
            if (hiddenremotedircache.path)
                hiddenremotedircache = new Array(hiddenremotedircache); // messy, messy, messy
            gRemoteDirTree.treeBoxObject.rowCountChanged(row, -count);
            remotedircache[row].open = false;
            remotedircache[row].children = temp.length;
            if (gRemotePath.value.indexOf(remotedircache[row].path) != -1
                    && gRemotePath.value != remotedircache[row].path)
            {
                list(remotedircache[row].path);
                gRemoteDirTree.view.selection.select(row);
                gRemoteDirTree.treeBoxObject.ensureRowIsVisible(row);
            }
            if (gRemotePath.value == remotedircache[row].path)
            {
                gRemoteDirTree.view.selection.select(row);
                gRemoteDirTree.treeBoxObject.ensureRowIsVisible(row);
            }
        }
        else
        {
            if (checkIsListing() || (eventQueue.length && checkRemoteCache(remotedircache[row].path) == -1))
                return;
            var found = -1;
            var number = remotedircache[row].children;
            for (var x = 0; x < hiddenremotedircache.length; ++x)
                if (hiddenremotedircache[x].path.indexOf(remotedircache[row].path) != -1)
                {
                    found = x;
                    break;
                }
            if (found == -1)
            {
                findIt(row);
                return;
            }
            var toBeAdded = hiddenremotedircache.splice(found, number);
            var piece = remotedircache.splice(0, row + 1);
            if (toBeAdded.path)
                toBeAdded = new Array(toBeAdded);    // messy, messy, messy
            if (piece.path)
                piece = new Array(piece); // messy, messy, messy
            if (remotedircache.path)
                remotedircache = new Array(remotedircache); // messy, messy, messy
            if (hiddenremotedircache.path)
                hiddenremotedircache = new Array(hiddenremotedircache); // messy, messy, messy
            remotedircache = piece.concat(toBeAdded, remotedircache);
            if (remotedircache.path)
                remotedircache = new Array(remotedircache); // ditto, ditto, ditto
            gRemoteDirTree.treeBoxObject.rowCountChanged(row, toBeAdded.length);
            if (!remotedircache[row].empty)
                remotedircache[row].open = true;
            remotedircache[row].children = -1;
            if (gRemotePath.value == remotedircache[row].path)
            {
                gRemoteDirTree.view.selection.select(row);
                gRemoteDirTree.treeBoxObject.ensureRowIsVisible(row + (remoteLastRowSeen - row - 1));
                remoteLastRowSeen = 0;
            }
        }
    },
    isSeparator: function(row){ return false; },
    isSorted: function(row){ return false; },
      isContainer: function(row){ return true; },
    getImageSrc: function(row,col){
        if (this.isContainerOpen(row))
            return "res/directoryopen.ico";    // hack - folder icon from "moz-icon://"?
        else
            return "res/directory.ico";
    },
    setTree: function(treebox){ this.treebox = treebox; },
    getRowProperties: function(row,props){},
    getCellProperties: function(row,col,props){},
    getColumnProperties: function(colid,col,props){},
    };

    gRemoteTree.view = treeView;
    gRemoteDirTree.view = dirTreeView;

    // on startup, select '/' on remotedirtree
    if (gRemoteDirTree.view.selection.count == 0)
        gRemoteDirTree.view.selection.select(0);
}
function remoteDirManager(path, data)
{
    for (var x = 0; x < remotedircache.length; ++x)
        if (remotedircache[x].path == path)
        {
            if (data.length == 0)
            {
                remotedircache[x].empty = true;
                remotedircache[x].open = false;
            }
            else
                remotedircache[x].empty = false;
            break;
        }
    if (path.charAt(path.length - 1) != '/')
        path += '/';
    for (var x = 0; x < data.length; ++x)
        data[x] = {path: path + data[x].name, open: false, empty: false, children: -1, hasnext: true };
    if (data.path)
        data = new Array(data); // messy, messy, messy
    data.sort(directorySort);
    if (data.length)
        data[data.length - 1].hasnext = false;
    remotedircache = remotedircache.concat(data);
    if (remotedircache.path)
        remotedircache = new Array(remotedircache); // messy, messy, messy
    remotedircache.sort(directorySort);
    // check for duplicates
    for (var x = 0; x < remotedircache.length - 1; ++x)
        if (remotedircache[x].path == remotedircache[x + 1].path)
        {
            if (remotedircache[x].open)
                remotedircache[x + 1].open = true;
            if (remotedircache[x].empty)
                remotedircache[x + 1].empty = true;
            if (remotedircache[x].children != -1)
                remotedircache[x + 1].children = remotedircache[x].children;
            if (remotedircache[x].hasnext)
                remotedircache[x + 1].hasnext = true;
            remotedircache.splice(x, 1);
            if (remotedircache.path)
                remotedircache = new Array(remotedircache); // messy, messy, messy
        }
    var didSplice = false;
    for (var x = 0; x < remotedircache.length; ++x)
    {
        for (var y = 0; y < hiddenremotedircache.length; ++y)
        {
            if (x >= remotedircache.length) // splicing might cause invalid indices
                break;
            if (remotedircache[x].path == hiddenremotedircache[y].path)
            {
                remotedircache.splice(x, 1);
                didSplice = true;
                if (remotedircache.path)
                    remotedircache = new Array(remotedircache); // messy, messy, messy
            }
        }
        if (didSplice)    // gotta start from 0 again b/c array will have shifted around, better safe...
        {
            x = -1;    // will get incremented up to 0
            didSplice = false;
        }
    }
}
function findIt(row)    // again, elegance you will find in a ballroom, not here
{
    var temp = gRemotePath.value;
    if (!refreshRemote)
    {
        list(remotedircache[row].path, "findIt2(" + row + ", \'" + temp + "\')");
        return;
    }
    findIt3(row, temp);
}
function findIt2(row, temp)
{
    list(temp, "findIt3(" + row + ", \'" + temp + "\')");
}
function findIt3(row, temp)
{
    if (!remotedircache[row].empty)
        remotedircache[row].open = true;
    remotedircache[row].children = -1;
    for (var x = 0; x < remotedircache.length; ++x)
        if (remotedircache[x].path == temp)
        {
            gRemoteDirTree.view.selection.select(x); // when moving with keys
            gRemoteDirTree.treeBoxObject.ensureRowIsVisible(x + (remoteLastRowSeen - x - 1));
            remoteLastRowSeen = 0;
            break;
        }
}

// *************************************************************************************************
// *************************************** refresh remote view *************************************
// *************************************************************************************************

function refreshRemoteView()
{
    if (!isConnected)
        return;
    if (eventQueue.length && eventQueue[0].cmd != "aborted")
        return;
    refreshRemote = true;
    // get rid of old directory entries
    for (var x = 0; x < remotedircache.length; ++x)
        if (remotedircache[x].path.indexOf(gRemotePath.value) != -1
            && gRemotePath.value != remotedircache[x].path)
        {
            remotedircache.splice(x, 1);
            if (remotedircache.path)
                    remotedircache = new Array(remotedircache); // messy, messy, messy
            x = -1; // start from the top, to be safe
        }
    for (var x = 0; x < hiddenremotedircache.length; ++x)
        if (hiddenremotedircache[x].path.indexOf(gRemotePath.value) != -1
            && gRemotePath.value != hiddenremotedircache[x].path)
        {
            hiddenremotedircache.splice(x, 1);
            if (hiddenremotedircache.path)
                    hiddenremotedircache = new Array(hiddenremotedircache); // messy, messy, messy
            x = -1; // start from the top, to be safe
        }
    for (var x = 0; x < remotedircache.length; ++x)
        if (remotedircache[x].path == gRemotePath.value)
        {
            remoteDirChangeHelper(x);
            break;
        }
}

// *************************************************************************************************
// *************************************** rename remote file **************************************
// *************************************************************************************************

var newRemoteName;
function renameRemoteFile(path, openRenamedDirectory)
{
    if (!isConnected)
        return;
    var newName = window.prompt(strbundle.getString("renameTo"), path.substring(path.lastIndexOf('/') + 1), strbundle.getString("rename"));
    if (!newName)
        return;

    if (path.charAt(path.length - 1) == '/')
        path = path.substring(path.length - 1);
    newName = path.substring(0, path.lastIndexOf('/')) + '/' + newName;
    newRemoteName = newName;    // damn globals

    addEventQueue("RNFR", path);
    addEventQueue("RNTO", newName, openRenamedDirectory);
    if (isReady)    // get the ball rollin' if it isn't already
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
}
function renameRemoteFile2(openRenamedDirectory)
{
    moreToRemember = "";
    if (openRenamedDirectory)
    {
        gRemotePath.value = newRemoteName;
        onRemotePathChange();
    }
    else
    {
        gRemoteTree.focus();
        for (var x = 0; x < gRemoteTree.view.rowCount; ++x)
            if (newRemoteName.substring(newRemoteName.lastIndexOf('/') + 1) == gRemoteTree.view.getCellText(x, "remotename"))
            {
                gRemoteTree.view.selection.select(x);
                break;
            }
    }
}

// *************************************************************************************************
// *************************************** make remote directory ***********************************
// *************************************************************************************************

function makeRemoteDirectory()
{
    if (!isConnected)
        return;
    if (eventQueue.length)
        return;
    var newName = window.prompt(strbundle.getString("directoryName"), "", strbundle.getString("newDirectory"));
    if (!newName)
        return;
    if (gRemotePath.value.charAt(gRemotePath.value.length - 1) != '/')
        newName = gRemotePath.value + '/' + newName;
    else
        newName = gRemotePath.value + newName;
    moreToRemember = "makeRemoteDirectory2(\"" + newName + "\")";
    addEventQueue("MKD", newName);
    if (isReady)    // get the ball rollin' if it isn't already
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
}
function makeRemoteDirectory2(newName)
{
    moreToRemember = "";
    gRemotePath.value = newName;
    onRemotePathChange();
    gRemoteTree.focus();
}

// *************************************************************************************************
// *************************************** remote properties ***************************************
// *************************************************************************************************

function getRemoteProperties()
{
    var fileList = gRemoteTree.view.selection;
    if (fileList.count == 0)
        return;

    var thepath = gRemoteTree.view.getCellText(fileList.currentIndex, "remotename");
    var index = checkRemoteCache(gRemotePath.value);
    var files = parseListData(remotecache[index].data);

    for (var x = 0; x < files.length; ++x)
        if (files[x].name == thepath)
        {
            if (gRemotePath.value.charAt(gRemotePath.value.length - 1) != '/')
                thepath = gRemotePath.value + '/' + thepath;
            else
                thepath = gRemotePath.value + thepath;

            var windowHeight = document.getElementById('main-window').boxObject.height;
            var windowWidth = document.getElementById('main-window').boxObject.width;

            var permissions = new Object();
            permissions.value = "";

            window.openDialog("chrome://fireftp/content/propertiesDialog.xul","propertiesDialog",
                "screenY="+(windowHeight/2 - 150)+",screenX="+(windowWidth/2 - 300)+
                ",width=600,height=300,chrome,modal=yes,dialog=yes,resizable=yes",
                thepath, files[x].name, files[x].size, files[x].date, files[x].attr, 'disabled', 'disabled',
                files[x].isDirectory, files[x].user, files[x].group, permissions, files[x].isSymlink, files[x].symlink);
            if (permissions.value)
            {
                addEventQueue("SITE CHMOD", permissions.value + ' ' + thepath, files[x].name);
                if (isReady)    // get the ball rollin' if it isn't already
                    writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
            }
            break;
        }
}
function getRemoteProperties2(remotename)
{
    moreToRemember = "";
    gRemoteTree.focus();
    for (var x = 0; x < gRemoteTree.view.rowCount; ++x)
        if (remotename == gRemoteTree.view.getCellText(x, "remotename"))
        {
            gRemoteTree.view.selection.select(x);
            break;
        }
}

// *************************************************************************************************
// *************************************** remote cut/paste ****************************************
// *************************************************************************************************

var remoteCutParentDir;
var remoteCutParentDir2;
var isRemoteDirCut;
var remotePasteReady = false;
function remoteCut()
{
    if (!isConnected)
        return;
    var fileList = gRemoteTree.view.selection;
    if (fileList.count == 0)
        return;

    remotePasteFiles = new Array;
    var remoteParent = gRemotePath.value;

    for (var x = 0; x < gRemoteTree.view.rowCount; ++x)
        if (gRemoteTree.view.selection.isSelected(x))
        {
            var remotepath = gRemoteTree.view.getCellText(x, "remotename");
            if (remoteParent.charAt(remoteParent.length - 1) != '/')
                remotepath = remoteParent + '/' + remotepath;
            else
                remotepath = remoteParent + remotepath;

            remotePasteFiles.push(remotepath);
        }

    remoteCutParentDir = remoteParent;
    remotePasteReady = false;
    isRemoteDirCut = false;
    document.getElementById('remotePasteContext').setAttribute("disabled", false);
    document.getElementById('remoteDirPasteContext').setAttribute("disabled", false);
}
function remotePaste(remotedir)
{
    if (!isConnected)
        return;
    var    parentDir;
    var prompt = true;
    var skipall = false;
    var remotefiles = parseListData(data);

    for (var x = 0; x < remotePasteFiles.length; ++x)
    {
        var parentDir = remotedir ? remotedir : gRemotePath.value;

        var newPath = parentDir.charAt(parentDir.length - 1) == '/'
                ? parentDir + remotePasteFiles[x].substring(remotePasteFiles[x].lastIndexOf('/') + 1)
                : parentDir + '/' + remotePasteFiles[x].substring(remotePasteFiles[x].lastIndexOf('/') + 1);

        var exists = false;
        var index;
        for (var y = 0; y < remotefiles.length; ++y)
            if (remotefiles[y].name == remotePasteFiles[x].substring(remotePasteFiles[x].lastIndexOf('/') + 1))
            {
                exists = true;
                index = y;
                break;
            }
        if (exists && skipall)
            continue;
        if (exists && prompt && !remotefiles[index].isDirectory)
        {
            var response = new Object();
            response.value = 0;
            var windowHeight = document.getElementById('main-window').boxObject.height;
            var windowWidth = document.getElementById('main-window').boxObject.width;
            var timer = destructmode;

            window.openDialog("chrome://fireftp/content/confirmFileDialog.xul","confirmFileDialog",
                "screenY="+(windowHeight/2 - 45)+",screenX="+(windowWidth/2 - 200)+
                ",width=400,height=90,chrome,modal=yes,dialog=yes,resizable=yes",
                response, remotePasteFiles[x].substring(remotePasteFiles[x].lastIndexOf('/') + 1), true, true, timer);
            if (response.value == 2)
                prompt = false;
            else if (response.value == 3)
                continue;
            else if (response.value == 4 || response.value == 0)
                return;
            else if (response.value == 5)
            {
                skipall = true;
                continue;
            }
        }

        addEventQueue("RNFR", remotePasteFiles[x]);
        addEventQueue("RNTO", newPath, "pasting");
    }

    remotePasteFiles = new Array;
    document.getElementById('remotePasteContext').setAttribute("disabled", true);
    document.getElementById('remoteDirPasteContext').setAttribute("disabled", true);

    remotePasteReady = true;

    if (isReady)    // get the ball rollin' if it isn't already
        writeControl(eventQueue[0].cmd, eventQueue[0].parameter);
}

function remoteDirCut()
{
    if (!isConnected)
        return;
    if (gRemoteDirTree.view.selection.count == 0)
        return;

    if (gRemoteDirTree.view.selection.currentIndex == 0)    // you can't cut the root
        return;                                                                        // and you can't stop the rock

    remotePasteFiles = new Array;
    var dir = gRemoteDirTree.view.selection.currentIndex;

    remotePasteFiles.push(remotedircache[dir].path);

    remoteCutParentDir = remotedircache[dir].path;
    remotePasteReady = false;
    isRemoteDirCut = true;
    document.getElementById('remotePasteContext').setAttribute("disabled", false);
    document.getElementById('remoteDirPasteContext').setAttribute("disabled", false);
}
function remoteDirPaste()
{
    if (!isConnected)
        return;
    if (gRemoteDirTree.view.selection.count == 0)
        return;

    var dir = gRemoteDirTree.view.selection.currentIndex;
    list(remotedircache[dir].path, "remoteDirPaste2(\'" + remotedircache[dir].path + "\')", true)
}
function remoteDirPaste2(path)
{
    remoteCutParentDir2 = path;
    remotePaste(path);
}
function refreshPasting(tempPath)
{
    moreToRemember = "";
    gRemotePath.value = remoteCutParentDir2;
    onRemotePathChange();
    moreToRemember = "refreshPasting2(\'" + tempPath + "\')";
    refreshRemoteView();
}
function refreshPasting2(tempPath)
{
    moreToRemember = "";
    if (!isRemoteDirCut || tempPath != remoteCutParentDir)
        gRemotePath.value = tempPath;
    else
        gRemotePath.value =
            remoteCutParentDir.substring(0, remoteCutParentDir.lastIndexOf('/')
            ? remoteCutParentDir.lastIndexOf('/') : 1);
    onRemotePathChange();
    remoteCutParentDir = "";
    remoteCutParentDir2 = "";
    refreshRemoteView();
}

// *************************************************************************************************
// *************************************** remote drag sessions ************************************
// *************************************************************************************************

function onRemoteDragOver(event)
{
    if (!isConnected)
        return;
    var row = {};
    var col = {};
    var child = {};
    var dragSession = whataDrag.getCurrentSession();
    var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance(Components.interfaces.nsITransferable);

    trans.addDataFlavor("text/unicode");
    dragSession.getData(trans, 0);
    var dataObj = new Object();
    var bestFlavor = new Object();
    var len = new Object();
    trans.getAnyTransferData(bestFlavor, dataObj, len);
    dataObj = dataObj.value.QueryInterface(Components.interfaces.nsISupportsString);

    gRemoteTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);

    if (dataObj.data == "remotetreechildren")
    {
        if (gRemoteTree.view.getCellText(row.value, "remoteattr").charAt(0) == "d")
            dragSession.canDrop = true;
        else
            dragSession.canDrop = false;
    }
    else
        dragSession.canDrop = true;
}
function onRemoteDragDrop(event)
{
    var dragSession = whataDrag.getCurrentSession();
    var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance(Components.interfaces.nsITransferable);

    trans.addDataFlavor("text/unicode");
    dragSession.getData(trans, 0);
    var dataObj = new Object();
    var bestFlavor = new Object();
    var len = new Object();
    trans.getAnyTransferData(bestFlavor, dataObj, len);
    dataObj = dataObj.value.QueryInterface(Components.interfaces.nsISupportsString);

    if (dataObj.data == "remotetreechildren")
    {
        var row = {};
        var col = {};
        var child = {};
        gRemoteTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);
        var remoteParent = gRemotePath.value;
        remoteCut();
        var remotepath = gRemoteTree.view.getCellText(row.value, "remotename");
        if (remoteParent.charAt(remoteParent.length - 1) != '/')
            remotepath = remoteParent + '/' + remotepath;
        else
            remotepath = remoteParent + remotepath;
        gRemotePath.value = remotepath;
        moreToRemember = "moreToRemember='';remotePaste()";
        onRemotePathChange();
    }
    else if (dataObj.data == "remotedirtreechildren")
    {
        var remoteParent = gRemotePath.value;
        remoteDirCut();
        remotePaste();
    }
    else if (dataObj.data == "localtreechildren")
        stor();
    else if (dataObj.data == "localdirtreechildren")
        storDir();
    event.preventBubble();
}
function onRemoteDirDragOver(event)
{
    if (!isConnected)
        return;
    var row = {};
    var col = {};
    var child = {};
    var dragSession = whataDrag.getCurrentSession();
    var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance(Components.interfaces.nsITransferable);
    trans.addDataFlavor("text/unicode");
    dragSession.getData(trans, 0);
    var dataObj = new Object();
    var bestFlavor = new Object();
    var len = new Object();
    trans.getAnyTransferData(bestFlavor, dataObj, len);
    dataObj = dataObj.value.QueryInterface(Components.interfaces.nsISupportsString);

    if (dataObj.data == "localdirtreechildren" || dataObj.data == "localtreechildren")
    {
        dragSession.canDrop = false;
        return;
    }

    gRemoteDirTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);

    if (gRemoteDirTree.view.getCellText(row.value, "remotename") != "")
        dragSession.canDrop = true;
    else
        dragSession.canDrop = false;
}
function onRemoteDirDragDrop(event)
{
    var row = {};
    var col = {};
    var child = {};
    var dragSession = whataDrag.getCurrentSession();
    var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance(Components.interfaces.nsITransferable);

    trans.addDataFlavor("text/unicode");
    dragSession.getData(trans, 0);
    var dataObj = new Object();
    var bestFlavor = new Object();
    var len = new Object();
    trans.getAnyTransferData(bestFlavor, dataObj, len);
    dataObj = dataObj.value.QueryInterface(Components.interfaces.nsISupportsString);

    var row = {};
    var col = {};
    var child = {};
    gRemoteDirTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);

    if (dataObj.data == "remotetreechildren")
    {
        gRemoteDirTree.view.selection.currentIndex = row.value;
        remoteCut();
        remoteDirPaste();
    }
    else if (dataObj.data == "remotedirtreechildren")
    {
        remoteDirCut();
        gRemoteDirTree.view.selection.currentIndex = row.value;
        remoteDirPaste();
    }
    event.preventBubble();
}

// *************************************************************************************************
// **************************************** local folder functions *********************************
// *************************************************************************************************

function getLocalFileSpec(path)
{
    try {
        var file = Components.classes['@mozilla.org/filespec;1'].createInstance(Components.interfaces.nsIFileSpec);
        file.unicodePath = path;
        return file;
    } catch (ex) { debug(ex,27); }
}
function localDirChangeHelper(index, toggle)
{
    var state = localdircache[index].open;
    gLocalPath.value = localdircache[index].path;

    var gFormHistory = Components.classes["@mozilla.org/satchel/form-history;1"]
        .getService(Components.interfaces.nsIFormHistory);
    gFormHistory.addEntry(gLocalPath.getAttribute("autocompletesearchparam"), gLocalPath.value);

    savePreferences();

    changeLocalView();

    if (!state && !localdircache[index].empty)
    {
        localdircache[index].open = false;
        gLocalDirTree.view.toggleOpenState(index);
    }
    if (toggle)
        gLocalDirTree.view.toggleOpenState(index);

    gLocalDirTree.view.selection.select(index);
    if (localLastRowSeen)
    {
        gLocalDirTree.treeBoxObject.ensureRowIsVisible(index + (localLastRowSeen - index - 1));
        localLastRowSeen = 0;
    }
    else
        gLocalDirTree.treeBoxObject.ensureRowIsVisible(index);
}
function onLocalCDUP()
{
    var parentIndex = gLocalDirTree.view.getParentIndex(gLocalDirTree.view.selection.currentIndex);
    if (parentIndex != -1)
    {
        gLocalDirTree.view.selection.select(parentIndex);
        localDirChangeHelper(parentIndex);
    }
}

var localLastRowSeen = 0;
function onLocalDirClick(event)
{
    if (event.button == 0)
    {
        var row = {};
        var col = {};
        var child = {};
        gLocalDirTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);
        var index = gLocalDirTree.view.selection.currentIndex;
        localLastRowSeen = gLocalDirTree.treeBoxObject.getLastVisibleRow();    // have you seen this row?

        if (index == row.value && localdircache[index].path != gLocalPath.value)
            localDirChangeHelper(index);

    } else if (event.button == 1 && !document.getElementById('localPasteContext').disabled)
        localDirPaste();
}
var localDirKeyDownIndex;    // global variables - yummy, as they say (you know who you are)
var localDirKeyDownOpen;
function onLocalDirKeyDown(event)
{
    localDirKeyDownIndex = gLocalDirTree.view.selection.currentIndex;
    localDirKeyDownOpen = localdircache[localDirKeyDownIndex].open;
}
function onLocalDirKeyPress(event)
{
    var index = gLocalDirTree.view.selection.currentIndex;
    switch(event.keyCode)
    {
        case 37:    // left
            if (localDirKeyDownIndex != index)
            {
                gLocalDirTree.view.selection.select(index);
                localDirChangeHelper(index);
            }
            break;
        case 38:    // up
            if (!index)
                return;

            // see if file is good first
            try {
                dir = Components.classes['@mozilla.org/file/local;1'].createInstance(Components.interfaces.nsILocalFile);
                dir.initWithPath(localdircache[index - 1].path);
                var entries = dir.directoryEntries;
            } catch (ex) {
                debug(ex,28);
                gLocalPath.value = localdircache[index - 1].path;
                onLocalPathChange();
                gLocalDirTree.view.selection.select(index);
                break;
            }

            if (localdircache[index - 1].open)
                localDirChangeHelper(index - 1);
            else
                localDirChangeHelper(index - 1, true);
            gLocalDirTree.view.selection.select(index);
            break;
        case 40:    // down
            if (index == localdircache.length - 1)
            {
                gLocalDirTree.view.selection.select(index - 1);    // this shouldn't work but it does
                return;
            }

            // see if file is good first
            try {
                dir = Components.classes['@mozilla.org/file/local;1'].createInstance(Components.interfaces.nsILocalFile);
                dir.initWithPath(localdircache[index + 1].path);
                var entries = dir.directoryEntries;
            } catch (ex) {
                debug(ex,29);
                gLocalPath.value = localdircache[index + 1].path;
                onLocalPathChange();
                gLocalDirTree.view.selection.select(index);
                break;
            }
            if (localdircache[index + 1].open)
                localDirChangeHelper(index + 1);
            else
                localDirChangeHelper(index + 1, true);
            gLocalDirTree.view.selection.select(index);
            break;
        case 39:    // right
            if (localDirKeyDownOpen && !localdircache[index].empty)
            {
                // see if file is good first
                try {
                    dir = Components.classes['@mozilla.org/file/local;1'].createInstance(Components.interfaces.nsILocalFile);
                    dir.initWithPath(localdircache[index + 1].path);
                    var entries = dir.directoryEntries;
                } catch (ex) {
                    error(strbundle.getString("noPermission"));
                    debug(ex,30);
                    break;
                }

                localDirChangeHelper(index + 1);
            }
            break;
        case 8: // backspace
            onLocalCDUP();
            break;
        case 116: // F5
            event.preventDefault();
            refreshLocalView();
            break;
        case 113: // F2
            renameLocalFile(localdircache[index].path, true);
            break;
        case 46: // delete
            deleteLocalFile(localdircache[index].path, true, true);
            break;
        case 93: // context menu
            var x = {};
            var y = {};
            var width = {};
            var height = {};
            var childrenBoxX = document.getElementById('localdirtreechildren').boxObject.x;
            var childrenBoxY = document.getElementById('localdirtreechildren').boxObject.y;

            gLocalDirTree.treeBoxObject.getCoordsForCellItem(index, "localdirname", "text", x, y, width, height);
            document.getElementById('localdirmenu').showPopup(document.getElementById('localdirtreechildren'), childrenBoxX + 75, childrenBoxY + y.value + 30, "context");
            break;
        default:
            break;
    }
    if (event.ctrlKey)
    {
        switch(event.charCode)
        {
            case 120:    // ctrl-x
                event.preventDefault();
                localDirCut();
                break;
            case 99:    // ctrl-c
                event.preventDefault();
                localDirCopy();
                break;
            case 118:    // ctrl-v
                event.preventDefault();
                localDirPaste();
                break;
            default:
                break;
        }
    }
}

// *************************************************************************************************
// *************************************** local context menus *************************************
// *************************************************************************************************

function onLocalDirRenameContext()
{
    var index = gLocalDirTree.view.selection.currentIndex;
    renameLocalFile(localdircache[index].path, true);
}
function onLocalRenameContext()
{
    var fileList = gLocalTree.view.selection;
    if (fileList.count == 0)
        return;
    var thepath = gLocalTree.view.getCellText(fileList.currentIndex, "localname");
    if (gLocalPath.value.charAt(gLocalPath.value.length - 1) != slash)
        thepath = gLocalPath.value + slash + thepath;
    else
        thepath = gLocalPath.value + thepath;
    renameLocalFile(thepath, false);
}
function onLocalDirDeleteContext()
{
    var index = gLocalDirTree.view.selection.currentIndex;
    deleteLocalFile(localdircache[index].path, true, true);
}
function onLocalDeleteContext()
{
    var fileList = gLocalTree.view.selection;
    if (fileList.count == 0)
        return;

    if (fileList.count > 1)
    {
        if (!window.confirm(strbundle.getString("confirmDelete") + " " + fileList.count + " " + strbundle.getString("confirmDelete2")))
            return;
        for (var x = 0; x < gLocalTree.view.rowCount; ++x)
            if (gLocalTree.view.selection.isSelected(x))
            {
                var thepath = gLocalTree.view.getCellText(x, "localname");
                if (gLocalPath.value.charAt(gLocalPath.value.length - 1) != slash)
                    thepath = gLocalPath.value + slash + thepath;
                else
                    thepath = gLocalPath.value + thepath;
                deleteLocalFile(thepath, false, false);
            }
        refreshLocalView();
    }
    else
    {
        var thepath = gLocalTree.view.getCellText(fileList.currentIndex, "localname");
        if (gLocalPath.value.charAt(gLocalPath.value.length - 1) != slash)
            thepath = gLocalPath.value + slash + thepath;
        else
            thepath = gLocalPath.value + thepath;
        deleteLocalFile(thepath, false, true);
    }
}

// *************************************************************************************************
// *************************************** local path change ***************************************
// *************************************************************************************************

var localPathFocus;
function onLocalPathFocus(event)
{
    localPathFocus = gLocalPath.value;
}
function onLocalPathBlur(event)
{
    gLocalPath.value = localPathFocus;
}
function onLocalPathChange()
{
    var path = gLocalPath.value;
    if (localdircache.length == 0 || localdircache[0].path.charAt(0) != path.charAt(0))
    {
        localdircache = new Array;
        hiddenlocaldircache = new Array;
        var thepath;
        if (path.indexOf('/') == 0) // linux
        {
            thepath = "/";
            slash = "/";
        }
        else    // windows
        {
            if (path.indexOf('\\') == -1)
            {
                gLocalPath.value += "\\";
                path += "\\";
            }
            thepath = path.substring(0, path.indexOf('\\') + 1);
            slash = "\\";
        }
        localdircache.push( {path: thepath, open: true, empty: false, children: -1} );
        changeLocalView();
    }

    if (slash == "/")
        gLocalPath.value = gLocalPath.value.replace(/\x5c/g, "/");
    else
        gLocalPath.value = gLocalPath.value.replace(/\x2f/g, "\\");
    if (gLocalPath.value != '/' && gLocalPath.value.charAt(gLocalPath.value.length - 1) == slash)
        gLocalPath.value = gLocalPath.value.substring(0,gLocalPath.value.length - 1);
    if (slash == "\\" && gLocalPath.value.indexOf('\\') == -1)
        gLocalPath.value += "\\";
    if (slash == "/" && gLocalPath.value.charAt(0) != '/')
        gLocalPath.value = '/' + gLocalPath.value;
    var newDir = gLocalPath.value;
    gLocalDirTree.focus();
    var found = false;

    for (var x = 0; x < localdircache.length; ++x)
        if (localdircache[x].path == newDir)
        {
            localDirChangeHelper(x);
            found = true;
            localPathFocus = newDir;
            return;
        }

    var previousParent = -1;
    var findParent = -1;
    while (true)
    {
        for (var x = localdircache.length - 1; x > -1; --x)
            if (newDir.indexOf(localdircache[x].path) == 0)
            {
                findParent = x;
                localDirChangeHelper(x);
                break;
            }
        for (var x = 0; x < localdircache.length; ++x)
            if (localdircache[x].path == newDir)
            {
                localPathFocus = newDir;
                localDirChangeHelper(x);
                return;
            }
        if (findParent == -1 || previousParent == findParent)
        {
            gLocalPath.value = localPathFocus;
            for (var x = 0; x < localdircache.length; ++x)
                if (localdircache[x].path == localPathFocus)
                {
                    localDirChangeHelper(x);
                    break;
                }
            error(strbundle.getString("localDirNotFound"));
            return;
        }
        previousParent = findParent;
    }
}

// *************************************************************************************************
// *************************************** local mouse events **************************************
// *************************************************************************************************

function onLocalDblClick(event)
{
    if (event.button != 0)
        return;
    var target = event.originalTarget;
    if (target.localName != "treechildren")
        return;

    var fileList = gLocalTree.view.selection;
    if (fileList.count == 0)
        return;

    if (gLocalTree.view.getCellText(fileList.currentIndex, "localsize") == "")
    {
        var thepath = gLocalTree.view.getCellText(fileList.currentIndex, "localname");
        if (gLocalPath.value.charAt(gLocalPath.value.length - 1) != slash)
            thepath = gLocalPath.value + slash + thepath;
        else
            thepath = gLocalPath.value + thepath;

        gLocalPath.value = thepath;
        onLocalPathChange();
    }
    else
        stor();
}
function onLocalClick(event)
{
    if (event.button == 1 && !document.getElementById('localPasteContext').disabled)
        localPaste();
}
function onLocalMouseOver(event)
{
    if (gLocalTree.view.rowCount)
        document.getElementById('statustxt').label =
        strbundle.getString("localListing") + " " + gLocalTree.view.rowCount + " " + strbundle.getString("objects") + " "
            + commas(localsize) + ", " + strbundle.getString("diskSpace") + " " + localAvailableDiskSpace;
    else
        document.getElementById('statustxt').label = strbundle.getString("localListingNoObjects");
}

// *************************************************************************************************
// *************************************** local key commands **************************************
// *************************************************************************************************

function onLocalKeyPress(event)
{
    if (event.keyCode == 13)
    {
        var fileList = gLocalTree.view.selection;
        if (fileList.count == 0)
            return;
        if (fileList.count == 1 && gLocalTree.view.getCellText(fileList.currentIndex, "localsize") == "")
        {
            var thepath = gLocalTree.view.getCellText(fileList.currentIndex, "localname");
            if (gLocalPath.value.charAt(gLocalPath.value.length - 1) != slash)
                thepath = gLocalPath.value + slash + thepath;
            else
                thepath = gLocalPath.value + thepath;
            gLocalPath.value = thepath;
            onLocalPathChange();
            gLocalTree.focus();
        }
        else
            stor();
    }
    else if (event.ctrlKey && (event.which == 65 || event.which == 97)) // ctrl-a: select all
    {
        event.preventDefault();
        gLocalTree.view.selection.selectAll();
    }
    else if (event.ctrlKey && event.which == 32)    // ctrl-space, select or deselect
        gLocalTree.view.selection.toggleSelect(gLocalTree.view.selection.currentIndex);
    else if (event.keyCode == 8)    // backspace
        onLocalCDUP();
    else if (event.keyCode == 116) // F5
    {
        event.preventDefault();
        refreshLocalView();
    }
    else if (event.keyCode == 113) // F2
        onLocalRenameContext();
    else if (event.charCode == 109 && event.ctrlKey)    // ctrl-m
    {
        event.preventDefault();
        makeLocalDirectory();
    }
    else if (event.keyCode == 46)    // del
        onLocalDeleteContext();
    else if (event.keyCode == 93) // context menu
    {
        var fileList = gLocalTree.view.selection;
        if (fileList.count == 0)
            return;
        var index = fileList.currentIndex;
        var x = {};
        var y = {};
        var width = {};
        var height = {};
        var childrenBoxX = document.getElementById('localtreechildren').boxObject.x;
        var childrenBoxY = document.getElementById('localtreechildren').boxObject.y;

        gLocalTree.treeBoxObject.getCoordsForCellItem(index, "localname", "text", x, y, width, height);
        document.getElementById('localmenu').showPopup(document.getElementById('localtreechildren'), childrenBoxX + 75, childrenBoxY + y.value + 30, "context");
    }
    else if (event.charCode == 112 && event.ctrlKey)    // ctrl-p
    {
        event.preventDefault();
        getLocalProperties();
    }
    else if (event.charCode == 120 && event.ctrlKey)    // ctrl-x
    {
        event.preventDefault();
        localCut();
    }
    else if (event.charCode == 99 && event.ctrlKey)    // ctrl-c
    {
        event.preventDefault();
        localCopy();
    }
    else if (event.charCode == 118 && event.ctrlKey)    // ctrl-v
    {
        event.preventDefault();
        localPaste();
    }
}

// *************************************************************************************************
// ******************************** highlighting multiple rows *************************************
// *************************************************************************************************

var localMouseDownRow;
var localMouseDownOnName;
var localMouseDownPressed;
var localMouseDirection;
var localMousePreviousY;

function onLocalMouseDown(event)
{
    if (event.target.getAttribute('id') != 'localtreechildren')
        return;
    localMouseDownPressed = true;
    var row = {};
    var col = {};
    var child = {};
    var x = {};
    var y = {};
    var width = {};
    var height = {};
    var childrenBoxX = document.getElementById('localtreechildren').boxObject.x;
    var childrenBoxY = document.getElementById('localtreechildren').boxObject.y;
    var thecell = gLocalTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);
    gLocalTree.treeBoxObject.getCoordsForCellItem (row.value, "localname", "text", x, y, width, height);
    if (row.value == -1)
    {
        gLocalTree.view.selection.clearSelection();
        row.value = gLocalTree.view.rowCount - 1;
    }
    localMouseDownRow = row.value;
    localMouseDownOnName = event.pageX - childrenBoxX < x.value + width.value ? true : false;
    if (localMouseDownOnName)
        dragSessionEnabled = true;
    else
        dragSessionEnabled = false;
}
function extendLocalSelectionUpwards()
{
    if (localMouseDirection || !localMouseDownPressed)
        return;
    if (gLocalTree.treeBoxObject.getFirstVisibleRow() == 0)
    {
        gLocalTree.view.selection.rangedSelect(localMouseDownRow, gLocalTree.treeBoxObject.getFirstVisibleRow(), false);
        return;
    }
    gLocalTree.treeBoxObject.ensureRowIsVisible(gLocalTree.treeBoxObject.getFirstVisibleRow() - 1);
    gLocalTree.view.selection.rangedSelect(localMouseDownRow, gLocalTree.treeBoxObject.getFirstVisibleRow(), false);
    if (localMouseDownPressed)
        setTimeout("extendLocalSelectionUpwards()", 100);
}
function extendLocalSelectionDownwards()
{
    if (!localMouseDirection || !localMouseDownPressed)
        return;
    if (gLocalTree.view.rowCount - 1 < gLocalTree.treeBoxObject.getLastVisibleRow())
    {
        gLocalTree.view.selection.rangedSelect(localMouseDownRow, gLocalTree.treeBoxObject.getLastVisibleRow(), false);
        return;
    }
    gLocalTree.treeBoxObject.ensureRowIsVisible(gLocalTree.treeBoxObject.getLastVisibleRow() + 1);
    gLocalTree.view.selection.rangedSelect(localMouseDownRow, gLocalTree.treeBoxObject.getLastVisibleRow(), false);
    if (localMouseDownPressed)
        setTimeout("extendLocalSelectionDownwards()", 100);
}
function onLocalMouseMove(event)    // does pageX or clientX make a difference?
{
    if (localMouseDownPressed && !event.ctrlKey && !dragSessionEnabled)
    {
        var row = {};
        var col = {};
        var child = {};
        if (localMousePreviousY)
            localMouseDirection = event.pageY - localMousePreviousY > 0 ? true : false;
        localMousePreviousY = event.pageY;
        if (event.pageY < document.getElementById('localtreechildren').boxObject.y)
        {
            extendLocalSelectionUpwards();
            return;
        }
        else if (event.pageY > document.getElementById('localtreechildren').boxObject.y + document.getElementById('localtreechildren').boxObject.height)
        {
            extendLocalSelectionDownwards();
            return;
        }
        gLocalTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);
        if (row.value == -1)
            return;
        gLocalTree.view.selection.rangedSelect(localMouseDownRow, row.value, false);
    }
}
function onLocalMouseUp(event)
{
    localMouseDownPressed = false;
}

// *************************************************************************************************
// ***************************************** local tree views **************************************
// *************************************************************************************************

function changeLocalView(column, direction)
{
    var dir;
    var treeitem = new Array;

    try {
        dir = Components.classes['@mozilla.org/file/local;1'].createInstance(Components.interfaces.nsILocalFile);
        dir.initWithPath(gLocalPath.value);
        var entries = dir.directoryEntries;
        while (entries.hasMoreElements())
        {
            var file = entries.getNext().QueryInterface(Components.interfaces.nsIFile);
            if (file.exists() && (!file.isHidden() || hiddenmode))
                treeitem.push(file);
        }
    } catch (ex) {
        error(strbundle.getString("noPermission"));
        debug(ex,31);
    }


    // sort directories to the top
    var directories = new Array;
    var files = new Array;
    for (var x = 0; x < treeitem.length; ++x)
    {
        if (treeitem[x].isDirectory())
            directories.push(treeitem[x]);
        else
            files.push(treeitem[x]);
    }
    treeitem = directories.concat(files);

    // begin column sorting
    if (!column)
    {
        if (document.getElementById('localname').getAttribute("sortDirection") &&
                document.getElementById('localname').getAttribute("sortDirection") != "natural")
        {
            column = "localname";
            direction = document.getElementById('localname').getAttribute("sortDirection");
        }
        if (document.getElementById('localsize').getAttribute("sortDirection") &&
                document.getElementById('localsize').getAttribute("sortDirection") != "natural")
        {
            column = "localsize";
            direction = document.getElementById('localsize').getAttribute("sortDirection");
        }
        if (document.getElementById('localdate').getAttribute("sortDirection") &&
                document.getElementById('localdate').getAttribute("sortDirection") != "natural")
        {
            column = "localdate";
            direction = document.getElementById('localdate').getAttribute("sortDirection");
        }
        if (document.getElementById('localattr').getAttribute("sortDirection") &&
                document.getElementById('localattr').getAttribute("sortDirection") != "natural")
        {
            column = "localattr";
            direction = document.getElementById('localattr').getAttribute("sortDirection");
        }
    }

    if (column == "localname")
        treeitem.sort(compareLocalName);
    if (column == "localsize")
        treeitem.sort(compareLocalSize);
    if (column == "localdate")
        treeitem.sort(compareLocalDate);
    if (column == "localattr")
        treeitem.sort(compareLocalAttr);
    if (direction == "ascending")
        treeitem.reverse();
    // end column sorting

    // get directory size
    localsize = 0;
    localAvailableDiskSpace = dir.diskSpaceAvailable;
    for (var x = 0; x < treeitem.length; ++x)
        localsize += treeitem[x].fileSize;

    if (localsize > 1024 * 1024 * 1024)
        localsize = parseInt(localsize / 1024 / 1024 / 1024).toFixed(1) + " GB";
    else if (localsize > 1024 * 1024)
        localsize = parseFloat(localsize / 1024 / 1024).toFixed(1) + " MB";
    else if (localsize > 1024)
        localsize = parseFloat(localsize / 1024).toFixed(1) + " KB";
    else
        localsize = localsize + " Bytes";

    if (localAvailableDiskSpace > 1024 * 1024 * 1024)
        localAvailableDiskSpace = parseFloat(localAvailableDiskSpace / 1024 / 1024 / 1024).toFixed(1) + " GB";
    else if (localAvailableDiskSpace > 1024 * 1024)
        localAvailableDiskSpace = parseFloat(localAvailableDiskSpace / 1024 / 1024).toFixed(1) + " MB";
    else if (localAvailableDiskSpace > 1024)
        localAvailableDiskSpace = parseFloat(localAvailableDiskSpace / 1024).toFixed(1) + " KB";
    else
        localAvailableDiskSpace = localAvailableDiskSpace + " Bytes";

    var treeView = {
    rowCount : treeitem.length,
    getCellText : function(row,column){
        if (row == -1)
            return " ";
        switch(column)
        {
            case "localname":
                return treeitem[row].leafName;
            case "localsize":
                if (treeitem[row].isDirectory())
                    return "";
                if (treeitem[row].fileSize == 0)
                    return "0 KB  ";
                return commas(parseInt(treeitem[row].fileSize / 1024) + 1) + " KB  ";
            case "localdate":
                var date = new Date(treeitem[row].lastModifiedTime);
                var monthsString = strbundle.getString("months");
                var months = monthsString.split("|");
                var currentDate = new Date();
                if (currentDate.getYear() < date.getYear())
                    return months[date.getMonth()] + ' ' + date.getDate() + ' ' + date.getYear();
                else
                {
                    var time =  date.toLocaleTimeString();
                    return months[date.getMonth()] + ' ' + date.getDate() + ' ' + time.substring(0, time.lastIndexOf(':'));
                }
            case "localattr":
                if (treeitem[row].permissions)
                    return treeitem[row].permissions;
                return "";
            default:
                return " "; // shouldn't get here
        }
    },
    setTree: function(treebox){ this.treebox = treebox; },
    isContainer: function(row){ return false; },
    isSeparator: function(row){ return false; },
    isSorted: function(row){ return false; },
    getLevel: function(row){ return 0; },
    getImageSrc: function(row,col)
    {
        if (row == -1)
            return "";
        if (col == "localname")
        {
            if (treeitem[row].isDirectory())
                return "res/directory.ico";      // kind of a hack - is there a way to get the folder icon from "moz-icon://"?
            return "moz-icon://" + this.getCellText(row, col) + "?size=16";
        }
    },
    getRowProperties: function(row,props){},
    getCellProperties: function(row,col,props){},
    getColumnProperties: function(colid,col,props){},
    cycleHeader: function(col, elem){ }
    };

    localDirManager(gLocalPath.value, directories);

    var dirTreeView = {
    rowCount : localdircache.length,
    getCellText : function(row,column){
        if (row == -1)
            return "";
        if (row == 0)
            return localdircache[row].path;
        return localdircache[row].path.substring(localdircache[row].path.lastIndexOf(slash) + 1);
    },
    getParentIndex: function(row){
        if (row == -1)
            return -1;
        if (row == 0)
            return -1;
        var parent = localdircache[row].path.substring(0, localdircache[row].path.lastIndexOf(slash));
        if (parent.length == 0)
            return 0;
        for (var x = 0; x < localdircache.length; ++x)
            if (localdircache[x].path == parent)
                return x;
    },
    isContainerOpen: function(row){ return localdircache[row].open; },
     isContainerEmpty:function(row){ return localdircache[row].empty; },
     hasNextSibling: function(row,nextrow) { return localdircache[row].hasnext; },
    getLevel:function(row) {
        if (row == -1)
            return 0;
        if (row < 0 || row >= localdircache.length)
             return 0;
        if (slash == "/")
            return row ? localdircache[row].path.match(/\x2f/g).length : 0;
        else
            return row ? localdircache[row].path.match(/\x5c/g).length : 0;
    },
    toggleOpenState:function(row){
        if (this.isContainerOpen(row))
        {
            var count = 1;
            while ((count + row) < localdircache.length && this.getLevel(count + row) > this.getLevel(row))
                ++count;
            --count;
            var temp = localdircache.splice(row + 1, count);
            if (temp.path)
                temp = new Array(temp); // messy, messy, messy
            if (localdircache.path)
                localdircache = new Array(localdircache); // messy, messy, messy
            if (hiddenlocaldircache.path)
                hiddenlocaldircache = new Array(hiddenlocaldircache); // messy, messy, messy
            hiddenlocaldircache = temp.concat(hiddenlocaldircache);
            if (hiddenlocaldircache.path)
                hiddenlocaldircache = new Array(hiddenlocaldircache); // messy, messy, messy
            gLocalDirTree.treeBoxObject.rowCountChanged(row, -count);
            localdircache[row].open = false;
            localdircache[row].children = temp.length;
            if (gLocalPath.value.indexOf(localdircache[row].path) != -1
                    && gLocalPath.value != localdircache[row].path)
            {
                gLocalPath.value = localdircache[row].path;
                changeLocalView();
                gLocalDirTree.view.selection.select(row);
                gLocalDirTree.treeBoxObject.ensureRowIsVisible(row);
            }
            if (gLocalPath.value == localdircache[row].path)
            {
                gLocalDirTree.view.selection.select(row);
                gLocalDirTree.treeBoxObject.ensureRowIsVisible(row);
            }
        }
        else
        {
            var found = -1;
            var number = localdircache[row].children;
            for (var x = 0; x < hiddenlocaldircache.length; ++x)
            {
                if (hiddenlocaldircache[x].path.indexOf(localdircache[row].path) != -1)
                {
                    found = x;
                    break;
                }
            }
            if (found == -1)
            {
                var temp = gLocalPath.value;
                if (!refreshLocal)
                {
                    gLocalPath.value = localdircache[row].path;
                    changeLocalView();
                    gLocalPath.value = temp;
                    changeLocalView();
                }
                if (!localdircache[row].empty)
                    localdircache[row].open = true;
                localdircache[row].children = -1;
                for (var x = 0; x < localdircache.length; ++x)
                    if (localdircache[x].path == temp)
                    {
                        gLocalDirTree.view.selection.select(x); // when moving with keys
                        gLocalDirTree.treeBoxObject.ensureRowIsVisible(x + (localLastRowSeen - x - 1));
                        localLastRowSeen = 0;
                        break;
                    }
                return;
            }
            var toBeAdded = hiddenlocaldircache.splice(found, number);
            var piece = localdircache.splice(0, row + 1);
            if (toBeAdded.path)
                toBeAdded = new Array(toBeAdded);    // messy, messy, messy
            if (piece.path)
                piece = new Array(piece); // messy, messy, messy
            if (localdircache.path)
                localdircache = new Array(localdircache); // messy, messy, messy
            if (hiddenlocaldircache.path)
                hiddenlocaldircache = new Array(hiddenlocaldircache); // messy, messy, messy
            localdircache = piece.concat(toBeAdded, localdircache);
            if (localdircache.path)
                localdircache = new Array(localdircache); // ditto, ditto, ditto
            gLocalDirTree.treeBoxObject.rowCountChanged(row, toBeAdded.length);
            if (!localdircache[row].empty)
                localdircache[row].open = true;
            localdircache[row].children = -1;
            if (gLocalPath.value == localdircache[row].path)
            {
                gLocalDirTree.view.selection.select(row);
                gLocalDirTree.treeBoxObject.ensureRowIsVisible(row + (localLastRowSeen - row - 1));
                localLastRowSeen = 0;
            }
        }
    },
    isSeparator: function(row){ return false; },
    isSorted: function(row){ return false; },
      isContainer: function(row){ return true; },
    getImageSrc: function(row,col){
        if (this.isContainerOpen(row))
            return "res/directoryopen.ico";    // hack - folder icon from "moz-icon://"?
        else
            return "res/directory.ico";
    },
    setTree: function(treebox){ this.treebox = treebox; },
    getRowProperties: function(row,props){},
    getCellProperties: function(row,col,props){},
    getColumnProperties: function(colid,col,props){},
    };

    gLocalTree.view = treeView;
    gLocalDirTree.view = dirTreeView;

    // on startup, select root on localdirtree
    if (gLocalDirTree.view.selection.count == 0)
        gLocalDirTree.view.selection.select(0);
}
function localDirManager(path, data)
{
    for (var x = 0; x < localdircache.length; ++x)
    {
        if (localdircache[x].path == path)
        {
            if (data.length == 0)
            {
                localdircache[x].empty = true;
                localdircache[x].open = false;
            }
            else
                localdircache[x].empty = false;
            break;
        }
    }
    for (var x = 0; x < data.length; ++x)
        data[x] = {path: data[x].path, open: false, empty: false, children: -1, hasnext: true };
    if (data.path)
        data = new Array(data); // messy, messy, messy
    data.sort(directorySort);
    if (data.length)
        data[data.length - 1].hasnext = false;
    localdircache = localdircache.concat(data);
    if (localdircache.path)
        localdircache = new Array(localdircache); // messy, messy, messy

    if (slash == "\\")    //XXX hack - damn you ms-dos: '\\' is greater than capital letters, so convert to '/'
    {
        for (var x = 0; x < localdircache.length; ++x)
            localdircache[x].path = localdircache[x].path.replace(/\x5c/g, "/");
    }
    localdircache.sort(directorySort);
    if (slash == "\\")    //XXX hack part deux- revert back to '\\'
    {
        for (var x = 0; x < localdircache.length; ++x)
            localdircache[x].path = localdircache[x].path.replace(/\x2f/g, "\\");
    }

    // check for duplicates
    for (var x = 0; x < localdircache.length - 1; ++x)
    {
        if (localdircache[x].path == localdircache[x + 1].path)
        {
            if (localdircache[x].open)
                localdircache[x + 1].open = true;
            if (localdircache[x].empty)
                localdircache[x + 1].empty = true;
            if (localdircache[x].children != -1)
                localdircache[x + 1].children = localdircache[x].children;
            if (localdircache[x].hasnext)
                localdircache[x + 1].hasnext = true;
            localdircache.splice(x, 1);
            if (localdircache.path)
                localdircache = new Array(localdircache); // messy, messy, messy
        }
    }
    var didSplice = false;
    for (var x = 0; x < localdircache.length; ++x)
    {
        for (var y = 0; y < hiddenlocaldircache.length; ++y)
        {
            if (x >= localdircache.length) // splicing might cause invalid indices
                break;
            if (localdircache[x].path == hiddenlocaldircache[y].path)
            {
                localdircache.splice(x, 1);
                didSplice = true;
                if (localdircache.path)
                    localdircache = new Array(localdircache); // messy, messy, messy
            }
        }
        if (didSplice)    // gotta start from 0 again b/c array will have shifted around, better safe...
        {
            x = -1;    // will get incremented up to 0
            didSplice = false;
        }
    }
}
// *************************************************************************************************
// *************************************** refresh local view **************************************
// *************************************************************************************************

function refreshLocalView()
{
    refreshLocal = true;
    // get rid of old directory entries
    for (var x = 0; x < localdircache.length; ++x)
        if (localdircache[x].path.indexOf(gLocalPath.value) != -1
            && gLocalPath.value != localdircache[x].path)
        {
            localdircache.splice(x, 1);
            if (localdircache.path)
                    localdircache = new Array(localdircache); // messy, messy, messy
            x = -1; // start from the top, to be safe
        }
    for (var x = 0; x < hiddenlocaldircache.length; ++x)
        if (hiddenlocaldircache[x].path.indexOf(gLocalPath.value) != -1
            && gLocalPath.value != hiddenlocaldircache[x].path)
        {
            hiddenlocaldircache.splice(x, 1);
            if (hiddenlocaldircache.path)
                    hiddenlocaldircache = new Array(hiddenlocaldircache); // messy, messy, messy
            x = -1; // start from the top, to be safe
        }
    for (var x = 0; x < localdircache.length; ++x)
        if (localdircache[x].path == gLocalPath.value)
        {
            localDirChangeHelper(x);
            break;
        }
    refreshLocal = false;
}

// *************************************************************************************************
// *************************************** browse local folders ************************************
// *************************************************************************************************

function browseLocal()
{
    var nsIFilePicker = Components.interfaces.nsIFilePicker;
    var fp = Components.classes["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
    fp.init(window, strbundle.getString("selectFiles"), nsIFilePicker.modeGetFolder);
    var res = fp.show();
    if (res == nsIFilePicker.returnOK)
    {
        var thedir = fp.file;
        gLocalPath.value = thedir.path;
        onLocalPathChange();
    }
}

// *************************************************************************************************
// *************************************** rename local file ***************************************
// *************************************************************************************************

function renameLocalFile(path, openRenamedDirectory)
{
    var file = getLocalFileSpec(path);
    var newName = window.prompt(strbundle.getString("renameTo"), file.leafName, strbundle.getString("rename"));
    if (!newName)
        return;

    if (file.exists())
    {
        try {
            file.rename(newName);
        } catch (ex) {
            error(strbundle.getString("renameFail"));
            debug(ex,32);
            return;
        }
    }
    if (openRenamedDirectory)
        onLocalCDUP();
    refreshLocalView();
    if (openRenamedDirectory)
    {
        gLocalPath.value = file.unicodePath;
        onLocalPathChange();
    }
    else
    {
        gLocalTree.focus();
        for (var x = 0; x < gLocalTree.view.rowCount; ++x)
            if (newName == gLocalTree.view.getCellText(x, "localname"))
            {
                gLocalTree.view.selection.select(x);
                break;
            }
    }
}

// *************************************************************************************************
// *************************************** make local directory ************************************
// *************************************************************************************************

function makeLocalDirectory()
{
    var newName = window.prompt(strbundle.getString("directoryName"), "", strbundle.getString("newDirectory"));
    if (!newName)
        return;
    if (gLocalPath.value.charAt(gLocalPath.value.length - 1) != slash)
        newName = gLocalPath.value + slash + newName;
    else
        newName = gLocalPath.value + newName;
    var file = getLocalFileSpec(newName);
    try{
        file.createDir();
    } catch (ex) {
        error(strbundle.getString("dirFail"));
        debug(ex,33);
        return;
    }
    refreshLocalView();
    gLocalPath.value = file.unicodePath;
    onLocalPathChange();
    gLocalTree.focus();
}

// *************************************************************************************************
// *************************************** delete local file ***************************************
// *************************************************************************************************

function deleteLocalFile(path, cdUP, prompt)
{
    var file = Components.classes['@mozilla.org/file/local;1'].createInstance(Components.interfaces.nsILocalFile);
    file.initWithPath(path);
    var isDirectory = file.isDirectory();

    if (prompt && isDirectory)
    {
        if (!window.confirm(strbundle.getString("confirmDelete") + " '" + file.leafName + "' " + strbundle.getString("confirmDelete3")))
            return;
    }
    else if (prompt)
    {
        if (!window.confirm(strbundle.getString("confirmDelete") + " '" + file.leafName + "'?"))
            return;
    }

    try {
        file.remove(true);
    } catch (ex) {
        error(strbundle.getString("delFail"));
        debug(ex,34);
        return;
    }

    if (prompt)
    {
        if (cdUP)
            onLocalCDUP();
        refreshLocalView();
    }
}

// *************************************************************************************************
// *************************************** local properties ****************************************
// *************************************************************************************************

function getLocalProperties()
{
    var fileList = gLocalTree.view.selection;
    if (fileList.count == 0)
        return;

    var thepath = gLocalTree.view.getCellText(fileList.currentIndex, "localname");
    if (gLocalPath.value.charAt(gLocalPath.value.length - 1) != slash)
        thepath = gLocalPath.value + slash + thepath;
    else
        thepath = gLocalPath.value + thepath;

    try {
        var file = getLocalFileSpec(thepath);
        var file2 = Components.classes['@mozilla.org/file/local;1'].createInstance(Components.interfaces.nsILocalFile);
        file2.initWithPath(thepath);

        var windowHeight = document.getElementById('main-window').boxObject.height;
        var windowWidth = document.getElementById('main-window').boxObject.width;

        var date = new Date(file2.lastModifiedTime);
        var monthsString = strbundle.getString("months");
        var months = monthsString.split("|");
        date = months[date.getMonth()] + ' ' + date.getDate() + ' ' + date.getYear() + ' ' + date.toLocaleTimeString();

        // linux permissions (not supported right now): file2.permissions
        window.openDialog("chrome://fireftp/content/propertiesDialog.xul","propertiesDialog",
                "screenY="+(windowHeight/2 - 100)+",screenX="+(windowWidth/2 - 300)+
                ",width=600,height=200,chrome,modal=yes,dialog=yes,resizable=yes",
                file.unicodePath, file.leafName, file.fileSize, date, 0,
                file2.isWritable(), file.isHidden(), file.isDirectory());
    } catch (ex) { debug(ex,41); }
}

// *************************************************************************************************
// *************************************** local cut/copy/paste ************************************
// *************************************************************************************************

var localCutParentDir;
function localCut()
{
    localCopy(true);
}
function localCopy(cut)
{
    var fileList = gLocalTree.view.selection;
    if (fileList.count == 0)
        return;

    localPasteFiles = new Array;
    var localParent = gLocalPath.value;

    for (var x = 0; x < gLocalTree.view.rowCount; ++x)
        if (gLocalTree.view.selection.isSelected(x))
        {
            var localpath = gLocalTree.view.getCellText(x, "localname");
            if (localParent.charAt(localParent.length - 1) != slash)
                localpath = localParent + slash + localpath;
            else
                localpath = localParent + localpath;

            localPasteFiles.push(getLocalFileSpec(localpath));
        }

    if (cut)
        localIsCut = true;
    else
        localIsCut = false;
    localCutParentDir = localParent;
    document.getElementById('localPasteContext').setAttribute("disabled", false);
    document.getElementById('localDirPasteContext').setAttribute("disabled", false);
}
function localPaste(localdir)
{
    var    parentDir;
    var prompt = true;
    var skipall = false;

    try {
        for (var x = 0; x < localPasteFiles.length; ++x)
        {
            if (!localPasteFiles[x].theparent)
                parentDir = localdir ? localdir : getLocalFileSpec(gLocalPath.value);
            else
            {
                parentDir = getLocalFileSpec(localPasteFiles[x].theparent);
                localPasteFiles[x] = localPasteFiles[x].thefile;
            }

            if (parentDir.unicodePath.indexOf(localPasteFiles[x].unicodePath) != -1)    // no, bad directory, bad!
                return;
            if (parentDir.unicodePath ==                                                // aw, not on the carpet!
                    (localCutParentDir.unicodePath ? localCutParentDir.unicodePath : localCutParentDir))
                return;

            var newPath = parentDir.unicodePath.charAt(parentDir.unicodePath.length - 1) == slash
                ? parentDir.unicodePath + localPasteFiles[x].leafName
                : parentDir.unicodePath + slash + localPasteFiles[x].leafName;

            var newFile = getLocalFileSpec(newPath);

            if (newFile.exists() && skipall)
                continue;
            if (newFile.exists() && prompt && !newFile.isDirectory())
            {
                var response = new Object();
                response.value = 0;
                var windowHeight = document.getElementById('main-window').boxObject.height;
                var windowWidth = document.getElementById('main-window').boxObject.width;
                var timer = destructmode;

                window.openDialog("chrome://fireftp/content/confirmFileDialog.xul","confirmFileDialog",
                    "screenY="+(windowHeight/2 - 45)+",screenX="+(windowWidth/2 - 200)+
                    ",width=400,height=90,chrome,modal=yes,dialog=yes,resizable=yes", response, localPasteFiles[x].leafName, true, true, timer);
                if (response.value == 2)
                    prompt = false;
                else if (response.value == 3)
                    continue;
                else if (response.value == 4 || response.value == 0)
                    return;
                else if (response.value == 5)
                {
                    skipall = true;
                    continue;
                }

                if ((response.value == 1 || response.value == 2) && !newFile.isDirectory())
                {
                    // due to a lovely quirk in mozilla's api you can't use nsIFileSpec's delete() function
                    // b/c javascript thinks it's a dirty word, so hack hack hack, workaround
                    var file2 = Components.classes['@mozilla.org/file/local;1']
                        .createInstance(Components.interfaces.nsILocalFile);
                    file2.initWithPath(newFile.unicodePath);
                    file2.remove(false);
                }
            }
            if (newFile.exists() && !prompt && !newFile.isDirectory())
            {
                var file2 = Components.classes['@mozilla.org/file/local;1']
                        .createInstance(Components.interfaces.nsILocalFile);
                file2.initWithPath(newFile.unicodePath);
                file2.remove(false);
            }

            if (localPasteFiles[x].isDirectory())
            {
                if (!newFile.exists())
                    newFile.createDir();

                var moreFiles = new Array;
                try {
                    dir = Components.classes['@mozilla.org/file/local;1']
                        .createInstance(Components.interfaces.nsILocalFile);
                    dir.initWithPath(localPasteFiles[x].unicodePath);
                    var entries = dir.directoryEntries;
                    while (entries.hasMoreElements())
                    {
                        var file = entries.getNext().QueryInterface(Components.interfaces.nsIFile);
                        moreFiles.push(file);
                    }
                } catch (ex) { debug(ex,35); }
                if (moreFiles.length)
                {
                    if (localIsCut)
                        localPasteFiles.splice(x + 1, 0, localPasteFiles[x]);
                    for (var y = 0; y < moreFiles.length; ++y)
                        localPasteFiles.splice(x + 1, 0, { thefile : getLocalFileSpec(moreFiles[y].path), theparent: newFile.unicodePath });
                }
                else if (localIsCut)
                {
                    var file2 = Components.classes['@mozilla.org/file/local;1']
                        .createInstance(Components.interfaces.nsILocalFile);
                    file2.initWithPath(localPasteFiles[x].unicodePath);
                    file2.remove(true);
                }
                continue;
            }
            if (localIsCut)
                localPasteFiles[x].moveToDir(parentDir);
            else
                localPasteFiles[x].copyToDir(parentDir);
        }
    } catch (ex) {
        debug(ex,36);
        error(strbundle.getString("pasteError"));
        localPasteFiles = new Array;
        document.getElementById('localPasteContext').setAttribute("disabled", true);
        document.getElementById('localDirPasteContext').setAttribute("disabled", true);
    }

    if (localIsCut)
    {
        localPasteFiles = new Array;
        document.getElementById('localPasteContext').setAttribute("disabled", true);
        document.getElementById('localDirPasteContext').setAttribute("disabled", true);
    }

    var tempPath = gLocalPath.value;
    if (localdir)
    {
        var pathvalue = localCutParentDir.unicodePath
                ? localCutParentDir.parent.unicodePath
                : localCutParentDir.substring(0,
                    (localCutParentDir.lastIndexOf(slash) ? localCutParentDir.lastIndexOf(slash) : 1));
        gLocalPath.value = pathvalue;
        onLocalPathChange();
        refreshLocalView();
        gLocalPath.value = localdir.unicodePath;
        onLocalPathChange();
        refreshLocalView();
        if (!localCutParentDir.unicodePath || tempPath != localCutParentDir.unicodePath)
            gLocalPath.value = tempPath;
        else
            gLocalPath.value = pathvalue;
        onLocalPathChange();
    }
    else
    {
        gLocalPath.value = localCutParentDir.unicodePath ? localCutParentDir.parent.unicodePath : localCutParentDir;
        onLocalPathChange();
        refreshLocalView();
        gLocalPath.value = tempPath;
    }

    refreshLocalView();
}
function localDirCut()
{
    if (gLocalDirTree.view.selection.currentIndex == 0)    // you can't cut the root
        return;

    localDirCopy(true);
}
function localDirCopy(cut)
{
    if (gLocalDirTree.view.selection.count == 0)
        return;

    localPasteFiles = new Array;
    var dir = gLocalDirTree.view.selection.currentIndex;
    var localdir = getLocalFileSpec(localdircache[dir].path);

    localPasteFiles.push(localdir);

    if (cut)
        localIsCut = true;
    else
        localIsCut = false;
    localCutParentDir = localdir;
    document.getElementById('localPasteContext').setAttribute("disabled", false);
    document.getElementById('localDirPasteContext').setAttribute("disabled", false);
}
function localDirPaste()
{
    if (gLocalDirTree.view.selection.count == 0)
        return;

    var dir = gLocalDirTree.view.selection.currentIndex;
    var localdir = getLocalFileSpec(localdircache[dir].path);

    localPaste(localdir);
}

// *************************************************************************************************
// *************************************** local drag functions ************************************
// *************************************************************************************************

function onLocalDragOver(event)
{
    var row = {};
    var col = {};
    var child = {};
    var dragSession = whataDrag.getCurrentSession();
    var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance(Components.interfaces.nsITransferable);

    trans.addDataFlavor("text/unicode");
    dragSession.getData(trans, 0);
    var dataObj = new Object();
    var bestFlavor = new Object();
    var len = new Object();
    trans.getAnyTransferData(bestFlavor, dataObj, len);
    dataObj = dataObj.value.QueryInterface(Components.interfaces.nsISupportsString);

    gLocalTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);

    if (dataObj.data == "localtreechildren")
    {
        if (gLocalTree.view.getCellText(row.value, "localsize") == "")
            dragSession.canDrop = true;
        else
            dragSession.canDrop = false;
    }
    else
        dragSession.canDrop = true;
}
function onLocalDragDrop(event)
{
    var dragSession = whataDrag.getCurrentSession();
    var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance(Components.interfaces.nsITransferable);

    trans.addDataFlavor("text/unicode");
    dragSession.getData(trans, 0);
    var dataObj = new Object();
    var bestFlavor = new Object();
    var len = new Object();
    trans.getAnyTransferData(bestFlavor, dataObj, len);
    dataObj = dataObj.value.QueryInterface(Components.interfaces.nsISupportsString);

    if (dataObj.data == "localtreechildren")
    {
        var row = {};
        var col = {};
        var child = {};
        gLocalTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);
        var localParent = gLocalPath.value;
        localCut();
        var localpath = gLocalTree.view.getCellText(row.value, "localname");
        if (localParent.charAt(localParent.length - 1) != slash)
            localpath = localParent + slash + localpath;
        else
            localpath = localParent + localpath;
        gLocalPath.value = localpath;
        onLocalPathChange();
        localPaste();
    }
    else if (dataObj.data == "localdirtreechildren")
    {
        var localParent = gLocalPath.value;
        localDirCut();
        localPaste();
    }
    else if (dataObj.data == "remotetreechildren")
        retr();
    else if (dataObj.data == "remotedirtreechildren")
        retrDir();
    event.preventBubble();
}
function onLocalDirDragOver(event)
{
    var row = {};
    var col = {};
    var child = {};
    var dragSession = whataDrag.getCurrentSession();
    var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance(Components.interfaces.nsITransferable);
    trans.addDataFlavor("text/unicode");
    dragSession.getData(trans, 0);
    var dataObj = new Object();
    var bestFlavor = new Object();
    var len = new Object();
    trans.getAnyTransferData(bestFlavor, dataObj, len);
    dataObj = dataObj.value.QueryInterface(Components.interfaces.nsISupportsString);

    if (dataObj.data == "remotedirtreechildren" || dataObj.data == "remotetreechildren")
    {
        dragSession.canDrop = false;
        return;
    }

    gLocalDirTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);

    if (gLocalDirTree.view.getCellText(row.value, "localname") != "")
        dragSession.canDrop = true;
    else
        dragSession.canDrop = false;
}
function onLocalDirDragDrop(event)
{
    var dragSession = whataDrag.getCurrentSession();
    var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance(Components.interfaces.nsITransferable);

    trans.addDataFlavor("text/unicode");
    dragSession.getData(trans, 0);
    var dataObj = new Object();
    var bestFlavor = new Object();
    var len = new Object();
    trans.getAnyTransferData(bestFlavor, dataObj, len);
    dataObj = dataObj.value.QueryInterface(Components.interfaces.nsISupportsString);

    var row = {};
    var col = {};
    var child = {};
    gLocalDirTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);

    if (dataObj.data == "localtreechildren")
    {
        gLocalDirTree.view.selection.currentIndex = row.value;
        localCut();
        localDirPaste();
    }
    else if (dataObj.data == "localdirtreechildren")
    {
        localDirCut();
        gLocalDirTree.view.selection.currentIndex = row.value;
        localDirPaste();
    }
    event.preventBubble();
}

// *************************************************************************************************
// *********************************************** misc ********************************************
// *************************************************************************************************

function copyLog()
{
    var text = '';
    for (var x = 0; x < document.getElementById('cmdlog').getRowCount(); ++x)
        text += document.getElementById('cmdlog').getItemAtIndex(x).value + '\n';
    var clipboard = Components.classes["@mozilla.org/widget/clipboardhelper;1"].
            getService(Components.interfaces.nsIClipboardHelper );
    clipboard.copyString(text);
}

// log button
function showLog()
{
    logmode = !logmode;
    savePreferences();
    if (logmode)
    {
        document.getElementById('cmdlog').collapsed = false;
        document.getElementById('logsplitter').state = '';
        document.getElementById('logbutton').checked = false;
    }
    else
    {
        document.getElementById('cmdlog').collapsed = true;
        document.getElementById('logsplitter').state = 'collapsed';
        document.getElementById('logbutton').checked = true;
    }
    if (logmode)
        document.getElementById('cmdlog').ensureIndexIsVisible(document.getElementById('cmdlog').getRowCount() - 1);
}

// preferences button
function showPreferences()
{
    var windowHeight = document.getElementById('main-window').boxObject.height;
    var windowWidth = document.getElementById('main-window').boxObject.width;

    var hiddenCheckboxChange = new Object();
    hiddenCheckboxChange.value = 0;

    window.openDialog("chrome://fireftp/content/preferencesDialog.xul","preferencesDialog",
            "screenY="+(windowHeight/2 - 175)+",screenX="+(windowWidth/2 - 200)+
            ",width=400,height=350,chrome,modal=yes,dialog=yes,resizable=yes", hiddenCheckboxChange);
    readPreferences();
    if (!hiddenCheckboxChange.value)
        return;
    if (!hiddenmode)
    {
        var fileSpec = getLocalFileSpec(gLocalPath.value);
        var hiddenFound = false;
        while (true)
        {
            if (fileSpec.isHidden() && fileSpec.unicodePath != localdircache[0].path)
            {
                hiddenFound = true;
                break;
            }
            if (fileSpec.unicodePath == fileSpec.parent.unicodePath)
                break;
            fileSpec = fileSpec.parent;
        }
        if (hiddenFound)
            gLocalPath.value = localdircache[0].path;
    }
    localdircache = new Array;
    onLocalPathChange();
}

// change TYPE A/TYPE I/auto from statusbar
function onChangeType()
{
    var transferTypes = new Array("Auto", "Binary", "ASCII");
    filemode = (filemode + 1) % 3;
    document.getElementById('statustype').label = transferTypes[filemode];
    savePreferences();
}

// open a local file
function openFile()
{
    var fileList = gLocalTree.view.selection;
    if (fileList.count == 0)
        return;
    var thepath = gLocalTree.view.getCellText(fileList.currentIndex, "localname");
    if (gLocalPath.value.charAt(gLocalPath.value.length - 1) != slash)
        thepath = gLocalPath.value + slash + thepath;
    else
        thepath = gLocalPath.value + thepath;

    try {
        var file = Components.classes["@mozilla.org/file/local;1"].createInstance(Components.interfaces.nsILocalFile);
        file.initWithPath(thepath);
        if (file.exists())
            file.launch();
    } catch (ex) { debug(ex,37); }
}

// detect an ascii file - returns "A" or "I"
function detectAscii(path)
{
    if (filemode == 1)    // binary
        return "I";
    if (filemode == 2)    // ASCII
        return "A";

    path = path.substring(path.lastIndexOf('/') + 1);
    path = path.substring(path.lastIndexOf('.') + 1);

    var found = false;
    for (var x = 0; x < prefAsciiFiles.length; ++x)
        if (prefAsciiFiles[x] == path)
            found = true;

    if (found)
        return "A";
    return "I";
}

// add commas to numbers
function commas(num)
{
    num = num.toString();
    if (num.search(/\d{4}$/) == -1)
        return num;
    num = num.replace(/\d{3}$/, ",$&");
    while (num.search(/\d{4}\x2C/) != -1)
        num = num.replace(/\d{3}\x2C/, ",$&");
    return num;
}
// pad with zeros
function zeros(num)
{
    num = num.toString();
    if (num.length == 1)
        num = "0" + num;
    return num;
}
// send error message
function error(message, skipLog)
{
    if (!skipLog)
    {
        var el = document.getElementById('cmdlog').appendItem(message, message);
        el.setAttribute('style', 'color:red;font-weight:bold;');
        document.getElementById('cmdlog').ensureIndexIsVisible(document.getElementById('cmdlog').getRowCount() - 1);
    }
    if (errormode)
    {
        var windowHeight = document.getElementById('main-window').boxObject.height;
        var windowWidth = document.getElementById('main-window').boxObject.width;

        window.openDialog("chrome://fireftp/content/alertDialog.xul","alertDialog",
            "screenY="+(windowHeight/2 - 100)+",screenX="+(windowWidth/2 - 200)+
            ",width=400,height=200,chrome,modal=yes,dialog=yes,resizable=yes", message);
    }
    document.getElementById('statusbytes').label = "";
    document.getElementById('statusmeter').setAttribute("mode", "determined");
    document.getElementById('statusmeter').setAttribute("value", "0%");
}
// add debug message to log; last error number is currently 42
function debug(message, errornum)
{
    if (debugmode)
    {
        message = "Error " + errornum + ": " + message;
        var el = document.getElementById('cmdlog').appendItem(message, message);
        el.setAttribute('style', 'color:red;font-weight:bold;');
        document.getElementById('cmdlog').ensureIndexIsVisible(document.getElementById('cmdlog').getRowCount() - 1);
    }
}
// change way main tab looks like
function interfaceChange(local, remote)
{
    document.getElementById('localview').collapsed = local;
    document.getElementById('storbutton').collapsed = local;
    document.getElementById('remoteview').collapsed = remote;
    document.getElementById('retrbutton').collapsed = remote;
}
function sendAbort()
{
    isReconnecting = false;
    document.getElementById('statusbytes').label = "";
    document.getElementById('statusmeter').setAttribute("mode", "determined");
    document.getElementById('statusmeter').setAttribute("value", "0%");
    if (!isConnected)
        return;
    //XXX writeControl("ABOR");

    document.getElementById('statusbytes').label = strbundle.getString("working");
    document.getElementById('statuselapsed').label = "";
    document.getElementById('statusremaining').label = "";
    document.getElementById('statusrate').label = "";
    document.getElementById('statusmeter').setAttribute("mode", "undetermined");
    document.title = "fireFTP";

    try {
        data_transport.close("Finished");     // ABOR does not seem to stop the connection in most cases
                                            // so this is a more direct approach
        data_finished = true;
        if (file_instream)
            file_instream.close();
    } catch (ex) { debug(ex,38); }

    moreToRemember = "";
    data_remember = "";
    eventQueue = new Array;
    addEventQueue("aborted");
    refreshLocalView();
    refreshRemoteView();
}
function recoverFromDisaster()
{
    if (eventQueue.length && eventQueue[0].cmd == "goodbye")
        eventQueue.shift();
    if (eventQueue.cmd)
        eventQueue = new Array(eventQueue);
    if (eventQueue.length && (eventQueue[0].cmd == "LIST" || eventQueue[0].cmd == "LIST2"
            || eventQueue[0].cmd == "RETR" || eventQueue[0].cmd == "RETR2"
            || eventQueue[0].cmd == "REST" || eventQueue[0].cmd == "APPE"
            || eventQueue[0].cmd == "STOR" || eventQueue[0].cmd == "STOR2"
            || eventQueue[0].cmd == "PASV" || eventQueue[0].cmd == "APPE2"))
    {
        var cmd = eventQueue[0].cmd;
        var parameter = eventQueue[0].parameter;
        if (cmd == "LIST2" || cmd == "RETR2" || cmd == "STOR2" || cmd == "APPE2")
            eventQueue[0].cmd = eventQueue[0].cmd.substring(0,4);
        cmd = eventQueue[0].cmd;

        // set up resuming for these poor interrupted transfers
        if (cmd == "REST")
        {
            try {
                var file = getLocalFileSpec(eventQueue[1].remember);
                if (file.fileSize)
                    eventQueue[0].parameter = file.fileSize;
            }catch(ex) { debug(ex,39); }
        }
        else if (cmd == "RETR")
        {
            try {
                var file = getLocalFileSpec(eventQueue[0].remember);
                if (file.fileSize)
                    eventQueue.unshift({ cmd: "REST", parameter: file.fileSize, remember: "" });
            }catch(ex) { debug(ex,40); }
        }

        // find the missing commands that complete the sets - this is where TYPE is handy
        var found = -1;
        var tempQueue = new Array;
        for (var x = 0; x < trashQueue.length; ++x)
            if (trashQueue[x].cmd == "TYPE" || found != -1)
            {
                tempQueue.push(trashQueue[x]);
                found = x;
            }
        eventQueue = tempQueue.concat(eventQueue);// ah, that's better

        // more resuming fun - this time for the stor/appe commandds
        if (cmd == "STOR" || cmd == "APPE")
            eventQueue.unshift({ cmd: "SIZE", parameter: parameter, remember: cmd });
    }
    else if (eventQueue.length && eventQueue[0].cmd == "RNTO") // don't worry RNTO, i didn't forget about you :)
    {
        if (trashQueue[trashQueue.length - 1].cmd == "RNFR")
            eventQueue.unshift(trashQueue[trashQueue.length - 1]); // ah, that's better
    }
    trashQueue = new Array;
}
function checkTimeout(id, cmd, dataSocket)
{
    // uploads currently can't be used with this function - we ignore them
    if (eventQueue.length && (eventQueue[0].cmd.indexOf("APPE") != -1 || eventQueue[0].cmd.indexOf("STOR") != -1))
        return;
    if (networkTimeoutID == id && eventQueue.length && (dataSocket || eventQueue[0].cmd.indexOf(cmd) != -1)) // still stuck here
    {
        legitClose = false;    // trying to restart the connection after a timeout
        close();
    }
        // try to restart the connection the hard way
        // are there better ways? if anybody is actually reading this, let me know
}
function displayWelcomeMessage()
{
    if (welcomemode)
    {
        var windowHeight = document.getElementById('main-window').boxObject.height;
        var windowWidth = document.getElementById('main-window').boxObject.width;

        window.openDialog("chrome://fireftp/content/welcomeDialog.xul","welcomeDialog",
                "screenY="+(windowHeight/2 - 100)+",screenX="+(windowWidth/2 - 200)+
                ",width=400,height=200,chrome,modal=no,dialog=yes,resizable=yes", welcomeMessage);
    }
}
// *************************************************************************************************
// *************************************** sort functions ******************************************
// *************************************************************************************************

function directorySort(a, b)
{
    var tempA = a.path.replace(/\x2f/g, "\x01").toLowerCase();    // make '/' less than everything (except null really)
    var tempB = b.path.replace(/\x2f/g, "\x01").toLowerCase();

    if (tempA < tempB)
        return -1;
    if (tempA > tempB)
        return 1;
    return 0;
}
function compareRemoteName(a, b)
{
    if (!a.isDirectory && b.isDirectory)
        return 1;
    if (a.isDirectory && !b.isDirectory)
        return -1;
    if (a.name.toLowerCase() < b.name.toLowerCase())
        return -1;
    if (a.name.toLowerCase() > b.name.toLowerCase())
        return 1;
    return 0;
}
function compareRemoteSize(a, b)
{
    if (!a.isDirectory && b.isDirectory)
        return 1;
    if (a.isDirectory && !b.isDirectory)
        return -1;
    return a.size - b.size;
}
function compareRemoteDate(a, b)
{
    if (!a.isDirectory && b.isDirectory)
        return 1;
    if (a.isDirectory && !b.isDirectory)
        return -1;
    var aTemp = a.date;
    var bTemp = b.date;
    if (a.date.indexOf(':') != -1)
        aTemp = aTemp + ' ' + ((new Date()).getYear() + 0);    // quirky
    if (b.date.indexOf(':') != -1)
        bTemp = bTemp + ' ' + ((new Date()).getYear() + 0);    // quirky
    return Date.parse(aTemp) - Date.parse(bTemp);
}
function compareRemoteAttr(a, b)
{
    if (!a.isDirectory && b.isDirectory)
        return 1;
    if (a.isDirectory && !b.isDirectory)
        return -1;
    if (a.attr < b.attr)
        return -1;
    if (a.attr > b.attr)
        return 1;
    return 0;
}
function compareLocalName(a, b)
{
    if (!a.isDirectory() && b.isDirectory())
        return 1;
    if (a.isDirectory() && !b.isDirectory())
        return -1;
    if (a.leafName.toLowerCase() < b.leafName.toLowerCase())
        return -1;
    if (a.leafName.toLowerCase() > b.leafName.toLowerCase())
        return 1;
    return 0;
}
function compareLocalSize(a, b)
{
    if (!a.isDirectory() && b.isDirectory())
        return 1;
    if (a.isDirectory() && !b.isDirectory())
        return -1;
    return a.fileSize - b.fileSize;
}
function compareLocalDate(a, b)
{
    if (!a.isDirectory() && b.isDirectory())
        return 1;
    if (a.isDirectory() && !b.isDirectory())
        return -1;
    return a.lastModifiedTime - b.lastModifiedTime;
}
function compareLocalAttr(a, b)
{
    if (!a.isDirectory() && b.isDirectory())
        return 1;
    if (a.isDirectory() && !b.isDirectory())
        return -1;
    if (a.permissions < b.permissions)
        return -1;
    if (a.permissions > b.permissions)
        return 1;
    return 0;
}
function customSort(target)
{
    if (target.localName != "treecol")
        return;

    var sortDirection =
        target.getAttribute("sortDirection") == "ascending" || target.getAttribute("sortDirection") == "natural"
        ? "descending" : "ascending";

    if (target.parentNode.parentNode.getAttribute("id") == "localtree")
    {
        document.getElementById('localname').setAttribute("sortDirection", "natural");
        document.getElementById('localsize').setAttribute("sortDirection", "natural");
        document.getElementById('localdate').setAttribute("sortDirection", "natural");
        document.getElementById('localattr').setAttribute("sortDirection", "natural");
        target.setAttribute("sortDirection", sortDirection);
        changeLocalView(target.getAttribute("id"), sortDirection);
        onLocalPathChange();
    }
    else
    {
        document.getElementById('remotename').setAttribute("sortDirection", "natural");
        document.getElementById('remotesize').setAttribute("sortDirection", "natural");
        document.getElementById('remotedate').setAttribute("sortDirection", "natural");
        document.getElementById('remoteattr').setAttribute("sortDirection", "natural");
        target.setAttribute("sortDirection", sortDirection);
        changeRemoteView(target.getAttribute("id"), sortDirection);
        onRemotePathChange();
    }
}

// *************************************************************************************************
// *************************************** create drag session *************************************
// *************************************************************************************************

var whataDrag = Components.classes["@mozilla.org/widget/dragservice;1"].getService(Components.interfaces.nsIDragService);
var dragSessionEnabled = false;
function onDragGesture(event, ignore)
{
    if (!isConnected && event.target.getAttribute("id").indexOf("remote") != -1)
        return;

    if (!dragSessionEnabled && !ignore)
        return;

    if (ignore)
    {
        var row = {};
        var col = {};
        var child = {};
        if (event.target.getAttribute("id") == "localdirtreechildren")
        {
            gLocalDirTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);
            if (!gLocalDirTree.view.getCellText(row.value, "localdirname"))
                return;
        }
        else
        {
            gRemoteDirTree.treeBoxObject.getCellAt(event.pageX, event.pageY, row, col, child);
            if (!gRemoteDirTree.view.getCellText(row.value, "remotedirname"))
                return;
        }
    }

    var transArray = Components.classes["@mozilla.org/supports-array;1"].createInstance(Components.interfaces.nsISupportsArray);
    var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance(Components.interfaces.nsITransferable);

    trans.addDataFlavor("text/unicode");
    var origin = Components.classes["@mozilla.org/supports-string;1"].createInstance(Components.interfaces.nsISupportsString);
    origin.data = event.target.getAttribute("id");
    trans.setTransferData("text/unicode", origin, origin.data.length * 2);
    transArray.AppendElement(trans.QueryInterface(Components.interfaces.nsISupports));
    whataDrag.invokeDragSession(event.target, transArray, null, whataDrag.DRAGDROP_ACTION_MOVE);
    event.preventBubble();
}