/***** BEGIN LICENSE BLOCK ***** {{{
Version: MPL 1.1/GPL 2.0/LGPL 2.1

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.

(c) 2006-2007: Martin Stubenschrott <stubenschrott@gmx.net>

Alternatively, the contents of this file may be used under the terms of
either the GNU General Public License Version 2 or later (the "GPL"), or
the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
in which case the provisions of the GPL or the LGPL are applicable instead
of those above. If you wish to allow use of your version of this file only
under the terms of either the GPL or the LGPL, and not to allow others to
use your version of this file under the terms of the MPL, indicate your
decision by deleting the provisions above and replace them with the notice
and other provisions required by the GPL or the LGPL. If you do not delete
the provisions above, a recipient may use your version of this file under
the terms of any one of the MPL, the GPL or the LGPL.
}}} ***** END LICENSE BLOCK *****/

// The only global object, a handler to the main Vimperator object
var vimperator = null;

var popup_allowed_events; // need to change and reset this firefox pref

// handles multi-line commands
var prev_match = new Array(5);
var heredoc = '';

// called when the chrome is fully loaded and before the main window is shown
window.addEventListener("load", init, false);

////////////////////////////////////////////////////////////////////////
// init/uninit //////////////////////////////////////////////////// {{{1
////////////////////////////////////////////////////////////////////////
function init()
{
    // init the main object
    vimperator = new Vimperator;
    
    // these inner classes are created here, because outside the init()
    // function, the chrome:// is not ready

    // TODO: can these classes be moved into a namesspace to now clobber
    // the main namespace?
    Vimperator.prototype.options       = new Options;
    Vimperator.prototype.events        = new Events;
    Vimperator.prototype.commands      = new Commands;
    Vimperator.prototype.bookmarks     = new Bookmarks;
    Vimperator.prototype.history       = new History;
    Vimperator.prototype.commandline   = new CommandLine;
    Vimperator.prototype.search        = new Search;
    Vimperator.prototype.previewwindow = new InformationList("vimperator-previewwindow", { incremental_fill: false, max_items: 10 });
    Vimperator.prototype.bufferwindow  = new InformationList("vimperator-bufferwindow", { incremental_fill: false, max_items: 10 });
    Vimperator.prototype.statusline    = new StatusLine;
    Vimperator.prototype.tabs          = new Tabs;
    Vimperator.prototype.mappings      = new Mappings;
    Vimperator.prototype.marks         = new Marks;

    // DJK FIXME
    Vimperator.prototype.echo    = vimperator.commandline.echo;
    Vimperator.prototype.echoerr = vimperator.commandline.echoErr;

    // XXX: move into Vimperator() ?
    vimperator.input = {
        buffer: "",                 // partial command storage
        pendingMap: null,           // pending map storage
        count: -1,                  // parsed count from the input buffer
    };

    // XXX: move elsewhere
    vimperator.registerCallback("submit", vimperator.modes.EX, function(command) { /*vimperator.*/execute(command); } );
    vimperator.registerCallback("complete", vimperator.modes.EX, function(str) { return exTabCompletion(str); } );

    // this function adds all our required listeners to react on events
    // also stuff like window.onScroll is handled there.
    //addEventListeners();
    //vimperator.events();

    // work around firefox popup blocker
    popup_allowed_events = Options.getFirefoxPref('dom.popup_allowed_events', 'change click dblclick mouseup reset submit');
    if (!popup_allowed_events.match("keypress"))
        Options.setFirefoxPref('dom.popup_allowed_events', popup_allowed_events + " keypress");

    // we have our own typeahead find implementation
    Options.setFirefoxPref('accessibility.typeaheadfind.autostart', false);
    Options.setFirefoxPref('accessibility.typeaheadfind', false); // actually the above setting should do it, but has no effect in firefox

    // first time intro message
    if (Options.getPref("firsttime", true))
    {
        setTimeout(function() {
            help(null, null, null, { inTab: true });
            Options.setPref("firsttime", false);
        }, 1000); 
    }

    gURLBar.blur();
    vimperator.focusContent();

    // firefox preferences which we need to be changed to work well with vimperator
    Options.setFirefoxPref("browser.startup.page", 3); // start with saved session

    // Finally, read a ~/.vimperatorrc
    // Make sourcing asynchronous, otherwise commands that open new tabs won't work
    setTimeout(function() {
        source("~/.vimperatorrc", true);
        logMessage("~/.vimperatorrc sourced");
    }, 50);

    window.addEventListener("unload",   unload, false);
    logMessage("Vimperator fully initialized");
}

