gollum 3.1.2 → 3.1.3

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/keyboard/keybinding_test.js

@@ -0,0 +1,69 @@
+/* ***** 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 ***** */
+
+if (typeof process !== "undefined") {
+    require("amd-loader");
+}
+
+define(function(require, exports, module) {
+"use strict";
+
+var EditSession = require("./../edit_session").EditSession,
+    Editor = require("./../editor").Editor,
+    MockRenderer = require("./../test/mockrenderer").MockRenderer,
+    assert = require("./../test/assertions"),
+    HashHandler = require('./hash_handler').HashHandler,
+    keys = require('../lib/keys'),
+    editor;
+
+function initEditor(docString) {
+    var doc = new EditSession(docString.split("\n"));
+    editor = new Editor(new MockRenderer(), doc);
+}
+
+module.exports = {
+
+    "test: adding a new keyboard handler does not remove the default handler": function() {
+        initEditor('abc');
+        var handler = new HashHandler({'del': 'f1'});
+        editor.keyBinding.setKeyboardHandler(handler);
+        editor.onCommandKey({}, 0, keys['f1']);
+        assert.equal('bc', editor.getValue(), "binding of new handler");
+        editor.onCommandKey({}, 0, keys['delete']);
+        assert.equal('c', editor.getValue(), "bindings of the old handler should still work");
+    }
+
+};
+
+});
+
+if (typeof module !== "undefined" && module === require.main) {
+    require("asyncjs").test.testcase(module.exports).exec()
+}

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/keyboard/state_handler.js

