gollum 3.1.2 → 3.1.3

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/edit_session_test.js

@@ -62,6 +62,7 @@ function createFoldTestSession() {
 }
 
 function assertArray(a, b) {
+    assert.equal(a+"", b+"");
     assert.ok(a.length == b.length);
     for (var i = 0; i < a.length; i++) {
         assert.equal(a[i], b[i]);
@@ -385,11 +386,12 @@ module.exports = {
                 assert.ok(splits[i] == assertEqual[i]);
             }
         }
-
+        
+        EditSession.prototype.$wrapAsCode = true;
         // Basic splitting.
         computeAndAssert("foo bar foo bar", [ 12 ]);
         computeAndAssert("foo bar f   bar", [ 12 ]);
-        computeAndAssert("foo bar f     r", [ 14 ]);
+        computeAndAssert("foo bar f     r", [ 12 ]); // 14 if we enable 
         computeAndAssert("foo bar foo bar foo bara foo", [12, 25]);
 
         // Don't split if there is only whitespaces/tabs at the end of the line.
@@ -405,7 +407,7 @@ module.exports = {
         computeAndAssert("foo \t \tbar", [ 7 ]);
 
         // Ignore spaces/tabs at beginning of split.
-        computeAndAssert("foo \t \t   \t \t bar", [ 14 ]);
+        computeAndAssert("foo \t \t   \t \t bar", [ 7 ]); // 14
 
         // Test wrapping for asian characters.
         computeAndAssert("ぁぁ", [1], 2);
@@ -417,6 +419,10 @@ module.exports = {
         computeAndAssert(" ab.c;ef++", [1, 3, 5, 7, 8], 2);
         computeAndAssert(" a.b", [1, 2, 3], 1);
         computeAndAssert("#>>", [1, 2], 1);
+        
+        // Test wrapping for punctuation in
+        EditSession.prototype.$wrapAsCode = false;
+        computeAndAssert("ab cde, Juhu kinners", [3, 8, 13, 19], 6);
     },
 
     "test get longest line" : function() {
@@ -898,7 +904,27 @@ module.exports = {
 
         return session;
     },
-
+    
+    "test delete fold with wrap enabled": function() {
+        var session = new EditSession("");
+        session.setValue([
+            "This is some placeholder text that will be folded inline.",
+            "This is some placeholder text that will be folded inline.",
+            "More text.",
+            "<p>The cursor in this paragraph text will be offset by 1 row.<p>",
+            "<p>Everything after this will be offset as well due to the folds in the row before too.</p>"
+        ].join("\n"));
+        session.addFold('...', new Range(0, 8, 0, 42));
+        session.addFold('...', new Range(1, 8, 1, 42));
+        session.addFold('...', new Range(3, 7, 3, 51));
+        session.setOption("wrap", 40);
+        session.remove(new Range(0,0, 2, 5));
+        // needed because adjustWrapLimit is called async from renderer
+        session.adjustWrapLimit(80);
+        
+        assert.equal(session.$wrapData + "", [[], [], [40, 76]] + "");
+    },
+        
     "test add fold": function() {
         var session = createFoldTestSession();
         var fold;
@@ -911,7 +937,7 @@ module.exports = {
                 fail = true;
             }
             if (fail != shouldFail) {
-                throw "Expected to get an exception";
+                throw new Error("Expected to get an exception");
             }
         }
 
@@ -980,7 +1006,8 @@ module.exports = {
         assertArray(session.$docRowCache, [1,3,4]);
         assertArray(session.$screenRowCache, [1,2,3]);
 
-        session.screenToDocumentPosition(0,0);
+        var pos = session.screenToDocumentPosition(0,0);
+        assert.equal(pos.row, 0);
         assertArray(session.$docRowCache, [1,3,4]);
         assertArray(session.$screenRowCache, [1,2,3]);
         
@@ -991,11 +1018,58 @@ module.exports = {
         session.$resetRowCache();
         assertArray(session.$docRowCache, []);
         assertArray(session.$screenRowCache, []);
+        
+        session.screenToDocumentPosition(1,3);
+        assertArray(session.$docRowCache, [1]);
+        assertArray(session.$screenRowCache, [1]);
+       
+        session.screenToDocumentPosition(5,3);
+        assertArray(session.$docRowCache, [1,3,4]);
+        assertArray(session.$screenRowCache, [1,2,3]);
+        
+        session = new EditSession(new Array(30).join("\n"));
+        session.documentToScreenPosition(2,0);
+        session.documentToScreenPosition(2,0);
+        assertArray(session.$docRowCache, [1,2]);
+        assertArray(session.$screenRowCache, [1,2]);
+    },
+
+    "test annotations": function() {
+        var session = new EditSession([]),
+            annotation = {row: 0, type: 'info', text: "This is a test."};
+
+        session.clearAnnotations();
+        assertArray(session.getAnnotations(), []);
+        session.setAnnotations([annotation]);
+        assertArray(session.getAnnotations(), [annotation]);
+    },
+    
+    "test: mode loading" : function(next) {
+        if (!require.undef) {
+            console.log("Skipping test: This test only runs in the browser");
+            next();
+            return;
+        }
+        var session = new EditSession([]);
+        session.setMode("ace/mode/javascript");
+        assert.equal(session.$modeid, "ace/mode/javascript");
+        session.on("changeMode", function() {
+            assert.equal(session.$modeid, "ace/mode/javascript");
+        });
+        session.setMode("ace/mode/sh", function(mode) {
+            assert.ok(!mode);
+        });
+        setTimeout(function() {
+            session.setMode("ace/mode/javascript", function(mode) {
+                session.setMode("ace/mode/javascript");
+                assert.equal(session.$modeid, "ace/mode/javascript");
+                next();
+            });
+        }, 0);
     }
 };
-
 });
 
 if (typeof module !== "undefined" && module === require.main) {
-    require("asyncjs").test.testcase(module.exports).exec()
+    require("asyncjs").test.testcase(module.exports).exec();
 }

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/editor.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,6 +34,7 @@ define(function(require, exports, module) {
 require("./lib/fixoldbrowsers");
 
 var oop = require("./lib/oop");
+var dom = require("./lib/dom");
 var lang = require("./lib/lang");
 var useragent = require("./lib/useragent");
 var TextInput = require("./keyboard/textinput").TextInput;
@@ -46,13 +47,13 @@ var Range = require("./range").Range;
 var EventEmitter = require("./lib/event_emitter").EventEmitter;
 var CommandManager = require("./commands/command_manager").CommandManager;
 var defaultCommands = require("./commands/default_commands").commands;
+var config = require("./config");
+var TokenIterator = require("./token_iterator").TokenIterator;
 
 /**
+ * The main entry point into the Ace functionality.
  *
- *
- * The main entry point into the Ace functionality. 
- *
- * The `Editor` manages the [[EditSession]] (which manages [[Document]]s), as well as the [[VirtualRenderer]], which draws everything to the screen. 
+ * The `Editor` manages the [[EditSession]] (which manages [[Document]]s), as well as the [[VirtualRenderer]], which draws everything to the screen.
  *
  * Event sessions dealing with the mouse and keyboard are bubbled up from `Document` to the `Editor`, which decides what to do with them.
  * @class Editor
@@ -86,28 +87,174 @@ var Editor = function(renderer, session) {
         wrap: true
     });
 
+    this.$historyTracker = this.$historyTracker.bind(this);
+    this.commands.on("exec", this.$historyTracker);
+
+    this.$initOperationListeners();
+    
+    this._$emitInputEvent = lang.delayedCall(function() {
+        this._signal("input", {});
+        if (this.session && this.session.bgTokenizer)
+            this.session.bgTokenizer.scheduleStart();
+    }.bind(this));
+    
+    this.on("change", function(_, _self) {
+        _self._$emitInputEvent.schedule(31);
+    });
+
     this.setSession(session || new EditSession(""));
+    config.resetOptions(this);
+    config._signal("editor", this);
 };
 
 (function(){
 
     oop.implement(this, EventEmitter);
 
+    this.$initOperationListeners = function() {
+        function last(a) {return a[a.length - 1]}
+
+        this.selections = [];
+        this.commands.on("exec", this.startOperation.bind(this), true);
+        this.commands.on("afterExec", this.endOperation.bind(this), true);
+
+        this.$opResetTimer = lang.delayedCall(this.endOperation.bind(this));
+
+        this.on("change", function() {
+            this.curOp || this.startOperation();
+            this.curOp.docChanged = true;
+        }.bind(this), true);
+
+        this.on("changeSelection", function() {
+            this.curOp || this.startOperation();
+            this.curOp.selectionChanged = true;
+        }.bind(this), true);
+    };
+
+    this.curOp = null;
+    this.prevOp = {};
+    this.startOperation = function(commadEvent) {
+        if (this.curOp) {
+            if (!commadEvent || this.curOp.command)
+                return;
+            this.prevOp = this.curOp;
+        }
+        if (!commadEvent) {
+            this.previousCommand = null;
+            commadEvent = {};
+        }
+
+        this.$opResetTimer.schedule();
+        this.curOp = {
+            command: commadEvent.command || {},
+            args: commadEvent.args,
+            scrollTop: this.renderer.scrollTop
+        };
+        if (this.curOp.command.name)
+            this.$blockScrolling++;
+        // this.selections.push(this.selection.toJSON());
+    };
+
+    this.endOperation = function(e) {
+        if (this.curOp) {
+            if (e && e.returnValue === false)
+                return this.curOp = null;
+            this._signal("beforeEndOperation");
+            var command = this.curOp.command;
+            if (command.name && this.$blockScrolling)
+                this.$blockScrolling--;
+            if (command && command.scrollIntoView) {
+                switch (command.scrollIntoView) {
+                    case "center":
+                        this.renderer.scrollCursorIntoView(null, 0.5);
+                        break;
+                    case "animate":
+                    case "cursor":
+                        this.renderer.scrollCursorIntoView();
+                        break;
+                    case "selectionPart":
+                        var range = this.selection.getRange();
+                        var config = this.renderer.layerConfig;
+                        if (range.start.row >= config.lastRow || range.end.row <= config.firstRow) {
+                            this.renderer.scrollSelectionIntoView(this.selection.anchor, this.selection.lead);
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                if (command.scrollIntoView == "animate")
+                    this.renderer.animateScrolling(this.curOp.scrollTop);
+            }
+            
+            this.prevOp = this.curOp;
+            this.curOp = null;
+        }
+    };
+
+    // TODO use property on commands instead of this
+    this.$mergeableCommands = ["backspace", "del", "insertstring"];
+    this.$historyTracker = function(e) {
+        if (!this.$mergeUndoDeltas)
+            return;
+
+        var prev = this.prevOp;
+        var mergeableCommands = this.$mergeableCommands;
+        // previous command was the same
+        var shouldMerge = prev.command && (e.command.name == prev.command.name);
+        if (e.command.name == "insertstring") {
+            var text = e.args;
+            if (this.mergeNextCommand === undefined)
+                this.mergeNextCommand = true;
+
+            shouldMerge = shouldMerge
+                && this.mergeNextCommand // previous command allows to coalesce with
+                && (!/\s/.test(text) || /\s/.test(prev.args)); // previous insertion was of same type
+
+            this.mergeNextCommand = true;
+        } else {
+            shouldMerge = shouldMerge
+                && mergeableCommands.indexOf(e.command.name) !== -1; // the command is mergeable
+        }
+
+        if (
+            this.$mergeUndoDeltas != "always"
+            && Date.now() - this.sequenceStartTime > 2000
+        ) {
+            shouldMerge = false; // the sequence is too long
+        }
+
+        if (shouldMerge)
+            this.session.mergeUndoDeltas = true;
+        else if (mergeableCommands.indexOf(e.command.name) !== -1)
+            this.sequenceStartTime = Date.now();
+    };
+
     /**
      * Sets a new key handler, such as "vim" or "windows".
      * @param {String} keyboardHandler The new key handler
      *
-     * 
      **/
-    this.setKeyboardHandler = function(keyboardHandler) {
-        this.keyBinding.setKeyboardHandler(keyboardHandler);
+    this.setKeyboardHandler = function(keyboardHandler, cb) {
+        if (keyboardHandler && typeof keyboardHandler === "string") {
+            this.$keybindingId = keyboardHandler;
+            var _self = this;
+            config.loadModule(["keybinding", keyboardHandler], function(module) {
+                if (_self.$keybindingId == keyboardHandler)
+                    _self.keyBinding.setKeyboardHandler(module && module.handler);
+                cb && cb();
+            });
+        } else {
+            this.$keybindingId = null;
+            this.keyBinding.setKeyboardHandler(keyboardHandler);
+            cb && cb();
+        }
     };
 
-    /** 
+    /**
      * Returns the keyboard handler, such as "vim" or "windows".
      *
      * @returns {String}
-     * 
+     *
      **/
     this.getKeyboardHandler = function() {
         return this.keyBinding.getKeyboardHandler();
@@ -119,20 +266,18 @@ var Editor = function(renderer, session) {
      * @event changeSession
      * @param {Object} e An object with two properties, `oldSession` and `session`, that represent the old and new [[EditSession]]s.
      *
-     *
      **/
     /**
      * Sets a new editsession to use. This method also emits the `'changeSession'` event.
      * @param {EditSession} session The new session to use
      *
-     *
      **/
     this.setSession = function(session) {
         if (this.session == session)
             return;
 
-        if (this.session) {
-            var oldSession = this.session;
+        var oldSession = this.session;
+        if (oldSession) {
             this.session.removeEventListener("change", this.$onDocumentChange);
             this.session.removeEventListener("changeMode", this.$onChangeMode);
             this.session.removeEventListener("tokenizerUpdate", this.$onTokenizerUpdate);
@@ -146,7 +291,7 @@ var Editor = function(renderer, session) {
             this.session.removeEventListener("changeAnnotation", this.$onChangeAnnotation);
             this.session.removeEventListener("changeOverwrite", this.$onCursorChange);
             this.session.removeEventListener("changeScrollTop", this.$onScrollTopChange);
-            this.session.removeEventListener("changeLeftTop", this.$onScrollLeftChange);
+            this.session.removeEventListener("changeScrollLeft", this.$onScrollLeftChange);
 
             var selection = this.session.getSelection();
             selection.removeEventListener("changeCursor", this.$onCursorChange);
@@ -154,76 +299,83 @@ var Editor = function(renderer, session) {
         }
 
         this.session = session;
+        if (session) {
+            this.$onDocumentChange = this.onDocumentChange.bind(this);
+            session.addEventListener("change", this.$onDocumentChange);
+            this.renderer.setSession(session);
+    
+            this.$onChangeMode = this.onChangeMode.bind(this);
+            session.addEventListener("changeMode", this.$onChangeMode);
+    
+            this.$onTokenizerUpdate = this.onTokenizerUpdate.bind(this);
+            session.addEventListener("tokenizerUpdate", this.$onTokenizerUpdate);
+    
+            this.$onChangeTabSize = this.renderer.onChangeTabSize.bind(this.renderer);
+            session.addEventListener("changeTabSize", this.$onChangeTabSize);
+    
+            this.$onChangeWrapLimit = this.onChangeWrapLimit.bind(this);
+            session.addEventListener("changeWrapLimit", this.$onChangeWrapLimit);
+    
+            this.$onChangeWrapMode = this.onChangeWrapMode.bind(this);
+            session.addEventListener("changeWrapMode", this.$onChangeWrapMode);
+    
+            this.$onChangeFold = this.onChangeFold.bind(this);
+            session.addEventListener("changeFold", this.$onChangeFold);
+    
+            this.$onChangeFrontMarker = this.onChangeFrontMarker.bind(this);
+            this.session.addEventListener("changeFrontMarker", this.$onChangeFrontMarker);
+    
+            this.$onChangeBackMarker = this.onChangeBackMarker.bind(this);
+            this.session.addEventListener("changeBackMarker", this.$onChangeBackMarker);
+    
+            this.$onChangeBreakpoint = this.onChangeBreakpoint.bind(this);
+            this.session.addEventListener("changeBreakpoint", this.$onChangeBreakpoint);
+    
+            this.$onChangeAnnotation = this.onChangeAnnotation.bind(this);
+            this.session.addEventListener("changeAnnotation", this.$onChangeAnnotation);
+    
+            this.$onCursorChange = this.onCursorChange.bind(this);
+            this.session.addEventListener("changeOverwrite", this.$onCursorChange);
+    
+            this.$onScrollTopChange = this.onScrollTopChange.bind(this);
+            this.session.addEventListener("changeScrollTop", this.$onScrollTopChange);
+    
+            this.$onScrollLeftChange = this.onScrollLeftChange.bind(this);
+            this.session.addEventListener("changeScrollLeft", this.$onScrollLeftChange);
+    
+            this.selection = session.getSelection();
+            this.selection.addEventListener("changeCursor", this.$onCursorChange);
+    
+            this.$onSelectionChange = this.onSelectionChange.bind(this);
+            this.selection.addEventListener("changeSelection", this.$onSelectionChange);
+    
+            this.onChangeMode();
+    
+            this.$blockScrolling += 1;
+            this.onCursorChange();
+            this.$blockScrolling -= 1;
+    
+            this.onScrollTopChange();
+            this.onScrollLeftChange();
+            this.onSelectionChange();
+            this.onChangeFrontMarker();
+            this.onChangeBackMarker();
+            this.onChangeBreakpoint();
+            this.onChangeAnnotation();
+            this.session.getUseWrapMode() && this.renderer.adjustWrapLimit();
+            this.renderer.updateFull();
+        } else {
+            this.selection = null;
+            this.renderer.setSession(session);
+        }
 
-        this.$onDocumentChange = this.onDocumentChange.bind(this);
-        session.addEventListener("change", this.$onDocumentChange);
-        this.renderer.setSession(session);
-
-        this.$onChangeMode = this.onChangeMode.bind(this);
-        session.addEventListener("changeMode", this.$onChangeMode);
-
-        this.$onTokenizerUpdate = this.onTokenizerUpdate.bind(this);
-        session.addEventListener("tokenizerUpdate", this.$onTokenizerUpdate);
-
-        this.$onChangeTabSize = this.renderer.onChangeTabSize.bind(this.renderer);
-        session.addEventListener("changeTabSize", this.$onChangeTabSize);
-
-        this.$onChangeWrapLimit = this.onChangeWrapLimit.bind(this);
-        session.addEventListener("changeWrapLimit", this.$onChangeWrapLimit);
-
-        this.$onChangeWrapMode = this.onChangeWrapMode.bind(this);
-        session.addEventListener("changeWrapMode", this.$onChangeWrapMode);
-
-        this.$onChangeFold = this.onChangeFold.bind(this);
-        session.addEventListener("changeFold", this.$onChangeFold);
-
-        this.$onChangeFrontMarker = this.onChangeFrontMarker.bind(this);
-        this.session.addEventListener("changeFrontMarker", this.$onChangeFrontMarker);
-
-        this.$onChangeBackMarker = this.onChangeBackMarker.bind(this);
-        this.session.addEventListener("changeBackMarker", this.$onChangeBackMarker);
-
-        this.$onChangeBreakpoint = this.onChangeBreakpoint.bind(this);
-        this.session.addEventListener("changeBreakpoint", this.$onChangeBreakpoint);
-
-        this.$onChangeAnnotation = this.onChangeAnnotation.bind(this);
-        this.session.addEventListener("changeAnnotation", this.$onChangeAnnotation);
-
-        this.$onCursorChange = this.onCursorChange.bind(this);
-        this.session.addEventListener("changeOverwrite", this.$onCursorChange);
-
-        this.$onScrollTopChange = this.onScrollTopChange.bind(this);
-        this.session.addEventListener("changeScrollTop", this.$onScrollTopChange);
-
-        this.$onScrollLeftChange = this.onScrollLeftChange.bind(this);
-        this.session.addEventListener("changeScrollLeft", this.$onScrollLeftChange);
-
-        this.selection = session.getSelection();
-        this.selection.addEventListener("changeCursor", this.$onCursorChange);
-
-        this.$onSelectionChange = this.onSelectionChange.bind(this);
-        this.selection.addEventListener("changeSelection", this.$onSelectionChange);
-
-        this.onChangeMode();
-
-        this.$blockScrolling += 1;
-        this.onCursorChange();
-        this.$blockScrolling -= 1;
-
-        this.onScrollTopChange();
-        this.onScrollLeftChange();
-        this.onSelectionChange();
-        this.onChangeFrontMarker();
-        this.onChangeBackMarker();
-        this.onChangeBreakpoint();
-        this.onChangeAnnotation();
-        this.session.getUseWrapMode() && this.renderer.adjustWrapLimit();
-        this.renderer.updateFull();
-
-        this._emit("changeSession", {
+        this._signal("changeSession", {
             session: session,
             oldSession: oldSession
         });
+        
+        oldSession && oldSession._signal("changeEditor", {oldEditor: this});
+        session && session._signal("changeEditor", {editor: this});
     };
 
     /**
@@ -234,13 +386,11 @@ var Editor = function(renderer, session) {
         return this.session;
     };
 
-    /** 
+    /**
      * Sets the current document to `val`.
      * @param {String} val The new value to set for the document
      * @param {Number} cursorPos Where to set the new value. `undefined` or 0 is selectAll, -1 is at the document start, and 1 is at the end
      *
-     * 
-     *
      * @returns {String} The current document value
      * @related Document.setValue
      **/
@@ -257,7 +407,7 @@ var Editor = function(renderer, session) {
         return val;
     };
 
-    /** 
+    /**
      * Returns the current session's content.
      *
      * @returns {String}
@@ -268,7 +418,7 @@ var Editor = function(renderer, session) {
     };
 
     /**
-     * 
+     *
      * Returns the currently highlighted selection.
      * @returns {String} The highlighted selection
      **/
@@ -276,11 +426,11 @@ var Editor = function(renderer, session) {
         return this.selection;
     };
 
-    /** 
+    /**
      * {:VirtualRenderer.onResize}
      * @param {Boolean} force If `true`, recomputes the size, even if the height and width haven't changed
      *
-     * 
+     *
      * @related VirtualRenderer.onResize
      **/
     this.resize = function(force) {
@@ -290,16 +440,15 @@ var Editor = function(renderer, session) {
     /**
      * {:VirtualRenderer.setTheme}
      * @param {String} theme The path to a theme
-     *
-     *
+     * @param {Function} cb optional callback called when theme is loaded
      **/
-    this.setTheme = function(theme) {
-        this.renderer.setTheme(theme);
+    this.setTheme = function(theme, cb) {
+        this.renderer.setTheme(theme, cb);
     };
 
-    /**  
+    /**
      * {:VirtualRenderer.getTheme}
-     * 
+     *
      * @returns {String} The set theme
      * @related VirtualRenderer.getTheme
      **/
@@ -311,14 +460,14 @@ var Editor = function(renderer, session) {
      * {:VirtualRenderer.setStyle}
      * @param {String} style A class name
      *
-     * 
+     *
      * @related VirtualRenderer.setStyle
      **/
     this.setStyle = function(style) {
         this.renderer.setStyle(style);
     };
 
-    /** 
+    /**
      * {:VirtualRenderer.unsetStyle}
      * @related VirtualRenderer.unsetStyle
      **/
@@ -326,15 +475,22 @@ var Editor = function(renderer, session) {
         this.renderer.unsetStyle(style);
     };
 
+    /**
+     * Gets the current font size of the editor text.
+     */
+    this.getFontSize = function () {
+        return this.getOption("fontSize") ||
+           dom.computedStyle(this.container, "fontSize");
+    };
+
     /**
      * Set a new font size (in pixels) for the editor text.
-     * @param {Number} size A font size 
-     * 
-     * 
+     * @param {String} size A font size ( _e.g._ "12px")
+     *
+     *
      **/
     this.setFontSize = function(size) {
-        this.container.style.fontSize = size;
-        this.renderer.updateFontSize();
+        this.setOption("fontSize", size);
     };
 
     this.$highlightBrackets = function() {
@@ -352,17 +508,110 @@ var Editor = function(renderer, session) {
         this.$highlightPending = true;
         setTimeout(function() {
             self.$highlightPending = false;
-
-            var pos = self.session.findMatchingBracket(self.getCursorPosition());
+            var session = self.session;
+            if (!session || !session.bgTokenizer) return;
+            var pos = session.findMatchingBracket(self.getCursorPosition());
             if (pos) {
-                var range = new Range(pos.row, pos.column, pos.row, pos.column+1);
-                self.session.$bracketHighlight = self.session.addMarker(range, "ace_bracket", "text");
+                var range = new Range(pos.row, pos.column, pos.row, pos.column + 1);
+            } else if (session.$mode.getMatching) {
+                var range = session.$mode.getMatching(self.session);
             }
+            if (range)
+                session.$bracketHighlight = session.addMarker(range, "ace_bracket", "text");
+        }, 50);
+    };
+
+    // todo: move to mode.getMatching
+    this.$highlightTags = function() {
+        if (this.$highlightTagPending)
+            return;
+
+        // perform highlight async to not block the browser during navigation
+        var self = this;
+        this.$highlightTagPending = true;
+        setTimeout(function() {
+            self.$highlightTagPending = false;
+            
+            var session = self.session;
+            if (!session || !session.bgTokenizer) return;
+            
+            var pos = self.getCursorPosition();
+            var iterator = new TokenIterator(self.session, pos.row, pos.column);
+            var token = iterator.getCurrentToken();
+            
+            if (!token || !/\b(?:tag-open|tag-name)/.test(token.type)) {
+                session.removeMarker(session.$tagHighlight);
+                session.$tagHighlight = null;
+                return;
+            }
+            
+            if (token.type.indexOf("tag-open") != -1) {
+                token = iterator.stepForward();
+                if (!token)
+                    return;
+            }
+            
+            var tag = token.value;
+            var depth = 0;
+            var prevToken = iterator.stepBackward();
+            
+            if (prevToken.value == '<'){
+                //find closing tag
+                do {
+                    prevToken = token;
+                    token = iterator.stepForward();
+                    
+                    if (token && token.value === tag && token.type.indexOf('tag-name') !== -1) {
+                        if (prevToken.value === '<'){
+                            depth++;
+                        } else if (prevToken.value === '</'){
+                            depth--;
+                        }
+                    }
+                    
+                } while (token && depth >= 0);
+            } else {
+                //find opening tag
+                do {
+                    token = prevToken;
+                    prevToken = iterator.stepBackward();
+                    
+                    if (token && token.value === tag && token.type.indexOf('tag-name') !== -1) {
+                        if (prevToken.value === '<') {
+                            depth++;
+                        } else if (prevToken.value === '</') {
+                            depth--;
+                        }
+                    }
+                } while (prevToken && depth <= 0);
+                
+                //select tag again
+                iterator.stepForward();
+            }
+            
+            if (!token) {
+                session.removeMarker(session.$tagHighlight);
+                session.$tagHighlight = null;
+                return;
+            }
+            
+            var row = iterator.getCurrentTokenRow();
+            var column = iterator.getCurrentTokenColumn();
+            var range = new Range(row, column, row, column+token.value.length);
+            
+            //remove range if different
+            if (session.$tagHighlight && range.compareRange(session.$backMarkers[session.$tagHighlight].range)!==0) {
+                session.removeMarker(session.$tagHighlight);
+                session.$tagHighlight = null;
+            }
+            
+            if (range && !session.$tagHighlight)
+                session.$tagHighlight = session.addMarker(range, "ace_bracket", "text");
         }, 50);
     };
 
     /**
-     * 
+     *
      * Brings the current `textInput` into focus.
      **/
     this.focus = function() {
@@ -378,14 +627,14 @@ var Editor = function(renderer, session) {
 
     /**
      * Returns `true` if the current `textInput` is in focus.
-     * @return Boolean
+     * @return {Boolean}
      **/
     this.isFocused = function() {
         return this.textInput.isFocused();
     };
 
     /**
-     * 
+     *
      * Blurs the current `textInput`.
      **/
     this.blur = function() {
@@ -394,32 +643,32 @@ var Editor = function(renderer, session) {
 
     /**
      * Emitted once the editor comes into focus.
-     * @event focus 
-     * 
-     * 
+     * @event focus
+     *
+     *
      **/
-    this.onFocus = function() {
+    this.onFocus = function(e) {
         if (this.$isFocused)
             return;
         this.$isFocused = true;
         this.renderer.showCursor();
         this.renderer.visualizeFocus();
-        this._emit("focus");
+        this._emit("focus", e);
     };
 
     /**
      * Emitted once the editor has been blurred.
      * @event blur
-     * 
-     * 
+     *
+     *
      **/
-    this.onBlur = function() {
+    this.onBlur = function(e) {
         if (!this.$isFocused)
             return;
         this.$isFocused = false;
         this.renderer.hideCursor();
         this.renderer.visualizeBlur();
-        this._emit("blur");
+        this._emit("blur", e);
     };
 
     this.$cursorChange = function() {
@@ -427,12 +676,12 @@ var Editor = function(renderer, session) {
     };
 
     /**
-     * Emitted whenever the document is changed. 
+     * Emitted whenever the document is changed.
      * @event change
      * @param {Object} e Contains a single property, `data`, which has the delta of changes
      *
      *
-     * 
+     *
      **/
     this.onDocumentChange = function(e) {
         var delta = e.data;
@@ -443,12 +692,13 @@ var Editor = function(renderer, session) {
             lastRow = range.end.row;
         else
             lastRow = Infinity;
-        this.renderer.updateLines(range.start.row, lastRow);
+        this.renderer.updateLines(range.start.row, lastRow, this.session.$useWrapMode);
 
-        this._emit("change", e);
+        this._signal("change", e);
 
         // update cursor because tab characters can influence the cursor position
         this.$cursorChange();
+        this.$updateHighlightActiveLine();
     };
 
     this.onTokenizerUpdate = function(e) {
@@ -460,25 +710,30 @@ var Editor = function(renderer, session) {
     this.onScrollTopChange = function() {
         this.renderer.scrollToY(this.session.getScrollTop());
     };
-    
+
     this.onScrollLeftChange = function() {
         this.renderer.scrollToX(this.session.getScrollLeft());
     };
 
     /**
      * Emitted when the selection changes.
-     * 
+     *
      **/
     this.onCursorChange = function() {
         this.$cursorChange();
 
         if (!this.$blockScrolling) {
+            config.warn("Automatically scrolling cursor into view after selection change",
+                "this will be disabled in the next version",
+                "set editor.$blockScrolling = Infinity to disable this message"
+            );
             this.renderer.scrollCursorIntoView();
         }
 
         this.$highlightBrackets();
+        this.$highlightTags();
         this.$updateHighlightActiveLine();
-        this._emit("changeSelection");
+        this._signal("changeSelection");
     };
 
     this.$updateHighlightActiveLine = function() {
@@ -488,17 +743,22 @@ var Editor = function(renderer, session) {
         if (this.$highlightActiveLine) {
             if ((this.$selectionStyle != "line" || !this.selection.isMultiLine()))
                 highlight = this.getCursorPosition();
+            if (this.renderer.$maxLines && this.session.getLength() === 1 && !(this.renderer.$minLines > 1))
+                highlight = false;
         }
 
         if (session.$highlightLineMarker && !highlight) {
             session.removeMarker(session.$highlightLineMarker.id);
-        session.$highlightLineMarker = null;
+            session.$highlightLineMarker = null;
         } else if (!session.$highlightLineMarker && highlight) {
-            session.$highlightLineMarker = session.highlightLines(highlight.row, highlight.row, "ace_active-line");
+            var range = new Range(highlight.row, highlight.column, highlight.row, Infinity);
+            range.id = session.addMarker(range, "ace_active-line", "screenLine");
+            session.$highlightLineMarker = range;
         } else if (highlight) {
             session.$highlightLineMarker.start.row = highlight.row;
             session.$highlightLineMarker.end.row = highlight.row;
-            session._emit("changeBackMarker");
+            session.$highlightLineMarker.start.column = highlight.column;
+            session._signal("changeBackMarker");
         }
     };
 
@@ -518,10 +778,10 @@ var Editor = function(renderer, session) {
             this.$updateHighlightActiveLine();
         }
 
-        var re = this.$highlightSelectedWord && this.$getSelectionHighLightRegexp()
+        var re = this.$highlightSelectedWord && this.$getSelectionHighLightRegexp();
         this.session.highlight(re);
-        
-        this._emit("changeSelection");
+
+        this._signal("changeSelection");
     };
 
     this.$getSelectionHighLightRegexp = function() {
@@ -575,8 +835,9 @@ var Editor = function(renderer, session) {
     };
 
 
-    this.onChangeMode = function() {
+    this.onChangeMode = function(e) {
         this.renderer.updateText();
+        this._emit("changeMode", e);
     };
 
 
@@ -597,25 +858,29 @@ var Editor = function(renderer, session) {
         this.renderer.updateFull();
     };
 
+    
+    /**
+     * Returns the string of text currently highlighted.
+     * @returns {String}
+     **/
+    this.getSelectedText = function() {
+        return this.session.getTextRange(this.getSelectionRange());
+    };
+    
     /**
      * Emitted when text is copied.
-     * @event copy 
+     * @event copy
      * @param {String} text The copied text
      *
-     * 
      **/
     /**
-     *
      * Returns the string of text currently highlighted.
      * @returns {String}
+     * @deprecated Use getSelectedText instead.
      **/
-
     this.getCopyText = function() {
-        var text = "";
-        if (!this.selection.isEmpty())
-            text = this.session.getTextRange(this.getSelectionRange());
-
-        this._emit("copy", text);
+        var text = this.getSelectedText();
+        this._signal("copy", text);
         return text;
     };
 
@@ -636,7 +901,7 @@ var Editor = function(renderer, session) {
     /**
      * Emitted when text is pasted.
      * @event paste
-     * @param {String} text The pasted text
+     * @param {Object} an object which contains one property, `text`, that represents the text to be pasted. Editing this property will alter the text that is pasted.
      *
      *
      **/
@@ -648,40 +913,66 @@ var Editor = function(renderer, session) {
      **/
     this.onPaste = function(text) {
         // todo this should change when paste becomes a command
-        if (this.$readOnly) 
+        if (this.$readOnly)
             return;
-        this._emit("paste", text);
-        this.insert(text);
-    };
 
+        var e = {text: text};
+        this._signal("paste", e);
+        text = e.text;
+        if (!this.inMultiSelectMode || this.inVirtualSelectionMode) {
+            this.insert(text);
+        } else {
+            var lines = text.split(/\r\n|\r|\n/);
+            var ranges = this.selection.rangeList.ranges;
+    
+            if (lines.length > ranges.length || lines.length < 2 || !lines[1])
+                return this.commands.exec("insertstring", this, text);
+    
+            for (var i = ranges.length; i--;) {
+                var range = ranges[i];
+                if (!range.isEmpty())
+                    this.session.remove(range);
+    
+                this.session.insert(range.start, lines[i]);
+            }
+        }
+        this.renderer.scrollCursorIntoView();
+    };
 
     this.execCommand = function(command, args) {
-        this.commands.exec(command, this, args);
+        return this.commands.exec(command, this, args);
     };
 
     /**
      * Inserts `text` into wherever the cursor is pointing.
      * @param {String} text The new text to add
-     * 
-     * 
+     *
      **/
-    this.insert = function(text) {
+    this.insert = function(text, pasted) {
         var session = this.session;
         var mode = session.getMode();
         var cursor = this.getCursorPosition();
 
-        if (this.getBehavioursEnabled()) {
+        if (this.getBehavioursEnabled() && !pasted) {
             // Get a transform if the current mode wants one.
             var transform = mode.transformAction(session.getState(cursor.row), 'insertion', this, session, text);
-            if (transform)
+            if (transform) {
+                if (text !== transform.text) {
+                    this.session.mergeUndoDeltas = false;
+                    this.$mergeNextCommand = false;
+                }
                 text = transform.text;
-        }
 
-        text = text.replace("\t", this.session.getTabString());
+            }
+        }
+        
+        if (text == "\t")
+            text = this.session.getTabString();
 
         // remove selected text
         if (!this.selection.isEmpty()) {
-            cursor = this.session.remove(this.getSelectionRange());
+            var range = this.getSelectionRange();
+            cursor = this.session.remove(range);
             this.clearSelection();
         }
         else if (this.session.getOverwrite()) {
@@ -690,6 +981,13 @@ var Editor = function(renderer, session) {
             this.session.remove(range);
         }
 
+        if (text == "\n" || text == "\r\n") {
+            var line = session.getLine(cursor.row);
+            if (cursor.column > line.search(/\S|$/)) {
+                var d = line.substr(cursor.column).search(/\S|$/);
+                session.doc.removeInLine(cursor.row, cursor.column, cursor.column + d);
+            }
+        }
         this.clearSelection();
 
         var start = cursor.column;
@@ -712,44 +1010,10 @@ var Editor = function(renderer, session) {
             }
         }
 
-        // TODO disabled multiline auto indent
-        // possibly doing the indent before inserting the text
-        // if (cursor.row !== end.row) {
         if (session.getDocument().isNewLine(text)) {
             var lineIndent = mode.getNextLineIndent(lineState, line.slice(0, cursor.column), session.getTabString());
 
-            this.moveCursorTo(cursor.row+1, 0);
-
-            var size = session.getTabSize();
-            var minIndent = Number.MAX_VALUE;
-
-            for (var row = cursor.row + 1; row <= end.row; ++row) {
-                var indent = 0;
-
-                line = session.getLine(row);
-                for (var i = 0; i < line.length; ++i)
-                    if (line.charAt(i) == '\t')
-                        indent += size;
-                    else if (line.charAt(i) == ' ')
-                        indent += 1;
-                    else
-                        break;
-                if (/[^\s]/.test(line))
-                    minIndent = Math.min(indent, minIndent);
-            }
-
-            for (var row = cursor.row + 1; row <= end.row; ++row) {
-                var outdent = minIndent;
-
-                line = session.getLine(row);
-                for (var i = 0; i < line.length && outdent > 0; ++i)
-                    if (line.charAt(i) == '\t')
-                        outdent -= size;
-                    else if (line.charAt(i) == ' ')
-                        outdent -= 1;
-                session.remove(new Range(row, 0, row, i));
-            }
-            session.indentRows(cursor.row + 1, end.row, lineIndent);
+            session.insert({row: cursor.row+1, column: 0}, lineIndent);
         }
         if (shouldOutdent)
             mode.autoOutdent(lineState, session, cursor.row);
@@ -763,10 +1027,10 @@ var Editor = function(renderer, session) {
         this.keyBinding.onCommandKey(e, hashId, keyCode);
     };
 
-    /** 
+    /**
      * Pass in `true` to enable overwrites in your session, or `false` to disable. If overwrites is enabled, any text you enter will type over any text after it. If the value of `overwrite` changes, this function also emites the `changeOverwrite` event.
      * @param {Boolean} overwrite Defines wheter or not to set overwrites
-     * 
+     *
      *
      * @related EditSession.setOverwrite
      **/
@@ -774,7 +1038,7 @@ var Editor = function(renderer, session) {
         this.session.setOverwrite(overwrite);
     };
 
-    /** 
+    /**
      * Returns `true` if overwrites are enabled; `false` otherwise.
      * @returns {Boolean}
      * @related EditSession.getOverwrite
@@ -783,7 +1047,7 @@ var Editor = function(renderer, session) {
         return this.session.getOverwrite();
     };
 
-    /**  
+    /**
      * Sets the value of overwrite to the opposite of whatever it currently is.
      * @related EditSession.toggleOverwrite
      **/
@@ -793,32 +1057,26 @@ var Editor = function(renderer, session) {
 
     /**
      * Sets how fast the mouse scrolling should do.
-     * @param {Number} speed A value indicating the new speed
-     * 
-     * 
-     *
+     * @param {Number} speed A value indicating the new speed (in milliseconds)
      **/
     this.setScrollSpeed = function(speed) {
-        this.$mouseHandler.setScrollSpeed(speed);
+        this.setOption("scrollSpeed", speed);
     };
 
     /**
-     * Returns the value indicating how fast the mouse scroll speed is.
+     * Returns the value indicating how fast the mouse scroll speed is (in milliseconds).
      * @returns {Number}
      **/
     this.getScrollSpeed = function() {
-        return this.$mouseHandler.getScrollSpeed();
+        return this.getOption("scrollSpeed");
     };
 
     /**
      * Sets the delay (in milliseconds) of the mouse drag.
      * @param {Number} dragDelay A value indicating the new delay
-     * 
-     * 
-     *
      **/
     this.setDragDelay = function(dragDelay) {
-        this.$mouseHandler.setDragDelay(dragDelay);
+        this.setOption("dragDelay", dragDelay);
     };
 
     /**
@@ -826,34 +1084,21 @@ var Editor = function(renderer, session) {
      * @returns {Number}
      **/
     this.getDragDelay = function() {
-        return this.$mouseHandler.getDragDelay();
+        return this.getOption("dragDelay");
     };
 
-    this.$selectionStyle = "line";
-
     /**
      * Emitted when the selection style changes, via [[Editor.setSelectionStyle]].
      * @event changeSelectionStyle
      * @param {Object} data Contains one property, `data`, which indicates the new selection style
-     *
-     *
-     * 
      **/
     /**
-     * Indicates how selections should occur.  
-     * 
-     * By default, selections are set to "line". This function also emits the `'changeSelectionStyle'` event.
+     * Draw selection markers spanning whole line, or only over selected text. Default value is "line"
+     * @param {String} style The new selection style "line"|"text"
      *
-     * @param {String} style The new selection style
-     *
-     * 
      **/
-    this.setSelectionStyle = function(style) {
-        if (this.$selectionStyle == style) return;
-
-        this.$selectionStyle = style;
-        this.onSelectionChange();
-        this._emit("changeSelectionStyle", {data: style});
+    this.setSelectionStyle = function(val) {
+        this.setOption("selectionStyle", val);
     };
 
     /**
@@ -861,60 +1106,38 @@ var Editor = function(renderer, session) {
      * @returns {String}
      **/
     this.getSelectionStyle = function() {
-        return this.$selectionStyle;
+        return this.getOption("selectionStyle");
     };
 
-    this.$highlightActiveLine = true;
-
     /**
      * Determines whether or not the current line should be highlighted.
      * @param {Boolean} shouldHighlight Set to `true` to highlight the current line
-     *
-     *
-     *
      **/
     this.setHighlightActiveLine = function(shouldHighlight) {
-        if (this.$highlightActiveLine == shouldHighlight)
-            return;
-
-        this.$highlightActiveLine = shouldHighlight;
-        this.$updateHighlightActiveLine();
+        this.setOption("highlightActiveLine", shouldHighlight);
     };
-
     /**
      * Returns `true` if current lines are always highlighted.
-     * @return Boolean
+     * @return {Boolean}
      **/
     this.getHighlightActiveLine = function() {
-        return this.$highlightActiveLine;
+        return this.getOption("highlightActiveLine");
     };
-
-    this.$highlightGutterLine = true;
     this.setHighlightGutterLine = function(shouldHighlight) {
-        if (this.$highlightGutterLine == shouldHighlight)
-            return;
-
-        this.renderer.setHighlightGutterLine(shouldHighlight);
-        this.$highlightGutterLine = shouldHighlight;
+        this.setOption("highlightGutterLine", shouldHighlight);
     };
 
     this.getHighlightGutterLine = function() {
-        return this.$highlightGutterLine;
+        return this.getOption("highlightGutterLine");
     };
 
-    this.$highlightSelectedWord = true;
     /**
      * Determines if the currently selected word should be highlighted.
      * @param {Boolean} shouldHighlight Set to `true` to highlight the currently selected word
      *
-     *
      **/
     this.setHighlightSelectedWord = function(shouldHighlight) {
-        if (this.$highlightSelectedWord == shouldHighlight)
-            return;
-
-        this.$highlightSelectedWord = shouldHighlight;
-        this.$onSelectionChange();
+        this.setOption("highlightSelectedWord", shouldHighlight);
     };
 
     /**
@@ -934,10 +1157,9 @@ var Editor = function(renderer, session) {
     };
 
     /**
-     * If `showInvisibiles` is set to `true`, invisible characters&mdash;like spaces or new lines&mdash;are show in the editor.
+     * If `showInvisibles` is set to `true`, invisible characters&mdash;like spaces or new lines&mdash;are show in the editor.
      * @param {Boolean} showInvisibles Specifies whether or not to show invisible characters
-     * 
-     * 
+     *
      **/
     this.setShowInvisibles = function(showInvisibles) {
         this.renderer.setShowInvisibles(showInvisibles);
@@ -962,8 +1184,7 @@ var Editor = function(renderer, session) {
     /**
      * If `showPrintMargin` is set to `true`, the print margin is shown in the editor.
      * @param {Boolean} showPrintMargin Specifies whether or not to show the print margin
-     * 
-     * 
+     *
      **/
     this.setShowPrintMargin = function(showPrintMargin) {
         this.renderer.setShowPrintMargin(showPrintMargin);
@@ -981,8 +1202,6 @@ var Editor = function(renderer, session) {
      * Sets the column defining where the print margin should be.
      * @param {Number} showPrintMargin Specifies the new print margin
      *
-     *
-     * 
      **/
     this.setPrintMarginColumn = function(showPrintMargin) {
         this.renderer.setPrintMarginColumn(showPrintMargin);
@@ -996,15 +1215,13 @@ var Editor = function(renderer, session) {
         return this.renderer.getPrintMarginColumn();
     };
 
-    this.$readOnly = false;
     /**
      * If `readOnly` is true, then the editor is set to read-only mode, and none of the content can change.
      * @param {Boolean} readOnly Specifies whether the editor can be modified or not
-     * 
-     * 
+     *
      **/
     this.setReadOnly = function(readOnly) {
-        this.$readOnly = readOnly;
+        this.setOption("readOnly", readOnly);
     };
 
     /**
@@ -1012,87 +1229,71 @@ var Editor = function(renderer, session) {
      * @returns {Boolean}
      **/
     this.getReadOnly = function() {
-        return this.$readOnly;
+        return this.getOption("readOnly");
     };
 
-    this.$modeBehaviours = true;
-
     /**
      * Specifies whether to use behaviors or not. ["Behaviors" in this case is the auto-pairing of special characters, like quotation marks, parenthesis, or brackets.]{: #BehaviorsDef}
      * @param {Boolean} enabled Enables or disables behaviors
-     * 
-     * 
+     *
      **/
     this.setBehavioursEnabled = function (enabled) {
-        this.$modeBehaviours = enabled;
+        this.setOption("behavioursEnabled", enabled);
     };
 
     /**
      * Returns `true` if the behaviors are currently enabled. {:BehaviorsDef}
-     * 
+     *
      * @returns {Boolean}
      **/
     this.getBehavioursEnabled = function () {
-        return this.$modeBehaviours;
+        return this.getOption("behavioursEnabled");
     };
 
-    this.$modeWrapBehaviours = true;
-
     /**
-     * Editor.setWrapBehavioursEnabled(enabled) 
-     * - enabled (Boolean): Enables or disables wrapping behaviors
-     * 
      * Specifies whether to use wrapping behaviors or not, i.e. automatically wrapping the selection with characters such as brackets
      * when such a character is typed in.
+     * @param {Boolean} enabled Enables or disables wrapping behaviors
+     *
      **/
     this.setWrapBehavioursEnabled = function (enabled) {
-        this.$modeWrapBehaviours = enabled;
+        this.setOption("wrapBehavioursEnabled", enabled);
     };
 
     /**
      * Returns `true` if the wrapping behaviors are currently enabled.
      **/
     this.getWrapBehavioursEnabled = function () {
-        return this.$modeWrapBehaviours;
+        return this.getOption("wrapBehavioursEnabled");
     };
 
     /**
-     * Indicates whether the fold widgets are shown or not.
+     * Indicates whether the fold widgets should be shown or not.
      * @param {Boolean} show Specifies whether the fold widgets are shown
-     * 
-     * 
      **/
     this.setShowFoldWidgets = function(show) {
-        var gutter = this.renderer.$gutterLayer;
-        if (gutter.getShowFoldWidgets() == show)
-            return;
+        this.setOption("showFoldWidgets", show);
 
-        this.renderer.$gutterLayer.setShowFoldWidgets(show);
-        this.$showFoldWidgets = show;
-        this.renderer.updateFull();
     };
-
     /**
      * Returns `true` if the fold widgets are shown.
-     * @return Boolean
+     * @return {Boolean}
      **/
     this.getShowFoldWidgets = function() {
-        return this.renderer.$gutterLayer.getShowFoldWidgets();
+        return this.getOption("showFoldWidgets");
     };
 
-    this.setFadeFoldWidgets = function(show) {
-        this.renderer.setFadeFoldWidgets(show);
+    this.setFadeFoldWidgets = function(fade) {
+        this.setOption("fadeFoldWidgets", fade);
     };
 
     this.getFadeFoldWidgets = function() {
-        return this.renderer.getFadeFoldWidgets();
+        return this.getOption("fadeFoldWidgets");
     };
 
     /**
-     * Removes words of text from the editor. A "word" is defined as a string of characters bookended by whitespace.
+     * Removes the current selection or one character.
      * @param {String} dir The direction of the deletion to occur, either "left" or "right"
-     * 
-     * 
      *
      **/
     this.remove = function(dir) {
@@ -1108,6 +1309,16 @@ var Editor = function(renderer, session) {
             var session = this.session;
             var state = session.getState(range.start.row);
             var new_range = session.getMode().transformAction(state, 'deletion', this, session, range);
+
+            if (range.end.column === 0) {
+                var text = session.getTextRange(range);
+                if (text[text.length - 1] == "\n") {
+                    var line = session.getLine(range.end.row);
+                    if (/^\s+$/.test(line)) {
+                        range.end.column = line.length;
+                    }
+                }
+            }
             if (new_range)
                 range = new_range;
         }
@@ -1236,35 +1447,58 @@ var Editor = function(renderer, session) {
         this.selection.setSelectionRange(originalRange);
     };
 
-    /** 
-     * Indents the current line.
-     * 
+    /**
+     * Inserts an indentation into the current cursor position or indents the selected lines.
+     *
      * @related EditSession.indentRows
      **/
     this.indent = function() {
         var session = this.session;
         var range = this.getSelectionRange();
 
-        if (range.start.row < range.end.row || range.start.column < range.end.column) {
+        if (range.start.row < range.end.row) {
             var rows = this.$getSelectedRows();
             session.indentRows(rows.first, rows.last, "\t");
+            return;
+        } else if (range.start.column < range.end.column) {
+            var text = session.getTextRange(range);
+            if (!/^\s+$/.test(text)) {
+                var rows = this.$getSelectedRows();
+                session.indentRows(rows.first, rows.last, "\t");
+                return;
+            }
+        }
+        
+        var line = session.getLine(range.start.row);
+        var position = range.start;
+        var size = session.getTabSize();
+        var column = session.documentToScreenColumn(position.row, position.column);
+
+        if (this.session.getUseSoftTabs()) {
+            var count = (size - column % size);
+            var indentString = lang.stringRepeat(" ", count);
         } else {
-            var indentString;
-
-            if (this.session.getUseSoftTabs()) {
-                var size        = session.getTabSize(),
-                    position    = this.getCursorPosition(),
-                    column      = session.documentToScreenColumn(position.row, position.column),
-                    count       = (size - column % size);
-
-                indentString = lang.stringRepeat(" ", count);
-            } else
-                indentString = "\t";
-            return this.insert(indentString);
+            var count = column % size;
+            while (line[range.start.column] == " " && count) {
+                range.start.column--;
+                count--;
+            }
+            this.selection.setSelectionRange(range);
+            indentString = "\t";
         }
+        return this.insert(indentString);
     };
 
-    /**  
+    /**
+     * Indents the current line.
+     * @related EditSession.indentRows
+     **/
+    this.blockIndent = function() {
+        var rows = this.$getSelectedRows();
+        this.session.indentRows(rows.first, rows.last, "\t");
+    };
+
+    /**
      * Outdents the current line.
      * @related EditSession.outdentRows
      **/
@@ -1299,7 +1533,6 @@ var Editor = function(renderer, session) {
     };
 
     /**
-     * 
      * Given the currently selected range, this function either comments all the lines, or uncomments all of them.
      **/
     this.toggleCommentLines = function() {
@@ -1308,35 +1541,40 @@ var Editor = function(renderer, session) {
         this.session.getMode().toggleCommentLines(state, this.session, rows.first, rows.last);
     };
 
+    this.toggleBlockComment = function() {
+        var cursor = this.getCursorPosition();
+        var state = this.session.getState(cursor.row);
+        var range = this.getSelectionRange();
+        this.session.getMode().toggleBlockComment(state, this.session, range, cursor);
+    };
+
     /**
      * Works like [[EditSession.getTokenAt]], except it returns a number.
      * @returns {Number}
      **/
-    this.getNumberAt = function( row, column ) {
-        var _numberRx = /[\-]?[0-9]+(?:\.[0-9]+)?/g
-        _numberRx.lastIndex = 0
+    this.getNumberAt = function(row, column) {
+        var _numberRx = /[\-]?[0-9]+(?:\.[0-9]+)?/g;
+        _numberRx.lastIndex = 0;
 
-        var s = this.session.getLine(row)
-        while(_numberRx.lastIndex < column - 1 ){
-            var m = _numberRx.exec(s)
+        var s = this.session.getLine(row);
+        while (_numberRx.lastIndex < column) {
+            var m = _numberRx.exec(s);
             if(m.index <= column && m.index+m[0].length >= column){
                 var number = {
                     value: m[0],
                     start: m.index,
                     end: m.index+m[0].length
-
-                }
-                return number
+                };
+                return number;
             }
         }
         return null;
     };
-    
+
     /**
-     * Editor.modifyNumber(amount) 
+     * If the character before the cursor is a number, this functions changes its value by `amount`.
      * @param {Number} amount The value to change the numeral by (can be negative to decrease value)
      *
-     * If the character before the cursor is a number, this functions changes its value by `amount`.
      **/
     this.modifyNumber = function(amount) {
         var row = this.selection.getCursor().row;
@@ -1357,14 +1595,14 @@ var Editor = function(renderer, session) {
 
                 var t = parseFloat(nr.value);
                 t *= Math.pow(10, decimals);
-                
+
 
                 if(fp !== nr.end && column < fp){
                     amount *= Math.pow(10, nr.end - column - 1);
                 } else {
                     amount *= Math.pow(10, nr.end - column);
                 }
-                
+
                 t += amount;
                 t /= Math.pow(10, decimals);
                 var nnr = t.toFixed(decimals);
@@ -1379,8 +1617,8 @@ var Editor = function(renderer, session) {
             }
         }
     };
-    
-    /** 
+
+    /**
      * Removes all the lines in the current selection
      * @related EditSession.remove
      **/
@@ -1402,128 +1640,143 @@ var Editor = function(renderer, session) {
         var sel = this.selection;
         var doc = this.session;
         var range = sel.getRange();
+        var reverse = sel.isBackwards();
         if (range.isEmpty()) {
             var row = range.start.row;
             doc.duplicateLines(row, row);
         } else {
-            var reverse = sel.isBackwards()
-            var point = sel.isBackwards() ? range.start : range.end;
+            var point = reverse ? range.start : range.end;
             var endPoint = doc.insert(point, doc.getTextRange(range), false);
             range.start = point;
             range.end = endPoint;
-            
-            sel.setSelectionRange(range, reverse)
+
+            sel.setSelectionRange(range, reverse);
         }
     };
-    
-    /** 
+
+    /**
      * Shifts all the selected lines down one row.
      *
      * @returns {Number} On success, it returns -1.
      * @related EditSession.moveLinesUp
      **/
     this.moveLinesDown = function() {
-        this.$moveLines(function(firstRow, lastRow) {
-            return this.session.moveLinesDown(firstRow, lastRow);
-        });
+        this.$moveLines(1, false);
     };
 
-    /** 
+    /**
      * Shifts all the selected lines up one row.
      * @returns {Number} On success, it returns -1.
      * @related EditSession.moveLinesDown
      **/
     this.moveLinesUp = function() {
-        this.$moveLines(function(firstRow, lastRow) {
-            return this.session.moveLinesUp(firstRow, lastRow);
-        });
+        this.$moveLines(-1, false);
     };
 
-    /** 
+    /**
      * Moves a range of text from the given range to the given position. `toPosition` is an object that looks like this:
      * ```json
      *    { row: newRowLocation, column: newColumnLocation }
      * ```
      * @param {Range} fromRange The range of text you want moved within the document
      * @param {Object} toPosition The location (row and column) where you want to move the text to
-     * 
+     *
      * @returns {Range} The new range where the text was moved to.
      * @related EditSession.moveText
      **/
-    this.moveText = function(range, toPosition) {
-        if (this.$readOnly)
-            return null;
-
-        return this.session.moveText(range, toPosition);
+    this.moveText = function(range, toPosition, copy) {
+        return this.session.moveText(range, toPosition, copy);
     };
 
-    /** 
+    /**
      * Copies all the selected lines up one row.
      * @returns {Number} On success, returns 0.
-     * 
+     *
      **/
     this.copyLinesUp = function() {
-        this.$moveLines(function(firstRow, lastRow) {
-            this.session.duplicateLines(firstRow, lastRow);
-            return 0;
-        });
+        this.$moveLines(-1, true);
     };
 
-    /** 
+    /**
      * Copies all the selected lines down one row.
      * @returns {Number} On success, returns the number of new rows added; in other words, `lastRow - firstRow + 1`.
      * @related EditSession.duplicateLines
      *
      **/
     this.copyLinesDown = function() {
-        this.$moveLines(function(firstRow, lastRow) {
-            return this.session.duplicateLines(firstRow, lastRow);
-        });
+        this.$moveLines(1, true);
     };
 
-
     /**
-     * Executes a specific function, which can be anything that manipulates selected lines, such as copying them, duplicating them, or shifting them.
-     * @param {Function} mover A method to call on each selected row
-     * 
+     * for internal use
+     * @ignore
      *
      **/
-    this.$moveLines = function(mover) {
-        var rows = this.$getSelectedRows();
+    this.$moveLines = function(dir, copy) {
+        var rows, moved;
         var selection = this.selection;
-        if (!selection.isMultiLine()) {
-            var range = selection.getRange();
-            var reverse = selection.isBackwards();
-        }
-
-        var linesMoved = mover.call(this, rows.first, rows.last);
-
-        if (range) {
-            range.start.row += linesMoved;
-            range.end.row += linesMoved;
-            selection.setSelectionRange(range, reverse);
-        }
-        else {
-            selection.setSelectionAnchor(rows.last+linesMoved+1, 0);
-            selection.$moveSelection(function() {
-                selection.moveCursorTo(rows.first+linesMoved, 0);
-            });
+        if (!selection.inMultiSelectMode || this.inVirtualSelectionMode) {
+            var range = selection.toOrientedRange();
+            rows = this.$getSelectedRows(range);
+            moved = this.session.$moveLines(rows.first, rows.last, copy ? 0 : dir);
+            if (copy && dir == -1) moved = 0;
+            range.moveBy(moved, 0);
+            selection.fromOrientedRange(range);
+        } else {
+            var ranges = selection.rangeList.ranges;
+            selection.rangeList.detach(this.session);
+            this.inVirtualSelectionMode = true;
+            
+            var diff = 0;
+            var totalDiff = 0;
+            var l = ranges.length;
+            for (var i = 0; i < l; i++) {
+                var rangeIndex = i;
+                ranges[i].moveBy(diff, 0);
+                rows = this.$getSelectedRows(ranges[i]);
+                var first = rows.first;
+                var last = rows.last;
+                while (++i < l) {
+                    if (totalDiff) ranges[i].moveBy(totalDiff, 0);
+                    var subRows = this.$getSelectedRows(ranges[i]);
+                    if (copy && subRows.first != last)
+                        break;
+                    else if (!copy && subRows.first > last + 1)
+                        break;
+                    last = subRows.last;
+                }
+                i--;
+                diff = this.session.$moveLines(first, last, copy ? 0 : dir);
+                if (copy && dir == -1) rangeIndex = i + 1;
+                while (rangeIndex <= i) {
+                    ranges[rangeIndex].moveBy(diff, 0);
+                    rangeIndex++;
+                }
+                if (!copy) diff = 0;
+                totalDiff += diff;
+            }
+            
+            selection.fromOrientedRange(selection.ranges[0]);
+            selection.rangeList.attach(this.session);
+            this.inVirtualSelectionMode = false;
         }
     };
 
     /**
      * Returns an object indicating the currently selected rows. The object looks like this:
+     *
      * ```json
      * { first: range.start.row, last: range.end.row }
      * ```
+     *
      * @returns {Object}
      **/
-    this.$getSelectedRows = function() {
-        var range = this.getSelectionRange().collapseRows();
+    this.$getSelectedRows = function(range) {
+        range = (range || this.getSelectionRange()).collapseRows();
 
         return {
-            first: range.start.row,
-            last: range.end.row
+            first: this.session.getRowFoldStart(range.start.row),
+            last: this.session.getRowFoldEnd(range.end.row)
         };
     };
 
@@ -1539,8 +1792,9 @@ var Editor = function(renderer, session) {
         this.renderer.hideComposition();
     };
 
-    /** 
+    /**
      * {:VirtualRenderer.getFirstVisibleRow}
+     *
      * @returns {Number}
      * @related VirtualRenderer.getFirstVisibleRow
      **/
@@ -1548,8 +1802,9 @@ var Editor = function(renderer, session) {
         return this.renderer.getFirstVisibleRow();
     };
 
-    /** 
+    /**
      * {:VirtualRenderer.getLastVisibleRow}
+     *
      * @returns {Number}
      * @related VirtualRenderer.getLastVisibleRow
      **/
@@ -1560,7 +1815,7 @@ var Editor = function(renderer, session) {
     /**
      * Indicates if the row is currently visible on the screen.
      * @param {Number} row The row to check
-     * 
+     *
      * @returns {Boolean}
      **/
     this.isRowVisible = function(row) {
@@ -1570,8 +1825,8 @@ var Editor = function(renderer, session) {
     /**
      * Indicates if the entire row is currently visible on the screen.
      * @param {Number} row The row to check
-     * 
-     * 
+     *
+     *
      * @returns {Boolean}
      **/
     this.isRowFullyVisible = function(row) {
@@ -1592,11 +1847,11 @@ var Editor = function(renderer, session) {
         var rows = dir * Math.floor(config.height / config.lineHeight);
 
         this.$blockScrolling++;
-        if (select == true) {
+        if (select === true) {
             this.selection.$moveSelection(function(){
                 this.moveCursorBy(rows, 0);
             });
-        } else if (select == false) {
+        } else if (select === false) {
             this.selection.moveCursorBy(rows, 0);
             this.selection.clearSelection();
         }
@@ -1653,7 +1908,7 @@ var Editor = function(renderer, session) {
         this.$moveByPage(-1);
     };
 
-    /** 
+    /**
      * Moves the editor to the specified row.
      * @related VirtualRenderer.scrollToRow
      **/
@@ -1661,14 +1916,14 @@ var Editor = function(renderer, session) {
         this.renderer.scrollToRow(row);
     };
 
-    /** 
+    /**
      * Scrolls to a line. If `center` is `true`, it puts the line in middle of screen (or attempts to).
      * @param {Number} line The line to scroll to
-     * @param {Boolean} center If `true` 
+     * @param {Boolean} center If `true`
      * @param {Boolean} animate If `true` animates scrolling
      * @param {Function} callback Function to be called when the animation has finished
      *
-     * 
+     *
      * @related VirtualRenderer.scrollToLine
      **/
     this.scrollToLine = function(line, center, animate, callback) {
@@ -1683,13 +1938,14 @@ var Editor = function(renderer, session) {
         var pos = {
             row: Math.floor(range.start.row + (range.end.row - range.start.row) / 2),
             column: Math.floor(range.start.column + (range.end.column - range.start.column) / 2)
-        }
+        };
         this.renderer.alignCursor(pos, 0.5);
     };
 
-    /** 
+    /**
      * Gets the current position of the cursor.
-     * @returns {Object} An object that looks something like this:  
+     * @returns {Object} An object that looks something like this:
+     *
      * ```json
      * { row: currRow, column: currCol }
      * ```
@@ -1700,7 +1956,7 @@ var Editor = function(renderer, session) {
         return this.selection.getCursor();
     };
 
-    /** 
+    /**
      * Returns the screen position of the cursor.
      * @returns {Number}
      * @related EditSession.documentToScreenPosition
@@ -1709,7 +1965,7 @@ var Editor = function(renderer, session) {
         return this.session.documentToScreenPosition(this.getCursorPosition());
     };
 
-    /** 
+    /**
      * {:Selection.getRange}
      * @returns {Range}
      * @related Selection.getRange
@@ -1719,7 +1975,7 @@ var Editor = function(renderer, session) {
     };
 
 
-    /** 
+    /**
      * Selects all the text in editor.
      * @related Selection.selectAll
      **/
@@ -1729,7 +1985,7 @@ var Editor = function(renderer, session) {
         this.$blockScrolling -= 1;
     };
 
-    /** 
+    /**
      * {:Selection.clearSelection}
      * @related Selection.clearSelection
      **/
@@ -1737,7 +1993,7 @@ var Editor = function(renderer, session) {
         this.selection.clearSelection();
     };
 
-    /** 
+    /**
      * Moves the cursor to the specified row and column. Note that this does not de-select the current selection.
      * @param {Number} row The new row number
      * @param {Number} column The new column number
@@ -1749,10 +2005,10 @@ var Editor = function(renderer, session) {
         this.selection.moveCursorTo(row, column);
     };
 
-    /** 
+    /**
      * Moves the cursor to the position indicated by `pos.row` and `pos.column`.
      * @param {Object} pos An object with two properties, row and column
-     * 
+     *
      *
      * @related Selection.moveCursorToPosition
      **/
@@ -1760,37 +2016,169 @@ var Editor = function(renderer, session) {
         this.selection.moveCursorToPosition(pos);
     };
 
-    /** 
-     * Moves the cursor's row and column to the next matching bracket.
+    /**
+     * Moves the cursor's row and column to the next matching bracket or HTML tag.
      *
      **/
-    this.jumpToMatching = function(select) {
+    this.jumpToMatching = function(select, expand) {
         var cursor = this.getCursorPosition();
+        var iterator = new TokenIterator(this.session, cursor.row, cursor.column);
+        var prevToken = iterator.getCurrentToken();
+        var token = prevToken || iterator.stepForward();
+
+        if (!token) return;
+
+        //get next closing tag or bracket
+        var matchType;
+        var found = false;
+        var depth = {};
+        var i = cursor.column - token.start;
+        var bracketType;
+        var brackets = {
+            ")": "(",
+            "(": "(",
+            "]": "[",
+            "[": "[",
+            "{": "{",
+            "}": "{"
+        };
+        
+        do {
+            if (token.value.match(/[{}()\[\]]/g)) {
+                for (; i < token.value.length && !found; i++) {
+                    if (!brackets[token.value[i]]) {
+                        continue;
+                    }
+
+                    bracketType = brackets[token.value[i]] + '.' + token.type.replace("rparen", "lparen");
+
+                    if (isNaN(depth[bracketType])) {
+                        depth[bracketType] = 0;
+                    }
+
+                    switch (token.value[i]) {
+                        case '(':
+                        case '[':
+                        case '{':
+                            depth[bracketType]++;
+                            break;
+                        case ')':
+                        case ']':
+                        case '}':
+                            depth[bracketType]--;
+
+                            if (depth[bracketType] === -1) {
+                                matchType = 'bracket';
+                                found = true;
+                            }
+                        break;
+                    }
+                }
+            }
+            else if (token && token.type.indexOf('tag-name') !== -1) {
+                if (isNaN(depth[token.value])) {
+                    depth[token.value] = 0;
+                }
+                
+                if (prevToken.value === '<') {
+                    depth[token.value]++;
+                }
+                else if (prevToken.value === '</') {
+                    depth[token.value]--;
+                }
+                
+                if (depth[token.value] === -1) {
+                    matchType = 'tag';
+                    found = true;
+                }
+            }
 
-        var range = this.session.getBracketRange(cursor);
-        if (!range) {
-            range = this.find({
-                needle: /[{}()\[\]]/g,
-                preventScroll:true,
-                start: {row: cursor.row, column: cursor.column - 1}
-            });
-            if (!range)
+            if (!found) {
+                prevToken = token;
+                token = iterator.stepForward();
+                i = 0;
+            }
+        } while (token && !found);
+
+        //no match found
+        if (!matchType)
+            return;
+
+        var range, pos;
+        if (matchType === 'bracket') {
+            range = this.session.getBracketRange(cursor);
+            if (!range) {
+                range = new Range(
+                    iterator.getCurrentTokenRow(),
+                    iterator.getCurrentTokenColumn() + i - 1,
+                    iterator.getCurrentTokenRow(),
+                    iterator.getCurrentTokenColumn() + i - 1
+                );
+                pos = range.start;
+                if (expand || pos.row === cursor.row && Math.abs(pos.column - cursor.column) < 2)
+                    range = this.session.getBracketRange(pos);
+            }
+        }
+        else if (matchType === 'tag') {
+            if (token && token.type.indexOf('tag-name') !== -1) 
+                var tag = token.value;
+            else
                 return;
-            var pos = range.start;
-            if (pos.row == cursor.row && Math.abs(pos.column - cursor.column) < 2)
-                range = this.session.getBracketRange(pos);
+
+            range = new Range(
+                iterator.getCurrentTokenRow(),
+                iterator.getCurrentTokenColumn() - 2,
+                iterator.getCurrentTokenRow(),
+                iterator.getCurrentTokenColumn() - 2
+            );
+
+            //find matching tag
+            if (range.compare(cursor.row, cursor.column) === 0) {
+                found = false;
+                do {
+                    token = prevToken;
+                    prevToken = iterator.stepBackward();
+                    
+                    if (prevToken) {
+                        if (prevToken.type.indexOf('tag-close') !== -1) {
+                            range.setEnd(iterator.getCurrentTokenRow(), iterator.getCurrentTokenColumn() + 1);
+                        }
+
+                        if (token.value === tag && token.type.indexOf('tag-name') !== -1) {
+                            if (prevToken.value === '<') {
+                                depth[tag]++;
+                            }
+                            else if (prevToken.value === '</') {
+                                depth[tag]--;
+                            }
+                            
+                            if (depth[tag] === 0)
+                                found = true;
+                        }
+                    }
+                } while (prevToken && !found);
+            }
+
+            //we found it
+            if (token && token.type.indexOf('tag-name')) {
+                pos = range.start;
+                if (pos.row == cursor.row && Math.abs(pos.column - cursor.column) < 2)
+                    pos = range.end;
+            }
         }
-        
+
         pos = range && range.cursor || pos;
         if (pos) {
             if (select) {
-                if (range && range.isEqual(this.getSelectionRange()))
+                if (range && expand) {
+                    this.selection.setRange(range);
+                } else if (range && range.isEqual(this.getSelectionRange())) {
                     this.clearSelection();
-                else
+                } else {
                     this.selection.selectTo(pos.row, pos.column);
+                }
             } else {
-                this.clearSelection();
-                this.moveCursorTo(pos.row, pos.column);
+                this.selection.moveTo(pos.row, pos.column);
             }
         }
     };
@@ -1800,13 +2188,15 @@ var Editor = function(renderer, session) {
      * @param {Number} lineNumber The line number to go to
      * @param {Number} column A column number to go to
      * @param {Boolean} animate If `true` animates scolling
-     * 
+     *
      **/
     this.gotoLine = function(lineNumber, column, animate) {
         this.selection.clearSelection();
         this.session.unfold({row: lineNumber - 1, column: column || 0});
 
         this.$blockScrolling += 1;
+        // todo: find a way to automatically exit multiselect mode
+        this.exitMultiSelectMode && this.exitMultiSelectMode();
         this.moveCursorTo(lineNumber - 1, column || 0);
         this.$blockScrolling -= 1;
 
@@ -1814,7 +2204,7 @@ var Editor = function(renderer, session) {
             this.scrollToLine(lineNumber - 1, true, animate);
     };
 
-    /** 
+    /**
      * Moves the cursor to the specified row and column. Note that this does de-select the current selection.
      * @param {Number} row The new row number
      * @param {Number} column The new column number
@@ -1823,39 +2213,44 @@ var Editor = function(renderer, session) {
      * @related Editor.moveCursorTo
      **/
     this.navigateTo = function(row, column) {
-        this.clearSelection();
-        this.moveCursorTo(row, column);
+        this.selection.moveTo(row, column);
     };
 
     /**
      * Moves the cursor up in the document the specified number of times. Note that this does de-select the current selection.
      * @param {Number} times The number of times to change navigation
-     * 
-     * 
+     *
+     *
      **/
     this.navigateUp = function(times) {
+        if (this.selection.isMultiLine() && !this.selection.isBackwards()) {
+            var selectionStart = this.selection.anchor.getPosition();
+            return this.moveCursorToPosition(selectionStart);
+        }
         this.selection.clearSelection();
-        times = times || 1;
-        this.selection.moveCursorBy(-times, 0);
+        this.selection.moveCursorBy(-times || -1, 0);
     };
 
     /**
      * Moves the cursor down in the document the specified number of times. Note that this does de-select the current selection.
      * @param {Number} times The number of times to change navigation
-     * 
-     * 
+     *
+     *
      **/
     this.navigateDown = function(times) {
+        if (this.selection.isMultiLine() && this.selection.isBackwards()) {
+            var selectionEnd = this.selection.anchor.getPosition();
+            return this.moveCursorToPosition(selectionEnd);
+        }
         this.selection.clearSelection();
-        times = times || 1;
-        this.selection.moveCursorBy(times, 0);
+        this.selection.moveCursorBy(times || 1, 0);
     };
 
     /**
      * Moves the cursor left in the document the specified number of times. Note that this does de-select the current selection.
      * @param {Number} times The number of times to change navigation
-     * 
-     * 
+     *
+     *
      **/
     this.navigateLeft = function(times) {
         if (!this.selection.isEmpty()) {
@@ -1874,8 +2269,8 @@ var Editor = function(renderer, session) {
     /**
      * Moves the cursor right in the document the specified number of times. Note that this does de-select the current selection.
      * @param {Number} times The number of times to change navigation
-     * 
-     * 
+     *
+     *
      **/
     this.navigateRight = function(times) {
         if (!this.selection.isEmpty()) {
@@ -1892,7 +2287,7 @@ var Editor = function(renderer, session) {
     };
 
     /**
-     * 
+     *
      * Moves the cursor to the start of the current line. Note that this does de-select the current selection.
      **/
     this.navigateLineStart = function() {
@@ -1901,7 +2296,7 @@ var Editor = function(renderer, session) {
     };
 
     /**
-     * 
+     *
      * Moves the cursor to the end of the current line. Note that this does de-select the current selection.
      **/
     this.navigateLineEnd = function() {
@@ -1910,29 +2305,25 @@ var Editor = function(renderer, session) {
     };
 
     /**
-     * 
+     *
      * Moves the cursor to the end of the current file. Note that this does de-select the current selection.
      **/
     this.navigateFileEnd = function() {
-        var scrollTop = this.renderer.scrollTop;
         this.selection.moveCursorFileEnd();
         this.clearSelection();
-        this.renderer.animateScrolling(scrollTop);
     };
 
     /**
-     * 
+     *
      * Moves the cursor to the start of the current file. Note that this does de-select the current selection.
      **/
     this.navigateFileStart = function() {
-        var scrollTop = this.renderer.scrollTop;
         this.selection.moveCursorFileStart();
         this.clearSelection();
-        this.renderer.animateScrolling(scrollTop);
     };
 
     /**
-     * 
+     *
      * Moves the cursor to the word immediately to the right of the current position. Note that this does de-select the current selection.
      **/
     this.navigateWordRight = function() {
@@ -1941,7 +2332,7 @@ var Editor = function(renderer, session) {
     };
 
     /**
-     * 
+     *
      * Moves the cursor to the word immediately to the left of the current position. Note that this does de-select the current selection.
      **/
     this.navigateWordLeft = function() {
@@ -1996,8 +2387,7 @@ var Editor = function(renderer, session) {
         this.$blockScrolling += 1;
 
         var selection = this.getSelectionRange();
-        this.clearSelection();
-        this.selection.moveCursorTo(0, 0);
+        this.selection.moveTo(0, 0);
 
         for (var i = ranges.length - 1; i >= 0; --i) {
             if(this.$tryReplace(ranges[i], replacement)) {
@@ -2022,7 +2412,7 @@ var Editor = function(renderer, session) {
         }
     };
 
-    /** 
+    /**
      * {:Search.getOptions} For more information on `options`, see [[Search `Search`]].
      * @related Search.getOptions
      * @returns {Object}
@@ -2031,7 +2421,7 @@ var Editor = function(renderer, session) {
         return this.$search.getOptions();
     };
 
-    /** 
+    /**
      * Attempts to find `needle` within the document. For more information on `options`, see [[Search `Search`]].
      * @param {String} needle The text to search for (optional)
      * @param {Object} options An object defining various search properties
@@ -2079,7 +2469,7 @@ var Editor = function(renderer, session) {
         this.selection.setRange(range);
     };
 
-    /** 
+    /**
      * Performs another search for `needle` in the document. For more information on `options`, see [[Search `Search`]].
      * @param {Object} options search options
      * @param {Boolean} animate If `true` animate scrolling
@@ -2091,7 +2481,7 @@ var Editor = function(renderer, session) {
         this.find({skipCurrent: true, backwards: false}, options, animate);
     };
 
-    /** 
+    /**
      * Performs a search for `needle` backwards. For more information on `options`, see [[Search `Search`]].
      * @param {Object} options search options
      * @param {Boolean} animate If `true` animate scrolling
@@ -2111,11 +2501,11 @@ var Editor = function(renderer, session) {
 
         var scrollTop = this.renderer.scrollTop;
         this.renderer.scrollSelectionIntoView(range.start, range.end, 0.5);
-        if (animate != false)
+        if (animate !== false)
             this.renderer.animateScrolling(scrollTop);
     };
 
-    /** 
+    /**
      * {:UndoManager.undo}
      * @related UndoManager.undo
      **/
@@ -2126,7 +2516,7 @@ var Editor = function(renderer, session) {
         this.renderer.scrollCursorIntoView(null, 0.5);
     };
 
-    /** 
+    /**
      * {:UndoManager.redo}
      * @related UndoManager.redo
      **/
@@ -2137,16 +2527,167 @@ var Editor = function(renderer, session) {
         this.renderer.scrollCursorIntoView(null, 0.5);
     };
 
-    /** 
-     * 
+    /**
+     *
      * Cleans up the entire editor.
      **/
     this.destroy = function() {
         this.renderer.destroy();
+        this._signal("destroy", this);
+        if (this.session) {
+            this.session.destroy();
+        }
+    };
+
+    /**
+     * Enables automatic scrolling of the cursor into view when editor itself is inside scrollable element
+     * @param {Boolean} enable default true
+     **/
+    this.setAutoScrollEditorIntoView = function(enable) {
+        if (!enable)
+            return;
+        var rect;
+        var self = this;
+        var shouldScroll = false;
+        if (!this.$scrollAnchor)
+            this.$scrollAnchor = document.createElement("div");
+        var scrollAnchor = this.$scrollAnchor;
+        scrollAnchor.style.cssText = "position:absolute";
+        this.container.insertBefore(scrollAnchor, this.container.firstChild);
+        var onChangeSelection = this.on("changeSelection", function() {
+            shouldScroll = true;
+        });
+        // needed to not trigger sync reflow
+        var onBeforeRender = this.renderer.on("beforeRender", function() {
+            if (shouldScroll)
+                rect = self.renderer.container.getBoundingClientRect();
+        });
+        var onAfterRender = this.renderer.on("afterRender", function() {
+            if (shouldScroll && rect && (self.isFocused()
+                || self.searchBox && self.searchBox.isFocused())
+            ) {
+                var renderer = self.renderer;
+                var pos = renderer.$cursorLayer.$pixelPos;
+                var config = renderer.layerConfig;
+                var top = pos.top - config.offset;
+                if (pos.top >= 0 && top + rect.top < 0) {
+                    shouldScroll = true;
+                } else if (pos.top < config.height &&
+                    pos.top + rect.top + config.lineHeight > window.innerHeight) {
+                    shouldScroll = false;
+                } else {
+                    shouldScroll = null;
+                }
+                if (shouldScroll != null) {
+                    scrollAnchor.style.top = top + "px";
+                    scrollAnchor.style.left = pos.left + "px";
+                    scrollAnchor.style.height = config.lineHeight + "px";
+                    scrollAnchor.scrollIntoView(shouldScroll);
+                }
+                shouldScroll = rect = null;
+            }
+        });
+        this.setAutoScrollEditorIntoView = function(enable) {
+            if (enable)
+                return;
+            delete this.setAutoScrollEditorIntoView;
+            this.removeEventListener("changeSelection", onChangeSelection);
+            this.renderer.removeEventListener("afterRender", onAfterRender);
+            this.renderer.removeEventListener("beforeRender", onBeforeRender);
+        };
+    };
+
+
+    this.$resetCursorStyle = function() {
+        var style = this.$cursorStyle || "ace";
+        var cursorLayer = this.renderer.$cursorLayer;
+        if (!cursorLayer)
+            return;
+        cursorLayer.setSmoothBlinking(/smooth/.test(style));
+        cursorLayer.isBlinking = !this.$readOnly && style != "wide";
+        dom.setCssClass(cursorLayer.element, "ace_slim-cursors", /slim/.test(style));
     };
 
 }).call(Editor.prototype);
 
 
+
+config.defineOptions(Editor.prototype, "editor", {
+    selectionStyle: {
+        set: function(style) {
+            this.onSelectionChange();
+            this._signal("changeSelectionStyle", {data: style});
+        },
+        initialValue: "line"
+    },
+    highlightActiveLine: {
+        set: function() {this.$updateHighlightActiveLine();},
+        initialValue: true
+    },
+    highlightSelectedWord: {
+        set: function(shouldHighlight) {this.$onSelectionChange();},
+        initialValue: true
+    },
+    readOnly: {
+        set: function(readOnly) {
+            // disabled to not break vim mode!
+            // this.textInput.setReadOnly(readOnly);
+            this.$resetCursorStyle(); 
+        },
+        initialValue: false
+    },
+    cursorStyle: {
+        set: function(val) { this.$resetCursorStyle(); },
+        values: ["ace", "slim", "smooth", "wide"],
+        initialValue: "ace"
+    },
+    mergeUndoDeltas: {
+        values: [false, true, "always"],
+        initialValue: true
+    },
+    behavioursEnabled: {initialValue: true},
+    wrapBehavioursEnabled: {initialValue: true},
+    autoScrollEditorIntoView: {
+        set: function(val) {this.setAutoScrollEditorIntoView(val)}
+    },
+
+    hScrollBarAlwaysVisible: "renderer",
+    vScrollBarAlwaysVisible: "renderer",
+    highlightGutterLine: "renderer",
+    animatedScroll: "renderer",
+    showInvisibles: "renderer",
+    showPrintMargin: "renderer",
+    printMarginColumn: "renderer",
+    printMargin: "renderer",
+    fadeFoldWidgets: "renderer",
+    showFoldWidgets: "renderer",
+    showLineNumbers: "renderer",
+    showGutter: "renderer",
+    displayIndentGuides: "renderer",
+    fontSize: "renderer",
+    fontFamily: "renderer",
+    maxLines: "renderer",
+    minLines: "renderer",
+    scrollPastEnd: "renderer",
+    fixedWidthGutter: "renderer",
+    theme: "renderer",
+
+    scrollSpeed: "$mouseHandler",
+    dragDelay: "$mouseHandler",
+    dragEnabled: "$mouseHandler",
+    focusTimout: "$mouseHandler",
+    tooltipFollowsMouse: "$mouseHandler",
+
+    firstLineNumber: "session",
+    overwrite: "session",
+    newLineMode: "session",
+    useWorker: "session",
+    useSoftTabs: "session",
+    tabSize: "session",
+    wrap: "session",
+    foldStyle: "session",
+    mode: "session"
+});
+
 exports.Editor = Editor;
-});
+});