/lenasys/trunk

/* ***** BEGIN LICENSE BLOCK *****

 * Distributed under the BSD license:

 *

 * Copyright (c) 2010, Ajax.org B.V.

 * All rights reserved.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above copyright

 *       notice, this list of conditions and the following disclaimer in the

 *       documentation and/or other materials provided with the distribution.

 *     * Neither the name of Ajax.org B.V. nor the

 *       names of its contributors may be used to endorse or promote products

 *       derived from this software without specific prior written permission.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * ***** END LICENSE BLOCK ***** */

define('ace/keyboard/vim', ['require', 'exports', 'module' , 'ace/keyboard/vim/commands', 'ace/keyboard/vim/maps/util', 'ace/lib/useragent'], function(require, exports, module) {

var cmds = require("./vim/commands");

var coreCommands = cmds.coreCommands;

var util = require("./vim/maps/util");

var useragent = require("../lib/useragent");

var startCommands = {

    "i": {

        command: coreCommands.start

    },

    "I": {

        command: coreCommands.startBeginning

    },

    "a": {

        command: coreCommands.append

    },

    "A": {

        command: coreCommands.appendEnd

    },

    "ctrl-f": {

        command: "gotopagedown"

    },

    "ctrl-b": {

        command: "gotopageup"

    }

};

exports.handler = {

    handleMacRepeat: function(data, hashId, key) {

        if (hashId == -1) {

            data.inputChar = key;

            data.lastEvent = "input";

        } else if (data.inputChar && data.$lastHash == hashId && data.$lastKey == key) {

            if (data.lastEvent == "input") {

                data.lastEvent = "input1";

            } else if (data.lastEvent == "input1") {

                return true;

            }

        } else {

            data.$lastHash = hashId;

            data.$lastKey = key;

            data.lastEvent = "keypress";

        }

    },

    handleKeyboard: function(data, hashId, key, keyCode, e) {

        if (hashId != 0 && (key == "" || key == "\x00"))

            return null;

        if (hashId == 1)

            key = "ctrl-" + key;

        if ((key == "esc" && hashId == 0) || key == "ctrl-[") {

            return {command: coreCommands.stop};

        } else if (data.state == "start") {

            if (useragent.isMac && this.handleMacRepeat(data, hashId, key)) {

                hashId = -1;

                key = data.inputChar;

            }

            if (hashId == -1 || hashId == 1 || hashId == 0 && key.length > 1) {

                if (cmds.inputBuffer.idle && startCommands[key])

                    return startCommands[key];

                return {

                    command: {

                        exec: function(editor) { 

                            return cmds.inputBuffer.push(editor, key);

                        }

                    }

                };

            } // if no modifier || shift: wait for input.

            else if (key.length == 1 && (hashId == 0 || hashId == 4)) {

                return {command: "null", passEvent: true};

            } else if (key == "esc" && hashId == 0) {

                return {command: coreCommands.stop};

            }

        } else {

            if (key == "ctrl-w") {

                return {command: "removewordleft"};

            }

        }

    },

    attach: function(editor) {

        editor.on("click", exports.onCursorMove);

        if (util.currentMode !== "insert")

            cmds.coreCommands.stop.exec(editor);

        editor.$vimModeHandler = this;

    },

    detach: function(editor) {

        editor.removeListener("click", exports.onCursorMove);

        util.noMode(editor);

        util.currentMode = "normal";

    },

    actions: cmds.actions,

    getStatusText: function() {

        if (util.currentMode == "insert")

            return "INSERT";

        if (util.onVisualMode)

            return (util.onVisualLineMode ? "VISUAL LINE " : "VISUAL ") + cmds.inputBuffer.status;

        return cmds.inputBuffer.status;

    }

};

exports.onCursorMove = function(e) {

    cmds.onCursorMove(e.editor, e);

    exports.onCursorMove.scheduled = false;

};

});