function unload()
{
    /*** save our preferences ***/
    vimperator.commandline.destroy();

    vimperator.events.destroy();

    // reset some modified firefox prefs
    if (Options.getFirefoxPref('dom.popup_allowed_events', 'change click dblclick mouseup reset submit')
            == popup_allowed_events + " keypress")
        Options.setFirefoxPref('dom.popup_allowed_events', popup_allowed_events);
}



function Vimperator() //{{{1
{
	////////////////////////////////////////////////////////////////////////////////
	////////////////////// PRIVATE SECTION /////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////////
    this.modes = { // actually not private, but Firefox complains if this doesn't come first
        // main modes
        NONE:             0,
        NORMAL:           1 << 0,
        INSERT:           1 << 1,
        VISUAL:           1 << 2,
        HINTS:            1 << 3,
        COMMAND_LINE:     1 << 4,
        // extended modes
        EX:               1 << 10,
        SEARCH_FORWARD:   1 << 11,
        SEARCH_BACKWARD:  1 << 12,
        ESCAPE_ONE_KEY:   1 << 13,
        ESCAPE_ALL_KEYS:  1 << 14,
        QUICK_HINT:       1 << 15,
        EXTENDED_HINT:    1 << 16,
        ALWAYS_HINT:      1 << 17
    }
    var mode_messages = {};
    mode_messages[this.modes.NORMAL]          = "";
    mode_messages[this.modes.INSERT]          = "INSERT";
    mode_messages[this.modes.VISUAL]          = "VISUAL";
    mode_messages[this.modes.HINTS]           = "HINTS";
    mode_messages[this.modes.ESCAPE_ONE_KEY]  = "escape one key";
    mode_messages[this.modes.ESCAPE_ALL_KEYS] = "escape all keys";
    mode_messages[this.modes.ESCAPE_ONE_KEY | this.modes.ESCAPE_ALL_KEYS] = "pass one key";
    mode_messages[this.modes.QUICK_HINT]      = "quick";
    mode_messages[this.modes.EXTENDED_HINT]   = "extended";
    mode_messages[this.modes.ALWAYS_HINT]     = "always";

	var callbacks = new Array();
    var mode = this.modes.NORMAL;
    var extended_mode = this.modes.NONE;
    var count = -1;
    var inputbuffer = "";

    function showMode()
    {
        if (!vimperator.options["showmode"])
            return;

        var str_mode = mode_messages[mode];
        var str_extended = mode_messages[extended_mode];
        if(!str_mode && !str_extended)
        {
            vimperator.echo("");
            return;
        }

        if(str_mode && str_extended)
            str_extended = " (" + str_extended + ")";
        else
        {
            str_extended = "(" + str_extended + ")";
            str_mode = "";
        }

        vimperator.echo("-- " + str_mode + str_extended + " --");
    }

	////////////////////////////////////////////////////////////////////////////////
	////////////////////// PUBLIC SECTION //////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////////
    this.ver  = "###VERSION### CVS (created: ###DATE###)";
    // DJK FIXME
    // this.commandline = new CommandLine();
//    this.search = new Search();

    /////////////// callbacks ////////////////////////////
	/**
     * @param type Can be:
     *  "submit": when the user pressed enter in the command line
     *  "change"
     *  "cancel"
     *  "complete"
     */
	this.registerCallback = function(type, mode, func)
	{
		// TODO: check if callback is already registered
		callbacks.push([type, mode, func]);
	}
	this.triggerCallback = function(type, data)
	{
		for (var i in callbacks)
		{
			var [thistype, thismode, thisfunc] = callbacks[i];
			if (vimperator.hasMode(thismode) && type == thistype)
				return thisfunc.call(this, data);
		}
		return false;
	}

    // just forward these echo commands
    // DJK FIXME: this.echo = this.commandline.echo;
    // DJK FIXME: this.echoerr = this.commandline.echoErr;


    this.getMode = function()
    {
        return [mode, extended_mode];
    }

    // set current mode
    // use "null" if you only want to set one of those modes
    this.setMode = function(main, extended, silent)
    {
        // if a main mode is set, the extended is always cleared
        if (main)
        {
            mode = main;
            extended_mode = this.modes.NONE;
        }
        if (typeof extended === "number")
            extended_mode = extended;

        if (!silent)
            showMode();
    }
    // returns true if "whichmode" is found in either the main or
    // extended mode
    this.hasMode = function(whichmode)
    {
        return ((mode & whichmode) || (extended_mode & whichmode) > 0) ? true : false;
    }
    this.addMode = function(main, extended)
    {
        if (main)
            mode |= main;
        if (extended)
            extended_mode |= extended;

        showMode();
    }
    // always show the new mode in the statusline
    this.removeMode = function(main, extended)
    {
        if (main)
            mode = (mode | main) ^ main;
        if (extended)
            extended_mode = (extended_mode | extended) ^ extended;

        showMode();
    }

    // After pressing Escape, put focus on a non-input field of the browser document
    this.focusContent = function()
    {
        var ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"].
                 getService(Components.interfaces.nsIWindowWatcher);

        if (window == ww.activeWindow && document.commandDispatcher.focusedElement)
            document.commandDispatcher.focusedElement.blur();

        content.focus();
    }


    this.getCurrentBuffer = function()
    {
        return document.commandDispatcher.focusedWindow;
    }
}