@@ -223,8 +223,7 @@ StateHandler.prototype = {
  * This is a useful matching function and therefore is defined here so that
  * users of KeyboardStateMapper can use it.
  *
- * @return boolean
- *          If no command key (Command|Option|Shift|Ctrl) is pressed, it
+ * @return {Boolean} If no command key (Command|Option|Shift|Ctrl) is pressed, it
  *          returns true. If the only the Shift key is pressed + a character
  *          true is returned as well. Otherwise, false is returned.
  *          Summing up, the function returns true whenever the user typed

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/keyboard/textarea.js

@@ -0,0 +1,82 @@
+/* ***** 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(function(require, exports, module) {
+"use strict";
+
+var HashHandler = require("./hash_handler").HashHandler;
+exports.handler = new HashHandler();
+
+[{
+    bindKey: "Shift-Tab|Tab",
+    command: "passKeysToBrowser"
+}, {
+    bindKey: {win: "Ctrl-L", mac: "Cmd-L"},
+    command: "passKeysToBrowser"
+}, {
+    bindKey: {win: "Ctrl-G", mac: "Cmd-G"},
+    command: "gotoline"
+}, {
+    bindKey: {win: "Ctrl-T|Ctrl-Shift-T", mac: "Cmd-T|Cmd-Shift-T"},
+    command: "passKeysToBrowser"
+}, {
+    bindKey: {win: "Ctrl-G", mac: "Cmd-G"},
+    command: "passKeysToBrowser"
+}, {
+    bindKey: {win: "Ctrl-G", mac: "Cmd-G"},
+    command: "passKeysToBrowser"
+}, {
+    name: "golineup",
+    bindKey: {win: null, mac: "Ctrl-P"},
+}, {
+    name: "golinedown",
+    bindKey: {win: null, mac: "Ctrl-N"},
+}, {
+    name: "gotoleft",    
+    bindKey: {win: null, mac: "Ctrl-B"},
+}, {
+    name: "gotoright",
+    bindKey: {win: null, mac: "Ctrl-F"},
+}, {
+    name: "gotolineend",
+    bindKey: {win: null, mac: "Ctrl-E"},
+}, {
+    name: "gotolinestart",
+    bindKey: {win: null, mac: "Ctrl-A"},
+}
+].forEach(function(k) {
+    var bindKey = k.bindKey;
+    if (typeof bindKey == "object")
+        bindKey = bindKey[exports.handler.platform];
+    exports.handler.bindKey(bindKey, k.command);
+});
+exports.handler.$id = "ace/keyboard/textarea";
+
+});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/keyboard/textinput.js

@@ -3,7 +3,7 @@
  *
  * 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
@@ -14,7 +14,7 @@
  *     * 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
@@ -34,189 +34,253 @@ define(function(require, exports, module) {
 var event = require("../lib/event");
 var useragent = require("../lib/useragent");
 var dom = require("../lib/dom");
+var lang = require("../lib/lang");
+var BROKEN_SETDATA = useragent.isChrome < 18;
+var USE_IE_MIME_TYPE =  useragent.isIE;
 
 var TextInput = function(parentNode, host) {
     var text = dom.createElement("textarea");
     text.className = "ace_text-input";
-    /*/ debug
-    text.style.opacity = 1
-    text.style.background = "rgba(0, 250, 0, 0.3)"
-    text.style.outline = "rgba(0, 250, 0, 0.8) solid 1px"
-    text.style.outlineOffset = "3px"
-    /**/
+
     if (useragent.isTouchPad)
         text.setAttribute("x-palm-disable-auto-cap", true);
 
-    text.wrap = "off";
-    text.spellcheck = false;
+    text.setAttribute("wrap", "off");
+    text.setAttribute("autocorrect", "off");
+    text.setAttribute("autocapitalize", "off");
+    text.setAttribute("spellcheck", false);
 
-    text.style.top = "-2em";
+    text.style.opacity = "0";
+    if (useragent.isOldIE) text.style.top = "-100px";
     parentNode.insertBefore(text, parentNode.firstChild);
 
-    var PLACEHOLDER = useragent.isIE || useragent.isOpera ? "\x01\x01" : "\x00\x00";
-
-    resetValue();
-
-    if (isFocused())
-        host.onFocus();
+    var PLACEHOLDER = "\x01\x01";
 
-    // Somehow fixes problem with firing onpropertychange on first typed char
-    if (useragent.isOldIE) {
-        resetSelection();
-        resetValue();
-        setTimeout(resetSelection);
-    }
-
-    var cut = false
     var copied = false;
     var pasted = false;
+    var inComposition = false;
+    var tempStyle = '';
+    var isSelectionEmpty = true;
+
+    // FOCUS
+    // ie9 throws error if document.activeElement is accessed too soon
+    try { var isFocused = document.activeElement === text; } catch(e) {}
+    
+    event.addListener(text, "blur", function(e) {
+        host.onBlur(e);
+        isFocused = false;
+    });
+    event.addListener(text, "focus", function(e) {
+        isFocused = true;
+        host.onFocus(e);
+        resetSelection();
+    });
+    this.focus = function() {
+        text.style.position = "fixed";
+        text.style.top = "-10000000px";
+        text.focus();
+        setTimeout(function() {
+            text.style.position = "";
+        }, 0);
+    };
+    this.blur = function() { text.blur(); };
+    this.isFocused = function() {
+        return isFocused;
+    };
 
-    var inCompostion = false;
-
-    var resetTimeout = null;
+    // modifying selection of blured textarea can focus it (chrome mac/linux)
+    var syncSelection = lang.delayedCall(function() {
+        isFocused && resetSelection(isSelectionEmpty);
+    });
+    var syncValue = lang.delayedCall(function() {
+         if (!inComposition) {
+            text.value = PLACEHOLDER;
+            isFocused && resetSelection();
+         }
+    });
 
-    var tempStyle = '';
+    function resetSelection(isEmpty) {
+        if (inComposition)
+            return;
+        
+        // this prevents infinite recursion on safari 8 
+        // see https://github.com/ajaxorg/ace/issues/2114
+        inComposition = true;
+        
+        if (inputHandler) {
+            selectionStart = 0;
+            selectionEnd = isEmpty ? 0 : text.value.length - 1;
+        } else {
+            var selectionStart = isEmpty ? 2 : 1;
+            var selectionEnd = 2;
+        }
+        // on firefox this throws if textarea is hidden
+        try {
+            text.setSelectionRange(selectionStart, selectionEnd);
+        } catch(e){}
+        
+        inComposition = false;
+    }
 
     function resetValue() {
+        if (inComposition)
+            return;
         text.value = PLACEHOLDER;
         //http://code.google.com/p/chromium/issues/detail?id=76516
-        if (useragent.isWebKit && !resetTimeout)
-            resetTimeout = setTimeout(function(){
-                text.value = PLACEHOLDER;
-                resetSelection();
-                resetTimeout = null;
-            });
+        if (useragent.isWebKit)
+            syncValue.schedule();
+    }
+
+    useragent.isWebKit || host.addEventListener('changeSelection', function() {
+        if (host.selection.isEmpty() != isSelectionEmpty) {
+            isSelectionEmpty = !isSelectionEmpty;
+            syncSelection.schedule();
+        }
+    });
+
+    resetValue();
+    if (isFocused)
+        host.onFocus();
+
+
+    var isAllSelected = function(text) {
+        return text.selectionStart === 0 && text.selectionEnd === text.value.length;
     };
+    // IE8 does not support setSelectionRange
+    if (!text.setSelectionRange && text.createTextRange) {
+        text.setSelectionRange = function(selectionStart, selectionEnd) {
+            var range = this.createTextRange();
+            range.collapse(true);
+            range.moveStart('character', selectionStart);
+            range.moveEnd('character', selectionEnd);
+            range.select();
+        };
+        isAllSelected = function(text) {
+            try {
+                var range = text.ownerDocument.selection.createRange();
+            }catch(e) {}
+            if (!range || range.parentElement() != text) return false;
+                return range.text == text.value;
+        }
+    }
+    if (useragent.isOldIE) {
+        var inPropertyChange = false;
+        var onPropertyChange = function(e){
+            if (inPropertyChange)
+                return;
+            var data = text.value;
+            if (inComposition || !data || data == PLACEHOLDER)
+                return;
+            // can happen either after delete or during insert operation
+            if (e && data == PLACEHOLDER[0])
+                return syncProperty.schedule();
 
-    function resetSelection(isEmpty) {
-        var selectionStart = isEmpty ? 2 : 1;
-        var selectionEnd = 2;
-        // on firefox this throws if textarea is hidden
-        try {
-            if (text.setSelectionRange) {
-                text.setSelectionRange(selectionStart, selectionEnd);
-            }
-            // IE8 does not support setSelectionRange
-            else if (text.createTextRange) {
-                var range = text.createTextRange();
-                range.collapse(true);
-                range.moveEnd('character', selectionEnd);
-                range.moveStart('character', selectionStart);
-                range.select();
+            sendText(data);
+            // ie8 calls propertychange handlers synchronously!
+            inPropertyChange = true;
+            resetValue();
+            inPropertyChange = false;
+        };
+        var syncProperty = lang.delayedCall(onPropertyChange);
+        event.addListener(text, "propertychange", onPropertyChange);
+
+        var keytable = { 13:1, 27:1 };
+        event.addListener(text, "keyup", function (e) {
+            if (inComposition && (!text.value || keytable[e.keyCode]))
+                setTimeout(onCompositionEnd, 0);
+            if ((text.value.charCodeAt(0)||0) < 129) {
+                return syncProperty.call();
             }
-        } catch(e){}
-    };
+            inComposition ? onCompositionUpdate() : onCompositionStart();
+        });
+        // when user presses backspace after focusing the editor 
+        // propertychange isn't called for the next character
+        event.addListener(text, "keydown", function (e) {
+            syncProperty.schedule(50);
+        });
+    }
 
     var onSelect = function(e) {
-        if (cut) {
-            cut = false;
-            return;
-        }
         if (copied) {
             copied = false;
-            return;
-        }
-        if (text.selectionStart === 0 && text.selectionEnd === text.value.length) {
+        } else if (isAllSelected(text)) {
             host.selectAll();
             resetSelection();
+        } else if (inputHandler) {
+            resetSelection(host.selection.isEmpty());
         }
     };
 
-    var onInput = function(e) {
-        if (inCompostion)
-            return;
-
+    var inputHandler = null;
+    this.setInputHandler = function(cb) {inputHandler = cb};
+    this.getInputHandler = function() {return inputHandler};
+    var afterContextMenu = false;
+    
+    var sendText = function(data) {
+        if (inputHandler) {
+            data = inputHandler(data);
+            inputHandler = null;
+        }
         if (pasted) {
-            var data = text.value;
-            resetValue();
+            resetSelection();
             if (data)
                 host.onPaste(data);
             pasted = false;
-            return;
-        }
-
-        var data = text.value;
-        if (data.substring(0, 2) == PLACEHOLDER)
-            data = data.substr(2);
-        else
-            data = data.substr(1);
-
-        resetValue();
-        if (data) {
+        } else if (data == PLACEHOLDER.charAt(0)) {
+            if (afterContextMenu)
+                host.execCommand("del", {source: "ace"});
+            else // some versions of android do not fire keydown when pressing backspace
+                host.execCommand("backspace", {source: "ace"});
+        } else {
+            if (data.substring(0, 2) == PLACEHOLDER)
+                data = data.substr(2);
+            else if (data.charAt(0) == PLACEHOLDER.charAt(0))
+                data = data.substr(1);
+            else if (data.charAt(data.length - 1) == PLACEHOLDER.charAt(0))
+                data = data.slice(0, -1);
             // can happen if undo in textarea isn't stopped
-            if (data[data.length - 1] == PLACEHOLDER[0])
+            if (data.charAt(data.length - 1) == PLACEHOLDER.charAt(0))
                 data = data.slice(0, -1);
-        if (data)
-            host.onTextInput(data);
-        } else
-            host.onDelete();
-    };
-
-    var onCompositionStart = function(e) {
-        inCompostion = true;
-        host.onCompositionStart();
-        setTimeout(onCompositionUpdate, 0);
-    };
-
-    var onCompositionUpdate = function() {
-        if (!inCompostion) return;
-        host.onCompositionUpdate(text.value);
-    };
-
-    var onCompositionEnd = function(e) {
-        inCompostion = false;
-        host.onCompositionEnd();
+            
+            if (data)
+                host.onTextInput(data);
+        }
+        if (afterContextMenu)
+            afterContextMenu = false;
     };
-
-    var onCut = function(e) {
-        var data = host.getCopyText();
-        if (!data) {
-            event.preventDefault(e);
+    var onInput = function(e) {
+        // console.log("onInput", inComposition)
+        if (inComposition)
             return;
-        }
-
+        var data = text.value;
+        sendText(data);
+        resetValue();
+    };
+    
+    var handleClipboardData = function(e, data) {
         var clipboardData = e.clipboardData || window.clipboardData;
-
-        if (clipboardData) {
+        if (!clipboardData || BROKEN_SETDATA)
+            return;
+        // using "Text" doesn't work on old webkit but ie needs it
+        // TODO are there other browsers that require "Text"?
+        var mime = USE_IE_MIME_TYPE ? "Text" : "text/plain";
+        if (data) {
             // Safari 5 has clipboardData object, but does not handle setData()
-            var supported = clipboardData.setData("Text", data);
-            if (supported) {
-                host.onCut();
-                event.preventDefault(e);
-            }
-        }
-
-        if (!supported) {
-            cut = true;
-            text.value = data;
-            text.select();
-            setTimeout(function(){
-                cut = false;
-                resetValue();
-                resetSelection();
-                host.onCut();
-            });
+            return clipboardData.setData(mime, data) !== false;
+        } else {
+            return clipboardData.getData(mime);
         }
     };
 
-    var onCopy = function(e) {
+    var doCopy = function(e, isCut) {
         var data = host.getCopyText();
-        if (!data) {
-            event.preventDefault(e);
-            return;
-        }
-
-        var clipboardData = e.clipboardData || window.clipboardData;
+        if (!data)
+            return event.preventDefault(e);
 
-        if (clipboardData) {
-            // Safari 5 has clipboardData object, but does not handle setData()
-            var supported = clipboardData.setData("Text", data);
-            if (supported) {
-                host.onCopy();
-                event.preventDefault(e);
-            }
-        }
-        if (!supported) {
+        if (handleClipboardData(e, data)) {
+            isCut ? host.onCut() : host.onCopy();
+            event.preventDefault(e);
+        } else {
             copied = true;
             text.value = data;
             text.select();
@@ -224,20 +288,26 @@ var TextInput = function(parentNode, host) {
                 copied = false;
                 resetValue();
                 resetSelection();
-                host.onCopy();
+                isCut ? host.onCut() : host.onCopy();
             });
         }
-
-        
     };
-
+    
+    var onCut = function(e) {
+        doCopy(e, true);
+    };
+    
+    var onCopy = function(e) {
+        doCopy(e, false);
+    };
+    
     var onPaste = function(e) {
-        var clipboardData = e.clipboardData || window.clipboardData;
-
-        if (clipboardData) {
-            var data = clipboardData.getData("Text");
+        var data = handleClipboardData(e);
+        if (typeof data == "string") {
             if (data)
                 host.onPaste(data);
+            if (useragent.isIE)
+                setTimeout(resetSelection);
             event.preventDefault(e);
         }
         else {
@@ -261,7 +331,7 @@ var TextInput = function(parentNode, host) {
     if (!('oncut' in text) || !('oncopy' in text) || !('onpaste' in text)){
         event.addListener(parentNode, "keydown", function(e) {
             if ((useragent.isMac && !e.metaKey) || !e.ctrlKey)
-            return;
+                return;
 
             switch (e.keyCode) {
                 case 67:
@@ -277,68 +347,128 @@ var TextInput = function(parentNode, host) {
         });
     }
 
-    if (useragent.isOldIE) {
-        event.addListener(text, "propertychange", function(e){
-            if (text.value != "" && text.value != PLACEHOLDER)
-                onInput(e);
-        });
 
-        var keytable = { 13:1, 27:1 };
-        event.addListener(text, "keyup", function (e) {
-            if (inCompostion && (!text.value || keytable[e.keyCode]))
-                setTimeout(onCompositionEnd, 0);
-            if ((text.value.charCodeAt(0)|0) < 129) {
+    // COMPOSITION
+    var onCompositionStart = function(e) {
+        if (inComposition || !host.onCompositionStart || host.$readOnly) 
+            return;
+        // console.log("onCompositionStart", inComposition)
+        inComposition = {};
+        host.onCompositionStart();
+        setTimeout(onCompositionUpdate, 0);
+        host.on("mousedown", onCompositionEnd);
+        if (!host.selection.isEmpty()) {
+            host.insert("");
+            host.session.markUndoGroup();
+            host.selection.clearSelection();
+        }
+        host.session.markUndoGroup();
+    };
+
+    var onCompositionUpdate = function() {
+        // console.log("onCompositionUpdate", inComposition && JSON.stringify(text.value))
+        if (!inComposition || !host.onCompositionUpdate || host.$readOnly)
+            return;
+        var val = text.value.replace(/\x01/g, "");
+        if (inComposition.lastValue === val) return;
+        
+        host.onCompositionUpdate(val);
+        if (inComposition.lastValue)
+            host.undo();
+        inComposition.lastValue = val;
+        if (inComposition.lastValue) {
+            var r = host.selection.getRange();
+            host.insert(inComposition.lastValue);
+            host.session.markUndoGroup();
+            inComposition.range = host.selection.getRange();
+            host.selection.setRange(r);
+            host.selection.clearSelection();
+        }
+    };
+
+    var onCompositionEnd = function(e) {
+        if (!host.onCompositionEnd || host.$readOnly) return;
+        // console.log("onCompositionEnd", inComposition &&inComposition.lastValue)
+        var c = inComposition;
+        inComposition = false;
+        var timer = setTimeout(function() {
+            timer = null;
+            var str = text.value.replace(/\x01/g, "");
+            // console.log(str, c.lastValue)
+            if (inComposition)
                 return;
+            else if (str == c.lastValue)
+                resetValue();
+            else if (!c.lastValue && str) {
+                resetValue();
+                sendText(str);
             }
-            inCompostion ? onCompositionUpdate() : onCompositionStart();
         });
-    }
+        inputHandler = function compositionInputHandler(str) {
+            // console.log("onCompositionEnd", str, c.lastValue)
+            if (timer)
+                clearTimeout(timer);
+            str = str.replace(/\x01/g, "");
+            if (str == c.lastValue)
+                return "";
+            if (c.lastValue && timer)
+                host.undo();
+            return str;
+        };
+        host.onCompositionEnd();
+        host.removeListener("mousedown", onCompositionEnd);
+        if (e.type == "compositionend" && c.range) {
+            host.selection.setRange(c.range);
+        }
+    };
+    
+    
+
+    var syncComposition = lang.delayedCall(onCompositionUpdate, 50);
 
     event.addListener(text, "compositionstart", onCompositionStart);
     if (useragent.isGecko) {
-        event.addListener(text, "text", onCompositionUpdate);
-    }
-    if (useragent.isWebKit) {
-        event.addListener(text, "keyup", onCompositionUpdate);
+        event.addListener(text, "text", function(){syncComposition.schedule()});
+    } else {
+        event.addListener(text, "keyup", function(){syncComposition.schedule()});
+        event.addListener(text, "keydown", function(){syncComposition.schedule()});
     }
     event.addListener(text, "compositionend", onCompositionEnd);
 
-    event.addListener(text, "blur", function() {
-        host.onBlur();
-    });
-
-    event.addListener(text, "focus", function() {
-        host.onFocus();
-        resetSelection();
-    });
-
-    this.focus = function() {
-        text.focus();
-    };
-
-    this.blur = function() {
-        text.blur();
-    };
-
-    function isFocused() {
-        return document.activeElement === text;
-    }
-    this.isFocused = isFocused;
-
     this.getElement = function() {
         return text;
     };
 
+    this.setReadOnly = function(readOnly) {
+       text.readOnly = readOnly;
+    };
+
     this.onContextMenu = function(e) {
+        afterContextMenu = true;
+        resetSelection(host.selection.isEmpty());
+        host._emit("nativecontextmenu", {target: host, domEvent: e});
+        this.moveToMouse(e, true);
+    };
+    
+    this.moveToMouse = function(e, bringToFront) {
+        if (!bringToFront && useragent.isOldIE)
+            return;
         if (!tempStyle)
             tempStyle = text.style.cssText;
-
-        text.style.cssText =
-            "position:fixed; z-index:100000;" + 
-            (useragent.isIE ? "background:rgba(0, 0, 0, 0.03); opacity:0.1;" : "") + //"background:rgba(250, 0, 0, 0.3); opacity:1;" +
-            "left:" + (e.clientX - 2) + "px; top:" + (e.clientY - 2) + "px;";
-
-        resetSelection(host.selection.isEmpty());
+        text.style.cssText = (bringToFront ? "z-index:100000;" : "")
+            + "height:" + text.style.height + ";"
+            + (useragent.isIE ? "opacity:0.1;" : "");
+
+        var rect = host.container.getBoundingClientRect();
+        var style = dom.computedStyle(host.container);
+        var top = rect.top + (parseInt(style.borderTopWidth) || 0);
+        var left = rect.left + (parseInt(rect.borderLeftWidth) || 0);
+        var maxTop = rect.bottom - top - text.clientHeight -2;
+        var move = function(e) {
+            text.style.left = e.clientX - left - 2 + "px";
+            text.style.top = Math.min(e.clientY - top - 2, maxTop) + "px";
+        }; 
+        move(e);
 
         if (e.type != "mousedown")
             return;
@@ -347,15 +477,15 @@ var TextInput = function(parentNode, host) {
             host.renderer.$keepTextAreaAtCursor = null;
 
         // on windows context menu is opened after mouseup
-        if (useragent.isWin)
-            event.capture(host.container, function(e) {
-                text.style.left = e.clientX - 2 + "px";
-                text.style.top = e.clientY - 2 + "px";
-            }, onContextMenuClose);
+        if (useragent.isWin && !useragent.isOldIE)
+            event.capture(host.container, move, onContextMenuClose);
     };
 
+    this.onContextMenuClose = onContextMenuClose;
+    var closeTimeout;
     function onContextMenuClose() {
-        setTimeout(function () {
+        clearTimeout(closeTimeout)
+        closeTimeout = setTimeout(function () {
             if (tempStyle) {
                 text.style.cssText = tempStyle;
                 tempStyle = '';
@@ -364,16 +494,15 @@ var TextInput = function(parentNode, host) {
                 host.renderer.$keepTextAreaAtCursor = true;
                 host.renderer.$moveTextAreaToCursor();
             }
-        }, 0);
-    };
-    this.onContextMenuClose = onContextMenuClose;
+        }, useragent.isOldIE ? 200 : 0);
+    }
 
-    // firefox fires contextmenu event after opening it
-    if (!useragent.isGecko)
-        event.addListener(text, "contextmenu", function(e) {
-            host.textInput.onContextMenu(e);
-            onContextMenuClose();
-        });
+    var onContextMenu = function(e) {
+        host.textInput.onContextMenu(e);
+        onContextMenuClose();
+    };
+    event.addListener(host.renderer.scroller, "contextmenu", onContextMenu);
+    event.addListener(text, "contextmenu", onContextMenu);
 };
 
 exports.TextInput = TextInput;