API Docs for: 3.8.0
Show:

File: editor/js/exec-command.js


  2.     /**
  3.      * Plugin for the frame module to handle execCommands for Editor
  4.      * @class Plugin.ExecCommand
  5.      * @extends Base
  6.      * @constructor
  7.      * @module editor
  8.      * @submodule exec-command
  9.      */
  10.         var ExecCommand = function() {
  11.             ExecCommand.superclass.constructor.apply(this, arguments);
  12.         },
  13.         /**
  14.         * This method is meant to normalize IE's in ability to exec the proper command on elements with CSS styling.
  15.         * @method fixIETags
  16.         * @protected
  17.         * @param {String} cmd The command to execute
  18.         * @param {String} tag The tag to create
  19.         * @param {String} rule The rule that we are looking for.
  20.         */
  21.         fixIETags = function(cmd, tag, rule) {
  22.             var inst = this.getInstance(),
  23.                 doc = inst.config.doc,
  24.                 sel = doc.selection.createRange(),
  25.                 o = doc.queryCommandValue(cmd),
  26.                 html, reg, m, p, d, s, c;

  28.             if (o) {
  29.                 html = sel.htmlText;
  30.                 reg = new RegExp(rule, 'g');
  31.                 m = html.match(reg);

  33.                 if (m) {
  34.                     html = html.replace(rule + ';', '').replace(rule, '');

  36.                     sel.pasteHTML('<var id="yui-ie-bs">');

  38.                     p = doc.getElementById('yui-ie-bs');
  39.                     d = doc.createElement('div');
  40.                     s = doc.createElement(tag);

  42.                     d.innerHTML = html;
  43.                     if (p.parentNode !== inst.config.doc.body) {
  44.                         p = p.parentNode;
  45.                     }

  47.                     c = d.childNodes;

  49.                     p.parentNode.replaceChild(s, p);

  51.                     Y.each(c, function(f) {
  52.                         s.appendChild(f);
  53.                     });
  54.                     sel.collapse();
  55.                     if (sel.moveToElementText) {
  56.                         sel.moveToElementText(s);
  57.                     }
  58.                     sel.select();
  59.                 }
  60.             }
  61.             this._command(cmd);
  62.         };

  64.         Y.extend(ExecCommand, Y.Base, {
  65.             /**
  66.             * An internal reference to the keyCode of the last key that was pressed.
  67.             * @private
  68.             * @property _lastKey
  69.             */
  70.             _lastKey: null,
  71.             /**
  72.             * An internal reference to the instance of the frame plugged into.
  73.             * @private
  74.             * @property _inst
  75.             */
  76.             _inst: null,
  77.             /**
  78.             * Execute a command on the frame's document.
  79.             * @method command
  80.             * @param {String} action The action to perform (bold, italic, fontname)
  81.             * @param {String} value The optional value (helvetica)
  82.             * @return {Node/NodeList} Should return the Node/Nodelist affected
  83.             */
  84.             command: function(action, value) {
  85.                 var fn = ExecCommand.COMMANDS[action];

  87.                 Y.log('execCommand(' + action + '): "' + value + '"', 'info', 'exec-command');
  88.                 if (fn) {
  89.                     Y.log('OVERIDE execCommand(' + action + '): "' + value + '"', 'info', 'exec-command');
  90.                     return fn.call(this, action, value);
  91.                 } else {
  92.                     return this._command(action, value);
  93.                 }
  94.             },
  95.             /**
  96.             * The private version of execCommand that doesn't filter for overrides.
  97.             * @private
  98.             * @method _command
  99.             * @param {String} action The action to perform (bold, italic, fontname)
  100.             * @param {String} value The optional value (helvetica)
  101.             */
  102.             _command: function(action, value) {
  103.                 var inst = this.getInstance();
  104.                 try {
  105.                     try {
  106.                         inst.config.doc.execCommand('styleWithCSS', null, 1);
  107.                     } catch (e1) {
  108.                         try {
  109.                             inst.config.doc.execCommand('useCSS', null, 0);
  110.                         } catch (e2) {
  111.                         }
  112.                     }
  113.                     Y.log('Using default browser execCommand(' + action + '): "' + value + '"', 'info', 'exec-command');
  114.                     inst.config.doc.execCommand(action, null, value);
  115.                 } catch (e) {
  116.                     Y.log(e.message, 'warn', 'exec-command');
  117.                 }
  118.             },
  119.             /**
  120.             * Get's the instance of YUI bound to the parent frame
  121.             * @method getInstance
  122.             * @return {YUI} The YUI instance bound to the parent frame
  123.             */
  124.             getInstance: function() {
  125.                 if (!this._inst) {
  126.                     this._inst = this.get('host').getInstance();
  127.                 }
  128.                 return this._inst;
  129.             },
  130.             initializer: function() {
  131.                 Y.mix(this.get('host'), {
  132.                     execCommand: function(action, value) {
  133.                         return this.exec.command(action, value);
  134.                     },
  135.                     _execCommand: function(action, value) {
  136.                         return this.exec._command(action, value);
  137.                     }
  138.                 });

  140.                 this.get('host').on('dom:keypress', Y.bind(function(e) {
  141.                     this._lastKey = e.keyCode;
  142.                 }, this));
  143.             },
  144.             _wrapContent: function(str, override) {
  145.                 var useP = (this.getInstance().host.editorPara && !override ? true : false);

  147.                 if (useP) {
  148.                     str = '<p>' + str + '</p>';
  149.                 } else {
  150.                     str = str + '<br>';
  151.                 }
  152.                 return str;
  153.             }
  154.         }, {
  155.             /**
  156.             * execCommand
  157.             * @property NAME
  158.             * @static
  159.             */
  160.             NAME: 'execCommand',
  161.             /**
  162.             * exec
  163.             * @property NS
  164.             * @static
  165.             */
  166.             NS: 'exec',
  167.             ATTRS: {
  168.                 host: {
  169.                     value: false
  170.                 }
  171.             },
  172.             /**
  173.             * Static object literal of execCommand overrides
  174.             * @property COMMANDS
  175.             * @static
  176.             */
  177.             COMMANDS: {
  178.                 /**
  179.                 * Wraps the content with a new element of type (tag)
  180.                 * @method COMMANDS.wrap
  181.                 * @static
  182.                 * @param {String} cmd The command executed: wrap
  183.                 * @param {String} tag The tag to wrap the selection with
  184.                 * @return {NodeList} NodeList of the items touched by this command.
  185.                 */
  186.                 wrap: function(cmd, tag) {
  187.                     var inst = this.getInstance();
  188.                     return (new inst.EditorSelection()).wrapContent(tag);
  189.                 },
  190.                 /**
  191.                 * Inserts the provided HTML at the cursor, should be a single element.
  192.                 * @method COMMANDS.inserthtml
  193.                 * @static
  194.                 * @param {String} cmd The command executed: inserthtml
  195.                 * @param {String} html The html to insert
  196.                 * @return {Node} Node instance of the item touched by this command.
  197.                 */
  198.                 inserthtml: function(cmd, html) {
  199.                     var inst = this.getInstance();
  200.                     if (inst.EditorSelection.hasCursor() || Y.UA.ie) {
  201.                         return (new inst.EditorSelection()).insertContent(html);
  202.                     } else {
  203.                         this._command('inserthtml', html);
  204.                     }
  205.                 },
  206.                 /**
  207.                 * Inserts the provided HTML at the cursor, and focuses the cursor afterwards.
  208.                 * @method COMMANDS.insertandfocus
  209.                 * @static
  210.                 * @param {String} cmd The command executed: insertandfocus
  211.                 * @param {String} html The html to insert
  212.                 * @return {Node} Node instance of the item touched by this command.
  213.                 */
  214.                 insertandfocus: function(cmd, html) {
  215.                     var inst = this.getInstance(), out, sel;
  216.                     if (inst.EditorSelection.hasCursor()) {
  217.                         html += inst.EditorSelection.CURSOR;
  218.                         out = this.command('inserthtml', html);
  219.                         sel = new inst.EditorSelection();
  220.                         sel.focusCursor(true, true);
  221.                     } else {
  222.                         this.command('inserthtml', html);
  223.                     }
  224.                     return out;
  225.                 },
  226.                 /**
  227.                 * Inserts a BR at the current cursor position
  228.                 * @method COMMANDS.insertbr
  229.                 * @static
  230.                 * @param {String} cmd The command executed: insertbr
  231.                 */
  232.                 insertbr: function() {
  233.                     var inst = this.getInstance(),
  234.                         sel = new inst.EditorSelection(),
  235.                         html = '<var>|</var>', last = null,
  236.                         q = (Y.UA.webkit) ? 'span.Apple-style-span,var' : 'var',
  237.                         insert = function(n) {
  238.                             var c = inst.Node.create('<br>');
  239.                             n.insert(c, 'before');
  240.                             return c;
  241.                         };

  243.                     if (sel._selection.pasteHTML) {
  244.                         sel._selection.pasteHTML(html);
  245.                     } else {
  246.                         this._command('inserthtml', html);
  247.                     }


  250.                     inst.all(q).each(function(n) {
  251.                         var g = true, s;
  252.                         if (Y.UA.webkit) {
  253.                             g = false;
  254.                             if (n.get('innerHTML') === '|') {
  255.                                 g = true;
  256.                             }
  257.                         }
  258.                         if (g) {
  259.                             last = insert(n);
  260.                             if ((!last.previous() || !last.previous().test('br')) && Y.UA.gecko) {
  261.                                 s = last.cloneNode();
  262.                                 last.insert(s, 'after');
  263.                                 last = s;
  264.                             }
  265.                             n.remove();
  266.                         }
  267.                     });
  268.                     if (Y.UA.webkit && last) {
  269.                         insert(last);
  270.                         sel.selectNode(last);
  271.                     }
  272.                 },
  273.                 /**
  274.                 * Inserts an image at the cursor position
  275.                 * @method COMMANDS.insertimage
  276.                 * @static
  277.                 * @param {String} cmd The command executed: insertimage
  278.                 * @param {String} img The url of the image to be inserted
  279.                 * @return {Node} Node instance of the item touched by this command.
  280.                 */
  281.                 insertimage: function(cmd, img) {
  282.                     return this.command('inserthtml', '<img src="' + img + '">');
  283.                 },
  284.                 /**
  285.                 * Add a class to all of the elements in the selection
  286.                 * @method COMMANDS.addclass
  287.                 * @static
  288.                 * @param {String} cmd The command executed: addclass
  289.                 * @param {String} cls The className to add
  290.                 * @return {NodeList} NodeList of the items touched by this command.
  291.                 */
  292.                 addclass: function(cmd, cls) {
  293.                     var inst = this.getInstance();
  294.                     return (new inst.EditorSelection()).getSelected().addClass(cls);
  295.                 },
  296.                 /**
  297.                 * Remove a class from all of the elements in the selection
  298.                 * @method COMMANDS.removeclass
  299.                 * @static
  300.                 * @param {String} cmd The command executed: removeclass
  301.                 * @param {String} cls The className to remove
  302.                 * @return {NodeList} NodeList of the items touched by this command.
  303.                 */
  304.                 removeclass: function(cmd, cls) {
  305.                     var inst = this.getInstance();
  306.                     return (new inst.EditorSelection()).getSelected().removeClass(cls);
  307.                 },
  308.                 /**
  309.                 * Adds a forecolor to the current selection, or creates a new element and applies it
  310.                 * @method COMMANDS.forecolor
  311.                 * @static
  312.                 * @param {String} cmd The command executed: forecolor
  313.                 * @param {String} val The color value to apply
  314.                 * @return {NodeList} NodeList of the items touched by this command.
  315.                 */
  316.                 forecolor: function(cmd, val) {
  317.                     var inst = this.getInstance(),
  318.                         sel = new inst.EditorSelection(), n;

  320.                     if (!Y.UA.ie) {
  321.                         this._command('useCSS', false);
  322.                     }
  323.                     if (inst.EditorSelection.hasCursor()) {
  324.                         if (sel.isCollapsed) {
  325.                             if (sel.anchorNode && (sel.anchorNode.get('innerHTML') === '&nbsp;')) {
  326.                                 sel.anchorNode.setStyle('color', val);
  327.                                 n = sel.anchorNode;
  328.                             } else {
  329.                                 n = this.command('inserthtml', '<span style="color: ' + val + '">' + inst.EditorSelection.CURSOR + '</span>');
  330.                                 sel.focusCursor(true, true);
  331.                             }
  332.                             return n;
  333.                         } else {
  334.                             return this._command(cmd, val);
  335.                         }
  336.                     } else {
  337.                         this._command(cmd, val);
  338.                     }
  339.                 },
  340.                 /**
  341.                 * Adds a background color to the current selection, or creates a new element and applies it
  342.                 * @method COMMANDS.backcolor
  343.                 * @static
  344.                 * @param {String} cmd The command executed: backcolor
  345.                 * @param {String} val The color value to apply
  346.                 * @return {NodeList} NodeList of the items touched by this command.
  347.                 */
  348.                 backcolor: function(cmd, val) {
  349.                     var inst = this.getInstance(),
  350.                         sel = new inst.EditorSelection(), n;

  352.                     if (Y.UA.gecko || Y.UA.opera) {
  353.                         cmd = 'hilitecolor';
  354.                     }
  355.                     if (!Y.UA.ie) {
  356.                         this._command('useCSS', false);
  357.                     }
  358.                     if (inst.EditorSelection.hasCursor()) {
  359.                         if (sel.isCollapsed) {
  360.                             if (sel.anchorNode && (sel.anchorNode.get('innerHTML') === '&nbsp;')) {
  361.                                 sel.anchorNode.setStyle('backgroundColor', val);
  362.                                 n = sel.anchorNode;
  363.                             } else {
  364.                                 n = this.command('inserthtml',
  365.                                     '<span style="background-color: ' + val + '">' + inst.EditorSelection.CURSOR + '</span>');
  366.                                 sel.focusCursor(true, true);
  367.                             }
  368.                             return n;
  369.                         } else {
  370.                             return this._command(cmd, val);
  371.                         }
  372.                     } else {
  373.                         this._command(cmd, val);
  374.                     }
  375.                 },
  376.                 /**
  377.                 * Sugar method, calles backcolor
  378.                 * @method COMMANDS.hilitecolor
  379.                 * @static
  380.                 * @param {String} cmd The command executed: backcolor
  381.                 * @param {String} val The color value to apply
  382.                 * @return {NodeList} NodeList of the items touched by this command.
  383.                 */
  384.                 hilitecolor: function() {
  385.                     return ExecCommand.COMMANDS.backcolor.apply(this, arguments);
  386.                 },
  387.                 /**
  388.                 * Adds a font name to the current selection, or creates a new element and applies it
  389.                 * @method COMMANDS.fontname2
  390.                 * @deprecated
  391.                 * @static
  392.                 * @param {String} cmd The command executed: fontname
  393.                 * @param {String} val The font name to apply
  394.                 * @return {NodeList} NodeList of the items touched by this command.
  395.                 */
  396.                 fontname2: function(cmd, val) {
  397.                     this._command('fontname', val);
  398.                     var inst = this.getInstance(),
  399.                         sel = new inst.EditorSelection();

  401.                     if (sel.isCollapsed && (this._lastKey !== 32)) {
  402.                         if (sel.anchorNode.test('font')) {
  403.                             sel.anchorNode.set('face', val);
  404.                         }
  405.                     }
  406.                 },
  407.                 /**
  408.                 * Adds a fontsize to the current selection, or creates a new element and applies it
  409.                 * @method COMMANDS.fontsize2
  410.                 * @deprecated
  411.                 * @static
  412.                 * @param {String} cmd The command executed: fontsize
  413.                 * @param {String} val The font size to apply
  414.                 * @return {NodeList} NodeList of the items touched by this command.
  415.                 */
  416.                 fontsize2: function(cmd, val) {
  417.                     this._command('fontsize', val);

  419.                     var inst = this.getInstance(),
  420.                         sel = new inst.EditorSelection(), p;

  422.                     if (sel.isCollapsed && sel.anchorNode && (this._lastKey !== 32)) {
  423.                         if (Y.UA.webkit) {
  424.                             if (sel.anchorNode.getStyle('lineHeight')) {
  425.                                 sel.anchorNode.setStyle('lineHeight', '');
  426.                             }
  427.                         }
  428.                         if (sel.anchorNode.test('font')) {
  429.                             sel.anchorNode.set('size', val);
  430.                         } else if (Y.UA.gecko) {
  431.                             p = sel.anchorNode.ancestor(inst.EditorSelection.DEFAULT_BLOCK_TAG);
  432.                             if (p) {
  433.                                 p.setStyle('fontSize', '');
  434.                             }
  435.                         }
  436.                     }
  437.                 },
  438.                 /**
  439.                 * Overload for COMMANDS.list
  440.                 * @method COMMANDS.insertorderedlist
  441.                 * @static
  442.                 * @param {String} cmd The command executed: list, ul
  443.                 */
  444.                 insertunorderedlist: function() {
  445.                     this.command('list', 'ul');
  446.                 },
  447.                 /**
  448.                 * Overload for COMMANDS.list
  449.                 * @method COMMANDS.insertunorderedlist
  450.                 * @static
  451.                 * @param {String} cmd The command executed: list, ol
  452.                 */
  453.                 insertorderedlist: function() {
  454.                     this.command('list', 'ol');
  455.                 },
  456.                 /**
  457.                 * Noramlizes lists creation/destruction for IE. All others pass through to native calls
  458.                 * @method COMMANDS.list
  459.                 * @static
  460.                 * @param {String} cmd The command executed: list (not used)
  461.                 * @param {String} tag The tag to deal with
  462.                 */
  463.                 list: function(cmd, tag) {
  464.                     var inst = this.getInstance(), html, self = this,
  465.                         /*
  466.                         The yui3- class name below is not a skinnable class,
  467.                         it's a utility class used internally by editor and
  468.                         stripped when completed, calling getClassName on this
  469.                         is a waste of resources.
  470.                         */
  471.                         DIR = 'dir', cls = 'yui3-touched',
  472.                         dir, range, div, elm, n, str, s, par, list, lis,
  473.                         useP = (inst.host.editorPara ? true : false), tmp,
  474.                         sdir, hasPParent, fc,
  475.                         sel = new inst.EditorSelection();

  477.                     cmd = 'insert' + ((tag === 'ul') ? 'un' : '') + 'orderedlist';

  479.                     if (Y.UA.ie && !sel.isCollapsed) {
  480.                         range = sel._selection;
  481.                         html = range.htmlText;
  482.                         div = inst.Node.create(html) || inst.one('body');

  484.                         if (div.test('li') || div.one('li')) {
  485.                             this._command(cmd, null);
  486.                             return;
  487.                         }
  488.                         if (div.test(tag)) {
  489.                             elm = range.item ? range.item(0) : range.parentElement();
  490.                             n = inst.one(elm);
  491.                             lis = n.all('li');

  493.                             str = '<div>';
  494.                             lis.each(function(l) {
  495.                                 str = self._wrapContent(l.get('innerHTML'));
  496.                             });
  497.                             str += '</div>';
  498.                             s = inst.Node.create(str);
  499.                             if (n.get('parentNode').test('div')) {
  500.                                 n = n.get('parentNode');
  501.                             }
  502.                             if (n && n.hasAttribute(DIR)) {
  503.                                 if (useP) {
  504.                                     s.all('p').setAttribute(DIR, n.getAttribute(DIR));
  505.                                 } else {
  506.                                     s.setAttribute(DIR, n.getAttribute(DIR));
  507.                                 }
  508.                             }
  509.                             if (useP) {
  510.                                 n.replace(s.get('innerHTML'));
  511.                             } else {
  512.                                 n.replace(s);
  513.                             }
  514.                             if (range.moveToElementText) {
  515.                                 range.moveToElementText(s._node);
  516.                             }
  517.                             range.select();
  518.                         } else {
  519.                             par = Y.one(range.parentElement());
  520.                             if (!par.test(inst.EditorSelection.BLOCKS)) {
  521.                                 par = par.ancestor(inst.EditorSelection.BLOCKS);
  522.                             }
  523.                             if (par) {
  524.                                 if (par.hasAttribute(DIR)) {
  525.                                     dir = par.getAttribute(DIR);
  526.                                 }
  527.                             }
  528.                             if (html.indexOf('<br>') > -1) {
  529.                                 html = html.split(/<br>/i);
  530.                             } else {
  531.                                 tmp = inst.Node.create(html),
  532.                                 ps = tmp ? tmp.all('p') : null;

  534.                                 if (ps && ps.size()) {
  535.                                     html = [];
  536.                                     ps.each(function(n) {
  537.                                         html.push(n.get('innerHTML'));
  538.                                     });
  539.                                 } else {
  540.                                     html = [html];
  541.                                 }
  542.                             }
  543.                             list = '<' + tag + ' id="ie-list">';
  544.                             Y.each(html, function(v) {
  545.                                 var a = inst.Node.create(v);
  546.                                 if (a && a.test('p')) {
  547.                                     if (a.hasAttribute(DIR)) {
  548.                                         dir = a.getAttribute(DIR);
  549.                                     }
  550.                                     v = a.get('innerHTML');
  551.                                 }
  552.                                 list += '<li>' + v + '</li>';
  553.                             });
  554.                             list += '</' + tag + '>';
  555.                             range.pasteHTML(list);
  556.                             elm = inst.config.doc.getElementById('ie-list');
  557.                             elm.id = '';
  558.                             if (dir) {
  559.                                 elm.setAttribute(DIR, dir);
  560.                             }
  561.                             if (range.moveToElementText) {
  562.                                 range.moveToElementText(elm);
  563.                             }
  564.                             range.select();
  565.                         }
  566.                     } else if (Y.UA.ie) {
  567.                         par = inst.one(sel._selection.parentElement());
  568.                         if (par.test('p')) {
  569.                             if (par && par.hasAttribute(DIR)) {
  570.                                 dir = par.getAttribute(DIR);
  571.                             }
  572.                             html = Y.EditorSelection.getText(par);
  573.                             if (html === '') {
  574.                                 sdir = '';
  575.                                 if (dir) {
  576.                                     sdir = ' dir="' + dir + '"';
  577.                                 }
  578.                                 list = inst.Node.create(Y.Lang.sub('<{tag}{dir}><li></li></{tag}>', { tag: tag, dir: sdir }));
  579.                                 par.replace(list);
  580.                                 sel.selectNode(list.one('li'));
  581.                             } else {
  582.                                 this._command(cmd, null);
  583.                             }
  584.                         } else {
  585.                             this._command(cmd, null);
  586.                         }
  587.                     } else {
  588.                         inst.all(tag).addClass(cls);
  589.                         if (sel.anchorNode.test(inst.EditorSelection.BLOCKS)) {
  590.                             par = sel.anchorNode;
  591.                         } else {
  592.                             par = sel.anchorNode.ancestor(inst.EditorSelection.BLOCKS);
  593.                         }
  594.                         if (!par) { //No parent, find the first block under the anchorNode
  595.                             par = sel.anchorNode.one(inst.EditorSelection.BLOCKS);
  596.                         }

  598.                         if (par && par.hasAttribute(DIR)) {
  599.                             dir = par.getAttribute(DIR);
  600.                         }
  601.                         if (par && par.test(tag)) {
  602.                             hasPParent = par.ancestor('p');
  603.                             html = inst.Node.create('<div/>');
  604.                             elm = par.all('li');
  605.                             elm.each(function(h) {
  606.                                 html.append(self._wrapContent(h.get('innerHTML'), hasPParent));
  607.                             });
  608.                             if (dir) {
  609.                                 if (useP) {
  610.                                     html.all('p').setAttribute(DIR, dir);
  611.                                 } else {
  612.                                     html.setAttribute(DIR, dir);
  613.                                 }
  614.                             }
  615.                             if (useP) {
  616.                                 html = inst.Node.create(html.get('innerHTML'));
  617.                             }
  618.                             fc = html.get('firstChild');
  619.                             par.replace(html);
  620.                             sel.selectNode(fc);
  621.                         } else {
  622.                             this._command(cmd, null);
  623.                         }
  624.                         list = inst.all(tag);
  625.                         if (dir) {
  626.                             if (list.size()) {
  627.                                 //Changed to a List
  628.                                 list.each(function(n) {
  629.                                     if (!n.hasClass(cls)) {
  630.                                         n.setAttribute(DIR, dir);
  631.                                     }
  632.                                 });
  633.                             }
  634.                         }

  636.                         list.removeClass(cls);
  637.                     }
  638.                 },
  639.                 /**
  640.                 * Noramlizes alignment for Webkit Browsers
  641.                 * @method COMMANDS.justify
  642.                 * @static
  643.                 * @param {String} cmd The command executed: justify (not used)
  644.                 * @param {String} val The actual command from the justify{center,all,left,right} stubs
  645.                 */
  646.                 justify: function(cmd, val) {
  647.                     if (Y.UA.webkit) {
  648.                         var inst = this.getInstance(),
  649.                             sel = new inst.EditorSelection(),
  650.                             aNode = sel.anchorNode, html,
  651.                             bgColor = aNode.getStyle('backgroundColor');

  653.                             this._command(val);
  654.                             sel = new inst.EditorSelection();
  655.                             if (sel.anchorNode.test('div')) {
  656.                                 html = '<span>' + sel.anchorNode.get('innerHTML') + '</span>';
  657.                                 sel.anchorNode.set('innerHTML', html);
  658.                                 sel.anchorNode.one('span').setStyle('backgroundColor', bgColor);
  659.                                 sel.selectNode(sel.anchorNode.one('span'));
  660.                             }
  661.                     } else {
  662.                         this._command(val);
  663.                     }
  664.                 },
  665.                 /**
  666.                 * Override method for COMMANDS.justify
  667.                 * @method COMMANDS.justifycenter
  668.                 * @static
  669.                 */
  670.                 justifycenter: function() {
  671.                     this.command('justify', 'justifycenter');
  672.                 },
  673.                 /**
  674.                 * Override method for COMMANDS.justify
  675.                 * @method COMMANDS.justifyleft
  676.                 * @static
  677.                 */
  678.                 justifyleft: function() {
  679.                     this.command('justify', 'justifyleft');
  680.                 },
  681.                 /**
  682.                 * Override method for COMMANDS.justify
  683.                 * @method COMMANDS.justifyright
  684.                 * @static
  685.                 */
  686.                 justifyright: function() {
  687.                     this.command('justify', 'justifyright');
  688.                 },
  689.                 /**
  690.                 * Override method for COMMANDS.justify
  691.                 * @method COMMANDS.justifyfull
  692.                 * @static
  693.                 */
  694.                 justifyfull: function() {
  695.                     this.command('justify', 'justifyfull');
  696.                 }
  697.             }
  698.         });

  700.         if (Y.UA.ie) {
  701.             ExecCommand.COMMANDS.bold = function() {
  702.                 fixIETags.call(this, 'bold', 'b', 'FONT-WEIGHT: bold');
  703.             };
  704.             ExecCommand.COMMANDS.italic = function() {
  705.                 fixIETags.call(this, 'italic', 'i', 'FONT-STYLE: italic');
  706.             };
  707.             ExecCommand.COMMANDS.underline = function() {
  708.                 fixIETags.call(this, 'underline', 'u', 'TEXT-DECORATION: underline');
  709.             };
  710.         }

  712.         Y.namespace('Plugin');
  713.         Y.Plugin.ExecCommand = ExecCommand;


  716.