function Events() //{{{1
{
    ////////////////////////////////////////////////////////////////////////////////
    ////////////////////// CONSTRUCTOR /////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////

    // this handler is for middle click only in the content
    //window.addEventListener("mousedown", onVimperatorKeypress, true);
    //content.mPanelContainer.addEventListener("mousedown", onVimperatorKeypress, true);
    //document.getElementById("content").onclick = function(event) { alert("foo"); };

    // any tab related events
    var tabcontainer = getBrowser().tabContainer;
    tabcontainer.addEventListener("TabMove",   function(event) {
        vimperator.statusline.updateTabCount()
        updateBufferList();
    }, false);
    tabcontainer.addEventListener("TabOpen",   function(event) {
        vimperator.statusline.updateTabCount();
        updateBufferList();
        vimperator.setMode(); // trick to reshow the mode in the command line
    }, false);
    tabcontainer.addEventListener("TabClose",  function(event) {
        vimperator.statusline.updateTabCount()
        updateBufferList();
        vimperator.setMode(); // trick to reshow the mode in the command line
    }, false);
    tabcontainer.addEventListener("TabSelect", function(event) { 
        vimperator.statusline.updateTabCount();
        updateBufferList();
        vimperator.setMode(); // trick to reshow the mode in the command line
    }, false);

    // this adds an event which is is called on each page load, even if the
    // page is loaded in a background tab
    getBrowser().addEventListener("load", onPageLoad, true);

    // called when the window is scrolled.
    window.onscroll = function (event)
    {
        vimperator.statusline.updateBufferPosition();
        vimperator.setMode(); // trick to reshow the mode in the command line
    };

    window.document.addEventListener("DOMTitleChanged", function(event)
    {
        //alert("titlechanged");
    }, null);

    ////////////////////////////////////////////////////////////////////////////////
    ////////////////////// PRIVATE SECTION /////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////
    function onPageLoad(event)
    {
        if (event.originalTarget instanceof HTMLDocument)
        {
            var doc = event.originalTarget;
            // document is part of a frameset
            if (doc.defaultView.frameElement)
            {
                // hacky way to get rid of "Transfering data from ..." on sites with frames
                // when you click on a link inside a frameset, because asyncUpdateUI
                // is not triggered there (firefox bug?)
                setTimeout(vimperator.statusline.updateUrl, 10);
                return; 
            }

            // code which should happen for all (also background) newly loaded tabs goes here:
            updateBufferList();

            //update history
            var url = getCurrentLocation();
            var title = getCurrentTitle(); // not perfect "- Vimperator" in the title
            vimperator.history.add(url, title);

            // code which is only relevant if the page load is the current tab goes here:
            if(doc == getBrowser().selectedBrowser.contentDocument)
            {
                /* none yet */
                //vimperator.statusline.updateUrl();
                //logMessage("onpageLoad");
            }
        }
    }

    ////////////////////////////////////////////////////////////////////////////////
    ////////////////////// PUBLIC SECTION //////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////
    this.destroy = function()
    {
        // BIG TODO: removeEventListeners() to avoid mem leaks
        window.dump("TODO: remove eventlisteners");
    };

    this.onEscape = function()
    {
        if (!vimperator.hasMode(vimperator.modes.ESCAPE_ONE_KEY))
        {
            vimperator.setMode(vimperator.modes.NORMAL);
            vimperator.echo("");
            hah.disableHahMode();
            vimperator.focusContent();
            vimperator.statusline.updateUrl();
        }
    };

    this.onKeyPress = function(event)
    {
        if (event.type != "keypress")
            return false;

        // change the event to a usable string representation
        var key = keyToString(event);
         //alert(key);
        if (key == null)
             return false;
        // sometimes the non-content area has focus, making our keys not work
        //    if (event.target.id == "main-window")
        //        alert("focusContent();");


        // XXX: ugly hack for now pass certain keys to firefox as they are without beeping
        // also fixes key navigation in menus, etc.
        if (key == "<Tab>" || key == "<Return>" || key == "<Space>" || key == "<Up>" || key == "<Down>")
            return false;

        // XXX: for now only, later: input mappings if form element focused
        if (isFormElemFocused())
            return false;
        
        // handle Escape-one-key mode (Ctrl-v)
        if (vimperator.hasMode(vimperator.modes.ESCAPE_ONE_KEY) && !vimperator.hasMode(vimperator.modes.ESCAPE_ALL_KEYS))
        {
            vimperator.removeMode(null, vimperator.modes.ESCAPE_ONE_KEY);
            return false;
        }
        // handle Escape-all-keys mode (I)
        if (vimperator.hasMode(vimperator.modes.ESCAPE_ALL_KEYS))
        {
            if(vimperator.hasMode(vimperator.modes.ESCAPE_ONE_KEY))
                vimperator.removeMode(null, vimperator.modes.ESCAPE_ONE_KEY); // and then let flow continue
            else if (key == "<Esc>" || key == "<C-[>" || key == "<C-v>")
                ; // let flow continue to handle these keys
            else
                return false;
        }

    //  // FIXME: handle middle click in content area {{{
    //  //     alert(event.target.id);
    //  if (/*event.type == 'mousedown' && */event.button == 1 && event.target.id == 'content')
    //  {
    //      //echo("foo " + event.target.id);
    //      //if (document.commandDispatcher.focusedElement == command_line.inputField)
    //      {
    //      //alert(command_line.value.substring(0, command_line.selectionStart));
    //          command_line.value = command_line.value.substring(0, command_line.selectionStart) +
    //                               readFromClipboard() +
    //                               command_line.value.substring(command_line.selectionEnd, command_line.value.length);
    //         alert(command_line.value);
    //      }
    //      //else
    // //       {
    // //           openURLs(readFromClipboard());
    // //       }
    //      return true;
    //  } }}}



        // if Hit-a-hint mode is on, special handling of keys is required
        // g_hint_mappings is used
        // FIXME: total mess
        if (vimperator.hasMode(vimperator.modes.HINTS))
        {
            // never propagate this key to firefox, when hints are visible
            event.preventDefault();
            event.stopPropagation();

            for (i = 0; i < g_hint_mappings.length; i++)
            {
                if(g_hint_mappings[i][0] == key)
                {
                    if(g_hint_mappings[i][3] == true || hah.currentState() == 1)
                    {
                        //g_hint_mappings[i][1].call(this, event);
                        eval(g_hint_mappings[i][1]);
                        if (g_hint_mappings[i][2] == true) // stop processing this event
                        {
                            hah.disableHahMode();
                            vimperator.input.buffer = "";
                            vimperator.statusline.updateInputBuffer("");
                            return false;
                        }
                        else
                        {
                            // FIXME: make sure that YOU update the statusbar message yourself
                            // first in g_hint_mappings when in this mode!
                            vimperator.statusline.updateInputBuffer(vimperator.input.buffer);
                            return false;
                        }
                    }
                }
            }

            // no mapping found, beep()
            if (hah.currentState() == 1)
            {
                beep();
                hah.disableHahMode();
                vimperator.input.buffer = "";
                vimperator.statusline.updateInputBuffer(vimperator.input.buffer);
                return true;
            }

            // if we came here, let hit-a-hint process the key as it is part
            // of a partial link
            var res = hah.processEvent(event);
            if (res < 0) // error occured processing this key
            {
                beep();
                //if(hah.currentMode() == HINT_MODE_QUICK)
                if(vimperator.hasMode(vimperator.modes.QUICK_HINT))
                    hah.disableHahMode();
                else // ALWAYS mode
                    hah.resetHintedElements();
                vimperator.input.buffer = "";
            }
            //else if (res == 0 || hah.currentMode() == HINT_MODE_EXTENDED) // key processed, part of a larger hint
            else if (res == 0 || vimperator.hasMode(vimperator.modes.EXTENDED_HINT)) // key processed, part of a larger hint
                vimperator.input.buffer += key;
            else // this key completed a quick hint
            {
                // if the hint is all in UPPERCASE, open it in new tab
                vimperator.input.buffer += key;
                if (vimperator.input.buffer.toUpperCase() == vimperator.input.buffer)
                    hah.openHints(true, false);
                else // open in current window
                    hah.openHints(false, false);

                //if(hah.currentMode() == HINT_MODE_QUICK)
                if(vimperator.hasMode(vimperator.modes.QUICK_HINT))
                    hah.disableHahMode();
                else // ALWAYS mode
                    hah.resetHintedElements();

                vimperator.input.buffer = "";
            }

            vimperator.statusline.updateInputBuffer(vimperator.input.buffer);
            return true;
        }

        if (vimperator.hasMode(vimperator.modes.NORMAL))
        {
            var count_str = vimperator.input.buffer.match(/^[0-9]*/)[0];
            var candidate_command = (vimperator.input.buffer + key).replace(count_str, '');
            var map;

            // counts must be at the start of a complete mapping (10j -> go 10 lines down)
            if ((vimperator.input.buffer + key).match(/^[1-9][0-9]*$/))
            {
                vimperator.input.buffer += key;
                vimperator.statusline.updateInputBuffer(vimperator.input.buffer);
                return true;
            }

            if (vimperator.input.pendingMap)
            {
                if (key != "<Esc>" && key != "<C-[>")
                    vimperator.input.pendingMap.execute(null, vimperator.input.count, key);

                vimperator.input.pendingMap = null;
                vimperator.input.buffer = "";
                event.preventDefault();
                event.stopPropagation();
            }
            else if (map = vimperator.mappings.get(vimperator.modes.NORMAL, candidate_command))
            {
                vimperator.input.count = parseInt(count_str, 10);
                if (isNaN(vimperator.input.count))
                    vimperator.input.count = -1;
                if (map.flags & Mappings.flags.ARGUMENT)
                {
                    vimperator.input.pendingMap = map;
                    vimperator.input.buffer += key;
                }
                else
                {
                    map.execute(null, vimperator.input.count);
                    vimperator.input.buffer = "";
                }

                event.preventDefault();
                event.stopPropagation();
            }
            else if (vimperator.mappings.getCandidates(vimperator.modes.NORMAL, candidate_command).length > 0)
            {
                vimperator.input.buffer += key;
                event.preventDefault();
                event.stopPropagation();
            }
            else
            {
                vimperator.input.buffer = "";
                vimperator.input.pendingMap = null;
                beep();
            }
        }
        vimperator.statusline.updateInputBuffer(vimperator.input.buffer);
        return false;
    };
    window.addEventListener("keypress", this.onKeyPress, true);


    this.progressListener =
    {
        QueryInterface: function(aIID)
        {
            if (aIID.equals(Components.interfaces.nsIWebProgressListener) ||
                    aIID.equals(Components.interfaces.nsIXULBrowserWindow) || // for setOverLink();
                    aIID.equals(Components.interfaces.nsISupportsWeakReference) ||
                    aIID.equals(Components.interfaces.nsISupports))
                return this;
            throw Components.results.NS_NOINTERFACE;
        },

        // XXX: function may later be needed to detect a canceled synchronous openURL()
        onStateChange: function(webProgress, aRequest, flags, aStatus)
        {
            // STATE_IS_DOCUMENT | STATE_IS_WINDOW is important, because we also
            // receive statechange events for loading images and other parts of the web page
            if(flags & (Components.interfaces.nsIWebProgressListener.STATE_IS_DOCUMENT |
                        Components.interfaces.nsIWebProgressListener.STATE_IS_WINDOW))
            {
                // This fires when the load event is initiated
                if(flags & Components.interfaces.nsIWebProgressListener.STATE_START)
                {
                    vimperator.statusline.updateProgress(0);
                }
                else if (flags & Components.interfaces.nsIWebProgressListener.STATE_STOP)
                    logMessage("stop");// vimperator.statusline.updateUrl();
            }
        },
        // for notifying the user about secure web pages
        onSecurityChange: function (webProgress, aRequest, aState)
        {
            const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
            if(aState & nsIWebProgressListener.STATE_IS_INSECURE)
                vimperator.statusline.setClass("insecure");
            else if(aState & nsIWebProgressListener.STATE_IS_BROKEN)
                vimperator.statusline.setClass("broken");
            else if(aState & nsIWebProgressListener.STATE_IS_SECURE)
                vimperator.statusline.setClass("secure");
        },
        onStatusChange: function(webProgress, request, status, message)
        {
            //logMessage("status: " + message);
            vimperator.statusline.updateUrl(message);
        },
        onProgressChange: function(webProgress, request, curSelfProgress, maxSelfProgress, curTotalProgress, maxTotalProgress)
        {
            vimperator.statusline.updateProgress(curTotalProgress/maxTotalProgress);
        },
        // happens when the users switches tabs
        onLocationChange: function()
        {
            // if (vimperator.hasMode(vimperator.modes.HINTS) && !vimperator.hasMode(vimperator.modes.ALWAYS_HINT))
            //     hah.disableHahMode();

            vimperator.statusline.updateUrl();
            vimperator.statusline.updateProgress();

            // if this is not delayed we get the wrong position of the old buffer
            setTimeout(function() { vimperator.statusline.updateBufferPosition(); }, 100); 
        },
        // called at the very end of a page load
        asyncUpdateUI: function()
        {  
            //logMessage("async");
            setTimeout(vimperator.statusline.updateUrl, 100);
        },
        setOverLink : function(link, b)
        {
            var ssli = vimperator.options["showstatuslinks"];
            if (link && ssli)
            {
                if (ssli == 1)
                    vimperator.statusline.updateUrl("Link: " + link);
                else if (ssli == 2)
                    vimperator.echo("Link: " + link);
            }
                
            if (link == "")
            {
                if (ssli == 1)
                    vimperator.statusline.updateUrl();
                else if (ssli == 2)
                    vimperator.setMode(); // trick to reshow the mode in the command line
            }
        },

        // stub functions for the interfaces
        setJSStatus : function(status) { },
        setJSDefaultStatus : function(status) { },
        setDefaultStatus : function(status) { },
        onLinkIconAvailable: function() { }
    };
    window.XULBrowserWindow = this.progressListener;
    window.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
        .getInterface(Components.interfaces.nsIWebNavigation)
        .QueryInterface(Components.interfaces.nsIDocShellTreeItem).treeOwner
        .QueryInterface(Components.interfaces.nsIInterfaceRequestor)
        .getInterface(Components.interfaces.nsIXULWindow)
        .XULBrowserWindow = window.XULBrowserWindow;
    getBrowser().addProgressListener(this.progressListener, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
    
}


/** provides functions for working with tabs
 * XXX: ATTENTION: We are planning to move to the FUEL API once we switch to
 * Firefox 3.0, then this class should go away and their tab methods should be used
 * @deprecated
 */
function Tabs() //{{{1
{
    ////////////////////////////////////////////////////////////////////////////////
    ////////////////////// PRIVATE SECTION /////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////
    /** @param spec can either be:
     * - an absolute integer
     * - "" for the current tab
     * - "+1" for the next tab
     * - "-3" for the tab, which is 3 positions left of the current
     * - "$" for the last tab
     */
    function indexFromSpec(spec, wrap)
    {
        var position = getBrowser().tabContainer.selectedIndex;
        var length   = getBrowser().mTabs.length;
        var last     = length - 1;

        if (spec === undefined || spec === "")
            return position;

        if (typeof spec === "number")
            position = spec;
        else if (spec === "$")
            return last;
        else if (!spec.match(/^([+-]?\d+|)$/))
        {
            // TODO: move error reporting to ex-command?
            vimperator.echoerr("E488: Trailing characters");
            return false;
        }
        else
        {
            if (spec.match(/^([+-]\d+)$/)) // relative position +/-N
                position += parseInt(spec);
            else                           // absolute position
                position = parseInt(spec);
        }

        if (position > last)
            position = wrap ? position % length : last;
        else if (position < 0)
            position = wrap ? (position % length) + length: 0;

        return position;
    }

    ////////////////////////////////////////////////////////////////////////////////
    ////////////////////// PUBLIC SECTION //////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////
    // @returns the index of the currently selected tab starting with 0
    this.index = function(tab)
    {
        if(tab)
        {
            var length = getBrowser().mTabs.length;
            for (var i = 0; i < length; i++)
            {
                if (getBrowser().mTabs[i] == tab)
                    return i;
            }
            return false;
        }

        return getBrowser().tabContainer.selectedIndex;
    }
    this.count = function()
    {
        return getBrowser().mTabs.length;
    }

    // TODO: implement filter
    // @returns an array of tabs which match filter
    this.get = function(filter)
    {
        var buffers = [];
        var browsers = getBrowser().browsers;
        for (var i in browsers)
        {
            var title = browsers[i].contentTitle || "(Untitled)";
            var uri = browsers[i].currentURI.spec;
            var number = i + 1;
            buffers.push([number, title, uri]);
        }
        return buffers;
    }

    this.getTab = function(index)
    {
        if (index)
            return getBrowser().mTabs[index];

        return getBrowser().tabContainer.selectedItem;
    }

    /*  spec == "" moves the tab to the last position as per Vim
     *  wrap causes the movement to wrap around the start and end of the tab list
     *  NOTE: position is a 0 based index
     *  FIXME: tabmove! N should probably produce an error
     */
    this.move = function(tab, spec, wrap)
    {
        if (spec === "")
            spec = "$"; // if not specified, move to the last tab -> XXX: move to ex handling?

        var index = indexFromSpec(spec, false); // XXX: really no wrap?
        getBrowser().moveTabTo(tab, index);
    }

    /* quit_on_last_tab = 1: quit without saving session
     * quit_on_last_tab = 2: quit and save session
     */
    this.remove = function(tab, count, focus_left_tab, quit_on_last_tab)
    {
        if (count < 1) count = 1;

        if (quit_on_last_tab >= 1 && getBrowser().mTabs.length <= count)
            quit(quit_on_last_tab == 2);

        if(focus_left_tab && tab.previousSibling)
            this.select("-1", false);

        getBrowser().removeTab(tab);
    }

    this.keepOnly = function(tab)
    {
        getBrowser().removeAllTabsBut(tab);
    }

    this.select = function(spec, wrap)
    {
        var index = indexFromSpec(spec, wrap);
        if (index === false)
        {
            beep(); // XXX: move to ex-handling?
            return false;
        }
        getBrowser().mTabContainer.selectedIndex = index;
    }

    /* XXX: disabled until we find a better way where to update the titles, right now
     * it has O(n^2) complexity on firefox start when we load 50 tabs
     * (c) by hrist
     
         window.addEventListener("TabMove",    function() { vimperator.statusline.updateTabCount(); vimperator.tabs.updateTitles(); }, false);
         window.addEventListener("TabOpen",    function() { vimperator.statusline.updateTabCount(); vimperator.tabs.updateTitles(); }, false);
         window.addEventListener("TabClose",   function() { vimperator.statusline.updateTabCount(); vimperator.tabs.updateTitles(); }, false);

    this.updateTitles = function(forceclear)
    {    
        for(var i=0;i < vimperator.tabs.count();i++)
        {    
            var old_title = getBrowser().mTabContainer.childNodes[i].getAttribute("label");
            var split_title = old_title.match(/^(\d+:\s+)(.*)/);
            if(forceclear)
            {    
                for(var i=0;i<vimperator.tabs.count();i++)
                getBrowser().mTabContainer.childNodes[i].setAttribute("label", split_title[2]);
                return;
            }    

            var numbertabs = vimperator.options["numbertabs"];
            if(numbertabs)
            {    
                if(split_title)
                {    
                    var new_title = (i+1) + ": "+ split_title[2];
                }    
                else  var new_title = (i+1) + ": " + old_title;
                getBrowser().mTabContainer.childNodes[i].setAttribute("label", new_title);
            }    
            else getBrowser().mTabContainer.childNodes[i].setAttribute("label", split_title[2]);
        }    
    }
    */
}




////////////////////////////////////////////////////////////////////////
// text input functions /////////////////////////////////////////// {{{1
////////////////////////////////////////////////////////////////////////
//TODO: convert all these functions to methods
function isFormElemFocused()
{
    var elt = document.commandDispatcher.focusedElement;
    if (elt == null)
        return false;

    var tagname = elt.localName.toLowerCase();
    var type = elt.type.toLowerCase();

    if ( (tagname == "input" && (type != "image")) ||
          tagname == "textarea" ||
//            tagName == "SELECT" ||
//            tagName == "BUTTON" ||
          tagname == "isindex") // isindex is a deprecated one-line input box
        return true;

    return false;
}


////////////////////////////////////////////////////////////////////////
// logging //////////////////////////////////////////////////////// {{{1
////////////////////////////////////////////////////////////////////////

var gConsoleService = Components.classes['@mozilla.org/consoleservice;1']
                    .getService(Components.interfaces.nsIConsoleService);

/**
 * logs any object to the javascript error console
 * also prints all properties of thie object
 */
function logMessage(msg)
{
    gConsoleService.logStringMessage('vimperator: ' + msg);
}

/**
 * logs any object to the javascript error console
 * also prints all properties of thie object
 */
function logObject(object)
{
    if (typeof object != 'object')
        return;

    var string = object + '::\n';
    for (var i in object)
    {
        var value;
        try {
            var value = object[i];
        } catch (e) { value = '' }

        string += i + ': ' + value + '\n';
    }
    logMessage(string);
}


////////////////////////////////////////////////////////////////////////
// misc helper functions ////////////////////////////////////////// {{{1
////////////////////////////////////////////////////////////////////////
// this function gets an event as the input and converts it to 
// a keycode which can be used in mappings
// e.g. pressing ctrl+n would result in the string "<C-n>"
// null if unknown key
function keyToString(event)
{
    var key = String.fromCharCode(event.charCode);
    var modifier = "";
    if (event.ctrlKey)
        modifier += "C-";
    if (event.altKey)
        modifier += "A-";
    if (event.metaKey)
        modifier += "M-";

    if (event.charCode == 0)
    {
        if (event.shiftKey)
            modifier += "S-";
        if (event.keyCode == KeyEvent.DOM_VK_ESCAPE)
            key = "Esc";
        else if (event.keyCode == KeyEvent.DOM_VK_RETURN)
            key = "Return";
        else if (event.keyCode == KeyEvent.DOM_VK_TAB)
            key = "Tab";
        else if (event.keyCode == KeyEvent.DOM_VK_DELETE)
            key = "Del";
        else if (event.keyCode == KeyEvent.DOM_VK_BACK_SPACE)
            key = "BS";
        else if (event.keyCode == KeyEvent.DOM_VK_HOME)
            key = "Home";
        else if (event.keyCode == KeyEvent.DOM_VK_END)
            key = "End";
        else if (event.keyCode == KeyEvent.DOM_VK_LEFT)
            key = "Left";
        else if (event.keyCode == KeyEvent.DOM_VK_RIGHT)
            key = "Right";
        else if (event.keyCode == KeyEvent.DOM_VK_UP)
            key = "Up";
        else if (event.keyCode == KeyEvent.DOM_VK_DOWN)
            key = "Down";
        else if (event.keyCode == KeyEvent.DOM_VK_PAGE_UP)
            key = "PageUp";
        else if (event.keyCode == KeyEvent.DOM_VK_PAGE_DOWN)
            key = "PageDown";
        else if (event.keyCode == KeyEvent.DOM_VK_F1)
            key = "F1";
        else if (event.keyCode == KeyEvent.DOM_VK_F2)
            key = "F2";
        else if (event.keyCode == KeyEvent.DOM_VK_F3)
            key = "F3";
        else if (event.keyCode == KeyEvent.DOM_VK_F4)
            key = "F4";
        else if (event.keyCode == KeyEvent.DOM_VK_F5)
            key = "F5";
        else if (event.keyCode == KeyEvent.DOM_VK_F6)
            key = "F6";
        else if (event.keyCode == KeyEvent.DOM_VK_F7)
            key = "F7";
        else if (event.keyCode == KeyEvent.DOM_VK_F8)
            key = "F8";
        else if (event.keyCode == KeyEvent.DOM_VK_F9)
            key = "F9";
        else if (event.keyCode == KeyEvent.DOM_VK_F10)
            key = "F10";
        else if (event.keyCode == KeyEvent.DOM_VK_F11)
            key = "F11";
        else if (event.keyCode == KeyEvent.DOM_VK_F12)
            key = "F12";
        else
            return null;
    }

    // special handling of the Space key
    if (event.charCode == 32)
    {
        if (event.shiftKey)
            modifier += "S-";
        key = "Space";
    }

    // a normal key like a, b, c, 0, etc.
    if (event.charCode > 0)
    {
        if (modifier.length > 0 || event.charCode == 32)
            return "<" + modifier + key + ">";
        else
            return key;
    }
    else // a key like F1 is always enclosed in < and >
        return "<" + modifier + key + ">";
}

////////////////////////////////////////////////////////////////////////
// DOM related helper functsion /////////////////////////////////// {{{1
////////////////////////////////////////////////////////////////////////
// Handle frames if they're present
function getPageLinkNodes()
{
    var frames = window._content.frames;

    // The main content may have link nodes as well as it's frames.
    var nodes = getLinkNodes(_content.content.document);
    var tmp;
    for (var i=0; i<frames.length; i++) {
    tmp = getLinkNodes(frames[i].document);
    // is javascript this crappy?
    for (var j=0; j<tmp.length; j++)
        nodes.push(tmp[j]);
    }
    return nodes;
}

// For a single document, grab all the nodes
function getLinkNodes(doc)
{
    var a_nodes = doc.getElementsByTagName('a');
    var i_nodes = doc.getElementsByTagName('input');
    var s_nodes = doc.getElementsByTagName('select');
    var t_nodes = doc.getElementsByTagName('textarea');

    var links = [];

    for (var i=0; i<t_nodes.length; i++) {
    links.push(t_nodes[i]);
    }
    for (var i=0; i<s_nodes.length; i++) {
    links.push(s_nodes[i]);
    }
    for (var i=0; i<i_nodes.length; i++) {
    if (i_nodes[i].type == "hidden") continue;
    links.push(i_nodes[i]);
    }
    for (var i=0; i<a_nodes.length; i++) {
    if (!a_nodes[i].hasAttribute('href')) continue;
    links.push(a_nodes[i]);
    }

    return links;
}//}}}


// vim: set fdm=marker sw=4 ts=4 et: