Revert "[IMP] web_editor: update summernote up to 2015-08-31"

Revert till several issues are solved.

6 files changed, 563 insertions, 179 deletions

diff --git a/addons/web_editor/static/lib/summernote/src/js/editing/Bullet.js b/addons/web_editor/static/lib/summernote/src/js/editing/Bullet.js
index 6a115edaa90..d0b0f2e9169 100644
--- a/addons/web_editor/static/lib/summernote/src/js/editing/Bullet.js
+++ b/addons/web_editor/static/lib/summernote/src/js/editing/Bullet.js
@@ -5,17 +5,9 @@ define([
   'summernote/core/range'
 ], function (list, func, dom, range) {
 
-  /**
-   * @class editing.Bullet
-   *
-   * @alternateClassName Bullet
-   */
   var Bullet = function () {
     /**
-     * @method insertOrderedList
-     *
      * toggle ordered list
-     *
      * @type command
      */
     this.insertOrderedList = function () {
@@ -23,10 +15,7 @@ define([
     };
 
     /**
-     * @method insertUnorderedList
-     *
      * toggle unordered list
-     *
      * @type command
      */
     this.insertUnorderedList = function () {
@@ -34,10 +23,7 @@ define([
     };
 
     /**
-     * @method indent
-     *
      * indent
-     *
      * @type command
      */
     this.indent = function () {
@@ -64,10 +50,7 @@ define([
     };
 
     /**
-     * @method outdent
-     *
      * outdent
-     *
      * @type command
      */
     this.outdent = function () {
@@ -95,10 +78,7 @@ define([
     };
 
     /**
-     * @method toggleList
-     *
      * toggle list
-     *
      * @param {String} listName - OL or UL
      */
     this.toggleList = function (listName) {
@@ -106,16 +86,13 @@ define([
       var rng = range.create().wrapBodyInlineWithPara();
 
       var paras = rng.nodes(dom.isPara, { includeAncestor: true });
-      var bookmark = rng.paraBookmark(paras);
       var clustereds = list.clusterBy(paras, func.peq2('parentNode'));
 
       // paragraph to list
       if (list.find(paras, dom.isPurePara)) {
-        var wrappedParas = [];
         $.each(clustereds, function (idx, paras) {
-          wrappedParas = wrappedParas.concat(self.wrapList(paras, listName));
+          self.wrapList(paras, listName);
         });
-        paras = wrappedParas;
       // list to paragraph or change list style
       } else {
         var diffLists = rng.nodes(dom.isList, {
@@ -129,19 +106,16 @@ define([
             dom.replace(listNode, listName);
           });
         } else {
-          paras = this.releaseList(clustereds, true);
+          this.releaseList(clustereds, true);
         }
       }
 
-      range.createFromParaBookmark(bookmark, paras).select();
+      rng.select();
     };
 
     /**
-     * @method wrapList
-     *
      * @param {Node[]} paras
      * @param {String} listName
-     * @return {Node[]}
      */
     this.wrapList = function (paras, listName) {
       var head = list.head(paras);
@@ -153,7 +127,7 @@ define([
       var listNode = prevList || dom.insertAfter(dom.create(listName || 'UL'), last);
 
       // P to LI
-      paras = paras.map(function (para) {
+      paras = $.map(paras, function (para) {
         return dom.isPurePara(para) ? dom.replace(para, 'LI') : para;
       });
 
@@ -164,13 +138,9 @@ define([
         dom.appendChildNodes(listNode, list.from(nextList.childNodes));
         dom.remove(nextList);
       }
-
-      return paras;
     };
 
     /**
-     * @method releaseList
-     *
      * @param {Array[]} clustereds
      * @param {Boolean} isEscapseToBody
      * @return {Node[]}
@@ -187,23 +157,19 @@ define([
         var lastList = headList.childNodes.length > 1 ? dom.splitTree(headList, {
           node: last.parentNode,
           offset: dom.position(last) + 1
-        }, {
-          isSkipPaddingBlankHTML: true
-        }) : null;
+        }, true) : null;
 
         var middleList = dom.splitTree(headList, {
           node: head.parentNode,
           offset: dom.position(head)
-        }, {
-          isSkipPaddingBlankHTML: true
-        });
+        }, true);
 
         paras = isEscapseToBody ? dom.listDescendant(middleList, dom.isLi) :
                                   list.from(middleList.childNodes).filter(dom.isLi);
 
         // LI to P
         if (isEscapseToBody || !dom.isList(headList.parentNode)) {
-          paras = paras.map(function (para) {
+          paras = $.map(paras, function (para) {
             return dom.replace(para, 'P');
           });
         }
diff --git a/addons/web_editor/static/lib/summernote/src/js/editing/Editor.js b/addons/web_editor/static/lib/summernote/src/js/editing/Editor.js
new file mode 100644
index 00000000000..1acd957096d
--- /dev/null
+++ b/addons/web_editor/static/lib/summernote/src/js/editing/Editor.js
@@ -0,0 +1,495 @@
+define([
+  'summernote/core/agent',
+  'summernote/core/func',
+  'summernote/core/list',
+  'summernote/core/dom',
+  'summernote/core/range',
+  'summernote/core/async',
+  'summernote/editing/Style',
+  'summernote/editing/Typing',
+  'summernote/editing/Table',
+  'summernote/editing/Bullet'
+], function (agent, func, list, dom, range, async,
+             Style, Typing, Table, Bullet) {
+  /**
+   * Editor
+   * @class
+   */
+  var Editor = function () {
+
+    var style = new Style();
+    var table = new Table();
+    var typing = new Typing();
+    var bullet = new Bullet();
+
+    this.style = style;   // odoo change for overwrite
+    this.table = table;   // odoo change for overwrite
+    this.typing = typing; // odoo change for overwrite
+    this.bullet = bullet; // odoo change for overwrite
+
+    /**
+     * create range
+     */
+    this.createRange = function ($editable) {
+      $editable.focus();
+      return range.create();
+    };
+
+    /**
+     * save current range
+     *
+     * @param {jQuery} $editable
+     */
+    this.saveRange = function ($editable, thenCollapse) {
+      var r = range.create();
+      if (!r || ($editable[0] !== r.sc && !$.contains($editable[0], r.sc))) {
+        $editable.focus();
+      }
+      $editable.data('range', range.create());
+      if (thenCollapse) {
+        range.create().collapse().select();
+      }
+    };
+
+    this.saveNode = function ($editable) {
+      // copy child node reference
+      var copy = [];
+      for (var key  = 0, len = $editable[0].childNodes.length; key < len; key++) {
+        copy.push($editable[0].childNodes[key]);
+      }
+      $editable.data('childNodes', copy);
+    };
+
+    /**
+     * restore lately range
+     *
+     * @param {jQuery} $editable
+     */
+    this.restoreRange = function ($editable) {
+      var rng = $editable.data('range');
+      if (rng) {
+        rng.select();
+        $editable.focus();
+      }
+    };
+
+    this.restoreNode = function ($editable) {
+      $editable.html('');
+      var child = $editable.data('childNodes');
+      for (var index = 0, len = child.length; index < len; index++) {
+        $editable[0].appendChild(child[index]);
+      }
+    };
+    /**
+     * current style
+     */
+    this.currentStyle = function () {
+      var rng = range.create();
+      return rng ? rng.isOnEditable() && style.current(rng) : false;
+    };
+
+    var triggerOnChange = this.triggerOnChange = function ($editable) {
+      var onChange = $editable.data('callbacks').onChange;
+      if (onChange) {
+        onChange($editable.html(), $editable);
+      }
+    };
+
+    /**
+     * undo
+     * @param {jQuery} $editable
+     */
+    this.undo = function ($editable) {
+      $editable.data('NoteHistory').undo();
+      triggerOnChange($editable);
+    };
+
+    /**
+     * redo
+     * @param {jQuery} $editable
+     */
+    this.redo = function ($editable) {
+      $editable.data('NoteHistory').redo();
+      triggerOnChange($editable);
+    };
+
+    /**
+     * after command
+     * @param {jQuery} $editable
+     */
+    var afterCommand = this.afterCommand = function ($editable) {
+      $editable.data('NoteHistory').recordUndo();
+      triggerOnChange($editable);
+    };
+
+    /* jshint ignore:start */
+    // native commands(with execCommand), generate function for execCommand
+    var commands = ['bold', 'italic', 'underline', 'strikethrough', 'superscript', 'subscript',
+                    'justifyLeft', 'justifyCenter', 'justifyRight', 'justifyFull',
+                    'formatBlock', 'removeFormat',
+                    'backColor', 'foreColor', 'insertHorizontalRule', 'fontName'];
+
+    for (var idx = 0, len = commands.length; idx < len; idx ++) {
+      this[commands[idx]] = (function (sCmd) {
+        return function ($editable, value) {
+          document.execCommand(sCmd, false, value);
+
+          afterCommand($editable);
+        };
+      })(commands[idx]);
+    }
+    /* jshint ignore:end */
+
+    /**
+     * handle tab key
+     *
+     * @param {jQuery} $editable
+     * @param {Object} options
+     */
+    this.tab = function ($editable, options) {
+      var rng = range.create();
+      if (rng.isCollapsed() && rng.isOnCell()) {
+        table.tab(rng);
+      } else {
+        typing.insertTab($editable, rng, options.tabsize);
+        afterCommand($editable);
+      }
+    };
+
+    /**
+     * handle shift+tab key
+     */
+    this.untab = function () {
+      var rng = range.create();
+      if (rng.isCollapsed() && rng.isOnCell()) {
+        table.tab(rng, true);
+      }
+    };
+
+    /**
+     * insert paragraph
+     *
+     * @param {Node} $editable
+     */
+    this.insertParagraph = function ($editable) {
+      typing.insertParagraph($editable);
+      afterCommand($editable);
+    };
+
+    /**
+     * @param {jQuery} $editable
+     */
+    this.insertOrderedList = function ($editable) {
+      bullet.insertOrderedList($editable);
+      afterCommand($editable);
+    };
+
+    /**
+     * @param {jQuery} $editable
+     */
+    this.insertUnorderedList = function ($editable) {
+      bullet.insertUnorderedList($editable);
+      afterCommand($editable);
+    };
+
+    /**
+     * @param {jQuery} $editable
+     */
+    this.indent = function ($editable) {
+      bullet.indent($editable);
+      afterCommand($editable);
+    };
+
+    /**
+     * @param {jQuery} $editable
+     */
+    this.outdent = function ($editable) {
+      bullet.outdent($editable);
+      afterCommand($editable);
+    };
+
+    /**
+     * insert image
+     *
+     * @param {jQuery} $editable
+     * @param {String} sUrl
+     */
+    this.insertImage = function ($editable, sUrl, filename) {
+      async.createImage(sUrl, filename).then(function ($image) {
+        $image.css({
+          display: '',
+          width: Math.min($editable.width(), $image.width())
+        });
+        range.create().insertNode($image[0]);
+        afterCommand($editable);
+      }).fail(function () {
+        var callbacks = $editable.data('callbacks');
+        if (callbacks.onImageUploadError) {
+          callbacks.onImageUploadError();
+        }
+      });
+    };
+
+    /**
+     * insert node
+     * @param {Node} $editable
+     * @param {Node} node
+     * @param {Boolean} [isInline]
+     */
+    this.insertNode = function ($editable, node, isInline) {
+      range.create().insertNode(node, isInline);
+      afterCommand($editable);
+    };
+
+    /**
+     * insert text
+     * @param {Node} $editable
+     * @param {String} text
+     */
+    this.insertText = function ($editable, text) {
+      var textNode = this.createRange($editable).insertNode(dom.createText(text), true);
+      range.create(textNode, dom.nodeLength(textNode)).select();
+      afterCommand($editable);
+    };
+
+    /**
+     * formatBlock
+     *
+     * @param {jQuery} $editable
+     * @param {String} tagName
+     */
+    this.formatBlock = function ($editable, tagName) {
+      tagName = agent.isMSIE ? '<' + tagName + '>' : tagName;
+      document.execCommand('FormatBlock', false, tagName);
+      afterCommand($editable);
+    };
+
+    this.formatPara = function ($editable) {
+      this.formatBlock($editable, 'P');
+      afterCommand($editable);
+    };
+
+    /* jshint ignore:start */
+    for (var idx = 1; idx <= 6; idx ++) {
+      this['formatH' + idx] = function (idx) {
+        return function ($editable) {
+          this.formatBlock($editable, 'H' + idx);
+        };
+      }(idx);
+    };
+    /* jshint ignore:end */
+
+    /**
+     * fontsize
+     * FIXME: Still buggy
+     *
+     * @param {jQuery} $editable
+     * @param {String} value - px
+     */
+    this.fontSize = function ($editable, value) {
+      document.execCommand('fontSize', false, 3);
+      if (agent.isFF) {
+        // firefox: <font size="3"> to <span style='font-size={value}px;'>, buggy
+        $editable.find('font[size=3]').removeAttr('size').css('font-size', value + 'px');
+      } else {
+        // chrome: <span style="font-size: medium"> to <span style='font-size={value}px;'>
+        $editable.find('span').filter(function () {
+          return this.style.fontSize === 'medium';
+        }).css('font-size', value + 'px');
+      }
+
+      afterCommand($editable);
+    };
+
+    /**
+     * lineHeight
+     * @param {jQuery} $editable
+     * @param {String} value
+     */
+    this.lineHeight = function ($editable, value) {
+      style.stylePara(range.create(), {
+        lineHeight: value
+      });
+      afterCommand($editable);
+    };
+
+    /**
+     * unlink
+     *
+     * @type command
+     *
+     * @param {jQuery} $editable
+     */
+    this.unlink = function ($editable) {
+      var rng = range.create();
+      if (rng.isOnAnchor()) {
+        var anchor = dom.ancestor(rng.sc, dom.isAnchor);
+        rng = range.createFromNode(anchor);
+        rng.select();
+        document.execCommand('unlink');
+
+        afterCommand($editable);
+      }
+    };
+
+    /**
+     * create link
+     *
+     * @type command
+     *
+     * @param {jQuery} $editable
+     * @param {Object} linkInfo
+     * @param {Object} options
+     */
+    this.createLink = function ($editable, linkInfo, options) {
+      var linkUrl = linkInfo.url;
+      var linkText = linkInfo.text;
+      var isNewWindow = linkInfo.newWindow;
+      var className = linkInfo.className || null;
+      var rng = linkInfo.range;
+
+      if (options.onCreateLink) {
+        linkUrl = options.onCreateLink(linkUrl);
+      }
+
+      rng = rng.deleteContents(true);
+      var anchor = dom.ancestor(rng.sc, dom.isAnchor);
+
+      // Create a new link when there is no anchor on range.
+      if (!anchor) {
+        anchor = rng.insertNode($('<A>' + linkText + '</A>')[0], true);
+      }
+      $(anchor).html(linkText).attr({
+        'href': linkUrl,
+        'target': isNewWindow ? '_blank' : null,
+        'class': className
+      });
+
+      range.createFromNode(anchor).select();
+      afterCommand($editable);
+    };
+
+    /**
+     * returns link info
+     *
+     * @return {Object}
+     */
+    this.getLinkInfo = function ($editable) {
+      $editable.focus();
+
+      var rng = range.create().expand(dom.isAnchor);
+
+      // Get the first anchor on range(for edit).
+      var $anchor = $(list.head(rng.nodes(dom.isAnchor)));
+
+      return {
+        range: rng,
+        text: rng.toString(),
+        isNewWindow: $anchor.length ? $anchor.attr('target') === '_blank' : true,
+        url: $anchor.length ? $anchor.attr('href') : ''
+      };
+    };
+
+    this.color = function ($editable, sObjColor) {
+      var oColor = JSON.parse(sObjColor);
+      var foreColor = oColor.foreColor, backColor = oColor.backColor;
+
+      if (foreColor) { document.execCommand('foreColor', false, foreColor); }
+      if (backColor) { document.execCommand('backColor', false, backColor); }
+
+      afterCommand($editable);
+    };
+
+    this.insertTable = function ($editable, sDim) {
+      var dimension = sDim.split('x');
+      var rng = range.create();
+      rng = rng.deleteContents();
+      rng.insertNode(table.createTable(dimension[0], dimension[1]));
+      afterCommand($editable);
+    };
+
+    /**
+     * @return {Node} image from the current range selection
+     */
+    function getImgTarget () {
+      var rng = range.create();
+      var target = rng.sc.childNodes.length && rng.sc.childNodes[rng.so] || rng.sc;
+      return target;
+    }
+
+    /**
+     * @param {jQuery} $editable
+     * @param {String} value
+     */
+    this.floatMe = function ($editable, value) {
+      var $target = $( getImgTarget() );
+      $target.css('float', value);
+      afterCommand($editable);
+    };
+
+    this.imageShape = function ($editable, value) {
+      var $target = $( getImgTarget() );
+      $target.removeClass('img-rounded img-circle img-thumbnail');
+
+      if (value) {
+        $target.addClass(value);
+      }
+
+      afterCommand($editable);
+    };
+
+    /**
+     * resize overlay element
+     * @param {jQuery} $editable
+     * @param {String} value
+     */
+    this.resize = function ($editable, value) {
+      var $target = $( getImgTarget() );
+      $target.css({
+        width: value * 100 + '%',
+        height: ''
+      });
+
+      afterCommand($editable);
+    };
+
+    /**
+     * @param {Position} pos
+     * @param {jQuery} $target - target element
+     * @param {Boolean} [bKeepRatio] - keep ratio
+     */
+    this.resizeTo = function (pos, $target, bKeepRatio) {
+      var imageSize;
+      if (bKeepRatio) {
+        var newRatio = pos.y / pos.x;
+        var ratio = $target.data('ratio');
+        imageSize = {
+          width: ratio > newRatio ? pos.x : pos.y / ratio,
+          height: ratio > newRatio ? pos.x * ratio : pos.y
+        };
+      } else {
+        imageSize = {
+          width: pos.x,
+          height: pos.y
+        };
+      }
+
+      $target.css(imageSize);
+    };
+
+    /**
+     * remove media object
+     *
+     * @param {jQuery} $editable
+     * @param {String} value - dummy argument (for keep interface)
+     */
+    this.removeMedia = function ($editable, value) {
+      var $target = $( getImgTarget() );
+      $target.detach();
+
+      afterCommand($editable);
+    };
+  };
+
+  return Editor;
+});
diff --git a/addons/web_editor/static/lib/summernote/src/js/editing/History.js b/addons/web_editor/static/lib/summernote/src/js/editing/History.js
index f50e87fe166..dc301bf957b 100644
--- a/addons/web_editor/static/lib/summernote/src/js/editing/History.js
+++ b/addons/web_editor/static/lib/summernote/src/js/editing/History.js
@@ -1,12 +1,10 @@
-define(['summernote/core/range'], function (range) {
+define(['summernote/core/range', 'summernote/core/dom'], function (range, dom) {
   /**
-   * @class editing.History
-   *
-   * Editor History
-   *
+   * History
+   * @class
    */
   var History = function ($editable) {
-    var stack = [], stackOffset = -1;
+    var stack = [], stackOffset = -1, hasUndo = false;
     var editable = $editable[0];
 
     var makeSnapshot = function () {
@@ -15,7 +13,7 @@ define(['summernote/core/range'], function (range) {
 
       return {
         contents: $editable.html(),
-        bookmark: (rng ? rng.bookmark(editable) : emptyBookmark)
+        bookmark: (rng && dom.ancestor(rng.sc, dom.isEditable) ? rng.bookmark(editable) : emptyBookmark)
       };
     };
 
@@ -28,29 +26,21 @@ define(['summernote/core/range'], function (range) {
       }
     };
 
-    /**
-     * undo
-     */
     this.undo = function () {
-      // Create snap shot if not yet recorded
-      if ($editable.html() !== stack[stackOffset].contents) {
-        this.recordUndo();
-      }
-
-      if (0 < stackOffset) {
+      if (0 < stackOffset || (stack.length - 1 === stackOffset && hasUndo)) {
+        if (stack.length - 1 === stackOffset) {
+          this.recordUndo();
+        }
         stackOffset--;
         applySnapshot(stack[stackOffset]);
+        hasUndo = !!stackOffset;
       }
     };
 
-    /* ODOO: to suggest upstream */
     this.hasUndo = function () {
-        return 0 < stackOffset;
+        return 0 < stackOffset || hasUndo;
     };
 
-    /**
-     * redo
-     */
     this.redo = function () {
       if (stack.length - 1 > stackOffset) {
         stackOffset++;
@@ -58,24 +48,49 @@ define(['summernote/core/range'], function (range) {
       }
     };
 
-    /* ODOO: to suggest upstream */
     this.hasRedo = function () {
         return stack.length - 1 > stackOffset;
     };
 
-    /**
-     * recorded undo
-     */
+    var last;
     this.recordUndo = function () {
-      stackOffset++;
+      // test event for firefox: remove stack of history because event doesn't exists
+      var key = typeof event !== 'undefined' ? event : false;
+      if (key && !event.metaKey && !event.ctrlKey && !event.altKey && event.type === "keydown") {
+        key = event.type + "-";
+        if (event.which === 8 || event.which === 46) key += 'delete';
+        else if (event.which === 13) key += 'enter';
+        else key += 'other';
+        if (key === last) return;
+        hasUndo = true;
+      }
+      last = key;
 
       // Wash out stack after stackOffset
-      if (stack.length > stackOffset) {
-        stack = stack.slice(0, stackOffset);
+      if (stack.length > stackOffset+1) {
+        stack = stack.slice(0, stackOffset+1);
+      }
+
+      if (stack[stackOffset] && stack[stackOffset].contents === $editable.html()) {
+        return;
       }
 
+      stackOffset++;
+
       // Create new snapshot and push it to the end
       stack.push(makeSnapshot());
+      return true;
+    };
+
+    this.splitNext = function () {
+        last = false;
+    };
+
+    this.reset = function () {
+        last = false;
+        stack = [];
+        stackOffset = -1;
+        this.recordUndo();
     };
 
     // Create first undo stack
diff --git a/addons/web_editor/static/lib/summernote/src/js/editing/Style.js b/addons/web_editor/static/lib/summernote/src/js/editing/Style.js
index bf749cd817b..835d575be1b 100644
--- a/addons/web_editor/static/lib/summernote/src/js/editing/Style.js
+++ b/addons/web_editor/static/lib/summernote/src/js/editing/Style.js
@@ -1,28 +1,20 @@
 define([
   'summernote/core/agent',
-  'summernote/core/func',
-  'summernote/core/list',
   'summernote/core/dom'
-], function (agent, func, list, dom) {
+], function (agent, dom) {
   /**
-   * @class editing.Style
-   *
    * Style
-   *
+   * @class
    */
   var Style = function () {
     /**
-     * @method jQueryCSS
-     *
-     * [workaround] for old jQuery
      * passing an array of style properties to .css()
      * will result in an object of property-value pairs.
      * (compability with version < 1.9)
      *
-     * @private
      * @param  {jQuery} $obj
      * @param  {Array} propertyNames - An array of one or more CSS properties.
-     * @return {Object}
+     * @returns {Object}
      */
     var jQueryCSS = function ($obj, propertyNames) {
       if (agent.jqueryVersion < 1.9) {
@@ -36,19 +28,6 @@ define([
     };
 
     /**
-     * returns style object from node
-     *
-     * @param {jQuery} $node
-     * @return {Object}
-     */
-    this.fromNode = function ($node) {
-      var properties = ['font-family', 'font-size', 'text-align', 'list-style-type', 'line-height'];
-      var styleInfo = jQueryCSS($node, properties) || {};
-      styleInfo['font-size'] = parseInt(styleInfo['font-size'], 10);
-      return styleInfo;
-    };
-
-    /**
      * paragraph level style
      *
      * @param {WrappedRange} rng
@@ -63,58 +42,6 @@ define([
     };
 
     /**
-     * insert and returns styleNodes on range.
-     *
-     * @param {WrappedRange} rng
-     * @param {Object} [options] - options for styleNodes
-     * @param {String} [options.nodeName] - default: `SPAN`
-     * @param {Boolean} [options.expandClosestSibling] - default: `false`
-     * @param {Boolean} [options.onlyPartialContains] - default: `false`
-     * @return {Node[]}
-     */
-    this.styleNodes = function (rng, options) {
-      rng = rng.splitText();
-
-      var nodeName = options && options.nodeName || 'SPAN';
-      var expandClosestSibling = !!(options && options.expandClosestSibling);
-      var onlyPartialContains = !!(options && options.onlyPartialContains);
-
-      if (rng.isCollapsed()) {
-        return [rng.insertNode(dom.create(nodeName))];
-      }
-
-      var pred = dom.makePredByNodeName(nodeName);
-      var nodes = rng.nodes(dom.isText, {
-        fullyContains: true
-      }).map(function (text) {
-        return dom.singleChildAncestor(text, pred) || dom.wrap(text, nodeName);
-      });
-
-      if (expandClosestSibling) {
-        if (onlyPartialContains) {
-          var nodesInRange = rng.nodes();
-          // compose with partial contains predication
-          pred = func.and(pred, function (node) {
-            return list.contains(nodesInRange, node);
-          });
-        }
-
-        return nodes.map(function (node) {
-          var siblings = dom.withClosestSiblings(node, pred);
-          var head = list.head(siblings);
-          var tails = list.tail(siblings);
-          $.each(tails, function (idx, elem) {
-            dom.appendChildNodes(head, elem.childNodes);
-            dom.remove(elem);
-          });
-          return list.head(siblings);
-        });
-      } else {
-        return nodes;
-      }
-    };
-
-    /**
      * get current style on cursor
      *
      * @param {WrappedRange} rng
@@ -122,7 +49,10 @@ define([
      */
     this.current = function (rng) {
       var $cont = $(dom.isText(rng.sc) ? rng.sc.parentNode : rng.sc);
-      var styleInfo = this.fromNode($cont);
+      var properties = ['font-family', 'font-size', 'text-align', 'list-style-type', 'line-height'];
+      var styleInfo = jQueryCSS($cont, properties) || {};
+
+      styleInfo['font-size'] = parseInt(styleInfo['font-size'], 10);
 
       // document.queryCommandState for toggle state
       styleInfo['font-bold'] = document.queryCommandState('bold') ? 'bold' : 'normal';
@@ -149,6 +79,7 @@ define([
         styleInfo['line-height'] = lineHeight.toFixed(1);
       }
 
+      styleInfo.image = rng.isOnImg();
       styleInfo.anchor = rng.isOnAnchor() && dom.ancestor(rng.sc, dom.isAnchor);
       styleInfo.ancestors = dom.listAncestor(rng.sc, dom.isEditable);
       styleInfo.range = rng;
diff --git a/addons/web_editor/static/lib/summernote/src/js/editing/Table.js b/addons/web_editor/static/lib/summernote/src/js/editing/Table.js
index 634d5a79d7e..291f85128e5 100644
--- a/addons/web_editor/static/lib/summernote/src/js/editing/Table.js
+++ b/addons/web_editor/static/lib/summernote/src/js/editing/Table.js
@@ -2,10 +2,8 @@ define([
   'summernote/core/dom', 'summernote/core/range', 'summernote/core/list'
 ], function (dom, range, list) {
   /**
-   * @class editing.Table
-   *
    * Table
-   *
+   * @class
    */
   var Table = function () {
     /**
diff --git a/addons/web_editor/static/lib/summernote/src/js/editing/Typing.js b/addons/web_editor/static/lib/summernote/src/js/editing/Typing.js
index f95eba9e9f3..2a094cafa22 100644
--- a/addons/web_editor/static/lib/summernote/src/js/editing/Typing.js
+++ b/addons/web_editor/static/lib/summernote/src/js/editing/Typing.js
@@ -1,24 +1,12 @@
 define([
   'summernote/core/dom',
-  'summernote/core/range',
-  'summernote/editing/Bullet'
-], function (dom, range, Bullet) {
+  'summernote/core/range'
+], function (dom, range) {
 
-  /**
-   * @class editing.Typing
-   *
-   * Typing
-   *
-   */
   var Typing = function () {
 
-    // a Bullet instance to toggle lists off
-    var bullet = new Bullet();
-
     /**
-     * insert tab
-     *
-     * @param {jQuery} $editable
+     * @param {jQuery} $editable 
      * @param {WrappedRange} rng
      * @param {Number} tabsize
      */
@@ -49,22 +37,14 @@ define([
       var nextPara;
       // on paragraph: split paragraph
       if (splitRoot) {
-        // if it is an empty line with li
-        if (dom.isEmpty(splitRoot) && dom.isLi(splitRoot)) {
-          // disable UL/OL and escape!
-          bullet.toggleList(splitRoot.parentNode.nodeName);
-          return;
-        // if new line has content (not a line break)
-        } else {
-          nextPara = dom.splitTree(splitRoot, rng.getStartPoint());
+        nextPara = dom.splitTree(splitRoot, rng.getStartPoint());
 
-          var emptyAnchors = dom.listDescendant(splitRoot, dom.isEmptyAnchor);
-          emptyAnchors = emptyAnchors.concat(dom.listDescendant(nextPara, dom.isEmptyAnchor));
+        var emptyAnchors = dom.listDescendant(splitRoot, dom.isEmptyAnchor);
+        emptyAnchors = emptyAnchors.concat(dom.listDescendant(nextPara, dom.isEmptyAnchor));
 
-          $.each(emptyAnchors, function (idx, anchor) {
-            dom.remove(anchor);
-          });
-        }
+        $.each(emptyAnchors, function (idx, anchor) {
+          dom.remove(anchor);
+        });
       // no paragraph: insert empty paragraph
       } else {
         var next = rng.sc.childNodes[rng.so];
@@ -77,7 +57,6 @@ define([
       }
 
       range.create(nextPara, 0).normalize().select();
-
     };
 
   };