define('ace/keyboard/vim/commands', ['require', 'exports', 'module' , 'ace/keyboard/vim/maps/util', 'ace/keyboard/vim/maps/motions', 'ace/keyboard/vim/maps/operators', 'ace/keyboard/vim/maps/aliases', 'ace/keyboard/vim/registers'], function(require, exports, module) {

"never use strict";

var util = require("./maps/util");

var motions = require("./maps/motions");

var operators = require("./maps/operators");

var alias = require("./maps/aliases");

var registers = require("./registers");

var NUMBER = 1;

var OPERATOR = 2;

var MOTION = 3;

var ACTION = 4;

var HMARGIN = 8; // Minimum amount of line separation between margins;

var repeat = function repeat(fn, count, args) {

    while (0 < count--)

        fn.apply(this, args);

};

var ensureScrollMargin = function(editor) {

    var renderer = editor.renderer;

    var pos = renderer.$cursorLayer.getPixelPosition();

    var top = pos.top;

    var margin = HMARGIN * renderer.layerConfig.lineHeight;

    if (2 * margin > renderer.$size.scrollerHeight)

        margin = renderer.$size.scrollerHeight / 2;

    if (renderer.scrollTop > top - margin) {

        renderer.session.setScrollTop(top - margin);

    }

    if (renderer.scrollTop + renderer.$size.scrollerHeight < top + margin + renderer.lineHeight) {

        renderer.session.setScrollTop(top + margin + renderer.lineHeight - renderer.$size.scrollerHeight);

    }

};

var actions = exports.actions = {

    "z": {

        param: true,

        fn: function(editor, range, count, param) {

            switch (param) {

                case "z":

                    editor.renderer.alignCursor(null, 0.5);

                    break;

                case "t":

                    editor.renderer.alignCursor(null, 0);

                    break;

                case "b":

                    editor.renderer.alignCursor(null, 1);

                    break;

            }

        }

    },

    "r": {

        param: true,

        fn: function(editor, range, count, param) {

            if (param && param.length) {

                repeat(function() { editor.insert(param); }, count || 1);

                editor.navigateLeft();

            }

        }

    },

    "R": {

        fn: function(editor, range, count, param) {

            util.insertMode(editor);

            editor.setOverwrite(true);

        }

    },

    "~": {

        fn: function(editor, range, count) {

            repeat(function() {

                var range = editor.selection.getRange();

                if (range.isEmpty())

                    range.end.column++;

                var text = editor.session.getTextRange(range);

                var toggled = text.toUpperCase();

                if (toggled == text)

                    editor.navigateRight();

                else

                    editor.session.replace(range, toggled);

            }, count || 1);

        }

    },

    "*": {

        fn: function(editor, range, count, param) {

            editor.selection.selectWord();

            editor.findNext();

            ensureScrollMargin(editor);

            var r = editor.selection.getRange();

            editor.selection.setSelectionRange(r, true);

        }

    },

    "#": {

        fn: function(editor, range, count, param) {

            editor.selection.selectWord();

            editor.findPrevious();

            ensureScrollMargin(editor);

            var r = editor.selection.getRange();

            editor.selection.setSelectionRange(r, true);

        }

    },

    "m": {

        param: true,

        fn: function(editor, range, count, param) {

            var s =  editor.session;

            var markers = s.vimMarkers || (s.vimMarkers = {});

            var c = editor.getCursorPosition();

            if (!markers[param]) {

                markers[param] = editor.session.doc.createAnchor(c);

            }

            markers[param].setPosition(c.row, c.column, true);

        }

    },

    "n": {

        fn: function(editor, range, count, param) {

            var options = editor.getLastSearchOptions();

            options.backwards = false;

            editor.selection.moveCursorRight();

            editor.selection.clearSelection();

            editor.findNext(options);

            ensureScrollMargin(editor);

            var r = editor.selection.getRange();

            r.end.row = r.start.row;

            r.end.column = r.start.column;

            editor.selection.setSelectionRange(r, true);

        }

    },

    "N": {

        fn: function(editor, range, count, param) {

            var options = editor.getLastSearchOptions();

            options.backwards = true;

            editor.findPrevious(options);

            ensureScrollMargin(editor);

            var r = editor.selection.getRange();

            r.end.row = r.start.row;

            r.end.column = r.start.column;

            editor.selection.setSelectionRange(r, true);

        }

    },

    "v": {

        fn: function(editor, range, count, param) {

            editor.selection.selectRight();

            util.visualMode(editor, false);

        },

        acceptsMotion: true

    },

    "V": {

        fn: function(editor, range, count, param) {

            var row = editor.getCursorPosition().row;

            editor.selection.clearSelection();

            editor.selection.moveCursorTo(row, 0);

            editor.selection.selectLineEnd();

            editor.selection.visualLineStart = row;

            util.visualMode(editor, true);

        },

        acceptsMotion: true

    },

    "Y": {

        fn: function(editor, range, count, param) {

            util.copyLine(editor);

        }

    },

    "p": {

        fn: function(editor, range, count, param) {

            var defaultReg = registers._default;

            editor.setOverwrite(false);

            if (defaultReg.isLine) {

                var pos = editor.getCursorPosition();

                var lines = defaultReg.text.split("\n");

                editor.session.getDocument().insertLines(pos.row + 1, lines);

                editor.moveCursorTo(pos.row + 1, 0);

            }

            else {

                editor.navigateRight();

                editor.insert(defaultReg.text);

                editor.navigateLeft();

            }

            editor.setOverwrite(true);

            editor.selection.clearSelection();

        }

    },

    "P": {

        fn: function(editor, range, count, param) {

            var defaultReg = registers._default;

            editor.setOverwrite(false);

            if (defaultReg.isLine) {

                var pos = editor.getCursorPosition();

                var lines = defaultReg.text.split("\n");

                editor.session.getDocument().insertLines(pos.row, lines);

                editor.moveCursorTo(pos.row, 0);

            }

            else {

                editor.insert(defaultReg.text);

            }

            editor.setOverwrite(true);

            editor.selection.clearSelection();

        }

    },

    "J": {

        fn: function(editor, range, count, param) {

            var session = editor.session;

            range = editor.getSelectionRange();

            var pos = {row: range.start.row, column: range.start.column};

            count = count || range.end.row - range.start.row;

            var maxRow = Math.min(pos.row + (count || 1), session.getLength() - 1);

            range.start.column = session.getLine(pos.row).length;

            range.end.column = session.getLine(maxRow).length;

            range.end.row = maxRow;

            var text = "";

            for (var i = pos.row; i < maxRow; i++) {

                var nextLine = session.getLine(i + 1);

                text += " " + /^\s*(.*)$/.exec(nextLine)[1] || "";

            }

            session.replace(range, text);

            editor.moveCursorTo(pos.row, pos.column);

        }

    },

    "u": {

        fn: function(editor, range, count, param) {

            count = parseInt(count || 1, 10);

            for (var i = 0; i < count; i++) {

                editor.undo();

            }

            editor.selection.clearSelection();

        }

    },

    "ctrl-r": {

        fn: function(editor, range, count, param) {

            count = parseInt(count || 1, 10);

            for (var i = 0; i < count; i++) {

                editor.redo();

            }

            editor.selection.clearSelection();

        }

    },

    ":": {

        fn: function(editor, range, count, param) {

        }

    },

    "/": {

        fn: function(editor, range, count, param) {

        }

    },

    "?": {

        fn: function(editor, range, count, param) {

        }

    },

    ".": {

        fn: function(editor, range, count, param) {

            util.onInsertReplaySequence = inputBuffer.lastInsertCommands;

            var previous = inputBuffer.previous;

            if (previous) // If there is a previous action

                inputBuffer.exec(editor, previous.action, previous.param);

        }

    },

    "ctrl-x": {

        fn: function(editor, range, count, param) {

            editor.modifyNumber(-(count || 1));

        }

    },

    "ctrl-a": {

        fn: function(editor, range, count, param) {

            editor.modifyNumber(count || 1);

        }

    }

};

var inputBuffer = exports.inputBuffer = {

    accepting: [NUMBER, OPERATOR, MOTION, ACTION],

    currentCmd: null,

    currentCount: "",

    status: "",

    operator: null,

    motion: null,

    lastInsertCommands: [],

    push: function(editor, ch, keyId) {

        var isKeyHandled = true;

        this.idle = false;

        var wObj = this.waitingForParam;

        if (wObj) {

            this.exec(editor, wObj, ch);

        }

        else if (!(ch === "0" && !this.currentCount.length) &&

            (ch.match(/^\d+$/) && this.isAccepting(NUMBER))) {

            this.currentCount += ch;

            this.currentCmd = NUMBER;

            this.accepting = [NUMBER, OPERATOR, MOTION, ACTION];

        }

        else if (!this.operator && this.isAccepting(OPERATOR) && operators[ch]) {

            this.operator = {

                ch: ch,

                count: this.getCount()

            };

            this.currentCmd = OPERATOR;

            this.accepting = [NUMBER, MOTION, ACTION];

            this.exec(editor, { operator: this.operator });

        }

        else if (motions[ch] && this.isAccepting(MOTION)) {

            this.currentCmd = MOTION;

            var ctx = {

                operator: this.operator,

                motion: {

                    ch: ch,

                    count: this.getCount()

                }

            };

            if (motions[ch].param)

                this.waitForParam(ctx);

            else

                this.exec(editor, ctx);

        }

        else if (alias[ch] && this.isAccepting(MOTION)) {

            alias[ch].operator.count = this.getCount();

            this.exec(editor, alias[ch]);

        }

        else if (actions[ch] && this.isAccepting(ACTION)) {

            var actionObj = {

                action: {

                    fn: actions[ch].fn,

                    count: this.getCount()

                }

            };

            if (actions[ch].param) {

                this.waitForParam(actionObj);

            }

            else {

                this.exec(editor, actionObj);

            }

            if (actions[ch].acceptsMotion)

                this.idle = false;

        }

        else if (this.operator) {

            this.exec(editor, { operator: this.operator }, ch);

        }

        else {

            isKeyHandled = ch.length == 1;

            this.reset();

        }

        if (this.waitingForParam || this.motion || this.operator) {

            this.status += ch;

        } else if (this.currentCount) {

            this.status = this.currentCount;

        } else if (this.status) {

            this.status = "";

        } else {

            return isKeyHandled;

        }

        editor._emit("changeStatus");

        return isKeyHandled;

    },

    waitForParam: function(cmd) {

        this.waitingForParam = cmd;

    },

    getCount: function() {

        var count = this.currentCount;

        this.currentCount = "";

        return count && parseInt(count, 10);

    },

    exec: function(editor, action, param) {

        var m = action.motion;

        var o = action.operator;

        var a = action.action;

        if (!param)

            param = action.param;

        if (o) {

            this.previous = {

                action: action,

                param: param

            };

        }

        if (o && !editor.selection.isEmpty()) {

            if (operators[o.ch].selFn) {

                operators[o.ch].selFn(editor, editor.getSelectionRange(), o.count, param);

                this.reset();

            }

            return;

        }

        else if (!m && !a && o && param) {

            operators[o.ch].fn(editor, null, o.count, param);

            this.reset();

        }

        else if (m) {

            var run = function(fn) {

                if (fn && typeof fn === "function") { // There should always be a motion

                    if (m.count && !motionObj.handlesCount)

                        repeat(fn, m.count, [editor, null, m.count, param]);

                    else

                        fn(editor, null, m.count, param);

                }

            };

            var motionObj = motions[m.ch];

            var selectable = motionObj.sel;

            if (!o) {